Findlet for finding intersections of sinusoidal curves in the 2D Hough space by iteratively calling FastInterceptFinder2d. More...

#include <SingleHoughSpaceFastInterceptFinder.h>

Inheritance diagram for SingleHoughSpaceFastInterceptFinder:

Classes
struct	paircompare
	this sorting makes sure the clusters can be searched from bottom left of the HS to top right normally, a C++ array looks like a matrix: (0, 0 ) ... (maxX, 0 ) ... ... (0, maxY) ... (maxX, maxY) but for sorting we want it to be like regular coordinates (0, maxY) ... (maxX, maxY) ... ... (0, 0 ) ... (maxX, 0 ) By setting the offset to the maximum allowed number of cells (2^14) and simplifying (16384 - lhs.second) * 16384 + lhs.first < (16384 - rhs.second) * 16384 + rhs.first to (rhs.second - lhs.second) * 16384 < rhs.first - lhs.first we get the formula below More...

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
	SingleHoughSpaceFastInterceptFinder ()
	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 (std::vector< VXDHoughState > &hits, std::vector< std::vector< VXDHoughState * > > &rawTrackCandidates) override
	Load in the prepared hits and create track candidates for further processing like hit filtering and fitting.

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< VXDHoughState, std::vector< VXDHoughState * > >
	Parent class.

Private Member Functions
unsigned short	layerFilter (const std::bitset< 8 > &layer)
	layer filter, checks if at least hits from 3 layers are in a set of hits

