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

#include <MultiHoughSpaceFastInterceptFinder.h>

Inheritance diagram for MultiHoughSpaceFastInterceptFinder:

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

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

Public Member Functions
	MultiHoughSpaceFastInterceptFinder ()
	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 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.

typedef std::map< VxdID, std::vector< VxdID > >	friendSensorMap
	Map that contains the "friend" sensors for each SVD L6 sensor.

Private Member Functions
void	initializeSectorFriendMap ()
	fill the map of friend sensors for each L6 sensor to

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 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 (uint lastIndexX, uint lastIndexY)
	Perform depth first search recursive algorithm to find clusters in the Hough Space.

Private Attributes
HitSelector	m_HitSelector
	Use the friend map to just fill the hits in the acceptance region of the current L6 sensor into the m_currentSensorsHitList which is then used the Hough trafo track finding.

uint	m_maxRecursionLevel = 7
	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 = 256
	number of sectors of the Hough Space on the vertical axis

double	m_verticalHoughSpaceSize = 0.25
	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 = 6
	minimum cluster size of sectors belonging to intercepts in the Hough Space

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

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

uint	m_MaximumHSClusterSizeY = 100
	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.

friendSensorMap	m_fullFriendMap
	friendMap for all the SVD L6 sensors

std::vector< VXDHoughState * >	m_currentSensorsHitList
	hits that are in the acceptance region (= on friend sensors) for the current L6 senosr

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 happened before.

bool	m_terminated = false
	Flag to keep track whether termination happened 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.

This is done 80 times for a subset of SVD sensors, one subset for each layer 6 sensor to reduce combinatorics in the Hough Space and to improve the purity of the found track candidates. 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 35 of file MultiHoughSpaceFastInterceptFinder.h.

Member Typedef Documentation

◆ friendSensorMap

typedef std::map<VxdID, std::vector<VxdID> > friendSensorMap

private

Map that contains the "friend" sensors for each SVD L6 sensor.

Definition at line 40 of file MultiHoughSpaceFastInterceptFinder.h.

◆ IOTypes

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

inherited

Types that should be served to apply on invocation.

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

Definition at line 53 of file Findlet.h.

◆ Super

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

private

Parent class.

Definition at line 37 of file MultiHoughSpaceFastInterceptFinder.h.

◆ ToVector

using ToVector = typename ToVectorImpl<T>::Type

protectedinherited

Short hand for ToRangeImpl.

Definition at line 49 of file Findlet.h.

Constructor & Destructor Documentation

◆ MultiHoughSpaceFastInterceptFinder()

MultiHoughSpaceFastInterceptFinder ( )

Find intercepts in the 2D Hough space.

Definition at line 22 of file MultiHoughSpaceFastInterceptFinder.cc.

                                                                       : Super()
{
  addProcessingSignalListener(&m_HitSelector);
}

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 103 of file MultiHoughSpaceFastInterceptFinder.cc.

