Convenience class for the typical usage-case: A box divisioned hough tree with maximum and minimum values in both directions. More...

#include <SimpleBoxDivisionHoughTree3D.h>

Inheritance diagram for SimpleBoxDivisionHoughTree3D< AHitPtr, AInBoxAlgorithm, divisionX, divisionY, divisionZ >:

Public Types
using	BoxDivision
	Type of the box division strategy.

using	HoughTree
	Type of the fast hough tree structure.

using	Type
	Type of the coordinate I.

using	HasType
	Predicate that the given type is indeed a coordinate of the hough space.

using	TypeIndex
	Function to get the coordinate index from its type.

using	Node
	Type of the nodes used in the tree for the search.

Public Member Functions
	SimpleBoxDivisionHoughTree3D (float maximumX, float maximumY, float maximumZ, Width< 0 > overlapX=0, Width< 1 > overlapY=0, Width< 2 > overlapZ=0)
	Constructor using the given maximal level.

void	initialize ()
	Initialize the tree with the given values.

std::vector< std::pair< HoughBox, std::vector< AHitPtr > > >	findSingleBest (const TrackingUtilities::Weight &minWeight)
	Find only the leaf with the highest weight (~= number of items)

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.

void	constructArray (double lowerBound, double upperBound, Width< I > nBinOverlap=0, Width< I > nBinWidth=0)
	Construct the discrete value array at coordinate index I.

void	assignArray (Array< I > array, Width< I > overlap=0)
	Provide an externally constructed array by coordinate index.

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.

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

const Array< I > &	getArray () const
	Getter for the array of discrete value for coordinate I.

Static Public Member Functions
static void	writeDebugInfoToFile (const std::string &filename)
	Write debug information into a ROOT file; not implemented.

