ATLAS Offline Software
Public Types | Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
IDTPM::TrackAnalysisCollections Class Reference

#include <TrackAnalysisCollections.h>

Inheritance diagram for IDTPM::TrackAnalysisCollections:
Collaboration diagram for IDTPM::TrackAnalysisCollections:

Public Types

enum  Stage : size_t { FULL, FS, InRoI, NStages }
 Enum for selection stages. More...
 
enum  Counter : size_t {
  ALL, SELECTED, INROI, MATCHED,
  NCOUNTERS
}
 Enum for counting objects at various stages. More...
 

Public Member Functions

 TrackAnalysisCollections (const std::string &anaTag)
 Constructor. More...
 
 ~TrackAnalysisCollections ()=default
 Destructor. More...
 
TrackAnalysisCollectionsoperator= (const TrackAnalysisCollections &)=delete
 = operator More...
 
StatusCode initialize ()
 initialize More...
 
StatusCode fillEventInfo (const SG::ReadHandleKey< xAOD::EventInfo > &eventInfoHandleKey, const SG::ReadHandleKey< xAOD::TruthEventContainer > &truthEventHandleKey, const SG::ReadHandleKey< xAOD::TruthPileupEventContainer > &truthPUEventHandleKey)
 — Setter methods — More...
 
StatusCode fillTruthPartContainer (const SG::ReadHandleKey< xAOD::TruthParticleContainer > &truthPartHandleKey)
 fill FULL track collections and vectors More...
 
StatusCode fillOfflTrackContainer (const SG::ReadHandleKey< xAOD::TrackParticleContainer > &handleKey)
 Offline track particles. More...
 
StatusCode fillTrigTrackContainer (const SG::ReadHandleKey< xAOD::TrackParticleContainer > &handleKey)
 Trigger track particles. More...
 
StatusCode fillTestTruthVec (const std::vector< const xAOD::TruthParticle * > &vec, Stage stage=FULL)
 fill TEST track vectors More...
 
StatusCode fillTestTrackVec (const std::vector< const xAOD::TrackParticle * > &vec, Stage stage=FULL)
 TEST = tracks. More...
 
StatusCode fillRefTruthVec (const std::vector< const xAOD::TruthParticle * > &vec, Stage stage=FULL)
 fill REFERENCE track vectors More...
 
StatusCode fillRefTrackVec (const std::vector< const xAOD::TrackParticle * > &vec, Stage stage=FULL)
 REFERENCE = tracks. More...
 
StatusCode fillTruthPartVec (const std::vector< const xAOD::TruthParticle * > &vec, Stage stage=FULL)
 fill truth/offline/trigger track vector (TEST or REFERENCE) More...
 
StatusCode fillOfflTrackVec (const std::vector< const xAOD::TrackParticle * > &vec, Stage stage=FULL)
 Offline tracks. More...
 
StatusCode fillTrigTrackVec (const std::vector< const xAOD::TrackParticle * > &vec, Stage stage=FULL)
 Trigger tracks. More...
 
StatusCode fillTruthVertexContainer (const SG::ReadHandleKey< xAOD::TruthVertexContainer > &truthVertexHandleKey)
 fill FULL vertex collections and vectors More...
 
StatusCode fillOfflVertexContainer (const SG::ReadHandleKey< xAOD::VertexContainer > &handleKey)
 Offline vertices. More...
 
StatusCode fillTrigVertexContainer (const SG::ReadHandleKey< xAOD::VertexContainer > &handleKey)
 Trigger vertices. More...
 
StatusCode fillTestTruthVertexVec (const std::vector< const xAOD::TruthVertex * > &vec, Stage stage=FULL)
 fill TEST vertex vectors More...
 
StatusCode fillTestRecoVertexVec (const std::vector< const xAOD::Vertex * > &vec, Stage stage=FULL)
 TEST = reco. More...
 
StatusCode fillRefTruthVertexVec (const std::vector< const xAOD::TruthVertex * > &vec, Stage stage=FULL)
 fill REFERENCE vertex vectors More...
 
StatusCode fillRefRecoVertexVec (const std::vector< const xAOD::Vertex * > &vec, Stage stage=FULL)
 REFERENCE = reco. More...
 
StatusCode fillTruthVertexVec (const std::vector< const xAOD::TruthVertex * > &vec, Stage stage=FULL)
 fill truth/offline/trigger vertex vector (TEST or REFERENCE) More...
 
StatusCode fillOfflVertexVec (const std::vector< const xAOD::Vertex * > &vec, Stage stage=FULL)
 Offline tracks. More...
 
StatusCode fillTrigVertexVec (const std::vector< const xAOD::Vertex * > &vec, Stage stage=FULL)
 Trigger tracks. More...
 
bool empty (Stage stage=FULL)
 Utility methods — More...
 
void clear (Stage stage=FULL)
 Clear vectors. More...
 
void copyFS ()
 copy content of FS vectors to InRoI vectors More...
 
std::string printInfo (Stage stage=FULL, bool printVertex=true) const
 print information about tracks in the collection(s) More...
 
std::string printVertexInfo (Stage stage=FULL) const
 print information about vertices in the collection(s) More...
 
const std::string & anaTag ()
 — Getter methods — More...
 
const xAOD::EventInfoeventInfo ()
 get event info More...
 
const xAOD::TruthEventContainertruthEventContainer ()
 
const xAOD::TruthPileupEventContainertruthPileupEventContainer ()
 
const xAOD::TruthParticleContainertestTruthContainer ()
 get full TEST track containers More...
 
const xAOD::TrackParticleContainertestTrackContainer ()
 TEST = Track. More...
 
const xAOD::TruthParticleContainerrefTruthContainer ()
 get full REFERENCE track containers More...
 
const xAOD::TrackParticleContainerrefTrackContainer ()
 REFERENCE = Track. More...
 
const xAOD::TruthParticleContainertruthPartContainer ()
 get truth/offline/trigger track containers (TEST or REFERENCE) More...
 
const xAOD::TrackParticleContainerofflTrackContainer ()
 
const xAOD::TrackParticleContainertrigTrackContainer ()
 
const std::vector< const xAOD::TruthParticle * > & testTruthVec (Stage stage=FULL)
 get TEST track vectors More...
 
const std::vector< const xAOD::TrackParticle * > & testTrackVec (Stage stage=FULL)
 TEST = Track. More...
 
const std::vector< const xAOD::TruthParticle * > & refTruthVec (Stage stage=FULL)
 get REFERENCE track vectors More...
 
const std::vector< const xAOD::TrackParticle * > & refTrackVec (Stage stage=FULL)
 TEST = Track. More...
 
const std::vector< const xAOD::TruthParticle * > & truthPartVec (Stage stage=FULL)
 get truth/offline/trigger track vector (TEST or REFERENCE) More...
 
const std::vector< const xAOD::TrackParticle * > & offlTrackVec (Stage stage=FULL)
 
const std::vector< const xAOD::TrackParticle * > & trigTrackVec (Stage stage=FULL)
 
std::vector< size_t > testTrackCounts ()
 get counts vectors for TEST/REFERENCE track vectors at all stages More...
 
std::vector< size_t > refTrackCounts ()
 REFERENCE. More...
 
const xAOD::TruthVertexContainertestTruthVertexContainer ()
 get full TEST vertex containers More...
 
const xAOD::VertexContainertestRecoVertexContainer ()
 TEST = Reco. More...
 
const xAOD::TruthVertexContainerrefTruthVertexContainer ()
 get full REFERENCE vertex containers More...
 
const xAOD::VertexContainerrefRecoVertexContainer ()
 REFERENCE = Reco. More...
 
const xAOD::TruthVertexContainertruthVertexContainer ()
 get truth/offline/trigger vertex containers (TEST or REFERENCE) More...
 
const xAOD::VertexContainerofflVertexContainer ()
 
const xAOD::VertexContainertrigVertexContainer ()
 
const std::vector< const xAOD::TruthVertex * > & testTruthVertexVec (Stage stage=FULL)
 get TEST vertex vectors More...
 
const std::vector< const xAOD::Vertex * > & testRecoVertexVec (Stage stage=FULL)
 TEST = Reco. More...
 
const std::vector< const xAOD::TruthVertex * > & refTruthVertexVec (Stage stage=FULL)
 get REFERENCE vertex vectors More...
 
const std::vector< const xAOD::Vertex * > & refRecoVertexVec (Stage stage=FULL)
 REFERENCE = Reco. More...
 
const std::vector< const xAOD::TruthVertex * > & truthVertexVec (Stage stage=FULL)
 get truth/offline/trigger vertex vector (TEST or REFERENCE) More...
 
const std::vector< const xAOD::Vertex * > & offlVertexVec (Stage stage=FULL)
 
const std::vector< const xAOD::Vertex * > & trigVertexVec (Stage stage=FULL)
 
std::vector< size_t > testVertexCounts ()
 get counts vectors for TEST/REFERENCE vertex vectors at all stages More...
 
std::vector< size_t > refVertexCounts ()
 REFERENCE. More...
 
ITrackMatchingLookupmatches ()
 get track matching information More...
 
std::string printMatchInfo ()
 print track matching information More...
 
bool updateChainRois (const std::string &chainRoi, const std::string &roiStr)
 update chainRois map More...
 
bool msgLvl (const MSG::Level lvl) const
 Test the output level. More...
 
MsgStream & msg () const
 The standard message stream. More...
 
MsgStream & msg (const MSG::Level lvl) const
 The standard message stream. More...
 
void setLevel (MSG::Level lvl)
 Change the current logging level. More...
 

Private Types

typedef std::unordered_map< std::string, std::string > mapChainRoi_t
 map of chainRoiNames for caching More...
 

Private Member Functions

void initMessaging () const
 Initialize our message level and MessageSvc. More...
 

Private Attributes

std::string m_anaTag
 TrackAnalysis properties. More...
 
SmartIF< ITrackAnalysisDefinitionSvcm_trkAnaDefSvc
 
const xAOD::EventInfom_eventInfo {nullptr}
 — Collections class variables — EventInfo, TruthEvent, and TruthPUEvent More...
 
const xAOD::TruthEventContainerm_truthEventContainer {nullptr}
 
const xAOD::TruthPileupEventContainerm_truthPUEventContainer {nullptr}
 
const xAOD::TruthParticleContainerm_truthPartContainer {nullptr}
 Full track collections. More...
 
const xAOD::TrackParticleContainerm_offlTrackContainer {nullptr}
 
const xAOD::TrackParticleContainerm_trigTrackContainer {nullptr}
 
