CDCMCTrackStore Class Reference

Class to organize and present the monte carlo hit information. More...

#include <CDCMCTrackStore.h>

Public Types
using	CDCHitVector = std::vector<const CDCHit*>
	Type for an ordered sequence of pointers to the CDCHit.

Public Member Functions
	CDCMCTrackStore ()=default
	Default constructor - for cppcheck.
	CDCMCTrackStore (CDCMCTrackStore &)=delete
	Singleton: Delete copy constructor and assignment operator.
CDCMCTrackStore &	operator= (const CDCMCTrackStore &)=delete
	Operator =.
void	clear ()
	Clear all Monte Carlo hits.
void	fill (const CDCMCMap *ptrMCMap, const CDCSimHitLookUp *ptrSimHitLookUp)
	Fill the store with the tracks from Monte Carlo information.
const std::map< ITrackType, Belle2::TrackFindingCDC::CDCMCTrackStore::CDCHitVector > &	getMCTracksByMCParticleIdx () const
	Getter for the stored Monte Carlo tracks ordered by their Monte Carlo Id.
const std::map< ITrackType, std::vector< Belle2::TrackFindingCDC::CDCMCTrackStore::CDCHitVector > > &	getMCSegmentsByMCParticleIdx () const
	Getter for the stored Monte Carlo segments ordered by their Monte Carlo Id.
TrackingUtilities::Index	getInTrackId (const CDCHit *ptrHit) const
	Getter for the index of the hit within its track.
TrackingUtilities::Index	getInTrackSegmentId (const CDCHit *ptrHit) const
	Getter for the index of the segment of the hit within its track.
TrackingUtilities::Index	getNPassedSuperLayers (const CDCHit *ptrHit) const
	Getter for the number of super layers traversed until this hit.
TrackingUtilities::Index	getNLoops (const CDCHit *ptrHit) const
	Getter for the number of traversed loops until this hit.

Static Public Member Functions
static const CDCMCTrackStore &	getInstance ()
	Getter for the singletone instance.

Private Member Functions
void	fillMCTracks ()
	Construct the tracks by grouping the hits by the mc particle id and sorted them for the FlightTime of the related CDCSimHits.
void	fillMCSegments ()
	Construct the segments by dividing the mc tracks in to disconnected parts and sorted them for the FlightTime of the related CDCSimHits.
void	arrangeMCTrack (CDCHitVector &mcTrack) const
	Sorts the given track for the FlightTime of the associated CDCSimHits.
void	fillInTrackId ()
	Fill the look up table for the in track index of each hit.
void	fillInTrackSegmentId ()
	Fill the look up table for the in track segment index of each hit.
void	fillNLoopsAndNPassedSuperLayers ()
	Fill the look up table of the number of traversed super layers until each hit.
bool	changedSuperLayer (const CDCHitVector &mcSegment, const CDCHitVector &nextMCSegment) const
	Helper function to decide whether the number of passed superlayers changed from one segment to the next.

Private Attributes
const CDCMCMap *	m_ptrMCMap
	Reference to the MC map of the current event.
const CDCSimHitLookUp *	m_ptrSimHitLookUp
	Reference to the CDCSimHit look up for additional information about related primary sim hits.
std::map< ITrackType, CDCHitVector >	m_mcTracksByMCParticleIdx
	The memory for the tracks made of CDCHits sorted for the time of flight and associated to the Monte Carlo particle id.
std::map< ITrackType, std::vector< CDCHitVector > >	m_mcSegmentsByMCParticleIdx
	The memory for the segments made of CDCHits sorted for the time of flight and associated to the Monte Carlo particle id.
std::map< const CDCHit *, int >	m_inTrackIds
	Look up table for index of the hit within its track.
std::map< const CDCHit *, int >	m_inTrackSegmentIds
	Look up table for index of the segment of the hits within their respective tracks.
std::map< const CDCHit *, int >	m_nPassedSuperLayers
	Look up table for the number of super layers the particle traversed before making the individual hit.
std::map< const CDCHit *, int >	m_nLoops
	Look up table for the number of loops the particle traversed before making the individual hit.

Detailed Description

Class to organize and present the monte carlo hit information.

