This Algorithm is meant to be an example of use of the TrackToCalo tools : More...

#include <TBTrackToCaloAlg.h>

Inheritance diagram for TBTrackToCaloAlg:

Collaboration diagram for TBTrackToCaloAlg:

Public Member Functions
	TBTrackToCaloAlg (const std::string &name, ISvcLocator *pSvcLocator)

virtual StatusCode	initialize () override

virtual StatusCode	execute () override

virtual StatusCode	finalize () override

bool	CreateTrkImpactInCalo ()

ImpactInCalo *	GetImpactsInCalo (const Trk::Track *track, bool &got_a_track)

void	CompareImpactWithCluster ()

void	PrintImpact ()

CaloCellList *	CellsCrossedByTrack (const Trk::Track *trk, const CaloCell_ID::CaloSample sam, int neta, int nphi)

bool	PrintCellsCrossed ()

void	PrintBeamPosition ()

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

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

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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

void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
	TBTrackToCaloAlg ()

	TBTrackToCaloAlg (const TBTrackToCaloAlg &)

TBTrackToCaloAlg &	operator= (const TBTrackToCaloAlg &)

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
std::string	m_TrackName

const TrackCollection *	m_tracks

std::string	m_TrackParticleName

const Rec::TrackParticleContainer *	m_particle

std::string	m_trkinput

std::string	m_cluster_container

std::string	m_cell_container

const CaloCell_ID *	m_calo_id

std::string	m_ImpactInCalosOutputName

TBExtrapolTrackToCaloTool *	m_toCalo

CaloDepthTool *	m_calodepth

CaloPhiRange	m_phiRange

ICaloCoordinateTool *	m_calo_tb_coord

SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}

DataObjIDColl	m_extendedExtraObjects

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

This Algorithm is meant to be an example of use of the TrackToCalo tools :

It loops on a given Track collection ( choosen by jobOption ) and extrapolates all tracks to the layers of the calorimeter.
Impacts are stored in an ImpactInCaloCollection, which is then used to fill CBNT
An example of primitive Track to Cluster matching is provided, as well as an example of how one can retreive all the CaloCell's around a track extrapolation, using the CaloCellList class ( these 2 are off by default )
One can also find an example of usage of the CaloDepthTool methods to define if one should extrapolate to the barrel or to the endcap.

Definition at line 63 of file TBTrackToCaloAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ TBTrackToCaloAlg() [1/3]

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

Definition at line 44 of file TBTrackToCaloAlg.cxx.

                                                              :
   AthAlgorithm(name,pSvcLocator),
   m_TrackName("Tracks"),
   m_tracks(0),
   m_calodepth(nullptr)
 {  
   // Get parameter values from jobOptions file
   declareProperty("TrackName", m_TrackName);
   declareProperty("TrackParticleName", m_TrackParticleName);
   declareProperty("ClusterContainerName", m_cluster_container);
   declareProperty("CaloCellContainerName", m_cell_container);
   declareProperty("ImpactInCaloContainerName", m_ImpactInCalosOutputName);
   declareProperty("TrackInputType", m_trkinput);
   m_calo_id = 0;
   m_calo_tb_coord = 0;
   m_particle = 0;
   m_toCalo = 0;
 }

◆ TBTrackToCaloAlg() [2/3]

TBTrackToCaloAlg::TBTrackToCaloAlg ( )

private

◆ TBTrackToCaloAlg() [3/3]

TBTrackToCaloAlg::TBTrackToCaloAlg ( const TBTrackToCaloAlg & )

private

Member Function Documentation

◆ CellsCrossedByTrack()

CaloCellList * TBTrackToCaloAlg::CellsCrossedByTrack	(	const Trk::Track *	trk,
		const CaloCell_ID::CaloSample	sam,
		int	neta,
		int	nphi
	)

