CDCMCSegment2DLookUp Class Reference

Specialisation of the lookup for the truth values of two dimensional segments. More...

#include <CDCMCSegment2DLookUp.h>

Inheritance diagram for CDCMCSegment2DLookUp:

Public Member Functions
	CDCMCSegment2DLookUp ()=default
	Default constructor, needs to be public for initialization in CDCMCManager.
	CDCMCSegment2DLookUp (CDCMCSegment2DLookUp &)=delete
	Singleton: Delete copy constructor and assignment operator,.
CDCMCSegment2DLookUp &	operator= (const CDCMCSegment2DLookUp &)=delete
	Operator =.
void	clear ()
	Clears all Monte Carlo information left from the last event.
MCTrackIdPurityPair	getHighestPurity (const TrackingUtilities::CDCSegment2D &hits) const
	Get the track id with the highest corresponding purity.
ITrackType	getMCTrackId (const TrackingUtilities::CDCSegment2D *ptrHits) const
	Getter for the Monte Carlo track id matched to this collection of hits.
int	getCorrectRLVote (const TrackingUtilities::CDCSegment2D *ptrHits) const
	Getter for the difference of correct versus incorrect right left passage information.
double	getRLPurity (const TrackingUtilities::CDCSegment2D *ptrHits) const
	Getter for the right left passge purity which respects the forward backward reconstruction.
const MCParticle *	getMCParticle (const TrackingUtilities::CDCSegment2D *ptrHits) const
	Getter for the mc particle matched to this collection of hits.
const CDCHit *	getFirstHit (const TrackingUtilities::CDCSegment2D *ptrHits) const
	Getter for the first hit in the collection of hits which has the Monte Carlo track id matched to this collection of hits.
const CDCHit *	getLastHit (const TrackingUtilities::CDCSegment2D *ptrHits) const
	Getter for the last hit in the collection of hits which has the Monte Carlo track id matched to this collection of hits.
TrackingUtilities::Index	getFirstInTrackId (const TrackingUtilities::CDCSegment2D *ptrHits) const
	Getter for in track id for the first hit in the collection of hits which has the Monte Carlo track id matched to this collection of hits.
TrackingUtilities::Index	getLastInTrackId (const TrackingUtilities::CDCSegment2D *ptrHits) const
	Getter for in track id for the last hit in the collection of hits which has the Monte Carlo track id matched to this collection of hits.
TrackingUtilities::Index	getFirstInTrackSegmentId (const TrackingUtilities::CDCSegment2D *ptrHits) const
	Getter for in track collection of hits id for the first hit in the collection of hits which has the Monte Carlo track id matched to this collection of hits.
TrackingUtilities::Index	getLastInTrackSegmentId (const TrackingUtilities::CDCSegment2D *ptrHits) const
	Getter for in track collection of hits id for the last hit in the collection of hits which has the Monte Carlo track id matched to this collection of hits.
TrackingUtilities::Index	getFirstNPassedSuperLayers (const TrackingUtilities::CDCSegment2D *ptrHits) const
	Getter for number of passed superlayer till the first hit the collection of hits which has the Monte Carlo track id matched to this collection of hits.
TrackingUtilities::Index	getLastNPassedSuperLayers (const TrackingUtilities::CDCSegment2D *ptrHits) const
	Getter for number of passed superlayer till the last hit the collection of hits which has the Monte Carlo track id matched to this collection of hits.
TrackingUtilities::Index	getFirstNLoops (const TrackingUtilities::CDCSegment2D *ptrHits) const
	Getter for number of loops till the first hit the collection of hits which has the Monte Carlo track id matched to this collection of hits.
TrackingUtilities::Index	getLastNLoops (const TrackingUtilities::CDCSegment2D *ptrHits) const
	Getter for number of loops till the last hit the collection of hits which has the Monte Carlo track id matched to this collection of hits.
TrackingUtilities::EForwardBackward	isForwardOrBackwardToMCTrack (const TrackingUtilities::CDCSegment2D *ptrHits) const
	Returns the orientation of the collection of hits relative to its matched track.
