HyperHough< AHitPointerType, AHitDecisionAlgorithm, qDivisions, pDivisions, muDivisions > Class Template Reference

Hough Tree for finding StereoHits with using CDCRecoHit3D as the item type. More...

#include <HyperHough.h>

Inheritance diagram for HyperHough< AHitPointerType, AHitDecisionAlgorithm, qDivisions, pDivisions, muDivisions >:

Collaboration diagram for HyperHough< AHitPointerType, AHitDecisionAlgorithm, qDivisions, pDivisions, muDivisions >:

Public Types
using	DecisionAlgorithm = AHitDecisionAlgorithm
	typedef of the templated AHitDecisionAlgorithm; used to reach methods defined in the algorithm e.g. debugLine, centerX, centerY etc.
using	BoxDivision = SectoredLinearDivision< HoughBox, divisions... >
	Type of the box division strategy.
using	HoughTree = WeightedFastHoughTree< AItemPtr, HoughBox, BoxDivision >
	Type of the fast hough tree structure.
template<size_t I>
using	Type = typename HoughBox::template Type< I >
	Type of the coordinate I.
template<class T >
using	HasType = typename HoughBox::template HasType< T >
	Predicate that the given type is indeed a coordinate of the hough space.
template<class T >
using	TypeIndex = typename HoughBox::template TypeIndex< T >
	Function to get the coordinate index from its type.
using	Node = typename HoughTree::Node
	Type of the nodes used in the tree for the search.

Public Member Functions
	HyperHough ()
	Constructor using the given maximal level setting the maximal values.
void	initialize ()
	Initialize the tree with the given values.
std::vector< std::pair< HoughBox, std::vector< AHitPointerType > > >	findSingleBest (const Weight &minWeight)
	Find only the leaf with the highest weight (~= number of items)
void	writeDebugInfoToFile (const std::string &filename)
	Write debug information into a ROOT file; not implemented.
void	drawDebugPlot (const std::vector< CDCRecoHit3D > &allHits, const std::vector< CDCRecoHit3D > &foundHits, const typename AInBoxAlgorithm::HoughBox &node)
	Draws found hits and node boundaries FIXME this is a copy-paste from DebugableSimpleBoxDivisionHoughTree It should be possible to unify it with this tree, but not sure of does worth it.
float	getMaximumX () const
	Return the maximum value in x direction.
float	getMaximumY () const
	Return the maximum value in y direction.
float	getMaximumZ () const
	Return the maximum value in Z direction.
Width< 0 >	getOverlapX () const
	Return the overlap in x direction.
Width< 1 >	getOverlapY () const
	Return the overlap in y direction.
Width< 2 >	getOverlapZ () const
	Return the overlap in y direction.
size_t	getDivision (size_t i) const
	Getter the number of divisions at each level for coordinate index I.
template<size_t I>
void	constructArray (double lowerBound, double upperBound, Width< I > nBinOverlap=0, Width< I > nBinWidth=0)
	Construct the discrete value array at coordinate index I. More...
template<size_t I>
void	assignArray (Array< I > array, Width< I > overlap=0)
	Provide an externally constructed array by coordinate index.
template<class T >
std::enable_if_t< HasType< T >::value, void >	assignArray (Array< TypeIndex< T >::value > array, Width< TypeIndex< T >::value > overlap=0)
	Provide an externally constructed array by coordinate type.
template<class AItemPtrs >
void	seed (const AItemPtrs &items)
	Prepare the leave finding by filling the top node with given hits.
void	fell ()
	Terminates the processing by striping all hit information from the tree.
void	raze ()
	Release all memory that the tree aquired during the runs.
HoughTree *	getTree () const
	Getter for the tree used in the search in the hough plane.
int	getMaxLevel () const
	Getter for the currently set maximal level.
void	setMaxLevel (int maxLevel)
	Setter maximal level of the hough tree.
int	getSectorLevelSkip () const
	Getter for number of levels to skip in first level to form a finer sectored hough space.
void	setSectorLevelSkip (int sectorLevelSkip)
	Setter for number of levels to skip in first level to form a finer sectored hough space.
template<size_t I>
const Array< I > &	getArray () const
	Getter for the array of discrete value for coordinate I.