std::vector< std::vector< const xAOD::TruthParticle * > > m_truthPartVec {}
 vectors of track/truth particles at different stages of the selection/workflow More...
 
std::vector< std::vector< const xAOD::TrackParticle * > > m_offlTrackVec {}
 
std::vector< std::vector< const xAOD::TrackParticle * > > m_trigTrackVec {}
 
const xAOD::TruthVertexContainerm_truthVertexContainer {nullptr}
 Full vertex collections. More...
 
const xAOD::VertexContainerm_offlVertexContainer {nullptr}
 
const xAOD::VertexContainerm_trigVertexContainer {nullptr}
 
std::vector< std::vector< const xAOD::TruthVertex * > > m_truthVertexVec {}
 vectors of reco/truth vertices at different stages of the selection/workflow More...
 
std::vector< std::vector< const xAOD::Vertex * > > m_offlVertexVec {}
 
std::vector< std::vector< const xAOD::Vertex * > > m_trigVertexVec {}
 
std::vector< const xAOD::TrackParticle * > m_nullTrackVec {}
 null vectors More...
 
std::vector< const xAOD::TruthParticle * > m_nullTruthVec {}
 
std::vector< const xAOD::TruthVertex * > m_nullTruthVertVec {}
 
std::vector< const xAOD::Vertex * > m_nullRecoVertVec {}
 
std::unique_ptr< ITrackMatchingLookupm_matches
 Lookup table for test-reference matching. More...
 
mapChainRoi_t m_chainRois {}
 
std::string m_nm
 Message source name. More...
 
boost::thread_specific_ptr< MsgStream > m_msg_tls
 MsgStream instance (a std::cout like with print-out levels) More...
 
std::atomic< IMessageSvc * > m_imsg { nullptr }
 MessageSvc pointer. More...
 
std::atomic< MSG::Level > m_lvl { MSG::NIL }
 Current logging level. More...
 
std::atomic_flag m_initialized ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
 Messaging initialized (initMessaging) More...
 

Detailed Description

Definition at line 46 of file TrackAnalysisCollections.h.

Member Typedef Documentation

◆ mapChainRoi_t

typedef std::unordered_map< std::string, std::string > IDTPM::TrackAnalysisCollections::mapChainRoi_t
private

map of chainRoiNames for caching

Definition at line 311 of file TrackAnalysisCollections.h.

Member Enumeration Documentation

◆ Counter

Enum for counting objects at various stages.

Enumerator
ALL 
SELECTED 
INROI 
MATCHED 
NCOUNTERS 

Definition at line 57 of file TrackAnalysisCollections.h.

57 : size_t { ALL, SELECTED, INROI, MATCHED, NCOUNTERS };

◆ Stage

Enum for selection stages.

  • FULL = full track collections, no selectrions
  • FS = Full-Scan track collections, after quality-based selection
  • InRoI = selected track collections inside the RoI
Enumerator
FULL 
FS 
InRoI 
NStages 

Definition at line 54 of file TrackAnalysisCollections.h.

54 : size_t { FULL, FS, InRoI, NStages };

Constructor & Destructor Documentation

◆ TrackAnalysisCollections()

IDTPM::TrackAnalysisCollections::TrackAnalysisCollections ( const std::string &  anaTag)

Constructor.

local includes

STD include(s)


— Constructor —

tracks

vertices

Definition at line 22 of file TrackAnalysisCollections.cxx.

23  :
24  AthMessaging( "TrackAnalysisCollections"+anaTag ),
25  m_anaTag( anaTag )
26 {
28  m_truthPartVec.resize( NStages );
29  m_offlTrackVec.resize( NStages );
30  m_trigTrackVec.resize( NStages );
31 
33  m_truthVertexVec.resize( NStages );
34  m_offlVertexVec.resize( NStages );
35  m_trigVertexVec.resize( NStages );
36 }

◆ ~TrackAnalysisCollections()

IDTPM::TrackAnalysisCollections::~TrackAnalysisCollections ( )
default

Destructor.

Member Function Documentation

◆ anaTag()

const std::string& IDTPM::TrackAnalysisCollections::anaTag ( )
inline

— Getter methods —

get TrackAnalysis tag

Definition at line 181 of file TrackAnalysisCollections.h.

181 { return m_anaTag; }

◆ clear()

void IDTPM::TrackAnalysisCollections::clear ( Stage  stage = FULL)

Clear vectors.

clear collections

tracks

vertices

tracks

vertices

tracks

vertices

Definition at line 628 of file TrackAnalysisCollections.cxx.

630 {
631  if( stage == FULL ) {
633  m_truthPartVec[ FULL ].clear();
634  m_offlTrackVec[ FULL ].clear();
635  m_trigTrackVec[ FULL ].clear();
637  m_truthVertexVec[ FULL ].clear();
638  m_offlVertexVec[ FULL ].clear();
639  m_trigVertexVec[ FULL ].clear();
640  }
641  if( stage == FULL or stage == FS ) {
643  m_truthPartVec[ FS ].clear();
644  m_offlTrackVec[ FS ].clear();
645  m_trigTrackVec[ FS ].clear();
647  m_truthVertexVec[ FS ].clear();
648  m_offlVertexVec[ FS ].clear();
649  m_trigVertexVec[ FS ].clear();
650  }
651  if( stage == FULL or stage == FS or stage == InRoI ) {
653  m_truthPartVec[ InRoI ].clear();
654  m_offlTrackVec[ InRoI ].clear();
655  m_trigTrackVec[ InRoI ].clear();
657  m_truthVertexVec[ InRoI ].clear();
658  m_offlVertexVec[ InRoI ].clear();
659  m_trigVertexVec[ InRoI ].clear();
660  }
661 }

◆ copyFS()

void IDTPM::TrackAnalysisCollections::copyFS ( )

copy content of FS vectors to InRoI vectors

copy inRoI collections from FullScan collections

— Offline — tracks

vertices

Truth — tracks

vertices

— EF trigger —

tracks

vertices

Debug printout

Definition at line 664 of file TrackAnalysisCollections.cxx.

665 {
666  ATH_MSG_DEBUG( "Copying tracks in RoI" );
667 
670  m_offlTrackVec[ InRoI ].clear();
671  m_offlTrackVec[ InRoI ].insert(
673  m_offlTrackVec[ FS ].begin(),
674  m_offlTrackVec[ FS ].end() );
676  m_offlVertexVec[ InRoI ].clear();
677  m_offlVertexVec[ InRoI ].insert(
679  m_offlVertexVec[ FS ].begin(),
680  m_offlVertexVec[ FS ].end() );
681 
684  m_truthPartVec[ InRoI ].clear();
685  m_truthPartVec[ InRoI ].insert(
687  m_truthPartVec[ FS ].begin(),
688  m_truthPartVec[ FS ].end() );
690  m_truthVertexVec[ InRoI ].clear();
691  m_truthVertexVec[ InRoI ].insert(
694  m_truthVertexVec[ FS ].end() );
695 
697  if( m_trkAnaDefSvc->useEFTrigger() ) {
699  m_trigTrackVec[ InRoI ].clear();
700  m_trigTrackVec[ InRoI ].insert(
702  m_trigTrackVec[ FS ].begin(),
703  m_trigTrackVec[ FS ].end() );
705  m_trigVertexVec[ InRoI ].clear();
706  m_trigVertexVec[ InRoI ].insert(
708  m_trigVertexVec[ FS ].begin(),
709  m_trigVertexVec[ FS ].end() );
710  }
711 
713  ATH_MSG_DEBUG( "Tracks and vertices after in RoI copy: " << printInfo( InRoI ) );
714 }

◆ empty()

bool IDTPM::TrackAnalysisCollections::empty ( Stage  stage = FULL)

Utility methods —

check if collection are empty


— Utility methods —

empty

check if empty disabled for FS trigger track vector (always empty by construction)

Definition at line 607 of file TrackAnalysisCollections.cxx.

609 {
612  bool isTrigEmpty = m_trkAnaDefSvc->useTrigger() and not m_trkAnaDefSvc->useEFTrigger() and
614  m_trigTrackVec[ stage ].empty() : false;
615  bool isEFTrigEmpty = m_trkAnaDefSvc->useEFTrigger() ?
616  m_trigTrackVec[ stage ].empty() : false;
617  bool isOfflEmpty = m_trkAnaDefSvc->useOffline() ?
618  m_offlTrackVec[ stage ].empty() : false;
619  bool isTruthEmpty = m_trkAnaDefSvc->useTruth() ?
620  m_truthPartVec[ stage ].empty() : false;
621 
622  if( isTrigEmpty or isEFTrigEmpty or isOfflEmpty or isTruthEmpty ) return true;
623 
624  return false;
625 }

◆ eventInfo()

const xAOD::EventInfo* IDTPM::TrackAnalysisCollections::eventInfo ( )
inline

get event info

Definition at line 184 of file TrackAnalysisCollections.h.

184 { return m_eventInfo; }

◆ fillEventInfo()

StatusCode IDTPM::TrackAnalysisCollections::fillEventInfo ( const SG::ReadHandleKey< xAOD::EventInfo > &  eventInfoHandleKey,
const SG::ReadHandleKey< xAOD::TruthEventContainer > &  truthEventHandleKey,
const SG::ReadHandleKey< xAOD::TruthPileupEventContainer > &  truthPUEventHandleKey 
)

— Setter methods —

fill event info


--— Fill Event Info --—

EventInfo

TruthEvent

TruthPileupEvent

Definition at line 68 of file TrackAnalysisCollections.cxx.

72 {
73  m_eventInfo = nullptr;
74  m_truthEventContainer = nullptr;
75  m_truthPUEventContainer = nullptr;
76 
78  SG::ReadHandle< xAOD::EventInfo > pie( eventInfoHandleKey );
79  if( not pie.isValid() ) {
80  ATH_MSG_WARNING( "Shouldn't happen. EventInfo is buggy" );
81  } else m_eventInfo = pie.ptr();
82 
83  if( not m_trkAnaDefSvc->useTruth() ) return StatusCode::SUCCESS;
84 
86  SG::ReadHandle< xAOD::TruthEventContainer > pTruthEventCont( truthEventHandleKey );
87  if( not pTruthEventCont.isValid() ) {
88  ATH_MSG_WARNING( "Non valid truth event collection: " << truthEventHandleKey.key() );
89  }
90  else m_truthEventContainer = pTruthEventCont.ptr();
91 
93  if( m_trkAnaDefSvc->hasFullPileupTruth() ) {
94  SG::ReadHandle< xAOD::TruthPileupEventContainer > pTruthPUEventCont( truthPUEventHandleKey );
95  if( not pTruthPUEventCont.isValid() ) {
96  ATH_MSG_WARNING( "Non valid truth pile up event collection: " << truthPUEventHandleKey.key() );
97  }
98  else m_truthPUEventContainer = pTruthPUEventCont.ptr();
99  }
100 
101  return StatusCode::SUCCESS;
102 }