TrackingUtilities::EForwardBackward	areAlignedInMCTrack (const TrackingUtilities::CDCSegment2D *ptrFromHits, const TrackingUtilities::CDCSegment2D *ptrToHits) const
	Returns if the second collection of hits follows the first collection of hits in their common Monte Carlo track.
TrackingUtilities::EForwardBackward	areAlignedInMCTrackWithRLCheck (const TrackingUtilities::CDCSegment2D *ptrFromHits, const TrackingUtilities::CDCSegment2D *ptrToHits) const
	Returns if the second collection of hits follows the first collection of hits in their common Monte Carlo track.
TrackingUtilities::CDCTrajectory3D	getTrajectory3D (const TrackingUtilities::CDCSegment2D *ptrHits) const
	Returns the trajectory of the collection of hits.

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

Private Member Functions
std::map< ITrackType, size_t >	getHitCountByMCTrackId (const TrackingUtilities::CDCSegment2D &hits) const
	Fill a map with the number of hits for each track id contained in the given hit range.

Private Attributes
float	m_minimalMatchPurity
	Threshold for the purity that must be exceeded to be considered as a match.
float	m_minimalRLPurity
	Threshold for the correct fraction of right left passage information to be considered a match.

Detailed Description

Specialisation of the lookup for the truth values of two dimensional segments.

Definition at line 25 of file CDCMCSegment2DLookUp.h.

Member Function Documentation

areAlignedInMCTrack()

TrackingUtilities::EForwardBackward areAlignedInMCTrack ( const TrackingUtilities::CDCSegment2D * ptrFromHits, const TrackingUtilities::CDCSegment2D * ptrToHits ) const

inherited

Returns if the second collection of hits follows the first collection of hits in their common Monte Carlo track.

• Returns EForwardBackward::c_Invalid if the collection of hits is not matched in the same Monte Carlo track.
• Returns EForwardBackward::c_Forward if both collections of hits are coaligned with the Monte Carlo track and the second collection of hits comes after the first.
• Returns EForwardBackward::c_Backward if both collections of hits are anticoaligned with the Monte Carlo track and the second collection of hits comes after the first in the reversed sense.

Check if the segments are in the same track