Definition at line 572 of file TBTrackToCaloAlg.cxx.

 {
   CaloCellList* my_list = 0;
  
   // Retreive CaloCell's from StoreGate :  
  
   const CaloCellContainer* cell_container;
   StatusCode sc=evtStore()->retrieve(cell_container,m_cell_container);
   if ( sc != StatusCode::SUCCESS  ) return 0;
  
   SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
   const CaloDetDescrManager* caloDDMgr = *caloMgrHandle;
  
   // Where is the track shooting ?
   double offset = 0.;
   double trketa_at = 0.;
   double trkphi_at = 0.;
   Amg::Vector3D* pt_ctb = new Amg::Vector3D();
   Amg::Vector3D* pt_local = new Amg::Vector3D();
   bool result = m_toCalo->
     TrackSeenByCalo(trk,sam,offset,pt_ctb,pt_local,trketa_at,trkphi_at);
  
   if (!result) {
     delete pt_ctb;
     delete pt_local;
     return 0;
   }
  
   double eta = pt_local->eta();
   double phi = pt_local->phi();
  
   // CaloCellList needs both enums: subCalo and CaloSample
   CaloCell_ID::SUBCALO subcalo;
   bool barrel;
   int sampling_or_module;
   CaloDetDescrManager::decode_sample (subcalo, barrel, sampling_or_module, sam);
  
   // Get the corresponding grannularities : needs to know where you are 
   //                  the easiest is to look for the CaloDetDescrElement
   const CaloDetDescrElement* dde =
      caloDDMgr->get_element(subcalo,sampling_or_module,barrel,eta,phi);
  
   double deta = int(neta/2)*dde->deta();
   double dphi = int(nphi/2)*dde->dphi();
   
   //std::cout << "zone is ..." << eta << " " << phi << " "
   //          << deta << " " << dphi << " " << std::endl;
   // Construct the list : 
   my_list = new CaloCellList(caloDDMgr, cell_container,subcalo);
   my_list->select(eta,phi,deta,dphi, (int) sam);
  
   // cleanup 
   delete pt_ctb;
   delete pt_local;
   
   return my_list ;
 }

◆ CompareImpactWithCluster()

void TBTrackToCaloAlg::CompareImpactWithCluster ( )

Definition at line 441 of file TBTrackToCaloAlg.cxx.

 {
   StatusCode sc1, sc2;
  
   ATH_MSG_DEBUG ( "TBTrackToCaloAlg::CompareImpactWithCluster()" );
  
   // loop on clusters
   
   const CaloClusterContainer* cluster_container = nullptr;
   sc1=evtStore()->retrieve(cluster_container,m_cluster_container);
   
   const ImpactInCaloCollection* impact_collection;
   sc2=evtStore()->retrieve(impact_collection,m_ImpactInCalosOutputName);
   
   if(sc1 == StatusCode::SUCCESS && sc2 == StatusCode::SUCCESS ){
  
     typedef ImpactInCaloCollection::const_iterator impact_iterator;
     impact_iterator f_imp = impact_collection->begin();
     impact_iterator l_imp = impact_collection->end();
  
     for (const CaloCluster* cluster : *cluster_container) {
       double hecluster = cluster->energy()/GeV;
       double heta = cluster->eta();
       double hphi = cluster->phi();
  
       ATH_MSG_INFO ( "Found a cluster : E= " << hecluster 
                      << "(GeV), etaCaloLocal=" <<  heta 
                      << ", phiCaloLocal=" << hphi );
       
       for ( ; f_imp!=l_imp; ++f_imp){ 
     const ImpactInCalo* impact = (*f_imp);
         
     ATH_MSG_INFO 
           ( "==> Comparison between cluster and impact in Middle : deta=" 
         << heta-impact->etaCaloLocal_2()
         << " , dphi=" << hphi-impact->phiCaloLocal_2() );
       }
     }
   }
   else {
     if (sc1 != StatusCode::SUCCESS)
       ATH_MSG_ERROR ("Clusters not found" 
                      << m_cluster_container );
     if (sc2 != StatusCode::SUCCESS)
       ATH_MSG_ERROR ("ImpactInCalos not found" 
                      << m_ImpactInCalosOutputName );
   }
 }

◆ CreateTrkImpactInCalo()

bool TBTrackToCaloAlg::CreateTrkImpactInCalo ( )

