Muon::MuPatTrack Class Reference

track candidate object. More...

#include <MuPatTrack.h>

Inheritance diagram for Muon::MuPatTrack:

Collaboration diagram for Muon::MuPatTrack:

Public Types
enum	ProcessingStage {   Unknown , InitialLoop , LayerRecovery , ExtendedWithSegment ,   SegmentRecovery , FitRemovedSegment , RefitRemovedSegment , AmbiguityCreateCandidateFromSeeds ,   AmbiguitySelectCandidates , MatchFail , FitFail , FitWorse ,   UnassociatedEM , FitRemovedLayer , TrackSelector , KeptUntilEndOfCombi ,   NumberOfProcessingStages }
	enum to keep track of the life of candidates More...
using	MeasVec = std::vector<const Trk::MeasurementBase*>

Public Member Functions
	MuPatTrack (const std::vector< MuPatSegment * > &segments, std::unique_ptr< Trk::Track > &track, MuPatSegment *seedSeg=0)
	constructor taking a vector of MuPatSegment object, the candidate takes ownership of the track It will increase the usedInFit counter of the MuPatSegment objects by one.
	MuPatTrack (MuPatSegment *segment, std::unique_ptr< Trk::Track > &track)
	constructor taking a MuPatSegment object, the candidate takes ownership of the track It will increase the usedInFit counter of the MuPatSegment objects by one.
	MuPatTrack (MuPatSegment *segment1, MuPatSegment *segment2, std::unique_ptr< Trk::Track > &track, MuPatSegment *seedSeg=0)
	constructor taking two MuPatSegment objects, the candidate takes ownership of the track It will increase the usedInFit counter of the MuPatSegment objects by one.
	~MuPatTrack ()
	destructor, decrease the usedInFit counter of all MuPatSegment objects by one
	MuPatTrack (const MuPatTrack &can)
	copying constructor.
MuPatTrack &	operator= (const MuPatTrack &can)
	assignment operator.
Trk::Track &	track () const
	access to track
void	updateTrack (std::unique_ptr< Trk::Track > &newTrack)
	update track.
const std::vector< MuPatSegment * > &	segments () const
	access to segments
MuPatSegment *	seedSegment () const
	Return pointer to the seed segment.
const std::vector< MuPatSegment * > &	excludedSegments () const
	access to segments
void	addSegment (MuPatSegment *segment, std::unique_ptr< Trk::Track > &newTrack)
	add segment + the associated new track.
void	addExcludedSegment (MuPatSegment *segment)
	add segment that does not match the track
bool	isSegmentExcluded (const MuPatSegment *segment) const
	loops over the excluded segment collection and checks whether the pointer is in there
const Trk::TrackParameters &	entryPars () const
	returns first track parameters
bool	hasMomentum () const
	returns whether canditate has a momentum measurement
std::vector< MuonStationIndex::StIndex >	stationsInOrder ()
	returns vector with contained stationIndices in the order they were added
bool	resetChambersOnCandidate (const std::set< MuonStationIndex::ChIndex > &chambers)
	reset chambers on the candidate.
std::string	segmentNames () const
	string containing the names of the segments on the candidate
const MeasVec &	etaHits () const
	return all eta hits on the entry
const MeasVec &	phiHits () const
	return all phi hits on the entry
const MeasVec &	fakePhiHits () const
	return all fake phi hits on the entry
const MeasVec &	hits () const
	return all hits on the entry.
bool	hasSmallChamber () const
	returns whether entry contains a small chamber
bool	hasLargeChamber () const
	returns whether entry contains a small chamber
bool	hasSLOverlap () const
	returns whether there is at least one small/large overlap in the same station layer
bool	hasEndcap () const
	returns whether the entry contains endcap hits
void	hasEndcap (bool hasEC)
	set whether entry has endcap hits
const std::set< MuonStationIndex::StIndex > &	stations () const
	returns set with contained stationIndices
const std::set< MuonStationIndex::ChIndex > &	chambers () const
	returns set with contained chamberIndices
bool	containsChamber (MuonStationIndex::ChIndex chIndex) const
	returns whether the ChamberIndex is already contained in candidate
bool	containsStation (MuonStationIndex::StIndex chIndex) const
	returns whether the StationIndex is already contained in candidate
const MuPatHitList &	hitList () const
	returns a reference to the hit list
const std::set< Identifier > &	chamberIds () const
	returns set with contained chamber ids
bool	shareChambers (const MuPatCandidateBase &entry) const
	checks whether the two entries contain the same chamber
const Trk::MeasurementBase *	addToTrash (std::unique_ptr< const Trk::MeasurementBase > meas)
	adds the measurement to the garbage container.
void	addToTrash (const std::vector< std::shared_ptr< const Trk::MeasurementBase > > &measurements)
const std::vector< std::shared_ptr< const Trk::MeasurementBase > > &	garbage () const

Static Public Member Functions
static const std::string &	processingStageString (ProcessingStage stage)
	Convert enum to string.
static unsigned int	processingStageStringMaxLen ()
	maximum width of the strings corresponding to the ProcessingStage