Definition at line 171 of file CDCMCHitCollectionLookUp.icc.h.

    {
      ITrackType fromMCTrackId = getMCTrackId(ptrFromHits);
      if (fromMCTrackId == INVALID_ITRACK) return TrackingUtilities::EForwardBackward::c_Invalid;
 
      ITrackType toMCTrackId = getMCTrackId(ptrToHits);
      if (toMCTrackId == INVALID_ITRACK) return TrackingUtilities::EForwardBackward::c_Invalid;
 
      if (fromMCTrackId != toMCTrackId) return TrackingUtilities::EForwardBackward::c_Invalid;
 
      // Check if the segments are meaningful on their own
      TrackingUtilities::EForwardBackward fromFBInfo = isForwardOrBackwardToMCTrack(ptrFromHits);
      if (fromFBInfo == TrackingUtilities::EForwardBackward::c_Invalid) return TrackingUtilities::EForwardBackward::c_Invalid;
 
      TrackingUtilities::EForwardBackward toFBInfo = isForwardOrBackwardToMCTrack(ptrToHits);
      if (toFBInfo == TrackingUtilities::EForwardBackward::c_Invalid) return TrackingUtilities::EForwardBackward::c_Invalid;
 
      if (fromFBInfo != toFBInfo) return TrackingUtilities::EForwardBackward::c_Invalid;
 
      {
        // Now check if hits are aligned within their common track
        // Index firstNPassedSuperLayersOfFromHits = getFirstNPassedSuperLayers(ptrFromHits);
        TrackingUtilities::Index lastNPassedSuperLayersOfFromHits = getLastNPassedSuperLayers(ptrFromHits);
        // if (firstNPassedSuperLayersOfFromHits == c_InvalidIndex) return
        // EForwardBackward::c_Invalid;
        if (lastNPassedSuperLayersOfFromHits == TrackingUtilities::c_InvalidIndex) return TrackingUtilities::EForwardBackward::c_Invalid;
 
        TrackingUtilities::Index firstNPassedSuperLayersOfToHits = getFirstNPassedSuperLayers(ptrToHits);
        // Index lastNPassedSuperLayersOfToHits = getLastNPassedSuperLayers(ptrToHits);
        if (firstNPassedSuperLayersOfToHits == TrackingUtilities::c_InvalidIndex) return TrackingUtilities::EForwardBackward::c_Invalid;
        // if (lastNPassedSuperLayersOfToHits == c_InvalidIndex) return EForwardBackward::c_Invalid;
 
        if (lastNPassedSuperLayersOfFromHits < firstNPassedSuperLayersOfToHits) {
          if (fromFBInfo == TrackingUtilities::EForwardBackward::c_Forward and
              toFBInfo == TrackingUtilities::EForwardBackward::c_Forward) {
            return TrackingUtilities::EForwardBackward::c_Forward;
          } else {
            return TrackingUtilities::EForwardBackward::c_Invalid;
          }
        } else if (firstNPassedSuperLayersOfToHits < lastNPassedSuperLayersOfFromHits) {
          if (fromFBInfo == TrackingUtilities::EForwardBackward::c_Backward and
              toFBInfo == TrackingUtilities::EForwardBackward::c_Backward) {
            return TrackingUtilities::EForwardBackward::c_Backward;
          } else {
            return TrackingUtilities::EForwardBackward::c_Invalid;
          }
        }
      }
 
      {
        // Now we are in the same true segment with both segments
        // Index firstInTrackSegmentIdOfFromHits = getFirstInTrackSegmentId(ptrFromHits);
        TrackingUtilities::Index lastInTrackSegmentIdOfFromHits = getLastInTrackSegmentId(ptrFromHits);
        // if (firstInTrackSegmentIdOfFromHits == c_InvalidIndex) return
        // EForwardBackward::c_Invalid;
        if (lastInTrackSegmentIdOfFromHits == TrackingUtilities::c_InvalidIndex) return TrackingUtilities::EForwardBackward::c_Invalid;
 
        TrackingUtilities::Index firstInTrackSegmentIdOfToHits = getFirstInTrackSegmentId(ptrToHits);
        // Index lastInTrackSegmentIdOfToHits = getLastInTrackSegmentId(ptrToHits);
        if (firstInTrackSegmentIdOfToHits == TrackingUtilities::c_InvalidIndex) return TrackingUtilities::EForwardBackward::c_Invalid;
        // if (lastInTrackSegmentIdOfToHits == c_InvalidIndex) return EForwardBackward::c_Invalid;
 
        if (lastInTrackSegmentIdOfFromHits < firstInTrackSegmentIdOfToHits) {
          if (fromFBInfo == TrackingUtilities::EForwardBackward::c_Forward and
              toFBInfo == TrackingUtilities::EForwardBackward::c_Forward) {
            return TrackingUtilities::EForwardBackward::c_Forward;
          } else {
            return TrackingUtilities::EForwardBackward::c_Invalid;
          }
        } else if (firstInTrackSegmentIdOfToHits < lastInTrackSegmentIdOfFromHits) {
          // Test if to segment lies before in the mc track
          // Hence the whole pair of segments is reverse to the track direction of flight
          if (fromFBInfo == TrackingUtilities::EForwardBackward::c_Backward and
              toFBInfo == TrackingUtilities::EForwardBackward::c_Backward) {
            return TrackingUtilities::EForwardBackward::c_Backward;
          } else {
            return TrackingUtilities::EForwardBackward::c_Invalid;
          }
        }
      }
 
      {
        // Now we are in the same true segment with both of the hits
        // Index firstInTrackIdOfFromHits = getFirstInTrackId(ptrFromHits);
        TrackingUtilities::Index lastInTrackIdOfFromHits = getLastInTrackId(ptrFromHits);
        // if (firstInTrackIdOfFromHits == c_InvalidIndex) return EForwardBackward::c_Invalid;
        if (lastInTrackIdOfFromHits == TrackingUtilities::c_InvalidIndex) return TrackingUtilities::EForwardBackward::c_Invalid;
 
        TrackingUtilities::Index firstInTrackIdOfToHits = getFirstInTrackId(ptrToHits);
        // Index lastInTrackIdOfToHits = getLastInTrackId(ptrToHits);
        if (firstInTrackIdOfToHits == TrackingUtilities::c_InvalidIndex) return TrackingUtilities::EForwardBackward::c_Invalid;
        // if (lastInTrackIdOfToHits == c_InvalidIndex) return EForwardBackward::c_Invalid;
 
        // Relax conditions somewhat such that segments may overlap at the borders.
 
        if (lastInTrackIdOfFromHits - 1 < firstInTrackIdOfToHits + 1) {
          if (fromFBInfo == TrackingUtilities::EForwardBackward::c_Forward and
              toFBInfo == TrackingUtilities::EForwardBackward::c_Forward) {
            return TrackingUtilities::EForwardBackward::c_Forward;
          }
        }
 
        if (firstInTrackIdOfToHits - 1 < lastInTrackIdOfFromHits + 1) {
          if (fromFBInfo == TrackingUtilities::EForwardBackward::c_Backward and
              toFBInfo == TrackingUtilities::EForwardBackward::c_Backward) {
            return TrackingUtilities::EForwardBackward::c_Backward;
          }
        }
      }
      // FIXME: Handle intertwined hits that are not cleanly consecutive along the track?
      return TrackingUtilities::EForwardBackward::c_Invalid;
    }