Definition at line 133 of file TBTrackToCaloAlg.cxx.

 {
   bool got_a_track = false;
   
   ATH_MSG_DEBUG ( "TBTrackToCaloAlg::CreateTrkImpactInCalo()" );
  
   //create and record new ImpactInCalo container
   ImpactInCaloCollection* outputContainer = new ImpactInCaloCollection();
   StatusCode sc=evtStore()->record(outputContainer,m_ImpactInCalosOutputName,false); //"false" indicates it can't be modified by another algorithm
   if(sc != StatusCode::SUCCESS){
     ATH_MSG_ERROR ( " Could not record ImpactInCaloCollection" 
                     << m_ImpactInCalosOutputName );
     return got_a_track ;
   }
  
   m_particle = 0;
   m_tracks = 0;
  
   if( m_trkinput == "TrackParticleCandidates")
     {
       if (m_TrackParticleName == "") {
     ATH_MSG_ERROR ("m_TrackParticleName not set" );
     return true;
       }
  
       sc = evtStore()->retrieve(m_particle, m_TrackParticleName);
  
       if (sc.isFailure()) ATH_MSG_ERROR ("TrackParticle not found: will only play with calo " << m_TrackParticleName );
       else {
     ATH_MSG_DEBUG ("TrackParticle found in StoreGate" );
         for (const Rec::TrackParticle* tp : *m_particle) {
       const Trk::Track* tr = tp->originalTrack();
  
       ImpactInCalo * imp = GetImpactsInCalo(tr, got_a_track);     
       if(imp) outputContainer->push_back(imp);
       else ATH_MSG_DEBUG (" ImpactInCalo pointer not valid for this track");
     }
       }
     }
  
   else
     {
       if (m_TrackName == "") {
     ATH_MSG_ERROR ("m_TrackName not set" );
     return true;
       }
  
       sc = evtStore()->retrieve(m_tracks, m_TrackName);
  
       if (sc.isFailure()) ATH_MSG_ERROR ("Tracks not found: will only play with calo " << m_TrackName );
       else {
     ATH_MSG_DEBUG ("Tracks found in StoreGate" );
         for (const Trk::Track* tr : *m_tracks) {
       ImpactInCalo * imp = GetImpactsInCalo(tr, got_a_track);
       if(imp) outputContainer->push_back(imp);
       else ATH_MSG_DEBUG (" ImpactInCalo pointer not valid for this track");
     }
       }
     }
  
   return  got_a_track;
 }

◆ declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode TBTrackToCaloAlg::execute ( )

overridevirtual

Definition at line 98 of file TBTrackToCaloAlg.cxx.

 {
   ATH_MSG_DEBUG ( "TBTrackToCaloAlg::execute()" );
  
   // just a simple test ( trick to trigger position reading )
   // PrintBeamPosition();
  
   // Create the impacts :
   /*found_a_track =*/ CreateTrkImpactInCalo();
   
   // Example 1 : you want to read them and compare to clusters
  
   /*
     if (found_a_track) {
     PrintImpact();
     //CompareImpactWithCluster();
     } 
   */
  
   // Example 2 : you want to know the list of cells crossed by the track
   // bool found_cells = PrintCellsCrossed();
   ATH_CHECK(m_caloMgrKey.initialize());
   return StatusCode::SUCCESS;
 }

◆ extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 50 of file AthAlgorithm.cxx.

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

◆ finalize()

StatusCode TBTrackToCaloAlg::finalize ( )

overridevirtual

Definition at line 124 of file TBTrackToCaloAlg.cxx.

 {
   ATH_MSG_DEBUG ( "TBTrackToCaloAlg::finalize()" );
   
   return StatusCode::SUCCESS;
 }

◆ GetImpactsInCalo()

ImpactInCalo * TBTrackToCaloAlg::GetImpactsInCalo	(	const Trk::Track *	track,
		bool &	got_a_track
	)