static std::size_t	numberOfInstantiations ()

Public Attributes
ProcessingStage	created {Unknown}
ProcessingStage	lastSegmentChange {Unknown}
unsigned int	nmdtHitsMl1 {0}
	public hit counters
unsigned int	nmdtHitsMl2 {0}
unsigned int	ncscHitsEta {0}
unsigned int	ncscHitsPhi {0}
unsigned int	nrpcHitsEta {0}
unsigned int	nrpcHitsPhi {0}
unsigned int	ntgcHitsEta {0}
unsigned int	ntgcHitsPhi {0}

Static Public Attributes
static std::atomic_size_t	s_numberOfInstantiations

Protected Member Functions
void	hasSmallChamber (bool hasSmall)
	set whether entry has small chamber
void	hasLargeChamber (bool hasLarge)
	set whether entry has large chamber
void	hasSLOverlap (bool hasSL)
	set whether entry has at least one small/large overlap in the same station layer
MuPatHitList &	hitList ()
	returns a reference to the hit list
std::set< Identifier > &	chamberIds ()
	returns set with contained chamber ids
void	setEtaHits (const MeasVec &hits)
	set eta hits on the entry
void	setPhiHits (const MeasVec &hits)
	set phi hits on the entry
void	setFakePhiHits (const MeasVec &hits)
	set fake phi hits on the entry
void	setAllHits (const MeasVec &hits)
	set all hits on the entry
void	clearChambers ()
	clear the list of contained chambers.
void	addChamber (MuonStationIndex::ChIndex chIndex)
	add the chamber to the list of contained chambers.
void	setChambers (const std::set< MuonStationIndex::ChIndex > &chambers)
	Set the list of chambers and update list of stations.

Protected Attributes
std::set< MuonStationIndex::ChIndex >	m_chambers
std::set< MuonStationIndex::StIndex >	m_stations
bool	m_hasMomentum {false}

Private Member Functions
void	updateSegments (bool add)
	update segment/track association, if add == true ,will add track to segments else remove it
void	modifySegmentCounters (int change)
	increase the segment counters by the passed number

Static Private Member Functions
static std::vector< std::string >	initProcessingStageStrings ()
	Initialize s_processingStageStrings & s_processingStageStringMaxLen.
static const std::vector< std::string > &	processingStageStrings ()
	Return list of processing stage strings.
static bool	hasMomentum (const Trk::Track &track)
	check whether track measures momentum

Private Attributes
std::vector< MuPatSegment * >	m_segments {}
std::vector< MuPatSegment * >	m_excludedSegments {}
std::unique_ptr< Trk::Track >	m_track {}
MuPatSegment *	m_seedSeg {nullptr}
	The special segment for this track.
MeasVec	m_etaHits
MeasVec	m_phiHits
MeasVec	m_fakePhiHits
MeasVec	m_allHits
MuPatHitList	m_hitList
std::set< Identifier >	m_chamberIds
bool	m_hasEndcap {false}
bool	m_hasSmallChamber {false}
bool	m_hasLargeChamber {false}
bool	m_hasSLOverlap {false}
std::vector< std::shared_ptr< const Trk::MeasurementBase > >	m_garbage {}

Friends
class	MuPatCandidateTool

Detailed Description

track candidate object.

The purpose of the track candidate is three folded:

• provide the generic MuPatCandidateBase interface for tracks
• keep track of segments used to build track
• cache additional information that cannot be stored on the track

The following information is cached:

• the stage during the pattern recognition the candidate was made (Moore legacy)
• the pointer to the track
• a vector of the segments that were used to form the track
• a vector of the segments that were already tested against the candidate but failed. This information can be used to speed up the pat-rec code by avoiding fits that were already tried.

Definition at line 37 of file MuPatTrack.h.

Member Typedef Documentation

MeasVec

using Muon::MuPatCandidateBase::MeasVec = std::vector<const Trk::MeasurementBase*>

inherited

Definition at line 50 of file MuPatCandidateBase.h.

Member Enumeration Documentation

ProcessingStage

enum Muon::MuPatTrack::ProcessingStage

enum to keep track of the life of candidates

Enumerator
Unknown
InitialLoop
LayerRecovery
ExtendedWithSegment
SegmentRecovery
FitRemovedSegment
RefitRemovedSegment
AmbiguityCreateCandidateFromSeeds
AmbiguitySelectCandidates
MatchFail
FitFail
FitWorse
UnassociatedEM
FitRemovedLayer
TrackSelector
KeptUntilEndOfCombi
NumberOfProcessingStages

Definition at line 42 of file MuPatTrack.h.

                             {
            Unknown,
            InitialLoop,
            LayerRecovery,
            ExtendedWithSegment,
            SegmentRecovery,
            FitRemovedSegment,
            RefitRemovedSegment,
            AmbiguityCreateCandidateFromSeeds,
            AmbiguitySelectCandidates,
            MatchFail,
            FitFail,
            FitWorse,
            UnassociatedEM,
            FitRemovedLayer,
            TrackSelector,
            KeptUntilEndOfCombi,
            NumberOfProcessingStages
        };

