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::function< double(double)>	m_curvResolution
	Memory for the freely defined curvature resolution function.

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.

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

template<class ANode>

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()

template<class ANode>

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 {}

Member Function Documentation

◆ beginWalk()

template<class ANode>

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()

template<class ANode>

void clear ( )

inline

Clear the found candidates.

Definition at line 117 of file AxialLegendreLeafProcessor.h.

118 {

119 m_tracks.clear();

120 m_axialWireHits.clear();

121 }

◆ exposeParameters()

template<class ANode>

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()

template<class ANode>

std::vector< typename AxialLegendreLeafProcessor< ANode >::Candidate > getCandidates ( ) const

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()

template<class ANode>

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

inline

Getter for the tracks.

Definition at line 111 of file AxialLegendreLeafProcessor.h.

112 {

113 return m_tracks;

114 }

◆ isLeaf()

template<class ANode>

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()()

template<class ANode>

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()

template<class ANode>

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()

template<class ANode>

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 = M_PI / 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()

template<class ANode>

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.

125 {

126 m_axialWireHits = std::move(axialWireHits);

127 }

◆ skip()

template<class ANode>

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;
      }

◆ m_nNodes

template<class ANode>

int m_nNodes = 0

Statistic: Number received node.

Definition at line 138 of file AxialLegendreLeafProcessor.h.

template<class ANode>

std::vector<CDCTrack> m_tracks

private

Memory for found trajectories.

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