Definition at line 196 of file TBTrackToCaloAlg.cxx.

 {
   Amg::Vector3D* pt_calo_ctb = new Amg::Vector3D; 
   Amg::Vector3D* pt_calo_local = new Amg::Vector3D; 
  
   SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
   const CaloDetDescrManager* caloDDMgr = *caloMgrHandle;
  
   double trketa = 0.;
   // take the last measured point to find out if I am in barrel or endcap :
   const DataVector <const Trk::TrackParameters>* paramvec = track->trackParameters();
   if (paramvec) { 
     for (const Trk::TrackParameters* params : *paramvec)
       trketa = params->eta();
   } 
   else
     ATH_MSG_ERROR ( "  No track parameters for this track ??? do nothing " );
   
   double distbar = 0.;
   double distec = 0.;
   double offset = 0.;   
   double trketa_at = 0.;
   double trkphi_at = 0.;
   bool result = false;
   CaloCell_ID::CaloSample sample;
   
   // PreSampler :
   double x_ctb_0 = 0;
   double y_ctb_0 = 0;
   double z_ctb_0 = 0;
   double etaCaloLocal_0 = 0; 
   double phiCaloLocal_0 = 0;
   double trketa_at_0 = 0.;
   double trkphi_at_0 = 0.;
   // Strip :
   double x_ctb_1 = 0;
   double y_ctb_1 = 0;
   double z_ctb_1 = 0;
   double etaCaloLocal_1 = 0; 
   double phiCaloLocal_1 = 0;
   double trketa_at_1 = 0.;
   double trkphi_at_1 = 0.;
   // Middle :
   double x_ctb_2 = 0;
   double y_ctb_2 = 0;
   double z_ctb_2 = 0;
   double etaCaloLocal_2 = 0; 
   double phiCaloLocal_2 = 0;
   double trketa_at_2 = 0.;
   double trkphi_at_2 = 0.;
   // Back :
   double x_ctb_3 = 0;
   double y_ctb_3 = 0;
   double z_ctb_3 = 0;
   double etaCaloLocal_3 = 0; 
   double phiCaloLocal_3 = 0;
   double trketa_at_3 = 0.;
   double trkphi_at_3 = 0.;
   // Tiles : 
   double x_ctb_tile = 0;
   double y_ctb_tile = 0;
   double z_ctb_tile = 0;
   double etaCaloLocal_tile = 0; 
   double phiCaloLocal_tile = 0;
   double trketa_at_tile = 0.;
   double trkphi_at_tile = 0.;
   
   if (paramvec) { 
     
     // PS :
     distbar = CaloDepthTool::deta(CaloCell_ID::PreSamplerB,trketa,caloDDMgr);
     distec = CaloDepthTool::deta(CaloCell_ID::PreSamplerE,trketa,caloDDMgr);
     
     ATH_MSG_DEBUG ( " TrackTo ...PS : for eta= " << trketa << " dist to Barrel =" << distbar 
                     << " to endcap =" << distec );
     if (distbar < 0 )  sample = CaloCell_ID::PreSamplerB;
     else if (distec < 0 ) sample = CaloCell_ID::PreSamplerE;
     else if ( distbar < distec) sample = CaloCell_ID::PreSamplerB;
     else sample = CaloCell_ID::PreSamplerE;
     ATH_MSG_DEBUG ( "  => will shoot in sample " << sample );
     
     result = m_toCalo->TrackSeenByCalo(track,sample,offset,
                        pt_calo_ctb,pt_calo_local,trketa_at,trkphi_at);
     
     if (result) {
       got_a_track=true;
       x_ctb_0 = pt_calo_ctb->x();
       y_ctb_0 = pt_calo_ctb->y();
       z_ctb_0 = pt_calo_ctb->z();
       etaCaloLocal_0 = pt_calo_local->eta(); 
       phiCaloLocal_0 = pt_calo_local->phi();
       trketa_at_0 = trketa_at;
       trkphi_at_0 = trkphi_at;
       
       ATH_MSG_DEBUG ( "Extrapolation to PreSamplerB gives: " 
       << " etaCaloLocal=" << pt_calo_local->eta()
                       << " phiCaloLocal=" << pt_calo_local->phi() );
     }
     
     // strip :
     distbar = CaloDepthTool::deta(CaloCell_ID::EMB1,trketa,caloDDMgr);
     distec = CaloDepthTool::deta(CaloCell_ID::EME1,trketa,caloDDMgr);
     
     ATH_MSG_DEBUG ( " TrackTo ...Strip : for eta= " << trketa << " dist to Barrel =" << distbar 
                     << " to endcap =" << distec );
     if (distbar < 0 ) sample = CaloCell_ID::EMB1;
     else if (distec < 0 ) sample = CaloCell_ID::EME1;
     else if ( distbar < distec) sample = CaloCell_ID::EMB1;
     else sample = CaloCell_ID::EME1;
     ATH_MSG_DEBUG ( "  => will shoot in sample " << sample );
     
     result = m_toCalo->TrackSeenByCalo(track,sample,offset,
                        pt_calo_ctb,pt_calo_local,trketa_at,trkphi_at);
     
     if (result) {
       got_a_track=true;
       x_ctb_1 = pt_calo_ctb->x();
       y_ctb_1 = pt_calo_ctb->y();
       z_ctb_1 = pt_calo_ctb->z();
       etaCaloLocal_1 = pt_calo_local->eta(); 
       phiCaloLocal_1 = pt_calo_local->phi();
       trketa_at_1 = trketa_at;
       trkphi_at_1 = trkphi_at;
       
       ATH_MSG_DEBUG ( "Extrapolation to EMB1 gives: " 
                       << " etaCaloLocal=" << pt_calo_local->eta()
                       << " phiCaloLocal=" << pt_calo_local->phi() );
     }
     
     
     // middle :
     distbar = CaloDepthTool::deta(CaloCell_ID::EMB2,trketa,caloDDMgr);
     distec = CaloDepthTool::deta(CaloCell_ID::EME2,trketa,caloDDMgr);
     
     ATH_MSG_DEBUG ( " TrackTo ...Middle : for eta= " << trketa << " dist to Barrel =" << distbar 
                     << " to endcap =" << distec );
     if (distbar < 0 ) sample = CaloCell_ID::EMB2;
     else if (distec < 0 ) sample = CaloCell_ID::EME2;
     else if ( distbar < distec) sample = CaloCell_ID::EMB2;
     else sample = CaloCell_ID::EME2;
     ATH_MSG_DEBUG ( "  => will shoot in sample " << sample );
     
     result = m_toCalo->TrackSeenByCalo(track,sample,offset,
                        pt_calo_ctb,pt_calo_local,trketa_at,trkphi_at);
     
     if (result) {
       got_a_track=true;
       x_ctb_2 = pt_calo_ctb->x();
       y_ctb_2 = pt_calo_ctb->y();
       z_ctb_2 = pt_calo_ctb->z();
       etaCaloLocal_2 = pt_calo_local->eta(); 
       phiCaloLocal_2 = pt_calo_local->phi();
       trketa_at_2 = trketa_at;
       trkphi_at_2 = trkphi_at;
       
       ATH_MSG_DEBUG ( "Extrapolation to EMB2 gives: " 
                       << " etaCaloLocal=" << pt_calo_local->eta()
                       << " phiCaloLocal=" << pt_calo_local->phi() );
     }
     
     // Back :
     //
     // there is a real gap between 1.35 (end of EMB3) and 1.5 (start of EMEC3)
     // => for TrackToCalo chooses the closest. One could choose to stay in 
     //    barrel as long as not in endcap
     // In both cases, m_calodepth will see that you are outside the accpetance and
     // will use the backup solution (egparametrisation right now, rel 10.0.2).
     //
     
     distbar = CaloDepthTool::deta(CaloCell_ID::EMB3,trketa,caloDDMgr);
     distec = CaloDepthTool::deta(CaloCell_ID::EME3,trketa,caloDDMgr);
     
     ATH_MSG_DEBUG ( " TrackTo ...Back : for eta= " << trketa << " dist to Barrel =" << distbar 
                     << " to endcap =" << distec );
     if (distbar < 0 ) sample = CaloCell_ID::EMB3;
     else if (distec < 0 ) sample = CaloCell_ID::EME3;
     else if ( distbar < distec) sample = CaloCell_ID::EMB3;
     else sample = CaloCell_ID::EME3;
     ATH_MSG_DEBUG ( "  => will shoot in sample " << sample );
     
     result = m_toCalo->TrackSeenByCalo(track,sample,offset,
                        pt_calo_ctb,pt_calo_local,trketa_at,trkphi_at);
     
     if (result) {
       got_a_track=true;
       x_ctb_3 = pt_calo_ctb->x();
       y_ctb_3 = pt_calo_ctb->y();
       z_ctb_3 = pt_calo_ctb->z();
       etaCaloLocal_3 = pt_calo_local->eta(); 
       phiCaloLocal_3 = pt_calo_local->phi();
       trketa_at_3 = trketa_at;
       trkphi_at_3 = trkphi_at;
       
       ATH_MSG_DEBUG ( "Extrapolation to EMB3 gives: " 
                       << " etaCaloLocal=" << pt_calo_local->eta()
                       << " phiCaloLocal=" << pt_calo_local->phi() );
     }
     
     // Tile or HEC0 :
     distbar = CaloDepthTool::deta(CaloCell_ID::TileBar0,trketa,caloDDMgr);
     distec = CaloDepthTool::deta(CaloCell_ID::HEC0,trketa,caloDDMgr);
     
     ATH_MSG_DEBUG ( " TrackTo ...Tile : for eta= " << trketa << " dist to Barrel =" << distbar 
                     << " to endcap =" << distec );
     if (distbar < 0 ) sample = CaloCell_ID::TileBar0;
     else if (distec < 0 ) sample = CaloCell_ID::HEC0;
     else if ( distbar > distec && distec < 10. ) sample = CaloCell_ID::HEC0;
     else sample = CaloCell_ID::TileBar0;
     ATH_MSG_DEBUG ( "  => will shoot in sample " << sample );
     
     result = m_toCalo->TrackSeenByCalo(track,sample,offset,
                        pt_calo_ctb,pt_calo_local,trketa_at,trkphi_at);
     
     if (result) {
       got_a_track=true;
       x_ctb_tile = pt_calo_ctb->x();
       y_ctb_tile = pt_calo_ctb->y();
       z_ctb_tile = pt_calo_ctb->z();
       etaCaloLocal_tile = pt_calo_local->eta(); 
       phiCaloLocal_tile = pt_calo_local->phi();
       trketa_at_tile = trketa_at;
       trkphi_at_tile = trkphi_at;
       
       ATH_MSG_DEBUG ( "Extrapolation to TileBar0 gives: " 
                       << " etaCaloLocal=" << pt_calo_local->eta()
                       << " phiCaloLocal=" << pt_calo_local->phi() );
     }
   }
   
   ImpactInCalo * imp= new ImpactInCalo(x_ctb_0, y_ctb_0, z_ctb_0, etaCaloLocal_0, phiCaloLocal_0, trketa_at_0, trkphi_at_0,
                        x_ctb_1, y_ctb_1, z_ctb_1, etaCaloLocal_1, phiCaloLocal_1, trketa_at_1, trkphi_at_1,
                        x_ctb_2, y_ctb_2, z_ctb_2, etaCaloLocal_2, phiCaloLocal_2, trketa_at_2, trkphi_at_2,
                        x_ctb_3, y_ctb_3, z_ctb_3, etaCaloLocal_3, phiCaloLocal_3, trketa_at_3, trkphi_at_3,
                        x_ctb_tile, y_ctb_tile, z_ctb_tile, etaCaloLocal_tile, phiCaloLocal_tile, trketa_at_tile, trkphi_at_tile);
   
   if(pt_calo_ctb) delete pt_calo_ctb;
   if(pt_calo_local) delete pt_calo_local;
   
   return imp;
 }

