StereoHitTrackQuadTreeMatcher< AQuadTree > Class Template Reference

A matcher algorithm for using a stereo quad tree for matching rl tagged wire hits to tracks. More...

#include <StereoHitTrackQuadTreeMatcher.h>

Inheritance diagram for StereoHitTrackQuadTreeMatcher< AQuadTree >:

Collaboration diagram for StereoHitTrackQuadTreeMatcher< AQuadTree >:

Public Types
using	WeightedRelationItem = WeightedRelation< CDCTrack, const CDCRLWireHit >
	Shortcut class name for a weighted relation between a collector item and a collection item.
using	IOTypes = std::tuple< AIOTypes... >
	Types that should be served to apply on invokation.
using	IOVectors = std::tuple< std::vector< AIOTypes >... >
	Vector types that should be served to apply on invokation.

Public Member Functions
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) override
	Expose the parameters to the module.
void	initialize () override
	Initialize the filter and the quad tree.
void	terminate () override
	Terminate the filter and the quad tree.
void	apply (std::vector< CDCTrack > &collectorItems, const std::vector< CDCRLWireHit > &collectionItems, std::vector< WeightedRelationItem > &weightedRelations) override
	Main function: create weighted relations between collectors and collection items using the implemented functionality overriden in a derived class.
virtual void	apply (ToVector< AIOTypes > &... ioVectors)=0
	Main function executing the algorithm.
virtual std::string	getDescription ()
	Brief description of the purpose of the concret findlet.
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.

Protected Types
template<class T >
using	ToVector = typename ToVectorImpl< T >::Type
	Short hand for ToRangeImpl.

Protected Member Functions
virtual void	match (CDCTrack &collectorItem, const std::vector< CDCRLWireHit > &collectionItems, std::vector< WeightedRelationItem > &relationsForCollector)
	Override this function to implement your own matching algorithm between one collector and many collection items. More...
virtual Weight	match (CDCTrack &collectorItem, const CDCRLWireHit &collectionItem)
	Override this function to implement your own matching algorithm between one collector and one collection items. More...
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 = MatcherInterface< CDCTrack, CDCRLWireHit >
	The parent class.

Private Member Functions
void	match (CDCTrack &track, const std::vector< CDCRLWireHit > &rlWireHits, std::vector< Super::WeightedRelationItem > &relationsForCollector) override
	Create a QuadTree and fill with each unused stereo hit (to be exact: twice for each stereo hit - right and left). More...
void	writeDebugInformation ()
	Use the writeDebugInformation function of the quad tree to write the tree into a root file with a ascending number.

Private Attributes
bool	m_param_checkForB2BTracks = true
	Parameters Set to false to skip the B2B check (good for curlers).
double	m_param_checkForInWireBoundsFactor = 1.0
	Set to false to skip the in-wire-bound check (good for second stage).
unsigned int	m_param_quadTreeLevel = 7
	Maximum level of the quad tree search.
unsigned int	m_param_minimumNumberOfHits = 5
	Minimal number of hits a quad tree node must have to be called a found bin.
bool	m_param_writeDebugInformation = false
	Set to true to output debug information.
unsigned int	m_numberOfPassedDebugCalls = 0
	Store the number of passed calls to the debug function.
AQuadTree	m_quadTreeInstance
	Quad tree instance.
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 happend before.
bool	m_terminated = false
	Flag to keep track whether termination happend before.
std::string	m_initializedAs
	Name of the type during initialisation.

Detailed Description

template<class AQuadTree>
class Belle2::TrackFindingCDC::StereoHitTrackQuadTreeMatcher< AQuadTree >

A matcher algorithm for using a stereo quad tree for matching rl tagged wire hits to tracks.

Definition at line 25 of file StereoHitTrackQuadTreeMatcher.h.

Member Function Documentation

match() [1/3]

virtual Weight match ( CDCTrack &  collectorItem, const CDCRLWireHit &  collectionItem  )

inlineprotectedvirtualinherited

Override this function to implement your own matching algorithm between one collector and one collection items.