Definition at line 28 of file CDCMCTrackStore.h.

Member Typedef Documentation

CDCHitVector

using CDCHitVector = std::vector<const CDCHit*>

Type for an ordered sequence of pointers to the CDCHit.

Definition at line 32 of file CDCMCTrackStore.h.

Member Function Documentation

arrangeMCTrack()

void arrangeMCTrack ( CDCHitVector & mcTrack ) const

private

Sorts the given track for the FlightTime of the associated CDCSimHits.

Sort with NaN as high.

Definition at line 238 of file CDCMCTrackStore.cc.

{
  if (not m_ptrMCMap) {
    B2WARNING("CDCMCMap not set. Cannot sort track");
    return;
  }
 
  const CDCSimHitLookUp& simHitLookUp = *m_ptrSimHitLookUp;
 
  std::stable_sort(mcTrack.begin(), mcTrack.end(),
  [&simHitLookUp](const CDCHit * ptrHit, const CDCHit * ptrOtherHit) -> bool {
 
    const CDCSimHit* ptrSimHit = simHitLookUp.getClosestPrimarySimHit(ptrHit);
    const CDCSimHit* ptrOtherSimHit = simHitLookUp.getClosestPrimarySimHit(ptrOtherHit);
 
    if (not ptrSimHit)
    {
      B2FATAL("No CDCSimHit for CDCHit");
    }
 
    if (not ptrOtherSimHit)
    {
      B2FATAL("No CDCSimHit for CDCHit");
    }
 
    double secondaryFlightTime =  ptrSimHit->getFlightTime();
    double otherSecondaryFlightTime =  ptrOtherSimHit->getFlightTime();

    return (secondaryFlightTime < std::fmin(INFINITY, otherSecondaryFlightTime));
  });
 
}

changedSuperLayer()

bool changedSuperLayer ( const CDCHitVector & mcSegment, const CDCHitVector & nextMCSegment ) const

private

Helper function to decide whether the number of passed superlayers changed from one segment to the next.

The number of passed superlayers is easily detectable in a switch of the superlayer number form one segment to the next. An exception to this rule happens were particles are curling back exiting the super layer 0 and reentering the CDC super layer 0. There is no change of super layer number in this case since consecutive segments (only looking at the CDC) have the super layer number 0. Since this case would screw the evaluation of segment pair or triple selection we have to treat it separately.

Definition at line 344 of file CDCMCTrackStore.cc.

{
  const CDCSimHitLookUp& simHitLookUp = *m_ptrSimHitLookUp;
  const CDCHit* ptrHit = mcSegment.front();
  const CDCHit* ptrNextHit = nextMCSegment.front();
 
  assert(ptrHit);
  assert(ptrNextHit);
 
  const CDCHit& hit = *ptrHit;
  const CDCHit& nextHit = *ptrNextHit;
 
  if (hit.getISuperLayer() != nextHit.getISuperLayer()) {
    return true;
  } else if (hit.getISuperLayer() == 0) {
    const CDCSimHit* ptrSimHit = simHitLookUp.getClosestPrimarySimHit(ptrHit);
    const CDCSimHit* ptrNextSimHit = simHitLookUp.getClosestPrimarySimHit(ptrNextHit);
 
    Vector3D pos(ptrSimHit->getPosTrack());
    Vector3D mom(ptrSimHit->getMomentum());
    Vector3D nextMom(ptrNextSimHit->getMomentum());
    Vector3D nextPos(ptrNextSimHit->getPosTrack());
 
    if (pos.dotXY(nextPos) < 0) return true;
    if ((nextPos - pos).dotXY(nextMom) < 0) return true;
    if ((nextPos - pos).dotXY(mom) < 0) return true;
 
    // TODO introduce a smarter check here
    return false;
  } else {
    return false;
  }
}

clear()

void clear

(

)

Clear all Monte Carlo hits.

Definition at line 36 of file CDCMCTrackStore.cc.

{
 
  B2DEBUG(29, "In CDCMCTrackStore::clear()");
 
  m_ptrMCMap = nullptr;
 
  m_mcTracksByMCParticleIdx.clear();
  m_mcSegmentsByMCParticleIdx.clear();
 
  m_inTrackIds.clear();
  m_inTrackSegmentIds.clear();
  m_nPassedSuperLayers.clear();
  m_nLoops.clear();
 
}