◆ initialize()

StatusCode TBTrackToCaloAlg::initialize ( )

overridevirtual

Definition at line 65 of file TBTrackToCaloAlg.cxx.

 {
   ATH_MSG_DEBUG ( "TBTrackToCaloAlg::initialize()" );
  
   ATH_CHECK(detStore()->retrieve(m_calo_id,"CaloCell_ID"));
  
   IAlgTool* algTool = 0;
  
   StatusCode sc = toolSvc()->retrieveTool("ExtrapolTrackToCaloTool", algTool,this);
   //m_toCalo=dynamic_cast<IExtrapolTrackToCaloTool*>(algTool); 
   //m_toCalo=dynamic_cast<IExtrapolateToCaloTool*>(algTool); 
   m_toCalo=dynamic_cast<TBExtrapolTrackToCaloTool*>(algTool); 
   if(sc.isFailure() || !m_toCalo) {
     ATH_MSG_ERROR ( "Cannot get ExtrapolTrackToCaloTool" );
     return StatusCode::FAILURE;
   }
   
   IAlgTool* tool = 0;
   ATH_CHECK( toolSvc()->retrieveTool("TBCaloCoordinate", tool) );
   m_calo_tb_coord = dynamic_cast<ICaloCoordinateTool*>(tool);
  
   // retrived via the Extrapolator to make sure that jobOpt setting is consistent.
   m_calodepth = m_toCalo->getCaloDepth();
   if (!m_calodepth) {
     ATH_MSG_ERROR ( "Cannot get CaloDepthTool" );
     return StatusCode::FAILURE; 
   }
  
   ATH_MSG_INFO ( "TBTrackToCaloAlg initialisation OK" );
   return StatusCode::SUCCESS;
 }

