IDTPM2::TrackAnalysisStore Class Reference

#include <TrackAnalysisStore.h>

Inheritance diagram for IDTPM2::TrackAnalysisStore:

Public Types
using	beam_key_t = SG::ReadDecorHandleKeyArray<xAOD::EventInfo>
using	keys_t = SG::ReadDecorHandleKeyArray<xAOD::EventInfo>

Public Member Functions
	TrackAnalysisStore (const std::string &anaTag, const EventContext &context)
	Constructor.
	TrackAnalysisStore (const std::string &anaTag, const ToolHandle< Trig::TrigDecisionTool > *tdt, const EventContext &context)
	~TrackAnalysisStore ()=default
	Destructor.
TrackAnalysisStore &	operator= (const TrackAnalysisStore &)=delete
	= operator
StatusCode	initialize ()
	initialize this should not actually be needed - we should be creating a new instance whenever this is required, so all the "initialisation" could be moved to the constructor
const std::string &	anaTag ()
	— Setter methods —
const std::vector< ParentView > &	parents () const
const TIDA::Associator< const TrackView > *	matcher () const
	test and reference tracks ...
void	set_matcher (const TIDA::Associator< const TrackView > *m)
const std::vector< const TrackView * > &	reference_tracks () const
const std::vector< const TrackView * > &	test_tracks () const
std::vector< const TrackView * > &	reference_tracks ()
std::vector< const TrackView * > &	test_tracks ()
void	reference_tracks (const std::vector< const TrackView * > &v)
	these are a bit dodgy - ie we pass in a vector<const TrackView*> so we want to construct a reference veiw_store_t ?
void	test_tracks (const std::vector< const TrackView * > &v)
const std::vector< const VertexView * > &	refvertices () const
	vertex accessors
const std::vector< const VertexView * > &	testvertices () const
std::vector< const VertexView * > &	refvertices ()
std::vector< const VertexView * > &	testvertices ()
void	set_vertex_matcher (const TIDA::Associator< const VertexView > *m)
const TIDA::Associator< const VertexView > *	vertex_matcher () const
const xAOD::EventInfo *	eventInfo () const
	get event info
const xAOD::TruthEventContainer *	truthEventContainer () const
const xAOD::TruthPileupEventContainer *	truthPileupEventContainer () const
int	roiIndex () const
	odds n ends ...
void	roiIndex (int i)
template<typename T>
StatusCode	fillInfo (const T *&t, const std::string &key)
	filling methods to fetch collections ...
template<typename Collection>
std::pair< typename Collection::const_iterator, typename Collection::const_iterator >	getPair (const ElementLink< TrigRoiDescriptorCollection > &roi_link, const std::string &key)
StatusCode	fillEventInfo (const std::string &key)
void	fillViewRef (const std::string &key)
	track fillers ...
void	fillViewTest (const std::string &key)
void	fillViewTest (const std::string &key, const ElementLink< TrigRoiDescriptorCollection > &roi_link)
	Roi filler ...
void	fillVertexViewRef (const std::string &key)
	vertex fillers ...
void	fillVertexViewTest (const std::string &key)
void	fillVertexViewTest (const std::string &key, const ElementLink< TrigRoiDescriptorCollection > &roi_link)
void	fillEventInfo (const xAOD::EventInfo *e)
bool	hasTagNProbe () const
void	addTagNProbe (const TagNProbe *t)
const TagNProbe *	tagNProbe () const
void	setBeamKeys (const beam_key_t *k)
void	decoratePerigee ()
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.

Protected Types
using	view_store_t = std::vector<std::unique_ptr<TrackView>>
	polymoprphic master store types
using	vtx_store_t = std::vector<std::unique_ptr<VertexView>>

Protected Member Functions
void	fillView (const std::string &key, view_store_t &trackView)
	track fillers ...
void	fillView (const std::string &key, const ElementLink< TrigRoiDescriptorCollection > &roi_link, view_store_t &trackView)
	must be a better way that to have a duplicated function, but only one I can think of is to pass in the TrackView, and both TrackParticle and TruthParticle contaiuners
void	fillView (const std::string &key, vtx_store_t &vertexView)
	track vertices ...
void	fillView (const std::string &key, const ElementLink< TrigRoiDescriptorCollection > &roi_link, vtx_store_t &vertexView)
	this and the roi based TrackView fillView should really be done with a single template
template<typename T, typename U, typename V = U>
bool	fillView_internal (const std::string &key, std::vector< std::unique_ptr< U > > &outView)
	templates for athena type track and vertex retrieval ...
template<typename T>
bool	fillView_internal (const std::string &key, std::vector< ParentView > &parentView)
	the specialisation for the ParentView, because we want to retrieve the parent, and then get the child tracks to add to the tracks for the analysis, and then add the lookup back to the parent on those tracks