fill()

void fill	(	const CDCMCMap *	ptrMCMap,
		const CDCSimHitLookUp *	ptrSimHitLookUp )

Fill the store with the tracks from Monte Carlo information.

It uses the CDCMCMap to construct the Monte Carlo tracks.

Definition at line 55 of file CDCMCTrackStore.cc.

{
 
  B2DEBUG(29, "In CDCMCTrackStore::fill()");
  clear();
 
  m_ptrMCMap = ptrMCMap;
  m_ptrSimHitLookUp = ptrSimHitLookUp;
 
  // Put the right hits into the right track
  fillMCTracks();
 
  // Split the tracks into segments
  fillMCSegments();
 
  // Assign the reverse mapping from CDCHits to position in track
  fillInTrackId();
 
  // Assigns the reverse mapping from CDCHits to segment ids
  fillInTrackSegmentId();
 
  // Assigns the reverse mapping from CDCHits to the number of already traversed superlayers
  fillNLoopsAndNPassedSuperLayers();
 
  B2DEBUG(28, "m_mcTracksByMCParticleIdx.size(): " << m_mcTracksByMCParticleIdx.size());
  B2DEBUG(28, "m_mcSegmentsByMCParticleIdx.size(): " << m_mcSegmentsByMCParticleIdx.size());
 
  B2DEBUG(28, "m_inTrackIds.size(): " << m_inTrackIds.size());
  B2DEBUG(28, "m_inTrackSegmentIds.size() " << m_inTrackSegmentIds.size());
  B2DEBUG(28, "m_nPassedSuperLayers.size(): " << m_nPassedSuperLayers.size());
  B2DEBUG(28, "m_nLoops.size(): " << m_nLoops.size());
 
}

fillInTrackId()

void fillInTrackId ( )

private

Fill the look up table for the in track index of each hit.

Definition at line 277 of file CDCMCTrackStore.cc.

{
 
  for (const std::pair<ITrackType, CDCHitVector> mcTrackAndMCParticleIdx : getMCTracksByMCParticleIdx()) {
 
    const CDCHitVector& mcTrack = mcTrackAndMCParticleIdx.second;
 
    //Fill the in track ids
    int iHit = -1;
    for (const CDCHit* ptrHit : mcTrack) {
      ++iHit;
      m_inTrackIds[ptrHit] = iHit;
    }
  }
 
}

fillInTrackSegmentId()

void fillInTrackSegmentId ( )

private

Fill the look up table for the in track segment index of each hit.

Definition at line 294 of file CDCMCTrackStore.cc.

{
  for (const std::pair<ITrackType, std::vector<CDCHitVector> > mcSegmentsAndMCParticleIdx : getMCSegmentsByMCParticleIdx()) {
    const std::vector<CDCHitVector>& mcSegments = mcSegmentsAndMCParticleIdx.second;
 
    int iSegment = -1;
    for (const CDCHitVector&   mcSegment : mcSegments) {
      ++iSegment;
      for (const CDCHit* ptrHit : mcSegment) {
 
        m_inTrackSegmentIds[ptrHit] = iSegment;
      }
    }
  }
 
}

fillMCSegments()

void fillMCSegments ( )

private

Construct the segments by dividing the mc tracks in to disconnected parts and sorted them for the FlightTime of the related CDCSimHits.

Definition at line 124 of file CDCMCTrackStore.cc.

