FastInterceptFinder2DFPGA Class Reference

Findlet for finging intersections of sinosoidal curves in the 2D Hough space by iteratively calling fastInterceptFinder2d. More...

#include <FastInterceptFinder2DFPGA.h>

Inheritance diagram for FastInterceptFinder2DFPGA:

Collaboration diagram for FastInterceptFinder2DFPGA:

Public Types
using	IOTypes = std::tuple< AIOTypes... >
	Types that should be served to apply on invokation.
using	IOVectors = std::tuple< std::vector< AIOTypes >... >
	Vector types that should be served to apply on invokation.

Public Member Functions
	FastInterceptFinder2DFPGA ()
	Find intercepts in the 2D Hough space.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) override
	Expose the parameters of the sub findlets.
void	initialize () override
	Create the store arrays.
void	apply (const std::vector< std::pair< VxdID, std::pair< long, long >>> &hits, std::vector< std::pair< double, double >> &tracks) override
	Load in the prepared hits and create tracks for extrapolation to PXD.
virtual std::string	getDescription ()
	Brief description of the purpose of the concret findlet.
virtual void	apply (ToVector< AIOTypes > &... ioVectors)=0
	Main function executing the algorithm.
void	beginRun () override
	Receive and dispatch signal for the beginning of a new run.
void	beginEvent () override
	Receive and dispatch signal for the start of a new event.
void	endRun () override
	Receive and dispatch signal for the end of the run.
void	terminate () override
	Receive and dispatch Signal for termination of the event processing.

Protected Types
using	ToVector = typename ToVectorImpl< T >::Type
	Short hand for ToRangeImpl.

Protected Member Functions
void	addProcessingSignalListener (ProcessingSignalListener *psl)
	Register a processing signal listener to be notified.
int	getNProcessingSignalListener ()
	Get the number of currently registered listeners.

Private Types
using	Super = TrackFindingCDC::Findlet< const std::pair< VxdID, std::pair< long, long > >, std::pair< double, double > >
	Parent class.

Private Member Functions
unsigned short	layerFilter (std::vector< bool > layer)
	Layer filter, checks if at least hits from 3 layers are in a set of hits. More...
void	fastInterceptFinder2d (const std::vector< std::pair< VxdID, std::pair< long, long >>> &hits, uint xmin, uint xmax, uint ymin, uint ymax, uint currentRecursion)
	find intercepts in the 2D Hough Space by recursively calling itself until no hits are assinged to a given Hough Space cell, or until the maximum number of recursions (m_maxRecursionLevel) is reached More...
void	FindHoughSpaceCluster ()
	Find Hough Space clusters. More...
void	DepthFirstSearch (uint lastIndexX, uint lastIndexY)
	Perform depth first search recursive algorithm to find clusters in the Hough Space. More...
void	gnuplotoutput (const std::vector< std::pair< VxdID, std::pair< long, long >>> &hits)
	gnuplot output for debugging

Private Attributes
bool	m_param_isUFinder = true
	Is this the intercept finder for the u-side hits (r-phi) or v-side (r-z)?
uint	m_param_maxRecursionLevel = 6
	maximum number of recursive calls of fastInterceptFinder2d
uint	m_param_nAngleSectors = 256
	number of sectors of the Hough Space on the horizontal axis
uint	m_param_nVerticalSectors = 256
	number of sectors of the Hough Space on the vertical axis
long	m_param_verticalHoughSpaceSize = convertFloatToInt(64, 6)
	vertical size of the Hough Space, defaults to the value for u-side
double	m_param_minimumX = -3.168
	minimum x value of the Hough Space, defaults to the value for u-side
double	m_param_maximumX = 3.168
	maximum x value of the Hough Space, defaults to the value for u-side
double	m_unitX = 0
	HS unit size in x.
double	m_unitY = 0
	HS unit size in y.
uint	m_param_MinimumHSClusterSize = 3
	minimum cluster size of sectors belonging to intercepts in the Hough Space
uint	m_param_MaximumHSClusterSize = 1000
	maximum cluster size of sectors belonging to intercepts in the Hough Space
