Predicate class that is feed the nodes in a WeightedHoughTree walk It decides if a node should be further expanded and extracts items from nodes that are considered as leafs to build tracks. More...

#include <AxialLegendreLeafProcessor.h>

Public Types
using	Candidate = std::pair< CDCTrajectory2D, std::vector< CDCRLWireHit > >
	Preliminary structure to save found hits and trajectory information.

Public Member Functions
	AxialLegendreLeafProcessor (int maxLevel)
	Initialize a new processor with the maximum level.

bool	operator() (ANode *node)
	Entry point for the WeightedHoughTree walk to ask if a node is a leaf that should not be further divided into sub nodes.

bool	skip (const ANode *node)
	Decide if the node should be expanded further or marks an end point of the depth search.

bool	isLeaf (const ANode *node)
	Decide when a leaf node is reached that should be processed further.

void	processLeaf (ANode *leaf)
	A valuable leaf has been found in the hough tree walk.

std::vector< WithSharedMark< CDCRLWireHit > >	searchRoad (const ANode &node, const CDCTrajectory2D &trajectory2D)
	Look for more hits near a ftted trajectory from hits available in the give node.

std::vector< Candidate >	getCandidates () const
	Getter for the candidates structure still used in some tests.

const std::vector< CDCTrack > &	getTracks () const
	Getter for the tracks.

void	clear ()
	Clear the found candidates.

void	setAxialWireHits (std::vector< const CDCWireHit * > axialWireHits)
	Set the pool of all axial wire hits to be used in the postprocessing.

void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix)
	Expose the parameters as a module parameter list.

void	beginWalk ()
	Function to notify the leaf processor about changes in parameters before a new walk.

Public Attributes
int	m_nNodes = 0
	Statistic: Number received node.

int	m_nSkippedNodes = 0
	Statistic: Number of skipped nodes.

int	m_nLeafs = 0
	Statistic: Number processed leaf.

Private Attributes
int	m_param_maxLevel = 1
	Memory for the maximal level of the tree.

double	m_param_minWeight = 0
	Memory for the minimal weight threshold for following the children of a node.

double	m_param_maxCurv = NAN
	Memory for the maximal curvature that should be searched in the current walk.

double	m_param_curlCurv = 0.018
	Memory for the curvature of a curler in the CDC.

int	m_param_nRoadSearches = 0
	Memory for the number of repeated road searches.

int	m_param_roadLevel = 0
	Memory for the tree node level which should be the source of hits for the road searches. Defaults to the top most node.

std::string	m_param_curvResolution = "const"
	Memory for the name of the resolution function to be used. Valid values are 'none', 'const', 'basic', 'origin', 'offOrigin'.

std::vector< CDCTrack >	m_tracks
	Memory for found trajectories.

std::vector< const CDCWireHit * >	m_axialWireHits
	Memory for the pool of axial wire hits to can be used in the post processing.

std::function< double(double)>	m_curvResolution
	Memory for the freely defined curvature resolution function.

Detailed Description

template<class ANode>
class Belle2::TrackFindingCDC::AxialLegendreLeafProcessor< ANode >

Predicate class that is feed the nodes in a WeightedHoughTree walk It decides if a node should be further expanded and extracts items from nodes that are considered as leafs to build tracks.

It accumulates the tracks in a member vector from where they can be taken after the walk over the tree has been completed.

Definition at line 36 of file AxialLegendreLeafProcessor.h.

Member Typedef Documentation

◆ Candidate

using Candidate = std::pair<CDCTrajectory2D, std::vector<CDCRLWireHit> >

Preliminary structure to save found hits and trajectory information.

Definition at line 40 of file AxialLegendreLeafProcessor.h.

Constructor & Destructor Documentation

◆ AxialLegendreLeafProcessor()

AxialLegendreLeafProcessor ( int maxLevel )

inlineexplicit

Initialize a new processor with the maximum level.

Definition at line 44 of file AxialLegendreLeafProcessor.h.

45 : m_param_maxLevel(maxLevel)

46 {}

Belle2::TrackFindingCDC::AxialLegendreLeafProcessor::m_param_maxLevel

int m_param_maxLevel

Memory for the maximal level of the tree.