{
  for (std::pair<const ITrackType, CDCHitVector>& mcTrackAndMCParticleIdx : m_mcTracksByMCParticleIdx) {
 
    ITrackType mcParticleIdx = mcTrackAndMCParticleIdx.first;
    CDCHitVector& mcTrack = mcTrackAndMCParticleIdx.second;
 
    if (mcTrack.empty()) continue;
    std::vector<CDCHitVector>& mcSegments = m_mcSegmentsByMCParticleIdx[mcParticleIdx];
    mcSegments.clear();
 
    // Split track into runs in the same superlayer
    auto superLayerRanges = adjacent_groupby(mcTrack.begin(), mcTrack.end(), [](const CDCHit * hit) {
      return hit->getISuperLayer();
    });
 
    std::vector<CDCHitVector> superLayerRuns;
    for (const auto& superLayerRange : superLayerRanges) {
      superLayerRuns.push_back({superLayerRange.begin(), superLayerRange.end()});
    }
 
    std::vector<std::vector<CDCHitVector>::iterator> smallSuperLayerRuns;
    for (auto itSuperLayerRun = superLayerRuns.begin();
         itSuperLayerRun != superLayerRuns.end();
         ++itSuperLayerRun) {
      if (itSuperLayerRun->size() < 3) smallSuperLayerRuns.push_back(itSuperLayerRun);
    }
 
    // Merge small run to an adjacent run
    for (auto itSuperLayerRun : smallSuperLayerRuns) {
      ISuperLayer iSL = itSuperLayerRun->front()->getISuperLayer();
 
      // Look in both directions to adopt the hits in this small runs
      auto itSuperLayerRunBefore = superLayerRuns.end();
      int hitDistanceBefore = INT_MAX;
      if (std::distance(superLayerRuns.begin(), itSuperLayerRun) >= 2) {
        itSuperLayerRunBefore = itSuperLayerRun - 2;
        if (itSuperLayerRunBefore->front()->getISuperLayer() == iSL) {
          hitDistanceBefore = (itSuperLayerRunBefore - 1)->size();
        } else {
          itSuperLayerRunBefore = superLayerRuns.end();
        }
      }
 
      auto itSuperLayerRunAfter = superLayerRuns.end();
      int hitDistanceAfter = INT_MAX;
      if (std::distance(itSuperLayerRun, superLayerRuns.end()) > 2) {
        itSuperLayerRunAfter = itSuperLayerRun + 2;
        if (itSuperLayerRunAfter->front()->getISuperLayer() == iSL) {
          hitDistanceAfter = (itSuperLayerRunAfter + 1)->size();
        } else {
          itSuperLayerRunAfter = superLayerRuns.end();
        }
      }
 
      auto itMergeSuperLayerRun = superLayerRuns.end();
      bool mergeBefore = false;
      if (hitDistanceBefore < hitDistanceAfter) {
        itMergeSuperLayerRun = itSuperLayerRunBefore;
        mergeBefore = true;
      } else {
        itMergeSuperLayerRun = itSuperLayerRunAfter;
        mergeBefore = false;
      }
 
      if (itMergeSuperLayerRun == superLayerRuns.end()) continue;
      else if (mergeBefore) {
        itMergeSuperLayerRun->insert(itMergeSuperLayerRun->end(), itSuperLayerRun->begin(), itSuperLayerRun->end());
        itSuperLayerRun->clear();
      } else {
        itMergeSuperLayerRun->insert(itMergeSuperLayerRun->begin(), itSuperLayerRun->begin(), itSuperLayerRun->end());
        itSuperLayerRun->clear();
      }
    }
 
    // Remove empty small runs
    erase_remove_if(superLayerRuns, Size() == 0u);
 
    // Concat the runs that are now in the same superlayer
    auto mergeSameSuperLayer = [](CDCHitVector & lhs, CDCHitVector & rhs) {
      if (lhs.empty() or rhs.empty()) return true;
      if (lhs.front()->getISuperLayer() != rhs.front()->getISuperLayer()) return false;
      lhs.insert(lhs.end(), rhs.begin(), rhs.end());
      rhs.clear();
      return true;
    };
    erase_unique(superLayerRuns, mergeSameSuperLayer);
 
    // Now analyse the runs in turn and break them in the connected segments
    for (const CDCHitVector& superLayerRun : superLayerRuns) {
      const CDCWireTopology& wireTopology = CDCWireTopology::getInstance();
      auto areNeighbors = [&wireTopology](const CDCHit * lhs, const CDCHit * rhs) {
        WireID lhsWireID(lhs->getISuperLayer(), lhs->getILayer(), lhs->getIWire());
        WireID rhsWireID(rhs->getISuperLayer(), rhs->getILayer(), rhs->getIWire());
 
        return (wireTopology.arePrimaryNeighbors(lhsWireID, rhsWireID) or
                wireTopology.areSeconaryNeighbors(lhsWireID, rhsWireID) or
                lhsWireID == rhsWireID);
      };
 
      auto segmentRanges = unique_ranges(superLayerRun.begin(), superLayerRun.end(), areNeighbors);
 
      for (const ConstVectorRange<const CDCHit*>& segmentRange : segmentRanges) {
        mcSegments.emplace_back(segmentRange.begin(), segmentRange.end());
      }
    } // end for superLayerRuns
 
    // Lets sort them along for the time of flight.
    for (CDCHitVector& mcSegment : mcSegments) {
      arrangeMCTrack(mcSegment);
    }
  } // End for mc track
}