uint	m_param_MaximumHSClusterSizeX = 1000
	maximum cluster size in x of sectors belonging to intercepts in the Hough Space
uint	m_param_MaximumHSClusterSizeY = 1000
	maximum cluster size in y of sectors belonging to intercepts in the Hough Space
std::array< long, 16385 >	m_HSSinValuesLUT = {0}
	Look-Up-Tables for values as cache to speed up calculation sine values of the Hough Space sector boarder coordinates.
std::array< long, 16385 >	m_HSCosValuesLUT = {0}
	cosine values of the Hough Space sector boarder coordinates
std::array< long, 16384 >	m_HSCenterSinValuesLUT = {0}
	sine values of the Hough Space sector center coordinates
std::array< long, 16384 >	m_HSCenterCosValuesLUT = {0}
	cosine values of the Hough Space sector center coordinates
std::array< long, 16385 >	m_HSYLUT = {0}
	y values of the Hough Space sector boarders
std::array< long, 16384 >	m_HSYCenterLUT = {0}
	y values of the Hough Space sector centers
std::array< double, 16385 >	m_HSXLUT = {0}
	x values of the Hough Space sector boarders
std::array< double, 16384 >	m_HSXCenterLUT = {0}
	x values of the Hough Space sector centers
std::vector< int >	m_SectorArray
	vector containing only the 1D representation of active cells to speed up processing
std::vector< std::pair< uint, uint > >	m_activeSectorArray
	vector containing information for each cell whether it contained enough hits after m_maxRecursionLevel to be "active". More...
uint	m_clusterCount = 0
	count the clusters
uint	m_clusterSize = 0
	size of the current cluster
bool	m_param_writeGnuplotOutput = false
	use gnuplot output?
std::string	m_param_gnuplotHSOutputFileName = "HSFPGA.plt"
	gnuplot HS output filename
std::string	m_param_gnuplotHSRectOutputFileName = "HSFPGARect.plt"
	gnuplot HS sector output filename
std::string	m_param_gnuplotHSCoGOutputFileName = "HSFPGACoG.plt"
	gnuplot HS sector output filename
std::ofstream	m_rectoutstream
	HS sector debug file.
std::ofstream	m_cogoutstream
	HS CoG debug file.
const std::string	m_const_rectColor [8] = {"blue", "cyan", "green", "yellow", "orange", "violet", "skyblue", "pink"}
	color definition for the sector debug output
uint	m_rectcounter = 1
	count HS debug rectangles
std::pair< int, int >	m_clusterInitialPosition = std::make_pair(0, 0)
	start cell of the recursive cluster finding in the Hough Space
std::pair< int, int >	m_clusterCoG = std::make_pair(0, 0)
	center of gravity containing describing the current best track parameters in the Hough Space
std::vector< std::pair< double, double > >	m_trackCandidates
	vector containing track candidates, consisting of the found intersection values in the Hough Space
std::vector< ProcessingSignalListener * >	m_subordinaryProcessingSignalListeners
	References to subordinary signal processing listener contained in this findlet.
bool	m_initialized = false
	Flag to keep track whether initialization happend before.
bool	m_terminated = false
	Flag to keep track whether termination happend before.
std::string	m_initializedAs
	Name of the type during initialisation.

Detailed Description

Findlet for finging intersections of sinosoidal curves in the 2D Hough space by iteratively calling fastInterceptFinder2d.

Definition at line 33 of file FastInterceptFinder2DFPGA.h.

Member Function Documentation

DepthFirstSearch()

void DepthFirstSearch ( uint  lastIndexX, uint  lastIndexY  )

private

Perform depth first search recursive algorithm to find clusters in the Hough Space.

Parameters

lastIndexX	x-index of the last cell checked
lastIndexY	y-index of the last cell checked

Definition at line 316 of file FastInterceptFinder2DFPGA.cc.