template<typename T>
StatusCode	fill (T const *&container, const std::string &key)
	have the eventInfo already ?? then just pass in the pointer
template<typename T>
StatusCode	fillRoi (std::pair< typename T::const_iterator, typename T::const_iterator > &itrpair, const std::string &key, const ElementLink< TrigRoiDescriptorCollection > &roi_link)
	more rational generic Roi fill method
const EventContext &	eventContext () const
void	trackptrs (const view_store_t &v, std::vector< const TrackView * > &vp)
	do this with a single template for treacks and vertices
void	trackptrs (const std::vector< ParentView > &v, std::vector< const TrackView * > &vp)
void	vertexptrs (const vtx_store_t &v, std::vector< const VertexView * > &vp)
template<typename T>
bool	isGoodOffline (const T &, const std::string &, const std::string &="")=delete
	to be over ridden by selection for actual EDM classes

Protected Attributes
view_store_t	m_reftracks
	tracks
view_store_t	m_testtracks
std::vector< ParentView >	m_parents
std::vector< const TrackView * >	m_reftrackptr
std::vector< const TrackView * >	m_testtrackptr
const EventContext &	m_context
const TIDA::Associator< const TrackView > *	m_matcher = 0
	store the track matches in an actual simple way
vtx_store_t	m_refvertices_raw
vtx_store_t	m_testvertices_raw
std::vector< const VertexView * >	m_refvertices
std::vector< const VertexView * >	m_testvertices
const TIDA::Associator< const VertexView > *	m_vertex_matcher = 0
	store the vertex matches in an actual simple way NB: a vertex match can be quite complex: two vertices can have similar z positions, but different tracks
const ToolHandle< Trig::TrigDecisionTool > *	m_tdt
	Actually, actually, we don;t even need this AT ALL, it serves no purpose since we can control everything from the main execute() method as and when required, so this actually serves no real purpose any longer.
int	m_roiIndex
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 TagNProbe *	m_tnp = 0
	TrackAnalysis properties why do ALL these classes have independent m_anaTag variables ?
std::string	m_anaTag
const beam_key_t *	m_beamkeys = 0
	enable / diable local truth decoration handling

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

Private Attributes
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 78 of file TrackAnalysisStore.h.

Member Typedef Documentation

beam_key_t

using IDTPM2::TrackAnalysisStore::beam_key_t = SG::ReadDecorHandleKeyArray<xAOD::EventInfo>

Definition at line 82 of file TrackAnalysisStore.h.

keys_t

using IDTPM2::TrackAnalysisStore::keys_t = SG::ReadDecorHandleKeyArray<xAOD::EventInfo>

Definition at line 215 of file TrackAnalysisStore.h.

view_store_t

using IDTPM2::TrackAnalysisStore::view_store_t = std::vector<std::unique_ptr<TrackView>>

protected

polymoprphic master store types

Definition at line 225 of file TrackAnalysisStore.h.

vtx_store_t

using IDTPM2::TrackAnalysisStore::vtx_store_t = std::vector<std::unique_ptr<VertexView>>

protected

Definition at line 227 of file TrackAnalysisStore.h.

Constructor & Destructor Documentation

TrackAnalysisStore() [1/2]

IDTPM2::TrackAnalysisStore::TrackAnalysisStore	(	const std::string &	anaTag,
		const EventContext &	context )

Constructor.

---

— Constructors —

Definition at line 39 of file TrackAnalysisStore.cxx.

                                                                                                   :
    AthMessaging( "TrackAnalysisStore"+anaTag ),
    m_context(context),
    m_tdt(0),
    m_roiIndex(0),
    m_anaTag(anaTag)
{ }

TrackAnalysisStore() [2/2]

IDTPM2::TrackAnalysisStore::TrackAnalysisStore	(	const std::string &	anaTag,
		const ToolHandle< Trig::TrigDecisionTool > *	tdt,
		const EventContext &	context )

Definition at line 47 of file TrackAnalysisStore.cxx.

                                                                                                   : 
    AthMessaging( "TrackAnalysisStore"+anaTag ),
    m_context(context),
    m_tdt(tdt),
    m_roiIndex(0),
    m_anaTag(anaTag)
{ }

~TrackAnalysisStore()

IDTPM2::TrackAnalysisStore::~TrackAnalysisStore ( )

default

Destructor.

Member Function Documentation

addTagNProbe()

void IDTPM2::TrackAnalysisStore::addTagNProbe ( const TagNProbe * t )

inline

Definition at line 211 of file TrackAnalysisStore.h.

{ m_tnp=t; }

anaTag()

const std::string & IDTPM2::TrackAnalysisStore::anaTag ( )

inline