Private Types
using	Super = SimpleBoxDivisionHoughTree3D< AHitPointerType, AHitDecisionAlgorithm, qDivisions, pDivisions, muDivisions >
	Super type.
using	HoughBox = typename AInBoxAlgorithm::HoughBox
	The HoughBox we use.
using	Width = typename HoughBox::template Width< I >
	Type of the width in coordinate I.
template<size_t I>
using	Array = typename Type< I >::Array
	Type of the discrete value array to coordinate index I.
using	Arrays = TupleGenerateN< Array, sizeof...(divisions)>
	Tuple type of the discrete value arrays.

Private Member Functions
template<size_t... Is>
HoughBox	constructHoughPlaneImpl (const std::index_sequence< Is... > &is)
	Construct the box of the top node of the tree. Implementation unroling the indices.
HoughBox	constructHoughPlane ()
	Construct the box of the top node of the tree.

Private Attributes
float	m_maximumX
	The maximum value in X direction.
float	m_maximumY
	The maximum value in y direction.
float	m_maximumZ
	The maximum value in z direction.
Width< 0 >	m_overlapX
	The overlap in X direction.
Width< 1 >	m_overlapY
	The overlap in Y direction.
Width< 2 >	m_overlapZ
	The overlap in Y direction.
int	m_maxLevel
	Number of the maximum tree level.
int	m_sectorLevelSkip
	Number of levels to skip in first level to form a finer sectored hough space.
const std::array< size_t, sizeof ...(divisions)>	m_divisions = {{divisions ...}}
	Array of the number of divisions at each level.
HoughBox::Delta	m_overlaps
	An tuple of division overlaps in each coordinate.
Arrays	m_arrays
	A tuple of value arrays providing the memory for the discrete bin bounds.
std::unique_ptr< HoughTree >	m_houghTree = nullptr
	Dynamic hough tree structure traversed in the leaf search.

Detailed Description

template<class AHitPointerType, class AHitDecisionAlgorithm, size_t qDivisions = 2, size_t pDivisions = 2, size_t muDivisions = 2>
class Belle2::TrackFindingCDC::HyperHough< AHitPointerType, AHitDecisionAlgorithm, qDivisions, pDivisions, muDivisions >

Hough Tree for finding StereoHits with using CDCRecoHit3D as the item type.

This implementation uses the HitInHyperBox decision algorithm with 2 divisions for each step. This class is only an alias. The real algorithm can be found in SimpleBoxDivisionHoughTree3D.

Definition at line 28 of file HyperHough.h.

Member Function Documentation

constructArray()

void constructArray ( double  lowerBound, double  upperBound, Width< I >  nBinOverlap = 0, Width< I >  nBinWidth = 0  )

inlineinherited

Construct the discrete value array at coordinate index I.

This function is only applicable for discrete axes. For continuous axes assignArray should be call with an array containing only the lower and upper bound of the axes range and an optional overlap.

Parameters

lowerBound	Lower bound of the value range
upperBound	Upper bound of the value range
nBinOverlap	Overlap of neighboring bins. Default is no overlap. Usuallly this is counted in number of discrete values
nBinWidth	Width of the bins at lowest level. Default is width of 1. Usually this is counted in numbers of discrete values

Definition at line 104 of file BoxDivisionHoughTree.h.

      {
        static_assert(std::is_integral<Width<I> >::value, "Method only applicable to discrete axes");
        const size_t division = getDivision(I);
        const int granularityLevel = m_maxLevel + m_sectorLevelSkip;
        const size_t nBins = std::pow(division, granularityLevel);
 
        if (nBinWidth == 0) {
          nBinWidth = nBinOverlap + 1;
        }
 
        B2ASSERT("Width " << nBinWidth << "is not bigger than overlap " << nBinOverlap,
                 nBinOverlap < nBinWidth);
 
        const auto nPositions = (nBinWidth - nBinOverlap) * nBins + nBinOverlap + 1;
        std::get<I>(m_arrays) = linspace<float>(lowerBound, upperBound, nPositions);
        std::get<I>(m_overlaps) = nBinOverlap;
      }

---

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

• tracking/trackFindingCDC/hough/hyperbolic/include/HyperHough.h