Definition: AxialLegendreLeafProcessor.h:148

Member Function Documentation

◆ beginWalk()

void beginWalk

Function to notify the leaf processor about changes in parameters before a new walk.

Definition at line 232 of file AxialLegendreLeafProcessor.icc.h.

    {
      // Setup the requested precision function
      if (m_param_curvResolution == "none") {
        m_curvResolution = [](double curv __attribute__((unused))) { return NAN; };
      } else if (m_param_curvResolution == "const") {
        m_curvResolution = [](double curv __attribute__((unused))) { return 0.0008; };
      } else if (m_param_curvResolution == "basic") {
        m_curvResolution = &PrecisionUtil::getBasicCurvPrecision;
      } else if (m_param_curvResolution == "origin") {
        m_curvResolution = &PrecisionUtil::getOriginCurvPrecision;
      } else if (m_param_curvResolution == "nonOrigin") {
        m_curvResolution = &PrecisionUtil::getNonOriginCurvPrecision;
      } else {
        B2WARNING("Unknown curvature resolution function " << m_param_curvResolution);
        m_curvResolution = [](double curv __attribute__((unused))) { return NAN; };
      }
    }

◆ clear()

void clear ( )

inline

Clear the found candidates.

Definition at line 117 of file AxialLegendreLeafProcessor.h.

      {
        m_tracks.clear();
        m_axialWireHits.clear();
      }

◆ exposeParameters()

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

Expose the parameters as a module parameter list.

Definition at line 191 of file AxialLegendreLeafProcessor.icc.h.

    {
      moduleParamList->addParameter(prefixed(prefix, "maxLevel"),
                                    m_param_maxLevel,
                                    "Level of divisions in the hough space at which a leaf is reached",
                                    m_param_maxLevel);
 
      moduleParamList->addParameter(prefixed(prefix, "minWeight"),
                                    m_param_minWeight,
                                    "Minimal exceptable weight of a leaf to be considered",
                                    m_param_minWeight);
 
      moduleParamList->addParameter(prefixed(prefix, "maxCurv"),
                                    m_param_maxCurv,
                                    "Maximal curvature of a leaf to be considered",
                                    m_param_maxCurv);
 
      moduleParamList->addParameter(prefixed(prefix, "curlCurv"),
                                    m_param_curlCurv,
                                    "Curvature below which hits on both arms of the trajectory are allowed",
                                    m_param_curlCurv);
 
      moduleParamList->addParameter(prefixed(prefix, "nRoadSearches"),
                                    m_param_nRoadSearches,
                                    "How often the road search should be performed to find new hits",
                                    m_param_nRoadSearches);
 
      moduleParamList->addParameter(prefixed(prefix, "roadLevel"),
                                    m_param_roadLevel,
                                    "Level of the read from which additional hits in the road search can be taken",
                                    m_param_roadLevel);
 
      moduleParamList->addParameter(prefixed(prefix, "curvResolution"),
                                    m_param_curvResolution,
                                    "The name of the resolution function to be used. "
                                    "Valid values are 'none', 'const', 'basic', 'origin', 'nonOrigin'",
                                    m_param_curvResolution);
    }

◆ getCandidates()

std::vector< typename AxialLegendreLeafProcessor< ANode >::Candidate > getCandidates

Getter for the candidates structure still used in some tests.

Definition at line 176 of file AxialLegendreLeafProcessor.icc.h.

    {
      std::vector<Candidate> result;
      for (const CDCTrack& track : m_tracks) {
        std::vector<CDCRLWireHit> rlWireHits;
        for (const CDCRecoHit3D& recoHit3D : track) {
          rlWireHits.push_back(recoHit3D.getRLWireHit());
        }
        CDCTrajectory2D trajectory2D = track.getStartTrajectory3D().getTrajectory2D();
        result.emplace_back(std::move(trajectory2D), std::move(rlWireHits));
      }
      return result;
    }

◆ getTracks()

const std::vector< CDCTrack > & getTracks ( ) const

inline

Getter for the tracks.

Definition at line 111 of file AxialLegendreLeafProcessor.h.

      {
        return m_tracks;
      }

◆ isLeaf()

bool isLeaf ( const ANode * node )

inline

Decide when a leaf node is reached that should be processed further.

