SingleHoughSpaceFastInterceptFinder Class Reference

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

#include <SingleHoughSpaceFastInterceptFinder.h>

Inheritance diagram for SingleHoughSpaceFastInterceptFinder:

Public Types
using	IOTypes
	Types that should be served to apply on invocation.
using	IOVectors
	Vector types that should be served to apply on invocation.

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 concrete findlet.
virtual std::string	getDescription ()
	Brief description of the purpose of the concrete 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
	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 = TrackingUtilities::Findlet<VXDHoughState, std::vector<VXDHoughState*>>
	Parent class.

Private Member Functions
void	fastInterceptFinder2d (const std::vector< VXDHoughState * > &hits, const ushort xmin, const ushort xmax, const ushort ymin, const ushort ymax, const ushort currentRecursion)
	find intercepts in the 2D Hough Space by recursively calling itself until no hits are assigned 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 (const uint lastGlobalSectorIndex)
	Perform depth first search recursive algorithm to find clusters in the Hough Space.

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

Private Attributes
ushort	m_maxRecursionLevel = 9
	maximum number of recursive calls of FastInterceptFinder2d
ushort	m_nAngleSectors = 512
	number of sectors of the Hough Space on the horizontal axis
ushort	m_nVerticalSectors = 512
	number of sectors of the Hough Space on the vertical axis
float	m_verticalHoughSpaceSize = 0.16
	vertical size of the Hough Space, defaults to the value for u-side
float	m_minimumX = -3.168
	minimum x value of the Hough Space, defaults to the value for u-side
float	m_maximumX = 3.168
	maximum x value of the Hough Space, defaults to the value for u-side
ushort	m_MinimumHSClusterSize = 1
	minimum cluster size of sectors belonging to intercepts in the Hough Space
ushort	m_MaximumHSClusterSize = 12
	maximum cluster size of sectors belonging to intercepts in the Hough Space
ushort	m_MaximumHSClusterSizeX = 2
	maximum cluster size in x of sectors belonging to intercepts in the Hough Space
ushort	m_MaximumHSClusterSizeY = 12
	maximum cluster size in y of sectors belonging to intercepts in the Hough Space
float	m_unitX = 0
	HS unit size in x.
float	m_unitY = 0
	HS unit size in y.
std::array< float, c_maxLUTSize >	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< float, c_maxLUTSize >	m_HSCosValuesLUT = {0}
	cosine values of the Hough Space sector boarder coordinates
std::array< float, c_maxHSSectorNumber >	m_HSCenterSinValuesLUT = {0}
	sine values of the Hough Space sector center coordinates
std::array< float, c_maxHSSectorNumber >	m_HSCenterCosValuesLUT = {0}
	cosine values of the Hough Space sector center coordinates
std::unordered_map< uint, std::vector< VXDHoughState * > >	m_activeSectorsMap
	Map containing only active HS sectors, i.e.
std::vector< uint >	m_activeSectorsIndices
	Cache the global indices of the active sectors for sorted access.
ushort	m_clusterCount = 0
	count the clusters
ushort	m_clusterSize = 0
	size of the current cluster
std::pair< ushort, ushort >	m_clusterInitialPosition = std::make_pair(0, 0)
	start cell of the recursive cluster finding 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
	Flag to keep track whether initialization happened before.
bool	m_terminated
	Flag to keep track whether termination happened before.
std::string	m_initializedAs
	Name of the type during initialisation.

Static Private Attributes
static const ushort	c_maxAllowedRecusionLevel = 10
	Define some magic numbers Maximum allowed recursion level.
static constexpr ushort	c_maxHSSectorNumber = (1 << c_maxAllowedRecusionLevel)
	Maximum number of HS sectors in x and y, also the size of some of the the Look-Up-Tables (LUTs) below.
static constexpr ushort	c_xIndexBitMask = c_maxHSSectorNumber - 1
	Bit mask for coordinate transformation, creates all-ones for the coordinate system conversion.
static constexpr ushort	c_maxLUTSize = c_maxHSSectorNumber + 1
	Look-Up-Table size including the right-most value.

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

inherited

Types that should be served to apply on invocation.

Definition at line 30 of file Findlet.h.

IOVectors

using IOVectors

inherited

Vector types that should be served to apply on invocation.

Definition at line 53 of file Findlet.h.

Super

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

private

Parent class.

Definition at line 33 of file SingleHoughSpaceFastInterceptFinder.h.

ToVector