— Setter methods —

get TrackAnalysis tag

Definition at line 106 of file TrackAnalysisStore.h.

{ return m_anaTag; }

decoratePerigee()

void IDTPM2::TrackAnalysisStore::decoratePerigee

(

)

can extrapolate to the beamline perigee, if we don't know where the beamline is ...

only currently bother with this for actual, Truth/Particles ...

add perigee parameters ... NB: could make this add perigee parameters only when actually requested ...

should always have a production vertex ...

all of this would probably be much better, and certainiy more compact using some vector types ...

do we really want to bother for neutrals ???

siimple ultra-fast limear extrapolations ...

linear ...

do we need this ?

Definition at line 222 of file TrackAnalysisStore.cxx.

                                               { 

    if ( !m_beamkeys ) return;

    if ( m_reftracks.empty() || !m_reftracks.front()->is<xAOD::TruthParticle>() ) return;
        
    SG::ReadDecorHandle<xAOD::EventInfo, float> beamPosX((*m_beamkeys)[0], m_context);
    SG::ReadDecorHandle<xAOD::EventInfo, float> beamPosY((*m_beamkeys)[1], m_context);
    SG::ReadDecorHandle<xAOD::EventInfo, float> beamPosZ((*m_beamkeys)[2], m_context);

    for ( size_t i=0 ; i<m_reftracks.size() ; i++ ) {
 
      TruthView* tv = dynamic_cast<TruthView*>(m_reftracks[i].get());
 
      if ( !tv ) throw std::runtime_error("not a TruthView");
 
      const xAOD::TruthParticle* tp = tv->as<xAOD::TruthParticle>();
 
      if ( std::fabs(tv->pt())<50 ) continue;
 
      if ( !MC::isStable(tp) ) continue;                   
      
      float charge = tp->charge();

      if ( !tp->hasProdVtx() ) {
    tv->add_z0(-999);
    tv->add_d0(-999);
    tv->add_phi(tp->phi());
    continue;
      }

 
      double vx = tp->prodVtx()->x();
      double vy = tp->prodVtx()->y();
      double vz = tp->prodVtx()->z();
 
      double bx = beamPosX(0);
      double by = beamPosY(0);
      double bz = beamPosZ(0);
 
      double dx = vx - bx;
      double dy = vy - by;
      double dz = vz - bz;
      
      double eta = tp->eta();
      double phi = tp->phi();
 
      double theta = 2*std::atan( std::exp( -eta ) );
 
      double   sinphi = std::sin(phi);
      double   cosphi = std::cos(phi);
      double tantheta = std::tan(theta);
 
      if ( charge==0 ) { 

    
    double    z0 = dz - (dy*cosphi + dy*sinphi)/tantheta + bz;
    double    d0 =       dy*cosphi - dx*sinphi; 
    
    tv->add_z0(z0);
    tv->add_d0(d0);
    tv->add_phi(tp->phi());
 
      }
      else { 

    //  double    z0_ = dz - (dy*cosphi + dy*sinphi)/tantheta + bz;
    //  double    d0_ =       dy*cosphi - dx*sinphi; 
    
    // helix approximation ...
 
    int sign = ( charge<0 ? -1 : 1 );
 
    const double B = 2;
    const double c = 2.99792458;
    
    double QR = -charge*std::fabs(tv->pt())*10/(B*c);
    
    double nx =  sign*sinphi;
    double ny = -sign*cosphi;
    
    double Cx = vx + QR*nx;
    double Cy = vy + QR*ny;
    
    double wx = Cx - beamPosX(0);
    double wy = Cy - beamPosY(0);
    
    double w = std::sqrt( wx*wx + wy*wy );
    
    double d0   = w - std::fabs(QR);
    
    double rvx = -QR*nx;
    double rvy = -QR*ny;
    
    double rpx = -std::fabs(QR)*wx/w;
    double rpy = -std::fabs(QR)*wy/w; 
    
    double dphi = sign*std::atan2( rvx*rpy - rvy*rpx, rvx*rpx + rvy*rpy );

    //      double side = dx*wy - dy*wx;
    
    double s = dphi*QR;
    
    double z0 = dz - s/tantheta + bz;
 
    double phi = tp->phi()-dphi;
    
    tv->add_z0(z0);
    tv->add_d0(d0);
    tv->add_phi(phi);
    
      }
    }
 
}

eventContext()

const EventContext & IDTPM2::TrackAnalysisStore::eventContext ( ) const

inlineprotected

Definition at line 274 of file TrackAnalysisStore.h.

{ return m_context; }

eventInfo()

const xAOD::EventInfo * IDTPM2::TrackAnalysisStore::eventInfo ( ) const

inline

get event info

Definition at line 148 of file TrackAnalysisStore.h.