Constructor & Destructor Documentation

MuPatTrack() [1/4]

Muon::MuPatTrack::MuPatTrack	(	const std::vector< MuPatSegment * > &	segments,
		std::unique_ptr< Trk::Track > &	track,
		MuPatSegment *	seedSeg = 0 )

constructor taking a vector of MuPatSegment object, the candidate takes ownership of the track It will increase the usedInFit counter of the MuPatSegment objects by one.

Definition at line 72 of file MuPatTrack.cxx.

                                                                                                                          :
        MuPatCandidateBase(), m_segments(segments) {
 
        m_track.swap(track);
        // increase segment counters
        modifySegmentCounters(+1);
        m_hasMomentum = hasMomentum();
 
        // now update links between tracks and segments
        updateSegments(true);
       
        if (seedSeg){
            m_seedSeg = seedSeg;
            addToTrash(seedSeg->garbage());
        } else if (!segments.empty())
            m_seedSeg = segments[0];
        for (MuPatSegment* seg : segments){
            addToTrash(seg->garbage());
        }
    }

MuPatTrack() [2/4]

Muon::MuPatTrack::MuPatTrack	(	MuPatSegment *	segment,
		std::unique_ptr< Trk::Track > &	track )

constructor taking a MuPatSegment object, the candidate takes ownership of the track It will increase the usedInFit counter of the MuPatSegment objects by one.

Definition at line 93 of file MuPatTrack.cxx.

                                                                                :
        MuPatCandidateBase(){
        m_track.swap(track);
 
        m_segments.reserve(3);
        m_segments.push_back(segment);
        addToTrash(segment->garbage());
        // increase segment counters
        modifySegmentCounters(+1);
        m_hasMomentum = hasMomentum();
 
        // now update links between tracks and segments
        updateSegments(true);
        
    }

MuPatTrack() [3/4]

Muon::MuPatTrack::MuPatTrack	(	MuPatSegment *	segment1,
		MuPatSegment *	segment2,
		std::unique_ptr< Trk::Track > &	track,
		MuPatSegment *	seedSeg = 0 )

constructor taking two MuPatSegment objects, the candidate takes ownership of the track It will increase the usedInFit counter of the MuPatSegment objects by one.

Definition at line 109 of file MuPatTrack.cxx.

                                                                                                                                :
        MuPatCandidateBase() {
        m_track.swap(track);
 
        m_segments.reserve(3);
        m_segments.push_back(segment1);
        m_segments.push_back(segment2);
        // increase segment counters
        modifySegmentCounters(+1);
        m_hasMomentum = hasMomentum();
 
        // now update links between tracks and segments
        updateSegments(true);
        
        m_excludedSegments.clear();
        if (seedSeg)
            m_seedSeg = seedSeg;
        else
            m_seedSeg = segment1 ? segment1 : segment2;
        for (MuPatSegment* seg : {segment1, segment2, seedSeg}) {
            if (seg) addToTrash(seg->garbage());
        }
    }

~MuPatTrack()

Muon::MuPatTrack::~MuPatTrack

(

)

destructor, decrease the usedInFit counter of all MuPatSegment objects by one

Definition at line 133 of file MuPatTrack.cxx.

                            {
        // now update links between tracks and segments
        updateSegments(false);
    }

MuPatTrack() [4/4]

Muon::MuPatTrack::MuPatTrack

(

const MuPatTrack &

can

)

copying constructor.

It will not copy the track, just its pointer (lazy). It will increase the usedInFit counter of the MuPatSegment objects by one.

Definition at line 138 of file MuPatTrack.cxx.

                                                :
        MuPatCandidateBase(can),
        Trk::ObjectCounter<MuPatTrack>(can),
        created(can.created),
        lastSegmentChange(can.lastSegmentChange),
        m_segments(can.m_segments),
        m_excludedSegments(can.m_excludedSegments),
        m_track (std::make_unique<Trk::Track>(can.track())),
        m_seedSeg(can.m_seedSeg) {
        m_hasMomentum = can.m_hasMomentum;
        // increase segment counters
        modifySegmentCounters(+1);
 
        // now update links between tracks and segments
        updateSegments(true);
    }

Member Function Documentation

addChamber()

void Muon::MuPatCandidateBase::addChamber ( MuonStationIndex::ChIndex chIndex )

protectedinherited

add the chamber to the list of contained chambers.

Will also add the corresponding station.

Definition at line 38 of file MuPatCandidateBase.cxx.

                                                                       {
        m_chambers.insert(chIndex);
        m_stations.insert(MuonStationIndex::toStationIndex(chIndex));
    }

addExcludedSegment()

void Muon::MuPatTrack::addExcludedSegment

(

MuPatSegment *

segment

)

add segment that does not match the track

Definition at line 212 of file MuPatTrack.cxx.

{ m_excludedSegments.push_back(segment); }

addSegment()

void Muon::MuPatTrack::addSegment	(	MuPatSegment *	segment,
		std::unique_ptr< Trk::Track > &	newTrack )

add segment + the associated new track.

Takes ownership of the track.