Definition at line 78 of file AxialLegendreLeafProcessor.h.

      {
        //if (node->getLevel() <= 6) return false;
        if (node->getLevel() >= m_param_maxLevel) return true;
 
        // Compare the resolution at the mean curvature to the resolution defined by the resolution function
        std::array<DiscreteCurv, 2> curvs = node->template getBounds<DiscreteCurv>();
        float lowerCurv = *(curvs[0]);
        float upperCurv = *(curvs[1]);
        float curvWidth = std::fabs(upperCurv - lowerCurv);
        double curvRes = m_curvResolution((lowerCurv + upperCurv) / 2.0);
        if (curvRes >= curvWidth) return true;
        return false;
      }

◆ operator()()

bool operator() ( ANode * node )

inline

Entry point for the WeightedHoughTree walk to ask if a node is a leaf that should not be further divided into sub nodes.

Definition at line 53 of file AxialLegendreLeafProcessor.h.

      {
        ++m_nNodes;
        if (skip(node)) {
          ++m_nSkippedNodes;
          return true;
        } else if (isLeaf(node)) {
          ++m_nLeafs;
          processLeaf(node);
          return true;
        } else {
          return false;
        }
      }

◆ processLeaf()

void processLeaf ( ANode * leaf )

A valuable leaf has been found in the hough tree walk.

Extract its content! It may pull more hits from the whole tree by looking at the top node.

Definition at line 37 of file AxialLegendreLeafProcessor.icc.h.

    {
      // Special post processing looking for more hits
      // Start off by fitting the items of the leaf with a general trajectory
      // that may have a distinct impact != 0
      auto fitPos = EFitPos::c_RecoPos;
      auto fitVariance = EFitVariance::c_DriftLength;
      // Other combinations of fit information
      // EFitPos::c_RLDriftCircle x EFitVariance::(c_Nominal, c_Pseudo, c_Proper)
      // have been tried, but found to be worse, which is
      // not intuitive. Probably the perfect circle trajectory
      // is not as good of a model on the full CDC volume.
      CDCObservations2D observations2D(fitPos, fitVariance);
 
      CDCKarimakiFitter fitter;
      // Tested alternative CDCRiemannFitter with only marginal differences;
 
      std::vector<WithSharedMark<CDCRLWireHit>> hits(leaf->begin(), leaf->end());
      std::sort(hits.begin(), hits.end()); // Hits should be naturally sorted
      observations2D.appendRange(hits);
      CDCTrajectory2D trajectory2D = fitter.fit(observations2D);
      {
        const double curv = trajectory2D.getCurvature();
        std::array<DiscreteCurv, 2> curvs = leaf->template getBounds<DiscreteCurv>();
 
        float lowerCurv = *(curvs[0]);
        float upperCurv = *(curvs[1]);
        if (static_cast<double>(ESignUtil::common(lowerCurv, upperCurv)) * curv < 0) {
          trajectory2D.reverse();
        }
      }
      trajectory2D.setLocalOrigin(Vector2D(0, 0));
 
      // Look for more hits near the found trajectory
      if (m_param_nRoadSearches > 0) {
        // Acquire all available items in some parent node for the road search
        // Somewhat bypasses the logic of the tree walk - Must handle with care!
        ANode* roadNode = leaf;
        while (roadNode->getParent() and roadNode->getLevel() > m_param_roadLevel) {
          roadNode = roadNode->getParent();
        }
 
        for (int iRoadSearch = 0; iRoadSearch < m_param_nRoadSearches; ++iRoadSearch) {
          // Use a road search to find new hits from the trajectory
          // hits = this->searchRoad(*roadNode, trajectory2D); // In case you only want the road hits
          // if (hits.size() < 5) return;
 
          // Second version always holding on to the originally found hits
          int nHitsBefore = hits.size();
          std::vector<WithSharedMark<CDCRLWireHit>> roadHits = this->searchRoad(*roadNode, trajectory2D);
          std::sort(roadHits.begin(), roadHits.end());
          hits.insert(hits.end(), roadHits.begin(), roadHits.end());
          std::inplace_merge(hits.begin(), hits.begin() + nHitsBefore, hits.end());
          hits.erase(std::unique(hits.begin(), hits.end()), hits.end());
 
          // Update the current fit
          observations2D.clear();
          observations2D.appendRange(hits);
          trajectory2D = fitter.fit(observations2D);
          trajectory2D.setLocalOrigin(Vector2D(0.0, 0.0));
        }
      }
 
      // Mark found hit as used and safe them with the trajectory
      std::vector<const CDCWireHit*> foundWireHits;
      for (CDCRLWireHit& rlWireHit : hits) {
        foundWireHits.push_back(&rlWireHit.getWireHit());
      }
 
      AxialTrackUtil::addCandidateFromHits(foundWireHits, m_axialWireHits, m_tracks, true);
 
      // Sync up the marks with the used hits
      for (WithSharedMark<CDCRLWireHit>& markableRLWireHit : leaf->getTree()->getTopNode()) {
        const AutomatonCell& automatonCell = markableRLWireHit.getWireHit().getAutomatonCell();
        if (automatonCell.hasTakenFlag() or automatonCell.hasMaskedFlag()) {
          markableRLWireHit.mark();
        } else {
          markableRLWireHit.unmark();
        }
      }
    }