{ return m_eventInfo; }

fill()

template<typename T>

StatusCode IDTPM2::TrackAnalysisStore::fill ( T const *& container, const std::string & key )

protected

have the eventInfo already ?? then just pass in the pointer

more rational generic fill method

more rational generic fill methods

Definition at line 405 of file TrackAnalysisStore.h.

                                                                               {
      MY_MSG_DEBUG << "fill: collection (ordinary fill)" << key << endmsg;
      SG::ReadHandle<T> collection( key, eventContext() );  
      if( !collection.isValid() ) return StatusCode::FAILURE; // MY_MSG_WARNING <<  "Collection " << key << " could not be loaded"  << endmsg;
      container = collection.cptr();
      return StatusCode::SUCCESS;
}

fillEventInfo() [1/2]

StatusCode IDTPM2::TrackAnalysisStore::fillEventInfo ( const std::string & key )

inline

Definition at line 171 of file TrackAnalysisStore.h.

{ return fillInfo<xAOD::EventInfo>( m_eventInfo, key ); }

fillEventInfo() [2/2]

void IDTPM2::TrackAnalysisStore::fillEventInfo ( const xAOD::EventInfo * e )

inline

Definition at line 207 of file TrackAnalysisStore.h.

{ m_eventInfo = e; }

fillInfo()

template<typename T>

StatusCode IDTPM2::TrackAnalysisStore::fillInfo	(	const T *&	t,
		const std::string &	key )

filling methods to fetch collections ...

Definition at line 437 of file TrackAnalysisStore.h.

                                                                           {
  SG::ReadHandle<T> collection( key, eventContext() );
    if ( ! collection.isValid() ) return StatusCode::FAILURE; // MY_MSG_WARNING <<  "Collection " << key << " could not be loaded"  << endmsg;
    else t = collection.ptr();
    return StatusCode::SUCCESS;
}

fillRoi()

template<typename T>

StatusCode IDTPM2::TrackAnalysisStore::fillRoi ( std::pair< typename T::const_iterator, typename T::const_iterator > & itrpair, const std::string & key, const ElementLink< TrigRoiDescriptorCollection > & roi_link )

protected

more rational generic Roi fill method

Definition at line 418 of file TrackAnalysisStore.h.

                                                                               {
  
      MY_MSG_DEBUG <<  "fill: collection (roi)" << key << endmsg;
      
      SG::ReadHandle<T> collection( key, eventContext() );
 
      if( !collection.isValid() ) return StatusCode::FAILURE; // MY_MSG_WARNING <<  "Collection " << key << " could not be loaded"  << endmsg;
 
      if ( m_tdt ) {
    itrpair = (*m_tdt)->associateToEventView( collection, roi_link );
    return StatusCode::SUCCESS;
      }      
      else return StatusCode::FAILURE;
}  

fillVertexViewRef()

void IDTPM2::TrackAnalysisStore::fillVertexViewRef ( const std::string & key )

inline

vertex fillers ...

Definition at line 199 of file TrackAnalysisStore.h.

{ fillView( key, m_refvertices_raw ); vertexptrs( m_refvertices_raw, m_refvertices ); }

fillVertexViewTest() [1/2]

void IDTPM2::TrackAnalysisStore::fillVertexViewTest ( const std::string & key )

inline

Definition at line 201 of file TrackAnalysisStore.h.

{ fillView( key, m_testvertices_raw ); vertexptrs( m_testvertices_raw, m_testvertices ); }

fillVertexViewTest() [2/2]

void IDTPM2::TrackAnalysisStore::fillVertexViewTest ( const std::string & key, const ElementLink< TrigRoiDescriptorCollection > & roi_link )

inline

Definition at line 203 of file TrackAnalysisStore.h.

                                                                                                            {
    fillView( key, roi_link, m_testvertices_raw ); vertexptrs( m_testvertices_raw, m_testvertices );
  }

fillView() [1/4]

void IDTPM2::TrackAnalysisStore::fillView ( const std::string & key, const ElementLink< TrigRoiDescriptorCollection > & roi_link, view_store_t & trackView )

protected

must be a better way that to have a duplicated function, but only one I can think of is to pass in the TrackView, and both TrackParticle and TruthParticle contaiuners

don't need to bother with TruthParticles as they are not reconstructed in an Roi

Definition at line 91 of file TrackAnalysisStore.cxx.

                                                                                                                                                 { 
    
    std::pair<xAOD::TrackParticleContainer::const_iterator, xAOD::TrackParticleContainer::const_iterator> itrpair;
    
    if ( fillRoi<xAOD::TrackParticleContainer>( itrpair, key, roi_link ).isSuccess() ) {
      fillv( trackView, itrpair.first, itrpair.second );
    }
    else {
      throw std::runtime_error( "iterator pair not retrieved FFS for key: "+key );
    }
    
}