Definition at line 216 of file MuPatTrack.cxx.

                                                                                        {
        // add segment and increase counter
        m_segments.push_back(segment);
        addToTrash(segment->garbage());
        segment->addTrack(this);
        ++segment->usedInFit;
        for (const MuonStationIndex::ChIndex& chit : segment->chambers()) addChamber(chit);
 
        if (newTrack) {
            // delete old track, assign new
            m_track.swap(newTrack);
        }
        m_hasMomentum = hasMomentum();
    }

addToTrash() [1/2]

void Muon::MuPatCandidateBase::addToTrash ( const std::vector< std::shared_ptr< const Trk::MeasurementBase > > & measurements )

inherited

Definition at line 97 of file MuPatCandidateBase.cxx.

                                                                                                              {
        if (m_garbage.capacity() < measurements.size() + m_garbage.size()){
            m_garbage.reserve(measurements.size() + m_garbage.size());
        }
        m_garbage.insert(m_garbage.end(), measurements.begin(), measurements.end());
    }

addToTrash() [2/2]

const Trk::MeasurementBase * Muon::MuPatCandidateBase::addToTrash ( std::unique_ptr< const Trk::MeasurementBase > meas )

inherited

adds the measurement to the garbage container.

Definition at line 92 of file MuPatCandidateBase.cxx.

    {
      m_garbage.push_back(std::move(meas));
      return m_garbage.back().get();
    }

chamberIds() [1/2]

std::set< Identifier > & Muon::MuPatCandidateBase::chamberIds ( )

protectedinherited

returns set with contained chamber ids

Definition at line 36 of file MuPatCandidateBase.cxx.

{ return m_chamberIds; }

chamberIds() [2/2]

const std::set< Identifier > & Muon::MuPatCandidateBase::chamberIds ( ) const

inherited

returns set with contained chamber ids

Definition at line 33 of file MuPatCandidateBase.cxx.

{ return m_chamberIds; }

chambers()

const std::set< MuonStationIndex::ChIndex > & Muon::MuPatCandidateBase::chambers ( ) const

inherited

returns set with contained chamberIndices

Definition at line 31 of file MuPatCandidateBase.cxx.

{ return m_chambers; }

clearChambers()

void Muon::MuPatCandidateBase::clearChambers ( )

protectedinherited

clear the list of contained chambers.

Will also clear the list of contained stations and list of chamber Ids.

Definition at line 83 of file MuPatCandidateBase.cxx.

                                           {
        m_chambers.clear();
        m_stations.clear();
        m_chamberIds.clear();
    }

containsChamber()

bool Muon::MuPatCandidateBase::containsChamber ( MuonStationIndex::ChIndex chIndex ) const

inherited

returns whether the ChamberIndex is already contained in candidate

Definition at line 75 of file MuPatCandidateBase.cxx.

                                                                                  {
        return m_chambers.find(chIndex) != m_chambers.end();
    }

containsStation()

bool Muon::MuPatCandidateBase::containsStation ( MuonStationIndex::StIndex chIndex ) const

inherited

returns whether the StationIndex is already contained in candidate

Definition at line 79 of file MuPatCandidateBase.cxx.

                                                                                  {
        return m_stations.find(stIndex) != m_stations.end();
    }

entryPars()

const Trk::TrackParameters & Muon::MuPatTrack::entryPars ( ) const

inlinevirtual

returns first track parameters

Implements Muon::MuPatCandidateBase.

Definition at line 177 of file MuPatTrack.h.

                                                                 {
        const Trk::Perigee* pp = m_track->perigeeParameters();
        if (pp) { return *pp; }
        assert(!m_track->trackParameters() || m_track->trackParameters()->empty());
        return *m_track->trackParameters()->front();
    }

etaHits()

const MeasVec & Muon::MuPatCandidateBase::etaHits ( ) const

inherited

return all eta hits on the entry

excludedSegments()

const std::vector< MuPatSegment * > & Muon::MuPatTrack::excludedSegments ( ) const

inline

access to segments

Definition at line 173 of file MuPatTrack.h.

{ return m_excludedSegments; }

fakePhiHits()

const MuPatCandidateBase::MeasVec & Muon::MuPatCandidateBase::fakePhiHits ( ) const

inherited

return all fake phi hits on the entry

Definition at line 59 of file MuPatCandidateBase.cxx.

{ return m_fakePhiHits; }

garbage()

const std::vector< std::shared_ptr< const Trk::MeasurementBase > > & Muon::MuPatCandidateBase::garbage ( ) const

inherited

Definition at line 103 of file MuPatCandidateBase.cxx.

{return m_garbage;}

hasEndcap() [1/2]

bool Muon::MuPatCandidateBase::hasEndcap ( ) const

inherited

returns whether the entry contains endcap hits

Definition at line 71 of file MuPatCandidateBase.cxx.

{ return m_hasEndcap; }

hasEndcap() [2/2]

void Muon::MuPatCandidateBase::hasEndcap ( bool hasEC )

inherited

set whether entry has endcap hits

Definition at line 73 of file MuPatCandidateBase.cxx.

{ m_hasEndcap = hasEC; }