using ToVector

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 21 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 53 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_activeSectorsMap.clear();
  m_activeSectorsIndices.clear();
 
  const std::vector<VXDHoughState*> currentEventHitList = TrackingUtilities::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().Perp2() > b->getHit()->getPosition().Perp2());
    });
 
    rawTrackCandidates.emplace_back(trackCand);
  }
 
  B2DEBUG(29, "m_trackCandidates.size: " << m_trackCandidates.size());
 
}

beginEvent()

void beginEvent ( )

overrideinherited

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

Definition at line 36 of file CompositeProcessingSignalListener.cc.

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

beginRun()

void beginRun ( )

overrideinherited

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

Definition at line 33 of file CompositeProcessingSignalListener.cc.

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

DepthFirstSearch()

void DepthFirstSearch ( const uint lastGlobalSectorIndex )

private

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

Parameters

lastGlobalSectorIndex

global index of the last sector checked

Definition at line 269 of file SingleHoughSpaceFastInterceptFinder.cc.

{
  if (m_clusterSize >= m_MaximumHSClusterSize) return;
 
  // Get local (x, y) indices out of the globalSectorIndex by reverting (eq. 0)
  // Bitwise and with c_xIndexBitMask (which is (c_maxHSSectorNumber - 1))
  // (currentGlobalSectorIndex & c_xIndexBitMask)
  // equals % c_maxHSSectorNumber, i.e.
  // currentGlobalSectorIndex % c_maxHSSectorNumber.
  // Bitshifting right by c_maxAllowedRecusionLevel, i.e.
  // >> c_maxAllowedRecusionLevel
  // equals a division by 2^c_maxAllowedRecusionLevel but is much faster.
  const ushort lastLocalIndexX = (lastGlobalSectorIndex & c_xIndexBitMask);
  const ushort lastLocalIndexY = c_maxHSSectorNumber - (lastGlobalSectorIndex >> c_maxAllowedRecusionLevel);
 
  // For the iterative / recursive search, just check the direct neighbours in x and y direction
  for (ushort currentLocalIndexY = lastLocalIndexY; currentLocalIndexY >= lastLocalIndexY - 1; currentLocalIndexY--) {
    if (std::abs(static_cast<short>(m_clusterInitialPosition.second) - static_cast<short>(currentLocalIndexY)) >=
        m_MaximumHSClusterSizeY
        or m_clusterSize >= m_MaximumHSClusterSize or currentLocalIndexY > m_nVerticalSectors) {
      return;
    }
 
    for (ushort currentLocalIndexX = lastLocalIndexX; currentLocalIndexX <= lastLocalIndexX + 1; currentLocalIndexX++) {
      if (std::abs(static_cast<short>(m_clusterInitialPosition.first) - static_cast<short>(currentLocalIndexX)) >= m_MaximumHSClusterSizeX
          or m_clusterSize >= m_MaximumHSClusterSize or currentLocalIndexX > m_nAngleSectors) {
        return;
      }
 
      // Calculate the global index for this sector by applying (eq. 0)
      const uint currentGlobalSectorIndex = currentLocalIndexX + c_maxHSSectorNumber * (c_maxHSSectorNumber - currentLocalIndexY);
      // If currentGlobalSectorIndex == lastGlobalSectorIndex, the sector in check is the "parent" we came from
      // and thus has already been checked, so continue
      if (currentGlobalSectorIndex == lastGlobalSectorIndex) {
        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 (currentLocalIndexX < m_nAngleSectors and currentLocalIndexY < m_nVerticalSectors) {
 
        const auto activeSectorHits = m_activeSectorsMap.find(currentGlobalSectorIndex);
        // Only continue searching if the current cluster is smaller than the maximum cluster size
        if (activeSectorHits != m_activeSectorsMap.end()) {
          m_clusterSize++;
 
          // No need to check whether currentGlobalSectorIndex exists as a key in m_activeSectorsMap as they were
          // created at the same time so it's certain the key exists.
          for (VXDHoughState* hit : activeSectorHits->second) {
            if (not TrackingUtilities::is_in(hit, m_currentTrackCandidate)) {
              m_currentTrackCandidate.emplace_back(hit);
            }
          }
          // this sector now has been used and the hits have been processed, so it can be removed from the map
          m_activeSectorsMap.erase(currentGlobalSectorIndex);
 
          // search in the next Hough Space cells...
          DepthFirstSearch(currentGlobalSectorIndex);
        }
      }
    }
  }
}

endRun()

void endRun ( )

overrideinherited

Receive and dispatch signal for the end of the run.

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 CompositeProcessingSignalListener.

Definition at line 25 of file SingleHoughSpaceFastInterceptFinder.cc.

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

fastInterceptFinder2d()

void fastInterceptFinder2d ( const std::vector< VXDHoughState * > & hits, const ushort xmin, const ushort xmax, const ushort ymin, const ushort ymax, const ushort currentRecursion )

private

find intercepts in the 2D Hough Space by recursively calling itself until no hits are assigned 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 130 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 ushort centerx = xmin + (ushort)((xmax - xmin) >> 1);   // >> 1 equals a division by 2
  const ushort centery = ymin + (ushort)((ymax - ymin) >> 1);   // >> 1 equals a division by 2
  const ushort xIndexCache[3] = {xmin, centerx, xmax};
  const ushort yIndexCache[3] = {ymin, centery, ymax};
 
  for (int i = 0; i < 2 ; ++i) {
    const ushort left  = xIndexCache[i];
    const ushort right = xIndexCache[i + 1];
    const ushort localIndexX = left;
 
    if (left == right) continue;
 
    const float& sinLeft     = m_HSSinValuesLUT[left];
    const float& cosLeft     = m_HSCosValuesLUT[left];
    const float& sinRight    = m_HSSinValuesLUT[right];
    const float& 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, so this is just an approximation which is good enough
    const float sinCenter   = m_HSCenterSinValuesLUT[(left + right) >> 1];    // >> 1 equals a division by 2
    const float cosCenter   = m_HSCenterCosValuesLUT[(left + right) >> 1];    // >> 1 equals a division by 2
 
    for (int j = 0; j < 2; ++j) {
      const ushort lowerIndex = yIndexCache[j];
      const ushort upperIndex = yIndexCache[j + 1];
 
      if (lowerIndex == upperIndex) continue;
 
      const ushort localIndexY = lowerIndex;
      // Sector counting for y starts at positive values, i.e. the topmost sector has index 0,
      // and the bottommost sector has the highest index
      const float localUpperCoordinate = m_verticalHoughSpaceSize - m_unitY * lowerIndex;
      const float localLowerCoordinate = m_verticalHoughSpaceSize - m_unitY * upperIndex;
 
      // reset layerHits and containedHits
      layerHits = 0;
      containedHits.clear();
      for (VXDHoughState* hit : hits) {
 
        const VXDHoughState::DataCache& hitData = hit->getDataCache();
        const float& m = hitData.xConformal;
        const float& a = hitData.yConformal;
 
        const float derivativeyLeft   = m * -sinLeft   + a * cosLeft;
        const float derivativeyRight  = m * -sinRight  + a * cosRight;
        const float 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 float yLeft   = m * cosLeft   + a * sinLeft;
        const float yRight  = m * cosRight  + a * sinRight;
        const float 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 {
          // As usual in creating a 2D-array as 1D, calculate the global index as
          // xIndex + yIndex * ySize
          // A bit more complicated here though, since the y-axis is inverted on the fly.
          // Instead of starting the coordinate system in the top-left corner, it has to start in the bottom-left corner
          // for creating HS clusters from bottom to top and from left to right, so this becomes
          // xIndex + ySize * (ySize - yIndex)   (eq. 0)
          const uint globalIndex = localIndexX + c_maxHSSectorNumber * (c_maxHSSectorNumber - localIndexY);
          m_activeSectorsMap.insert({globalIndex, containedHits});
          m_activeSectorsIndices.push_back(globalIndex);
        }
      }
    }
  }
}

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