static void	drawDebugPlot (const std::vector< TrackingUtilities::CDCRecoHit3D > &allHits, const std::vector< TrackingUtilities::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.

Private Types
using	Super = BoxDivisionHoughTree<AHitPtr, typename AInBoxAlgorithm::HoughBox, divisionX, divisionY, divisionZ>
	The Super class.

using	HoughBox = typename AInBoxAlgorithm::HoughBox
	The HoughBox we use.

template<size_t I>
using	Width = typename HoughBox::template Width<I>
	Type of the width in coordinate I.

using	Array
	Type of the discrete value array to coordinate index I.

using	Arrays
	Tuple type of the discrete value arrays.

Private Member Functions
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 = 0
	The maximum value in X direction.

float	m_maximumY = 0
	The maximum value in y direction.

float	m_maximumZ = 0
	The maximum value in z direction.

Width< 0 >	m_overlapX = 0
	The overlap in X direction.

Width< 1 >	m_overlapY = 0
	The overlap in Y direction.

Width< 2 >	m_overlapZ = 0
	The overlap in Y direction.

const std::array< size_t, sizeof ...(divisions)>	m_divisions
	Array of the number of divisions at each level.

std::unique_ptr< HoughTree >	m_houghTree
	Dynamic hough tree structure traversed in the leaf search.

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.

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.

Detailed Description

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>
class Belle2::TrackFindingCDC::SimpleBoxDivisionHoughTree3D< AHitPtr, AInBoxAlgorithm, divisionX, divisionY, divisionZ >

Convenience class for the typical usage-case: A box divisioned hough tree with maximum and minimum values in both directions.

This time in 3D

Definition at line 28 of file SimpleBoxDivisionHoughTree3D.h.

Member Typedef Documentation

◆ Array

using Array

privateinherited

Type of the discrete value array to coordinate index I.

Definition at line 78 of file BoxDivisionHoughTree.h.

◆ Arrays

using Arrays

privateinherited

Tuple type of the discrete value arrays.

Definition at line 81 of file BoxDivisionHoughTree.h.

◆ BoxDivision

using BoxDivision

inherited

Type of the box division strategy.

Definition at line 41 of file BoxDivisionHoughTree.h.

◆ HasType

using HasType

inherited

Predicate that the given type is indeed a coordinate of the hough space.

Definition at line 52 of file BoxDivisionHoughTree.h.

◆ HoughBox

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

using HoughBox = typename AInBoxAlgorithm::HoughBox

private

The HoughBox we use.

Definition at line 36 of file SimpleBoxDivisionHoughTree3D.h.

◆ HoughTree

using HoughTree

inherited

Type of the fast hough tree structure.

Definition at line 44 of file BoxDivisionHoughTree.h.

◆ Node

using Node

inherited

Type of the nodes used in the tree for the search.

Definition at line 63 of file BoxDivisionHoughTree.h.

◆ Super

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

using Super = BoxDivisionHoughTree<AHitPtr, typename AInBoxAlgorithm::HoughBox, divisionX, divisionY, divisionZ>

private

The Super class.

Definition at line 33 of file SimpleBoxDivisionHoughTree3D.h.

◆ Type

using Type

inherited

Type of the coordinate I.

Definition at line 48 of file BoxDivisionHoughTree.h.

◆ TypeIndex

using TypeIndex

inherited

Function to get the coordinate index from its type.

Definition at line 56 of file BoxDivisionHoughTree.h.

◆ Width

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

template<size_t I>

using Width = typename HoughBox::template Width<I>

private

Type of the width in coordinate I.

Definition at line 40 of file SimpleBoxDivisionHoughTree3D.h.

Constructor & Destructor Documentation

◆ SimpleBoxDivisionHoughTree3D()

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

SimpleBoxDivisionHoughTree3D	(	float	maximumX,
		float	maximumY,
		float	maximumZ,
		Width< 0 >	overlapX = 0,
		Width< 1 >	overlapY = 0,
		Width< 2 >	overlapZ = 0 )

inline

Constructor using the given maximal level.

Definition at line 44 of file SimpleBoxDivisionHoughTree3D.h.

        : Super(0)
        , m_maximumX(maximumX)
        , m_maximumY(maximumY)
        , m_maximumZ(maximumZ)
        , m_overlapX(overlapX)
        , m_overlapY(overlapY)
        , m_overlapZ(overlapZ)
      {
      }

Member Function Documentation

◆ assignArray() [1/2]

void assignArray	(	Array< I >	array,
		Width< I >	overlap = 0 )

inlineinherited

Provide an externally constructed array by coordinate index.

Definition at line 129 of file BoxDivisionHoughTree.h.

      {
        std::get<I>(m_arrays) = std::move(array);
        std::get<I>(m_overlaps) = overlap;
 
        // In case of a discrete axes, check whether the size of the array is sensible
        // such that the bin width at the highest granularity level is a whole number given the overlap.
        if (std::is_integral<Width<I> >::value) {
          const int division = getDivision(I);
          const int granularityLevel = m_maxLevel + m_sectorLevelSkip;
          const long int nBins = std::pow(division, granularityLevel);
          const long int nPositions = std::get<I>(m_arrays).size();
          const long int nWidthTimeNBins = nPositions - 1 + (nBins - 1) * overlap;
 
          B2ASSERT("Not enough positions in array to cover all bins.\n"
                   "Expected: positions = " << nBins - (nBins - 1) * overlap + 1 << " at least.\n"
                   "Actual:   positions = " << nPositions << " (overlap = " << overlap << ", bins = " << nBins << ")\n",
                   nWidthTimeNBins >= nBins);
 
          B2ASSERT("Number of positions in array introduces inhomogeneous width at the highest granularity level.\n"
                   "Expected: positions = 'width * bins - (bins - 1) * overlap + 1'\n"
                   "Actual:   positions = " << nPositions << " (overlap = " << overlap << ", bins = " << nBins << ")\n",
                   nWidthTimeNBins % nBins == 0);
        }
      }

◆ assignArray() [2/2]

std::enable_if_t< HasType< T >::value, void > assignArray	(	Array< TypeIndex< T >::value >	array,
		Width< TypeIndex< T >::value >	overlap = 0 )

inlineinherited

Provide an externally constructed array by coordinate type.

Definition at line 158 of file BoxDivisionHoughTree.h.

      {
        assignArray<TypeIndex<T>::value>(std::move(array), overlap);
      }

◆ 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. Usually 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 105 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) = TrackingUtilities::linspace<float>(lowerBound, upperBound, nPositions);
        std::get<I>(m_overlaps) = nBinOverlap;
      }

◆ constructHoughPlane()

HoughBox constructHoughPlane ( )

inlineprivateinherited

Construct the box of the top node of the tree.

Definition at line 246 of file BoxDivisionHoughTree.h.

      {
        return constructHoughPlaneImpl(std::make_index_sequence<sizeof...(divisions)>());
      }

◆ constructHoughPlaneImpl()

HoughBox constructHoughPlaneImpl ( const std::index_sequence< Is... > & is )

inlineprivateinherited