hasLargeChamber() [1/2]

bool Muon::MuPatCandidateBase::hasLargeChamber ( ) const

inherited

returns whether entry contains a small chamber

Definition at line 45 of file MuPatCandidateBase.cxx.

{ return m_hasLargeChamber; }

hasLargeChamber() [2/2]

void Muon::MuPatCandidateBase::hasLargeChamber ( bool hasLarge )

protectedinherited

set whether entry has large chamber

Definition at line 51 of file MuPatCandidateBase.cxx.

{ m_hasLargeChamber = hasLarge; }

hasMomentum() [1/2]

bool Muon::MuPatTrack::hasMomentum

(

)

const

returns whether canditate has a momentum measurement

Definition at line 186 of file MuPatTrack.cxx.

                                       {
        if (!m_track) return false;
        return hasMomentum(*m_track);
    }

hasMomentum() [2/2]

bool Muon::MuPatTrack::hasMomentum ( const Trk::Track & track )

staticprivate

check whether track measures momentum

Definition at line 191 of file MuPatTrack.cxx.

                                                      {
        // use track info if set properly
        if (track.info().trackProperties(Trk::TrackInfo::StraightTrack)) return false;
 
        bool hasMom = false;
        const Trk::Perigee* pp = track.perigeeParameters();
        if (pp) {
            const AmgSymMatrix(5)* cov = pp->covariance();
            if (cov) {
                // sum covariance terms of momentum, use it to determine whether fit was SL fit
                double momCov = 0.;
                for (int i = 0; i < 4; ++i) momCov += std::abs((*cov)(4, i));
                for (int i = 0; i < 4; ++i) momCov += std::abs((*cov)(i, 4));
                if (momCov > 1e-10) { hasMom = true; }
            }
        }
        return hasMom;
    }

hasSLOverlap() [1/2]

bool Muon::MuPatCandidateBase::hasSLOverlap ( ) const

inherited

returns whether there is at least one small/large overlap in the same station layer

Definition at line 47 of file MuPatCandidateBase.cxx.

{ return m_hasSLOverlap; }

hasSLOverlap() [2/2]

void Muon::MuPatCandidateBase::hasSLOverlap ( bool hasSL )

protectedinherited

set whether entry has at least one small/large overlap in the same station layer

Definition at line 53 of file MuPatCandidateBase.cxx.

{ m_hasSLOverlap = hasSL; }

hasSmallChamber() [1/2]

bool Muon::MuPatCandidateBase::hasSmallChamber ( ) const

inherited

returns whether entry contains a small chamber

Definition at line 43 of file MuPatCandidateBase.cxx.

{ return m_hasSmallChamber; }

hasSmallChamber() [2/2]

void Muon::MuPatCandidateBase::hasSmallChamber ( bool hasSmall )

protectedinherited

set whether entry has small chamber

Definition at line 49 of file MuPatCandidateBase.cxx.

{ m_hasSmallChamber = hasSmall; }

hitList() [1/2]

MuPatHitList & Muon::MuPatCandidateBase::hitList ( )

inlineprotectedinherited

returns a reference to the hit list

Definition at line 145 of file MuPatCandidateBase.h.

{ return m_hitList; }

hitList() [2/2]

const MuPatHitList & Muon::MuPatCandidateBase::hitList ( ) const

inlineinherited

returns a reference to the hit list

Definition at line 108 of file MuPatCandidateBase.h.

{ return m_hitList; }

hits()

const MuPatCandidateBase::MeasVec & Muon::MuPatCandidateBase::hits ( ) const

inherited

return all hits on the entry.

(Does not including the fake phi hits)

Definition at line 61 of file MuPatCandidateBase.cxx.

{ return m_allHits; }

initProcessingStageStrings()

std::vector< std::string > Muon::MuPatTrack::initProcessingStageStrings ( )

staticprivate

Initialize s_processingStageStrings & s_processingStageStringMaxLen.

Definition at line 30 of file MuPatTrack.cxx.

                                                                {
        std::vector<std::string> pss;
        pss.resize(NumberOfProcessingStages + 1);
        pss[Unknown] = "Unknown";
        pss[InitialLoop] = "InitialLoop";
        pss[LayerRecovery] = "LayerRecov";
        pss[ExtendedWithSegment] = "ExtWSegment";
        pss[SegmentRecovery] = "SegmentRecov";
        pss[FitRemovedSegment] = "FitRmSegment";
        pss[RefitRemovedSegment] = "RefitRmSegment";
        pss[AmbiguityCreateCandidateFromSeeds] = "AmbiCreate";
        pss[AmbiguitySelectCandidates] = "AmbiSelect";
        pss[MatchFail] = "MatchFail";
        pss[FitFail] = "FitFail";
        pss[FitWorse] = "FitWorse";
        pss[UnassociatedEM] = "UnassocEM";
        pss[FitRemovedLayer] = "FitRmLayer";
        pss[TrackSelector] = "TrackSelect";
        pss[KeptUntilEndOfCombi] = "--KEPT--";
        pss[NumberOfProcessingStages] = "OutOfBounds";
 
        return pss;
    }