fillView() [2/4]

void IDTPM2::TrackAnalysisStore::fillView ( const std::string & key, const ElementLink< TrigRoiDescriptorCollection > & roi_link, vtx_store_t & vertexView )

protected

this and the roi based TrackView fillView should really be done with a single template

this and the roi based TrackView fillView should really be done with a single template eventually, likelyt create Parent and Child VertexViews as from the TrackView, then we can have the vertices own their own tracks and we would be unstoppable I tell you !

!

don't need to bother with TruthVertices as they are not reconstructed in an Roi

Definition at line 119 of file TrackAnalysisStore.cxx.

                                                                                                                                                 { 

    std::pair<xAOD::VertexContainer::const_iterator, xAOD::VertexContainer::const_iterator> itrpair;
    
    if ( fillRoi<xAOD::VertexContainer>( itrpair, key, roi_link ).isSuccess() ) {
      fillv( vertexView, itrpair.first, itrpair.second );
    }
    else {
      throw std::runtime_error( "iterator pair not retrieved FFS for key: "+key );
    }    
 
}

fillView() [3/4]

void IDTPM2::TrackAnalysisStore::fillView ( const std::string & key, view_store_t & trackView )

protected

track fillers ...

track stuff ...

this is a bit naughty - using the m_parents directly rather than passing it in - prevents being able to use this mechanism for the test corrections as well, so perhaps it could be changed, should change this to always pass in both a TrackView and a ParentView vectors

Definition at line 77 of file TrackAnalysisStore.cxx.

                                                                                       { 
  if ( fillView_internal<xAOD::TrackParticleContainer, TrackView>( key, trackView ) ) return;
  if (  m_beamkeys && fillView_internal<xAOD::TruthParticleContainer, TrackView, TruthView>( key, trackView ) ) return decoratePerigee();
  if ( !m_beamkeys && fillView_internal<xAOD::TruthParticleContainer, TrackView>( key, trackView ) ) return;
  if ( fillView_internal<xAOD::ElectronContainer>( key, m_parents ) ) return; 
  if ( fillView_internal<xAOD::MuonContainer>(     key, m_parents ) ) return;
  if ( fillView_internal<xAOD::TauJetContainer>(   key, m_parents ) ) return;
}

fillView() [4/4]

void IDTPM2::TrackAnalysisStore::fillView ( const std::string & key, vtx_store_t & vertexView )

protected

track vertices ...

vertex stuff ... now we have the child-parent relationship sorted out, these vertices should really become ParentViews containing the pointers to all their tracks

Definition at line 109 of file TrackAnalysisStore.cxx.

                                                                                       { 
  if ( fillView_internal<xAOD::VertexContainer, VertexView>(      key, vertexView ) ) return;
  if ( fillView_internal<xAOD::TruthVertexContainer, VertexView>( key, vertexView ) ) return;
}

fillView_internal() [1/2]

template<typename T>

bool IDTPM2::TrackAnalysisStore::fillView_internal ( const std::string & key, std::vector< ParentView > & parentView )

protected

the specialisation for the ParentView, because we want to retrieve the parent, and then get the child tracks to add to the tracks for the analysis, and then add the lookup back to the parent on those tracks

Definition at line 388 of file TrackAnalysisStore.h.

                                                                                                          {
    ChainString cs(key);
    const T* parents = 0;
    if ( fill( parents, cs.head() ).isSuccess() ) {
      if ( parents ) {
    for ( auto p : *parents ) if ( isGoodOffline( *p, cs.value(0), cs.value(1) ) ) parentView.push_back(p);
        for ( size_t i=parentView.size() ; i-- ; ) parentView[i].claimChildren();
    return true;
      }
    }
    return false;
}

fillView_internal() [2/2]

template<typename T, typename U, typename V>

bool IDTPM2::TrackAnalysisStore::fillView_internal ( const std::string & key, std::vector< std::unique_ptr< U > > & outView )

protected

templates for athena type track and vertex retrieval ...

Definition at line 371 of file TrackAnalysisStore.h.

                                                                                                             { 
    const T* collection = 0;
    if ( fill( collection, key ).isSuccess() ) {
      if ( collection ) {
    fillv<U,V>( outView, collection->begin(), collection->end() );
    return true;
      }
    }
    return false;
}

fillViewRef()

void IDTPM2::TrackAnalysisStore::fillViewRef ( const std::string & key )

inline

track fillers ...

Definition at line 182 of file TrackAnalysisStore.h.

                                            {
    fillView( key, m_reftracks );
    if ( m_parents.size()>0 ) trackptrs( m_parents,   m_reftrackptr );
    else                      trackptrs( m_reftracks, m_reftrackptr );
  }