If you override this function, you just have to return a weight - the rest of the logic is handled by the MatcherInterface class.

Definition at line 82 of file MatcherInterface.h.

match() [2/3]

virtual void match ( CDCTrack &  collectorItem, const std::vector< CDCRLWireHit > &  collectionItems, std::vector< WeightedRelationItem > &  relationsForCollector  )

inlineprotectedvirtualinherited

Override this function to implement your own matching algorithm between one collector and many collection items.

A reason to override this instead of the other match function could be, if you want to apply some sort of caching for each collector item.

Definition at line 68 of file MatcherInterface.h.

match() [3/3]

void match ( CDCTrack &  track, const std::vector< CDCRLWireHit > &  rlWireHits, std::vector< Super::WeightedRelationItem > &  relationsForCollector  )

overrideprivate

Create a QuadTree and fill with each unused stereo hit (to be exact: twice for each stereo hit - right and left).

The QuadTree has two dimensions: inverse slope in z-direction and z0. Each bin with a high number of items (= stereo hits) in it is stored. Later, the one node with the highest number of items in it is taken and each hit is assigned to the track.

Definition at line 82 of file StereoHitTrackQuadTreeMatcher.cc.

{
  // TODO: Extract this into smaller steps
  // TODO: Split the filtering from the rest.
  // This means this method would output WeightedRelations based on the quad tree decision and a second filter step
  // can be applied on these weighted relations
 
  // Reconstruct the hits to the track
  const CDCTrajectory2D& trajectory2D = track.getStartTrajectory3D().getTrajectory2D();
  const bool isCurler = trajectory2D.isCurler();
 
  using CDCRecoHitWithRLPointer = std::pair<CDCRecoHit3D, const CDCRLWireHit*>;
  std::vector<CDCRecoHitWithRLPointer> recoHits;
  recoHits.reserve(rlWireHits.size() + track.size());
 
  /*
   * Use the given trajectory to reconstruct the 2d hits in the vector in z direction
   * to match the trajectory perfectly. Then add the newly created reconstructed 3D hit to the given list.
   */
  for (const CDCRLWireHit& rlWireHit : rlWireHits) {
    if (rlWireHit.getWireHit().getAutomatonCell().hasTakenFlag()) continue;
 
    const CDCWire& wire = rlWireHit.getWire();
    const WireLine& wireLine = wire.getWireLine();
    double signedDriftLength = rlWireHit.getSignedRefDriftLength();
    for (const Vector3D& recoPos3D : trajectory2D.reconstructBoth3D(wireLine, signedDriftLength)) {
      // Skip hits out of CDC
      if (not wire.isInCellZBounds(recoPos3D, m_param_checkForInWireBoundsFactor)) {
        continue;
      }
 
      // If the track is a curler, shift all perpS values to positive ones.
      // Else do not use this hit if m_param_checkForB2BTracks is enabled.
      double perpS = trajectory2D.calcArcLength2D(recoPos3D.xy());
      if (perpS < 0) {
        if (isCurler) {
          perpS += trajectory2D.getArcLength2DPeriod();
        } else if (m_param_checkForB2BTracks) {
          continue;
        }
      }
      recoHits.emplace_back(CDCRecoHit3D(rlWireHit, recoPos3D, perpS), &rlWireHit);
    }
  }
 
  // Also add already found stereo hits of the track
  for (const CDCRecoHit3D& recoHit : track) {
    if (not recoHit.isAxial()) {
      recoHit.getWireHit().getAutomatonCell().setAssignedFlag();
      const CDCRLWireHit& rlWireHit = recoHit.getRLWireHit();
      recoHits.emplace_back(recoHit, &rlWireHit);
    }
  }
 
  // Do the tree finding
  m_quadTreeInstance.seed(recoHits);
 
  if (m_param_writeDebugInformation) {
    writeDebugInformation();
  }
 
  const auto& foundStereoHitsWithNode = m_quadTreeInstance.findSingleBest(m_param_minimumNumberOfHits);
  m_quadTreeInstance.fell();
 
  if (foundStereoHitsWithNode.size() != 1) {
    return;
  }
 
  // There is the possibility that we have added one cdc hits twice (as left and right one). We search for those cases here:
  auto foundStereoHits = foundStereoHitsWithNode[0].second;
  const auto& node = foundStereoHitsWithNode[0].first;
 
  if (m_param_writeDebugInformation) {
    std::vector<CDCRecoHit3D> allHits;
    std::vector<CDCRecoHit3D> foundHits;
    // Turn vector of pairs into vector of first items
    for (const CDCRecoHitWithRLPointer& recoHitWithRL : recoHits) {
      const CDCRecoHit3D& recoHit3D = recoHitWithRL.first;
      allHits.push_back(recoHit3D);
    }
    for (const CDCRecoHitWithRLPointer& recoHitWithRL : foundStereoHits) {
      const CDCRecoHit3D& recoHit3D = recoHitWithRL.first;
      foundHits.push_back(recoHit3D);
    }
    m_quadTreeInstance.drawDebugPlot(allHits, foundHits, node);
  }
 
  // Remove all assigned hits, which where already found before (and do not need to be added again)
  const auto& isAssignedHit = [](const CDCRecoHitWithRLPointer & recoHitWithRLPointer) {
    const CDCRecoHit3D& recoHit3D = recoHitWithRLPointer.first;
    const auto& automatonCell = recoHit3D.getWireHit().getAutomatonCell();
    return automatonCell.hasAssignedFlag();
  };
 
  foundStereoHits.erase(std::remove_if(foundStereoHits.begin(),
                                       foundStereoHits.end(),
                                       isAssignedHit),
                        foundStereoHits.end());
 
  // Sort the found stereo hits by same CDCHit and smaller distance to the node
  auto sortByHitAndNodeCenterDistance = [node](const CDCRecoHitWithRLPointer & lhs,
  const CDCRecoHitWithRLPointer & rhs) {
 
 
    const CDCRecoHit3D& rhsRecoHit = rhs.first;
    const CDCRecoHit3D& lhsRecoHit = lhs.first;
 
    const CDCWireHit& rhsWireHit = rhsRecoHit.getWireHit();
    const CDCWireHit& lhsWireHit = lhsRecoHit.getWireHit();
 
    if (lhsWireHit < rhsWireHit) {
      return true;
    } else if (rhsWireHit < lhsWireHit)  {
      return false;
    } else {
      return AQuadTree::DecisionAlgorithm::BoxAlgorithm::compareDistances(node, lhsRecoHit, rhsRecoHit); //returns true if lhs < rhs
    }
  };
 
  const auto& sameHitComparer = [](const CDCRecoHitWithRLPointer & lhs,
  const CDCRecoHitWithRLPointer & rhs) {
    const CDCRecoHit3D& rhsRecoHit = rhs.first;
    const CDCRecoHit3D& lhsRecoHit = lhs.first;
 
    return lhsRecoHit.getWireHit() == rhsRecoHit.getWireHit();
  };
 
  std::sort(foundStereoHits.begin(),
            foundStereoHits.end(),
            sortByHitAndNodeCenterDistance);
 
  // If the same hit is added as right and left hypothesis, do only use the one with the smaller distance to the node.
  foundStereoHits.erase(std::unique(foundStereoHits.begin(),
                                    foundStereoHits.end(),
                                    sameHitComparer),
                        foundStereoHits.end());
 
  // Add the found stereo hits to the relation vector. In the moment, all hits get the same weight (may change later).
  for (const CDCRecoHitWithRLPointer& recoHitWithRLPointer : foundStereoHits) {
    const CDCRLWireHit* rlWireHit = recoHitWithRLPointer.second;
    relationsForCollector.emplace_back(&track, foundStereoHits.size(), rlWireHit);
  }
}

---

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

• tracking/trackFindingCDC/collectors/matchers/include/StereoHitTrackQuadTreeMatcher.h
• tracking/trackFindingCDC/collectors/matchers/src/StereoHitTrackQuadTreeMatcher.cc