areAlignedInMCTrackWithRLCheck()

TrackingUtilities::EForwardBackward areAlignedInMCTrackWithRLCheck ( const TrackingUtilities::CDCSegment2D * ptrFromHits, const TrackingUtilities::CDCSegment2D * ptrToHits ) const

inherited

Returns if the second collection of hits follows the first collection of hits in their common Monte Carlo track.

Also checks that the majority of the right left passage information agrees with the forward backward information

Definition at line 179 of file CDCMCHitCollectionLookUp.icc.h.

    {
      TrackingUtilities::EForwardBackward result = areAlignedInMCTrack(ptrFromHits, ptrToHits);
      if (result == TrackingUtilities::EForwardBackward::c_Invalid) return result;
 
      int fromCorrectRLVote = getCorrectRLVote(ptrFromHits);
      int toCorrectRLVote = getCorrectRLVote(ptrToHits);
 
      if (result == TrackingUtilities::EForwardBackward::c_Backward) {
        fromCorrectRLVote = -fromCorrectRLVote;
        toCorrectRLVote = -toCorrectRLVote;
      }
 
      int fromNCorrectRL = (fromCorrectRLVote + ptrFromHits->size()) / 2;
      int toNCorrectRL = (toCorrectRLVote + ptrToHits->size()) / 2;
 
      float fromRLPurity = 1.0 * fromNCorrectRL / ptrFromHits->size();
      float toRLPurity = 1.0 * toNCorrectRL / ptrToHits->size();
 
      // Require the minimal rl purity and also at least 2.5 correct hits
      // (cut chosen to require all correct in single hit triplet segment)
      if (fromRLPurity > m_minimalRLPurity and toRLPurity > m_minimalRLPurity and
          fromNCorrectRL > 2.5 and toNCorrectRL > 2.5) {
        return result;
      }
 
      return TrackingUtilities::EForwardBackward::c_Invalid;
    }

clear()

void clear ( )

inherited

Clears all Monte Carlo information left from the last event.

Definition at line 77 of file CDCMCHitCollectionLookUp.icc.h.

    {
      B2DEBUG(25, "Clearing CDCMCHitCollectionLookUp<ACDCHitCollection>");
    }

getCorrectRLVote()

int getCorrectRLVote ( const TrackingUtilities::CDCSegment2D * ptrHits ) const