◆ searchRoad()

std::vector< WithSharedMark< CDCRLWireHit > > searchRoad	(	const ANode &	node,
		const CDCTrajectory2D &	trajectory2D
	)

Look for more hits near a ftted trajectory from hits available in the give node.

Definition at line 124 of file AxialLegendreLeafProcessor.icc.h.

    {
      PerigeeCircle circle = trajectory2D.getGlobalCircle();
      Vector2D support = trajectory2D.getGlobalPerigee();
      const float curv = circle.curvature();
      const float phi0 = circle.phi0();
 
      StereoHitContained<OffOrigin<InPhi0ImpactCurvBox> > hitInPhi0CurvBox(m_param_curlCurv);
      hitInPhi0CurvBox.setLocalOrigin(support);
      using RoadHoughBox = StereoHitContained<OffOrigin<InPhi0ImpactCurvBox> >::HoughBox;
 
      // Determine a precision that we expect to achieve at the fitted momentum
      // There certainly is some optimizsation potential here.
      // Spread in the impact parameter is made available here but is not activated yet.
      const float levelPrecision = 9.0;
      // Earlier version
      // const float levelPrecision = 10.5 - 0.24 * exp(-4.13118 * PrecisionUtil::convertRhoToPt(curv) + 2.74);
      const float phi0Precision = 3.1415 / std::pow(2.0, levelPrecision + 1.0);
      const float impactPrecision = 0.0 * std::sqrt(CDCWireHit::c_simpleDriftLengthVariance);
      const float curvPrecision = 0.15 / std::pow(2.0, levelPrecision);
 
      DiscreteCurv::Array curvBounds{{curv - curvPrecision, curv + curvPrecision}};
      ContinuousImpact::Array impactBounds{{ -impactPrecision, impactPrecision}};
      DiscretePhi0::Array phi0Bounds{{Vector2D::Phi(phi0 - phi0Precision), Vector2D::Phi(phi0 + phi0Precision)}};
      RoadHoughBox precisionPhi0CurvBox(DiscretePhi0::getRange(phi0Bounds),
                                        ContinuousImpact::getRange(impactBounds),
                                        DiscreteCurv::getRange(curvBounds));
 
      std::vector<WithSharedMark<CDCRLWireHit>> hitsInPrecisionBox;
 
      // Explicitly making a copy here to ensure that we do not change the node content
      for (WithSharedMark<CDCRLWireHit> markableRLWireHit : node) {
        // Skip marked hits
        if (markableRLWireHit.isMarked()) continue;
        Weight weight = hitInPhi0CurvBox(markableRLWireHit, &precisionPhi0CurvBox);
        if (not std::isnan(weight)) hitsInPrecisionBox.push_back(markableRLWireHit);
      }
 
      return hitsInPrecisionBox;
    }

◆ setAxialWireHits()

void setAxialWireHits ( std::vector< const CDCWireHit * > axialWireHits )

inline

Set the pool of all axial wire hits to be used in the postprocessing.

Definition at line 124 of file AxialLegendreLeafProcessor.h.

      {
        m_axialWireHits = std::move(axialWireHits);
      }