void	fastInterceptFinder2d (const std::vector< VXDHoughState * > &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

void	FindHoughSpaceCluster ()
	Find Hough Space clusters.

void	DepthFirstSearch (uint lastIndexX, uint lastIndexY)
	Perform depth first search recursive algorithm to find clusters in the Hough Space.

Private Attributes
uint	m_maxRecursionLevel = 9
	maximum number of recursive calls of FastInterceptFinder2d

uint	m_nAngleSectors = 256
	number of sectors of the Hough Space on the horizontal axis

uint	m_nVerticalSectors = 512
	number of sectors of the Hough Space on the vertical axis

double	m_verticalHoughSpaceSize = 0.16
	vertical size of the Hough Space, defaults to the value for u-side

double	m_minimumX = -3.168
	minimum x value of the Hough Space, defaults to the value for u-side

double	m_maximumX = 3.168
	maximum x value of the Hough Space, defaults to the value for u-side

uint	m_MinimumHSClusterSize = 1
	minimum cluster size of sectors belonging to intercepts in the Hough Space

uint	m_MaximumHSClusterSize = 10
	maximum cluster size of sectors belonging to intercepts in the Hough Space

uint	m_MaximumHSClusterSizeX = 2
	maximum cluster size in x of sectors belonging to intercepts in the Hough Space

uint	m_MaximumHSClusterSizeY = 10
	maximum cluster size in y of sectors belonging to intercepts in the Hough Space

double	m_unitX = 0
	HS unit size in x.

double	m_unitY = 0
	HS unit size in y.

std::array< double, 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< double, 16385 >	m_HSCosValuesLUT = {0}
	cosine values of the Hough Space sector boarder coordinates

std::array< double, 16384 >	m_HSCenterSinValuesLUT = {0}
	sine values of the Hough Space sector center coordinates

std::array< double, 16384 >	m_HSCenterCosValuesLUT = {0}
	cosine values of the Hough Space sector center coordinates

std::array< double, 16385 >	m_HSYLUT = {0}
	y values of the Hough Space sector boarders

std::array< double, 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::map< std::pair< uint, uint >, std::pair< int, std::vector< VXDHoughState * > >, paircompare >	m_activeSectors
	Map containing only active HS sectors, i.e.

uint	m_clusterCount = 0
	count the clusters

uint	m_clusterSize = 0
	size of the current cluster

std::pair< uint, uint >	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< VXDHoughState * >	m_currentTrackCandidate
	the current track candidate

std::vector< std::vector< VXDHoughState * > >	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 finding intersections of sinusoidal curves in the 2D Hough space by iteratively calling FastInterceptFinder2d.

The found track candidates are then clustered via a recursive search. Afterwards track candidates are formed and stored in the output vector.

Definition at line 31 of file SingleHoughSpaceFastInterceptFinder.h.

Member Typedef Documentation

◆ IOTypes

using IOTypes = std::tuple<AIOTypes...>

inherited

Types that should be served to apply on invokation.

Definition at line 30 of file Findlet.h.

◆ IOVectors

using IOVectors = std::tuple< std::vector<AIOTypes>... >

inherited

Vector types that should be served to apply on invokation.

Definition at line 53 of file Findlet.h.

◆ Super

using Super = TrackFindingCDC::Findlet<VXDHoughState, std::vector<VXDHoughState*> >

private

Parent class.

Definition at line 33 of file SingleHoughSpaceFastInterceptFinder.h.

◆ ToVector

using ToVector = typename ToVectorImpl<T>::Type

protectedinherited

Short hand for ToRangeImpl.

Definition at line 49 of file Findlet.h.

Constructor & Destructor Documentation

◆ SingleHoughSpaceFastInterceptFinder()

SingleHoughSpaceFastInterceptFinder ( )

Find intercepts in the 2D Hough space.

Definition at line 22 of file SingleHoughSpaceFastInterceptFinder.cc.

                                                                         : Super()
{
}

Member Function Documentation

◆ addProcessingSignalListener()

void addProcessingSignalListener ( ProcessingSignalListener * psl )

protectedinherited

Register a processing signal listener to be notified.

Definition at line 55 of file CompositeProcessingSignalListener.cc.

{
  m_subordinaryProcessingSignalListeners.push_back(psl);
}

◆ apply()

void apply	(	std::vector< VXDHoughState > &	hits,
		std::vector< std::vector< VXDHoughState * > > &	rawTrackCandidates
	)

override

Load in the prepared hits and create track candidates for further processing like hit filtering and fitting.

Definition at line 98 of file SingleHoughSpaceFastInterceptFinder.cc.

{
  m_trackCandidates.clear();
  m_activeSectors.clear();
 
  const std::vector<VXDHoughState*> currentEventHitList = TrackFindingCDC::as_pointers<VXDHoughState>(hits);
 
  fastInterceptFinder2d(currentEventHitList, 0, m_nAngleSectors, 0, m_nVerticalSectors, 0);
 
  FindHoughSpaceCluster();
 
  for (auto& trackCand : m_trackCandidates) {
    // sort for layer, and 2D radius in case of same layer before storing as SpacePointTrackCand
    // outer hit goes first, as later on tracks are build from outside to inside
    std::sort(trackCand.begin(), trackCand.end(),
    [](const VXDHoughState * a, const VXDHoughState * b) {
      return
        (a->getDataCache().layer > b->getDataCache().layer) or
        (a->getDataCache().layer == b->getDataCache().layer
         and a->getHit()->getPosition().Perp() > b->getHit()->getPosition().Perp());
    });
 
    rawTrackCandidates.emplace_back(trackCand);
  }
 
  B2DEBUG(29, "m_trackCandidates.size: " << m_trackCandidates.size());
 
}

◆ beginEvent()

void beginEvent ( )

overridevirtualinherited

Receive and dispatch signal for the start of a new event.

Reimplemented from ProcessingSignalListener.

Definition at line 31 of file CompositeProcessingSignalListener.cc.

{
  Super::beginEvent();
  for (ProcessingSignalListener* psl : m_subordinaryProcessingSignalListeners) {
    psl->beginEvent();
  }
}

◆ beginRun()

void beginRun ( )

overridevirtualinherited

Receive and dispatch signal for the beginning of a new run.

Reimplemented from ProcessingSignalListener.

Reimplemented in LayerRelationFilter< AFilter >, FourHitFilter, QualityIndicatorFilter, ThreeHitFilter, TwoHitVirtualIPFilter, TwoHitVirtualIPQIFilter, RecoTrackStorer, ROIFinder, SpacePointLoaderAndPreparer, and TrackCandidateResultRefiner.

Definition at line 23 of file CompositeProcessingSignalListener.cc.

{
  Super::beginRun();
  for (ProcessingSignalListener* psl : m_subordinaryProcessingSignalListeners) {
    psl->beginRun();
  }
}

◆ 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 248 of file SingleHoughSpaceFastInterceptFinder.cc.

{
  if (m_clusterSize >= m_MaximumHSClusterSize) return;
 
  for (uint currentIndexY = lastIndexY; currentIndexY >= lastIndexY - 1; currentIndexY--) {
    if (abs((int)m_clusterInitialPosition.second - (int)currentIndexY) >= m_MaximumHSClusterSizeY or
        m_clusterSize >= m_MaximumHSClusterSize or currentIndexY > m_nVerticalSectors) return;
    for (uint currentIndexX = lastIndexX; currentIndexX <= lastIndexX + 1; currentIndexX++) {
      if (abs((int)m_clusterInitialPosition.first - (int)currentIndexX) >= m_MaximumHSClusterSizeX or
          m_clusterSize >= m_MaximumHSClusterSize or currentIndexX > m_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_nAngleSectors and currentIndexY < m_nVerticalSectors) {
 
        auto activeSector = m_activeSectors.find({currentIndexX, currentIndexY});
        // Only continue searching if the current cluster is smaller than the maximum cluster size
        if (activeSector != m_activeSectors.end() and activeSector->second.first < 0 /*and m_clusterSize < m_MaximumHSClusterSize*/) {
          activeSector->second.first = m_clusterCount;
          m_clusterSize++;
 
          // No need to check whether currentIndex exists as a key in m_activeSectors as they were created at the same time
          // so it's certain the key exists.
          for (VXDHoughState* hit : activeSector->second.second) {
            if (not TrackFindingCDC::is_in(hit, m_currentTrackCandidate)) {
              m_currentTrackCandidate.emplace_back(hit);
            }
          }
 
          // search in the next Hough Space cells...
          DepthFirstSearch(currentIndexX, currentIndexY);
        }
      }
    }
  }
}

◆ endRun()

void endRun ( )

overridevirtualinherited

Receive and dispatch signal for the end of the run.

Reimplemented from ProcessingSignalListener.

Definition at line 39 of file CompositeProcessingSignalListener.cc.

{
  for (ProcessingSignalListener* psl : reversedRange(m_subordinaryProcessingSignalListeners)) {
    psl->endRun();
  }
  Super::endRun();
}

◆ exposeParameters()

void exposeParameters	(	ModuleParamList *	moduleParamList,
		const std::string &	prefix
	)

overridevirtual

Expose the parameters of the sub findlets.

Reimplemented from Findlet< VXDHoughState, std::vector< VXDHoughState * > >.

Definition at line 26 of file SingleHoughSpaceFastInterceptFinder.cc.

{
  Super::exposeParameters(moduleParamList, prefix);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "maximumRecursionLevel"), m_maxRecursionLevel,
                                "Maximum recursion level for the fast Hough trafo algorithm.",  m_maxRecursionLevel);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "nAngleSectors"), m_nAngleSectors,
                                "Number of angle sectors (= x-axis) dividing the Hough space.", m_nAngleSectors);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "nVerticalSectors"), m_nVerticalSectors,
                                "Number of vertical sectors (= y-axis) dividing the Hough space.", m_nVerticalSectors);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "verticalHoughSpaceSize"), m_verticalHoughSpaceSize,
                                "Vertical size of the Hough space.", m_verticalHoughSpaceSize);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "HoughSpaceMinimumX"), m_minimumX,
                                "Minimum x value of the Hough space.", m_minimumX);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "HoughSpaceMaximumX"), m_maximumX,
                                "Maximum x value of the Hough space.", m_maximumX);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "minimumHSClusterSize"), m_MinimumHSClusterSize,
                                "Maximum x value of the Hough space.", m_MinimumHSClusterSize);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "maximumHSClusterSize"), m_MaximumHSClusterSize,
                                "Maximum x value of the Hough space.", m_MaximumHSClusterSize);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "maximumHSClusterSizeX"), m_MaximumHSClusterSizeX,
                                "Maximum x value of the Hough space.", m_MaximumHSClusterSizeX);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "maximumHSClusterSizeY"), m_MaximumHSClusterSizeY,
                                "Maximum x value of the Hough space.", m_MaximumHSClusterSizeY);
 
}