◆ inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ operator=()

TBTrackToCaloAlg& TBTrackToCaloAlg::operator= ( const TBTrackToCaloAlg & )

private

◆ outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

◆ PrintBeamPosition()

void TBTrackToCaloAlg::PrintBeamPosition ( )

Definition at line 700 of file TBTrackToCaloAlg.cxx.

 {
   // Get the messaging service, print where you are
   ATH_MSG_INFO ( "TBTrackToCaloAlg::PrintBeamPosition()" );
  
   ATH_MSG_INFO ( "Just a check... beam direction in calo : " );
   m_calo_tb_coord->read_table_position();  
   Amg::Vector3D beam (1.,0.,0.);
   beam = ( *(m_calo_tb_coord->transform_ctb_to_calo()) )* beam;
 }

◆ PrintCellsCrossed()

bool TBTrackToCaloAlg::PrintCellsCrossed ( )

Definition at line 632 of file TBTrackToCaloAlg.cxx.

 {
  
   // Get the messaging service, print where you are
   ATH_MSG_INFO ( "TBTrackToCaloAlg::PrintCellsCrossed()" );
   
   // Here we are :
   CaloCell_ID::CaloSample sam = CaloCell_ID::EMB2;
   int neta = 5;
   int nphi = 5;
   
   // get tracks from TDS
   if (m_TrackName == "") {
     ATH_MSG_ERROR ("m_TrackName not set" );
     return true;
   }
  
   StatusCode sc = evtStore()->retrieve(m_tracks, m_TrackName);
   if (sc.isFailure()){
     ATH_MSG_ERROR ("Tracks not found: will only play with calo " 
                    << m_TrackName );
   }
   else{ 
     ATH_MSG_DEBUG ("Tracks found in StoreGate" );
  
     for (const Trk::Track* tr : *m_tracks) {
       
       const Trk::Perigee *aMeasPer=
     dynamic_cast<const Trk::Perigee*>(tr->perigeeParameters());
       if (aMeasPer==0){
     ATH_MSG_ERROR ( "Could not get Trk::MeasuredPerigee" );
       }
       else {
     double d0 = aMeasPer->parameters()[Trk::d0];
     double z0 = aMeasPer->parameters()[Trk::z0];
     double phi0 = aMeasPer->parameters()[Trk::phi0];
     double theta = aMeasPer->parameters()[Trk::theta];
     double qOverP = aMeasPer->parameters()[Trk::qOverP];
     ATH_MSG_INFO ( " " );
     ATH_MSG_INFO ( "Found a track: parameters are " << d0  << " " 
                        << z0  << " " << phi0 << " " << theta << " " << qOverP );
       }
  
       // Warning : if anything fails, CellsCrossedByTrack will
       //           simply return a null pointer
       //           if it works, it does a new CaloCellList
       //           ==> the client has to do the delete !!!!
  
       CaloCellList* my_list = CellsCrossedByTrack(tr, sam, neta, nphi); 
  
       if (my_list) {
  
         for (const CaloCell* cell : *my_list)
       ATH_MSG_INFO ( "found cell ! eta=" << cell->eta() 
                          << " phi=" << cell->phi() << " energy=" << cell->energy() );
     
     delete my_list;
  
     }
       else 
     ATH_MSG_ERROR (" :-(  extrapolation did not work");
     }
   }
   
   return true;
 }