◆ skip()

bool skip ( const ANode * node )

inline

Decide if the node should be expanded further or marks an end point of the depth search.

Definition at line 69 of file AxialLegendreLeafProcessor.h.

      {
        bool tooLowWeight = not(node->getWeight() >= m_param_minWeight);
        bool tooHighCurvature = (static_cast<float>(node->template getLowerBound<DiscreteCurv>()) > m_param_maxCurv or
                                 - static_cast<float>(node->template getUpperBound<DiscreteCurv>()) > m_param_maxCurv);
        return tooLowWeight or tooHighCurvature;
      }

Member Data Documentation

◆ m_axialWireHits

std::vector<const CDCWireHit*> m_axialWireHits

private

Memory for the pool of axial wire hits to can be used in the post processing.

Definition at line 180 of file AxialLegendreLeafProcessor.h.

◆ m_curvResolution

std::function<double(double)> m_curvResolution

private

Memory for the freely defined curvature resolution function.

Definition at line 183 of file AxialLegendreLeafProcessor.h.

◆ m_nLeafs

int m_nLeafs = 0

Statistic: Number processed leaf.

Definition at line 144 of file AxialLegendreLeafProcessor.h.

◆ m_nNodes

int m_nNodes = 0

Statistic: Number received node.

Definition at line 138 of file AxialLegendreLeafProcessor.h.

◆ m_nSkippedNodes

int m_nSkippedNodes = 0

Statistic: Number of skipped nodes.

Definition at line 141 of file AxialLegendreLeafProcessor.h.

◆ m_param_curlCurv

double m_param_curlCurv = 0.018

private

Memory for the curvature of a curler in the CDC.

Definition at line 157 of file AxialLegendreLeafProcessor.h.

◆ m_param_curvResolution

std::string m_param_curvResolution = "const"

private

Memory for the name of the resolution function to be used. Valid values are 'none', 'const', 'basic', 'origin', 'offOrigin'.

Definition at line 166 of file AxialLegendreLeafProcessor.h.

◆ m_param_maxCurv

double m_param_maxCurv = NAN

private

Memory for the maximal curvature that should be searched in the current walk.

Definition at line 154 of file AxialLegendreLeafProcessor.h.

◆ m_param_maxLevel

int m_param_maxLevel = 1

private

Memory for the maximal level of the tree.

Definition at line 148 of file AxialLegendreLeafProcessor.h.

◆ m_param_minWeight

double m_param_minWeight = 0

private

Memory for the minimal weight threshold for following the children of a node.

Definition at line 151 of file AxialLegendreLeafProcessor.h.

◆ m_param_nRoadSearches

int m_param_nRoadSearches = 0

private

Memory for the number of repeated road searches.

Definition at line 160 of file AxialLegendreLeafProcessor.h.

◆ m_param_roadLevel

int m_param_roadLevel = 0

private

Memory for the tree node level which should be the source of hits for the road searches. Defaults to the top most node.

Definition at line 163 of file AxialLegendreLeafProcessor.h.

◆ m_tracks

std::vector<CDCTrack> m_tracks

private

Memory for found trajectories.

Definition at line 177 of file AxialLegendreLeafProcessor.h.

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

tracking/trackFindingCDC/hough/perigee/include/AxialLegendreLeafProcessor.h
tracking/trackFindingCDC/hough/perigee/include/AxialLegendreLeafProcessor.icc.h

Public Types

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Candidate

Constructor & Destructor Documentation

◆ AxialLegendreLeafProcessor()

Member Function Documentation

◆ beginWalk()

◆ clear()

◆ exposeParameters()

◆ getCandidates()

◆ getTracks()

◆ isLeaf()

◆ operator()()

◆ processLeaf()

◆ searchRoad()

◆ setAxialWireHits()

◆ skip()

Member Data Documentation

◆ m_axialWireHits

◆ m_curvResolution

◆ m_nLeafs

◆ m_nNodes

◆ m_nSkippedNodes

◆ m_param_curlCurv

◆ m_param_curvResolution

◆ m_param_maxCurv

◆ m_param_maxLevel

◆ m_param_minWeight

◆ m_param_nRoadSearches

◆ m_param_roadLevel

◆ m_tracks