isSegmentExcluded()

bool Muon::MuPatTrack::isSegmentExcluded

(

const MuPatSegment *

segment

)

const

loops over the excluded segment collection and checks whether the pointer is in there

Definition at line 213 of file MuPatTrack.cxx.

                                                                        {
        return std::find(m_excludedSegments.begin(), m_excludedSegments.end(), segment) != m_excludedSegments.end();
    }

modifySegmentCounters()

void Muon::MuPatTrack::modifySegmentCounters ( int change )

private

increase the segment counters by the passed number

Definition at line 231 of file MuPatTrack.cxx.

                                                     {
        // modify usedInFit counter of segment
        for (MuPatSegment* seg : m_segments) {
            for (const MuonStationIndex::ChIndex& chit : seg->chambers()) addChamber(chit);
            seg->usedInFit += change;
        }
    }

numberOfInstantiations()

std::size_t Trk::ObjectCounter< MuPatTrack >::numberOfInstantiations ( )

inlinestaticinherited

Definition at line 25 of file TrkObjectCounter.h.

  {
#ifndef NDEBUG
    return s_numberOfInstantiations.load();
#endif
    return 0;
  }

operator=()

MuPatTrack & Muon::MuPatTrack::operator=

(

const MuPatTrack &

can

)

assignment operator.

It will not copy the track, just its pointer (lazy). It will increase the usedInFit counter of the MuPatSegment objects by one.

Definition at line 155 of file MuPatTrack.cxx.

                                                           {
        if (&can != this) {
 
            // now update links between tracks and segments, remove old links
            updateSegments(false);
 
            // decrease old segment counters
            modifySegmentCounters(-1);
 
            // copy members
            MuPatCandidateBase::operator=(can);
            created = can.created;
            lastSegmentChange = can.lastSegmentChange;
            m_segments = can.m_segments;
            m_excludedSegments = can.m_excludedSegments;
 
            m_track = std::make_unique<Trk::Track>(can.track());
            m_chambers = can.m_chambers;
            m_stations = can.m_stations;
            m_hasMomentum = can.m_hasMomentum;
            m_seedSeg = can.m_seedSeg;
 
            // increase new segment counters
            modifySegmentCounters(+1);
 
            // now update links between tracks and segments, add new segments
            updateSegments(true);
        }
        return *this;
    }

phiHits()

const MuPatCandidateBase::MeasVec & Muon::MuPatCandidateBase::phiHits ( ) const

inherited

return all phi hits on the entry

Definition at line 57 of file MuPatCandidateBase.cxx.

{ return m_phiHits; }

processingStageString()

const std::string & Muon::MuPatTrack::processingStageString ( MuPatTrack::ProcessingStage stage )

static

Convert enum to string.

Definition at line 61 of file MuPatTrack.cxx.

                                                                                      {
        const std::vector<std::string>& pss = processingStageStrings();
 
        if (static_cast<size_t>(stage) < pss.size()) {
            return pss[static_cast<size_t>(stage)];
        } else {
            return pss[NumberOfProcessingStages];
        }
    }

processingStageStringMaxLen()

unsigned int Muon::MuPatTrack::processingStageStringMaxLen ( )

static

maximum width of the strings corresponding to the ProcessingStage

Definition at line 16 of file MuPatTrack.cxx.

                                                         {
        static const unsigned int maxlen = []() -> unsigned int {
          const std::vector<std::string>& pss = processingStageStrings();
          auto it = std::max_element(pss.begin(), pss.end(),
                                     [](const std::string& lhs, const std::string& rhs) { return lhs.size() < rhs.size(); });
 
          if (it != pss.end())
            return it->size();
          return 0u;
        }();
 
        return maxlen;
    }

processingStageStrings()

const std::vector< std::string > & Muon::MuPatTrack::processingStageStrings ( )

staticprivate

Return list of processing stage strings.

Definition at line 54 of file MuPatTrack.cxx.

    {
      static const std::vector<std::string> processingStrings =
        initProcessingStageStrings();
      return processingStrings;
    }

resetChambersOnCandidate()

bool Muon::MuPatTrack::resetChambersOnCandidate

(

const std::set< MuonStationIndex::ChIndex > &

chambers

)

reset chambers on the candidate.

Return whether segments were removed.

Definition at line 239 of file MuPatTrack.cxx.

                                                                                             {
        // loop over input chambers, check whether segments have a chamber in the list
        // remove segment if not in the list
        setChambers(chambers);  // also updates station list
 
        bool bRemovedSegments = false;
        std::vector<MuPatSegment*>::iterator it = m_segments.begin();
        // NOTE: can not cache m_segments.end() because it may change in the loop
        while (it != m_segments.end()) {
            bool inChamberSet = false;
            for (const MuonStationIndex::ChIndex& chit : (*it)->chambers()) {
                if (containsChamber(chit)) {
                    inChamberSet = true;
                    break;
                }
            }
            if (inChamberSet) {
                ++it;
            } else {
                (*it)->removeTrack(this);
                bRemovedSegments = true;
                it = m_segments.erase(it);  // it points to next element
            }
        }
 
        return bRemovedSegments;
    }