fillMCTracks()

void fillMCTracks ( )

private

Construct the tracks by grouping the hits by the mc particle id and sorted them for the FlightTime of the related CDCSimHits.

Definition at line 90 of file CDCMCTrackStore.cc.

{
  if (not m_ptrMCMap) {
    B2WARNING("CDCMCMap not set. Cannot create tracks");
    return;
  }
 
  const CDCMCMap& mcMap = *m_ptrMCMap;
 
  for (const auto& relation : mcMap.getHitsByMCParticle()) {
 
    const MCParticle* ptrMCParticle = std::get<const MCParticle* const>(relation);
    const CDCHit* ptrHit = std::get<const CDCHit*>(relation);
 
    if (not mcMap.isBackground(ptrHit) and ptrMCParticle) {
 
      ITrackType mcParticleIdx = ptrMCParticle->getArrayIndex();
      //Append hit to its own track
      m_mcTracksByMCParticleIdx[mcParticleIdx].push_back(ptrHit);
    }
  }
 
 
  //Sort the tracks along the time of flight
  for (std::pair<const ITrackType, CDCHitVector>& mcTrackAndMCParticleIdx : m_mcTracksByMCParticleIdx) {
 
    //int mcParticleIdx = mcTrackAndMCParticleIdx.first;
    CDCHitVector& mcTrack = mcTrackAndMCParticleIdx.second;
    arrangeMCTrack(mcTrack);
 
  }
 
}

fillNLoopsAndNPassedSuperLayers()

void fillNLoopsAndNPassedSuperLayers ( )

private

Fill the look up table of the number of traversed super layers until each hit.

Definition at line 311 of file CDCMCTrackStore.cc.

{
 
  for (const std::pair<ITrackType, std::vector<CDCHitVector> > mcSegmentsAndMCParticleIdx : getMCSegmentsByMCParticleIdx()) {
    const std::vector<CDCHitVector>& mcSegments = mcSegmentsAndMCParticleIdx.second;
 
    const CDCHitVector* ptrLastMCSegment = nullptr;
    int nPassedSuperLayers = 0;
    int nLoops = 0;
 
    for (const CDCHitVector& mcSegment : mcSegments) {
      if (ptrLastMCSegment and changedSuperLayer(*ptrLastMCSegment, mcSegment)) {
        ++nPassedSuperLayers;
 
        // Increase the superlayer number if the track leaves the CDC for the inner volume.
        // Feel free to do something smarter here.
        if (ptrLastMCSegment->front()->getISuperLayer() == 0 and
            mcSegment.front()->getISuperLayer() == 0) {
          ++nLoops;
        }
      }
 
      for (const CDCHit* ptrHit : mcSegment) {
        m_nPassedSuperLayers[ptrHit] = nPassedSuperLayers;
        m_nLoops[ptrHit] = nLoops;
      }
 
      ptrLastMCSegment = &mcSegment;
 
    }
  }
}

getInstance()

const CDCMCTrackStore & getInstance ( )

static

Getter for the singletone instance.

Definition at line 30 of file CDCMCTrackStore.cc.

{
  return CDCMCManager::getMCTrackStore();
}

getInTrackId()

Index getInTrackId

(

const CDCHit *

ptrHit

)

const

Getter for the index of the hit within its track.

Definition at line 379 of file CDCMCTrackStore.cc.

{
 
  auto itFoundHit = m_inTrackIds.find(ptrHit);
  return itFoundHit == m_inTrackIds.end() ? c_InvalidIndex : itFoundHit->second;
 
}

getInTrackSegmentId()