◆ fillOfflTrackContainer()

StatusCode IDTPM::TrackAnalysisCollections::fillOfflTrackContainer ( const SG::ReadHandleKey< xAOD::TrackParticleContainer > &  handleKey)

Offline track particles.

Fill container

Fill FULL vector

Definition at line 166 of file TrackAnalysisCollections.cxx.

168 {
169  if( m_trkAnaDefSvc->useOffline() ) {
170  ATH_MSG_DEBUG( "Loading collection: " << handleKey.key() );
171 
173 
174  if( not pColl.isValid() ) {
175  ATH_MSG_ERROR( "Non valid offline tracks collection: " << handleKey.key() );
176  return StatusCode::FAILURE;
177  }
178 
180  m_offlTrackContainer = pColl.ptr();
181 
183  m_offlTrackVec[ FULL ].clear();
184  m_offlTrackVec[ FULL ].insert(
186  pColl->begin(), pColl->end() );
187  } else {
188  m_offlTrackContainer = nullptr;
189  m_offlTrackVec[ FULL ].clear();
190  }
191 
192  return StatusCode::SUCCESS;
193 }

◆ fillOfflTrackVec()

StatusCode IDTPM::TrackAnalysisCollections::fillOfflTrackVec ( const std::vector< const xAOD::TrackParticle * > &  vec,
Stage  stage = FULL 
)

Offline tracks.

Definition at line 336 of file TrackAnalysisCollections.cxx.

339 {
340  if( m_trkAnaDefSvc->useOffline() ) {
341  m_offlTrackVec[ stage ].clear();
342  m_offlTrackVec[ stage ].insert(
344  vec.begin(), vec.end() );
345  return StatusCode::SUCCESS;
346  }
347 
348  ATH_MSG_DEBUG( "No Offline TrackParticle vector" );
349  return StatusCode::SUCCESS;
350 }

◆ fillOfflVertexContainer()

StatusCode IDTPM::TrackAnalysisCollections::fillOfflVertexContainer ( const SG::ReadHandleKey< xAOD::VertexContainer > &  handleKey)

Offline vertices.

Skip if not useOffline or if handle key is empty

Fill container

Fill FULL vector

Definition at line 404 of file TrackAnalysisCollections.cxx.

406 {
407  m_offlVertexContainer = nullptr;
408  m_offlVertexVec[ FULL ].clear();
409 
411  if( not m_trkAnaDefSvc->useOffline() or
412  handleKey.key().empty() ) return StatusCode::SUCCESS;
413 
414  ATH_MSG_DEBUG( "Loading collection: " << handleKey.key() );
415  SG::ReadHandle< xAOD::VertexContainer > pColl( handleKey );
416  if( not pColl.isValid() ) {
417  ATH_MSG_ERROR( "Non valid offline vertex collection: " << handleKey.key() );
418  return StatusCode::FAILURE;
419  }
420 
422  m_offlVertexContainer = pColl.ptr();
423 
425  m_offlVertexVec[ FULL ].insert(
427  pColl->begin(), pColl->end() );
428 
429  return StatusCode::SUCCESS;
430 }

◆ fillOfflVertexVec()

StatusCode IDTPM::TrackAnalysisCollections::fillOfflVertexVec ( const std::vector< const xAOD::Vertex * > &  vec,
Stage  stage = FULL 
)

Offline tracks.

Definition at line 570 of file TrackAnalysisCollections.cxx.

573 {
574  if( m_trkAnaDefSvc->useOffline() ) {
575  m_offlVertexVec[ stage ].clear();
576  m_offlVertexVec[ stage ].insert(
578  vec.begin(), vec.end() );
579  return StatusCode::SUCCESS;
580  }
581 
582  ATH_MSG_DEBUG( "No Offline vertex vector" );
583  return StatusCode::SUCCESS;
584 }

◆ fillRefRecoVertexVec()

StatusCode IDTPM::TrackAnalysisCollections::fillRefRecoVertexVec ( const std::vector< const xAOD::Vertex * > &  vec,
Stage  stage = FULL 
)

REFERENCE = reco.

Definition at line 526 of file TrackAnalysisCollections.cxx.

529 {
530  if( m_trkAnaDefSvc->isReferenceOffline() ) {
531  m_offlVertexVec[ stage ].clear();
532  m_offlVertexVec[ stage ].insert(
534  vec.begin(), vec.end() );
535  return StatusCode::SUCCESS;
536 
537  } else if( m_trkAnaDefSvc->isReferenceTrigger() ) {
538  m_trigVertexVec[ stage ].clear();
539  m_trigVertexVec[ stage ].insert(
541  vec.begin(), vec.end() );
542  return StatusCode::SUCCESS;
543  }
544 
545  ATH_MSG_DEBUG( "No REFERENCE Reco vertex vector" );
546  return StatusCode::SUCCESS;
547 }

◆ fillRefTrackVec()

StatusCode IDTPM::TrackAnalysisCollections::fillRefTrackVec ( const std::vector< const xAOD::TrackParticle * > &  vec,
Stage  stage = FULL 
)

REFERENCE = tracks.

Definition at line 291 of file TrackAnalysisCollections.cxx.

294 {
295  if( m_trkAnaDefSvc->isReferenceOffline() ) {
296  m_offlTrackVec[ stage ].clear();
297  m_offlTrackVec[ stage ].insert(
299  vec.begin(), vec.end() );
300  return StatusCode::SUCCESS;
301  }
302 
303  if( m_trkAnaDefSvc->isReferenceTrigger() ) {
304  m_trigTrackVec[ stage ].clear();
305  m_trigTrackVec[ stage ].insert(
307  vec.begin(), vec.end() );
308  return StatusCode::SUCCESS;
309  }
310 
311  ATH_MSG_DEBUG( "No REFERENCE TrackParticle vector" );
312  return StatusCode::SUCCESS;
313 }

◆ fillRefTruthVec()

StatusCode IDTPM::TrackAnalysisCollections::fillRefTruthVec ( const std::vector< const xAOD::TruthParticle * > &  vec,
Stage  stage = FULL 
)

fill REFERENCE track vectors


— Fill REFERENCE track vectors —

REFERENCE = truth

Definition at line 274 of file TrackAnalysisCollections.cxx.

277 {
278  if( m_trkAnaDefSvc->isReferenceTruth() ) {
279  m_truthPartVec[ stage ].clear();
280  m_truthPartVec[ stage ].insert(
282  vec.begin(), vec.end() );
283  return StatusCode::SUCCESS;
284  }
285 
286  ATH_MSG_DEBUG( "No REFERENCE TruthParticle vector" );
287  return StatusCode::SUCCESS;
288 }

◆ fillRefTruthVertexVec()

StatusCode IDTPM::TrackAnalysisCollections::fillRefTruthVertexVec ( const std::vector< const xAOD::TruthVertex * > &  vec,
Stage  stage = FULL 
)

fill REFERENCE vertex vectors


— Fill REFERENCE vertex vectors —

REFERENCE = truth

Definition at line 509 of file TrackAnalysisCollections.cxx.

512 {
513  if( m_trkAnaDefSvc->isReferenceTruth() ) {
514  m_truthVertexVec[ stage ].clear();
515  m_truthVertexVec[ stage ].insert(
517  vec.begin(), vec.end() );
518  return StatusCode::SUCCESS;
519  }
520 
521  ATH_MSG_DEBUG( "No REFERENCE Truth vertex vector" );
522  return StatusCode::SUCCESS;
523 }

◆ fillTestRecoVertexVec()

StatusCode IDTPM::TrackAnalysisCollections::fillTestRecoVertexVec ( const std::vector< const xAOD::Vertex * > &  vec,
Stage  stage = FULL 
)

TEST = reco.

Definition at line 482 of file TrackAnalysisCollections.cxx.

485 {
486  if( m_trkAnaDefSvc->isTestOffline() ) {
487  m_offlVertexVec[ stage ].clear();
488  m_offlVertexVec[ stage ].insert(
490  vec.begin(), vec.end() );
491  return StatusCode::SUCCESS;
492 
493  } else if( m_trkAnaDefSvc->isTestTrigger() ) {
494  m_trigVertexVec[ stage ].clear();
495  m_trigVertexVec[ stage ].insert(
497  vec.begin(), vec.end() );
498  return StatusCode::SUCCESS;
499  }
500 
501  ATH_MSG_DEBUG( "No TEST Reco vertex vector");
502  return StatusCode::SUCCESS;
503 }

◆ fillTestTrackVec()

StatusCode IDTPM::TrackAnalysisCollections::fillTestTrackVec ( const std::vector< const xAOD::TrackParticle * > &  vec,
Stage  stage = FULL 
)

TEST = tracks.

Definition at line 246 of file TrackAnalysisCollections.cxx.

249 {
250  if( m_trkAnaDefSvc->isTestOffline() ) {
251  m_offlTrackVec[ stage ].clear();
252  m_offlTrackVec[ stage ].insert(
254  vec.begin(), vec.end() );
255  return StatusCode::SUCCESS;
256  }
257 
258  if( m_trkAnaDefSvc->isTestTrigger() ) {
259  m_trigTrackVec[ stage ].clear();
260  m_trigTrackVec[ stage ].insert(
262  vec.begin(), vec.end() );
263  return StatusCode::SUCCESS;
264  }
265 
266  ATH_MSG_DEBUG( "No TEST TrackParticle vector");
267  return StatusCode::SUCCESS;
268 }

◆ fillTestTruthVec()

StatusCode IDTPM::TrackAnalysisCollections::fillTestTruthVec ( const std::vector< const xAOD::TruthParticle * > &  vec,
Stage  stage = FULL 
)

fill TEST track vectors


— Fill TEST track vectors —

TEST = truth

Definition at line 229 of file TrackAnalysisCollections.cxx.

232 {
233  if( m_trkAnaDefSvc->isTestTruth() ) {
234  m_truthPartVec[ stage ].clear();
235  m_truthPartVec[ stage ].insert(
237  vec.begin(), vec.end() );
238  return StatusCode::SUCCESS;
239  }
240 
241  ATH_MSG_DEBUG( "No TEST TruthParticle vector" );
242  return StatusCode::SUCCESS;
243 }

◆ fillTestTruthVertexVec()

