AxialTrackMerger Class Reference

Findlet implementing the merging of axial tracks found in the legendre tree search. More...

#include <AxialTrackMerger.h>

Inheritance diagram for AxialTrackMerger:

Collaboration diagram for AxialTrackMerger:

Public Types
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
std::string	getDescription () final
	Short description of the findlet.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) final
	Expose the parameters to a module.
void	apply (std::vector< CDCTrack > &axialTracks, const std::vector< const CDCWireHit * > &axialWireHits) final
	Merge tracks together. Allows for axial hits to be added as it may see fit.
template<class ACDCTracks >
WithWeight< MayBePtr< CDCTrack > >	calculateBestTrackToMerge (CDCTrack &track, ACDCTracks &tracks)
	Determine the best track for merging with the candidate track.
virtual void	exposeParameters (ModuleParamList *moduleParamList __attribute__((unused)), const std::string &prefix __attribute__((unused)))
	Forward prefixed parameters of this findlet to the module parameter list.
virtual void	apply (ToVector< AIOTypes > &... ioVectors)=0
	Main function executing the algorithm.
void	initialize () override
	Receive and dispatch signal before the start of the event processing.
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.
void	terminate () override
	Receive and dispatch Signal for termination of the event processing.

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

Protected Member Functions
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 = Findlet< CDCTrack &, const CDCWireHit *const >
	Type of the base class.

Private Member Functions
void	doTracksMerging (std::vector< CDCTrack > &axialTracks, const std::vector< const CDCWireHit * > &allAxialWireHits)
	The track finding often finds two curling tracks, originating from the same particle. More...

Static Private Member Functions
template<class ACDCTracks >
static WithWeight< MayBePtr< CDCTrack > >	calculateBestTrackToMerge (CDCTrack &track, ACDCTracks &tracks)
	Searches for the best candidate to merge this track to. More...
static double	doTracksFitTogether (CDCTrack &track1, CDCTrack &track2)
	Fits the hit content of both tracks in a common fit repeated with an annealing schedule removing far away hits. More...
static void	removeStrangeHits (double factor, std::vector< const CDCWireHit * > &wireHits, CDCTrajectory2D &trajectory)
	Remove all hits that are further than factor * driftlength waay from the trajectory. More...
static void	mergeTracks (CDCTrack &track1, CDCTrack &track2, const std::vector< const CDCWireHit * > &allAxialWireHits)
	Function to merge two track candidates. More...

Private Attributes
double	m_param_minFitProb = 0.85
	Parameter : Minimal fit probability of the common fit of two tracks to be eligible for merging.
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

Findlet implementing the merging of axial tracks found in the legendre tree search.

Definition at line 40 of file AxialTrackMerger.h.

Member Function Documentation

calculateBestTrackToMerge()

static WithWeight<MayBePtr<CDCTrack> > calculateBestTrackToMerge ( CDCTrack &  track, ACDCTracks &  tracks  )

staticprivate

Searches for the best candidate to merge this track to.

Parameters

track	track for which we try to find merging partner
tracks	search range of tracks

Returns

a pointer to the best fit candidate including a fit probability

Return values

<tt>{nullptr,0}<

doTracksFitTogether()

double doTracksFitTogether ( CDCTrack &  track1, CDCTrack &  track2  )

staticprivate

Fits the hit content of both tracks in a common fit repeated with an annealing schedule removing far away hits.

Returns

Some measure of fit probability

Definition at line 109 of file AxialTrackMerger.cc.