◆ PrintImpact()

void TBTrackToCaloAlg::PrintImpact ( )

Definition at line 491 of file TBTrackToCaloAlg.cxx.

 {
   StatusCode sc;
  
   ATH_MSG_INFO ( " Method PrintImpacts : " );
  
   ATH_MSG_INFO ( " " );
   ATH_MSG_INFO ( " Start with Impacts : " );
   
   const ImpactInCaloCollection* impact_collection;
   sc=evtStore()->retrieve(impact_collection,m_ImpactInCalosOutputName);
   
   if(sc == StatusCode::SUCCESS ){
  
     for (const ImpactInCalo* impact : *impact_collection) {
       const double impcosPhi = std::cos(impact->phiCaloLocal_1());
       const double impeta = impact->etaCaloLocal_1();
  
       ATH_MSG_INFO ( "Found an impact in strips : parameters are eta = " << impeta  
                      << " cosPhi = " << impcosPhi );
  
       //impact->print();
     }
   }
   else {
     ATH_MSG_ERROR ("ImpactInCalos not found" 
                    << m_ImpactInCalosOutputName );
   }
  
   if (m_tracks) {
  
     ATH_MSG_INFO ( " " );
     ATH_MSG_INFO (" Now loop on Trk::Track collection " );
     ATH_MSG_INFO ( " " );
  
     for (const Trk::Track* tr : *m_tracks) {
       const Trk::Perigee *aMeasPer=
     dynamic_cast<const Trk::Perigee*>(tr->perigeeParameters());
       if (aMeasPer==0){
     ATH_MSG_ERROR ( "Could not get Trk::MeasuredPerigee" );
       }
       else {    
  
     const double trkcosPhi = cos(aMeasPer->parameters()[Trk::phi]);
     const double trketa = aMeasPer->eta();
     
     ATH_MSG_INFO ( "Found a Trk::Track : parameters are eta = " << trketa  
                        << " cosPhi = " << trkcosPhi );
       }
     }
   }
  
   if (m_particle) {
     
     ATH_MSG_INFO ( " " );
     ATH_MSG_INFO (" Now loop on Trk::TrackParticle collection " );
     ATH_MSG_INFO ( " " );
     
     for (Rec::TrackParticleContainer::const_iterator itr = m_particle->begin();
      itr != m_particle->end(); ++itr )
       {
     const Trk::Perigee *aMeasPer=
       dynamic_cast<const Trk::Perigee*>(((*itr)->originalTrack())->perigeeParameters());
     if (aMeasPer==0){
       ATH_MSG_ERROR ( "Could not get TrkParticle::MeasuredPerigee" );
     }
     else {  
       
       const double partcosPhi = cos(aMeasPer->parameters()[Trk::phi]);
       const double parteta = aMeasPer->eta();
       
       ATH_MSG_INFO ( "Found a trackparticle : parameters are eta = " << parteta  
                          << " cosPhi = " << partcosPhi );
     }
       }
   }
 }