StatusCode IDTPM::TrackAnalysisCollections::fillTestTruthVertexVec ( const std::vector< const xAOD::TruthVertex * > &  vec,
Stage  stage = FULL 
)

fill TEST vertex vectors


— Fill TEST vertex vectors —

TEST = truth

Definition at line 465 of file TrackAnalysisCollections.cxx.

468 {
469  if( m_trkAnaDefSvc->isTestTruth() ) {
470  m_truthVertexVec[ stage ].clear();
471  m_truthVertexVec[ stage ].insert(
473  vec.begin(), vec.end() );
474  return StatusCode::SUCCESS;
475  }
476 
477  ATH_MSG_DEBUG( "No TEST Truth vertex vector" );
478  return StatusCode::SUCCESS;
479 }

◆ fillTrigTrackContainer()

StatusCode IDTPM::TrackAnalysisCollections::fillTrigTrackContainer ( const SG::ReadHandleKey< xAOD::TrackParticleContainer > &  handleKey)

Trigger track particles.

Fill container

Fill FULL vector

Definition at line 196 of file TrackAnalysisCollections.cxx.

198 {
199  if( m_trkAnaDefSvc->useTrigger()) {
200  ATH_MSG_DEBUG( "Loading collection: " << handleKey.key() );
201 
203 
204  if( not pColl.isValid() ) {
205  ATH_MSG_ERROR( "Non valid trigger tracks collection: " << handleKey.key() );
206  return StatusCode::FAILURE;
207  }
208 
210  m_trigTrackContainer = pColl.ptr();
211 
213  m_trigTrackVec[ FULL ].clear();
214  m_trigTrackVec[ FULL ].insert(
216  pColl->begin(), pColl->end() );
217  } else {
218  m_trigTrackContainer = nullptr;
219  m_trigTrackVec[ FULL ].clear();
220  }
221 
222  return StatusCode::SUCCESS;
223 }

◆ fillTrigTrackVec()

StatusCode IDTPM::TrackAnalysisCollections::fillTrigTrackVec ( const std::vector< const xAOD::TrackParticle * > &  vec,
Stage  stage = FULL 
)

Trigger tracks.

Definition at line 353 of file TrackAnalysisCollections.cxx.

356 {
357  if( m_trkAnaDefSvc->useTrigger() or m_trkAnaDefSvc->useEFTrigger() ) {
358  m_trigTrackVec[ stage ].clear();
359  m_trigTrackVec[ stage ].insert(
361  vec.begin(), vec.end() );
362  return StatusCode::SUCCESS;
363  }
364 
365  ATH_MSG_DEBUG( "No Trigger TrackParticle vector" );
366  return StatusCode::SUCCESS;
367 }

◆ fillTrigVertexContainer()

StatusCode IDTPM::TrackAnalysisCollections::fillTrigVertexContainer ( const SG::ReadHandleKey< xAOD::VertexContainer > &  handleKey)

Trigger vertices.

Skip if not useTrigger or if handle key is empty

Fill container

Fill FULL vector

Definition at line 433 of file TrackAnalysisCollections.cxx.

435 {
436  m_trigVertexContainer = nullptr;
437  m_trigVertexVec[ FULL ].clear();
438 
440  if( not m_trkAnaDefSvc->useTrigger() or
441  handleKey.key().empty() ) return StatusCode::SUCCESS;
442 
443  ATH_MSG_DEBUG( "Loading collection: " << handleKey.key() );
444  SG::ReadHandle< xAOD::VertexContainer > pColl( handleKey );
445  if( not pColl.isValid() ) {
446  ATH_MSG_ERROR( "Non valid trigger vertex collection: " << handleKey.key() );
447  return StatusCode::FAILURE;
448  }
449 
451  m_trigVertexContainer = pColl.ptr();
452 
454  m_trigVertexVec[ FULL ].insert(
456  pColl->begin(), pColl->end() );
457 
458  return StatusCode::SUCCESS;
459 }

◆ fillTrigVertexVec()

StatusCode IDTPM::TrackAnalysisCollections::fillTrigVertexVec ( const std::vector< const xAOD::Vertex * > &  vec,
Stage  stage = FULL 
)

Trigger tracks.

Definition at line 587 of file TrackAnalysisCollections.cxx.

590 {
591  if( m_trkAnaDefSvc->useTrigger() or m_trkAnaDefSvc->useEFTrigger() ) {
592  m_trigVertexVec[ stage ].clear();
593  m_trigVertexVec[ stage ].insert(
595  vec.begin(), vec.end() );
596  return StatusCode::SUCCESS;
597  }
598 
599  ATH_MSG_DEBUG( "No Trigger vertex vector" );
600  return StatusCode::SUCCESS;
601 }

◆ fillTruthPartContainer()

StatusCode IDTPM::TrackAnalysisCollections::fillTruthPartContainer ( const SG::ReadHandleKey< xAOD::TruthParticleContainer > &  truthPartHandleKey)

fill FULL track collections and vectors


— Fill FULL Track containers —

Truth particles

Fill container

Fill FULL vector

Grab the entire truth particle collection

Grab only truth particles from Hard Scatter

Grab only truth particles from Pile Up

Definition at line 108 of file TrackAnalysisCollections.cxx.

110 {
111  if( m_trkAnaDefSvc->useTruth() ) {
112  ATH_MSG_DEBUG( "Loading collection: " << truthPartHandleKey.key() );
113  SG::ReadHandle< xAOD::TruthParticleContainer > pTruthColl( truthPartHandleKey );
114  if( not pTruthColl.isValid() ) {
115  ATH_MSG_ERROR( "Non valid truth particles collection: " << truthPartHandleKey.key() );
116  return StatusCode::FAILURE;
117  }
118 
120  m_truthPartContainer = pTruthColl.ptr();
121 
123  m_truthPartVec[ FULL ].clear(); // clear to initialize it
124 
126  if( m_trkAnaDefSvc->pileupSwitch() == "All" ) {
127  m_truthPartVec[ FULL ].insert(
128  m_truthPartVec[ FULL ].begin(), pTruthColl->begin(), pTruthColl->end() );
129 
131  } else if( m_trkAnaDefSvc->pileupSwitch() == "HardScatter" ) {
132  if( m_truthEventContainer ) {
133  const xAOD::TruthEvent* event = m_truthEventContainer->at(0);
134  const auto& links = event->truthParticleLinks();
135  for( const auto& link : links ) {
136  if( link.isValid() ) m_truthPartVec[ FULL ].push_back( *link );
137  }
138  }
139 
141  } else if( m_trkAnaDefSvc->pileupSwitch() == "PileUp" ) {
143  // loop over all pile up events
144  for( size_t ipu=0; ipu < m_truthPUEventContainer->size(); ipu++ ) {
145  const xAOD::TruthPileupEvent* eventPU = m_truthPUEventContainer->at( ipu );
146  const auto& links = eventPU->truthParticleLinks();
147  for( const auto& link : links ) {
148  if( link.isValid() ) m_truthPartVec[ FULL ].push_back( *link );
149  }
150  }
151  }
152 
153  } else {
154  ATH_MSG_ERROR( "Invalid pileupSwitch: " << m_trkAnaDefSvc->pileupSwitch() );
155  return StatusCode::FAILURE;
156  }
157  } else {
158  m_truthPartContainer = nullptr;
159  m_truthPartVec[ FULL ].clear();
160  }
161 
162  return StatusCode::SUCCESS;
163 }

◆ fillTruthPartVec()

StatusCode IDTPM::TrackAnalysisCollections::fillTruthPartVec ( const std::vector< const xAOD::TruthParticle * > &  vec,
Stage  stage = FULL 
)

fill truth/offline/trigger track vector (TEST or REFERENCE)


— Fill track vectors —

Truth tracks

Definition at line 319 of file TrackAnalysisCollections.cxx.

322 {
323  if( m_trkAnaDefSvc->useTruth() ) {
324  m_truthPartVec[ stage ].clear();
325  m_truthPartVec[ stage ].insert(
327  vec.begin(), vec.end() );
328  return StatusCode::SUCCESS;
329  }
330 
331  ATH_MSG_DEBUG( "No TruthParticle vector" );
332  return StatusCode::SUCCESS;
333 }

◆ fillTruthVertexContainer()

StatusCode IDTPM::TrackAnalysisCollections::fillTruthVertexContainer ( const SG::ReadHandleKey< xAOD::TruthVertexContainer > &  truthVertexHandleKey)

fill FULL vertex collections and vectors


— Fill FULL Vertex containers —

Truth vertices

Skip if not useTruth or if handle key is empty

Fill container

Grab the entire truth Vertex collection

TODO - select truth vertices based on PU switch

Definition at line 373 of file TrackAnalysisCollections.cxx.

375 {
376  m_truthVertexContainer = nullptr;
377  m_truthVertexVec[ FULL ].clear();
378 
380  if( not m_trkAnaDefSvc->useTruth() or
381  truthVertexHandleKey.key().empty() ) return StatusCode::SUCCESS;
382 
383  ATH_MSG_DEBUG( "Loading collection: " << truthVertexHandleKey.key() );
384  SG::ReadHandle< xAOD::TruthVertexContainer > pTruthVertColl( truthVertexHandleKey );
385  if( not pTruthVertColl.isValid() ) {
386  ATH_MSG_ERROR( "Non valid truth vertex collection: " << truthVertexHandleKey.key() );
387  return StatusCode::FAILURE;
388  }
389 
391  m_truthVertexContainer = pTruthVertColl.ptr();
392 
394  m_truthVertexVec[ FULL ].insert(
396  pTruthVertColl->begin(), pTruthVertColl->end() );
397 
399 
400  return StatusCode::SUCCESS;
401 }

◆ fillTruthVertexVec()

StatusCode IDTPM::TrackAnalysisCollections::fillTruthVertexVec ( const std::vector< const xAOD::TruthVertex * > &  vec,
Stage  stage = FULL 
)

fill truth/offline/trigger vertex vector (TEST or REFERENCE)


— Fill vertex vectors —

Truth tracks

Definition at line 553 of file TrackAnalysisCollections.cxx.

556 {
557  if( m_trkAnaDefSvc->useTruth() ) {
558  m_truthVertexVec[ stage ].clear();
559  m_truthVertexVec[ stage ].insert(
561  vec.begin(), vec.end() );
562  return StatusCode::SUCCESS;
563  }
564 
565  ATH_MSG_DEBUG( "No Truth vertex vector" );
566  return StatusCode::SUCCESS;
567 }

◆ initialize()

StatusCode IDTPM::TrackAnalysisCollections::initialize ( )

initialize