fillViewTest() [1/2]

void IDTPM2::TrackAnalysisStore::fillViewTest ( const std::string & key )

inline

Definition at line 188 of file TrackAnalysisStore.h.

{ fillView( key, m_testtracks ); trackptrs( m_testtracks, m_testtrackptr ); }

fillViewTest() [2/2]

void IDTPM2::TrackAnalysisStore::fillViewTest ( const std::string & key, const ElementLink< TrigRoiDescriptorCollection > & roi_link )

inline

Roi filler ...

Definition at line 192 of file TrackAnalysisStore.h.

                                                                                                      {
    fillView( key, roi_link, m_testtracks ); trackptrs( m_testtracks, m_testtrackptr );
  }

getPair()

template<typename Collection>

std::pair< typename Collection::const_iterator, typename Collection::const_iterator > IDTPM2::TrackAnalysisStore::getPair	(	const ElementLink< TrigRoiDescriptorCollection > &	roi_link,
		const std::string &	key )

access by a pair of begin and end iterators

Definition at line 450 of file TrackAnalysisStore.h.

                                          {
    
    std::pair< typename Collection::const_iterator,
           typename Collection::const_iterator > itrpair;
 
    SG::ReadHandle<Collection> handle( key, eventContext() );
 
    //    CLID checkCLID;
    //    const std::string* keyStr = m_provider->evtStore()->keyToString(roi_link.key(), checkCLID);
    //    MY_MSG_DEBUG <<  "Requesting range over (" << key << ") associated to ROI from " << (keyStr == nullptr ? "UNKNOWN" : *keyStr)  << endmsg;
 
    if ( m_tdt ) itrpair = (*m_tdt)->associateToEventView( handle, roi_link );
 
    return itrpair;
}

hasTagNProbe()

bool IDTPM2::TrackAnalysisStore::hasTagNProbe ( ) const

inline

Definition at line 209 of file TrackAnalysisStore.h.

{ return m_tnp!=0; }

initialize()

StatusCode IDTPM2::TrackAnalysisStore::initialize

(

)

initialize this should not actually be needed - we should be creating a new instance whenever this is required, so all the "initialisation" could be moved to the constructor

---

— initialize —

this was a tool, instantiated, AS NEW for EVERY event, therefor having an initialize() method of this nature is completely pointless - so now everything is done in the constructor and the initialise is actually redundent. Also the DefinitioSvc is not needed, as the required information can simply be passed in from the top level tool.

Definition at line 66 of file TrackAnalysisStore.cxx.

{  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;
  }
}

isGoodOffline()

template<typename T>

bool IDTPM2::TrackAnalysisStore::isGoodOffline ( const T & , const std::string & , const std::string & = "" )

protecteddelete

to be over ridden by selection for actual EDM classes

matcher()

const TIDA::Associator< const TrackView > * IDTPM2::TrackAnalysisStore::matcher ( ) const

inline

test and reference tracks ...

these are all the accessors you actually should ever need ... local matcher ...

Definition at line 116 of file TrackAnalysisStore.h.

{ return m_matcher; }

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 167 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 182 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 user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

operator=()

TrackAnalysisStore & IDTPM2::TrackAnalysisStore::operator= ( const TrackAnalysisStore & )

delete

= operator

parents()

const std::vector< ParentView > & IDTPM2::TrackAnalysisStore::parents ( ) const

inline

Definition at line 108 of file TrackAnalysisStore.h.

{ return m_parents; }; 

reference_tracks() [1/3]

std::vector< const TrackView * > & IDTPM2::TrackAnalysisStore::reference_tracks ( )

inline

Definition at line 123 of file TrackAnalysisStore.h.

{ return m_reftrackptr;  }

reference_tracks() [2/3]

const std::vector< const TrackView * > & IDTPM2::TrackAnalysisStore::reference_tracks ( ) const

inline

Definition at line 120 of file TrackAnalysisStore.h.

{ return m_reftrackptr;  }

reference_tracks() [3/3]

void IDTPM2::TrackAnalysisStore::reference_tracks ( const std::vector< const TrackView * > & v )

inline

these are a bit dodgy - ie we pass in a vector<const TrackView*> so we want to construct a reference veiw_store_t ?

? this would mean making copies of the original TrackView objects, so now we would have two, seperate sets of pointers to copies of the same objects so we don't want this, and so we clear the raw view

Definition at line 131 of file TrackAnalysisStore.h.

{  m_reftrackptr = v; m_reftracks.clear();  }

refvertices() [1/2]

std::vector< const VertexView * > & IDTPM2::TrackAnalysisStore::refvertices ( )

inline

Definition at line 139 of file TrackAnalysisStore.h.