◆ fastInterceptFinder2d()

void fastInterceptFinder2d	(	const std::vector< VXDHoughState * > &	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 129 of file SingleHoughSpaceFastInterceptFinder.cc.

{
  std::vector<VXDHoughState*> containedHits;
  containedHits.reserve(hits.size());
  std::bitset<8> layerHits; /* For layer filter */
 
  if (currentRecursion == m_maxRecursionLevel + 1) return;
 
  // these int-divisions can cause {min, center} or {center, max} to be the same, which is a desired behaviour
  const uint centerx = xmin + (uint)((xmax - xmin) / 2);
  const uint centery = ymin + (uint)((ymax - ymin) / 2);
  const uint xIndexCache[3] = {xmin, centerx, xmax};
  const uint yIndexCache[3] = {ymin, centery, ymax};
 
  for (int i = 0; i < 2 ; ++i) {
    const uint left  = xIndexCache[i];
    const uint right = xIndexCache[i + 1];
    const uint localIndexX = left;
 
    if (left == right) continue;
 
    const double& sinLeft     = m_HSSinValuesLUT[left];
    const double& cosLeft     = m_HSCosValuesLUT[left];
    const double& sinRight    = m_HSSinValuesLUT[right];
    const double& cosRight    = m_HSCosValuesLUT[right];
 
    // the sin and cos of the current center can't be stored in a LUT, as the number of possible centers
    // is quite large and the logic would become rather complex
    const double sinCenter   = m_HSCenterSinValuesLUT[(left + right) / 2];
    const double cosCenter   = m_HSCenterCosValuesLUT[(left + right) / 2];
 
    for (int j = 0; j < 2; ++j) {
      const uint lowerIndex = yIndexCache[j];
      const uint upperIndex = yIndexCache[j + 1];
 
      if (lowerIndex == upperIndex) continue;
 
      const uint localIndexY = lowerIndex;
      const double& localUpperCoordinate = m_HSYLUT[lowerIndex];
      const double& localLowerCoordinate = m_HSYLUT[upperIndex];
 
      // reset layerHits and containedHits
      layerHits = 0;
      containedHits.clear();
      for (VXDHoughState* hit : hits) {
 
        const VXDHoughState::DataCache& hitData = hit->getDataCache();
        const double& m = hitData.xConformal;
        const double& a = hitData.yConformal;
 
        const double derivativeyLeft   = m * -sinLeft   + a * cosLeft;
        const double derivativeyRight  = m * -sinRight  + a * cosRight;
        const double derivativeyCenter = m * -sinCenter + a * cosCenter;
 
        // Only interested in the rising arm of the sinosoidal curves.
        // Thus if derivative on both sides of the cell is negative, ignore and continue.
        if (derivativeyLeft < 0 and derivativeyRight < 0 and derivativeyCenter < 0) continue;
 
        const double yLeft   = m * cosLeft   + a * sinLeft;
        const double yRight  = m * cosRight  + a * sinRight;
        const double yCenter = m * cosCenter + a * sinCenter;
 
        /* Check if HS-parameter curve is inside (or outside) actual sub-HS */
        if ((yLeft <= localUpperCoordinate and yRight >= localLowerCoordinate) or
            (yCenter <= localUpperCoordinate and yLeft >= localLowerCoordinate and yRight >= localLowerCoordinate) or
            (yCenter >= localLowerCoordinate and yLeft <= localUpperCoordinate and yRight <= localUpperCoordinate)) {
          layerHits[hitData.layer] = true;
          containedHits.emplace_back(hit);
        }
      }
 
      if (layerFilter(layerHits) > 0) {
        // recursive call of fastInterceptFinder2d, until currentRecursion == m_maxRecursionLevel
        if (currentRecursion < m_maxRecursionLevel) {
          fastInterceptFinder2d(containedHits, left, right, lowerIndex, upperIndex, currentRecursion + 1);
        } else {
          m_activeSectors.insert({std::make_pair(localIndexX, localIndexY), std::make_pair(-layerFilter(layerHits), containedHits) });
        }
      }
    }
  }
}

◆ FindHoughSpaceCluster()

void FindHoughSpaceCluster ( )

private

Find Hough Space clusters.

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

Definition at line 215 of file SingleHoughSpaceFastInterceptFinder.cc.

{
  m_clusterCount = 1;
 
  for (auto& currentCell : m_activeSectors) {
 
    // cell content meanings:
    // -3, -4  : active sector, not yet visited
    // 0       : non-active sector (will never be visited, only checked)
    // 1,2,3...: index of the clusters
    if (currentCell.second.first > -1) continue;
 
    m_clusterInitialPosition = std::make_pair(currentCell.first.first, currentCell.first.second);
    m_clusterSize = 1;
    currentCell.second.first = m_clusterCount;
 
    m_currentTrackCandidate.clear();
    for (VXDHoughState* hit : currentCell.second.second) {
      m_currentTrackCandidate.emplace_back(hit);
    }
 
    // Check for HS sectors connected to each other which could form a cluster
    DepthFirstSearch(currentCell.first.first, currentCell.first.second);
    // if cluster valid (i.e. not too small and not too big): finalize!
    if (m_clusterSize >= m_MinimumHSClusterSize and m_clusterSize <= m_MaximumHSClusterSize) {
 
      m_trackCandidates.emplace_back(m_currentTrackCandidate);
      m_currentTrackCandidate.clear();
    }
    m_clusterCount++;
  }
}

◆ getDescription()

virtual std::string getDescription ( )

inlinevirtualinherited

Brief description of the purpose of the concret findlet.

Definition at line 60 of file Findlet.h.

      {
        return "(no description)";
      }

◆ getNProcessingSignalListener()

int getNProcessingSignalListener ( )

protectedinherited

Get the number of currently registered listeners.

Definition at line 60 of file CompositeProcessingSignalListener.cc.

{
  return m_subordinaryProcessingSignalListeners.size();
}

◆ initialize()

void initialize ( )

overridevirtual

Create the store arrays.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 62 of file SingleHoughSpaceFastInterceptFinder.cc.

{
  Super::initialize();
 
  m_maxRecursionLevel = ceil(log2(std::max(m_nAngleSectors, m_nVerticalSectors))) - 1;
  if (m_maxRecursionLevel > 14) {
    B2ERROR("The maximum number of recursions (maximumRecursionLevel) must not be larger than 14, but it is " <<
            m_maxRecursionLevel <<
            ", please choose a smaller value for maximumRecursionLevel, and / or for nAngleSectors and / or nVerticalSectors.");
  }
  m_unitX = (m_maximumX - m_minimumX) / (double)m_nAngleSectors;
  for (uint i = 0; i < m_nAngleSectors; i++) {
    double x = m_minimumX + m_unitX * (double)i;
    double xc = x + 0.5 * m_unitX;
 
    m_HSXLUT[i] = x;
    m_HSSinValuesLUT[i] = sin(x);
    m_HSCosValuesLUT[i] = cos(x);
    m_HSCenterSinValuesLUT[i] = sin(xc);
    m_HSCenterCosValuesLUT[i] = cos(xc);
    m_HSXCenterLUT[i] = xc;
  }
  m_HSXLUT[m_nAngleSectors] = m_maximumX;
  m_HSSinValuesLUT[m_nAngleSectors] = sin(m_maximumX);
  m_HSCosValuesLUT[m_nAngleSectors] = cos(m_maximumX);
 
  m_unitY = 2. * m_verticalHoughSpaceSize / m_nVerticalSectors;
  for (uint i = 0; i <= m_nVerticalSectors; i++) {
    m_HSYLUT[i] = m_verticalHoughSpaceSize - m_unitY * i;
    m_HSYCenterLUT[i] = m_verticalHoughSpaceSize - m_unitY * i - 0.5 * m_unitY;
  }
  B2DEBUG(29, "HS size x: " << (m_maximumX - m_minimumX) << " HS size y: " << m_verticalHoughSpaceSize <<
          " unitX: " << m_unitX << " unitY: " << m_unitY);
}

◆ layerFilter()

unsigned short layerFilter ( const std::bitset< 8 > & layer )

inlineprivate

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

Parameters

layer bitset containing information whether there as a hit in a layer

Definition at line 52 of file SingleHoughSpaceFastInterceptFinder.h.

      {
        uint layercount = layer.count();
        return (layercount >= 3 ? layercount : 0);
      }

◆ terminate()

void terminate ( )

overridevirtualinherited

Receive and dispatch Signal for termination of the event processing.

Reimplemented from ProcessingSignalListener.

Reimplemented in StereoHitTrackQuadTreeMatcher< Belle2::TrackFindingCDC::HyperHough >, StereoHitTrackQuadTreeMatcher< Belle2::TrackFindingCDC::QuadraticLegendre >, and StereoHitTrackQuadTreeMatcher< Belle2::TrackFindingCDC::Z0TanLambdaLegendre >.

Definition at line 47 of file CompositeProcessingSignalListener.cc.

{
  for (ProcessingSignalListener* psl : reversedRange(m_subordinaryProcessingSignalListeners)) {
    psl->terminate();
  }
  Super::terminate();
}

Member Data Documentation

◆ m_activeSectors

std::map<std::pair<uint, uint>, std::pair<int, std::vector<VXDHoughState*> >, paircompare> m_activeSectors

private

Map containing only active HS sectors, i.e.

those with hits from enough layers contained in them. The keys are the indices of the HS cell, and the custom sort function above is used to sort the content. The value is a pair consisting of the (negative) number of layers hit in a given cell, and a vector containing the hit information of all hits that are contained in this cell. During cluster finding the first value of the value-pair will be assigned the current cluster number.

Definition at line 153 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_clusterCoG

std::pair<int, int> m_clusterCoG = std::make_pair(0, 0)

private

center of gravity containing describing the current best track parameters in the Hough Space

Definition at line 163 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_clusterCount

uint m_clusterCount = 0

private

count the clusters

Definition at line 156 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_clusterInitialPosition

std::pair<uint, uint> m_clusterInitialPosition = std::make_pair(0, 0)

private

start cell of the recursive cluster finding in the Hough Space

Definition at line 161 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_clusterSize

uint m_clusterSize = 0

private

size of the current cluster

Definition at line 158 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_currentTrackCandidate

std::vector<VXDHoughState*> m_currentTrackCandidate

private

the current track candidate

Definition at line 166 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_HSCenterCosValuesLUT

std::array<double, 16384> m_HSCenterCosValuesLUT = {0}

private

cosine values of the Hough Space sector center coordinates

Definition at line 119 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_HSCenterSinValuesLUT

std::array<double, 16384> m_HSCenterSinValuesLUT = {0}

private

sine values of the Hough Space sector center coordinates

Definition at line 117 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_HSCosValuesLUT

std::array<double, 16385> m_HSCosValuesLUT = {0}

private

cosine values of the Hough Space sector boarder coordinates

Definition at line 115 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_HSSinValuesLUT

std::array<double, 16385> m_HSSinValuesLUT = {0}

private

Look-Up-Tables for values as cache to speed up calculation sine values of the Hough Space sector boarder coordinates.

Definition at line 113 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_HSXCenterLUT

std::array<double, 16384> m_HSXCenterLUT = {0}

private

x values of the Hough Space sector centers

Definition at line 127 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_HSXLUT

std::array<double, 16385> m_HSXLUT = {0}

private

x values of the Hough Space sector boarders

Definition at line 125 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_HSYCenterLUT

std::array<double, 16384> m_HSYCenterLUT = {0}

private

y values of the Hough Space sector centers

Definition at line 123 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_HSYLUT

std::array<double, 16385> m_HSYLUT = {0}

private

y values of the Hough Space sector boarders

Definition at line 121 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_initialized

bool m_initialized = false

privateinherited

Flag to keep track whether initialization happend before.

Definition at line 52 of file ProcessingSignalListener.h.

◆ m_initializedAs

std::string m_initializedAs

privateinherited

Name of the type during initialisation.

Definition at line 58 of file ProcessingSignalListener.h.

◆ m_MaximumHSClusterSize

uint m_MaximumHSClusterSize = 10

private

maximum cluster size of sectors belonging to intercepts in the Hough Space

Definition at line 99 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_MaximumHSClusterSizeX

uint m_MaximumHSClusterSizeX = 2

private

maximum cluster size in x of sectors belonging to intercepts in the Hough Space

Definition at line 101 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_MaximumHSClusterSizeY

uint m_MaximumHSClusterSizeY = 10

private

maximum cluster size in y of sectors belonging to intercepts in the Hough Space

Definition at line 103 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_maximumX

double m_maximumX = 3.168

private

maximum x value of the Hough Space, defaults to the value for u-side

Definition at line 94 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_maxRecursionLevel

uint m_maxRecursionLevel = 9

private

maximum number of recursive calls of FastInterceptFinder2d

Definition at line 80 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_MinimumHSClusterSize

uint m_MinimumHSClusterSize = 1

private

minimum cluster size of sectors belonging to intercepts in the Hough Space

Definition at line 97 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_minimumX

double m_minimumX = -3.168

private

minimum x value of the Hough Space, defaults to the value for u-side

Definition at line 92 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_nAngleSectors

uint m_nAngleSectors = 256

private

number of sectors of the Hough Space on the horizontal axis

Definition at line 83 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_nVerticalSectors

uint m_nVerticalSectors = 512

private

number of sectors of the Hough Space on the vertical axis

Definition at line 86 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_subordinaryProcessingSignalListeners

std::vector<ProcessingSignalListener*> m_subordinaryProcessingSignalListeners

privateinherited

References to subordinary signal processing listener contained in this findlet.

Definition at line 52 of file CompositeProcessingSignalListener.h.

◆ m_terminated

bool m_terminated = false

privateinherited

Flag to keep track whether termination happend before.

Definition at line 55 of file ProcessingSignalListener.h.

◆ m_trackCandidates

std::vector<std::vector<VXDHoughState*> > m_trackCandidates

private

vector containing track candidates, consisting of the found intersection values in the Hough Space

Definition at line 169 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_unitX

double m_unitX = 0

private

HS unit size in x.

Definition at line 107 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_unitY

double m_unitY = 0

private

HS unit size in y.

Definition at line 109 of file SingleHoughSpaceFastInterceptFinder.h.

◆ m_verticalHoughSpaceSize

double m_verticalHoughSpaceSize = 0.16

private

vertical size of the Hough Space, defaults to the value for u-side

Definition at line 89 of file SingleHoughSpaceFastInterceptFinder.h.

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

tracking/vxdHoughTracking/findlets/include/SingleHoughSpaceFastInterceptFinder.h
tracking/vxdHoughTracking/findlets/src/SingleHoughSpaceFastInterceptFinder.cc

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ IOTypes

◆ IOVectors

◆ Super

◆ ToVector

Constructor & Destructor Documentation

◆ SingleHoughSpaceFastInterceptFinder()

Member Function Documentation

◆ addProcessingSignalListener()

◆ apply()

◆ beginEvent()

◆ beginRun()

◆ DepthFirstSearch()

◆ endRun()

◆ exposeParameters()

◆ fastInterceptFinder2d()

◆ FindHoughSpaceCluster()

◆ getDescription()

◆ getNProcessingSignalListener()

◆ initialize()

◆ layerFilter()

◆ terminate()

Member Data Documentation

◆ m_activeSectors

◆ m_clusterCoG

◆ m_clusterCount

◆ m_clusterInitialPosition

◆ m_clusterSize

◆ m_currentTrackCandidate

◆ m_HSCenterCosValuesLUT

◆ m_HSCenterSinValuesLUT

◆ m_HSCosValuesLUT

◆ m_HSSinValuesLUT

◆ m_HSXCenterLUT

◆ m_HSXLUT

◆ m_HSYCenterLUT

◆ m_HSYLUT

◆ m_initialized

◆ m_initializedAs

◆ m_MaximumHSClusterSize

◆ m_MaximumHSClusterSizeX

◆ m_MaximumHSClusterSizeY

◆ m_maximumX

◆ m_maxRecursionLevel

◆ m_MinimumHSClusterSize

◆ m_minimumX

◆ m_nAngleSectors

◆ m_nVerticalSectors

◆ m_subordinaryProcessingSignalListeners

◆ m_terminated

◆ m_trackCandidates

◆ m_unitX

◆ m_unitY

◆ m_verticalHoughSpaceSize