— initialize —

load trkAnaDefSvc

construct track matching lookup table based on the types of test and reference Truth->Track

Track->Truth

Track->Track

Definition at line 41 of file TrackAnalysisCollections.cxx.

42 {
44  m_trkAnaDefSvc = Gaudi::svcLocator()->service( "TrkAnaDefSvc"+m_anaTag );
45  ATH_CHECK( m_trkAnaDefSvc.isValid() );
46 
50  if( m_trkAnaDefSvc->isTestTruth() ) {
51  m_matches = std::make_unique< TrackMatchingLookup_truthTrk >( m_anaTag );
52  }
54  else if( m_trkAnaDefSvc->isReferenceTruth() ) {
55  m_matches = std::make_unique< TrackMatchingLookup_trkTruth >( m_anaTag );
56  }
58  else {
59  m_matches = std::make_unique< TrackMatchingLookup_trk >( m_anaTag );
60  }
61 
62  return StatusCode::SUCCESS;
63 }

◆ initMessaging()

void AthMessaging::initMessaging ( ) const
privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

40 {
42  m_lvl = m_imsg ?
43  static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
44  MSG::INFO;
45 }

◆ matches()

ITrackMatchingLookup& IDTPM::TrackAnalysisCollections::matches ( )
inline

get track matching information

Definition at line 261 of file TrackAnalysisCollections.h.

261 { return *m_matches; }

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const
inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 164 of file AthMessaging.h.

165 {
166  MsgStream* ms = m_msg_tls.get();
167  if (!ms) {
168  if (!m_initialized.test_and_set()) initMessaging();
169  ms = new MsgStream(m_imsg,m_nm);
170  m_msg_tls.reset( ms );
171  }
172 
173  ms->setLevel (m_lvl);
174  return *ms;
175 }

◆ msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level  lvl) const
inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 179 of file AthMessaging.h.

180 { return msg() << lvl; }

◆ msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Test the output level.

Parameters
lvlThe message level to test against
Returns
boolean Indicating if messages at given level will be printed
Return values
trueMessages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

152 {
153  if (!m_initialized.test_and_set()) initMessaging();
154  if (m_lvl <= lvl) {
155  msg() << lvl;
156  return true;
157  } else {
158  return false;
159  }
160 }

◆ offlTrackContainer()

const xAOD::TrackParticleContainer* IDTPM::TrackAnalysisCollections::offlTrackContainer ( )
inline

Definition at line 199 of file TrackAnalysisCollections.h.

199  {
200  return m_offlTrackContainer; }

◆ offlTrackVec()

const std::vector< const xAOD::TrackParticle* >& IDTPM::TrackAnalysisCollections::offlTrackVec ( Stage  stage = FULL)
inline

Definition at line 215 of file TrackAnalysisCollections.h.

215  {
216  return m_offlTrackVec[ stage ]; }

◆ offlVertexContainer()

const xAOD::VertexContainer* IDTPM::TrackAnalysisCollections::offlVertexContainer ( )
inline

Definition at line 235 of file TrackAnalysisCollections.h.

235  {
236  return m_offlVertexContainer; }

◆ offlVertexVec()

const std::vector< const xAOD::Vertex* >& IDTPM::TrackAnalysisCollections::offlVertexVec ( Stage  stage = FULL)
inline

Definition at line 251 of file TrackAnalysisCollections.h.

251  {
252  return m_offlVertexVec[ stage ]; }

◆ operator=()

TrackAnalysisCollections& IDTPM::TrackAnalysisCollections::operator= ( const TrackAnalysisCollections )
delete

= operator

◆ printInfo()

std::string IDTPM::TrackAnalysisCollections::printInfo ( Stage  stage = FULL,
bool  printVertex = true 
) const

print information about tracks in the collection(s)


— Print collection info (for debug) —

print tracks

print also vertex info

Definition at line 1034 of file TrackAnalysisCollections.cxx.

1036 {
1037  std::stringstream ss;
1038  ss << "\n==========================================" << std::endl;
1039 
1040  size_t it(0);
1041  for( const xAOD::TrackParticle* thisOfflineTrack : m_offlTrackVec[ stage ] ) {
1042  ss << "Offline track"
1043  << " : pt = " << pT( *thisOfflineTrack )
1044  << " : eta = " << eta( *thisOfflineTrack )
1045  << " : phi = " << phi( *thisOfflineTrack )
1046  << std::endl;
1047  if( it > 20 ) { ss << "et al...." << std::endl; break; }
1048  it++;
1049  }
1050 
1051  if( not m_offlTrackVec[ stage ].empty() )
1052  ss << "==========================================" << std::endl;
1053 
1054  it = 0;
1055  for( const xAOD::TruthParticle* thisTruthParticle : m_truthPartVec[ stage ] ) {
1056  ss << "Truth particle"
1057  << " : pt = " << pT( *thisTruthParticle )
1058  << " : eta = " << eta( *thisTruthParticle )
1059  << " : phi = " << phi( *thisTruthParticle )
1060  << std::endl;
1061  if( it > 20 ) { ss << "et al...." << std::endl; break; }
1062  it++;
1063  }
1064 
1065  if( not m_truthPartVec[ stage ].empty() )
1066  ss << "==========================================" << std::endl;
1067 
1068  it = 0;
1069  for( const xAOD::TrackParticle* thisTriggerTrack : m_trigTrackVec[ stage ] ) {
1070  ss << "Trigger track"
1071  << " : pt = " << pT( *thisTriggerTrack )
1072  << " : eta = " << eta( *thisTriggerTrack )
1073  << " : phi = " << phi( *thisTriggerTrack )
1074  << std::endl;
1075  if( it > 20 ) { ss << "et al...." << std::endl; break; }
1076  it++;
1077  }
1078 
1079  if( not m_trigTrackVec[ stage ].empty() )
1080  ss << "==========================================" << std::endl;
1081 
1083  if( printVertex ) ss << "Vertices: " << printVertexInfo( stage );
1084 
1085  return ss.str();
1086 }

◆ printMatchInfo()

std::string IDTPM::TrackAnalysisCollections::printMatchInfo ( )

print track matching information


— Print matching information (for debug) —

Truth->Track

Track->Truth

Track->Track

Definition at line 1137 of file TrackAnalysisCollections.cxx.

1138 {
1140  if( m_trkAnaDefSvc->isTestTruth() ) {
1141  return m_matches->printInfo( testTruthVec( InRoI ), refTrackVec( InRoI ) );
1142  }
1144  if( m_trkAnaDefSvc->isReferenceTruth() ) {
1145  return m_matches->printInfo( testTrackVec( InRoI ), refTruthVec( InRoI ) );
1146  }
1148  return m_matches->printInfo( testTrackVec( InRoI ), refTrackVec( InRoI ) );
1149 }

◆ printVertexInfo()

std::string IDTPM::TrackAnalysisCollections::printVertexInfo ( Stage  stage = FULL) const

print information about vertices in the collection(s)

printVertexInfo

Definition at line 1089 of file TrackAnalysisCollections.cxx.

1091 {
1092  std::stringstream ss;
1093  ss << "\n==========================================" << std::endl;
1094 
1095  size_t it(0);
1096  for( const xAOD::Vertex* thisOfflineVertex : m_offlVertexVec[ stage ] ) {
1097  ss << "Offline vertex"
1098  << " : z = " << posZ( *thisOfflineVertex )
1099  << std::endl;
1100  if( it > 20 ) { ss << "et al...." << std::endl; break; }
1101  it++;
1102  }
1103 
1104  if( not m_offlVertexVec[ stage ].empty() )
1105  ss << "==========================================" << std::endl;
1106 
1107  it = 0;
1108  for( const xAOD::TruthVertex* thisTruthVertex : m_truthVertexVec[ stage ] ) {
1109  ss << "Truth vertex"
1110  << " : z = " << posZ( *thisTruthVertex )
1111  << std::endl;
1112  if( it > 20 ) { ss << "et al...." << std::endl; break; }
1113  it++;
1114  }
1115 
1116  if( not m_truthVertexVec[ stage ].empty() )
1117  ss << "==========================================" << std::endl;
1118 
1119  it = 0;
1120  for( const xAOD::Vertex* thisTriggerVertex : m_trigVertexVec[ stage ] ) {
1121  ss << "Trigger vertex"
1122  << " : z = " << posZ( *thisTriggerVertex )
1123  << std::endl;
1124  if( it > 20 ) { ss << "et al...." << std::endl; break; }
1125  it++;
1126  }
1127 
1128  if( not m_trigVertexVec[ stage ].empty() )
1129  ss << "==========================================" << std::endl;
1130 
1131  return ss.str();
1132 }

◆ refRecoVertexContainer()

const xAOD::VertexContainer * IDTPM::TrackAnalysisCollections::refRecoVertexContainer ( )

REFERENCE = Reco.

Definition at line 915 of file TrackAnalysisCollections.cxx.

916 {
917  if( m_trkAnaDefSvc->isReferenceOffline() ) {
918  return m_offlVertexContainer;
919  }
920 
921  if( m_trkAnaDefSvc->isReferenceTrigger() ) {
922  return m_trigVertexContainer;
923  }
924 
925  return nullptr;
926 }

◆ refRecoVertexVec()

const std::vector< const xAOD::Vertex * > & IDTPM::TrackAnalysisCollections::refRecoVertexVec ( Stage  stage = FULL)

REFERENCE = Reco.

Definition at line 976 of file TrackAnalysisCollections.cxx.

978 {
979  if( m_trkAnaDefSvc->isReferenceOffline() ) {
980  return m_offlVertexVec[ stage ];
981  }
982 
983  if( m_trkAnaDefSvc->isReferenceTrigger() ) {
984  return m_trigVertexVec[ stage ];
985  }
986 
987  ATH_MSG_DEBUG( "No Test reco vertex vector found" );
988  return m_nullRecoVertVec;
989 }

◆ refTrackContainer()

const xAOD::TrackParticleContainer * IDTPM::TrackAnalysisCollections::refTrackContainer ( )

REFERENCE = Track.

Definition at line 758 of file TrackAnalysisCollections.cxx.

759 {
760  if( m_trkAnaDefSvc->isReferenceOffline() ) {
761  return m_offlTrackContainer;
762  }
763 
764  if( m_trkAnaDefSvc->isReferenceTrigger() ) {
765  return m_trigTrackContainer;
766  }
767 
768  return nullptr;
769 }

◆ refTrackCounts()

std::vector< size_t > IDTPM::TrackAnalysisCollections::refTrackCounts ( )

REFERENCE.