{ return m_refvertices;  }

refvertices() [2/2]

const std::vector< const VertexView * > & IDTPM2::TrackAnalysisStore::refvertices ( ) const

inline

vertex accessors

Definition at line 136 of file TrackAnalysisStore.h.

{ return  m_refvertices; }

roiIndex() [1/2]

int IDTPM2::TrackAnalysisStore::roiIndex ( ) const

inline

odds n ends ...

Definition at line 155 of file TrackAnalysisStore.h.

{ return m_roiIndex; }

roiIndex() [2/2]

void IDTPM2::TrackAnalysisStore::roiIndex ( int i )

inline

Definition at line 157 of file TrackAnalysisStore.h.

{ m_roiIndex = i; } 

set_matcher()

void IDTPM2::TrackAnalysisStore::set_matcher ( const TIDA::Associator< const TrackView > * m )

inline

Definition at line 118 of file TrackAnalysisStore.h.

{ m_matcher = m; };

set_vertex_matcher()

void IDTPM2::TrackAnalysisStore::set_vertex_matcher ( const TIDA::Associator< const VertexView > * m )

inline

Definition at line 142 of file TrackAnalysisStore.h.

{ m_vertex_matcher = m; };

setBeamKeys()

void IDTPM2::TrackAnalysisStore::setBeamKeys ( const beam_key_t * k )

inline

Definition at line 217 of file TrackAnalysisStore.h.

{ m_beamkeys = k; }

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;
}

tagNProbe()

const TagNProbe * IDTPM2::TrackAnalysisStore::tagNProbe ( ) const

inline

Definition at line 213 of file TrackAnalysisStore.h.

{ return m_tnp; }

test_tracks() [1/3]

std::vector< const TrackView * > & IDTPM2::TrackAnalysisStore::test_tracks ( )

inline

Definition at line 124 of file TrackAnalysisStore.h.

{ return m_testtrackptr; }

test_tracks() [2/3]

const std::vector< const TrackView * > & IDTPM2::TrackAnalysisStore::test_tracks ( ) const

inline

Definition at line 121 of file TrackAnalysisStore.h.

{ return m_testtrackptr; }

test_tracks() [3/3]

void IDTPM2::TrackAnalysisStore::test_tracks ( const std::vector< const TrackView * > & v )

inline

Definition at line 132 of file TrackAnalysisStore.h.

{ m_testtrackptr = v; m_testtracks.clear(); }

testvertices() [1/2]

std::vector< const VertexView * > & IDTPM2::TrackAnalysisStore::testvertices ( )

inline

Definition at line 140 of file TrackAnalysisStore.h.

{ return m_testvertices; }

testvertices() [2/2]

const std::vector< const VertexView * > & IDTPM2::TrackAnalysisStore::testvertices ( ) const

inline

Definition at line 137 of file TrackAnalysisStore.h.

{ return m_testvertices; }

trackptrs() [1/2]

void IDTPM2::TrackAnalysisStore::trackptrs ( const std::vector< ParentView > & v, std::vector< const TrackView * > & vp )

inlineprotected

Definition at line 279 of file TrackAnalysisStore.h.

                                                                                    {
    vp.clear();
    for ( size_t i=0 ; i<v.size() ; i++ ) append_pointers( vp, v[i].begin(), v[i].end() );
  }

trackptrs() [2/2]

void IDTPM2::TrackAnalysisStore::trackptrs ( const view_store_t & v, std::vector< const TrackView * > & vp )

inlineprotected

do this with a single template for treacks and vertices

Definition at line 277 of file TrackAnalysisStore.h.

{ fill_upointers( vp, v.begin(), v.end() );  }

truthEventContainer()

const xAOD::TruthEventContainer * IDTPM2::TrackAnalysisStore::truthEventContainer ( ) const

inline

Definition at line 149 of file TrackAnalysisStore.h.

{ return m_truthEventContainer; }

truthPileupEventContainer()

const xAOD::TruthPileupEventContainer * IDTPM2::TrackAnalysisStore::truthPileupEventContainer ( ) const

inline

Definition at line 150 of file TrackAnalysisStore.h.

{ return m_truthPUEventContainer; }

vertex_matcher()

const TIDA::Associator< const VertexView > * IDTPM2::TrackAnalysisStore::vertex_matcher ( ) const

inline

Definition at line 144 of file TrackAnalysisStore.h.

{ return m_vertex_matcher; }

vertexptrs()

void IDTPM2::TrackAnalysisStore::vertexptrs ( const vtx_store_t & v, std::vector< const VertexView * > & vp )

inlineprotected

Definition at line 284 of file TrackAnalysisStore.h.

{ fill_upointers( vp, v.begin(), v.end() );  }

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 IDTPM2::TrackAnalysisStore::m_anaTag