Construct the box of the top node of the tree. Implementation unroling the indices.

Definition at line 240 of file BoxDivisionHoughTree.h.

      {
        return HoughBox(Type<Is>::getRange(std::get<Is>(m_arrays))...);
      }

◆ drawDebugPlot()

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

static void drawDebugPlot	(	const std::vector< TrackingUtilities::CDCRecoHit3D > &	allHits,
		const std::vector< TrackingUtilities::CDCRecoHit3D > &	foundHits,
		const typename AInBoxAlgorithm::HoughBox &	node )

inlinestatic

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.

Definition at line 100 of file SimpleBoxDivisionHoughTree3D.h.

      {
        TGraph* allHitsGraph = new TGraph();
        allHitsGraph->SetLineWidth(2);
        allHitsGraph->SetLineColor(9);
 
        for (const TrackingUtilities::CDCRecoHit3D& recoHit3D : allHits) {
          const ROOT::Math::XYZVector& recoPos3D = recoHit3D.getRecoPos3D();
          const double R = std::sqrt(recoPos3D.x() * recoPos3D.x() + recoPos3D.y() * recoPos3D.y());
          const double Z = recoPos3D.z();
          allHitsGraph->SetPoint(allHitsGraph->GetN(), R, Z);
        }
 
        static int nevent(0);
        TCanvas canv("trackCanvas", "CDC stereo hits in an event", 0, 0, 1600, 1200);
        canv.cd();
        allHitsGraph->Draw("APL*");
        allHitsGraph->GetXaxis()->SetLimits(0, 120);
        allHitsGraph->GetYaxis()->SetRangeUser(-180, 180);
 
        TGraph* foundHitsGraph = new TGraph();
        foundHitsGraph->SetMarkerStyle(8);
        foundHitsGraph->SetMarkerColor(2);
 
        for (const TrackingUtilities::CDCRecoHit3D& recoHit3D : foundHits) {
          const ROOT::Math::XYZVector& recoPos3D = recoHit3D.getRecoPos3D();
          const double R = std::sqrt(recoPos3D.x() * recoPos3D.x() + recoPos3D.y() * recoPos3D.y());
          const double Z = recoPos3D.z();
          foundHitsGraph->SetPoint(foundHitsGraph->GetN(), R, Z);
        }
        foundHitsGraph->Draw("P");
 
        const double centerX = (AInBoxAlgorithm::BoxAlgorithm::centerX(node));
        const double deltaX = (AInBoxAlgorithm::BoxAlgorithm::deltaX(node));
        const double centerY = (AInBoxAlgorithm::BoxAlgorithm::centerY(node));
        const double centerZ = (AInBoxAlgorithm::BoxAlgorithm::centerZ(node));
 
        TF1* candidateL = new TF1("candL", AInBoxAlgorithm::BoxAlgorithm::debugLine(), 0, 120);
        TF1* candidateH = new TF1("candH", AInBoxAlgorithm::BoxAlgorithm::debugLine(), 0, 120);
        TF1* candidateMean = new TF1("candMean", AInBoxAlgorithm::BoxAlgorithm::debugLine(), 0, 120);
 
        candidateL->SetParameters(centerX - deltaX, centerY, centerZ - 100.0 * deltaX);
        candidateH->SetParameters(centerX + deltaX, centerY, centerZ + 100.0 * deltaX);
        candidateMean->SetParameters(centerX, centerY, centerZ);
 
        candidateL->SetLineColor(9);
        candidateH->SetLineColor(41);
        candidateMean->SetLineColor(2);
 
        candidateL->Draw("same");
        candidateH->Draw("same");
        candidateMean->Draw("same");
        canv.SaveAs(Form("CDCRLHits_%i.png", nevent));
        nevent++;
      }

◆ fell()

void fell ( )

inlineinherited

Terminates the processing by striping all hit information from the tree.

Definition at line 182 of file BoxDivisionHoughTree.h.

      {
        HoughTree* const tree = this->m_houghTree.get();
        if (tree != nullptr) {
          tree->fell();
        }
      }

◆ findSingleBest()

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

std::vector< std::pair< HoughBox, std::vector< AHitPtr > > > findSingleBest ( const TrackingUtilities::Weight & minWeight )

inline

Find only the leaf with the highest weight (~= number of items)