Definition at line 857 of file TrackAnalysisCollections.cxx.

858 {
859  std::vector< size_t > counts( NCOUNTERS, 0 );
860  counts[ ALL ] = m_trkAnaDefSvc->isReferenceTruth() ?
861  refTruthVec( FULL ).size() :
862  refTrackVec( FULL ).size();
863  counts[ SELECTED ] = m_trkAnaDefSvc->isReferenceTruth() ?
864  refTruthVec( FS ).size() :
865  refTrackVec( FS ).size();
866  counts[ INROI ] = m_trkAnaDefSvc->isReferenceTruth() ?
867  refTruthVec( InRoI ).size() :
868  refTrackVec( InRoI ).size();
869  counts[ MATCHED ] = matches().getNmatches( true );
870  return counts;
871 }

◆ refTrackVec()

const std::vector< const xAOD::TrackParticle * > & IDTPM::TrackAnalysisCollections::refTrackVec ( Stage  stage = FULL)

TEST = Track.

Definition at line 819 of file TrackAnalysisCollections.cxx.

821 {
822  if( m_trkAnaDefSvc->isReferenceOffline() ) {
823  return m_offlTrackVec[ stage ];
824  }
825 
826  if( m_trkAnaDefSvc->isReferenceTrigger() ) {
827  return m_trigTrackVec[ stage ];
828  }
829 
830  ATH_MSG_DEBUG( "No Test track vector found" );
831  return m_nullTrackVec;
832 }

◆ refTruthContainer()

const xAOD::TruthParticleContainer * IDTPM::TrackAnalysisCollections::refTruthContainer ( )

get full REFERENCE track containers

REFERENCE = Truth.

Definition at line 747 of file TrackAnalysisCollections.cxx.

748 {
749  if( m_trkAnaDefSvc->isReferenceTruth() ) {
750  return m_truthPartContainer;
751  }
752 
753  return nullptr;
754 }

◆ refTruthVec()

const std::vector< const xAOD::TruthParticle * > & IDTPM::TrackAnalysisCollections::refTruthVec ( Stage  stage = FULL)

get REFERENCE track vectors

REFERENCE = Truth.

Definition at line 806 of file TrackAnalysisCollections.cxx.

808 {
809  if( m_trkAnaDefSvc->isReferenceTruth() ) {
810  return m_truthPartVec[ stage ];
811  }
812 
813  ATH_MSG_DEBUG( "No Reference truth vector found" );
814  return m_nullTruthVec;
815 }

◆ refTruthVertexContainer()

const xAOD::TruthVertexContainer * IDTPM::TrackAnalysisCollections::refTruthVertexContainer ( )

get full REFERENCE vertex containers

REFERENCE = Truth.

Definition at line 904 of file TrackAnalysisCollections.cxx.

905 {
906  if( m_trkAnaDefSvc->isReferenceTruth() ) {
907  return m_truthVertexContainer;
908  }
909 
910  return nullptr;
911 }

◆ refTruthVertexVec()

const std::vector< const xAOD::TruthVertex * > & IDTPM::TrackAnalysisCollections::refTruthVertexVec ( Stage  stage = FULL)

get REFERENCE vertex vectors

REFERENCE = Truth.

Definition at line 963 of file TrackAnalysisCollections.cxx.

965 {
966  if( m_trkAnaDefSvc->isReferenceTruth() ) {
967  return m_truthVertexVec[ stage ];
968  }
969 
970  ATH_MSG_DEBUG( "No Reference truth vertex vector found" );
971  return m_nullTruthVertVec;
972 }

◆ refVertexCounts()

std::vector< size_t > IDTPM::TrackAnalysisCollections::refVertexCounts ( )

REFERENCE.

TODO: add matched vertex count

Definition at line 1014 of file TrackAnalysisCollections.cxx.

1015 {
1016  std::vector< size_t > counts( NCOUNTERS, 0 );
1017  counts[ ALL ] = m_trkAnaDefSvc->isReferenceTruth() ?
1018  refTruthVertexVec( FULL ).size() :
1019  refRecoVertexVec( FULL ).size();
1020  counts[ SELECTED ] = m_trkAnaDefSvc->isReferenceTruth() ?
1021  refTruthVertexVec( FS ).size() :
1022  refRecoVertexVec( FS ).size();
1023  counts[ INROI ] = m_trkAnaDefSvc->isReferenceTruth() ?
1024  refTruthVertexVec( InRoI ).size() :
1025  refRecoVertexVec( InRoI ).size();
1026  counts[ MATCHED ] = 0;
1027  return counts;
1028 }

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level  lvl)
inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

29 {
30  m_lvl = lvl;
31 }

◆ testRecoVertexContainer()

const xAOD::VertexContainer * IDTPM::TrackAnalysisCollections::testRecoVertexContainer ( )

TEST = Reco.

Definition at line 889 of file TrackAnalysisCollections.cxx.

890 {
891  if( m_trkAnaDefSvc->isTestOffline() ) {
892  return m_offlVertexContainer;
893  }
894 
895  if( m_trkAnaDefSvc->isTestTrigger() ) {
896  return m_trigVertexContainer;
897  }
898 
899  return nullptr;
900 }

◆ testRecoVertexVec()

const std::vector< const xAOD::Vertex * > & IDTPM::TrackAnalysisCollections::testRecoVertexVec ( Stage  stage = FULL)

TEST = Reco.

Definition at line 946 of file TrackAnalysisCollections.cxx.

948 {
949  if( m_trkAnaDefSvc->isTestOffline() ) {
950  return m_offlVertexVec[ stage ];
951  }
952 
953  if( m_trkAnaDefSvc->isTestTrigger() ) {
954  return m_trigVertexVec[ stage ];
955  }
956 
957  ATH_MSG_DEBUG( "No Test reco vertex vector found" );
958  return m_nullRecoVertVec;
959 }

◆ testTrackContainer()

const xAOD::TrackParticleContainer * IDTPM::TrackAnalysisCollections::testTrackContainer ( )

TEST = Track.

Definition at line 732 of file TrackAnalysisCollections.cxx.

733 {
734  if( m_trkAnaDefSvc->isTestOffline() ) {
735  return m_offlTrackContainer;
736  }
737 
738  if( m_trkAnaDefSvc->isTestTrigger() ) {
739  return m_trigTrackContainer;
740  }
741 
742  return nullptr;
743 }

◆ testTrackCounts()

std::vector< size_t > IDTPM::TrackAnalysisCollections::testTrackCounts ( )

get counts vectors for TEST/REFERENCE track vectors at all stages


— Get track counts —

TEST

Definition at line 839 of file TrackAnalysisCollections.cxx.

840 {
841  std::vector< size_t > counts( NCOUNTERS, 0 );
842  counts[ ALL ] = m_trkAnaDefSvc->isTestTruth() ?
843  testTruthVec( FULL ).size() :
844  testTrackVec( FULL ).size();
845  counts[ SELECTED ] = m_trkAnaDefSvc->isTestTruth() ?
846  testTruthVec( FS ).size() :
847  testTrackVec( FS ).size();
848  counts[ INROI ] = m_trkAnaDefSvc->isTestTruth() ?
849  testTruthVec( InRoI ).size() :
850  testTrackVec( InRoI ).size();
851  counts[ MATCHED ] = matches().getNmatches();
852  return counts;
853 }

◆ testTrackVec()

const std::vector< const xAOD::TrackParticle * > & IDTPM::TrackAnalysisCollections::testTrackVec ( Stage  stage = FULL)

TEST = Track.

Definition at line 789 of file TrackAnalysisCollections.cxx.

791 {
792  if( m_trkAnaDefSvc->isTestOffline() ) {
793  return m_offlTrackVec[ stage ];
794  }
795 
796  if( m_trkAnaDefSvc->isTestTrigger() ) {
797  return m_trigTrackVec[ stage ];
798  }
799 
800  ATH_MSG_DEBUG( "No Test track vector found" );
801  return m_nullTrackVec;
802 }

◆ testTruthContainer()

const xAOD::TruthParticleContainer * IDTPM::TrackAnalysisCollections::testTruthContainer ( )

get full TEST track containers


— Get FULL Track containers —

TEST = Truth

Definition at line 721 of file TrackAnalysisCollections.cxx.

722 {
723  if( m_trkAnaDefSvc->isTestTruth() ) {
724  return m_truthPartContainer;
725  }
726 
727  return nullptr;
728 }

◆ testTruthVec()

const std::vector< const xAOD::TruthParticle * > & IDTPM::TrackAnalysisCollections::testTruthVec ( Stage  stage = FULL)

get TEST track vectors


— Get track vectors —

TEST = Truth

Definition at line 776 of file TrackAnalysisCollections.cxx.

778 {
779  if( m_trkAnaDefSvc->isTestTruth() ) {
780  return m_truthPartVec[ stage ];
781  }
782 
783  ATH_MSG_DEBUG( "No Test truth vector found" );
784  return m_nullTruthVec;
785 }

◆ testTruthVertexContainer()

const xAOD::TruthVertexContainer * IDTPM::TrackAnalysisCollections::testTruthVertexContainer ( )

get full TEST vertex containers


— Get FULL Vertex containers —

TEST = Truth

Definition at line 878 of file TrackAnalysisCollections.cxx.

879 {
880  if( m_trkAnaDefSvc->isTestTruth() ) {
881  return m_truthVertexContainer;
882  }
883 
884  return nullptr;
885 }

◆ testTruthVertexVec()

const std::vector< const xAOD::TruthVertex * > & IDTPM::TrackAnalysisCollections::testTruthVertexVec ( Stage  stage = FULL)

get TEST vertex vectors


— Get vertex vectors —

TEST = Truth

Definition at line 933 of file TrackAnalysisCollections.cxx.

935 {
936  if( m_trkAnaDefSvc->isTestTruth() ) {
937  return m_truthVertexVec[ stage ];
938  }
939 
940  ATH_MSG_DEBUG( "No Test truth vertex vector found" );
941  return m_nullTruthVertVec;
942 }

◆ testVertexCounts()

std::vector< size_t > IDTPM::TrackAnalysisCollections::testVertexCounts ( )

get counts vectors for TEST/REFERENCE vertex vectors at all stages


— Get vertex counts —

TEST

TODO: add matched vertex count

Definition at line 996 of file TrackAnalysisCollections.cxx.