{
  m_trackCandidates.clear();
 
  for (auto& friends : m_fullFriendMap) {
    m_activeSectors.clear();
    m_currentSensorsHitList.clear();
 
    m_HitSelector.apply(hits, friends.second, m_currentSensorsHitList);
 
    fastInterceptFinder2d(m_currentSensorsHitList, 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 332 of file MultiHoughSpaceFastInterceptFinder.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 CompositeProcessingSignalListener.

Definition at line 27 of file MultiHoughSpaceFastInterceptFinder.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 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 213 of file MultiHoughSpaceFastInterceptFinder.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 299 of file MultiHoughSpaceFastInterceptFinder.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 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 60 of file CompositeProcessingSignalListener.cc.

{
  return m_subordinaryProcessingSignalListeners.size();
}

◆ initialize()

void initialize ( )

overridevirtual

Create the store arrays.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 63 of file MultiHoughSpaceFastInterceptFinder.cc.

{
  Super::initialize();
 
  const uint maxRecursionLevelFromSectors = ceil(log2(std::max(m_nAngleSectors, m_nVerticalSectors))) - 1;
  m_maxRecursionLevel = std::max(maxRecursionLevelFromSectors, m_maxRecursionLevel);
  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);
 
  initializeSectorFriendMap();
 
}

◆ initializeSectorFriendMap()

void initializeSectorFriendMap ( )

private

fill the map of friend sensors for each L6 sensor to

Definition at line 137 of file MultiHoughSpaceFastInterceptFinder.cc.

{
  const std::vector<VxdID> friends6XX1 = {VxdID(3, 0, 1), VxdID(3, 0, 2), VxdID(4, 0, 1), VxdID(4, 0, 2), VxdID(5, 0, 1), VxdID(5, 0, 2), VxdID(5, 0, 3), VxdID(6, 0, 2), VxdID(6, 0, 3)};
  const std::vector<VxdID> friends6XX5 = {VxdID(3, 0, 2), VxdID(4, 0, 2), VxdID(4, 0, 3), VxdID(5, 0, 3), VxdID(5, 0, 4), VxdID(6, 0, 3), VxdID(6, 0, 4)};
 
  friendSensorMap thetaFriends;
  thetaFriends.insert(std::make_pair(VxdID(6, 0, 1), friends6XX1));
  thetaFriends.insert(std::make_pair(VxdID(6, 0, 5), friends6XX5));
 
  const std::vector<VxdID> friends601X = {VxdID(3, 1, 0), VxdID(3, 6, 0), VxdID(3, 7, 0), VxdID(4, 1, 0), VxdID(4, 2, 0), VxdID(4, 10, 0), VxdID(5, 1, 0), VxdID(5, 2, 0), VxdID(5, 12, 0), VxdID(6, 1, 0)};
  const std::vector<VxdID> friends602X = {VxdID(3, 1, 0), VxdID(3, 2, 0), VxdID(3, 7, 0), VxdID(4, 1, 0), VxdID(4, 2, 0), VxdID(4, 10, 0), VxdID(5, 1, 0), VxdID(5, 2, 0), VxdID(5, 3, 0), VxdID(6, 2, 0)};
  const std::vector<VxdID> friends603X = {VxdID(3, 1, 0), VxdID(3, 2, 0), VxdID(3, 7, 0), VxdID(4, 1, 0), VxdID(4, 2, 0), VxdID(4, 3, 0), VxdID(5, 2, 0), VxdID(5, 3, 0), VxdID(6, 3, 0)};
  const std::vector<VxdID> friends604X = {VxdID(3, 1, 0), VxdID(3, 2, 0), VxdID(4, 2, 0), VxdID(4, 3, 0), VxdID(5, 3, 0), VxdID(5, 4, 0), VxdID(6, 4, 0)};
  const std::vector<VxdID> friends605X = {VxdID(3, 1, 0), VxdID(3, 2, 0), VxdID(3, 3, 0), VxdID(4, 2, 0), VxdID(4, 3, 0), VxdID(4, 4, 0), VxdID(5, 3, 0), VxdID(5, 4, 0), VxdID(5, 5, 0), VxdID(6, 5, 0)};
  const std::vector<VxdID> friends606X = {VxdID(3, 2, 0), VxdID(3, 3, 0), VxdID(4, 3, 0), VxdID(4, 4, 0), VxdID(4, 5, 0), VxdID(5, 4, 0), VxdID(5, 5, 0), VxdID(5, 6, 0), VxdID(6, 6, 0)};
  const std::vector<VxdID> friends607X = {VxdID(3, 2, 0), VxdID(3, 3, 0), VxdID(3, 4, 0), VxdID(4, 4, 0), VxdID(4, 5, 0), VxdID(5, 5, 0), VxdID(5, 6, 0), VxdID(6, 7, 0)};
  const std::vector<VxdID> friends608X = {VxdID(3, 2, 0), VxdID(3, 3, 0), VxdID(3, 4, 0), VxdID(4, 4, 0), VxdID(4, 5, 0), VxdID(4, 6, 0), VxdID(5, 6, 0), VxdID(5, 7, 0), VxdID(6, 8, 0)};
  const std::vector<VxdID> friends609X = {VxdID(3, 3, 0), VxdID(3, 4, 0), VxdID(3, 5, 0), VxdID(4, 5, 0), VxdID(4, 6, 0), VxdID(4, 7, 0), VxdID(5, 6, 0), VxdID(5, 7, 0), VxdID(5, 8, 0), VxdID(6, 9, 0)};
  const std::vector<VxdID> friends610X = {VxdID(3, 3, 0), VxdID(3, 4, 0), VxdID(3, 5, 0), VxdID(4, 5, 0), VxdID(4, 6, 0), VxdID(4, 7, 0), VxdID(5, 7, 0), VxdID(5, 8, 0), VxdID(5, 9, 0), VxdID(6, 10, 0)};
  const std::vector<VxdID> friends611X = {VxdID(3, 4, 0), VxdID(3, 5, 0), VxdID(4, 6, 0), VxdID(4, 7, 0), VxdID(4, 8, 0), VxdID(5, 8, 0), VxdID(5, 9, 0), VxdID(6, 11, 0)};
  const std::vector<VxdID> friends612X = {VxdID(3, 4, 0), VxdID(3, 5, 0), VxdID(3, 6, 0), VxdID(4, 7, 0), VxdID(4, 8, 0), VxdID(5, 9, 0), VxdID(5, 10, 0), VxdID(6, 12, 0)};
  const std::vector<VxdID> friends613X = {VxdID(3, 5, 0), VxdID(3, 6, 0), VxdID(4, 7, 0), VxdID(4, 8, 0), VxdID(4, 9, 0), VxdID(5, 9, 0), VxdID(5, 10, 0), VxdID(5, 11, 0), VxdID(6, 13, 0)};
  const std::vector<VxdID> friends614X = {VxdID(3, 5, 0), VxdID(3, 6, 0), VxdID(3, 7, 0), VxdID(4, 8, 0), VxdID(4, 9, 0), VxdID(4, 10, 0), VxdID(5, 10, 0), VxdID(5, 11, 0), VxdID(5, 12, 0), VxdID(6, 14, 0)};
  const std::vector<VxdID> friends615X = {VxdID(3, 6, 0), VxdID(3, 7, 0), VxdID(4, 9, 0), VxdID(4, 10, 0), VxdID(5, 11, 0), VxdID(5, 12, 0), VxdID(6, 15, 0)};
  const std::vector<VxdID> friends616X = {VxdID(3, 1, 0), VxdID(3, 7, 0), VxdID(4, 1, 0), VxdID(4, 9, 0), VxdID(4, 10, 0), VxdID(5, 1, 0), VxdID(5, 12, 0), VxdID(6, 16, 0)};
 
  friendSensorMap phiFriends;
  phiFriends.insert(std::make_pair(VxdID(6, 1, 0), friends601X));
  phiFriends.insert(std::make_pair(VxdID(6, 2, 0), friends602X));
  phiFriends.insert(std::make_pair(VxdID(6, 3, 0), friends603X));
  phiFriends.insert(std::make_pair(VxdID(6, 4, 0), friends604X));
  phiFriends.insert(std::make_pair(VxdID(6, 5, 0), friends605X));
  phiFriends.insert(std::make_pair(VxdID(6, 6, 0), friends606X));
  phiFriends.insert(std::make_pair(VxdID(6, 7, 0), friends607X));
  phiFriends.insert(std::make_pair(VxdID(6, 8, 0), friends608X));
  phiFriends.insert(std::make_pair(VxdID(6, 9, 0), friends609X));
  phiFriends.insert(std::make_pair(VxdID(6, 10, 0), friends610X));
  phiFriends.insert(std::make_pair(VxdID(6, 11, 0), friends611X));
  phiFriends.insert(std::make_pair(VxdID(6, 12, 0), friends612X));
  phiFriends.insert(std::make_pair(VxdID(6, 13, 0), friends613X));
  phiFriends.insert(std::make_pair(VxdID(6, 14, 0), friends614X));
  phiFriends.insert(std::make_pair(VxdID(6, 15, 0), friends615X));
  phiFriends.insert(std::make_pair(VxdID(6, 16, 0), friends616X));
 
  std::vector<VxdID> friendSensors;
 
  // loop over all phiFriends containing layer 6 ladders
  for (auto& phiFriendPair : phiFriends) {
    // get the according vector friends6XX0 for this phiFriendPair
    std::vector<VxdID> phiFriendLadders = phiFriendPair.second;
    unsigned short layer6Ladder = phiFriendPair.first.getLadderNumber();
    // loop over all thetafriends containing layer 6 sensors
    for (auto& thetaFriendPair : thetaFriends) {
      friendSensors.clear();
      // get the according vector friends600Y
      std::vector<VxdID> thetaFriendSensors = thetaFriendPair.second;
      unsigned short layer6Sensor = thetaFriendPair.first.getSensorNumber();
 
      // loop over all the layers/ladders in this phifriends vector, one specific friends6XX0
      for (auto& phiFriend : phiFriendLadders) {
        // loop over all sensor number in the different layers 3-5, one specific friends600Y
        for (auto& thetaFriend : thetaFriendSensors) {
          if (phiFriend.getLayerNumber() == thetaFriend.getLayerNumber()) {
            // get layer number of either phiFriend or thetaFriend, ladder number from phiFriend, and the sensor number from the thetaFriend
            friendSensors.emplace_back(VxdID(phiFriend.getLayerNumber(), phiFriend.getLadderNumber(), thetaFriend.getSensorNumber()));
          }
        }
      }
      // add the layer 6 sensor to the list of its own friends to check the vector with std::find in fillThisSensorsHitMap
      friendSensors.emplace_back(VxdID(6, layer6Ladder, layer6Sensor));
      m_fullFriendMap.insert(std::make_pair(VxdID(6, layer6Ladder, layer6Sensor), friendSensors));
    }
  }
}

◆ 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 66 of file MultiHoughSpaceFastInterceptFinder.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 173 of file MultiHoughSpaceFastInterceptFinder.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 183 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_clusterCount

uint m_clusterCount = 0

private

count the clusters

Definition at line 176 of file MultiHoughSpaceFastInterceptFinder.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 181 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_clusterSize

uint m_clusterSize = 0

private

size of the current cluster

Definition at line 178 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_currentSensorsHitList

std::vector<VXDHoughState*> m_currentSensorsHitList

private

hits that are in the acceptance region (= on friend sensors) for the current L6 senosr

Definition at line 129 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_currentTrackCandidate

std::vector<VXDHoughState*> m_currentTrackCandidate

private

the current track candidate

Definition at line 186 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_fullFriendMap

friendSensorMap m_fullFriendMap

private

friendMap for all the SVD L6 sensors

Definition at line 126 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_HitSelector

HitSelector m_HitSelector

private

Use the friend map to just fill the hits in the acceptance region of the current L6 sensor into the m_currentSensorsHitList which is then used the Hough trafo track finding.

Definition at line 59 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_HSCenterCosValuesLUT

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

private

cosine values of the Hough Space sector center coordinates

Definition at line 139 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_HSCenterSinValuesLUT

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

private

sine values of the Hough Space sector center coordinates

Definition at line 137 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_HSCosValuesLUT

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

private

cosine values of the Hough Space sector boarder coordinates

Definition at line 135 of file MultiHoughSpaceFastInterceptFinder.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 133 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_HSXCenterLUT

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

private

x values of the Hough Space sector centers

Definition at line 147 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_HSXLUT

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

private

x values of the Hough Space sector boarders

Definition at line 145 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_HSYCenterLUT

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

private

y values of the Hough Space sector centers

Definition at line 143 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_HSYLUT

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

private

y values of the Hough Space sector boarders

Definition at line 141 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_initialized

bool m_initialized = false

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

uint m_MaximumHSClusterSize = 100

private

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

Definition at line 113 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_MaximumHSClusterSizeX

uint m_MaximumHSClusterSizeX = 100

private

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

Definition at line 115 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_MaximumHSClusterSizeY

uint m_MaximumHSClusterSizeY = 100

private

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

Definition at line 117 of file MultiHoughSpaceFastInterceptFinder.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 108 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_maxRecursionLevel

uint m_maxRecursionLevel = 7

private

maximum number of recursive calls of fastInterceptFinder2d

Definition at line 94 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_MinimumHSClusterSize

uint m_MinimumHSClusterSize = 6

private

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

Definition at line 111 of file MultiHoughSpaceFastInterceptFinder.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 106 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_nAngleSectors

uint m_nAngleSectors = 256

private

number of sectors of the Hough Space on the horizontal axis

Definition at line 97 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_nVerticalSectors

uint m_nVerticalSectors = 256

private

number of sectors of the Hough Space on the vertical axis

Definition at line 100 of file MultiHoughSpaceFastInterceptFinder.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 = false

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 189 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_unitX

double m_unitX = 0

private

HS unit size in x.

Definition at line 121 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_unitY

double m_unitY = 0

private

HS unit size in y.

Definition at line 123 of file MultiHoughSpaceFastInterceptFinder.h.

◆ m_verticalHoughSpaceSize

double m_verticalHoughSpaceSize = 0.25

private

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

Definition at line 103 of file MultiHoughSpaceFastInterceptFinder.h.

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

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

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ friendSensorMap

◆ IOTypes

◆ IOVectors

◆ Super

◆ ToVector

Constructor & Destructor Documentation

◆ MultiHoughSpaceFastInterceptFinder()

Member Function Documentation

◆ addProcessingSignalListener()

◆ apply()

◆ beginEvent()

◆ beginRun()

◆ DepthFirstSearch()

◆ endRun()

◆ exposeParameters()

◆ fastInterceptFinder2d()

◆ FindHoughSpaceCluster()

◆ getDescription()

◆ getNProcessingSignalListener()

◆ initialize()

◆ initializeSectorFriendMap()

◆ layerFilter()

◆ terminate()

Member Data Documentation

◆ m_activeSectors

◆ m_clusterCoG

◆ m_clusterCount

◆ m_clusterInitialPosition

◆ m_clusterSize

◆ m_currentSensorsHitList

◆ m_currentTrackCandidate

◆ m_fullFriendMap

◆ m_HitSelector

◆ 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