Definition at line 73 of file SimpleBoxDivisionHoughTree3D.h.

      {
        AInBoxAlgorithm inBoxAlgorithm;
        auto skipLowWeightNode = [minWeight](const typename Super::Node * node) {
          return not(node->getWeight() >= minWeight);
        };
        auto found = this->getTree()->findHeaviestLeafSingle(inBoxAlgorithm, this->getMaxLevel(), skipLowWeightNode);
 
        std::vector<std::pair<HoughBox, std::vector<AHitPtr>>> result;
        if (found) {
          // Move the found content over. unique_ptr still destroys the left overs.
          result.push_back(std::move(*found));
        }
        return result;
      }

◆ getArray()

const Array< I > & getArray ( ) const

inlineinherited

Getter for the array of discrete value for coordinate I.

Definition at line 232 of file BoxDivisionHoughTree.h.

      {
        return std::get<I>(m_arrays);
      }

◆ getDivision()

size_t getDivision ( size_t i ) const

inlineinherited

Getter the number of divisions at each level for coordinate index I.

Definition at line 85 of file BoxDivisionHoughTree.h.

      {
        return m_divisions[i];
      }

◆ getMaximumX()

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

float getMaximumX ( ) const

inline

Return the maximum value in x direction.

Definition at line 159 of file SimpleBoxDivisionHoughTree3D.h.

      {
        return m_maximumX;
      }

◆ getMaximumY()

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

float getMaximumY ( ) const

inline

Return the maximum value in y direction.

Definition at line 165 of file SimpleBoxDivisionHoughTree3D.h.

      {
        return m_maximumY;
      }

◆ getMaximumZ()

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

float getMaximumZ ( ) const

inline

Return the maximum value in Z direction.

Definition at line 171 of file SimpleBoxDivisionHoughTree3D.h.

      {
        return m_maximumZ;
      }

◆ getMaxLevel()

int getMaxLevel ( ) const

inlineinherited

Getter for the currently set maximal level.

Definition at line 207 of file BoxDivisionHoughTree.h.

      {
        return m_maxLevel;
      }

◆ getOverlapX()

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

Width< 0 > getOverlapX ( ) const

inline

Return the overlap in x direction.

Definition at line 177 of file SimpleBoxDivisionHoughTree3D.h.

      {
        return m_overlapX;
      }

◆ getOverlapY()

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

Width< 1 > getOverlapY ( ) const

inline

Return the overlap in y direction.

Definition at line 183 of file SimpleBoxDivisionHoughTree3D.h.

      {
        return m_overlapY;
      }

◆ getOverlapZ()

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

Width< 2 > getOverlapZ ( ) const

inline

Return the overlap in y direction.

Definition at line 189 of file SimpleBoxDivisionHoughTree3D.h.

      {
        return m_overlapZ;
      }

◆ getSectorLevelSkip()

int getSectorLevelSkip ( ) const

inlineinherited

Getter for number of levels to skip in first level to form a finer sectored hough space.

Definition at line 219 of file BoxDivisionHoughTree.h.

      {
        return m_sectorLevelSkip;
      }

◆ getTree()

HoughTree * getTree ( ) const

inlineinherited

Getter for the tree used in the search in the hough plane.

Definition at line 201 of file BoxDivisionHoughTree.h.

      {
        return m_houghTree.get();
      }

◆ initialize()

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

void initialize ( )

inline

Initialize the tree with the given values.

Definition at line 62 of file SimpleBoxDivisionHoughTree3D.h.

      {
        Super::template constructArray<0>(-getMaximumX(), getMaximumX(), getOverlapX());
        Super::template constructArray<1>(-getMaximumY(), getMaximumY(), getOverlapY());
        Super::template constructArray<2>(-getMaximumZ(), getMaximumZ(), getOverlapZ());
 
        Super::initialize();
      }

◆ raze()

void raze ( )

inlineinherited

Release all memory that the tree acquired during the runs.

Definition at line 191 of file BoxDivisionHoughTree.h.

      {
        HoughTree* const tree = this->m_houghTree.get();
        if (tree != nullptr) {
          tree->raze();
        }
      }

◆ seed()

void seed ( const AItemPtrs & items )

inlineinherited

Prepare the leave finding by filling the top node with given hits.

Definition at line 175 of file BoxDivisionHoughTree.h.

      {
        if (not m_houghTree) initialize();
        m_houghTree->seed(items);
      }

◆ setMaxLevel()

void setMaxLevel ( int maxLevel )

inlineinherited

Setter maximal level of the hough tree.

Definition at line 213 of file BoxDivisionHoughTree.h.

      {
        m_maxLevel = maxLevel;
      }