997 {
998  std::vector< size_t > counts( NCOUNTERS, 0 );
999  counts[ ALL ] = m_trkAnaDefSvc->isTestTruth() ?
1000  testTruthVertexVec( FULL ).size() :
1001  testRecoVertexVec( FULL ).size();
1002  counts[ SELECTED ] = m_trkAnaDefSvc->isTestTruth() ?
1003  testTruthVertexVec( FS ).size() :
1004  testRecoVertexVec( FS ).size();
1005  counts[ INROI ] = m_trkAnaDefSvc->isTestTruth() ?
1006  testTruthVertexVec( InRoI ).size() :
1007  testRecoVertexVec( InRoI ).size();
1008  counts[ MATCHED ] = 0;
1009  return counts;
1010 }

◆ trigTrackContainer()

const xAOD::TrackParticleContainer* IDTPM::TrackAnalysisCollections::trigTrackContainer ( )
inline

Definition at line 201 of file TrackAnalysisCollections.h.

201  {
202  return m_trigTrackContainer; }

◆ trigTrackVec()

const std::vector< const xAOD::TrackParticle* >& IDTPM::TrackAnalysisCollections::trigTrackVec ( Stage  stage = FULL)
inline

Definition at line 217 of file TrackAnalysisCollections.h.

217  {
218  return m_trigTrackVec[ stage ]; }

◆ trigVertexContainer()

const xAOD::VertexContainer* IDTPM::TrackAnalysisCollections::trigVertexContainer ( )
inline

Definition at line 237 of file TrackAnalysisCollections.h.

237  {
238  return m_trigVertexContainer; }

◆ trigVertexVec()

const std::vector< const xAOD::Vertex* >& IDTPM::TrackAnalysisCollections::trigVertexVec ( Stage  stage = FULL)
inline

Definition at line 253 of file TrackAnalysisCollections.h.

253  {
254  return m_trigVertexVec[ stage ]; }

◆ truthEventContainer()

const xAOD::TruthEventContainer* IDTPM::TrackAnalysisCollections::truthEventContainer ( )
inline

Definition at line 185 of file TrackAnalysisCollections.h.

185 { return m_truthEventContainer; }

◆ truthPartContainer()

const xAOD::TruthParticleContainer* IDTPM::TrackAnalysisCollections::truthPartContainer ( )
inline

get truth/offline/trigger track containers (TEST or REFERENCE)

Definition at line 197 of file TrackAnalysisCollections.h.

197  {
198  return m_truthPartContainer; }

◆ truthPartVec()

const std::vector< const xAOD::TruthParticle* >& IDTPM::TrackAnalysisCollections::truthPartVec ( Stage  stage = FULL)
inline

get truth/offline/trigger track vector (TEST or REFERENCE)

Definition at line 213 of file TrackAnalysisCollections.h.

213  {
214  return m_truthPartVec[ stage ]; }

◆ truthPileupEventContainer()

const xAOD::TruthPileupEventContainer* IDTPM::TrackAnalysisCollections::truthPileupEventContainer ( )
inline

Definition at line 186 of file TrackAnalysisCollections.h.

186 { return m_truthPUEventContainer; }

◆ truthVertexContainer()

const xAOD::TruthVertexContainer* IDTPM::TrackAnalysisCollections::truthVertexContainer ( )
inline

get truth/offline/trigger vertex containers (TEST or REFERENCE)

Definition at line 233 of file TrackAnalysisCollections.h.

233  {
234  return m_truthVertexContainer; }

◆ truthVertexVec()

const std::vector< const xAOD::TruthVertex* >& IDTPM::TrackAnalysisCollections::truthVertexVec ( Stage  stage = FULL)
inline

get truth/offline/trigger vertex vector (TEST or REFERENCE)

Definition at line 249 of file TrackAnalysisCollections.h.

249  {
250  return m_truthVertexVec[ stage ]; }

◆ updateChainRois()

bool IDTPM::TrackAnalysisCollections::updateChainRois ( const std::string &  chainRoi,
const std::string &  roiStr 
)

update chainRois map


— update chainRois map —

Creating new matching lookup table for newChainRoiName

m_matches is now ready to be updated with new entries for the maps...

Definition at line 1155 of file TrackAnalysisCollections.cxx.

1157 {
1158  ATH_MSG_DEBUG( "Updating TrackAnalysisCollection with ChainRoiName: " << chainRoi );
1159 
1160  std::pair< mapChainRoi_t::iterator, bool > result =
1161  m_chainRois.insert( mapChainRoi_t::value_type( chainRoi, roiStr ) );
1162 
1163  if( not result.second ) {
1164  ATH_MSG_WARNING( "ChainRoiName has already been cached. No update." );
1165  return false;
1166  }
1167 
1169  m_matches->clear();
1170  m_matches->chainRoiName( chainRoi );
1172 
1173  return result.second;
1174 }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_anaTag

std::string IDTPM::TrackAnalysisCollections::m_anaTag
private

TrackAnalysis properties.

Definition at line 272 of file TrackAnalysisCollections.h.

◆ m_chainRois

mapChainRoi_t IDTPM::TrackAnalysisCollections::m_chainRois {}
private

Definition at line 312 of file TrackAnalysisCollections.h.

◆ m_eventInfo

const xAOD::EventInfo* IDTPM::TrackAnalysisCollections::m_eventInfo {nullptr}
private

— Collections class variables — EventInfo, TruthEvent, and TruthPUEvent

Definition at line 277 of file TrackAnalysisCollections.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }
mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }
mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

◆ m_matches

std::unique_ptr< ITrackMatchingLookup > IDTPM::TrackAnalysisCollections::m_matches
private

Lookup table for test-reference matching.

Definition at line 308 of file TrackAnalysisCollections.h.

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls
mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm
privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_nullRecoVertVec

std::vector< const xAOD::Vertex* > IDTPM::TrackAnalysisCollections::m_nullRecoVertVec {}
private

Definition at line 305 of file TrackAnalysisCollections.h.

◆ m_nullTrackVec

std::vector< const xAOD::TrackParticle* > IDTPM::TrackAnalysisCollections::m_nullTrackVec {}
private

null vectors

Definition at line 302 of file TrackAnalysisCollections.h.

◆ m_nullTruthVec

std::vector< const xAOD::TruthParticle* > IDTPM::TrackAnalysisCollections::m_nullTruthVec {}
private

Definition at line 303 of file TrackAnalysisCollections.h.

◆ m_nullTruthVertVec

std::vector< const xAOD::TruthVertex* > IDTPM::TrackAnalysisCollections::m_nullTruthVertVec {}
private

Definition at line 304 of file TrackAnalysisCollections.h.

◆ m_offlTrackContainer

const xAOD::TrackParticleContainer* IDTPM::TrackAnalysisCollections::m_offlTrackContainer {nullptr}
private

Definition at line 283 of file TrackAnalysisCollections.h.

◆ m_offlTrackVec

std::vector<std::vector< const xAOD::TrackParticle* > > IDTPM::TrackAnalysisCollections::m_offlTrackVec {}
private

Definition at line 288 of file TrackAnalysisCollections.h.

◆ m_offlVertexContainer

const xAOD::VertexContainer* IDTPM::TrackAnalysisCollections::m_offlVertexContainer {nullptr}
private

Definition at line 293 of file TrackAnalysisCollections.h.

◆ m_offlVertexVec

std::vector<std::vector< const xAOD::Vertex* > > IDTPM::TrackAnalysisCollections::m_offlVertexVec {}
private

Definition at line 298 of file TrackAnalysisCollections.h.

◆ m_trigTrackContainer

const xAOD::TrackParticleContainer* IDTPM::TrackAnalysisCollections::m_trigTrackContainer {nullptr}
private

Definition at line 284 of file TrackAnalysisCollections.h.

◆ m_trigTrackVec

std::vector<std::vector< const xAOD::TrackParticle* > > IDTPM::TrackAnalysisCollections::m_trigTrackVec {}
private

Definition at line 289 of file TrackAnalysisCollections.h.

◆ m_trigVertexContainer

const xAOD::VertexContainer* IDTPM::TrackAnalysisCollections::m_trigVertexContainer {nullptr}
private

Definition at line 294 of file TrackAnalysisCollections.h.

◆ m_trigVertexVec

std::vector<std::vector< const xAOD::Vertex* > > IDTPM::TrackAnalysisCollections::m_trigVertexVec {}
private

Definition at line 299 of file TrackAnalysisCollections.h.

◆ m_trkAnaDefSvc

SmartIF< ITrackAnalysisDefinitionSvc > IDTPM::TrackAnalysisCollections::m_trkAnaDefSvc
private

Definition at line 273 of file TrackAnalysisCollections.h.

◆ m_truthEventContainer

const xAOD::TruthEventContainer* IDTPM::TrackAnalysisCollections::m_truthEventContainer {nullptr}
private

Definition at line 278 of file TrackAnalysisCollections.h.

◆ m_truthPartContainer

const xAOD::TruthParticleContainer* IDTPM::TrackAnalysisCollections::m_truthPartContainer {nullptr}
private

Full track collections.

Definition at line 282 of file TrackAnalysisCollections.h.

◆ m_truthPartVec

std::vector<std::vector< const xAOD::TruthParticle* > > IDTPM::TrackAnalysisCollections::m_truthPartVec {}
private

vectors of track/truth particles at different stages of the selection/workflow

Definition at line 287 of file TrackAnalysisCollections.h.

◆ m_truthPUEventContainer

const xAOD::TruthPileupEventContainer* IDTPM::TrackAnalysisCollections::m_truthPUEventContainer {nullptr}
private

Definition at line 279 of file TrackAnalysisCollections.h.

◆ m_truthVertexContainer

const xAOD::TruthVertexContainer* IDTPM::TrackAnalysisCollections::m_truthVertexContainer {nullptr}
private

Full vertex collections.

Definition at line 292 of file TrackAnalysisCollections.h.

◆ m_truthVertexVec

std::vector<std::vector< const xAOD::TruthVertex* > > IDTPM::TrackAnalysisCollections::m_truthVertexVec {}
private

vectors of reco/truth vertices at different stages of the selection/workflow

Definition at line 297 of file TrackAnalysisCollections.h.