inherited

Getter for the difference of correct versus incorrect right left passage information.

Definition at line 98 of file CDCMCHitCollectionLookUp.icc.h.

    {
      if (not ptrHits) return INVALID_ITRACK;
      const ACDCHitCollection& hits = *ptrHits;
      MCTrackIdPurityPair mcTrackIdAndPurity = getHighestPurity(hits);
      if (mcTrackIdAndPurity.getPurity() >= m_minimalMatchPurity) {
        return mcTrackIdAndPurity.getCorrectRLVote();
      } else {
        return 0;
      }
    }

getFirstHit()

const CDCHit * getFirstHit ( const TrackingUtilities::CDCSegment2D * ptrHits ) const

inherited

Getter for the first hit in the collection of hits which has the Monte Carlo track id matched to this collection of hits.

Definition at line 108 of file CDCMCHitCollectionLookUp.icc.h.

    {
      if (not ptrHits) return nullptr;
      const ACDCHitCollection& hits = *ptrHits;
 
      ITrackType mcTrackId = getMCTrackId(ptrHits);
      if (mcTrackId == INVALID_ITRACK) return nullptr;
 
      const CDCMCHitLookUp& mcHitLookUp = CDCMCHitLookUp::getInstance();
 
      for (const CDCHit* hit : hits) {
        if (mcTrackId == mcHitLookUp.getMCTrackId(hit)) return hit;
      }
      return nullptr;
    }

getFirstInTrackId()

TrackingUtilities::Index getFirstInTrackId ( const TrackingUtilities::CDCSegment2D * ptrHits ) const

inlineinherited

Getter for in track id for the first hit in the collection of hits which has the Monte Carlo track id matched to this collection of hits.

Definition at line 116 of file CDCMCHitCollectionLookUp.h.

      { return CDCMCHitLookUp::getInstance().getInTrackId(getFirstHit(ptrHits)); }

getFirstInTrackSegmentId()

TrackingUtilities::Index getFirstInTrackSegmentId ( const TrackingUtilities::CDCSegment2D * ptrHits ) const

inlineinherited

Getter for in track collection of hits id for the first hit in the collection of hits which has the Monte Carlo track id matched to this collection of hits.

Definition at line 126 of file CDCMCHitCollectionLookUp.h.

      { return CDCMCHitLookUp::getInstance().getInTrackSegmentId(getFirstHit(ptrHits)); }

getFirstNLoops()

TrackingUtilities::Index getFirstNLoops ( const TrackingUtilities::CDCSegment2D * ptrHits ) const

inlineinherited

Getter for number of loops till the first hit the collection of hits which has the Monte Carlo track id matched to this collection of hits.

Definition at line 144 of file CDCMCHitCollectionLookUp.h.

      { return CDCMCHitLookUp::getInstance().getNLoops(getFirstHit(ptrHits)); }

getFirstNPassedSuperLayers()

TrackingUtilities::Index getFirstNPassedSuperLayers ( const TrackingUtilities::CDCSegment2D * ptrHits ) const

inlineinherited

Getter for number of passed superlayer till the first hit the collection of hits which has the Monte Carlo track id matched to this collection of hits.

Definition at line 136 of file CDCMCHitCollectionLookUp.h.

      { return CDCMCHitLookUp::getInstance().getNPassedSuperLayers(getFirstHit(ptrHits)); }

getHighestPurity()

MCTrackIdPurityPair getHighestPurity ( const TrackingUtilities::CDCSegment2D & hits ) const

inherited

Get the track id with the highest corresponding purity.