seedSegment()

MuPatSegment * Muon::MuPatTrack::seedSegment ( ) const

inline

Return pointer to the seed segment.

Definition at line 169 of file MuPatTrack.h.

                                                       {
        return m_seedSeg;  // could be a null pointer - do not dereference immediately!!
    }

segmentNames()

std::string Muon::MuPatTrack::segmentNames

(

)

const

string containing the names of the segments on the candidate

Remove the trailing white space

Definition at line 274 of file MuPatTrack.cxx.

                                             {
        std::string names;
        // rest with spaces
        for (const MuPatSegment* seg : m_segments) {
            names += seg->name;
            names += "  ";
        }
        return names.substr(0, names.size() - 1);
    }

segments()

const std::vector< MuPatSegment * > & Muon::MuPatTrack::segments ( ) const

inline

access to segments

Definition at line 167 of file MuPatTrack.h.

{ return m_segments; }

setAllHits()

void Muon::MuPatCandidateBase::setAllHits ( const MeasVec & hits )

protectedinherited

set all hits on the entry

Definition at line 69 of file MuPatCandidateBase.cxx.

{ m_allHits = hits; }

setChambers()

void Muon::MuPatCandidateBase::setChambers ( const std::set< MuonStationIndex::ChIndex > & chambers )

protectedinherited

Set the list of chambers and update list of stations.

Definition at line 14 of file MuPatCandidateBase.cxx.

                                                                                        {
        m_chambers = chambers;
        m_stations.clear();
        for (const MuonStationIndex::ChIndex it : chambers) m_stations.insert(MuonStationIndex::toStationIndex(it));
    }

setEtaHits()

void Muon::MuPatCandidateBase::setEtaHits ( const MeasVec & hits )

protectedinherited

set eta hits on the entry

Definition at line 63 of file MuPatCandidateBase.cxx.

{ m_etaHits = hits; }

setFakePhiHits()

void Muon::MuPatCandidateBase::setFakePhiHits ( const MeasVec & hits )

protectedinherited

set fake phi hits on the entry

Definition at line 67 of file MuPatCandidateBase.cxx.

{ m_fakePhiHits = hits; }

setPhiHits()

void Muon::MuPatCandidateBase::setPhiHits ( const MeasVec & hits )

protectedinherited

set phi hits on the entry

Definition at line 65 of file MuPatCandidateBase.cxx.

{ m_phiHits = hits; }

shareChambers()

bool Muon::MuPatCandidateBase::shareChambers ( const MuPatCandidateBase & entry ) const

inherited

checks whether the two entries contain the same chamber

Definition at line 20 of file MuPatCandidateBase.cxx.

                                                                                {
        std::vector<Identifier> intersection;
        std::set_intersection(entry.chamberIds().begin(), entry.chamberIds().end(), chamberIds().begin(), chamberIds().end(),
                              std::back_inserter(intersection));
 
        unsigned int intersectionSize = intersection.size();
        return intersectionSize != 0;
    }

stations()

const std::set< MuonStationIndex::StIndex > & Muon::MuPatCandidateBase::stations ( ) const

inherited

returns set with contained stationIndices

Definition at line 29 of file MuPatCandidateBase.cxx.

{ return m_stations; }

stationsInOrder()

std::vector< MuonStationIndex::StIndex > Muon::MuPatTrack::stationsInOrder

(

)

returns vector with contained stationIndices in the order they were added

Definition at line 267 of file MuPatTrack.cxx.

                                                                   {
        std::vector<MuonStationIndex::StIndex> stations;
        stations.reserve(m_segments.size());
        for (MuPatSegment* seg : m_segments) stations.push_back(seg->stIndex);
        return stations;
    }

track()

Trk::Track & Muon::MuPatTrack::track ( ) const

inline

access to track

Definition at line 175 of file MuPatTrack.h.

{ return *m_track; }

updateSegments()

void Muon::MuPatTrack::updateSegments ( bool add )

private

update segment/track association, if add == true ,will add track to segments else remove it

Definition at line 285 of file MuPatTrack.cxx.

                                            {
        for (MuPatSegment* seg : m_segments) {
            if (add) {
                seg->addTrack(this);
            } else {
                seg->removeTrack(this);
            }
        }
    }

updateTrack()

void Muon::MuPatTrack::updateTrack

(

std::unique_ptr< Trk::Track > &

newTrack

)

update track.

Candidate takes ownership of track.

Definition at line 210 of file MuPatTrack.cxx.

{ m_track.swap(track); }

Friends And Related Symbol Documentation

MuPatCandidateTool

friend class MuPatCandidateTool

friend

Definition at line 38 of file MuPatTrack.h.

Member Data Documentation

created

ProcessingStage Muon::MuPatTrack::created {Unknown}

Definition at line 144 of file MuPatTrack.h.

{Unknown};

lastSegmentChange

ProcessingStage Muon::MuPatTrack::lastSegmentChange {Unknown}

Definition at line 145 of file MuPatTrack.h.

{Unknown};

m_allHits