◆ renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

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

Definition at line 66 of file AthAlgorithm.cxx.

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

◆ sysStart()

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

overridevirtualinherited

Handle START transition.

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

◆ updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_calo_id

const CaloCell_ID* TBTrackToCaloAlg::m_calo_id

private

Definition at line 121 of file TBTrackToCaloAlg.h.

◆ m_calo_tb_coord

ICaloCoordinateTool* TBTrackToCaloAlg::m_calo_tb_coord

private

Definition at line 130 of file TBTrackToCaloAlg.h.

◆ m_calodepth

CaloDepthTool* TBTrackToCaloAlg::m_calodepth

private

Definition at line 126 of file TBTrackToCaloAlg.h.

◆ m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> TBTrackToCaloAlg::m_caloMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}

private

Definition at line 132 of file TBTrackToCaloAlg.h.

◆ m_cell_container

std::string TBTrackToCaloAlg::m_cell_container

private

Definition at line 120 of file TBTrackToCaloAlg.h.

◆ m_cluster_container

std::string TBTrackToCaloAlg::m_cluster_container

private

Definition at line 119 of file TBTrackToCaloAlg.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_ImpactInCalosOutputName

std::string TBTrackToCaloAlg::m_ImpactInCalosOutputName

private

Definition at line 124 of file TBTrackToCaloAlg.h.

◆ m_particle

const Rec::TrackParticleContainer* TBTrackToCaloAlg::m_particle

private

Definition at line 115 of file TBTrackToCaloAlg.h.

◆ m_phiRange

CaloPhiRange TBTrackToCaloAlg::m_phiRange

private

Definition at line 127 of file TBTrackToCaloAlg.h.

◆ m_toCalo

TBExtrapolTrackToCaloTool* TBTrackToCaloAlg::m_toCalo

private

Definition at line 125 of file TBTrackToCaloAlg.h.

◆ m_TrackName

std::string TBTrackToCaloAlg::m_TrackName

private

Definition at line 112 of file TBTrackToCaloAlg.h.

◆ m_TrackParticleName

std::string TBTrackToCaloAlg::m_TrackParticleName

private

Definition at line 114 of file TBTrackToCaloAlg.h.

◆ m_tracks

const TrackCollection* TBTrackToCaloAlg::m_tracks

private

Definition at line 113 of file TBTrackToCaloAlg.h.

◆ m_trkinput

std::string TBTrackToCaloAlg::m_trkinput

private

Definition at line 116 of file TBTrackToCaloAlg.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ TBTrackToCaloAlg() [1/3]

◆ TBTrackToCaloAlg() [2/3]

◆ TBTrackToCaloAlg() [3/3]

Member Function Documentation

◆ CellsCrossedByTrack()

◆ CompareImpactWithCluster()

◆ CreateTrkImpactInCalo()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ GetImpactsInCalo()

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ operator=()

◆ outputHandles()

◆ PrintBeamPosition()

◆ PrintCellsCrossed()

◆ PrintImpact()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_calo_id

◆ m_calo_tb_coord

◆ m_calodepth

◆ m_caloMgrKey

◆ m_cell_container

◆ m_cluster_container

◆ m_detStore

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_ImpactInCalosOutputName

◆ m_particle

◆ m_phiRange

◆ m_toCalo

◆ m_TrackName

◆ m_TrackParticleName

◆ m_tracks

◆ m_trkinput

◆ m_varHandleArraysDeclared

◆ m_vhka