MuonTrackPerformanceAlg Class Reference

#include <MuonTrackPerformanceAlg.h>

Inheritance diagram for MuonTrackPerformanceAlg:

Classes
struct	ChamberData
struct	EventData
struct	EventSummary
struct	TrackData
struct	TrackSummary

Public Member Functions
	MuonTrackPerformanceAlg (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~MuonTrackPerformanceAlg ()
virtual StatusCode	initialize () override
virtual StatusCode	execute () override
virtual StatusCode	finalize () override
virtual unsigned int	cardinality () const override final
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	extractEtaPhiCounts (const std::set< Identifier > &ids, int &neta, int &nphi, int &netaCh, int &nphiCh) const
bool	handleTracks ()
bool	handleTrackTruth (const TrackCollection &trackCollection)
bool	handleSegmentCombi (const Muon::MuonSegmentCombination &combi)
void	doSummary (const TrackCollection &tracks) const
void	doSummary (const Muon::IMuonTrackTruthTool::TruthTree &truthTracks) const
std::string	print (const Muon::IMuonTrackTruthTool::TruthTreeEntry &trackTruth) const
std::string	eventInfo () const
int	eventNumber () const
void	printMissingChambers () const
void	printMissingTracks () const
void	printFakeTracks () const
std::pair< int, int >	countHitsInChamber (const Identifier &chId, const std::set< Identifier > &hitIds) const
	counts number of eta (first number) and phi (second number in pair) hits in the set of hit IDs in the given chamber
bool	insertChamber (const Identifier &chId, const std::set< Identifier > &hits, int minEtaHits, int minPhiHits, ChamberData &chamberData) const
	insert chamber information into ChamberData if hits counts pass cuts, returns true if anything was inserted
bool	insertTechnology (const std::set< Identifier > &chIds, const std::set< Identifier > &hits, int minEtaHits, int minPhiHits, std::vector< ChamberData > &chamberData) const
	insert set of chambers into chamber data if hits counts pass cuts, returns true if anything was inserted
bool	insertStationLayers (const std::set< Identifier > &chIds, const std::set< Muon::MuonStationIndex::StIndex > &exclusionList, std::set< Muon::MuonStationIndex::StIndex > &layers) const
	insert station layers into layer set if they are not in exclusion list
bool	insertStationLayers (const std::vector< ChamberData > &chambers, const std::set< Muon::MuonStationIndex::StIndex > &exclusionList, std::set< Muon::MuonStationIndex::StIndex > &layers, bool usePrecision) const
	insert chamber data into layers if not in exclusion list
TrackData *	evaluateTrackTruthOverlap (const Muon::MuonTrackTruth &truthTrack) const
	evaluate track/truth overlap and create the corresponding overlap description object
TrackData *	createTrackData (const Muon::IMuonTrackTruthTool::TruthTreeEntry &trackTruth) const
	create track data object for truth track
void	addTrackToTrackData (const Trk::Track &track, TrackData &trackData) const
std::string	print (const TrackData &trackData) const
	print TrackData to a string
std::string	print (const EventData &event, const std::vector< TrackData * > &tracks, const std::string &message) const
std::string	print (const EventData &event, const std::vector< const Trk::Track * > &tracks, const std::string &message) const
std::string	printTrackCounters (bool doSecondaries=true) const
	print all the track counters to a string to provide a summary
void	clearTracks (std::vector< const Trk::Track * > tracks)
void	clearTracks (std::vector< TrackData * > tracks)
void	clearEvent (EventData &event)
HepMC::ConstGenParticlePtr	getMother (const TruthTrajectory &traj) const
HepMC::ConstGenParticlePtr	getInitialState (const TruthTrajectory &traj) const
bool	goodTruthTrack (const Muon::IMuonTrackTruthTool::TruthTreeEntry &entry) const
bool	isSecondary (const Muon::MuonTrackTruth &truthTrack) const
bool	isSecondary (const Muon::IMuonTrackTruthTool::TruthTreeEntry &entry) const
bool	isSecondary (const TruthTrajectory &truthTrajectory) const
bool	selectPdg (int pdg) const
void	printSummary (const std::vector< EventSummary > &summary, std::string typeName) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< TrackCollection >	m_trackKey
	Location of the input tracks.
SG::ReadHandleKey< xAOD::MuonContainer >	m_muons {this, "MuonLocation", "Muons", "input muons"}
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey {this, "EventInfoKey", "EventInfo", "EventInfo key"}
const xAOD::EventInfo *	m_eventInfo
	pointer to the event info
SG::ReadHandleKey< McEventCollection >	m_mcEventColl {this, "McEventCollectionKey", "TruthEvent", "McEventCollection"}
SG::ReadHandleKeyArray< MuonSimDataCollection >	m_muonSimData
SG::ReadHandleKey< CscSimDataCollection >	m_cscSimData {this, "CSC_SDO_Container", "CSC_SDO", "CSC SDO"}
SG::ReadHandleKey< TrackRecordCollection >	m_trackRecord {this, "TrackRecord", "MuonEntryLayerFilter", "Track Record Collection"}
int	m_doSummary {}
int	m_doHitResiduals {}
int	m_doTrackDebug {}
bool	m_doTruth {}
bool	m_doHistos {}
double	m_momentumCutSim {}
double	m_momentumCut {}
bool	m_usePtCut {}
bool	m_isCombined {}
bool	m_doSegments {}
bool	m_writeToFile {}
bool	m_doStau {}
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
PublicToolHandle< Muon::MuonEDMPrinterTool >	m_printer {this, "Printer", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}
ServiceHandle< Muon::IMuonEDMHelperSvc >	m_edmHelperSvc
ToolHandle< Muon::IMuonTrackTruthTool >	m_truthTool {this, "TrackTruthTool",""}
ToolHandle< Trk::ITrackSummaryHelperTool >	m_summaryHelperTool {this, "SummaryHelperTool", ""}
int	m_doEventListMissed {}
int	m_doEventListIncomplete {}
int	m_doEventListFake {}
int	m_minMdtHits {}
int	m_minCscEtaHits {}
int	m_minCscPhiHits {}
int	m_minRpcEtaHits {}
int	m_minRpcPhiHits {}
int	m_minTgcEtaHits {}
int	m_minTgcPhiHits {}
int	m_minsTgcEtaHits {}
int	m_minsTgcPhiHits {}
int	m_minMMEtaHits {}
unsigned int	m_nevents {}
unsigned int	m_ntracks {}
unsigned int	m_nmatchedTracks {}
unsigned int	m_nmatchedTracksSecondary {}
unsigned int	m_nmatchedFakeTracks {}
unsigned int	m_nfakeTracks {}
unsigned int	m_nfakeTracksHighPt {}
unsigned int	m_nfakeTracksLowPt {}
unsigned int	m_nfakeTracksSL {}
unsigned int	m_nmissedTracks {}
unsigned int	m_nmissedTracksOneStation {}
unsigned int	m_nmissedTracksSecondary {}
unsigned int	m_nmissedTracksOneStationSecondary {}
unsigned int	m_nmissingStationMomLoss {}
unsigned int	m_nmissingStationLayer {}
unsigned int	m_nmissingCscStationLayer {}
unsigned int	m_nmissingStationLayerTrigger {}
unsigned int	m_nmissingStation {}
unsigned int	m_nwrongStationLayer {}
unsigned int	m_nwrongStationLayerTrigger {}
unsigned int	m_nwrongStation {}
unsigned int	m_ntruthTracks {}
unsigned int	m_ntruthTracksSecondary {}
std::vector< EventData >	m_badEvents
std::string	m_fileName
	name of external file to write statistics
std::ofstream	m_fileOutput
	output file
IntegerArrayProperty	m_pdgsToBeConsidered
std::set< int >	m_selectedPdgs
int	m_trackType {}
std::string	m_trackTypeString
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 50 of file MuonTrackPerformanceAlg.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

MuonTrackPerformanceAlg()

MuonTrackPerformanceAlg::MuonTrackPerformanceAlg	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 18 of file MuonTrackPerformanceAlg.cxx.

                                                                                                :
    AthAlgorithm(name, pSvcLocator),
    m_eventInfo(nullptr),    
    m_nevents(0),
    m_ntracks(0),
    m_nmatchedTracks(0),
    m_nmatchedTracksSecondary(0),
    m_nmatchedFakeTracks(0),
    m_nfakeTracks(0),
    m_nfakeTracksHighPt(0),
    m_nfakeTracksLowPt(0),
    m_nfakeTracksSL(0),
    m_nmissedTracks(0),
    m_nmissedTracksOneStation(0),
    m_nmissedTracksSecondary(0),
    m_nmissedTracksOneStationSecondary(0),
    m_nmissingStationMomLoss(0),
    m_nmissingStationLayer(0),
    m_nmissingCscStationLayer(0),
    m_nmissingStationLayerTrigger(0),
    m_nmissingStation(0),
    m_nwrongStationLayer(0),
    m_nwrongStationLayerTrigger(0),
    m_nwrongStation(0),
    m_ntruthTracks(0),
    m_ntruthTracksSecondary(0) {
    declareProperty("DoHistos", m_doHistos = false);
    declareProperty("DoSummary", m_doSummary = 0);
    declareProperty("DoHitResiduals", m_doHitResiduals = 0);
    declareProperty("DoTrackDebug", m_doTrackDebug = 0);
    declareProperty("DoTruth", m_doTruth = true);
    declareProperty("writeToFile", m_writeToFile = true);
    declareProperty("FileName", m_fileName = "trkPerformance.txt");
    declareProperty("UsePtCut", m_usePtCut = true);
    declareProperty("IsCombined", m_isCombined = false);
    declareProperty("MuonMomentumCutSim", m_momentumCutSim = 2000.);
    declareProperty("LowMomentumThreshold", m_momentumCut = 2000.);
    declareProperty("DoSegments", m_doSegments = false);
    declareProperty("doStau", m_doStau = false);
    declareProperty("TrackType", m_trackType = 2);
    declareProperty("ProduceEventListMissedTracks", m_doEventListMissed = 0, "0: off, 1: two station, 2: + one station");
    declareProperty("ProduceEventListIncompleteTracks", m_doEventListIncomplete = 0,
                    "0: off, 1: missing precision layer, 2: +missing chamber");
    declareProperty("ProduceEventListFakeTracks", m_doEventListFake = 0, "0: off, 1: high pt, 2: +low pt, 3: +SL");
    declareProperty("MinMdtHits", m_minMdtHits = 3);
    declareProperty("MinCscEtaHits", m_minCscEtaHits = 3);
    declareProperty("MinCscPhiHits", m_minCscPhiHits = 3);
    declareProperty("MinRPCEtaHits", m_minRpcEtaHits = 1);
    declareProperty("MinRPCPhiits", m_minRpcPhiHits = 1);
    declareProperty("MinTGCEtaHits", m_minTgcEtaHits = 1);
    declareProperty("MinTGCPhiHits", m_minTgcPhiHits = 1);
    declareProperty("MinSTGCEtaHits", m_minsTgcEtaHits = 1);
    declareProperty("MinSTGCPhiHits", m_minsTgcPhiHits = 1);
    declareProperty("MinMMEtaHits", m_minMMEtaHits = 3);
    declareProperty("ConsideredPDGs", m_pdgsToBeConsidered);
}

~MuonTrackPerformanceAlg()

MuonTrackPerformanceAlg::~MuonTrackPerformanceAlg ( )

virtual

Definition at line 75 of file MuonTrackPerformanceAlg.cxx.

{}

Member Function Documentation

addTrackToTrackData()

void MuonTrackPerformanceAlg::addTrackToTrackData ( const Trk::Track & track, MuonTrackPerformanceAlg::TrackData & trackData ) const

private

Definition at line 1244 of file MuonTrackPerformanceAlg.cxx.

                                                                                                                          {
    trackData.trackPars = track.perigeeParameters() ? new Trk::Perigee(*track.perigeeParameters()) : nullptr;
    trackData.chi2Ndof = 0.;
 
    if (track.fitQuality() && track.fitQuality()->numberDoF())
        trackData.chi2Ndof = track.fitQuality()->chiSquared() / track.fitQuality()->numberDoF();
 
    trackData.trackSummary = track.trackSummary() ? new Trk::TrackSummary(*track.trackSummary()) : nullptr;
    if (trackData.trackSummary && !trackData.trackSummary->muonTrackSummary()) {
        m_summaryHelperTool->addDetailedTrackSummary(track, *trackData.trackSummary);
    }
}

cardinality()

virtual unsigned int MuonTrackPerformanceAlg::cardinality ( ) const

inlinefinaloverridevirtual

Definition at line 190 of file MuonTrackPerformanceAlg.h.

{ return 1;}

clearEvent()

void MuonTrackPerformanceAlg::clearEvent ( MuonTrackPerformanceAlg::EventData & event )

private

Definition at line 1366 of file MuonTrackPerformanceAlg.cxx.

                                                                                {
    clearTracks(event.missingTruthTracks);
    clearTracks(event.missingTruthTracksOneStation);
 
    clearTracks(event.missingStationMomLoss);
    clearTracks(event.missingStationLayer);
    clearTracks(event.missingStation);
 
    clearTracks(event.wrongStationLayer);
    clearTracks(event.wrongStation);
 
    clearTracks(event.fakeTracks);
    clearTracks(event.fakeTracksLowPt);
    clearTracks(event.fakeTracksSL);
}

clearTracks() [1/2]

void MuonTrackPerformanceAlg::clearTracks ( std::vector< const Trk::Track * > tracks )

private

Definition at line 1352 of file MuonTrackPerformanceAlg.cxx.

                                                                           {
    std::vector<const Trk::Track*>::const_iterator it = tracks.begin();
    std::vector<const Trk::Track*>::const_iterator it_end = tracks.end();
    for (; it != it_end; ++it) delete *it;
    tracks.clear();
}

clearTracks() [2/2]

void MuonTrackPerformanceAlg::clearTracks ( std::vector< TrackData * > tracks )

private

Definition at line 1359 of file MuonTrackPerformanceAlg.cxx.

                                                                                             {
    std::vector<TrackData*>::const_iterator it = tracks.begin();
    std::vector<TrackData*>::const_iterator it_end = tracks.end();
    for (; it != it_end; ++it) { delete *it; }
    tracks.clear();
}

countHitsInChamber()

std::pair< int, int > MuonTrackPerformanceAlg::countHitsInChamber ( const Identifier & chId, const std::set< Identifier > & hitIds ) const

private

counts number of eta (first number) and phi (second number in pair) hits in the set of hit IDs in the given chamber

Definition at line 997 of file MuonTrackPerformanceAlg.cxx.

                                                                                                                            {
    // loop over hits in set, calculate their chID and compare it with the input chamber
    int nhitsPhi = m_idHelperSvc->isMdt(chId) ? -1 : 0;
    int nhitsEta = 0;
    std::set<Identifier>::const_iterator it = hitIds.begin();
    std::set<Identifier>::const_iterator it_end = hitIds.end();
    for (; it != it_end; ++it) {
        Identifier ch = m_idHelperSvc->chamberId(*it);
        if (ch == chId) {
            if (m_idHelperSvc->measuresPhi(*it))
                ++nhitsPhi;
            else
                ++nhitsEta;
        }
    }
    return std::make_pair(nhitsEta, nhitsPhi);
}

createTrackData()

MuonTrackPerformanceAlg::TrackData * MuonTrackPerformanceAlg::createTrackData ( const Muon::IMuonTrackTruthTool::TruthTreeEntry & trackTruth ) const

private

create track data object for truth track

Definition at line 1257 of file MuonTrackPerformanceAlg.cxx.

                                                                   {
    if (!trackTruth.truthTrack) { return nullptr; }
 
    TrackData* trackData = new TrackData();
 
    std::map<Identifier, std::set<Identifier> > chambers;
 
    MuonSimDataCollection::const_iterator mit = trackTruth.mdtHits.begin();
    MuonSimDataCollection::const_iterator mit_end = trackTruth.mdtHits.end();
    for (; mit != mit_end; ++mit) {
        Identifier chId = m_idHelperSvc->chamberId(mit->first);
        chambers[chId].insert(mit->first);
    }
 
    if (m_idHelperSvc->hasCSC()) {
        CscSimDataCollection::const_iterator cit = trackTruth.cscHits.begin();
        CscSimDataCollection::const_iterator cit_end = trackTruth.cscHits.end();
        for (; cit != cit_end; ++cit) {
            Identifier chId = m_idHelperSvc->chamberId(cit->first);
            chambers[chId].insert(m_idHelperSvc->layerId(cit->first));
        }
    }
    if (m_idHelperSvc->hasSTGC()) {
        mit = trackTruth.stgcHits.begin();
        mit_end = trackTruth.stgcHits.end();
        for (; mit != mit_end; ++mit) {
            Identifier chId = m_idHelperSvc->chamberId(mit->first);
            chambers[chId].insert(mit->first);
        }
    }
    if (m_idHelperSvc->hasMM()) {
        mit = trackTruth.mmHits.begin();
        mit_end = trackTruth.mmHits.end();
        for (; mit != mit_end; ++mit) {
            Identifier chId = m_idHelperSvc->chamberId(mit->first);
            chambers[chId].insert(mit->first);
        }
    }
 
    mit = trackTruth.rpcHits.begin();
    mit_end = trackTruth.rpcHits.end();
    for (; mit != mit_end; ++mit) {
        Identifier chId = m_idHelperSvc->chamberId(mit->first);
        chambers[chId].insert(mit->first);
    }
 
    mit = trackTruth.tgcHits.begin();
    mit_end = trackTruth.tgcHits.end();
    for (; mit != mit_end; ++mit) {
        Identifier chId = m_idHelperSvc->chamberId(mit->first);
        chambers[chId].insert(mit->first);
    }
 
    std::vector<ChamberData> missingChambers;
    std::map<Identifier, std::set<Identifier> >::const_iterator chIt = chambers.begin();
    std::map<Identifier, std::set<Identifier> >::const_iterator chIt_end = chambers.end();
    for (; chIt != chIt_end; ++chIt) {
        ChamberData chamberData;
        unsigned int minEtaHits = 0;
        unsigned int minPhiHits = 0;
        if (m_idHelperSvc->isMdt(chIt->first)) {
            minEtaHits = m_minMdtHits;
            minPhiHits = m_minMdtHits;
        } else if (m_idHelperSvc->isRpc(chIt->first)) {
            minEtaHits = m_minRpcEtaHits;
            minPhiHits = m_minRpcPhiHits;
        } else if (m_idHelperSvc->isTgc(chIt->first)) {
            minEtaHits = m_minTgcEtaHits;
            minPhiHits = m_minTgcPhiHits;
        } else if (m_idHelperSvc->issTgc(chIt->first)) {
            minEtaHits = m_minsTgcEtaHits;
            minPhiHits = m_minsTgcPhiHits;
        } else if (m_idHelperSvc->isMM(chIt->first)) {
            minEtaHits = m_minMMEtaHits;
            minPhiHits = m_minMMEtaHits;
        } else if (m_idHelperSvc->isCsc(chIt->first)) {
            minEtaHits = m_minCscEtaHits;
            minPhiHits = m_minCscPhiHits;
        } else {
            ATH_MSG_WARNING("unexpected identifier");
            continue;
        }
        if (insertChamber(chIt->first, chIt->second, minEtaHits, minPhiHits, chamberData)) {
            trackData->missingChambers.push_back(chamberData);
            Muon::MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(chIt->first);
            if (m_idHelperSvc->isTrigger(chIt->first))
                trackData->missingLayersTrigger.insert(stIndex);
            else
                trackData->missingLayers.insert(stIndex);
        }
    }
    return trackData;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

doSummary() [1/2]

void MuonTrackPerformanceAlg::doSummary ( const Muon::IMuonTrackTruthTool::TruthTree & truthTracks ) const

private

Definition at line 622 of file MuonTrackPerformanceAlg.cxx.

                                                                                                 {
    msg() << " Summarizing tracks in event " << eventInfo() << " nevents " << m_nevents;
    if (truthTracks.empty())
        msg() << " : no truth tracks" << endmsg;
    else {
        msg() << " : " << truthTracks.size() << " truth tracks found " << std::endl;
        Muon::IMuonTrackTruthTool::TruthTree::const_iterator tit = truthTracks.begin();
        Muon::IMuonTrackTruthTool::TruthTree::const_iterator tit_end = truthTracks.end();
        for (; tit != tit_end; ++tit) {
            msg() << print(tit->second);
            // should finish with an 'endmsg' else the buffer does not get flushed.
            Muon::IMuonTrackTruthTool::TruthTree::const_iterator tit_temp = tit;
            if (++tit_temp == tit_end)
                msg() << endmsg;
            else
                msg() << std::endl;
        }
    }
}

doSummary() [2/2]

void MuonTrackPerformanceAlg::doSummary ( const TrackCollection & tracks ) const

private

Definition at line 598 of file MuonTrackPerformanceAlg.cxx.

                                                                                    {
    msg() << " Summarizing tracks in event " << eventInfo() << " nevents " << m_nevents;
    if (trackCollection.empty())
        msg() << " : no tracks found" << endmsg;
    else {
        msg() << " : " << trackCollection.size() << " tracks found " << std::endl;
        TrackCollection::const_iterator tit = trackCollection.begin();
        TrackCollection::const_iterator tit_end = trackCollection.end();
        for (; tit != tit_end; ++tit) {
            if (m_doHitResiduals > 0) {
                msg() << m_printer->print(**tit) << "  " << m_printer->printStations(**tit) << std::endl;
                msg() << m_printer->printMeasurements(**tit);
            } else {
                msg() << m_printer->print(**tit) << "  " << m_printer->printStations(**tit);
            }
            // should finish with an 'endmsg' else the buffer does not get flushed.
            if (tit == tit_end - 1)
                msg() << endmsg;
            else
                msg() << std::endl;
        }
    }
}

evaluateTrackTruthOverlap()

MuonTrackPerformanceAlg::TrackData * MuonTrackPerformanceAlg::evaluateTrackTruthOverlap ( const Muon::MuonTrackTruth & truthTrack ) const

private

evaluate track/truth overlap and create the corresponding overlap description object

Definition at line 1082 of file MuonTrackPerformanceAlg.cxx.

                                                                                                                               {
    TrackData* trackData = new TrackData();
 
    // handle missing chambers
    insertTechnology(truthTrack.mdts.missedChambers, truthTrack.mdts.missedHits, m_minMdtHits, 0, trackData->missingChambers);
    if (m_idHelperSvc->hasCSC())
        insertTechnology(truthTrack.cscs.missedChambers, truthTrack.cscs.missedHits, m_minCscEtaHits, m_minCscPhiHits,
                         trackData->missingChambers);
    if (m_idHelperSvc->hasSTGC())
        insertTechnology(truthTrack.stgcs.missedChambers, truthTrack.stgcs.missedHits, m_minsTgcEtaHits, m_minsTgcPhiHits,
                         trackData->missingChambers);
    if (m_idHelperSvc->hasMM())
        insertTechnology(truthTrack.mms.missedChambers, truthTrack.mms.missedHits, m_minMMEtaHits, 0, trackData->missingChambers);
    insertTechnology(truthTrack.rpcs.missedChambers, truthTrack.rpcs.missedHits, m_minRpcEtaHits, m_minRpcPhiHits,
                     trackData->missingChambers);
    insertTechnology(truthTrack.tgcs.missedChambers, truthTrack.tgcs.missedHits, m_minTgcEtaHits, m_minTgcPhiHits,
                     trackData->missingChambers);
 
    // handle wrong chambers
    insertTechnology(truthTrack.mdts.wrongChambers, truthTrack.mdts.wrongHits, m_minMdtHits, 0, trackData->wrongChambers);
    if (m_idHelperSvc->hasCSC())
        insertTechnology(truthTrack.cscs.wrongChambers, truthTrack.cscs.wrongHits, m_minCscEtaHits, m_minCscPhiHits,
                         trackData->wrongChambers);
    if (m_idHelperSvc->hasSTGC())
        insertTechnology(truthTrack.stgcs.wrongChambers, truthTrack.stgcs.wrongHits, m_minsTgcEtaHits, m_minsTgcPhiHits,
                         trackData->wrongChambers);
    if (m_idHelperSvc->hasMM())
        insertTechnology(truthTrack.mms.wrongChambers, truthTrack.mms.wrongHits, m_minMMEtaHits, 0, trackData->wrongChambers);
    insertTechnology(truthTrack.rpcs.wrongChambers, truthTrack.rpcs.wrongHits, m_minRpcEtaHits, m_minRpcPhiHits, trackData->wrongChambers);
    insertTechnology(truthTrack.tgcs.wrongChambers, truthTrack.tgcs.wrongHits, m_minTgcEtaHits, m_minTgcPhiHits, trackData->wrongChambers);
 
    // handle layer information for precision chambers
    std::set<Muon::MuonStationIndex::StIndex> dummyList;
    insertStationLayers(truthTrack.mdts.matchedChambers, dummyList, trackData->layers);
    if (m_idHelperSvc->hasCSC()) insertStationLayers(truthTrack.cscs.matchedChambers, dummyList, trackData->layers);
    if (m_idHelperSvc->hasMM()) insertStationLayers(truthTrack.mms.matchedChambers, dummyList, trackData->layers);
 
    insertStationLayers(trackData->missingChambers, trackData->layers, trackData->missingLayers, true);
    insertStationLayers(trackData->wrongChambers, trackData->layers, trackData->wrongLayers, true);
 
    // handle layer information for precision chambers
    insertStationLayers(truthTrack.rpcs.matchedChambers, dummyList, trackData->layersTrigger);
    insertStationLayers(truthTrack.tgcs.matchedChambers, dummyList, trackData->layersTrigger);
    if (m_idHelperSvc->hasSTGC()) insertStationLayers(truthTrack.stgcs.matchedChambers, dummyList, trackData->layersTrigger);
 
    insertStationLayers(trackData->missingChambers, trackData->layersTrigger, trackData->missingLayersTrigger, false);
    insertStationLayers(trackData->wrongChambers, trackData->layersTrigger, trackData->wrongLayersTrigger, false);
 
    return trackData;
}

eventInfo()

std::string MuonTrackPerformanceAlg::eventInfo ( ) const

private

Definition at line 596 of file MuonTrackPerformanceAlg.cxx.

{ return std::to_string(eventNumber()); }

eventNumber()

int MuonTrackPerformanceAlg::eventNumber ( ) const

private

Definition at line 591 of file MuonTrackPerformanceAlg.cxx.

                                               {
    if (!m_eventInfo) return -1;
    return m_eventInfo->eventNumber();
}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode MuonTrackPerformanceAlg::execute ( )

overridevirtual

Definition at line 112 of file MuonTrackPerformanceAlg.cxx.

                                            {
 
    SG::ReadHandle<xAOD::EventInfo> evInfo(m_eventInfoKey);
    if (!evInfo.isValid()) {
        ATH_MSG_WARNING("failed to retrieve EventInfo");
        return StatusCode::FAILURE;
    }
    m_eventInfo = evInfo.cptr();
    handleTracks();
 
    ++m_nevents;
 
    return StatusCode::SUCCESS;
}

extractEtaPhiCounts()

void MuonTrackPerformanceAlg::extractEtaPhiCounts ( const std::set< Identifier > & ids, int & neta, int & nphi, int & netaCh, int & nphiCh ) const

private

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

finalize()

StatusCode MuonTrackPerformanceAlg::finalize ( )

overridevirtual

Definition at line 563 of file MuonTrackPerformanceAlg.cxx.

                                             {
    ATH_MSG_INFO(std::endl << MuonTrackPerformanceAlg::printTrackCounters());
 
    // write to file
    if (m_writeToFile) {
        std::string outfile = "trkPerformance_";
        outfile.append(m_trackTypeString);
        outfile.append(".txt");
        m_fileOutput.open(outfile.c_str(), std::ios::trunc);
 
        m_fileOutput << MuonTrackPerformanceAlg::printTrackCounters(false) << std::endl;
 
        m_fileOutput.close();
    }
 
    if (m_doTruth && m_doTrackDebug >= 1) {
        printMissingTracks();
        printMissingChambers();
        printFakeTracks();
    }
 
    std::vector<EventData>::iterator eit = m_badEvents.begin();
    std::vector<EventData>::iterator eit_end = m_badEvents.end();
    for (; eit != eit_end; ++eit) { clearEvent(*eit); }
 
    return StatusCode::SUCCESS;
}

getInitialState()

HepMC::ConstGenParticlePtr MuonTrackPerformanceAlg::getInitialState ( const TruthTrajectory & traj ) const

private

Definition at line 1391 of file MuonTrackPerformanceAlg.cxx.

                                                                                                   {
    std::vector<HepMcParticleLink>::const_reverse_iterator pit = traj.rbegin();
    std::vector<HepMcParticleLink>::const_reverse_iterator pit_end = traj.rend();
    for (; pit != pit_end; ++pit) {
        if (std::abs((*pit)->pdg_id()) != 13) {
            if (pit != traj.rbegin())
                --pit;
            else
                return nullptr;
            return *pit;
        }
    }
    return nullptr;
}

getMother()

HepMC::ConstGenParticlePtr MuonTrackPerformanceAlg::getMother ( const TruthTrajectory & traj ) const

private

Definition at line 1382 of file MuonTrackPerformanceAlg.cxx.

                                                                                             {
    std::vector<HepMcParticleLink>::const_reverse_iterator pit = traj.rbegin();
    std::vector<HepMcParticleLink>::const_reverse_iterator pit_end = traj.rend();
    for (; pit != pit_end; ++pit) {
        if (std::abs((*pit)->pdg_id()) != 13) return *pit;
    }
    return nullptr;
}

goodTruthTrack()

bool MuonTrackPerformanceAlg::goodTruthTrack ( const Muon::IMuonTrackTruthTool::TruthTreeEntry & entry ) const

private

Definition at line 235 of file MuonTrackPerformanceAlg.cxx.

                                                                                                     {
    if ((!entry.cscHits.empty() || (!entry.mmHits.empty() && !entry.stgcHits.empty())) && entry.mdtHits.empty()) return false;
    TrackRecord* trackRecord = const_cast<TrackRecord*>(entry.truthTrack);
    if (!trackRecord) return false;
    if (m_usePtCut) {
        if (trackRecord->GetMomentum().perp() < m_momentumCutSim) return false;
    } else {
        if (trackRecord->GetMomentum().mag() < m_momentumCutSim) return false;
    }
    if (!selectPdg(trackRecord->GetPDGCode())) return false;
    if (m_isCombined && std::abs(trackRecord->GetMomentum().eta()) > 2.5) return false;
    int hits = entry.mdtHits.size();
    if (m_idHelperSvc->hasCSC()) hits += entry.cscHits.size();
    if (m_idHelperSvc->hasMM()) hits += entry.mmHits.size();
    return (hits > 4);
}

handleSegmentCombi()

bool MuonTrackPerformanceAlg::handleSegmentCombi ( const Muon::MuonSegmentCombination & combi )

private

This method loops over the segments in the combi and filles them into the internal structure of the MuonCombiTrackMaker

Definition at line 127 of file MuonTrackPerformanceAlg.cxx.

                                                                                        {
 
    unsigned int nstations = combi.numberOfStations();
 
    // loop over chambers in combi and extract segments
    for (unsigned int i = 0; i < nstations; ++i) {
        // loop over segments in station
        const Muon::MuonSegmentCombination::SegmentVec* stationSegs = combi.stationSegments(i);
 
        // check if not empty
        if (!stationSegs || stationSegs->empty()) continue;
 
        Muon::MuonSegmentCombination::SegmentVec::const_iterator ipsg = stationSegs->begin();
        Muon::MuonSegmentCombination::SegmentVec::const_iterator ipsg_end = stationSegs->end();
        for (; ipsg != ipsg_end; ++ipsg) {
            const Muon::MuonSegment* seg = dynamic_cast<const Muon::MuonSegment*>((*ipsg).get());
 
            if (!seg) {
                ATH_MSG_WARNING("MuonSegmentCombination contains a segment that is not a MuonSegment!!");
                return false;
            }
        }
    }
 
    return true;
}

handleTracks()

bool MuonTrackPerformanceAlg::handleTracks ( )

private

Definition at line 155 of file MuonTrackPerformanceAlg.cxx.

                                           {
    std::unique_ptr<TrackCollection> allTracks = std::make_unique<TrackCollection>();
    if (!m_trackKey.key().empty()) {  // MS tracks
        SG::ReadHandle<TrackCollection> trackCol(m_trackKey);
        if (!trackCol.isValid()) {
            ATH_MSG_WARNING(" Could not find tracks at " << m_trackKey.key());
            return false;
        }
        m_trackTypeString = m_trackKey.key();
        ATH_MSG_DEBUG(" Retrieved " << trackCol->size() << " tracks from " << trackCol.key());
        m_ntracks += trackCol->size();
 
        if (m_doTruth) { handleTrackTruth(*trackCol); }
 
        if ((msgLvl(MSG::DEBUG) || m_doSummary >= 2) && !m_doTruth) { doSummary(*trackCol); }
    } else {
        SG::ReadHandle<xAOD::MuonContainer> muons(m_muons);
        if (!muons.isValid()) {
            ATH_MSG_WARNING("could not find muons");
            return false;
        }
        if (m_doStau)
            m_trackTypeString = "MuGirlStauCombinedTracks";
        else {
            if (m_isCombined)
                m_trackTypeString = "CombinedMuonTracks";
            else {
                if (m_trackType == (int)xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle)
                    m_trackTypeString = "MSOnlyExtrapolatedMuonTracks";
                else
                    m_trackTypeString = "ExtrapolatedMuonTracks";
            }
        }
        for (auto muon : *muons) {
            if (!m_doStau) {
                // if combined and not stau, only take MuidCo and MuGirl
                if (m_isCombined && muon->author() != 1 && muon->author() != 6) continue;
                if (!m_isCombined) {
                    // only MuidCo, MuidSA, and STACO will have MSOnlyExtrapolated tracks
                    if (m_trackType == xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle && muon->author() != 1 &&
                        muon->author() != 5 && muon->author() != 2)
                        continue;
                    // MuGirl should also have ME tracks
                    if (m_trackType == xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle && muon->author() != 1 &&
                        muon->author() != 5 && muon->author() != 2 && muon->author() != 6)
                        continue;
                }
            } else {
                // only staus
                if (muon->author() != 7) continue;
            }
            // TrackCollection is a DataVector so allTracks takes ownership of these copies
            const xAOD::TrackParticle* tp = muon->trackParticle((xAOD::Muon::TrackParticleType)m_trackType);
            if (!tp) {
                // possible that MS-only track doesn't exist for combined muon, if initial extrapolation fails but combined fit succeeds
                // otherwise, the track particle should be there, throw a warning
                if (m_trackType == xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle)
                    ATH_MSG_DEBUG("no track particle of type " << m_trackType << " for muon with author " << muon->author() << " and pT "
                                                               << muon->pt());
                else
                    ATH_MSG_WARNING("no track particle of type " << m_trackType << " for muon with author " << muon->author() << " and pT "
                                                                 << muon->pt());
                continue;
            }
            if (tp->track()) {
                m_ntracks++;
                allTracks->push_back(new Trk::Track(*tp->track()));
            } else
                ATH_MSG_WARNING("no track for this trackParticle, skipping");
        }
        ATH_MSG_DEBUG("got " << allTracks->size() << " tracks");
 
        if (m_doTruth) { handleTrackTruth(*allTracks.get()); }
 
        if ((msgLvl(MSG::DEBUG) || m_doSummary >= 2) && !m_doTruth) { doSummary(*allTracks.get()); }
    }
 
    return true;
}

handleTrackTruth()

bool MuonTrackPerformanceAlg::handleTrackTruth ( const TrackCollection & trackCollection )

private

Definition at line 252 of file MuonTrackPerformanceAlg.cxx.

                                                                                     {
    bool didOutput = false;
 
    unsigned int ntruthTracks(0);
    unsigned int ntruthTracksSecondary(0);
 
    SG::ReadHandle<TrackRecordCollection> truthTrackCol(m_trackRecord);
    SG::ReadHandle<McEventCollection> mcEventCollection(m_mcEventColl);
    std::vector<const MuonSimDataCollection*> muonSimData;
    for (SG::ReadHandle<MuonSimDataCollection>& simDataMap : m_muonSimData.makeHandles()) {
        if (!simDataMap.isValid()) {
            ATH_MSG_WARNING(simDataMap.key() << " not valid");
            continue;
        }
        if (!simDataMap.isPresent()) continue;
        muonSimData.push_back(simDataMap.cptr());
    }
    const CscSimDataCollection* cscSimData = nullptr;
    if (m_idHelperSvc->hasCSC()) {
        SG::ReadHandle<CscSimDataCollection> cscSimDataMap(m_cscSimData);
        if (!cscSimDataMap.isValid()) {
            ATH_MSG_WARNING(cscSimDataMap.key() << " not valid");
        } else {
            cscSimData = cscSimDataMap.cptr();
        }
    }
    const Muon::IMuonTrackTruthTool::TruthTree truthTree =
        m_truthTool->createTruthTree(truthTrackCol.cptr(), mcEventCollection.cptr(), muonSimData, cscSimData);
 
    // map TrackRecord onto entry for printing
    std::map<const TrackRecord*, Muon::IMuonTrackTruthTool::TruthTreeEntry> truthTrackEntryMap;
    Muon::IMuonTrackTruthTool::TruthTree::const_iterator tit = truthTree.begin();
    Muon::IMuonTrackTruthTool::TruthTree::const_iterator tit_end = truthTree.end();
    for (; tit != tit_end; ++tit) {
        if (!tit->second.truthTrack) continue;
 
        truthTrackEntryMap[tit->second.truthTrack] = tit->second;
 
        if (!goodTruthTrack(tit->second)) continue;
 
        bool isSec = isSecondary(tit->second);
 
        if (isSec)
            ++ntruthTracksSecondary;
        else
            ++ntruthTracks;
    }
 
    m_ntruthTracks += ntruthTracks;
    m_ntruthTracksSecondary += ntruthTracksSecondary;
 
    std::set<const Trk::Track*> matchedTracks;
    std::set<const Trk::Track*> matchedFakeTracks;
    std::map<const TrackRecord*, Muon::IMuonTrackTruthTool::MatchResult> bestMatched;
 
    unsigned int nmatched(0);
    unsigned int nmatchedSecondary(0);
 
    Muon::IMuonTrackTruthTool::ResultVec result = m_truthTool->match(truthTree, trackCollection);
    Muon::IMuonTrackTruthTool::ResultVec::iterator rit = result.begin();
    Muon::IMuonTrackTruthTool::ResultVec::iterator rit_end = result.end();
    for (; rit != rit_end; ++rit) {
        Muon::MuonTrackTruth& trackTruth = rit->second;
 
        // skip track if not matched to any muon
        if (!trackTruth.truthTrack) continue;
 
        // skip match if zero overlap with truth track
        if (trackTruth.numberOfMatchedHits() == 0) continue;
 
        std::map<const TrackRecord*, Muon::IMuonTrackTruthTool::TruthTreeEntry>::iterator pos =
            truthTrackEntryMap.find(trackTruth.truthTrack);
        if (pos == truthTrackEntryMap.end()) {
            ATH_MSG_WARNING("Truth track not found in map, this should not happen!!");
            continue;
        }
 
        if (!goodTruthTrack(pos->second)) continue;
 
        // see whether we already had an track matched to this truth track
        if (!bestMatched.count(trackTruth.truthTrack)) {
            // no track found yet, this is the best match
            bestMatched[trackTruth.truthTrack] = *rit;
 
            matchedTracks.insert(rit->first);
 
            bool isSec = isSecondary(pos->second);
 
            if (isSec)
                ++nmatchedSecondary;
            else
                ++nmatched;
 
        } else {
            ++m_nmatchedFakeTracks;
            matchedFakeTracks.insert(rit->first);
        }
    }
 
    m_nmatchedTracks += nmatched;
    m_nmatchedTracksSecondary += nmatchedSecondary;
    m_nfakeTracks += trackCollection.size() - nmatched;
 
    // now we have gathered all links between the tracks and truth.
    // Let's generate some diagnostics
 
    EventData eventData;
    eventData.eventNumber = eventNumber();
    eventData.eventPosition = m_nevents;
 
    if (m_doTrackDebug >= 5 || msgLvl(MSG::DEBUG)) {
        ATH_MSG_INFO("Event " << eventData.eventNumber << " truth tracks " << ntruthTracks);
    }
 
    // first loop over truth tracks that were found by reco
    std::map<const TrackRecord*, Muon::IMuonTrackTruthTool::MatchResult>::iterator mit = bestMatched.begin();
    std::map<const TrackRecord*, Muon::IMuonTrackTruthTool::MatchResult>::iterator mit_end = bestMatched.end();
    for (; mit != mit_end; ++mit) {
        Muon::MuonTrackTruth& truthTrack = mit->second.second;
        std::map<const TrackRecord*, Muon::IMuonTrackTruthTool::TruthTreeEntry>::iterator pos =
            truthTrackEntryMap.find(truthTrack.truthTrack);
        if (pos == truthTrackEntryMap.end()) {
            ATH_MSG_WARNING("Truth track not found in map, this should not happen!!");
            continue;
        }
 
        // create track summary
        TrackData* trackData = evaluateTrackTruthOverlap(truthTrack);
        if (!trackData) continue;
        addTrackToTrackData(*mit->second.first, *trackData);
        trackData->truthTrack = new TrackRecord(*mit->first);
        if (truthTrack.truthTrajectory) {
            trackData->truthTrajectory = new TruthTrajectory(*truthTrack.truthTrajectory);
            HepMC::ConstGenParticlePtr mother = getMother(*truthTrack.truthTrajectory);
            if (mother) {
                trackData->motherPdg = mother->pdg_id();
                if (mother->end_vertex())
                    trackData->productionVertex = new Amg::Vector3D(
                        mother->end_vertex()->position().x(), mother->end_vertex()->position().y(), mother->end_vertex()->position().z());
            }
            HepMC::ConstGenParticlePtr original = getInitialState(*truthTrack.truthTrajectory);
            if (original) {
                trackData->momentumAtProduction =
                    new Amg::Vector3D(original->momentum().x(), original->momentum().y(), original->momentum().z());
            }
        }
        // check whether track is all ok
        if (trackData->allOk()) {
            if (m_doTrackDebug >= 5 || msgLvl(MSG::DEBUG)) {
                ATH_MSG_INFO(print(*trackData));
                didOutput = true;
            }
            delete trackData;
            continue;
        }
 
        // if we get here something was wrong, let's evaluate what
        if (trackData->hasMissingChambers()) {
            if (trackData->isEndcapSLTrack() && trackData->isMissingInner()) {
                ++m_nmissingStationMomLoss;
                eventData.missingStationMomLoss.push_back(trackData);
            } else if (trackData->hasMissingLayers()) {
                ++m_nmissingStationLayer;
                eventData.missingStationLayer.push_back(trackData);
            } else if (trackData->hasMissingLayersTrigger()) {
                ++m_nmissingStationLayerTrigger;
                eventData.missingStationLayerTrigger.push_back(trackData);
            } else {
                ++m_nmissingStation;
                eventData.missingStation.push_back(trackData);
            }
        } else if (trackData->hasWrongChambers()) {
            if (trackData->hasWrongLayers()) {
                eventData.wrongStationLayer.push_back(trackData);
                ++m_nwrongStationLayer;
            } else if (trackData->hasWrongLayersTrigger()) {
                eventData.wrongStationLayer.push_back(trackData);
                ++m_nwrongStationLayerTrigger;
            } else {
                ++m_nwrongStation;
                eventData.wrongStation.push_back(trackData);
            }
        } else {
            ATH_MSG_WARNING("Unknown problem with matched track " << std::endl << print(*trackData));
            delete trackData;
            continue;
        }
 
        if (msgLvl(MSG::DEBUG) || m_doTrackDebug >= 4) {
            ATH_MSG_INFO("Incomplete track in event " << eventInfo() << " nevents " << m_nevents << std::endl
                         << print(*trackData));
            didOutput = true;
        }
    }
 
    // now the truth tracks that were not found
    unsigned int nmissed(0);
    tit = truthTree.begin();
    tit_end = truthTree.end();
    for (; tit != tit_end; ++tit) {
        // skip bad truth tracks
        if (!goodTruthTrack(tit->second)) continue;
 
        // check whether truth track was matched
        if (bestMatched.count(tit->second.truthTrack)) continue;
 
        TrackData* trackData = createTrackData(tit->second);
        if (!trackData) {
            ATH_MSG_WARNING("Failed to create TrackData for truth track");
            continue;
        }
        trackData->truthTrack = new TrackRecord(*tit->second.truthTrack);
        if (tit->second.truthTrajectory) {
            trackData->truthTrajectory = new TruthTrajectory(*tit->second.truthTrajectory);
            HepMC::ConstGenParticlePtr mother = getMother(*tit->second.truthTrajectory);
            if (mother) {
                trackData->motherPdg = mother->pdg_id();
                if (mother->end_vertex())
                    trackData->productionVertex = new Amg::Vector3D(
                        mother->end_vertex()->position().x(), mother->end_vertex()->position().y(), mother->end_vertex()->position().z());
            }
            HepMC::ConstGenParticlePtr original = getInitialState(*tit->second.truthTrajectory);
            if (original) {
                trackData->momentumAtProduction =
                    new Amg::Vector3D(original->momentum().x(), original->momentum().y(), original->momentum().z());
            }
        }
        if (m_doTrackDebug >= 3 || msgLvl(MSG::DEBUG)) {
            ATH_MSG_INFO("Truth track not found: " << std::endl << print(*trackData));
            didOutput = true;
        }
        bool isSec = isSecondary(tit->second);
 
        if (trackData->missingLayers.size() == 1) {
            if (isSec)
                ++m_nmissedTracksOneStationSecondary;
            else
                ++m_nmissedTracksOneStation;
            eventData.missingTruthTracksOneStation.push_back(trackData);
        } else {
            if (isSec)
                ++m_nmissedTracksSecondary;
            else
                ++m_nmissedTracks;
            eventData.missingTruthTracks.push_back(trackData);
        }
        ++nmissed;
    }
 
    // sanity check
    if (ntruthTracks < nmatched)
        ATH_MSG_WARNING("found more matched tracks than truth tracks: truth  " << ntruthTracks << "  matched " << nmatched);
 
    if (nmissed != ntruthTracks - nmatched)
        ATH_MSG_WARNING("inconsisted number of missed tracks: truth  " << ntruthTracks << "  matched " << nmatched << " missed " << nmissed);
 
    // finally print fake tracks
    TrackCollection::const_iterator trit = trackCollection.begin();
    TrackCollection::const_iterator trit_end = trackCollection.end();
    for (; trit != trit_end; ++trit) {
        if (matchedTracks.count(*trit)) continue;
 
        double pt = 1e9;
        if ((**trit).perigeeParameters()) {
            if (m_usePtCut)
                pt = (**trit).perigeeParameters()->momentum().perp();
            else
                pt = (**trit).perigeeParameters()->momentum().mag();
        }
        bool isSL = false;
        if (m_edmHelperSvc->isSLTrack(**trit)) {
            pt = 0.;
            isSL = true;
        }
        bool isHighPt = pt > m_momentumCut;
        bool matchedFake = matchedFakeTracks.count(*trit);
        std::string fakeType = isHighPt ? "HighPt" : "LowPt";
        if (isSL) fakeType = "SL";
        if (matchedFake) fakeType += " (matched)";
 
        TrackSummary summary;
        if (matchedFake) summary.trackPars = "(matched) ";
        summary.trackPars += m_printer->print(**trit);
        summary.chambers = m_printer->printStations(**trit);
 
        TrackData* trackData = new TrackData();
        addTrackToTrackData(**trit, *trackData);
        if (isHighPt) {
            eventData.fakeTracks.push_back(trackData);
            ++m_nfakeTracksHighPt;
        } else if (isSL) {
            ++m_nfakeTracksSL;
            eventData.fakeTracksSL.push_back(trackData);
        } else {
            ++m_nfakeTracksLowPt;
            eventData.fakeTracksLowPt.push_back(trackData);
        }
 
        if (m_doTrackDebug >= 3 || msgLvl(MSG::DEBUG)) {
            msg() << MSG::INFO << "Fake track " << fakeType << ": " << std::endl
                  << summary.trackPars << "  " << summary.chambers << std::endl;
            didOutput = true;
        }
    }
    if (didOutput) { msg() << MSG::INFO << endmsg; }
 
    if (!eventData.goodEvent()) m_badEvents.push_back(eventData);
 
    return true;
}

initialize()

StatusCode MuonTrackPerformanceAlg::initialize ( )

overridevirtual

Definition at line 77 of file MuonTrackPerformanceAlg.cxx.

                                               {
 
    ATH_CHECK(m_idHelperSvc.retrieve());
    ATH_CHECK(m_printer.retrieve());
    ATH_CHECK(m_edmHelperSvc.retrieve());
    ATH_CHECK(m_truthTool.retrieve(EnableTool{m_doTruth}));   
 
    ATH_CHECK(m_summaryHelperTool.retrieve());
 
    // add muons
    if (m_pdgsToBeConsidered.value().empty()) {
        m_selectedPdgs.insert(13);
        m_selectedPdgs.insert(-13);
    } else {
        // add pdgs
        for (auto pdg : m_pdgsToBeConsidered.value()) m_selectedPdgs.insert(pdg);
        msg(MSG::DEBUG) << " PDG codes used for matching";
        for (auto val : m_selectedPdgs) msg(MSG::DEBUG) << " " << val;
        msg(MSG::DEBUG) << endmsg;
    }
 
    ATH_CHECK(m_trackKey.initialize(!m_trackKey.key().empty())); 
    ATH_CHECK(m_muons.initialize(!m_muons.key().empty())); 
    
    ATH_CHECK(m_eventInfoKey.initialize());
 
    ATH_CHECK(m_mcEventColl.initialize(m_doTruth));
    if (!(m_idHelperSvc->hasSTGC() && m_idHelperSvc->hasMM())) m_muonSimData = {"MDT_SDO", "RPC_SDO", "TGC_SDO"};
    ATH_CHECK(m_muonSimData.initialize(m_doTruth));
    ATH_CHECK(m_cscSimData.initialize(m_doTruth && m_idHelperSvc->hasCSC()));
    ATH_CHECK(m_trackRecord.initialize(m_doTruth));
 
    return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

insertChamber()

bool MuonTrackPerformanceAlg::insertChamber ( const Identifier & chId, const std::set< Identifier > & hits, int minEtaHits, int minPhiHits, MuonTrackPerformanceAlg::ChamberData & chamberData ) const

private

insert chamber information into ChamberData if hits counts pass cuts, returns true if anything was inserted

Definition at line 1015 of file MuonTrackPerformanceAlg.cxx.

                                                                                                   {
    // flag whether chamber passes selection
    bool passesThreshold = false;
 
    // count eta and phi hits in chamber
    std::pair<int, int> missingHits = countHitsInChamber(chId, hits);
    if (missingHits.first >= minEtaHits) passesThreshold = true;
    if (missingHits.second >= minPhiHits) passesThreshold = true;
 
 
    // if inside cuts, copy the hits into summary
    if (passesThreshold) {
        chamberData.chId = chId;
        std::set<Identifier>::const_iterator it = hits.begin();
        std::set<Identifier>::const_iterator it_end = hits.end();
        for (; it != it_end; ++it) {
            Identifier ch = m_idHelperSvc->chamberId(*it);
            if (ch == chId) {
                chamberData.hits.insert(*it);
            }
        }
    }
    return passesThreshold;
}

insertStationLayers() [1/2]

bool MuonTrackPerformanceAlg::insertStationLayers ( const std::set< Identifier > & chIds, const std::set< Muon::MuonStationIndex::StIndex > & exclusionList, std::set< Muon::MuonStationIndex::StIndex > & layers ) const

private

insert station layers into layer set if they are not in exclusion list

Definition at line 1053 of file MuonTrackPerformanceAlg.cxx.

                                                                                                     {
    unsigned int inputSize = layers.size();
 
    std::set<Identifier>::const_iterator chit = chIds.begin();
    std::set<Identifier>::const_iterator chit_end = chIds.end();
    for (; chit != chit_end; ++chit) {
        Muon::MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(*chit);
        if (!exclusionList.count(stIndex)) layers.insert(stIndex);
    }
 
    return inputSize != layers.size();
}

insertStationLayers() [2/2]

bool MuonTrackPerformanceAlg::insertStationLayers ( const std::vector< ChamberData > & chambers, const std::set< Muon::MuonStationIndex::StIndex > & exclusionList, std::set< Muon::MuonStationIndex::StIndex > & layers, bool usePrecision ) const

private

insert chamber data into layers if not in exclusion list

Definition at line 1068 of file MuonTrackPerformanceAlg.cxx.

                                                                                                                        {
    std::set<Identifier> chIds;
    std::vector<ChamberData>::const_iterator chit = chambers.begin();
    std::vector<ChamberData>::const_iterator chit_end = chambers.end();
    for (; chit != chit_end; ++chit) {
        bool isTrigger = m_idHelperSvc->isTrigger(chit->chId);
        if ((usePrecision && isTrigger) || (!usePrecision && !isTrigger)) continue;
        chIds.insert(m_idHelperSvc->chamberId(chit->chId));
    }
    return insertStationLayers(chIds, exclusionList, layers);
}

insertTechnology()

bool MuonTrackPerformanceAlg::insertTechnology ( const std::set< Identifier > & chIds, const std::set< Identifier > & hits, int minEtaHits, int minPhiHits, std::vector< ChamberData > & chamberData ) const

private

insert set of chambers into chamber data if hits counts pass cuts, returns true if anything was inserted

Definition at line 1041 of file MuonTrackPerformanceAlg.cxx.

                                                                                                                              {
    // loop over chambers
    std::set<Identifier>::const_iterator it = chIds.begin();
    std::set<Identifier>::const_iterator it_end = chIds.end();
    for (; it != it_end; ++it) {
        ChamberData chData;
        if (insertChamber(*it, hits, minEtaHits, minPhiHits, chData)) chambers.push_back(chData);
    }
    return !chambers.empty();
}

isSecondary() [1/3]

bool MuonTrackPerformanceAlg::isSecondary ( const Muon::IMuonTrackTruthTool::TruthTreeEntry & entry ) const

private

Definition at line 1411 of file MuonTrackPerformanceAlg.cxx.

                                                                                                  {
    if (!entry.truthTrajectory) return false;
    return isSecondary(*entry.truthTrajectory);
}

isSecondary() [2/3]

bool MuonTrackPerformanceAlg::isSecondary ( const Muon::MuonTrackTruth & truthTrack ) const

private

Definition at line 1406 of file MuonTrackPerformanceAlg.cxx.

                                                                                    {
    if (!truthTrack.truthTrajectory) return false;
    return isSecondary(*truthTrack.truthTrajectory);
}

isSecondary() [3/3]

bool MuonTrackPerformanceAlg::isSecondary ( const TruthTrajectory & truthTrajectory ) const

private

Definition at line 1416 of file MuonTrackPerformanceAlg.cxx.

                                                                                      {
    HepMC::ConstGenParticlePtr mother = getMother(truthTrajectory);
    if (mother && mother->end_vertex() && mother->end_vertex()->position().perp() > 100.) return true;
    return false;
}

msg()

MsgStream & AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

print() [1/4]

std::string MuonTrackPerformanceAlg::print ( const EventData & event, const std::vector< const Trk::Track * > & tracks, const std::string & message ) const

private

Definition at line 763 of file MuonTrackPerformanceAlg.cxx.

                                                                           {
    std::ostringstream sout;
    if (!tracks.empty()) {
        sout << "  Event " << event.eventNumber << " position in file " << event.eventPosition << " has " << tracks.size() << " " << message
             << std::endl;
        std::vector<const Trk::Track*>::const_iterator it = tracks.begin();
        std::vector<const Trk::Track*>::const_iterator it_end = tracks.end();
        for (; it != it_end; ++it) { sout << m_printer->print(**it) << std::endl << m_printer->printStations(**it) << std::endl; }
    }
    return sout.str();
}

print() [2/4]

std::string MuonTrackPerformanceAlg::print ( const EventData & event, const std::vector< TrackData * > & tracks, const std::string & message ) const

private

Definition at line 750 of file MuonTrackPerformanceAlg.cxx.

                                                                                                                                       {
    std::ostringstream sout;
    if (!tracks.empty()) {
        sout << "  Event " << event.eventNumber << " position in file " << event.eventPosition << " has " << tracks.size() << " " << message
             << std::endl;
        std::vector<TrackData*>::const_iterator it = tracks.begin();
        std::vector<TrackData*>::const_iterator it_end = tracks.end();
        for (; it != it_end; ++it) { sout << print(**it) << std::endl; }
    }
    return sout.str();
}

print() [3/4]

std::string MuonTrackPerformanceAlg::print ( const Muon::IMuonTrackTruthTool::TruthTreeEntry & trackTruth ) const

private

Definition at line 642 of file MuonTrackPerformanceAlg.cxx.

                                                                                                      {
    std::ostringstream sout;
    if (!trackTruth.truthTrack) {
        sout << " No TrackRecord found! ";
        return sout.str();
    }
 
    TrackRecord& trackRecord = const_cast<TrackRecord&>(*trackTruth.truthTrack);
    double charge = trackRecord.GetPDGCode() < 0 ? +1 : -1;
 
    // keep track of which chambers are present
    std::map<Identifier, std::pair<int, int> > precisionIds;
    std::map<Identifier, std::pair<int, int> > triggerIds;
    std::map<Identifier, std::pair<int, int> > nhitsCompIds;
 
    unsigned int neta = 0;
    unsigned int netaTrig = 0;
    unsigned int nphi = 0;
 
    std::set<Identifier> allIds;
    MuonSimDataCollection::const_iterator mit = trackTruth.mdtHits.begin();
    MuonSimDataCollection::const_iterator mit_end = trackTruth.mdtHits.end();
    for (; mit != mit_end; ++mit) allIds.insert(mit->first);
 
    if (m_idHelperSvc->hasCSC()) {
        CscSimDataCollection::const_iterator cit = trackTruth.cscHits.begin();
        CscSimDataCollection::const_iterator cit_end = trackTruth.cscHits.end();
        for (; cit != cit_end; ++cit) allIds.insert(m_idHelperSvc->layerId(cit->first));
    }
    if (m_idHelperSvc->hasSTGC()) {
        mit = trackTruth.stgcHits.begin();
        mit_end = trackTruth.stgcHits.end();
        for (; mit != mit_end; ++mit) allIds.insert(m_idHelperSvc->layerId(mit->first));
    }
    if (m_idHelperSvc->hasMM()) {
        mit = trackTruth.mmHits.begin();
        mit_end = trackTruth.mmHits.end();
        for (; mit != mit_end; ++mit) allIds.insert(m_idHelperSvc->layerId(mit->first));
    }
 
    mit = trackTruth.rpcHits.begin();
    mit_end = trackTruth.rpcHits.end();
    for (; mit != mit_end; ++mit) allIds.insert(m_idHelperSvc->layerId(mit->first));
 
    mit = trackTruth.tgcHits.begin();
    mit_end = trackTruth.tgcHits.end();
    for (; mit != mit_end; ++mit) allIds.insert(m_idHelperSvc->layerId(mit->first));
 
    std::set<Identifier>::iterator it = allIds.begin();
    std::set<Identifier>::iterator it_end = allIds.end();
    for (; it != it_end; ++it) {
        Identifier id = *it;
        Identifier chId = m_idHelperSvc->chamberId(id);
        bool measuresPhi = m_idHelperSvc->measuresPhi(id);
        if (measuresPhi) {
            ++nhitsCompIds[chId].first;
        } else {
            ++nhitsCompIds[chId].second;
        }
 
        if (m_idHelperSvc->isTrigger(chId)) {
            if (measuresPhi) {
                ++triggerIds[chId].first;
                ++nphi;
            } else {
                ++triggerIds[chId].second;
                ++netaTrig;
            }
            continue;
        }
        if (measuresPhi) {
            ++precisionIds[chId].first;
            ++nphi;
        } else {
            ++precisionIds[chId].second;
            ++neta;
        }
    }
    sout << "Truth:        hits " << std::setw(5) << neta + nphi + netaTrig << " r " << (int)trackRecord.GetPosition().perp() << " z "
         << (int)trackRecord.GetPosition().z() << std::setprecision(5) << " phi " << trackRecord.GetMomentum().phi() << " theta "
         << trackRecord.GetMomentum().theta() << std::setw(6) << " q*mom " << (int)trackRecord.GetMomentum().mag() * charge << " pt "
         << std::setw(5) << (int)trackRecord.GetMomentum().perp();
    if (std::abs(trackRecord.GetPDGCode()) != 13) sout << " pdg " << trackRecord.GetPDGCode();
 
    if (trackTruth.truthTrajectory) {
        HepMC::ConstGenParticlePtr mother = getMother(*trackTruth.truthTrajectory);
        if (mother) { sout << " mother " << mother->pdg_id(); }
    }
 
    sout << "   Eta hits " << neta << "  phi " << nphi << "  eta trig " << netaTrig << std::endl;
    std::map<Identifier, std::pair<int, int> >::iterator iit = precisionIds.begin();
    std::map<Identifier, std::pair<int, int> >::iterator iit_end = precisionIds.end();
    for (; iit != iit_end; ++iit) {
        sout.setf(std::ios::left);
        sout << "  " << std::setw(32) << m_idHelperSvc->toStringChamber(iit->first) << " hits: eta " << std::setw(3) << iit->second.second
             << " phi " << std::setw(3) << iit->second.first << std::endl;
    }
    iit = triggerIds.begin();
    iit_end = triggerIds.end();
    for (; iit != iit_end; ++iit) {
        sout << "  " << std::setw(32) << m_idHelperSvc->toStringChamber(iit->first) << " hits: eta " << std::setw(3)
             << nhitsCompIds[iit->first].second << " phi " << std::setw(3) << nhitsCompIds[iit->first].first << "   stations: Eta "
             << iit->second.second << " Phi " << iit->second.first << std::endl;
    }
 
    return sout.str();
}

print() [4/4]

std::string MuonTrackPerformanceAlg::print ( const TrackData & trackData ) const

private

print TrackData to a string

Definition at line 1133 of file MuonTrackPerformanceAlg.cxx.

                                                                                                {
    std::ostringstream sout;
 
    //   bool atIP = false;
    //   if( trackData.trackPars && trackData.trackPars->associatedSurface().center().mag() < 1000. ) atIP = true;
 
    if (trackData.truthTrack) {
        double charge = trackData.truthTrack->GetPDGCode() < 0 ? +1 : -1;
        Trk::Perigee perigee(Amg::Vector3D(trackData.truthTrack->GetPosition().x(), trackData.truthTrack->GetPosition().y(),
                                           trackData.truthTrack->GetPosition().z()),
                             Amg::Vector3D(trackData.truthTrack->GetMomentum().x(), trackData.truthTrack->GetMomentum().y(),
                                           trackData.truthTrack->GetMomentum().z()),
                             charge, Trk::PerigeeSurface(Amg::Vector3D(0., 0., 0.)));
        sout << "Truth: " << m_printer->print(perigee);  // << " barcode " << trackData.truthTrack->barcode();
        if (std::abs(trackData.truthTrack->GetPDGCode()) == 13) {
            if (trackData.motherPdg != -1) sout << " mother " << trackData.motherPdg;
        } else {
            sout << " pdg " << trackData.truthTrack->GetPDGCode();
        }
        if (trackData.momentumAtProduction) sout << " production p:  " << trackData.momentumAtProduction->mag();
 
        // if( trackData.productionVertex ) sout << " production vertex: r  " << trackData.productionVertex->perp()
        //                    << " z " << trackData.productionVertex->z();
        sout << std::endl;
    }
 
    if (trackData.trackPars) {
        sout << "Track: " << m_printer->print(*trackData.trackPars) << " chi2/ndof " << trackData.chi2Ndof << std::endl;
        if (trackData.trackPars->covariance()) {
            double qOverP = std::abs(trackData.trackPars->parameters()[Trk::qOverP]);
            double dpp = 0.;
            double cov00 = (*trackData.trackPars->covariance())(0, 0);
            double cov11 = (*trackData.trackPars->covariance())(1, 1);
            double cov22 = (*trackData.trackPars->covariance())(2, 2);
            double cov33 = (*trackData.trackPars->covariance())(3, 3);
            double cov44 = (*trackData.trackPars->covariance())(4, 4);
            if (qOverP > 0) dpp = std::sqrt(cov44) / qOverP;
            sout << " error d0 " << std::sqrt(cov00) << " z0 " << std::sqrt(cov11) << " phi (mrad) " << 1000 * std::sqrt(cov22)
                 << " theta (mrad) " << 1000 * std::sqrt(cov33) << " dp/p " << dpp << std::endl;
        }
 
        if (trackData.trackSummary && trackData.trackSummary->muonTrackSummary())
            sout << m_printer->print(*trackData.trackSummary->muonTrackSummary()) << std::endl;
    }
 
    if (!trackData.missingChambers.empty()) {
        sout << " Missing Chambers: " << std::endl;
        std::vector<ChamberData>::const_iterator chIt = trackData.missingChambers.begin();
        std::vector<ChamberData>::const_iterator chIt_end = trackData.missingChambers.end();
        for (; chIt != chIt_end; ++chIt) {
            sout << "    " << m_idHelperSvc->toStringChamber(chIt->chId) << " hits " << chIt->hits.size() << std::endl;
            if (m_doTrackDebug >= 6) {
                std::set<Identifier>::const_iterator hit = chIt->hits.begin();
                std::set<Identifier>::const_iterator hit_end = chIt->hits.end();
                for (; hit != hit_end; ++hit) { sout << "          " << m_idHelperSvc->toString(*hit) << std::endl; }
            }
        }
    }
 
    if (!trackData.wrongChambers.empty()) {
        sout << " Wrong Chambers: " << std::endl;
        std::vector<ChamberData>::const_iterator chIt = trackData.wrongChambers.begin();
        std::vector<ChamberData>::const_iterator chIt_end = trackData.wrongChambers.end();
        for (; chIt != chIt_end; ++chIt) {
            sout << "    " << m_idHelperSvc->toStringChamber(chIt->chId) << " hits " << chIt->hits.size() << std::endl;
            if (m_doTrackDebug >= 6) {
                std::set<Identifier>::const_iterator hit = chIt->hits.begin();
                std::set<Identifier>::const_iterator hit_end = chIt->hits.end();
                for (; hit != hit_end; ++hit) { sout << "          " << m_idHelperSvc->toString(*hit) << std::endl; }
            }
        }
    }
 
    if (!trackData.missingLayers.empty() || !trackData.missingLayersTrigger.empty()) {
        sout << " Missing Layers: ";
        if (!trackData.missingLayers.empty()) {
            sout << " Precision: ";
            std::set<Muon::MuonStationIndex::StIndex>::const_iterator it = trackData.missingLayers.begin();
            std::set<Muon::MuonStationIndex::StIndex>::const_iterator it_end = trackData.missingLayers.end();
            for (; it != it_end; ++it) sout << " " << Muon::MuonStationIndex::stName(*it);
        }
 
        if (!trackData.missingLayersTrigger.empty()) {
            sout << " Trigger: ";
            std::set<Muon::MuonStationIndex::StIndex>::const_iterator it = trackData.missingLayersTrigger.begin();
            std::set<Muon::MuonStationIndex::StIndex>::const_iterator it_end = trackData.missingLayersTrigger.end();
            for (; it != it_end; ++it) sout << " " << Muon::MuonStationIndex::stName(*it);
        }
        sout << std::endl;
    }
 
    if (!trackData.wrongLayers.empty() || !trackData.wrongLayersTrigger.empty()) {
        sout << " TrackData.Wrong Layers: ";
        if (!trackData.wrongLayers.empty()) {
            sout << " Precision: ";
            std::set<Muon::MuonStationIndex::StIndex>::const_iterator it = trackData.wrongLayers.begin();
            std::set<Muon::MuonStationIndex::StIndex>::const_iterator it_end = trackData.wrongLayers.end();
            for (; it != it_end; ++it) sout << " " << Muon::MuonStationIndex::stName(*it);
        }
 
        if (!trackData.wrongLayersTrigger.empty()) {
            sout << " Trigger: ";
            std::set<Muon::MuonStationIndex::StIndex>::const_iterator it = trackData.wrongLayersTrigger.begin();
            std::set<Muon::MuonStationIndex::StIndex>::const_iterator it_end = trackData.wrongLayersTrigger.end();
            for (; it != it_end; ++it) sout << " " << Muon::MuonStationIndex::stName(*it);
        }
        sout << std::endl;
    }
    return sout.str();
}

printFakeTracks()

void MuonTrackPerformanceAlg::printFakeTracks ( ) const

private

Definition at line 885 of file MuonTrackPerformanceAlg.cxx.

                                                    {
    std::fstream outputFile;
    if (m_doEventListFake > 0) {
        std::string filename = name();
        filename += "EventListFakeTracks.txt";
        outputFile.open(filename.c_str(), std::ios_base::out | std::ios_base::trunc);
    }
 
    msg() << MSG::INFO << "Summarizing events with fake tracks, high pt, total " << m_nfakeTracksHighPt << std::endl;
    std::vector<EventData>::const_iterator eit = m_badEvents.begin();
    std::vector<EventData>::const_iterator eit_end = m_badEvents.end();
    for (; eit != eit_end; ++eit) {
        if (eit->fakeTracks.empty()) continue;
        msg() << print(*eit, eit->fakeTracks, "  high pt fake tracks") << std::endl;
        if (m_doEventListFake > 0) outputFile << eit->eventNumber << std::endl;
    }
    msg() << endmsg;
 
    msg() << MSG::INFO << "Summarizing events with fake tracks, low pt, total " << m_nfakeTracksLowPt << std::endl;
    eit = m_badEvents.begin();
    eit_end = m_badEvents.end();
    for (; eit != eit_end; ++eit) {
        if (eit->fakeTracksLowPt.empty()) continue;
        msg() << print(*eit, eit->fakeTracksLowPt, "  low pt fake tracks") << std::endl;
        if (m_doEventListFake > 1) outputFile << eit->eventNumber << std::endl;
    }
    msg() << endmsg;
 
    msg() << MSG::INFO << "Summarizing events with fake tracks, SL, total " << m_nfakeTracksSL << std::endl;
    eit = m_badEvents.begin();
    eit_end = m_badEvents.end();
    for (; eit != eit_end; ++eit) {
        if (eit->fakeTracksSL.empty()) continue;
        msg() << print(*eit, eit->fakeTracksSL, "  SL fake tracks") << std::endl;
        if (m_doEventListFake > 2) outputFile << eit->eventNumber << std::endl;
    }
    msg() << endmsg;
}

printMissingChambers()

void MuonTrackPerformanceAlg::printMissingChambers ( ) const

private

Definition at line 776 of file MuonTrackPerformanceAlg.cxx.

                                                         {
    std::fstream outputFile;
    if (m_doEventListIncomplete > 0) {
        std::string filename = name();
        filename += "EventListIncompleteTracks.txt";
        outputFile.open(filename.c_str(), std::ios_base::out | std::ios_base::trunc);
    }
 
    msg() << MSG::INFO << "Summarizing events with endcap track without EI layer resulting in momentum loss, total "
           << m_nmissingStationMomLoss << std::endl;
    std::vector<EventData>::const_iterator eit = m_badEvents.begin();
    std::vector<EventData>::const_iterator eit_end = m_badEvents.end();
    for (; eit != eit_end; ++eit) {
        if (eit->missingStationMomLoss.empty()) continue;
        msg() << print(*eit, eit->missingStationMomLoss, "  tracks without inner layer in endcap") << std::endl;
        if (m_doEventListIncomplete > 0) outputFile << eit->eventNumber << std::endl;
    }
    msg() << endmsg;
 
    msg() << MSG::INFO << "Summarizing events with track with missing layer, total " << m_nmissingStationLayer << std::endl;
    eit = m_badEvents.begin();
    eit_end = m_badEvents.end();
    for (; eit != eit_end; ++eit) {
        if (eit->missingStationLayer.empty()) continue;
        msg() << print(*eit, eit->missingStationLayer, "  tracks with a missing layer") << std::endl;
        if (m_doEventListIncomplete > 0) outputFile << eit->eventNumber << std::endl;
    }
    msg() << endmsg;
 
    msg() << MSG::INFO << "Summarizing events with track with missing chamber, total " << m_nmissingStation << std::endl;
    eit = m_badEvents.begin();
    eit_end = m_badEvents.end();
    for (; eit != eit_end; ++eit) {
        if (eit->missingStation.empty()) continue;
        msg() << print(*eit, eit->missingStation, "  tracks with a missing chamber") << std::endl;
        if (m_doEventListIncomplete > 1) outputFile << eit->eventNumber << std::endl;
    }
    msg() << endmsg;
 
    msg() << MSG::INFO << "Summarizing events with track with wrong layer, total " << m_nwrongStationLayer << std::endl;
    eit = m_badEvents.begin();
    eit_end = m_badEvents.end();
    for (; eit != eit_end; ++eit) {
        if (eit->wrongStation.empty()) continue;
        msg() << print(*eit, eit->wrongStation, "  tracks with a wrong layer") << std::endl;
        if (m_doEventListIncomplete > 0) outputFile << eit->eventNumber << std::endl;
    }
    msg() << endmsg;
 
    msg() << MSG::INFO << "Summarizing events with track with wrong chamber, total " << m_nwrongStation << std::endl;
    eit = m_badEvents.begin();
    eit_end = m_badEvents.end();
    for (; eit != eit_end; ++eit) {
        if (eit->wrongStation.empty()) continue;
        msg() << print(*eit, eit->wrongStation, "  tracks with a wrong chamber") << std::endl;
        if (m_doEventListIncomplete > 0) outputFile << eit->eventNumber << std::endl;
    }
    msg() << endmsg;
 
    msg() << MSG::INFO << "Summarizing events with track with missing trigger layer, total " << m_nmissingStationLayerTrigger << std::endl;
    eit = m_badEvents.begin();
    eit_end = m_badEvents.end();
    for (; eit != eit_end; ++eit) {
        if (eit->missingStationLayerTrigger.empty()) continue;
        msg() << print(*eit, eit->missingStationLayerTrigger, "  tracks with a missing trigger layer") << std::endl;
        if (m_doEventListIncomplete > 0) outputFile << eit->eventNumber << std::endl;
    }
    msg() << endmsg;
 
    msg() << MSG::INFO << "Summarizing events with track with wrong trigger layer, total " << m_nwrongStationLayerTrigger << std::endl;
    eit = m_badEvents.begin();
    eit_end = m_badEvents.end();
    for (; eit != eit_end; ++eit) {
        if (eit->wrongStationLayerTrigger.empty()) continue;
        msg() << print(*eit, eit->wrongStationLayerTrigger, "  tracks with a wrong trigger layer") << std::endl;
        if (m_doEventListIncomplete > 0) outputFile << eit->eventNumber << std::endl;
    }
    msg() << endmsg;
}

printMissingTracks()

void MuonTrackPerformanceAlg::printMissingTracks ( ) const

private

Definition at line 856 of file MuonTrackPerformanceAlg.cxx.

                                                       {
    std::fstream outputFile;
    if (m_doEventListMissed > 0) {
        std::string filename = name();
        filename += "EventListMissedTracks.txt";
        outputFile.open(filename.c_str(), std::ios_base::out | std::ios_base::trunc);
    }
 
    msg() << MSG::INFO << "Summarizing events with missing track, total " << m_nmissedTracks << std::endl;
    std::vector<EventData>::const_iterator eit = m_badEvents.begin();
    std::vector<EventData>::const_iterator eit_end = m_badEvents.end();
    for (; eit != eit_end; ++eit) {
        if (eit->missingTruthTracks.empty()) continue;
        msg() << print(*eit, eit->missingTruthTracks, "  missing tracks") << std::endl;
        if (m_doEventListMissed > 0) outputFile << eit->eventNumber << std::endl;
    }
    msg() << endmsg;
 
    msg() << MSG::INFO << "Summarizing events with missing single station track, total " << m_nmissedTracksOneStation << std::endl;
    eit = m_badEvents.begin();
    eit_end = m_badEvents.end();
    for (; eit != eit_end; ++eit) {
        if (eit->missingTruthTracksOneStation.empty()) continue;
        msg() << print(*eit, eit->missingTruthTracksOneStation, "  missing single station tracks") << std::endl;
        if (m_doEventListMissed > 1) outputFile << eit->eventNumber << std::endl;
    }
    msg() << endmsg;
}

printSummary()

void MuonTrackPerformanceAlg::printSummary ( const std::vector< EventSummary > & summary, std::string typeName ) const

private

printTrackCounters()

std::string MuonTrackPerformanceAlg::printTrackCounters ( bool doSecondaries = true ) const

private

print all the track counters to a string to provide a summary

Definition at line 924 of file MuonTrackPerformanceAlg.cxx.

                                                                              {
    std::ostringstream sout;
    sout.precision(4);
 
    double evScale = m_nevents != 0 ? 1. / m_nevents : 1.;
 
    sout << std::endl;
    sout << "Summarizing results for track collection " << m_trackTypeString << "  " << m_nevents << " events: " << std::endl
         << "  number of tracks                           " << std::setw(12) << m_ntracks << "   average per event " << m_ntracks * evScale;
 
    if (m_doTruth) {
        unsigned int nmatchedTracks = !doSecondaries ? m_nmatchedTracks : m_nmatchedTracks + m_nmatchedTracksSecondary;
        unsigned int nmissedTracks = !doSecondaries ? m_nmissedTracks : m_nmissedTracks + m_nmissedTracksSecondary;
        unsigned int nmissedTracksOneStation =
            !doSecondaries ? m_nmissedTracksOneStation : m_nmissedTracksOneStation + m_nmissedTracksOneStationSecondary;
        unsigned int ntruthTracks = !doSecondaries ? m_ntruthTracks : m_ntruthTracks + m_ntruthTracksSecondary;
 
        double trTrkScale = ntruthTracks != 0 ? 1. / ntruthTracks : 1.;
        double trTrkScaleSec = m_ntruthTracksSecondary != 0 ? 1. / m_ntruthTracksSecondary : 1.;
 
        sout << std::endl
             << "  number of truth tracks                     " << std::setw(12) << ntruthTracks << "   average per event "
             << ntruthTracks * evScale << std::endl
             << "  number of good tracks                      " << std::setw(12) << nmatchedTracks << "   average per event "
             << nmatchedTracks * evScale << std::endl
             << "  number of missed multi station tracks      " << std::setw(12) << nmissedTracks << "   average per event "
             << nmissedTracks * evScale << std::endl
             << "  number of missed one station tracks        " << std::setw(12) << nmissedTracksOneStation << "   average per event "
             << nmissedTracksOneStation * evScale << std::endl;
        if (doSecondaries) {
            sout << "  number of secondary truth tracks           " << std::setw(12) << m_ntruthTracksSecondary << "   average per event "
                 << m_ntruthTracksSecondary * evScale << std::endl
                 << "  number of secondary good tracks            " << std::setw(12) << m_nmatchedTracksSecondary << "   average per event "
                 << m_nmatchedTracksSecondary * evScale << std::endl
                 << "  number of secondary missed multi st tracks " << std::setw(12) << m_nmissedTracksSecondary << "   average per event "
                 << m_nmissedTracksSecondary * evScale << std::endl
                 << "  number of secondary missed one st tracks   " << std::setw(12) << m_nmissedTracksOneStationSecondary
                 << "   average per event " << m_nmissedTracksOneStationSecondary * evScale << std::endl;
        }
        sout << "  number of fake tracks                      " << std::setw(12) << m_nfakeTracks << "   average per event "
             << m_nfakeTracks * evScale << std::endl
             << "  number of high pt fake tracks              " << std::setw(12) << m_nfakeTracksHighPt << "   average per event "
             << m_nfakeTracksHighPt * evScale << std::endl
             << "  number of low pt fake tracks               " << std::setw(12) << m_nfakeTracksLowPt << "   average per event "
             << m_nfakeTracksLowPt * evScale << std::endl
             << "  number of SL fake tracks                   " << std::setw(12) << m_nfakeTracksSL << "   average per event "
             << m_nfakeTracksSL * evScale << std::endl
             << "  number of matched fake tracks              " << std::setw(12) << m_nmatchedFakeTracks << "   average per event "
             << m_nmatchedFakeTracks * evScale << std::endl
             << "  number of tracks with lost momentum        " << std::setw(12) << m_nmissingStationMomLoss
             << "   average per truth track " << m_nmissingStationMomLoss * trTrkScale << std::endl
             << "  number of tracks missing precision layer   " << std::setw(12) << m_nmissingStationLayer << "   average per truth track "
             << m_nmissingStationLayer * trTrkScale << std::endl
             << "  number of tracks missing trigger layer     " << std::setw(12) << m_nmissingStationLayerTrigger
             << "   average per truth track " << m_nmissingStationLayerTrigger * trTrkScale << std::endl
             << "  number of tracks missing chamber           " << std::setw(12) << m_nmissingStation << "   average per truth track "
             << m_nmissingStation * trTrkScale << std::endl
             << "  number of tracks wrong precision layer     " << std::setw(12) << m_nwrongStationLayer << "   average per truth track "
             << m_nwrongStationLayer * trTrkScale << std::endl
             << "  number of tracks wrong trigger layer       " << std::setw(12) << m_nwrongStationLayerTrigger
             << "   average per truth track " << m_nwrongStationLayerTrigger * trTrkScale << std::endl
             << "  number of tracks wrong chamber             " << std::setw(12) << m_nwrongStation << "   average per truth track "
             << m_nwrongStation * trTrkScale << std::endl
             << "  efficiency: " << nmatchedTracks * trTrkScale << "  fake rate " << m_nfakeTracks * evScale << "  high pt "
             << m_nfakeTracksHighPt * evScale << "  low pt " << m_nfakeTracksLowPt * evScale << "  missed track rate (per truth track) "
             << nmissedTracks * trTrkScale;
        if (doSecondaries) sout << " secondary efficiency " << m_nmatchedTracksSecondary * trTrkScaleSec;
    }
    sout << std::endl;
 
    return sout.str();
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

selectPdg()

bool MuonTrackPerformanceAlg::selectPdg ( int pdg ) const

inlineprivate

Definition at line 260 of file MuonTrackPerformanceAlg.h.

{ return m_selectedPdgs.count(pdg); }

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_badEvents

std::vector<EventData> MuonTrackPerformanceAlg::m_badEvents

private

Definition at line 358 of file MuonTrackPerformanceAlg.h.

m_cscSimData

SG::ReadHandleKey<CscSimDataCollection> MuonTrackPerformanceAlg::m_cscSimData {this, "CSC_SDO_Container", "CSC_SDO", "CSC SDO"}

private

Definition at line 272 of file MuonTrackPerformanceAlg.h.

{this, "CSC_SDO_Container", "CSC_SDO", "CSC SDO"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doEventListFake

int MuonTrackPerformanceAlg::m_doEventListFake {}

private

Definition at line 301 of file MuonTrackPerformanceAlg.h.

{};

m_doEventListIncomplete

int MuonTrackPerformanceAlg::m_doEventListIncomplete {}

private

Definition at line 300 of file MuonTrackPerformanceAlg.h.

{};

m_doEventListMissed

int MuonTrackPerformanceAlg::m_doEventListMissed {}

private

Definition at line 299 of file MuonTrackPerformanceAlg.h.

{};

m_doHistos

bool MuonTrackPerformanceAlg::m_doHistos {}

private

Definition at line 280 of file MuonTrackPerformanceAlg.h.

{};

m_doHitResiduals

int MuonTrackPerformanceAlg::m_doHitResiduals {}

private

Definition at line 277 of file MuonTrackPerformanceAlg.h.

{};

m_doSegments

bool MuonTrackPerformanceAlg::m_doSegments {}

private

Definition at line 285 of file MuonTrackPerformanceAlg.h.

{};

m_doStau

bool MuonTrackPerformanceAlg::m_doStau {}

private

Definition at line 287 of file MuonTrackPerformanceAlg.h.

{};

m_doSummary

int MuonTrackPerformanceAlg::m_doSummary {}

private

Definition at line 276 of file MuonTrackPerformanceAlg.h.

{};

m_doTrackDebug

int MuonTrackPerformanceAlg::m_doTrackDebug {}

private

Definition at line 278 of file MuonTrackPerformanceAlg.h.

{};

m_doTruth

bool MuonTrackPerformanceAlg::m_doTruth {}

private

Definition at line 279 of file MuonTrackPerformanceAlg.h.

{};

m_edmHelperSvc

ServiceHandle<Muon::IMuonEDMHelperSvc> MuonTrackPerformanceAlg::m_edmHelperSvc

private

Initial value:

{this, "edmHelper", "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
                                                          "Handle to the service providing the IMuonEDMHelperSvc interface"}

Definition at line 293 of file MuonTrackPerformanceAlg.h.

                                                       {this, "edmHelper", "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
                                                          "Handle to the service providing the IMuonEDMHelperSvc interface"};

m_eventInfo

const xAOD::EventInfo* MuonTrackPerformanceAlg::m_eventInfo

private

pointer to the event info

Definition at line 266 of file MuonTrackPerformanceAlg.h.

m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> MuonTrackPerformanceAlg::m_eventInfoKey {this, "EventInfoKey", "EventInfo", "EventInfo key"}

private

Definition at line 265 of file MuonTrackPerformanceAlg.h.

{this, "EventInfoKey", "EventInfo", "EventInfo key"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_fileName

std::string MuonTrackPerformanceAlg::m_fileName

private

name of external file to write statistics

Definition at line 361 of file MuonTrackPerformanceAlg.h.

m_fileOutput

std::ofstream MuonTrackPerformanceAlg::m_fileOutput

private

output file

Definition at line 364 of file MuonTrackPerformanceAlg.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonTrackPerformanceAlg::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 289 of file MuonTrackPerformanceAlg.h.

{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_isCombined

bool MuonTrackPerformanceAlg::m_isCombined {}

private

Definition at line 284 of file MuonTrackPerformanceAlg.h.

{};

m_mcEventColl

SG::ReadHandleKey<McEventCollection> MuonTrackPerformanceAlg::m_mcEventColl {this, "McEventCollectionKey", "TruthEvent", "McEventCollection"}

private

Definition at line 269 of file MuonTrackPerformanceAlg.h.

{this, "McEventCollectionKey", "TruthEvent", "McEventCollection"};

m_minCscEtaHits

int MuonTrackPerformanceAlg::m_minCscEtaHits {}

private

Definition at line 304 of file MuonTrackPerformanceAlg.h.

{};

m_minCscPhiHits

int MuonTrackPerformanceAlg::m_minCscPhiHits {}

private

Definition at line 305 of file MuonTrackPerformanceAlg.h.

{};

m_minMdtHits

int MuonTrackPerformanceAlg::m_minMdtHits {}

private

Definition at line 303 of file MuonTrackPerformanceAlg.h.

{};

m_minMMEtaHits

int MuonTrackPerformanceAlg::m_minMMEtaHits {}

private

Definition at line 312 of file MuonTrackPerformanceAlg.h.

{};

m_minRpcEtaHits

int MuonTrackPerformanceAlg::m_minRpcEtaHits {}

private

Definition at line 306 of file MuonTrackPerformanceAlg.h.

{};

m_minRpcPhiHits

int MuonTrackPerformanceAlg::m_minRpcPhiHits {}

private

Definition at line 307 of file MuonTrackPerformanceAlg.h.

{};

m_minsTgcEtaHits

int MuonTrackPerformanceAlg::m_minsTgcEtaHits {}

private

Definition at line 310 of file MuonTrackPerformanceAlg.h.

{};

m_minsTgcPhiHits

int MuonTrackPerformanceAlg::m_minsTgcPhiHits {}

private

Definition at line 311 of file MuonTrackPerformanceAlg.h.

{};

m_minTgcEtaHits

int MuonTrackPerformanceAlg::m_minTgcEtaHits {}

private

Definition at line 308 of file MuonTrackPerformanceAlg.h.

{};

m_minTgcPhiHits

int MuonTrackPerformanceAlg::m_minTgcPhiHits {}

private

Definition at line 309 of file MuonTrackPerformanceAlg.h.

{};

m_momentumCut

double MuonTrackPerformanceAlg::m_momentumCut {}

private

Definition at line 282 of file MuonTrackPerformanceAlg.h.

{};

m_momentumCutSim

double MuonTrackPerformanceAlg::m_momentumCutSim {}

private

Definition at line 281 of file MuonTrackPerformanceAlg.h.

{};

m_muons

SG::ReadHandleKey<xAOD::MuonContainer> MuonTrackPerformanceAlg::m_muons {this, "MuonLocation", "Muons", "input muons"}

private

Definition at line 264 of file MuonTrackPerformanceAlg.h.

{this, "MuonLocation", "Muons", "input muons"};  // muons for cases other than MS tracks

m_muonSimData

SG::ReadHandleKeyArray<MuonSimDataCollection> MuonTrackPerformanceAlg::m_muonSimData

private

Initial value:

{
        this, "MuonSimDataNames", {"MDT_SDO", "RPC_SDO", "TGC_SDO", "sTGC_SDO", "MM_SDO"}, "Muon SDO maps"}

Definition at line 270 of file MuonTrackPerformanceAlg.h.

                                                             {
        this, "MuonSimDataNames", {"MDT_SDO", "RPC_SDO", "TGC_SDO", "sTGC_SDO", "MM_SDO"}, "Muon SDO maps"};

m_nevents

unsigned int MuonTrackPerformanceAlg::m_nevents {}

private

Definition at line 314 of file MuonTrackPerformanceAlg.h.

{};

m_nfakeTracks

unsigned int MuonTrackPerformanceAlg::m_nfakeTracks {}

private

Definition at line 321 of file MuonTrackPerformanceAlg.h.

{};

m_nfakeTracksHighPt

unsigned int MuonTrackPerformanceAlg::m_nfakeTracksHighPt {}

private

Definition at line 322 of file MuonTrackPerformanceAlg.h.

{};

m_nfakeTracksLowPt

unsigned int MuonTrackPerformanceAlg::m_nfakeTracksLowPt {}

private

Definition at line 323 of file MuonTrackPerformanceAlg.h.

{};

m_nfakeTracksSL

unsigned int MuonTrackPerformanceAlg::m_nfakeTracksSL {}

private

Definition at line 324 of file MuonTrackPerformanceAlg.h.

{};

m_nmatchedFakeTracks

unsigned int MuonTrackPerformanceAlg::m_nmatchedFakeTracks {}

private

Definition at line 319 of file MuonTrackPerformanceAlg.h.

{};

m_nmatchedTracks

unsigned int MuonTrackPerformanceAlg::m_nmatchedTracks {}

private

Definition at line 317 of file MuonTrackPerformanceAlg.h.

{};

m_nmatchedTracksSecondary

unsigned int MuonTrackPerformanceAlg::m_nmatchedTracksSecondary {}

private

Definition at line 318 of file MuonTrackPerformanceAlg.h.

{};

m_nmissedTracks

unsigned int MuonTrackPerformanceAlg::m_nmissedTracks {}

private

Definition at line 326 of file MuonTrackPerformanceAlg.h.

{};

m_nmissedTracksOneStation

unsigned int MuonTrackPerformanceAlg::m_nmissedTracksOneStation {}

private

Definition at line 327 of file MuonTrackPerformanceAlg.h.

{};

m_nmissedTracksOneStationSecondary

unsigned int MuonTrackPerformanceAlg::m_nmissedTracksOneStationSecondary {}

private

Definition at line 330 of file MuonTrackPerformanceAlg.h.

{};

m_nmissedTracksSecondary

unsigned int MuonTrackPerformanceAlg::m_nmissedTracksSecondary {}

private

Definition at line 329 of file MuonTrackPerformanceAlg.h.

{};

m_nmissingCscStationLayer

unsigned int MuonTrackPerformanceAlg::m_nmissingCscStationLayer {}

private

Definition at line 334 of file MuonTrackPerformanceAlg.h.

{};

m_nmissingStation

unsigned int MuonTrackPerformanceAlg::m_nmissingStation {}

private

Definition at line 336 of file MuonTrackPerformanceAlg.h.

{};

m_nmissingStationLayer

unsigned int MuonTrackPerformanceAlg::m_nmissingStationLayer {}

private

Definition at line 333 of file MuonTrackPerformanceAlg.h.

{};

m_nmissingStationLayerTrigger

unsigned int MuonTrackPerformanceAlg::m_nmissingStationLayerTrigger {}

private

Definition at line 335 of file MuonTrackPerformanceAlg.h.

{};

m_nmissingStationMomLoss

unsigned int MuonTrackPerformanceAlg::m_nmissingStationMomLoss {}

private

Definition at line 332 of file MuonTrackPerformanceAlg.h.

{};

m_ntracks

unsigned int MuonTrackPerformanceAlg::m_ntracks {}

private

Definition at line 315 of file MuonTrackPerformanceAlg.h.

{};

m_ntruthTracks

unsigned int MuonTrackPerformanceAlg::m_ntruthTracks {}

private

Definition at line 342 of file MuonTrackPerformanceAlg.h.

{};

m_ntruthTracksSecondary

unsigned int MuonTrackPerformanceAlg::m_ntruthTracksSecondary {}

private

Definition at line 343 of file MuonTrackPerformanceAlg.h.

{};

m_nwrongStation

unsigned int MuonTrackPerformanceAlg::m_nwrongStation {}

private

Definition at line 340 of file MuonTrackPerformanceAlg.h.

{};

m_nwrongStationLayer

unsigned int MuonTrackPerformanceAlg::m_nwrongStationLayer {}

private

Definition at line 338 of file MuonTrackPerformanceAlg.h.

{};

m_nwrongStationLayerTrigger

unsigned int MuonTrackPerformanceAlg::m_nwrongStationLayerTrigger {}

private

Definition at line 339 of file MuonTrackPerformanceAlg.h.

{};

m_pdgsToBeConsidered

IntegerArrayProperty MuonTrackPerformanceAlg::m_pdgsToBeConsidered

private

Definition at line 366 of file MuonTrackPerformanceAlg.h.

m_printer

PublicToolHandle<Muon::MuonEDMPrinterTool> MuonTrackPerformanceAlg::m_printer {this, "Printer", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}

private

Definition at line 291 of file MuonTrackPerformanceAlg.h.

{this, "Printer", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"};

m_selectedPdgs

std::set<int> MuonTrackPerformanceAlg::m_selectedPdgs

private

Definition at line 367 of file MuonTrackPerformanceAlg.h.

m_summaryHelperTool

ToolHandle<Trk::ITrackSummaryHelperTool> MuonTrackPerformanceAlg::m_summaryHelperTool {this, "SummaryHelperTool", ""}

private

Definition at line 298 of file MuonTrackPerformanceAlg.h.

{this, "SummaryHelperTool", ""};

m_trackKey

SG::ReadHandleKey<TrackCollection> MuonTrackPerformanceAlg::m_trackKey

private

Initial value:

{this, "TrackInputLocation", "MuonSpectrometerTracks",
                                                  "input tracks"}

Location of the input tracks.

Definition at line 262 of file MuonTrackPerformanceAlg.h.

                                               {this, "TrackInputLocation", "MuonSpectrometerTracks",
                                                  "input tracks"};                                 

m_trackRecord

SG::ReadHandleKey<TrackRecordCollection> MuonTrackPerformanceAlg::m_trackRecord {this, "TrackRecord", "MuonEntryLayerFilter", "Track Record Collection"}

private

Definition at line 273 of file MuonTrackPerformanceAlg.h.

{this, "TrackRecord", "MuonEntryLayerFilter", "Track Record Collection"};

m_trackType

int MuonTrackPerformanceAlg::m_trackType {}

private

Definition at line 370 of file MuonTrackPerformanceAlg.h.

{};

m_trackTypeString

std::string MuonTrackPerformanceAlg::m_trackTypeString

private

Definition at line 371 of file MuonTrackPerformanceAlg.h.

m_truthTool

ToolHandle<Muon::IMuonTrackTruthTool> MuonTrackPerformanceAlg::m_truthTool {this, "TrackTruthTool",""}

private

Definition at line 297 of file MuonTrackPerformanceAlg.h.

{this, "TrackTruthTool",""};

m_usePtCut

bool MuonTrackPerformanceAlg::m_usePtCut {}

private

Definition at line 283 of file MuonTrackPerformanceAlg.h.

{};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_writeToFile

bool MuonTrackPerformanceAlg::m_writeToFile {}

private

Definition at line 286 of file MuonTrackPerformanceAlg.h.

{};

---

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

• MuonTrackPerformanceAlg.h
• MuonTrackPerformanceAlg.cxx