IDTPM::TrackAnalysisCollections Class Reference

#include <TrackAnalysisCollections.h>

Inheritance 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.
	~TrackAnalysisCollections ()=default
	Destructor.
TrackAnalysisCollections &	operator= (const TrackAnalysisCollections &)=delete
	= operator
StatusCode	initialize ()
	initialize
StatusCode	fillEventInfo (const SG::ReadHandleKey< xAOD::EventInfo > &eventInfoHandleKey, const SG::ReadHandleKey< xAOD::TruthEventContainer > &truthEventHandleKey, const SG::ReadHandleKey< xAOD::TruthPileupEventContainer > &truthPUEventHandleKey)
	— Setter methods —
StatusCode	fillTruthPartContainer (const SG::ReadHandleKey< xAOD::TruthParticleContainer > &truthPartHandleKey)
	fill FULL track collections and vectors
StatusCode	fillOfflTrackContainer (const SG::ReadHandleKey< xAOD::TrackParticleContainer > &handleKey)
	Offline track particles.
StatusCode	fillTrigTrackContainer (const SG::ReadHandleKey< xAOD::TrackParticleContainer > &handleKey)
	Trigger track particles.
StatusCode	fillTestTruthVec (const std::vector< const xAOD::TruthParticle * > &vec, Stage stage=FULL)
	fill TEST track vectors
StatusCode	fillTestTrackVec (const std::vector< const xAOD::TrackParticle * > &vec, Stage stage=FULL)
	TEST = tracks.
StatusCode	fillRefTruthVec (const std::vector< const xAOD::TruthParticle * > &vec, Stage stage=FULL)
	fill REFERENCE track vectors
StatusCode	fillRefTrackVec (const std::vector< const xAOD::TrackParticle * > &vec, Stage stage=FULL)
	REFERENCE = tracks.
StatusCode	fillTruthPartVec (const std::vector< const xAOD::TruthParticle * > &vec, Stage stage=FULL)
	fill truth/offline/trigger track vector (TEST or REFERENCE)
StatusCode	fillOfflTrackVec (const std::vector< const xAOD::TrackParticle * > &vec, Stage stage=FULL)
	Offline tracks.
StatusCode	fillTrigTrackVec (const std::vector< const xAOD::TrackParticle * > &vec, Stage stage=FULL)
	Trigger tracks.
StatusCode	fillTruthVertexContainer (const SG::ReadHandleKey< xAOD::TruthVertexContainer > &truthVertexHandleKey)
	fill FULL vertex collections and vectors
StatusCode	fillOfflVertexContainer (const SG::ReadHandleKey< xAOD::VertexContainer > &handleKey)
	Offline vertices.
StatusCode	fillTrigVertexContainer (const SG::ReadHandleKey< xAOD::VertexContainer > &handleKey)
	Trigger vertices.
StatusCode	fillTestTruthVertexVec (const std::vector< const xAOD::TruthVertex * > &vec, Stage stage=FULL)
	fill TEST vertex vectors
StatusCode	fillTestRecoVertexVec (const std::vector< const xAOD::Vertex * > &vec, Stage stage=FULL)
	TEST = reco.
StatusCode	fillRefTruthVertexVec (const std::vector< const xAOD::TruthVertex * > &vec, Stage stage=FULL)
	fill REFERENCE vertex vectors
StatusCode	fillRefRecoVertexVec (const std::vector< const xAOD::Vertex * > &vec, Stage stage=FULL)
	REFERENCE = reco.
StatusCode	fillTruthVertexVec (const std::vector< const xAOD::TruthVertex * > &vec, Stage stage=FULL)
	fill truth/offline/trigger vertex vector (TEST or REFERENCE)
StatusCode	fillOfflVertexVec (const std::vector< const xAOD::Vertex * > &vec, Stage stage=FULL)
	Offline tracks.
StatusCode	fillTrigVertexVec (const std::vector< const xAOD::Vertex * > &vec, Stage stage=FULL)
	Trigger tracks.
bool	isNewEvent ()
	— Utility methods —
bool	isNewChain ()
	check if this is a new chain
void	newChain ()
	update before running on new chain
bool	isNewRoI ()
	check if this is a new RoI
void	newRoI ()
	update before running on new RoI
bool	empty (Stage stage=FULL)
	check if collection are empty
void	clear (Stage stage=FULL)
	Clear vectors.
void	copyFS ()
	copy content of FS vectors to InRoI vectors
std::string	printInfo (Stage stage=FULL, bool printVertex=true) const
	print information about tracks in the collection(s)
std::string	printVertexInfo (Stage stage=FULL) const
	print information about vertices in the collection(s)
const std::string &	anaTag ()
	— Getter methods —
const xAOD::EventInfo *	eventInfo ()
	get event info
const xAOD::TruthEventContainer *	truthEventContainer ()
const xAOD::TruthPileupEventContainer *	truthPileupEventContainer ()
const xAOD::TruthParticleContainer *	testTruthContainer ()
	get full TEST track containers
const xAOD::TrackParticleContainer *	testTrackContainer ()
	TEST = Track.
const xAOD::TruthParticleContainer *	refTruthContainer ()
	get full REFERENCE track containers
const xAOD::TrackParticleContainer *	refTrackContainer ()
	REFERENCE = Track.
const xAOD::TruthParticleContainer *	truthPartContainer ()
	get truth/offline/trigger track containers (TEST or REFERENCE)
const xAOD::TrackParticleContainer *	offlTrackContainer ()
const xAOD::TrackParticleContainer *	trigTrackContainer ()
const std::vector< const xAOD::TruthParticle * > &	testTruthVec (Stage stage=FULL)
	get TEST track vectors
const std::vector< const xAOD::TrackParticle * > &	testTrackVec (Stage stage=FULL)
	TEST = Track.
const std::vector< const xAOD::TruthParticle * > &	refTruthVec (Stage stage=FULL)
	get REFERENCE track vectors
const std::vector< const xAOD::TrackParticle * > &	refTrackVec (Stage stage=FULL)
	TEST = Track.