Definition at line 88 of file CDCMCHitCollectionLookUp.icc.h.

    {
      std::map<ITrackType, size_t> hitCountByMCTrackId = getHitCountByMCTrackId(hits);
 
      size_t nHits = 0;
      std::pair<ITrackType, size_t> highestHitCountMCTrackId(0, 0);
      static_cast<void>(std::max_element(hitCountByMCTrackId.begin(), hitCountByMCTrackId.end(),
                                         TrackingUtilities::LessOf<TrackingUtilities::Second>()));
 
      for (const auto& hitCountForMCTrackId : hitCountByMCTrackId) {
 
        nHits += hitCountForMCTrackId.second;
 
        if (highestHitCountMCTrackId.second < hitCountForMCTrackId.second) {
          highestHitCountMCTrackId = hitCountForMCTrackId;
        }
      }
 
      const CDCMCHitLookUp& mcHitLookUp = CDCMCHitLookUp::getInstance();
 
      int correctRLVote = 0;
      for (const auto& recoHit : hits) {
        const CDCHit* hit = recoHit;
        TrackingUtilities::ERightLeft mcRLInfo = mcHitLookUp.getRLInfo(hit);
        TrackingUtilities::ERightLeft rlInfo = recoHit.getRLInfo();
        if (rlInfo == mcRLInfo) {
          ++correctRLVote;
        } else {
          --correctRLVote;
        }
      }
 
      const float purity = static_cast<float>(highestHitCountMCTrackId.second) / nHits;
      return MCTrackIdPurityPair(highestHitCountMCTrackId.first, purity, correctRLVote);
    }

getHitCountByMCTrackId()

std::map< ITrackType, size_t > getHitCountByMCTrackId ( const TrackingUtilities::CDCSegment2D & hits ) const

privateinherited

Fill a map with the number of hits for each track id contained in the given hit range.

Definition at line 84 of file CDCMCHitCollectionLookUp.icc.h.

    {
      const CDCMCHitLookUp& mcHitLookUp = CDCMCHitLookUp::getInstance();
 
      std::map<ITrackType, size_t> hitCountByMCTrackId;
      for (const CDCHit* ptrHit : hits) {
        ITrackType mcTrackId = mcHitLookUp.getMCTrackId(ptrHit);
        // cppcheck-suppress stlFindInsert
        if (hitCountByMCTrackId.count(mcTrackId) == 0) hitCountByMCTrackId[mcTrackId] = 0;
        ++(hitCountByMCTrackId[mcTrackId]);
      }
      return hitCountByMCTrackId;
    }

getInstance()

const CDCMCSegment2DLookUp & getInstance ( )

static

Getter for the singletone instance.

Definition at line 22 of file CDCMCSegment2DLookUp.cc.

{
  return CDCMCManager::getMCSegment2DLookUp();
}

getLastHit()

const CDCHit * getLastHit ( const TrackingUtilities::CDCSegment2D * ptrHits ) const

inherited

Getter for the last hit in the collection of hits which has the Monte Carlo track id matched to this collection of hits.

Definition at line 111 of file CDCMCHitCollectionLookUp.icc.h.

    {
 
      if (not ptrHits) return nullptr;
      const ACDCHitCollection& hits = *ptrHits;
 
      ITrackType mcTrackId = getMCTrackId(ptrHits);
      if (mcTrackId == INVALID_ITRACK) return nullptr;
 
      const CDCMCHitLookUp& mcHitLookUp = CDCMCHitLookUp::getInstance();
 
      for (const CDCHit* hit : TrackingUtilities::reversedRange(hits)) {
        if (mcTrackId == mcHitLookUp.getMCTrackId(hit)) return hit;
      }
      return nullptr;
    }

getLastInTrackId()

TrackingUtilities::Index getLastInTrackId ( const TrackingUtilities::CDCSegment2D * ptrHits ) const

inlineinherited

Getter for in track id for the last hit in the collection of hits which has the Monte Carlo track id matched to this collection of hits.

Definition at line 120 of file CDCMCHitCollectionLookUp.h.

      { return CDCMCHitLookUp::getInstance().getInTrackId(getLastHit(ptrHits)); }

getLastInTrackSegmentId()

TrackingUtilities::Index getLastInTrackSegmentId ( const TrackingUtilities::CDCSegment2D * ptrHits ) const

inlineinherited

Getter for in track collection of hits id for the last hit in the collection of hits which has the Monte Carlo track id matched to this collection of hits.