The documentation for this class was generated from the following files:
IDTPM::TrackAnalysisCollections::printInfo
std::string printInfo(Stage stage=FULL, bool printVertex=true) const
print information about tracks in the collection(s)
Definition: TrackAnalysisCollections.cxx:1034
AthMessaging::m_lvl
std::atomic< MSG::Level > m_lvl
Current logging level.
Definition: AthMessaging.h:138
IDTPM::TrackAnalysisCollections::printVertexInfo
std::string printVertexInfo(Stage stage=FULL) const
print information about vertices in the collection(s)
Definition: TrackAnalysisCollections.cxx:1089
IDTPM::TrackAnalysisCollections::m_matches
std::unique_ptr< ITrackMatchingLookup > m_matches
Lookup table for test-reference matching.
Definition: TrackAnalysisCollections.h:308
get_generator_info.result
result
Definition: get_generator_info.py:21
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
python.FPGATrackSimAnalysisConfig.stage
stage
Definition: FPGATrackSimAnalysisConfig.py:558
IDTPM::TrackAnalysisCollections::NStages
@ NStages
Definition: TrackAnalysisCollections.h:54
IDTPM::TrackAnalysisCollections::ALL
@ ALL
Definition: TrackAnalysisCollections.h:57
IDTPM::TrackAnalysisCollections::m_nullTruthVertVec
std::vector< const xAOD::TruthVertex * > m_nullTruthVertVec
Definition: TrackAnalysisCollections.h:304
IDTPM::TrackAnalysisCollections::m_offlTrackVec
std::vector< std::vector< const xAOD::TrackParticle * > > m_offlTrackVec
Definition: TrackAnalysisCollections.h:288
IDTPM::TrackAnalysisCollections::m_trigTrackVec
std::vector< std::vector< const xAOD::TrackParticle * > > m_trigTrackVec
Definition: TrackAnalysisCollections.h:289
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
IDTPM::TrackAnalysisCollections::m_nullTrackVec
std::vector< const xAOD::TrackParticle * > m_nullTrackVec
null vectors
Definition: TrackAnalysisCollections.h:302
IDTPM::TrackAnalysisCollections::m_trigVertexVec
std::vector< std::vector< const xAOD::Vertex * > > m_trigVertexVec
Definition: TrackAnalysisCollections.h:299
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
skel.it
it
Definition: skel.GENtoEVGEN.py:396
IDTPM::TrackAnalysisCollections::m_offlTrackContainer
const xAOD::TrackParticleContainer * m_offlTrackContainer
Definition: TrackAnalysisCollections.h:283
xAOD::TruthPileupEvent_v1
Class describing a pile-up truth event in the MC record.
Definition: TruthPileupEvent_v1.h:23
IDTPM::TrackAnalysisCollections::refTruthVertexVec
const std::vector< const xAOD::TruthVertex * > & refTruthVertexVec(Stage stage=FULL)
get REFERENCE vertex vectors
Definition: TrackAnalysisCollections.cxx:963
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:12
IDTPM::TrackAnalysisCollections::m_nullTruthVec
std::vector< const xAOD::TruthParticle * > m_nullTruthVec
Definition: TrackAnalysisCollections.h:303
IDTPM::TrackAnalysisCollections::SELECTED
@ SELECTED
Definition: TrackAnalysisCollections.h:57
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
IDTPM::TrackAnalysisCollections::m_trigVertexContainer
const xAOD::VertexContainer * m_trigVertexContainer
Definition: TrackAnalysisCollections.h:294
IDTPM::TrackAnalysisCollections::m_truthVertexContainer
const xAOD::TruthVertexContainer * m_truthVertexContainer
Full vertex collections.
Definition: TrackAnalysisCollections.h:292
AthMessaging::m_imsg
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
Definition: AthMessaging.h:135
python.SystemOfUnits.ms
int ms
Definition: SystemOfUnits.py:132
IDTPM::phi
float phi(const U &p)
Definition: TrackParametersHelper.h:61
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
IDTPM::TrackAnalysisCollections::MATCHED
@ MATCHED
Definition: TrackAnalysisCollections.h:57
IDTPM::TrackAnalysisCollections::testTrackVec
const std::vector< const xAOD::TrackParticle * > & testTrackVec(Stage stage=FULL)
TEST = Track.
Definition: TrackAnalysisCollections.cxx:789
AthMessaging::AthMessaging
AthMessaging()
Default constructor:
IDTPM::TrackAnalysisCollections::m_trkAnaDefSvc
SmartIF< ITrackAnalysisDefinitionSvc > m_trkAnaDefSvc
Definition: TrackAnalysisCollections.h:273
IDTPM::TrackAnalysisCollections::m_trigTrackContainer
const xAOD::TrackParticleContainer * m_trigTrackContainer
Definition: TrackAnalysisCollections.h:284
IDTPM::TrackAnalysisCollections::m_truthEventContainer
const xAOD::TruthEventContainer * m_truthEventContainer
Definition: TrackAnalysisCollections.h:278
TrigConf::MSGTC::Level
Level
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:21
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
IDTPM::eta
float eta(const U &p)
Accessor utility function for getting the value of eta.
Definition: TrackParametersHelper.h:43
IDTPM::TrackAnalysisCollections::INROI
@ INROI
Definition: TrackAnalysisCollections.h:57
DMTest::links
links
Definition: CLinks_v1.cxx:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
IDTPM::TrackAnalysisCollections::FS
@ FS
Definition: TrackAnalysisCollections.h:54
IDTPM::TrackAnalysisCollections::testRecoVertexVec
const std::vector< const xAOD::Vertex * > & testRecoVertexVec(Stage stage=FULL)
TEST = Reco.
Definition: TrackAnalysisCollections.cxx:946
xAOD::TruthParticle_v1
Class describing a truth particle in the MC record.
Definition: TruthParticle_v1.h:37
IDTPM::TrackAnalysisCollections::m_truthVertexVec
std::vector< std::vector< const xAOD::TruthVertex * > > m_truthVertexVec
vectors of reco/truth vertices at different stages of the selection/workflow
Definition: TrackAnalysisCollections.h:297
IDTPM::TrackAnalysisCollections::matches
ITrackMatchingLookup & matches()
get track matching information
Definition: TrackAnalysisCollections.h:261
IDTPM::TrackAnalysisCollections::m_nullRecoVertVec
std::vector< const xAOD::Vertex * > m_nullRecoVertVec
Definition: TrackAnalysisCollections.h:305
IDTPM::pT
float pT(const U &p)
Accessor utility function for getting the value of pT.
Definition: TrackParametersHelper.h:33
xAOD::TruthEvent_v1
Class describing a signal truth event in the MC record.
Definition: TruthEvent_v1.h:35
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
IDTPM::TrackAnalysisCollections::NCOUNTERS
@ NCOUNTERS
Definition: TrackAnalysisCollections.h:57
IDTPM::posZ
float posZ(const V &v)
Accessor utility function for getting the value of vertex position z.
Definition: VertexParametersHelper.h:37
AthMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition: AthMessaging.h:164
IDTPM::TrackAnalysisCollections::testTruthVertexVec
const std::vector< const xAOD::TruthVertex * > & testTruthVertexVec(Stage stage=FULL)
get TEST vertex vectors
Definition: TrackAnalysisCollections.cxx:933
xAOD::TruthVertex_v1
Class describing a truth vertex in the MC record.
Definition: TruthVertex_v1.h:37
IDTPM::TrackAnalysisCollections::m_offlVertexVec
std::vector< std::vector< const xAOD::Vertex * > > m_offlVertexVec
Definition: TrackAnalysisCollections.h:298
IDTPM::TrackAnalysisCollections::m_truthPartContainer
const xAOD::TruthParticleContainer * m_truthPartContainer
Full track collections.
Definition: TrackAnalysisCollections.h:282
IDTPM::TrackAnalysisCollections::refTrackVec
const std::vector< const xAOD::TrackParticle * > & refTrackVec(Stage stage=FULL)
TEST = Track.
Definition: TrackAnalysisCollections.cxx:819
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
IDTPM::TrackAnalysisCollections::InRoI
@ InRoI
Definition: TrackAnalysisCollections.h:54
AthMessaging::m_nm
std::string m_nm
Message source name.
Definition: AthMessaging.h:129
IDTPM::ITrackMatchingLookup::getNmatches
virtual unsigned getNmatches(bool getRefN=false) const =0
get overall number of matches
IDTPM::TrackAnalysisCollections::testTruthVec
const std::vector< const xAOD::TruthParticle * > & testTruthVec(Stage stage=FULL)
get TEST track vectors
Definition: TrackAnalysisCollections.cxx:776
IDTPM::TrackAnalysisCollections::empty
bool empty(Stage stage=FULL)
— Utility methods —
Definition: TrackAnalysisCollections.cxx:607
IDTPM::TrackAnalysisCollections::m_truthPUEventContainer
const xAOD::TruthPileupEventContainer * m_truthPUEventContainer
Definition: TrackAnalysisCollections.h:279
IDTPM::TrackAnalysisCollections::m_anaTag
std::string m_anaTag
TrackAnalysis properties.
Definition: TrackAnalysisCollections.h:272
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
AthMessaging::initMessaging
void initMessaging() const
Initialize our message level and MessageSvc.
Definition: AthMessaging.cxx:39
IDTPM::TrackAnalysisCollections::FULL
@ FULL
Definition: TrackAnalysisCollections.h:54
xAOD::TruthEventBase_v1::truthParticleLinks
const TruthParticleLinks_t & truthParticleLinks() const
Get all the truth particles.
IDTPM::TrackAnalysisCollections::refRecoVertexVec
const std::vector< const xAOD::Vertex * > & refRecoVertexVec(Stage stage=FULL)
REFERENCE = Reco.
Definition: TrackAnalysisCollections.cxx:976
AthMessaging::m_msg_tls
boost::thread_specific_ptr< MsgStream > m_msg_tls
MsgStream instance (a std::cout like with print-out levels)
Definition: AthMessaging.h:132
IDTPM::TrackAnalysisCollections::anaTag
const std::string & anaTag()
— Getter methods —
Definition: TrackAnalysisCollections.h:181
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
IDTPM::TrackAnalysisCollections::m_chainRois
mapChainRoi_t m_chainRois
Definition: TrackAnalysisCollections.h:312
IDTPM::TrackAnalysisCollections::m_truthPartVec
std::vector< std::vector< const xAOD::TruthParticle * > > m_truthPartVec
vectors of track/truth particles at different stages of the selection/workflow
Definition: TrackAnalysisCollections.h:287
IDTPM::TrackAnalysisCollections::m_offlVertexContainer
const xAOD::VertexContainer * m_offlVertexContainer
Definition: TrackAnalysisCollections.h:293
IDTPM::TrackAnalysisCollections::m_eventInfo
const xAOD::EventInfo * m_eventInfo
— Collections class variables — EventInfo, TruthEvent, and TruthPUEvent
Definition: TrackAnalysisCollections.h:277
IDTPM::TrackAnalysisCollections::refTruthVec
const std::vector< const xAOD::TruthParticle * > & refTruthVec(Stage stage=FULL)
get REFERENCE track vectors
Definition: TrackAnalysisCollections.cxx:806