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 >:

Public Types
using	WeightedRelationItem
	Shortcut class name for a weighted relation between a collector item and a collection item.
using	IOTypes
	Types that should be served to apply on invocation.
using	IOVectors
	Vector types that should be served to apply on invocation.

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 overridden in a derived class.
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 overridden in a derived class.
virtual void	apply (ToVector< AIOTypes > &... ioVectors)=0
	Main function executing the algorithm.
virtual void	apply (ToVector< AIOTypes > &... ioVectors)=0
	Main function executing the algorithm.
virtual std::string	getDescription ()
	Brief description of the purpose of the concrete 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
using	ToVector
	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.
virtual Weight	match (CDCTrack &collectorItem, const CDCRLWireHit &collectionItem)
	Override this function to implement your own matching algorithm between one collector and one collection items.
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).
void	writeDebugInformation ()
	Use the writeDebugInformation function of the quad tree to write the tree into a root file with a ascending number.

Private Attributes
double	m_param_checkForInWireBoundsFactor = 1.0
	Parameters 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_checkForB2BTracks = true
	Set to false to skip the B2B check (good for curlers).
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
	Flag to keep track whether initialization happened before.
bool	m_terminated
	Flag to keep track whether termination happened 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 Typedef Documentation

IOTypes

using IOTypes

inherited

Types that should be served to apply on invocation.

Definition at line 30 of file Findlet.h.

IOVectors

using IOVectors

inherited

Vector types that should be served to apply on invocation.

Definition at line 53 of file Findlet.h.

Super

template<class AQuadTree>

using Super = MatcherInterface<CDCTrack, CDCRLWireHit>

private

The parent class.

Definition at line 28 of file StereoHitTrackQuadTreeMatcher.h.

ToVector

using ToVector

protectedinherited

Short hand for ToRangeImpl.

Definition at line 49 of file Findlet.h.

WeightedRelationItem

using WeightedRelationItem

inherited

Shortcut class name for a weighted relation between a collector item and a collection item.

Definition at line 46 of file MatcherInterface.h.

Member Function Documentation

addProcessingSignalListener()

void addProcessingSignalListener ( ProcessingSignalListener * psl )

protectedinherited

Register a processing signal listener to be notified.

Definition at line 53 of file CompositeProcessingSignalListener.cc.

{
  m_subordinaryProcessingSignalListeners.push_back(psl);
}

apply() [1/2]

void apply ( std::vector< CDCTrack > & collectorItems, const std::vector< CDCRLWireHit > & collectionItems, std::vector< WeightedRelationItem > & weightedRelations )

inlineoverrideinherited

Main function: create weighted relations between collectors and collection items using the implemented functionality overridden in a derived class.

Definition at line 52 of file MatcherInterface.h.

      {
        for (ACollectorItem& collectorItem : collectorItems) {
          match(collectorItem, collectionItems, weightedRelations);
        }
 
        std::sort(weightedRelations.begin(), weightedRelations.end());
      }

apply() [2/2]

void apply ( std::vector< CDCTrack > & collectorItems, const std::vector< CDCRLWireHit > & collectionItems, std::vector< WeightedRelationItem > & weightedRelations )

inlineoverrideinherited

Main function: create weighted relations between collectors and collection items using the implemented functionality overridden in a derived class.

Definition at line 52 of file MatcherInterface.h.

      {
        for (ACollectorItem& collectorItem : collectorItems) {
          match(collectorItem, collectionItems, weightedRelations);
        }
 
        std::sort(weightedRelations.begin(), weightedRelations.end());
      }

beginEvent()

void beginEvent ( )

overrideinherited

Receive and dispatch signal for the start of a new event.

Definition at line 36 of file CompositeProcessingSignalListener.cc.

{
  Super::beginEvent();
  for (ProcessingSignalListener* psl : m_subordinaryProcessingSignalListeners) {
    psl->beginEvent();
  }
}

beginRun()

void beginRun ( )

overrideinherited

Receive and dispatch signal for the beginning of a new run.

Definition at line 33 of file CompositeProcessingSignalListener.cc.

{
  Super::beginRun();
  for (ProcessingSignalListener* psl : m_subordinaryProcessingSignalListeners) {
    psl->beginRun();
  }
}

endRun()

void endRun ( )

overrideinherited

Receive and dispatch signal for the end of the run.

Definition at line 39 of file CompositeProcessingSignalListener.cc.

{
  for (ProcessingSignalListener* psl : reversedRange(m_subordinaryProcessingSignalListeners)) {
    psl->endRun();
  }
  Super::endRun();
}

exposeParameters()

template<class AQuadTree>

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

overridevirtual

Expose the parameters to the module.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 32 of file StereoHitTrackQuadTreeMatcher.cc.