◆ setSectorLevelSkip()

void setSectorLevelSkip ( int sectorLevelSkip )

inlineinherited

Setter for number of levels to skip in first level to form a finer sectored hough space.

Definition at line 225 of file BoxDivisionHoughTree.h.

      {
        m_sectorLevelSkip = sectorLevelSkip;
      }

◆ writeDebugInfoToFile()

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

static void writeDebugInfoToFile ( const std::string & filename )

inlinestatic

Write debug information into a ROOT file; not implemented.

Definition at line 90 of file SimpleBoxDivisionHoughTree3D.h.

      {
        //do nothing;
      }

Member Data Documentation

◆ m_arrays

Arrays m_arrays

privateinherited

A tuple of value arrays providing the memory for the discrete bin bounds.

Definition at line 268 of file BoxDivisionHoughTree.h.

◆ m_divisions

const std::array<size_t, sizeof ...(divisions)> m_divisions

privateinherited

Array of the number of divisions at each level.

Definition at line 253 of file BoxDivisionHoughTree.h.

253{{divisions ...}};

◆ m_houghTree

std::unique_ptr<HoughTree> m_houghTree

privateinherited

Dynamic hough tree structure traversed in the leaf search.

Definition at line 256 of file BoxDivisionHoughTree.h.

◆ m_maximumX

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

float m_maximumX = 0

private

The maximum value in X direction.

Definition at line 196 of file SimpleBoxDivisionHoughTree3D.h.

◆ m_maximumY

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

float m_maximumY = 0

private

The maximum value in y direction.

Definition at line 199 of file SimpleBoxDivisionHoughTree3D.h.

◆ m_maximumZ

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

float m_maximumZ = 0

private

The maximum value in z direction.

Definition at line 202 of file SimpleBoxDivisionHoughTree3D.h.

◆ m_maxLevel

int m_maxLevel

privateinherited

Number of the maximum tree level.

Definition at line 259 of file BoxDivisionHoughTree.h.

◆ m_overlaps

HoughBox::Delta m_overlaps

privateinherited

An tuple of division overlaps in each coordinate.

Definition at line 265 of file BoxDivisionHoughTree.h.

◆ m_overlapX

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

Width<0> m_overlapX = 0

private

The overlap in X direction.

Definition at line 205 of file SimpleBoxDivisionHoughTree3D.h.

◆ m_overlapY

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

Width<1> m_overlapY = 0

private

The overlap in Y direction.

Definition at line 208 of file SimpleBoxDivisionHoughTree3D.h.

◆ m_overlapZ

template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY, size_t divisionZ>

Width<2> m_overlapZ = 0

private

The overlap in Y direction.

Definition at line 211 of file SimpleBoxDivisionHoughTree3D.h.

◆ m_sectorLevelSkip

int m_sectorLevelSkip

privateinherited

Number of levels to skip in first level to form a finer sectored hough space.

Definition at line 262 of file BoxDivisionHoughTree.h.

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

tracking/trackFindingCDC/hough/trees/include/SimpleBoxDivisionHoughTree3D.h

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Array

◆ Arrays

◆ BoxDivision

◆ HasType

◆ HoughBox

◆ HoughTree

◆ Node

◆ Super

◆ Type

◆ TypeIndex

◆ Width

Constructor & Destructor Documentation

◆ SimpleBoxDivisionHoughTree3D()

Member Function Documentation

◆ assignArray() [1/2]

◆ assignArray() [2/2]

◆ constructArray()

◆ constructHoughPlane()

◆ constructHoughPlaneImpl()

◆ drawDebugPlot()

◆ fell()

◆ findSingleBest()

◆ getArray()

◆ getDivision()

◆ getMaximumX()

◆ getMaximumY()

◆ getMaximumZ()

◆ getMaxLevel()

◆ getOverlapX()

◆ getOverlapY()

◆ getOverlapZ()

◆ getSectorLevelSkip()

◆ getTree()

◆ initialize()

◆ raze()

◆ seed()

◆ setMaxLevel()

◆ setSectorLevelSkip()

◆ writeDebugInfoToFile()

Member Data Documentation

◆ m_arrays

◆ m_divisions

◆ m_houghTree

◆ m_maximumX

◆ m_maximumY

◆ m_maximumZ

◆ m_maxLevel

◆ m_overlaps

◆ m_overlapX

◆ m_overlapY

◆ m_overlapZ

◆ m_sectorLevelSkip