{
  m_clusterCount = 1;
 
  // Sort vector to create HS clusters from bottom left to top right
  std::sort(m_activeSectorsIndices.begin(), m_activeSectorsIndices.end());
 
  for (const uint& currentGlobalSectorIndex : m_activeSectorsIndices) {
 
    const auto currentCellHits = m_activeSectorsMap.find(currentGlobalSectorIndex);
    if (currentCellHits == m_activeSectorsMap.end()) {
      continue;
    }
 
    // Get local (x, y) indices out of the globalSectorIndex by reverting (eq. 0)
    // Bitwise and with c_xIndexBitMask (which is (c_maxHSSectorNumber - 1))
    // (currentGlobalSectorIndex & c_xIndexBitMask)
    // equals % c_maxHSSectorNumber, i.e.
    // currentGlobalSectorIndex % c_maxHSSectorNumber.
    // Bitshifting right by c_maxAllowedRecusionLevel, i.e.
    // >> c_maxAllowedRecusionLevel
    // equals a division by 2^c_maxAllowedRecusionLevel but is much faster.
    m_clusterInitialPosition = std::make_pair((currentGlobalSectorIndex & c_xIndexBitMask),
                                              c_maxHSSectorNumber - (currentGlobalSectorIndex >> c_maxAllowedRecusionLevel));
    m_clusterSize = 1;
 
    m_currentTrackCandidate.clear();
    for (VXDHoughState* hit : currentCellHits->second) {
      m_currentTrackCandidate.emplace_back(hit);
    }
    // this sector now has been used and the hits have been processed, so it can be removed from the map
    m_activeSectorsMap.erase(currentGlobalSectorIndex);
 
    // Check for HS sectors connected to each other which could form a cluster
    DepthFirstSearch(currentGlobalSectorIndex);
    // 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() [1/2]

virtual std::string getDescription ( )

inlinevirtualinherited

Brief description of the purpose of the concrete findlet.

Definition at line 60 of file Findlet.h.

      {
        return "(no description)";
      }

getDescription() [2/2]

virtual std::string getDescription ( )

inlinevirtualinherited

Brief description of the purpose of the concrete 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 56 of file CompositeProcessingSignalListener.cc.

{
  return m_subordinaryProcessingSignalListeners.size();
}

initialize()

void initialize ( )

overridevirtual

Create the store arrays.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 61 of file SingleHoughSpaceFastInterceptFinder.cc.

{
  Super::initialize();
 
  const ushort maxRecursionLevelFromSectors = ceil(log2(std::max(m_nAngleSectors, m_nVerticalSectors))) - 1;
  m_maxRecursionLevel = std::max(maxRecursionLevelFromSectors, m_maxRecursionLevel);
  B2ASSERT("The maximum number of recursions (maximumRecursionLevel) must not be larger than " << c_maxAllowedRecusionLevel <<
           ", but it is " << m_maxRecursionLevel <<
           ", please choose a smaller value for maximumRecursionLevel, and / or for nAngleSectors and / or nVerticalSectors.",
           m_maxRecursionLevel <= c_maxAllowedRecusionLevel);
  B2ASSERT("The maximum number of angleSectors must not be larger than " << c_maxHSSectorNumber <<
           ", but it is " << m_nAngleSectors << ", please choose a smaller value for nAngleSectors.",
           m_nAngleSectors <= c_maxHSSectorNumber);
  B2ASSERT("The maximum number of verticalSectors must not be larger than " << c_maxHSSectorNumber <<
           ", but it is " << m_nVerticalSectors << ", please choose a smaller value for nAngleSectors.",
           m_nVerticalSectors <= c_maxHSSectorNumber);
 
  m_unitX = (m_maximumX - m_minimumX) / (float)m_nAngleSectors;
  m_unitY = 2. * m_verticalHoughSpaceSize / m_nVerticalSectors;
 
  for (ushort i = 0; i < m_nAngleSectors; i++) {
    float x = m_minimumX + m_unitX * (float)i;
    float xc = x + 0.5 * m_unitX;
 
    m_HSSinValuesLUT[i] = sin(x);
    m_HSCosValuesLUT[i] = cos(x);
    m_HSCenterSinValuesLUT[i] = sin(xc);
    m_HSCenterCosValuesLUT[i] = cos(xc);
  }
  m_HSSinValuesLUT[m_nAngleSectors] = sin(m_maximumX);
  m_HSCosValuesLUT[m_nAngleSectors] = cos(m_maximumX);
 
  B2DEBUG(29, "HS size x: " << (m_maximumX - m_minimumX) << " HS size y: " << m_verticalHoughSpaceSize <<
          " unitX: " << m_unitX << " unitY: " << m_unitY);
}

layerFilter()

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

inlinestaticprivate

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.

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

terminate()

void terminate ( )

overrideinherited

Receive and dispatch Signal for termination of the event processing.

Definition at line 42 of file CompositeProcessingSignalListener.cc.

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

Member Data Documentation

c_maxAllowedRecusionLevel

const ushort c_maxAllowedRecusionLevel = 10

staticprivate

Define some magic numbers Maximum allowed recursion level.

Definition at line 112 of file SingleHoughSpaceFastInterceptFinder.h.

c_maxHSSectorNumber

ushort c_maxHSSectorNumber = (1 << c_maxAllowedRecusionLevel)

staticconstexprprivate

Maximum number of HS sectors in x and y, also the size of some of the the Look-Up-Tables (LUTs) below.

Definition at line 114 of file SingleHoughSpaceFastInterceptFinder.h.

c_maxLUTSize

ushort c_maxLUTSize = c_maxHSSectorNumber + 1

staticconstexprprivate

Look-Up-Table size including the right-most value.

Definition at line 118 of file SingleHoughSpaceFastInterceptFinder.h.

c_xIndexBitMask

ushort c_xIndexBitMask = c_maxHSSectorNumber - 1

staticconstexprprivate

Bit mask for coordinate transformation, creates all-ones for the coordinate system conversion.

Definition at line 116 of file SingleHoughSpaceFastInterceptFinder.h.

m_activeSectorsIndices

std::vector<uint> m_activeSectorsIndices

private

Cache the global indices of the active sectors for sorted access.

Definition at line 134 of file SingleHoughSpaceFastInterceptFinder.h.

m_activeSectorsMap

std::unordered_map<uint, std::vector<VXDHoughState*> > m_activeSectorsMap

private

Map containing only active HS sectors, i.e.

those with hits from enough layers contained in them. The keys are the global indices of the HS cell, the values are lists of pointers to the contained hits

Definition at line 132 of file SingleHoughSpaceFastInterceptFinder.h.

m_clusterCount

ushort m_clusterCount = 0

private

count the clusters

Definition at line 137 of file SingleHoughSpaceFastInterceptFinder.h.

m_clusterInitialPosition

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

private

start cell of the recursive cluster finding in the Hough Space

Definition at line 142 of file SingleHoughSpaceFastInterceptFinder.h.

m_clusterSize

ushort m_clusterSize = 0

private

size of the current cluster

Definition at line 139 of file SingleHoughSpaceFastInterceptFinder.h.

m_currentTrackCandidate

std::vector<VXDHoughState*> m_currentTrackCandidate

private

the current track candidate

Definition at line 145 of file SingleHoughSpaceFastInterceptFinder.h.

m_HSCenterCosValuesLUT

std::array<float, c_maxHSSectorNumber> m_HSCenterCosValuesLUT = {0}

private

cosine values of the Hough Space sector center coordinates

Definition at line 128 of file SingleHoughSpaceFastInterceptFinder.h.

{0};

m_HSCenterSinValuesLUT

std::array<float, c_maxHSSectorNumber> m_HSCenterSinValuesLUT = {0}

private

sine values of the Hough Space sector center coordinates

Definition at line 126 of file SingleHoughSpaceFastInterceptFinder.h.

{0};

m_HSCosValuesLUT

std::array<float, c_maxLUTSize> m_HSCosValuesLUT = {0}

private

cosine values of the Hough Space sector boarder coordinates

Definition at line 124 of file SingleHoughSpaceFastInterceptFinder.h.

{0};

m_HSSinValuesLUT

std::array<float, c_maxLUTSize> 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 122 of file SingleHoughSpaceFastInterceptFinder.h.

{0};

m_initialized

bool m_initialized

privateinherited

Flag to keep track whether initialization happened 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

ushort m_MaximumHSClusterSize = 12

private

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

Definition at line 98 of file SingleHoughSpaceFastInterceptFinder.h.

m_MaximumHSClusterSizeX

ushort m_MaximumHSClusterSizeX = 2

private

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

Definition at line 100 of file SingleHoughSpaceFastInterceptFinder.h.

m_MaximumHSClusterSizeY

ushort m_MaximumHSClusterSizeY = 12

private

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

Definition at line 102 of file SingleHoughSpaceFastInterceptFinder.h.

m_maximumX

float m_maximumX = 3.168

private

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

Definition at line 93 of file SingleHoughSpaceFastInterceptFinder.h.

m_maxRecursionLevel

ushort m_maxRecursionLevel = 9

private

maximum number of recursive calls of FastInterceptFinder2d

Definition at line 79 of file SingleHoughSpaceFastInterceptFinder.h.

m_MinimumHSClusterSize

ushort m_MinimumHSClusterSize = 1

private

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

Definition at line 96 of file SingleHoughSpaceFastInterceptFinder.h.

m_minimumX

float m_minimumX = -3.168

private

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

Definition at line 91 of file SingleHoughSpaceFastInterceptFinder.h.

m_nAngleSectors

ushort m_nAngleSectors = 512

private

number of sectors of the Hough Space on the horizontal axis

Definition at line 82 of file SingleHoughSpaceFastInterceptFinder.h.

m_nVerticalSectors

ushort m_nVerticalSectors = 512

private

number of sectors of the Hough Space on the vertical axis

Definition at line 85 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 60 of file CompositeProcessingSignalListener.h.

m_terminated

bool m_terminated

privateinherited

Flag to keep track whether termination happened 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 148 of file SingleHoughSpaceFastInterceptFinder.h.

m_unitX

float m_unitX = 0

private

HS unit size in x.

Definition at line 106 of file SingleHoughSpaceFastInterceptFinder.h.

m_unitY

float m_unitY = 0

private

HS unit size in y.

Definition at line 108 of file SingleHoughSpaceFastInterceptFinder.h.

m_verticalHoughSpaceSize

float m_verticalHoughSpaceSize = 0.16

private

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

Definition at line 88 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