{
  Super::exposeParameters(moduleParamList, prefix);
 
  moduleParamList->addParameter(prefixed(prefix, "level"), m_param_quadTreeLevel,
                                "The number of levels for the quad tree search.",
                                m_param_quadTreeLevel);
 
  moduleParamList->addParameter(prefixed(prefix, "minimumNumberOfHits"), m_param_minimumNumberOfHits,
                                "The minimum number of hits in a quad tree bin to be called as result.",
                                m_param_minimumNumberOfHits);
 
  moduleParamList->addParameter(prefixed(prefix, "writeDebugInformation"), m_param_writeDebugInformation,
                                "Set to true to output debug information.",
                                m_param_writeDebugInformation);
 
  moduleParamList->addParameter(prefixed(prefix, "checkForB2BTracks"),
                                m_param_checkForB2BTracks,
                                "Set to false to skip the check for back-2-back tracks "
                                "(good for cosmics).",
                                m_param_checkForB2BTracks);
 
  moduleParamList->addParameter(prefixed(prefix, "checkForInWireBoundsFactor"),
                                m_param_checkForInWireBoundsFactor,
                                "Used to scale the CDC before checking "
                                "whether hits are in the CDC z bounds.",
                                m_param_checkForInWireBoundsFactor);
}

getDescription()

virtual std::string getDescription ( )

inlinevirtualinherited

Brief description of the purpose of the concrete findlet.

Definition at line 60 of file Findlet.h.

      {
        return "(no description)";
      }

getNProcessingSignalListener()

int getNProcessingSignalListener ( )

protectedinherited

Get the number of currently registered listeners.

Definition at line 56 of file CompositeProcessingSignalListener.cc.

{
  return m_subordinaryProcessingSignalListeners.size();
}

initialize()

template<class AQuadTree>

void initialize ( )

overridevirtual

Initialize the filter and the quad tree.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 64 of file StereoHitTrackQuadTreeMatcher.cc.

{
  Super::initialize();
 
  m_quadTreeInstance.setMaxLevel(m_param_quadTreeLevel);
  m_quadTreeInstance.initialize();
}

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.

      {
        return NAN;
      }

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.

      {
        for (const ACollectionItem& collectionItem : collectionItems) {
          Weight weight = match(collectorItem, collectionItem);
          relationsForCollector.emplace_back(&collectorItem, weight, &collectionItem);
        }
      };

match() [3/3]

template<class AQuadTree>

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

terminate()

template<class AQuadTree>

void terminate ( )

overridevirtual

Terminate the filter and the quad tree.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 74 of file StereoHitTrackQuadTreeMatcher.cc.

{
  Super::terminate();
 
  m_quadTreeInstance.raze();
}

writeDebugInformation()

template<class AQuadTree>

void writeDebugInformation ( )

private

Use the writeDebugInformation function of the quad tree to write the tree into a root file with a ascending number.

Definition at line 228 of file StereoHitTrackQuadTreeMatcher.cc.

{
  std::string outputFileName = "quadTreeContent_call_" + std::to_string(m_numberOfPassedDebugCalls) + ".root";
  m_quadTreeInstance.writeDebugInfoToFile(outputFileName);
 
  m_numberOfPassedDebugCalls++;
}

Member Data Documentation

m_initialized

bool m_initialized

privateinherited

Flag to keep track whether initialization happened before.

Definition at line 52 of file ProcessingSignalListener.h.

m_initializedAs

std::string m_initializedAs

privateinherited

Name of the type during initialisation.

Definition at line 58 of file ProcessingSignalListener.h.

m_numberOfPassedDebugCalls

template<class AQuadTree>

unsigned int m_numberOfPassedDebugCalls = 0

private

Store the number of passed calls to the debug function.

Definition at line 66 of file StereoHitTrackQuadTreeMatcher.h.

m_param_checkForB2BTracks

template<class AQuadTree>

bool m_param_checkForB2BTracks = true

private

Set to false to skip the B2B check (good for curlers).

Definition at line 61 of file StereoHitTrackQuadTreeMatcher.h.

m_param_checkForInWireBoundsFactor

template<class AQuadTree>

double m_param_checkForInWireBoundsFactor = 1.0

private

Parameters Set to false to skip the in-wire-bound check (good for second stage).

Definition at line 55 of file StereoHitTrackQuadTreeMatcher.h.

m_param_minimumNumberOfHits

template<class AQuadTree>

unsigned int m_param_minimumNumberOfHits = 5

private

Minimal number of hits a quad tree node must have to be called a found bin.

Definition at line 59 of file StereoHitTrackQuadTreeMatcher.h.

m_param_quadTreeLevel

template<class AQuadTree>

unsigned int m_param_quadTreeLevel = 7

private

Maximum level of the quad tree search.

Definition at line 57 of file StereoHitTrackQuadTreeMatcher.h.

m_param_writeDebugInformation

template<class AQuadTree>

bool m_param_writeDebugInformation = false

private

Set to true to output debug information.

Definition at line 63 of file StereoHitTrackQuadTreeMatcher.h.

m_quadTreeInstance

template<class AQuadTree>

AQuadTree m_quadTreeInstance

private

Quad tree instance.

Definition at line 69 of file StereoHitTrackQuadTreeMatcher.h.

m_subordinaryProcessingSignalListeners

std::vector<ProcessingSignalListener*> m_subordinaryProcessingSignalListeners

privateinherited

References to subordinary signal processing listener contained in this findlet.

Definition at line 60 of file CompositeProcessingSignalListener.h.

m_terminated

bool m_terminated

privateinherited

Flag to keep track whether termination happened before.

Definition at line 55 of file ProcessingSignalListener.h.

---

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