{
  // First check whether most of the hits from the tracks lie in the backward direction
  // even if though track is not curling -> tracks should not be merged
  const CDCTrajectory3D& trajectory3D1 = track1.getStartTrajectory3D();
  const CDCTrajectory3D& trajectory3D2 = track2.getStartTrajectory3D();
 
  const Vector2D& phi0Vec1 = trajectory3D1.getFlightDirection3DAtSupport().xy();
  const Vector2D& phi0Vec2 = trajectory3D2.getFlightDirection3DAtSupport().xy();
 
  int fbVote12 = 0;
  int fbVote21 = 0;
 
  for (const CDCRecoHit3D& recoHit3D : track1) {
    EForwardBackward fbInfo = phi0Vec2.isForwardOrBackwardOf(recoHit3D.getRecoPos2D());
    if (not isValid(fbInfo)) continue;
    fbVote12 += fbInfo;
  }
 
  for (const CDCRecoHit3D& recoHit3D : track2) {
    EForwardBackward fbInfo = phi0Vec1.isForwardOrBackwardOf(recoHit3D.getRecoPos2D());
    if (not isValid(fbInfo)) continue;
    fbVote21 += fbInfo;
  }
 
  if (not trajectory3D1.isCurler() and fbVote12 < 0) return NAN;
  if (not trajectory3D2.isCurler() and fbVote21 < 0) return NAN;
 
  // Build common hit list by copying the wire hits into one large list
  // We use the wire hits here as we do not want them to bring
  // their "old" reconstructed position when fitting.
  std::vector<const CDCWireHit*> combinedWireHits;
  combinedWireHits.reserve(track1.size() + track2.size());
  for (const CDCRecoHit3D& hit : track1) {
    // cppcheck-suppress useStlAlgorithm
    combinedWireHits.push_back(&(hit.getWireHit()));
  }
  for (const CDCRecoHit3D& hit : track2) {
    // cppcheck-suppress useStlAlgorithm
    combinedWireHits.push_back(&(hit.getWireHit()));
  }
 
  // Sorting is done via pointer addresses (!!).
  // This is not very stable and also not very meaningful (in terms of ordering in the track),
  // but it does the job for unique.
  // (the ordering is still outwards though since the wire hits are ordered like that in continuous memory)
  std::sort(combinedWireHits.begin(), combinedWireHits.end());
  erase_unique(combinedWireHits);
 
  // Calculate track parameters
  CDCTrajectory2D commonTrajectory2D;
  const CDCKarimakiFitter& fitter = CDCKarimakiFitter::getNoDriftVarianceFitter();
 
  // Approach the best fit
  commonTrajectory2D = fitter.fit(combinedWireHits);
  removeStrangeHits(5, combinedWireHits, commonTrajectory2D);
  commonTrajectory2D = fitter.fit(combinedWireHits);
  removeStrangeHits(3, combinedWireHits, commonTrajectory2D);
  commonTrajectory2D = fitter.fit(combinedWireHits);
  removeStrangeHits(1, combinedWireHits, commonTrajectory2D);
  commonTrajectory2D = fitter.fit(combinedWireHits);
  removeStrangeHits(1, combinedWireHits, commonTrajectory2D);
  commonTrajectory2D = fitter.fit(combinedWireHits);
 
  // Dismiss this possibility if the hit list size after all the removing of hits is even smaller
  // than the two lists before or if the list is too small
  if (combinedWireHits.size() <= std::max(track1.size(), track2.size())
      or combinedWireHits.size() < 15) {
    return NAN;
  }
 
  return commonTrajectory2D.getPValue();
}

doTracksMerging()

void doTracksMerging ( std::vector< CDCTrack > &  axialTracks, const std::vector< const CDCWireHit * > &  allAxialWireHits  )

private

The track finding often finds two curling tracks, originating from the same particle.

This function merges them.

Definition at line 70 of file AxialTrackMerger.cc.

mergeTracks()

void mergeTracks ( CDCTrack &  track1, CDCTrack &  track2, const std::vector< const CDCWireHit * > &  allAxialWireHits  )

staticprivate

Function to merge two track candidates.

The hits of track2 are deleted and transfered to track1 and the track1 is resorted. The method also applys some postprocessing and splits the track1 in case it appears to contain two back-to-back arms,

Definition at line 196 of file AxialTrackMerger.cc.

removeStrangeHits()

void removeStrangeHits ( double  factor, std::vector< const CDCWireHit * > &  wireHits, CDCTrajectory2D &  trajectory  )

staticprivate

Remove all hits that are further than factor * driftlength waay from the trajectory.

Parameters

factor

gives a number how far the hit is allowed to be.

Definition at line 183 of file AxialTrackMerger.cc.

---

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

• tracking/trackFindingCDC/findlets/minimal/include/AxialTrackMerger.h
• tracking/trackFindingCDC/findlets/minimal/src/AxialTrackMerger.cc