Definition at line 130 of file CDCMCHitCollectionLookUp.h.

      { return CDCMCHitLookUp::getInstance().getInTrackSegmentId(getLastHit(ptrHits)); }

getLastNLoops()

TrackingUtilities::Index getLastNLoops ( const TrackingUtilities::CDCSegment2D * ptrHits ) const

inlineinherited

Getter for number of loops till the last hit the collection of hits which has the Monte Carlo track id matched to this collection of hits.

Definition at line 148 of file CDCMCHitCollectionLookUp.h.

      { return CDCMCHitLookUp::getInstance().getNLoops(getLastHit(ptrHits)); }

getLastNPassedSuperLayers()

TrackingUtilities::Index getLastNPassedSuperLayers ( const TrackingUtilities::CDCSegment2D * ptrHits ) const

inlineinherited

Getter for number of passed superlayer till the last hit the collection of hits which has the Monte Carlo track id matched to this collection of hits.

Definition at line 140 of file CDCMCHitCollectionLookUp.h.

      { return CDCMCHitLookUp::getInstance().getNPassedSuperLayers(getLastHit(ptrHits)); }

getMCParticle()

const MCParticle * getMCParticle ( const TrackingUtilities::CDCSegment2D * ptrHits ) const

inherited

Getter for the mc particle matched to this collection of hits.

Definition at line 104 of file CDCMCHitCollectionLookUp.icc.h.

    {
      const CDCHit* ptrHit = getFirstHit(ptrHits);
      const CDCMCHitLookUp& mcHitLookUp = CDCMCHitLookUp::getInstance();
      return mcHitLookUp.getMCParticle(ptrHit);
    }

getMCTrackId()

ITrackType getMCTrackId ( const TrackingUtilities::CDCSegment2D * ptrHits ) const

inherited

Getter for the Monte Carlo track id matched to this collection of hits.

On first encounter of a collection of hits this evaluates the purities for the contained track ids. The match is valid if the highest purity exceeds the s_minimalMatchPurity threshold. In case the highest purity is to low to result will be INVALID_ITRACK. To result is stored in member map object for fast look up for repeated calls.

Definition at line 95 of file CDCMCHitCollectionLookUp.icc.h.

    {
      if (not ptrHits) return INVALID_ITRACK;
      const ACDCHitCollection& hits = *ptrHits;
      MCTrackIdPurityPair mcTrackIdAndPurity = getHighestPurity(hits);
      if (mcTrackIdAndPurity.getPurity() >= m_minimalMatchPurity) {
        return mcTrackIdAndPurity.getMCTrackId();
      } else {
        return INVALID_ITRACK;
      }
    }

getRLPurity()

double getRLPurity ( const TrackingUtilities::CDCSegment2D * ptrHits ) const

inherited

Getter for the right left passge purity which respects the forward backward reconstruction.

Definition at line 101 of file CDCMCHitCollectionLookUp.icc.h.

    {
      TrackingUtilities::EForwardBackward fbInfo = isForwardOrBackwardToMCTrack(ptrHits);
      if (fbInfo == TrackingUtilities::EForwardBackward::c_Invalid) return NAN;
 
      int correctRLVote = getCorrectRLVote(ptrHits);
 
      if (fbInfo == TrackingUtilities::EForwardBackward::c_Backward) {
        correctRLVote = -correctRLVote;
      }
 
      int nCorrectRL = (correctRLVote + ptrHits->size()) / 2;
      float rlPurity = 1.0 * nCorrectRL / ptrHits->size();
      return rlPurity;
    }

getTrajectory3D()

TrackingUtilities::CDCTrajectory3D getTrajectory3D ( const TrackingUtilities::CDCSegment2D * ptrHits ) const

inherited

Returns the trajectory of the collection of hits.