MeasVec Muon::MuPatCandidateBase::m_allHits

privateinherited

Definition at line 163 of file MuPatCandidateBase.h.

m_chamberIds

std::set<Identifier> Muon::MuPatCandidateBase::m_chamberIds

privateinherited

Definition at line 167 of file MuPatCandidateBase.h.

m_chambers

std::set<MuonStationIndex::ChIndex> Muon::MuPatCandidateBase::m_chambers

protectedinherited

Definition at line 170 of file MuPatCandidateBase.h.

m_etaHits

MeasVec Muon::MuPatCandidateBase::m_etaHits

privateinherited

Definition at line 160 of file MuPatCandidateBase.h.

m_excludedSegments

std::vector<MuPatSegment*> Muon::MuPatTrack::m_excludedSegments {}

private

Definition at line 157 of file MuPatTrack.h.

{};  //<! list of associated segments

m_fakePhiHits

MeasVec Muon::MuPatCandidateBase::m_fakePhiHits

privateinherited

Definition at line 162 of file MuPatCandidateBase.h.

m_garbage

std::vector<std::shared_ptr<const Trk::MeasurementBase> > Muon::MuPatCandidateBase::m_garbage {}

privateinherited

Definition at line 191 of file MuPatCandidateBase.h.

{};

m_hasEndcap

bool Muon::MuPatCandidateBase::m_hasEndcap {false}

privateinherited

Definition at line 186 of file MuPatCandidateBase.h.

{false};

m_hasLargeChamber

bool Muon::MuPatCandidateBase::m_hasLargeChamber {false}

privateinherited

Definition at line 188 of file MuPatCandidateBase.h.

{false};

m_hasMomentum

bool Muon::MuPatCandidateBase::m_hasMomentum {false}

protectedinherited

Definition at line 172 of file MuPatCandidateBase.h.

{false};

m_hasSLOverlap

bool Muon::MuPatCandidateBase::m_hasSLOverlap {false}

privateinherited

Definition at line 189 of file MuPatCandidateBase.h.

{false};

m_hasSmallChamber

bool Muon::MuPatCandidateBase::m_hasSmallChamber {false}

privateinherited

Definition at line 187 of file MuPatCandidateBase.h.

{false};

m_hitList

MuPatHitList Muon::MuPatCandidateBase::m_hitList

privateinherited

Definition at line 165 of file MuPatCandidateBase.h.

m_phiHits

MeasVec Muon::MuPatCandidateBase::m_phiHits

privateinherited

Definition at line 161 of file MuPatCandidateBase.h.

m_seedSeg

MuPatSegment* Muon::MuPatTrack::m_seedSeg {nullptr}

private

The special segment for this track.

Definition at line 159 of file MuPatTrack.h.

{nullptr};                        

m_segments

std::vector<MuPatSegment*> Muon::MuPatTrack::m_segments {}

private

Definition at line 156 of file MuPatTrack.h.

{};          //<! list of associated segments

m_stations

std::set<MuonStationIndex::StIndex> Muon::MuPatCandidateBase::m_stations

protectedinherited

Definition at line 171 of file MuPatCandidateBase.h.

m_track

std::unique_ptr<Trk::Track> Muon::MuPatTrack::m_track {}

private

Definition at line 158 of file MuPatTrack.h.

{};            //<! associated track

ncscHitsEta

unsigned int Muon::MuPatCandidateBase::ncscHitsEta {0}

inherited

Definition at line 178 of file MuPatCandidateBase.h.

{0};

ncscHitsPhi

unsigned int Muon::MuPatCandidateBase::ncscHitsPhi {0}

inherited

Definition at line 179 of file MuPatCandidateBase.h.

{0};

nmdtHitsMl1

unsigned int Muon::MuPatCandidateBase::nmdtHitsMl1 {0}

inherited

public hit counters

Definition at line 176 of file MuPatCandidateBase.h.

{0};

nmdtHitsMl2

unsigned int Muon::MuPatCandidateBase::nmdtHitsMl2 {0}

inherited

Definition at line 177 of file MuPatCandidateBase.h.

{0};

nrpcHitsEta

unsigned int Muon::MuPatCandidateBase::nrpcHitsEta {0}

inherited

Definition at line 180 of file MuPatCandidateBase.h.

{0};

nrpcHitsPhi

unsigned int Muon::MuPatCandidateBase::nrpcHitsPhi {0}

inherited

Definition at line 181 of file MuPatCandidateBase.h.

{0};

ntgcHitsEta

unsigned int Muon::MuPatCandidateBase::ntgcHitsEta {0}

inherited

Definition at line 182 of file MuPatCandidateBase.h.

{0};

ntgcHitsPhi

unsigned int Muon::MuPatCandidateBase::ntgcHitsPhi {0}

inherited

Definition at line 183 of file MuPatCandidateBase.h.

{0};

s_numberOfInstantiations

std::atomic_size_t Trk::ObjectCounter< MuPatTrack >::s_numberOfInstantiations

inlinestaticinherited

Definition at line 22 of file TrkObjectCounter.h.

---

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

• MuPatTrack.h
• MuPatTrack.cxx