TBTrackToCaloAlg Class Reference

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

#include <TBTrackToCaloAlg.h>

Inheritance 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.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

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

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
	TBTrackToCaloAlg ()
	TBTrackToCaloAlg (const TBTrackToCaloAlg &)
TBTrackToCaloAlg &	operator= (const TBTrackToCaloAlg &)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
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()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode 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);
 
  // retrieved 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()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

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, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

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

{this,"CaloDetDescrManager", "CaloDetDescrManager"};

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:

• TBTrackToCaloAlg.h
• TBTrackToCaloAlg.cxx