const std::vector< const xAOD::TruthParticle * > &	truthPartVec (Stage stage=FULL)
	get truth/offline/trigger track vector (TEST or REFERENCE)
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
std::vector< size_t >	refTrackCounts ()
	REFERENCE.
const xAOD::TruthVertexContainer *	testTruthVertexContainer ()
	get full TEST vertex containers
const xAOD::VertexContainer *	testRecoVertexContainer ()
	TEST = Reco.
const xAOD::TruthVertexContainer *	refTruthVertexContainer ()
	get full REFERENCE vertex containers
const xAOD::VertexContainer *	refRecoVertexContainer ()
	REFERENCE = Reco.
const xAOD::TruthVertexContainer *	truthVertexContainer ()
	get truth/offline/trigger vertex containers (TEST or REFERENCE)
const xAOD::VertexContainer *	offlVertexContainer ()
const xAOD::VertexContainer *	trigVertexContainer ()
const std::vector< const xAOD::TruthVertex * > &	testTruthVertexVec (Stage stage=FULL)
	get TEST vertex vectors
const std::vector< const xAOD::Vertex * > &	testRecoVertexVec (Stage stage=FULL)
	TEST = Reco.
const std::vector< const xAOD::TruthVertex * > &	refTruthVertexVec (Stage stage=FULL)
	get REFERENCE vertex vectors
const std::vector< const xAOD::Vertex * > &	refRecoVertexVec (Stage stage=FULL)
	REFERENCE = Reco.
const std::vector< const xAOD::TruthVertex * > &	truthVertexVec (Stage stage=FULL)
	get truth/offline/trigger vertex vector (TEST or REFERENCE)
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
std::vector< size_t >	refVertexCounts ()
	REFERENCE.
ITrackMatchingLookup &	matches ()
	get track matching information
std::string	printMatchInfo ()
	print track matching information
bool	updateChainRois (const std::string &chainRoi, const std::string &roiStr)
	update chainRois map
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Types
typedef std::unordered_map< std::string, std::string >	mapChainRoi_t
	map of chainRoiNames for caching

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::string	m_anaTag
	TrackAnalysis properties.
SmartIF< ITrackAnalysisDefinitionSvc >	m_trkAnaDefSvc
bool	m_newChain
bool	m_newRoi
const xAOD::EventInfo *	m_eventInfo {nullptr}
	— Collections class variables — EventInfo, TruthEvent, and TruthPUEvent
const xAOD::TruthEventContainer *	m_truthEventContainer {nullptr}
const xAOD::TruthPileupEventContainer *	m_truthPUEventContainer {nullptr}
const xAOD::TruthParticleContainer *	m_truthPartContainer {nullptr}
	Full track collections.
const xAOD::TrackParticleContainer *	m_offlTrackContainer {nullptr}
const xAOD::TrackParticleContainer *	m_trigTrackContainer {nullptr}
std::vector< std::vector< const xAOD::TruthParticle * > >	m_truthPartVec {}
	vectors of track/truth particles at different stages of the selection/workflow
std::vector< std::vector< const xAOD::TrackParticle * > >	m_offlTrackVec {}
std::vector< std::vector< const xAOD::TrackParticle * > >	m_trigTrackVec {}
const xAOD::TruthVertexContainer *	m_truthVertexContainer {nullptr}
	Full vertex collections.
const xAOD::VertexContainer *	m_offlVertexContainer {nullptr}
const xAOD::VertexContainer *	m_trigVertexContainer {nullptr}
std::vector< std::vector< const xAOD::TruthVertex * > >	m_truthVertexVec {}
	vectors of reco/truth vertices at different stages of the selection/workflow
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
std::vector< const xAOD::TruthParticle * >	m_nullTruthVec {}
std::vector< const xAOD::TruthVertex * >	m_nullTruthVertVec {}
std::vector< const xAOD::Vertex * >	m_nullRecoVertVec {}
std::unique_ptr< ITrackMatchingLookup >	m_matches
	Lookup table for test-reference matching.
mapChainRoi_t	m_chainRois {}
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

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 328 of file TrackAnalysisCollections.h.

Member Enumeration Documentation

Counter

enum IDTPM::TrackAnalysisCollections::Counter : size_t

Enum for counting objects at various stages.

Enumerator
ALL
SELECTED
INROI
MATCHED
NCOUNTERS

Definition at line 57 of file TrackAnalysisCollections.h.

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

Stage

enum IDTPM::TrackAnalysisCollections::Stage : size_t

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.

: 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.

                            :
    AthMessaging( "TrackAnalysisCollections"+anaTag ),
    m_anaTag( anaTag ), m_newChain( true ), m_newRoi( true )
{
  m_truthPartVec.resize( NStages );
  m_offlTrackVec.resize( NStages );
  m_trigTrackVec.resize( NStages );

  m_truthVertexVec.resize( NStages );
  m_offlVertexVec.resize( NStages );
  m_trigVertexVec.resize( NStages );
}

~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 197 of file TrackAnalysisCollections.h.