Index getInTrackSegmentId

(

const CDCHit *

ptrHit

)

const

Getter for the index of the segment of the hit within its track.

Definition at line 389 of file CDCMCTrackStore.cc.

{
 
  auto itFoundHit = m_inTrackSegmentIds.find(ptrHit);
  return itFoundHit == m_inTrackSegmentIds.end() ? c_InvalidIndex : itFoundHit->second;
 
}

getMCSegmentsByMCParticleIdx()

const std::map< ITrackType, std::vector< Belle2::TrackFindingCDC::CDCMCTrackStore::CDCHitVector > > & getMCSegmentsByMCParticleIdx ( ) const

inline

Getter for the stored Monte Carlo segments ordered by their Monte Carlo Id.

Definition at line 64 of file CDCMCTrackStore.h.

      { return  m_mcSegmentsByMCParticleIdx;}

getMCTracksByMCParticleIdx()

const std::map< ITrackType, Belle2::TrackFindingCDC::CDCMCTrackStore::CDCHitVector > & getMCTracksByMCParticleIdx ( ) const

inline

Getter for the stored Monte Carlo tracks ordered by their Monte Carlo Id.

Definition at line 60 of file CDCMCTrackStore.h.

      { return  m_mcTracksByMCParticleIdx;}

getNLoops()

Index getNLoops

(

const CDCHit *

ptrHit

)

const

Getter for the number of traversed loops until this hit.

Definition at line 406 of file CDCMCTrackStore.cc.

{
 
  auto itFoundHit = m_nLoops.find(ptrHit);
  return itFoundHit == m_nLoops.end() ? c_InvalidIndex : itFoundHit->second;
 
}

getNPassedSuperLayers()

Index getNPassedSuperLayers

(

const CDCHit *

ptrHit

)

const

Getter for the number of super layers traversed until this hit.

Definition at line 398 of file CDCMCTrackStore.cc.

{
 
  auto itFoundHit = m_nPassedSuperLayers.find(ptrHit);
  return itFoundHit == m_nPassedSuperLayers.end() ? c_InvalidIndex : itFoundHit->second;
 
}

Member Data Documentation

m_inTrackIds

std::map<const CDCHit*, int> m_inTrackIds

private

Look up table for index of the hit within its track.

Definition at line 122 of file CDCMCTrackStore.h.

m_inTrackSegmentIds

std::map<const CDCHit*, int> m_inTrackSegmentIds

private

Look up table for index of the segment of the hits within their respective tracks.

Definition at line 125 of file CDCMCTrackStore.h.

m_mcSegmentsByMCParticleIdx

std::map<ITrackType, std::vector<CDCHitVector> > m_mcSegmentsByMCParticleIdx

private

The memory for the segments made of CDCHits sorted for the time of flight and associated to the Monte Carlo particle id.

Definition at line 119 of file CDCMCTrackStore.h.

m_mcTracksByMCParticleIdx

std::map<ITrackType, CDCHitVector> m_mcTracksByMCParticleIdx

private

The memory for the tracks made of CDCHits sorted for the time of flight and associated to the Monte Carlo particle id.

Definition at line 116 of file CDCMCTrackStore.h.

m_nLoops

std::map<const CDCHit*, int> m_nLoops

private

Look up table for the number of loops the particle traversed before making the individual hit.

Definition at line 131 of file CDCMCTrackStore.h.

m_nPassedSuperLayers

std::map<const CDCHit*, int> m_nPassedSuperLayers

private

Look up table for the number of super layers the particle traversed before making the individual hit.

Definition at line 128 of file CDCMCTrackStore.h.

m_ptrMCMap

const CDCMCMap* m_ptrMCMap

private

Reference to the MC map of the current event.

Definition at line 110 of file CDCMCTrackStore.h.

m_ptrSimHitLookUp

const CDCSimHitLookUp* m_ptrSimHitLookUp

private

Reference to the CDCSimHit look up for additional information about related primary sim hits.

Definition at line 113 of file CDCMCTrackStore.h.

---

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

• tracking/trackFindingCDC/mclookup/include/CDCMCTrackStore.h
• tracking/trackFindingCDC/mclookup/src/CDCMCTrackStore.cc