protected

Definition at line 358 of file TrackAnalysisStore.h.

m_beamkeys

const beam_key_t* IDTPM2::TrackAnalysisStore::m_beamkeys = 0

protected

enable / diable local truth decoration handling

Definition at line 363 of file TrackAnalysisStore.h.

m_context

const EventContext& IDTPM2::TrackAnalysisStore::m_context

protected

Definition at line 303 of file TrackAnalysisStore.h.

m_eventInfo

const xAOD::EventInfo* IDTPM2::TrackAnalysisStore::m_eventInfo = nullptr

protected

— Collections class variables — EventInfo, TruthEvent, and TruthPUEvent

Definition at line 345 of file TrackAnalysisStore.h.

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_matcher

const TIDA::Associator<const TrackView>* IDTPM2::TrackAnalysisStore::m_matcher = 0

protected

store the track matches in an actual simple way

Definition at line 307 of file TrackAnalysisStore.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_parents

std::vector<ParentView> IDTPM2::TrackAnalysisStore::m_parents

protected

Definition at line 298 of file TrackAnalysisStore.h.

m_reftrackptr

std::vector<const TrackView*> IDTPM2::TrackAnalysisStore::m_reftrackptr

protected

Definition at line 300 of file TrackAnalysisStore.h.

m_reftracks

view_store_t IDTPM2::TrackAnalysisStore::m_reftracks

protected

tracks

Definition at line 295 of file TrackAnalysisStore.h.

m_refvertices

std::vector<const VertexView*> IDTPM2::TrackAnalysisStore::m_refvertices

protected

Definition at line 314 of file TrackAnalysisStore.h.

m_refvertices_raw

vtx_store_t IDTPM2::TrackAnalysisStore::m_refvertices_raw

protected

Definition at line 311 of file TrackAnalysisStore.h.

m_roiIndex

int IDTPM2::TrackAnalysisStore::m_roiIndex

protected

Definition at line 341 of file TrackAnalysisStore.h.

m_tdt

const ToolHandle<Trig::TrigDecisionTool>* IDTPM2::TrackAnalysisStore::m_tdt

protected

Actually, actually, we don;t even need this AT ALL, it serves no purpose since we can control everything from the main execute() method as and when required, so this actually serves no real purpose any longer.

actually, we don't want to use a service handle for this, we extract it at the tool level, and pass it in when this tool is constructed for each event We stick with the Svc name however for the time being to avoid having to change the code that much SmartIF< ITrackAnalysisDefinitionSvc > m_trkAnaDefSvc; const ITrackAnalysisDefinition* m_trkAnaDefSvc; TrigDecisionTool - we don;t want to retrieve this tool ourselves, we can have it passed in by the parent tool

Definition at line 339 of file TrackAnalysisStore.h.

m_testtrackptr

std::vector<const TrackView*> IDTPM2::TrackAnalysisStore::m_testtrackptr

protected

Definition at line 301 of file TrackAnalysisStore.h.

m_testtracks

view_store_t IDTPM2::TrackAnalysisStore::m_testtracks

protected

Definition at line 296 of file TrackAnalysisStore.h.

m_testvertices

std::vector<const VertexView*> IDTPM2::TrackAnalysisStore::m_testvertices

protected

Definition at line 315 of file TrackAnalysisStore.h.

m_testvertices_raw

vtx_store_t IDTPM2::TrackAnalysisStore::m_testvertices_raw

protected

Definition at line 312 of file TrackAnalysisStore.h.

m_tnp

const TagNProbe* IDTPM2::TrackAnalysisStore::m_tnp = 0

protected

TrackAnalysis properties why do ALL these classes have independent m_anaTag variables ?

this is very dangerous, as none of them applear to ever be checked - there should be one analTag for an analysis, and all the tools in the analysis use the same thing

Definition at line 356 of file TrackAnalysisStore.h.

m_truthEventContainer

const xAOD::TruthEventContainer* IDTPM2::TrackAnalysisStore::m_truthEventContainer = nullptr

protected

Definition at line 346 of file TrackAnalysisStore.h.

m_truthPUEventContainer

const xAOD::TruthPileupEventContainer* IDTPM2::TrackAnalysisStore::m_truthPUEventContainer = nullptr

protected

Definition at line 347 of file TrackAnalysisStore.h.

m_vertex_matcher

const TIDA::Associator<const VertexView>* IDTPM2::TrackAnalysisStore::m_vertex_matcher = 0

protected

store the vertex matches in an actual simple way NB: a vertex match can be quite complex: two vertices can have similar z positions, but different tracks

Definition at line 321 of file TrackAnalysisStore.h.

---

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

• TrackAnalysisStore.h
• TrackAnalysisStore.cxx