{
  if (m_clusterSize >= m_param_MaximumHSClusterSize) return;
 
  for (uint currentIndexY = lastIndexY; currentIndexY >= lastIndexY - 1; currentIndexY--) {
    if (abs((int)m_clusterInitialPosition.second - (int)currentIndexY) >= m_param_MaximumHSClusterSizeY or
        m_clusterSize >= m_param_MaximumHSClusterSize or currentIndexY > m_param_nVerticalSectors) return;
    for (uint currentIndexX = lastIndexX; currentIndexX <= lastIndexX + 1; currentIndexX++) {
      if (abs((int)m_clusterInitialPosition.first - (int)currentIndexX) >= m_param_MaximumHSClusterSizeX or
          m_clusterSize >= m_param_MaximumHSClusterSize or currentIndexX > m_param_nAngleSectors) return;
 
      // The cell (currentIndexX, currentIndexY) is the current one has already been checked, so continue
      if (lastIndexX == currentIndexX && lastIndexY == currentIndexY) continue;
 
      // first check bounds to avoid out-of-bound array access
      // as they are uints, they are always >= 0, and in case of an overflow they would be too large
      if (currentIndexX < m_param_nAngleSectors and currentIndexY < m_param_nVerticalSectors) {
 
        if (m_SectorArray[currentIndexY * m_param_nAngleSectors + currentIndexX] < 0 /*and m_clusterSize < m_MaximumHSClusterSize*/) {
          // Only continue searching if the current cluster is smaller than the maximum cluster size
          m_SectorArray[currentIndexY * m_param_nAngleSectors + currentIndexX] = m_clusterCount;
          m_clusterCoG = std::make_pair(m_clusterCoG.first + currentIndexX, m_clusterCoG.second + currentIndexY);
          m_clusterSize++;
          // search in the next Hough Space cells...
          DepthFirstSearch(currentIndexX, currentIndexY);
        }
 
      }
    }
  }
}

fastInterceptFinder2d()

void fastInterceptFinder2d ( const std::vector< std::pair< VxdID, std::pair< long, long >>> &  hits, uint  xmin, uint  xmax, uint  ymin, uint  ymax, uint  currentRecursion  )

private

find intercepts in the 2D Hough Space by recursively calling itself until no hits are assinged to a given Hough Space cell, or until the maximum number of recursions (m_maxRecursionLevel) is reached

Parameters

hits	vector containing the hits that are used for track finding
xmin	minimum x-index of the sub-Hough Space in the current recursion step
xmax	maximum x-index of the sub-Hough Space in the current recursion step
ymin	minimum y-index of the sub-Hough Space in the current recursion step
ymax	maximum y-index of the sub-Hough Space in the current recursion step
currentRecursion	current recursion step, has to be < m_maxRecursionLevel

Definition at line 145 of file FastInterceptFinder2DFPGA.cc.

FindHoughSpaceCluster()

void FindHoughSpaceCluster ( )

private

Find Hough Space clusters.

Looop over all found sectors in m_SectorArray and then calls the DepthFirstSearch function to recursively find the clusters

Definition at line 246 of file FastInterceptFinder2DFPGA.cc.

layerFilter()

unsigned short layerFilter ( std::vector< bool >  layer )

inlineprivate

Layer filter, checks if at least hits from 3 layers are in a set of hits.

Parameters

layer

bool-vector containing information whether there is a hit in a layer

Definition at line 56 of file FastInterceptFinder2DFPGA.h.

    {
      uint layercount = std::count(layer.begin(), layer.end(), true);
      return (layercount >= 3 ? layercount : 0);
    }

Member Data Documentation

m_activeSectorArray

std::vector<std::pair<uint, uint> > m_activeSectorArray

private

vector containing information for each cell whether it contained enough hits after m_maxRecursionLevel to be "active".

The value will be (- number of hits) for an active cell after fastInterceptFinder2d or 0 for an inactive cell, The value will be positive with the cluster number assigned to it after cluster finding

Definition at line 144 of file FastInterceptFinder2DFPGA.h.

---

The documentation for this class was generated from the following files:

• tracking/datcon/findlets/include/FastInterceptFinder2DFPGA.h
• tracking/datcon/findlets/src/FastInterceptFinder2DFPGA.cc