{ 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.

{
  if( stage == FULL ) {
    m_truthPartVec[ FULL ].clear();
    m_offlTrackVec[ FULL ].clear();
    m_trigTrackVec[ FULL ].clear();
    m_truthVertexVec[ FULL ].clear();
    m_offlVertexVec[ FULL ].clear();
    m_trigVertexVec[ FULL ].clear();
  }
  if( stage == FULL or stage == FS ) {
    m_truthPartVec[ FS ].clear();
    m_offlTrackVec[ FS ].clear();
    m_trigTrackVec[ FS ].clear();
    m_truthVertexVec[ FS ].clear();
    m_offlVertexVec[ FS ].clear();
    m_trigVertexVec[ FS ].clear();
  }
  if( stage == FULL or stage == FS or stage == InRoI ) {
    m_truthPartVec[ InRoI ].clear();
    m_offlTrackVec[ InRoI ].clear();
    m_trigTrackVec[ InRoI ].clear();
    m_truthVertexVec[ InRoI ].clear();
    m_offlVertexVec[ InRoI ].clear();
    m_trigVertexVec[ InRoI ].clear();
  }
}

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.

{
  ATH_MSG_DEBUG( "Copying tracks in RoI" );

  m_offlTrackVec[ InRoI ].clear(); 
  m_offlTrackVec[ InRoI ].insert( 
    m_offlTrackVec[ InRoI ].begin(),
    m_offlTrackVec[ FS ].begin(),
    m_offlTrackVec[ FS ].end() );
  m_offlVertexVec[ InRoI ].clear(); 
  m_offlVertexVec[ InRoI ].insert( 
    m_offlVertexVec[ InRoI ].begin(),
    m_offlVertexVec[ FS ].begin(),
    m_offlVertexVec[ FS ].end() );

  m_truthPartVec[ InRoI ].clear(); 
  m_truthPartVec[ InRoI ].insert( 
    m_truthPartVec[ InRoI ].begin(),
    m_truthPartVec[ FS ].begin(),
    m_truthPartVec[ FS ].end() );
  m_truthVertexVec[ InRoI ].clear(); 
  m_truthVertexVec[ InRoI ].insert( 
    m_truthVertexVec[ InRoI ].begin(),
    m_truthVertexVec[ FS ].begin(),
    m_truthVertexVec[ FS ].end() );

  if( m_trkAnaDefSvc->useEFTrigger() ) {
    m_trigTrackVec[ InRoI ].clear(); 
    m_trigTrackVec[ InRoI ].insert( 
      m_trigTrackVec[ InRoI ].begin(),
      m_trigTrackVec[ FS ].begin(),
      m_trigTrackVec[ FS ].end() );
    m_trigVertexVec[ InRoI ].clear(); 
    m_trigVertexVec[ InRoI ].insert( 
      m_trigVertexVec[ InRoI ].begin(),
      m_trigVertexVec[ FS ].begin(),
      m_trigVertexVec[ FS ].end() );
  }

  ATH_MSG_DEBUG( "Tracks and vertices after in RoI copy: " << printInfo( InRoI ) );
}

empty()

bool IDTPM::TrackAnalysisCollections::empty

(

Stage

stage = FULL

)

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.

{
  bool isTrigEmpty  = m_trkAnaDefSvc->useTrigger() and not m_trkAnaDefSvc->useEFTrigger() and 
                      (stage != IDTPM::TrackAnalysisCollections::FS) ?
                      m_trigTrackVec[ stage ].empty() : false;
  bool isEFTrigEmpty  = m_trkAnaDefSvc->useEFTrigger() ?
                      m_trigTrackVec[ stage ].empty() : false;
  bool isOfflEmpty  = m_trkAnaDefSvc->useOffline() ?
                      m_offlTrackVec[ stage ].empty() : false;
  bool isTruthEmpty = m_trkAnaDefSvc->useTruth() ?
                      m_truthPartVec[ stage ].empty() : false;
 
  if( isTrigEmpty or isEFTrigEmpty or isOfflEmpty or isTruthEmpty ) return true;
 
  return false;
}

eventInfo()

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

inline

get event info

Definition at line 200 of file TrackAnalysisCollections.h.

{ 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.

{
  m_eventInfo = nullptr;
  m_truthEventContainer = nullptr;
  m_truthPUEventContainer = nullptr;

  SG::ReadHandle< xAOD::EventInfo > pie( eventInfoHandleKey );
  if( not pie.isValid() ) {
    ATH_MSG_WARNING( "Shouldn't happen. EventInfo is buggy" );
  } else m_eventInfo = pie.ptr();
 
  if( not m_trkAnaDefSvc->useTruth() ) return StatusCode::SUCCESS;

  SG::ReadHandle< xAOD::TruthEventContainer > pTruthEventCont( truthEventHandleKey );
  if( not pTruthEventCont.isValid() ) {
    ATH_MSG_WARNING( "Non valid truth event collection: " << truthEventHandleKey.key() );
  }
  else m_truthEventContainer = pTruthEventCont.ptr();

  if( m_trkAnaDefSvc->hasFullPileupTruth() ) {
    SG::ReadHandle< xAOD::TruthPileupEventContainer > pTruthPUEventCont( truthPUEventHandleKey );
    if( not pTruthPUEventCont.isValid() ) {
      ATH_MSG_WARNING( "Non valid truth pile up event collection: " << truthPUEventHandleKey.key() );
    }
    else m_truthPUEventContainer = pTruthPUEventCont.ptr();
  }
 
  return StatusCode::SUCCESS;
}

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.

{
  if( m_trkAnaDefSvc->useOffline() ) {
    ATH_MSG_DEBUG( "Loading collection: " << handleKey.key() );
 
    SG::ReadHandle< xAOD::TrackParticleContainer > pColl( handleKey );
 
    if( not pColl.isValid() ) {
      ATH_MSG_ERROR( "Non valid offline tracks collection: " << handleKey.key() );
      return StatusCode::FAILURE;
    }

    m_offlTrackContainer = pColl.ptr();

    m_offlTrackVec[ FULL ].clear(); 
    m_offlTrackVec[ FULL ].insert( 
      m_offlTrackVec[ FULL ].begin(),
      pColl->begin(), pColl->end() );
  } else {
    m_offlTrackContainer = nullptr;
    m_offlTrackVec[ FULL ].clear();
  }
 
  return StatusCode::SUCCESS; 
}

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.

{
  if( m_trkAnaDefSvc->useOffline() ) {
    m_offlTrackVec[ stage ].clear();
    m_offlTrackVec[ stage ].insert(
      m_offlTrackVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG( "No Offline TrackParticle vector" );
  return StatusCode::SUCCESS;
}

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.

{ 
  m_offlVertexContainer = nullptr;
  m_offlVertexVec[ FULL ].clear();

  if( not m_trkAnaDefSvc->useOffline() or
      handleKey.key().empty() ) return StatusCode::SUCCESS;
 
  ATH_MSG_DEBUG( "Loading collection: " << handleKey.key() );
  SG::ReadHandle< xAOD::VertexContainer > pColl( handleKey );
  if( not pColl.isValid() ) {
    ATH_MSG_ERROR( "Non valid offline vertex collection: " << handleKey.key() );
    return StatusCode::FAILURE;
  }

  m_offlVertexContainer = pColl.ptr();

  m_offlVertexVec[ FULL ].insert( 
    m_offlVertexVec[ FULL ].begin(),
    pColl->begin(), pColl->end() );
 
  return StatusCode::SUCCESS; 
}

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.

{
  if( m_trkAnaDefSvc->useOffline() ) {
    m_offlVertexVec[ stage ].clear();
    m_offlVertexVec[ stage ].insert(
      m_offlVertexVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG( "No Offline vertex vector" );
  return StatusCode::SUCCESS;
}

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.

{
  if( m_trkAnaDefSvc->isReferenceOffline() ) {
    m_offlVertexVec[ stage ].clear();
    m_offlVertexVec[ stage ].insert(
      m_offlVertexVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS;
 
  } else if( m_trkAnaDefSvc->isReferenceTrigger() ) {
    m_trigVertexVec[ stage ].clear();
    m_trigVertexVec[ stage ].insert(
      m_trigVertexVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG( "No REFERENCE Reco vertex vector" );
  return StatusCode::SUCCESS; 
}

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.

{
  if( m_trkAnaDefSvc->isReferenceOffline() ) {
    m_offlTrackVec[ stage ].clear(); 
    m_offlTrackVec[ stage ].insert( 
      m_offlTrackVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS; 
  }
 
  if( m_trkAnaDefSvc->isReferenceTrigger() ) {
    m_trigTrackVec[ stage ].clear(); 
    m_trigTrackVec[ stage ].insert( 
      m_trigTrackVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS; 
  }
 
  ATH_MSG_DEBUG( "No REFERENCE TrackParticle vector" );
  return StatusCode::SUCCESS; 
}

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.

{
  if( m_trkAnaDefSvc->isReferenceTruth() ) {
    m_truthPartVec[ stage ].clear(); 
    m_truthPartVec[ stage ].insert( 
      m_truthPartVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS; 
  }
 
  ATH_MSG_DEBUG( "No REFERENCE TruthParticle vector" );
  return StatusCode::SUCCESS; 
}

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.

{
  if( m_trkAnaDefSvc->isReferenceTruth() ) {
    m_truthVertexVec[ stage ].clear();
    m_truthVertexVec[ stage ].insert(
      m_truthVertexVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG( "No REFERENCE Truth vertex vector" );
  return StatusCode::SUCCESS;
}

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.

{
  if( m_trkAnaDefSvc->isTestOffline() ) {
    m_offlVertexVec[ stage ].clear();
    m_offlVertexVec[ stage ].insert(
      m_offlVertexVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS;
 
  } else if( m_trkAnaDefSvc->isTestTrigger() ) {
    m_trigVertexVec[ stage ].clear();
    m_trigVertexVec[ stage ].insert(
      m_trigVertexVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG( "No TEST Reco vertex vector");
  return StatusCode::SUCCESS;
}

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.

{
  if( m_trkAnaDefSvc->isTestOffline() ) {
    m_offlTrackVec[ stage ].clear(); 
    m_offlTrackVec[ stage ].insert( 
      m_offlTrackVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS; 
  }
 
  if( m_trkAnaDefSvc->isTestTrigger() ) {
    m_trigTrackVec[ stage ].clear(); 
    m_trigTrackVec[ stage ].insert( 
      m_trigTrackVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS; 
  }
 
  ATH_MSG_DEBUG( "No TEST TrackParticle vector");
  return StatusCode::SUCCESS; 
}

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.

{
  if( m_trkAnaDefSvc->isTestTruth() ) {
    m_truthPartVec[ stage ].clear(); 
    m_truthPartVec[ stage ].insert( 
      m_truthPartVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS; 
  }
 
  ATH_MSG_DEBUG( "No TEST TruthParticle vector" );
  return StatusCode::SUCCESS; 
}

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.

{
  if( m_trkAnaDefSvc->isTestTruth() ) {
    m_truthVertexVec[ stage ].clear();
    m_truthVertexVec[ stage ].insert(
      m_truthVertexVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG( "No TEST Truth vertex vector" );
  return StatusCode::SUCCESS;
}

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.

{
  if( m_trkAnaDefSvc->useTrigger()) {
    ATH_MSG_DEBUG( "Loading collection: " << handleKey.key() );
 
    SG::ReadHandle< xAOD::TrackParticleContainer > pColl( handleKey );
 
    if( not pColl.isValid() ) {
      ATH_MSG_ERROR( "Non valid trigger tracks collection: " << handleKey.key() );
      return StatusCode::FAILURE;
    }

    m_trigTrackContainer = pColl.ptr();

    m_trigTrackVec[ FULL ].clear(); 
    m_trigTrackVec[ FULL ].insert( 
      m_trigTrackVec[ FULL ].begin(),
      pColl->begin(), pColl->end() );
  } else {
    m_trigTrackContainer = nullptr;
    m_trigTrackVec[ FULL ].clear();
  }
 
  return StatusCode::SUCCESS; 
}

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.

{
  if( m_trkAnaDefSvc->useTrigger() or  m_trkAnaDefSvc->useEFTrigger() ) {
    m_trigTrackVec[ stage ].clear();
    m_trigTrackVec[ stage ].insert(
      m_trigTrackVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG( "No Trigger TrackParticle vector" );
  return StatusCode::SUCCESS;
}

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.

{ 
  m_trigVertexContainer = nullptr;
  m_trigVertexVec[ FULL ].clear();

  if( not m_trkAnaDefSvc->useTrigger() or
      handleKey.key().empty() ) return StatusCode::SUCCESS;
 
  ATH_MSG_DEBUG( "Loading collection: " << handleKey.key() );
  SG::ReadHandle< xAOD::VertexContainer > pColl( handleKey );
  if( not pColl.isValid() ) {
    ATH_MSG_ERROR( "Non valid trigger vertex collection: " << handleKey.key() );
    return StatusCode::FAILURE;
  }

  m_trigVertexContainer = pColl.ptr();

  m_trigVertexVec[ FULL ].insert( 
    m_trigVertexVec[ FULL ].begin(),
    pColl->begin(), pColl->end() );
 
  return StatusCode::SUCCESS; 
}

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.

{
  if( m_trkAnaDefSvc->useTrigger() or m_trkAnaDefSvc->useEFTrigger() ) {
    m_trigVertexVec[ stage ].clear();
    m_trigVertexVec[ stage ].insert(
      m_trigVertexVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG( "No Trigger vertex vector" );
  return StatusCode::SUCCESS;
}

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.

{
  if( m_trkAnaDefSvc->useTruth() ) {
    ATH_MSG_DEBUG( "Loading collection: " << truthPartHandleKey.key() );
    SG::ReadHandle< xAOD::TruthParticleContainer > pTruthColl( truthPartHandleKey );
    if( not pTruthColl.isValid() ) {
      ATH_MSG_ERROR( "Non valid truth particles collection: " << truthPartHandleKey.key() );
      return StatusCode::FAILURE;
    }

    m_truthPartContainer = pTruthColl.ptr();

    m_truthPartVec[ FULL ].clear(); // clear to initialize it

    if( m_trkAnaDefSvc->pileupSwitch() == "All" ) {
      m_truthPartVec[ FULL ].insert(
        m_truthPartVec[ FULL ].begin(), pTruthColl->begin(), pTruthColl->end() );

    } else if( m_trkAnaDefSvc->pileupSwitch() == "HardScatter" ) {
      if( m_truthEventContainer ) {
        const xAOD::TruthEvent* event = m_truthEventContainer->at(0);
        const auto& links = event->truthParticleLinks();
        for( const auto& link : links ) {
          if( link.isValid() ) m_truthPartVec[ FULL ].push_back( *link );
        }
      }

    } else if( m_trkAnaDefSvc->pileupSwitch() == "PileUp" ) {
      if( m_truthPUEventContainer ) {
        // loop over all pile up events
        for( size_t ipu=0; ipu < m_truthPUEventContainer->size(); ipu++ ) {
          const xAOD::TruthPileupEvent* eventPU = m_truthPUEventContainer->at( ipu );
          const auto& links = eventPU->truthParticleLinks();
          for( const auto& link : links ) {
            if( link.isValid() ) m_truthPartVec[ FULL ].push_back( *link );
          }
        }
      }
 
    } else {
      ATH_MSG_ERROR( "Invalid pileupSwitch: " << m_trkAnaDefSvc->pileupSwitch() );
      return StatusCode::FAILURE;
    }
  } else {
    m_truthPartContainer = nullptr;
    m_truthPartVec[ FULL ].clear();
  }
 
  return StatusCode::SUCCESS; 
}

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.

{
  if( m_trkAnaDefSvc->useTruth() ) {
    m_truthPartVec[ stage ].clear();
    m_truthPartVec[ stage ].insert(
      m_truthPartVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG( "No TruthParticle vector" );
  return StatusCode::SUCCESS;
}

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.

{
  m_truthVertexContainer = nullptr;
  m_truthVertexVec[ FULL ].clear();

  if( not m_trkAnaDefSvc->useTruth() or
      truthVertexHandleKey.key().empty() ) return StatusCode::SUCCESS;
 
  ATH_MSG_DEBUG( "Loading collection: " << truthVertexHandleKey.key() );
  SG::ReadHandle< xAOD::TruthVertexContainer > pTruthVertColl( truthVertexHandleKey );
  if( not pTruthVertColl.isValid() ) {
    ATH_MSG_ERROR( "Non valid truth vertex collection: " << truthVertexHandleKey.key() );
    return StatusCode::FAILURE;
  }

  m_truthVertexContainer = pTruthVertColl.ptr();

  m_truthVertexVec[ FULL ].insert(
    m_truthVertexVec[ FULL ].begin(),
    pTruthVertColl->begin(), pTruthVertColl->end() );

 
  return StatusCode::SUCCESS; 
}

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.

{
  if( m_trkAnaDefSvc->useTruth() ) {
    m_truthVertexVec[ stage ].clear();
    m_truthVertexVec[ stage ].insert(
      m_truthVertexVec[ stage ].begin(),
      vec.begin(), vec.end() );
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG( "No Truth vertex vector" );
  return StatusCode::SUCCESS;
}

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.

{
  m_trkAnaDefSvc = Gaudi::svcLocator()->service( "TrkAnaDefSvc"+m_anaTag );
  ATH_CHECK( m_trkAnaDefSvc.isValid() );

  if( m_trkAnaDefSvc->isTestTruth() ) {
    m_matches = std::make_unique< TrackMatchingLookup_truthTrk >( m_anaTag );
  }
  else if( m_trkAnaDefSvc->isReferenceTruth() ) {
    m_matches = std::make_unique< TrackMatchingLookup_trkTruth >( m_anaTag );
  }
  else {
    m_matches = std::make_unique< TrackMatchingLookup_trk >( m_anaTag );
  }
 
  return StatusCode::SUCCESS;
}

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.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

isNewChain()

bool IDTPM::TrackAnalysisCollections::isNewChain ( )

inline

check if this is a new chain

Definition at line 168 of file TrackAnalysisCollections.h.

{ return m_newChain; }

isNewEvent()

bool IDTPM::TrackAnalysisCollections::isNewEvent ( )

inline

— Utility methods —

check if this is a new event only true id BOTH m_newChain m_newRoi are true

Definition at line 165 of file TrackAnalysisCollections.h.

{ return ( m_newChain && m_newRoi ); }

isNewRoI()

bool IDTPM::TrackAnalysisCollections::isNewRoI ( )

inline

check if this is a new RoI

Definition at line 174 of file TrackAnalysisCollections.h.

{ return m_newRoi; }

matches()

ITrackMatchingLookup & IDTPM::TrackAnalysisCollections::matches ( )

inline

get track matching information

Definition at line 277 of file TrackAnalysisCollections.h.

{ 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 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

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 178 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

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

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

newChain()

void IDTPM::TrackAnalysisCollections::newChain ( )

inline

update before running on new chain

Definition at line 171 of file TrackAnalysisCollections.h.

{ m_newChain = false; m_newRoi = true; }

newRoI()

void IDTPM::TrackAnalysisCollections::newRoI ( )

inline

update before running on new RoI

Definition at line 177 of file TrackAnalysisCollections.h.

{ m_newRoi = false; }

offlTrackContainer()

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

inline

Definition at line 215 of file TrackAnalysisCollections.h.

                                                           {
      return m_offlTrackContainer; }

offlTrackVec()

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

inline

Definition at line 231 of file TrackAnalysisCollections.h.

                                                                                    {
      return m_offlTrackVec[ stage ]; }

offlVertexContainer()

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

inline

Definition at line 251 of file TrackAnalysisCollections.h.

                                                     {
      return m_offlVertexContainer; }

offlVertexVec()

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

inline

Definition at line 267 of file TrackAnalysisCollections.h.

                                                                              {
      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.

{
  std::stringstream ss;
  ss << "\n==========================================" << std::endl;
 
  size_t it(0);
  for( const xAOD::TrackParticle* thisOfflineTrack : m_offlTrackVec[ stage ] ) {
    ss << "Offline track" 
       << " : pt = "  << pT( *thisOfflineTrack )
       << " : eta = " << eta( *thisOfflineTrack )
       << " : phi = " << phi( *thisOfflineTrack )
       << std::endl;
    if( it > 20 ) { ss << "et al...." << std::endl; break; }
    it++;
  }
 
  if( not m_offlTrackVec[ stage ].empty() )
    ss << "==========================================" << std::endl;
 
  it = 0;
  for( const xAOD::TruthParticle* thisTruthParticle : m_truthPartVec[ stage ] ) {
    ss << "Truth particle"
       << " : pt = "  << pT( *thisTruthParticle )
       << " : eta = " << eta( *thisTruthParticle )
       << " : phi = " << phi( *thisTruthParticle )
       << std::endl;
    if( it > 20 ) { ss << "et al...." << std::endl; break; }
    it++;
  }
 
  if( not m_truthPartVec[ stage ].empty() )
      ss << "==========================================" << std::endl;
 
  it = 0;
  for( const xAOD::TrackParticle* thisTriggerTrack : m_trigTrackVec[ stage ] ) {
    ss << "Trigger track"
       << " : pt = "  << pT( *thisTriggerTrack )
       << " : eta = " << eta( *thisTriggerTrack )
       << " : phi = " << phi( *thisTriggerTrack )
       << std::endl;
    if( it > 20 ) { ss << "et al...." << std::endl; break; }
    it++;
  }
 
  if( not m_trigTrackVec[ stage ].empty() )
    ss << "==========================================" << std::endl;

  if( printVertex ) ss << "Vertices: " << printVertexInfo( stage );
 
  return ss.str();
}

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.

{
  if( m_trkAnaDefSvc->isTestTruth() ) {
    return m_matches->printInfo( testTruthVec( InRoI ), refTrackVec( InRoI ) );
  }
  if( m_trkAnaDefSvc->isReferenceTruth() ) {
    return m_matches->printInfo( testTrackVec( InRoI ), refTruthVec( InRoI ) );
  }
  return m_matches->printInfo( testTrackVec( InRoI ), refTrackVec( InRoI ) );
}

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.

{
  std::stringstream ss;
  ss << "\n==========================================" << std::endl;
 
  size_t it(0);
  for( const xAOD::Vertex* thisOfflineVertex : m_offlVertexVec[ stage ] ) {
    ss << "Offline vertex"
       << " : z = "  << posZ( *thisOfflineVertex )
       << std::endl;
    if( it > 20 ) { ss << "et al...." << std::endl; break; }
    it++;
  }
 
  if( not m_offlVertexVec[ stage ].empty() )
    ss << "==========================================" << std::endl;
 
  it = 0;
  for( const xAOD::TruthVertex* thisTruthVertex : m_truthVertexVec[ stage ] ) {
    ss << "Truth vertex"
       << " : z = "  << posZ( *thisTruthVertex )
       << std::endl;
    if( it > 20 ) { ss << "et al...." << std::endl; break; }
    it++;
  }
 
  if( not m_truthVertexVec[ stage ].empty() )
      ss << "==========================================" << std::endl;
 
  it = 0;
  for( const xAOD::Vertex* thisTriggerVertex : m_trigVertexVec[ stage ] ) {
    ss << "Trigger vertex"
       << " : z = "  << posZ( *thisTriggerVertex )
       << std::endl;
    if( it > 20 ) { ss << "et al...." << std::endl; break; }
    it++;
  }
 
  if( not m_trigVertexVec[ stage ].empty() )
    ss << "==========================================" << std::endl;
 
  return ss.str();
}

refRecoVertexContainer()

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

(

)

REFERENCE = Reco.

Definition at line 915 of file TrackAnalysisCollections.cxx.

{
  if( m_trkAnaDefSvc->isReferenceOffline() ) {
    return m_offlVertexContainer;
  }
    
  if( m_trkAnaDefSvc->isReferenceTrigger() ) {
    return m_trigVertexContainer;
  }
 
  return nullptr;
}

refRecoVertexVec()

const std::vector< const xAOD::Vertex * > & IDTPM::TrackAnalysisCollections::refRecoVertexVec

(

Stage

stage = FULL

)

REFERENCE = Reco.

Definition at line 976 of file TrackAnalysisCollections.cxx.

{
  if( m_trkAnaDefSvc->isReferenceOffline() ) {
    return m_offlVertexVec[ stage ];
  }
 
  if( m_trkAnaDefSvc->isReferenceTrigger() ) {
    return m_trigVertexVec[ stage ];
  }
 
  ATH_MSG_DEBUG( "No Test reco vertex vector found" );
  return m_nullRecoVertVec;
}

refTrackContainer()

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

(

)

REFERENCE = Track.

Definition at line 758 of file TrackAnalysisCollections.cxx.

{
  if( m_trkAnaDefSvc->isReferenceOffline() ) {
    return m_offlTrackContainer;
  }
    
  if( m_trkAnaDefSvc->isReferenceTrigger() ) {
    return m_trigTrackContainer;
  }
 
  return nullptr;
}

refTrackCounts()

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

(

)

REFERENCE.

Definition at line 857 of file TrackAnalysisCollections.cxx.

{
  std::vector< size_t > counts( NCOUNTERS, 0 );
  counts[ ALL ] = m_trkAnaDefSvc->isReferenceTruth() ?
      refTruthVec( FULL ).size() :
      refTrackVec( FULL ).size();
  counts[ SELECTED ] = m_trkAnaDefSvc->isReferenceTruth() ?
      refTruthVec( FS ).size() :
      refTrackVec( FS ).size();
  counts[ INROI ] = m_trkAnaDefSvc->isReferenceTruth() ?
      refTruthVec( InRoI ).size() :
      refTrackVec( InRoI ).size();
  counts[ MATCHED ] = matches().getNmatches( true );
  return counts;
}

refTrackVec()

const std::vector< const xAOD::TrackParticle * > & IDTPM::TrackAnalysisCollections::refTrackVec

(

Stage

stage = FULL

)

TEST = Track.

Definition at line 819 of file TrackAnalysisCollections.cxx.

{
  if( m_trkAnaDefSvc->isReferenceOffline() ) {
    return m_offlTrackVec[ stage ];
  }
 
  if( m_trkAnaDefSvc->isReferenceTrigger() ) {
    return m_trigTrackVec[ stage ];
  }
 
  ATH_MSG_DEBUG( "No Test track vector found" );
  return m_nullTrackVec;
}

refTruthContainer()

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

(

)

get full REFERENCE track containers

REFERENCE = Truth.

Definition at line 747 of file TrackAnalysisCollections.cxx.

{
  if( m_trkAnaDefSvc->isReferenceTruth() ) {
    return m_truthPartContainer;
  }
 
  return nullptr;
}

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.

{
  if( m_trkAnaDefSvc->isReferenceTruth() ) {
    return m_truthPartVec[ stage ];
  }
 
  ATH_MSG_DEBUG( "No Reference truth vector found" );
  return m_nullTruthVec;
}

refTruthVertexContainer()

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

(

)

get full REFERENCE vertex containers

REFERENCE = Truth.

Definition at line 904 of file TrackAnalysisCollections.cxx.

{
  if( m_trkAnaDefSvc->isReferenceTruth() ) {
    return m_truthVertexContainer;
  }
 
  return nullptr;
}

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.

{
  if( m_trkAnaDefSvc->isReferenceTruth() ) {
    return m_truthVertexVec[ stage ];
  }
 
  ATH_MSG_DEBUG( "No Reference truth vertex vector found" );
  return m_nullTruthVertVec;
}

refVertexCounts()

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

(

)

REFERENCE.

TODO: add matched vertex count

Definition at line 1014 of file TrackAnalysisCollections.cxx.

{
  std::vector< size_t > counts( NCOUNTERS, 0 );
  counts[ ALL ] = m_trkAnaDefSvc->isReferenceTruth() ?
      refTruthVertexVec( FULL ).size() :
      refRecoVertexVec( FULL ).size();
  counts[ SELECTED ] = m_trkAnaDefSvc->isReferenceTruth() ?
      refTruthVertexVec( FS ).size() :
      refRecoVertexVec( FS ).size();
  counts[ INROI ] = m_trkAnaDefSvc->isReferenceTruth() ?
      refTruthVertexVec( InRoI ).size() :
      refRecoVertexVec( InRoI ).size();
  counts[ MATCHED ] = 0; 
  return counts;
}

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.

{
  m_lvl = lvl;
}

testRecoVertexContainer()

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

(

)

TEST = Reco.

Definition at line 889 of file TrackAnalysisCollections.cxx.

{
  if( m_trkAnaDefSvc->isTestOffline() ) {
    return m_offlVertexContainer;
  }
    
  if( m_trkAnaDefSvc->isTestTrigger() ) {
    return m_trigVertexContainer;
  }
 
  return nullptr;
}

testRecoVertexVec()

const std::vector< const xAOD::Vertex * > & IDTPM::TrackAnalysisCollections::testRecoVertexVec

(

Stage

stage = FULL

)

TEST = Reco.

Definition at line 946 of file TrackAnalysisCollections.cxx.

{
  if( m_trkAnaDefSvc->isTestOffline() ) {
    return m_offlVertexVec[ stage ];
  }
 
  if( m_trkAnaDefSvc->isTestTrigger() ) {
    return m_trigVertexVec[ stage ];
  }
 
  ATH_MSG_DEBUG( "No Test reco vertex vector found" );
  return m_nullRecoVertVec;
}

testTrackContainer()

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

(

)

TEST = Track.

Definition at line 732 of file TrackAnalysisCollections.cxx.

{
  if( m_trkAnaDefSvc->isTestOffline() ) {
    return m_offlTrackContainer;
  }
    
  if( m_trkAnaDefSvc->isTestTrigger() ) {
    return m_trigTrackContainer;
  }
 
  return nullptr;
}

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.

{
  std::vector< size_t > counts( NCOUNTERS, 0 );
  counts[ ALL ] = m_trkAnaDefSvc->isTestTruth() ?
      testTruthVec( FULL ).size() :
      testTrackVec( FULL ).size();
  counts[ SELECTED ] = m_trkAnaDefSvc->isTestTruth() ?
      testTruthVec( FS ).size() :
      testTrackVec( FS ).size();
  counts[ INROI ] = m_trkAnaDefSvc->isTestTruth() ?
      testTruthVec( InRoI ).size() :
      testTrackVec( InRoI ).size();
  counts[ MATCHED ] = matches().getNmatches();
  return counts;
}

testTrackVec()

const std::vector< const xAOD::TrackParticle * > & IDTPM::TrackAnalysisCollections::testTrackVec

(

Stage

stage = FULL

)

TEST = Track.

Definition at line 789 of file TrackAnalysisCollections.cxx.

{
  if( m_trkAnaDefSvc->isTestOffline() ) {
    return m_offlTrackVec[ stage ];
  }
 
  if( m_trkAnaDefSvc->isTestTrigger() ) {
    return m_trigTrackVec[ stage ];
  }
 
  ATH_MSG_DEBUG( "No Test track vector found" );
  return m_nullTrackVec;
}

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.

{
  if( m_trkAnaDefSvc->isTestTruth() ) {
    return m_truthPartContainer;
  }
 
  return nullptr;
}

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.

{
  if( m_trkAnaDefSvc->isTestTruth() ) {
    return m_truthPartVec[ stage ];
  }
 
  ATH_MSG_DEBUG( "No Test truth vector found" );
  return m_nullTruthVec;
}

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.

{
  if( m_trkAnaDefSvc->isTestTruth() ) {
    return m_truthVertexContainer;
  }
 
  return nullptr;
}

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.

{
  if( m_trkAnaDefSvc->isTestTruth() ) {
    return m_truthVertexVec[ stage ];
  }
 
  ATH_MSG_DEBUG( "No Test truth vertex vector found" );
  return m_nullTruthVertVec;
}

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.

{
  std::vector< size_t > counts( NCOUNTERS, 0 );
  counts[ ALL ] = m_trkAnaDefSvc->isTestTruth() ?
      testTruthVertexVec( FULL ).size() :
      testRecoVertexVec( FULL ).size();
  counts[ SELECTED ] = m_trkAnaDefSvc->isTestTruth() ?
      testTruthVertexVec( FS ).size() :
      testRecoVertexVec( FS ).size();
  counts[ INROI ] = m_trkAnaDefSvc->isTestTruth() ?
      testTruthVertexVec( InRoI ).size() :
      testRecoVertexVec( InRoI ).size();
  counts[ MATCHED ] = 0; 
  return counts;
}

trigTrackContainer()

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

inline

Definition at line 217 of file TrackAnalysisCollections.h.

                                                           {
      return m_trigTrackContainer; }

trigTrackVec()

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

inline

Definition at line 233 of file TrackAnalysisCollections.h.

                                                                                    {
      return m_trigTrackVec[ stage ]; }

trigVertexContainer()

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

inline

Definition at line 253 of file TrackAnalysisCollections.h.

                                                     {
      return m_trigVertexContainer; }

trigVertexVec()

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

inline

Definition at line 269 of file TrackAnalysisCollections.h.

                                                                              {
      return m_trigVertexVec[ stage ]; }

truthEventContainer()

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

inline

Definition at line 201 of file TrackAnalysisCollections.h.

{ return m_truthEventContainer; }

truthPartContainer()

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

inline

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

Definition at line 213 of file TrackAnalysisCollections.h.

                                                           {
      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 229 of file TrackAnalysisCollections.h.

                                                                                    {
      return m_truthPartVec[ stage ]; }

truthPileupEventContainer()

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

inline

Definition at line 202 of file TrackAnalysisCollections.h.

{ return m_truthPUEventContainer; }

truthVertexContainer()

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

inline

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

Definition at line 249 of file TrackAnalysisCollections.h.

                                                           {
      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 265 of file TrackAnalysisCollections.h.

                                                                                    {
      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.

{
  ATH_MSG_DEBUG( "Updating TrackAnalysisCollection with ChainRoiName: " << chainRoi );
 
  std::pair< mapChainRoi_t::iterator, bool > result =
      m_chainRois.insert( mapChainRoi_t::value_type( chainRoi, roiStr ) );
 
  if( not result.second ) {
    ATH_MSG_WARNING( "ChainRoiName has already been cached. No update." );
    return false;
  }

  m_matches->clear();
  m_matches->chainRoiName( chainRoi );
 
  return result.second;
}

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 288 of file TrackAnalysisCollections.h.

m_chainRois

mapChainRoi_t IDTPM::TrackAnalysisCollections::m_chainRois {}

private

Definition at line 329 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 294 of file TrackAnalysisCollections.h.

{nullptr};

m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

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

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_matches

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

private

Lookup table for test-reference matching.

Definition at line 325 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_newChain

bool IDTPM::TrackAnalysisCollections::m_newChain

private

Definition at line 290 of file TrackAnalysisCollections.h.

m_newRoi

bool IDTPM::TrackAnalysisCollections::m_newRoi

private

Definition at line 290 of file TrackAnalysisCollections.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 322 of file TrackAnalysisCollections.h.

{};

m_nullTrackVec

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

private

null vectors

Definition at line 319 of file TrackAnalysisCollections.h.

{};

m_nullTruthVec

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

private

Definition at line 320 of file TrackAnalysisCollections.h.

{};

m_nullTruthVertVec

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

private

Definition at line 321 of file TrackAnalysisCollections.h.

{};

m_offlTrackContainer

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

private

Definition at line 300 of file TrackAnalysisCollections.h.

{nullptr};

m_offlTrackVec

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

private

Definition at line 305 of file TrackAnalysisCollections.h.

{};

m_offlVertexContainer

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

private

Definition at line 310 of file TrackAnalysisCollections.h.

{nullptr};

m_offlVertexVec

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

private

Definition at line 315 of file TrackAnalysisCollections.h.

{};

m_trigTrackContainer

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

private

Definition at line 301 of file TrackAnalysisCollections.h.

{nullptr};

m_trigTrackVec

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

private

Definition at line 306 of file TrackAnalysisCollections.h.

{};

m_trigVertexContainer

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

private

Definition at line 311 of file TrackAnalysisCollections.h.

{nullptr};

m_trigVertexVec

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

private

Definition at line 316 of file TrackAnalysisCollections.h.

{};

m_trkAnaDefSvc

SmartIF< ITrackAnalysisDefinitionSvc > IDTPM::TrackAnalysisCollections::m_trkAnaDefSvc

private

Definition at line 289 of file TrackAnalysisCollections.h.

m_truthEventContainer

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

private

Definition at line 295 of file TrackAnalysisCollections.h.

{nullptr};

m_truthPartContainer

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

private

Full track collections.

Definition at line 299 of file TrackAnalysisCollections.h.

{nullptr};

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 304 of file TrackAnalysisCollections.h.

{};

m_truthPUEventContainer

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

private

Definition at line 296 of file TrackAnalysisCollections.h.

{nullptr};

m_truthVertexContainer

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

private

Full vertex collections.

Definition at line 309 of file TrackAnalysisCollections.h.

{nullptr};

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 314 of file TrackAnalysisCollections.h.

{};

---

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

• TrackAnalysisCollections.h
• TrackAnalysisCollections.cxx