Definition at line 183 of file CDCMCHitCollectionLookUp.icc.h.

    {
      if (not ptrHits) {
        B2WARNING("Segment is nullptr. Could not get fit.");
        return TrackingUtilities::CDCTrajectory3D();
      }
 
      const CDCMCHitLookUp& mcHitLookUp = CDCMCHitLookUp::getInstance();
 
      const CDCHit* ptrFirstHit = getFirstHit(ptrHits);
      const CDCSimHit* ptrPrimarySimHit = mcHitLookUp.getClosestPrimarySimHit(ptrFirstHit);
 
      if (not ptrPrimarySimHit) {
        // If there is no primary SimHit simply use the secondary simhit as reference
        ptrPrimarySimHit = mcHitLookUp.getSimHit(ptrFirstHit);
        if (not ptrPrimarySimHit) {
          return TrackingUtilities::CDCTrajectory3D();
        }
      }
 
      const CDCSimHit& primarySimHit = *ptrPrimarySimHit;
 
      TrackingUtilities::Vector3D mom3D{primarySimHit.getMomentum()};
      TrackingUtilities::Vector3D pos3D{primarySimHit.getPosTrack()};
      double time{primarySimHit.getFlightTime()};
 
      int pdgCode = primarySimHit.getPDGCode();
      const TParticlePDG* ptrTPDGParticle = TDatabasePDG::Instance()->GetParticle(pdgCode);
 
      if (not ptrTPDGParticle) {
        B2WARNING("No particle for PDG code " << pdgCode << ". Could not get fit");
        return TrackingUtilities::CDCTrajectory3D();
      }
 
      const TParticlePDG& tPDGParticle = *ptrTPDGParticle;
 
      double charge = tPDGParticle.Charge() / 3.0;
 
      TrackingUtilities::ESign chargeSign = TrackingUtilities::sign(charge);
 
      TrackingUtilities::CDCTrajectory3D trajectory3D(pos3D, time, mom3D, charge);
 
      TrackingUtilities::ESign settedChargeSign = trajectory3D.getChargeSign();
 
      if (chargeSign != settedChargeSign) {
        B2WARNING("Charge sign of mc particle is not the same as the one of the fit");
      }
 
      return trajectory3D;
    }

isForwardOrBackwardToMCTrack()

TrackingUtilities::EForwardBackward isForwardOrBackwardToMCTrack ( const TrackingUtilities::CDCSegment2D * ptrHits ) const

inherited

Returns the orientation of the collection of hits relative to its matched track.

• Returns EForwardBackward::c_Invalid if the collection of hits is not matched to any track.
• Returns EForwardBackward::c_Forward if the collection of hits is coaligned with the matched track.
• Returns EForwardBackward::c_Backward if the collection of hits is coaligned with the matched track interpreted in reverse.
• Returns EForwardBackward::c_Unknown if the matter cannot be decided.

Definition at line 158 of file CDCMCHitCollectionLookUp.icc.h.

    {
      TrackingUtilities::Index firstInTrackId = getFirstInTrackId(ptrHits);
      TrackingUtilities::Index lastInTrackId = getLastInTrackId(ptrHits);
      if (firstInTrackId == TrackingUtilities::c_InvalidIndex or lastInTrackId == TrackingUtilities::c_InvalidIndex) {
        return TrackingUtilities::EForwardBackward::c_Invalid;
      } else if (firstInTrackId < lastInTrackId) {
        return TrackingUtilities::EForwardBackward::c_Forward;
      } else if (firstInTrackId > lastInTrackId) {
        return TrackingUtilities::EForwardBackward::c_Backward;
      } else if (firstInTrackId == lastInTrackId) {
        return TrackingUtilities::EForwardBackward::c_Unknown;
      }
      return TrackingUtilities::EForwardBackward::c_Invalid;
    }

Member Data Documentation

m_minimalMatchPurity

float m_minimalMatchPurity

privateinherited

Threshold for the purity that must be exceeded to be considered as a match.

Definition at line 187 of file CDCMCHitCollectionLookUp.h.

m_minimalRLPurity

float m_minimalRLPurity

privateinherited

Threshold for the correct fraction of right left passage information to be considered a match.

Definition at line 190 of file CDCMCHitCollectionLookUp.h.

---

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

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