TBExtrapolTrackToCaloTool Class Reference

This class takes a given TrkTrack, extrapolates it to the Calo and returns the variables needed to compare with the cluster position. More...

#include <TBExtrapolTrackToCaloTool.h>

Inheritance diagram for TBExtrapolTrackToCaloTool:

Collaboration diagram for TBExtrapolTrackToCaloTool:

Public Member Functions
	TBExtrapolTrackToCaloTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~TBExtrapolTrackToCaloTool ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
void	CaloVariables (const Trk::TrackParameters *parm, double &etaCaloLocal, double &phiCaloLocal)
	now return the variables needed to compare with CaloClusters:
void	CaloLocalPoint (const Trk::TrackParameters *parm, Amg::Vector3D *pt_ctb, Amg::Vector3D *pt_local)
bool	TrackSeenByCalo (const Trk::Track *trk, const CaloCell_ID::CaloSample sample, const double offset, Amg::Vector3D *pt_ctb, Amg::Vector3D *pt_local)
	The "do-it-all" method which combines the 3 steps.
bool	TrackSeenByCalo (const Trk::TrackParameters *parm, const CaloCell_ID::CaloSample sample, const double offset, Amg::Vector3D *pt_ctb, Amg::Vector3D *pt_local)
bool	TrackSeenByCalo (const Trk::Track *trk, const bool barrel, const CaloCell_ID::SUBCALO subcalo, const int sampling_or_module, const double offset, Amg::Vector3D *pt_ctb, Amg::Vector3D *pt_local)
bool	TrackSeenByCalo (const Trk::TrackParameters *parm, const bool barrel, const CaloCell_ID::SUBCALO subcalo, const int sampling_or_module, const double offset, Amg::Vector3D *pt_ctb, Amg::Vector3D *pt_local)
bool	TrackSeenByCalo (const Trk::Track *trk, const CaloCell_ID::CaloSample sample, const double offset, Amg::Vector3D *pt_ctb, Amg::Vector3D *pt_local, double &trketa_atcalo, double &trkphi_atcalo)
const Trk::TrackParameters *	extrapolate (const Trk::Track &, const CaloCell_ID::CaloSample, const double, const Trk::PropDirection=Trk::alongMomentum, const Trk::ParticleHypothesis=Trk::undefined) const
const Trk::TrackParameters *	extrapolate (const Trk::TrackParticleBase &, const CaloCell_ID::CaloSample, const double, const Trk::PropDirection=Trk::alongMomentum, const Trk::ParticleHypothesis=Trk::undefined) const
const Trk::TrackParameters *	extrapolate (const Trk::TrackParameters &, const CaloCell_ID::CaloSample, const double, Trk::ParticleHypothesis, const Trk::PropDirection=Trk::alongMomentum) const
const Trk::NeutralParameters *	extrapolate (const Trk::NeutralParameters &, const CaloCell_ID::CaloSample, const double, Trk::ParticleHypothesis, const Trk::PropDirection=Trk::alongMomentum) const
virtual const Trk::TrackParameters *	extrapolate (const xAOD::TrackParticle &, const CaloCell_ID::CaloSample, const double, const Trk::PropDirection=Trk::alongMomentum, const Trk::ParticleHypothesis=Trk::undefined) const
virtual const Trk::NeutralParameters *	extrapolate (const xAOD::NeutralParticle &, const CaloCell_ID::CaloSample, const double, const Trk::PropDirection=Trk::alongMomentum) const
	get Trk::NeutralParameters at the calorimeter sample from xAOD::NeutralParticle
virtual const DataVector< const Trk::TrackParameters > *	getParametersInCalo (const Trk::TrackParameters &, Trk::ParticleHypothesis, const Trk::PropDirection=Trk::alongMomentum) const
virtual const DataVector< const Trk::NeutralParameters > *	getParametersInCalo (const Trk::NeutralParameters &, Trk::ParticleHypothesis, const Trk::PropDirection=Trk::alongMomentum) const
virtual const DataVector< const Trk::TrackParameters > *	getParametersInCalo (const Trk::TrackParticleBase &, const Trk::ParticleHypothesis=Trk::undefined, const Trk::PropDirection=Trk::alongMomentum) const
virtual const DataVector< const Trk::TrackParameters > *	getParametersInCalo (const Trk::Track &, const Trk::ParticleHypothesis=Trk::undefined, const Trk::PropDirection=Trk::alongMomentum) const
virtual const DataVector< const Trk::TrackParameters > *	getParametersInCalo (const xAOD::TrackParticle &, const Trk::ParticleHypothesis=Trk::undefined, const Trk::PropDirection=Trk::alongMomentum) const
ImpactInCalo *	getImpactInCalo (const Trk::Track &, const Trk::ParticleHypothesis=Trk::undefined, const Trk::PropDirection=Trk::alongMomentum) const
ImpactInCalo *	getImpactInCalo (const Trk::TrackParticleBase &, const Trk::ParticleHypothesis=Trk::undefined, const Trk::PropDirection=Trk::alongMomentum) const
virtual ImpactInCalo *	getImpactInCalo (const Trk::TrackParameters &, Trk::ParticleHypothesis, const Trk::PropDirection=Trk::alongMomentum) const
virtual ImpactInCalo *	getImpactInCalo (const Trk::NeutralParameters &, Trk::ParticleHypothesis, const Trk::PropDirection=Trk::alongMomentum) const
CaloDepthTool *	getCaloDepth ()
	access to the private tool used to define the extrapolation depth, needed to play with delta-eta
const Trk::TrackParameters *	extrapolate (const Trk::TrackParameters *parm, const Trk::Surface *surf)
	to be used on AOD's or to extrapolate from perigee
const Trk::TrackParameters *	extrapolate (const Trk::Track *trk, const Trk::Surface *surf)
	will use the last measured hit, will not work on AOD's
virtual Amg::Vector3D	getMomentumAtVertex (const xAOD::Vertex &vertex, bool) const
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	sysInitialize () override
	Perform system initialization for an algorithm.
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

Static Public Member Functions
static const InterfaceID &	interfaceID ()

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
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloMgrKey
const CaloCell_ID *	m_calo_id {nullptr}
ICaloCoordinateTool *	m_calo_tb_coord {nullptr}
CaloPhiRange	m_range
ToolHandle< ICaloSurfaceBuilder >	m_calosurf
ToolHandle< Trk::IExtrapolator >	m_extrapolator
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 class takes a given TrkTrack, extrapolates it to the Calo and returns the variables needed to compare with the cluster position.

It heavily uses the Tracking PreconfiguredExtrapolator class.

The client is asked to select explicitely the CaloCell_ID::CaloSample where he wants to extrapolate. The 4 steps are combined :

• first guess of eta : take it from last point measured for Trk::Track or the imput Trk::Parameters
• CreateUserSurface(sample,offset,trketa)
• extrapolate
• compute calo variables ( neeed for H8, for Atlas correspond to the usual eta/phi )

The extrapolarion is performed WITH boundary checks.

INTERFACE :

Calorimeter : the enum CaloCell_ID::CaloSample is strongly recommended, the other one being here for backward compatibility.

Trk::Trk is recommended while running the full reconstruction or on ESD. If so, the extrapolation starts from the last measured point.

Trk::Parameter is mandatory while running on AOD's and can be used if you want to start the extrapolation from the perigee.

BEHIND THE SCEENE : the tools of the package CaloTrackingGeometry/CaloSurfaceBuilder are used to create the proper geometry elements ( Trk::Surface, Trk::Layer, Trk::Volume )

Definition at line 82 of file TBExtrapolTrackToCaloTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

TBExtrapolTrackToCaloTool()

TBExtrapolTrackToCaloTool::TBExtrapolTrackToCaloTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 39 of file TBExtrapolTrackToCaloTool.cxx.

                                           :
  AthAlgTool(type, name, parent),
  m_calosurf("CaloSurfaceBuilder"),
  m_extrapolator("Trk::Extrapolator/AtlasExtrapolator")
{
 
 declareProperty ("CaloSurfaceBuilder",m_calosurf,"Extrapolation ToolHandle");
 declareProperty ("Extrapolator",m_extrapolator,"CaloSurfaceBuilder ToolHandle");
 
}

~TBExtrapolTrackToCaloTool()

TBExtrapolTrackToCaloTool::~TBExtrapolTrackToCaloTool ( )

virtual

Definition at line 52 of file TBExtrapolTrackToCaloTool.cxx.

{}

Member Function Documentation

CaloLocalPoint()

void TBExtrapolTrackToCaloTool::CaloLocalPoint	(	const Trk::TrackParameters *	parm,
		Amg::Vector3D *	pt_ctb,
		Amg::Vector3D *	pt_local )

Definition at line 165 of file TBExtrapolTrackToCaloTool.cxx.

{
 
  if (!parm) {
    ATH_MSG_WARNING ("CaloLocalPoint TrkParam called with null Trk::TrackParameters*" );
    return;
  }
 
  if (!pt_local) {
    ATH_MSG_WARNING ("CaloLocalPoint TrkParam called with null Amg::Vector3D* pt_local" );
    return;
  }
 
  if (!pt_ctb) {
    ATH_MSG_WARNING ("CaloLocalPoint TrkParam called with null Amg::Vector3D* pt_ctb" );
    return;
  }
  
 
  *pt_ctb = parm->position();
 
  ATH_MSG_DEBUG ("Impact point in ctb coord : x,y,z= " 
      << pt_ctb->x() << " " 
      << pt_ctb->y() << " " << pt_ctb->z() << " R=" 
      << std::sqrt( pt_ctb->x()*pt_ctb->x() + pt_ctb->y()*pt_ctb->y() 
            + pt_ctb->z()*pt_ctb->z())
         << " eta=" << pt_ctb->eta() << " phi=" << pt_ctb->phi() );
 
  m_calo_tb_coord->ctb_to_local(*pt_ctb, *pt_local);
    
  ATH_MSG_DEBUG ("Impact point in local coord : x,y,z= " 
      << pt_local->x() << " " 
      << pt_local->y() << " " << pt_local->z() << " R=" 
      << std::sqrt( pt_local->x()*pt_local->x() 
            + pt_local->y()*pt_local->y() 
            + pt_local->z()*pt_local->z())
         << " eta=" << pt_local->eta() << " phi=" << pt_local->phi());
}

CaloVariables()

void TBExtrapolTrackToCaloTool::CaloVariables	(	const Trk::TrackParameters *	parm,
		double &	etaCaloLocal,
		double &	phiCaloLocal )

now return the variables needed to compare with CaloClusters:

Definition at line 122 of file TBExtrapolTrackToCaloTool.cxx.

{
 
 
  Amg::Vector3D pt_ctb,pt_local;  
  etaCaloLocal = 0.;
  phiCaloLocal = 0.;
 
  if (!parm) {
    ATH_MSG_WARNING ("CaloVariables called with null Trk::TrackParameters*" ) ;
    return;
  }
  
  pt_ctb = parm->position();
 
  m_calo_tb_coord->ctb_to_local(pt_ctb, pt_local);
 
  if ( msgLvl(MSG::DEBUG) ){
    
    ATH_MSG_DEBUG ("Impact point in ctb coord : x,y,z= " 
    << pt_ctb.x() << " " 
    << pt_ctb.y() << " " << pt_ctb.z() << " R=" 
    << std::sqrt( pt_ctb.x()*pt_ctb.x() + pt_ctb.y()*pt_ctb.y() 
            + pt_ctb.z()*pt_ctb.z())
     << " eta=" << pt_ctb.eta() << " phi=" << pt_ctb.phi() );
 
 
    
    ATH_MSG_DEBUG ("Impact point in local coord : x,y,z= " 
    << pt_local.x() << " " 
    << pt_local.y() << " " << pt_local.z() << " R=" 
    << std::sqrt( pt_local.x()*pt_local.x() + pt_local.y()*pt_local.y() 
            + pt_local.z()*pt_local.z())
            << " eta=" << pt_local.eta() << " phi=" << pt_local.phi());
  }
  
  etaCaloLocal = pt_local.eta();
  phiCaloLocal = pt_local.phi();
  
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

extrapolate() [1/8]

const Trk::NeutralParameters * TBExtrapolTrackToCaloTool::extrapolate ( const Trk::NeutralParameters & , const CaloCell_ID::CaloSample , const double , Trk::ParticleHypothesis , const Trk::PropDirection = Trk::alongMomentum ) const

inline

Definition at line 162 of file TBExtrapolTrackToCaloTool.h.

                                                      {std::cout<<"Not Implemented !!!!"<<std::endl; return 0;}

extrapolate() [2/8]

const Trk::TrackParameters * TBExtrapolTrackToCaloTool::extrapolate ( const Trk::Track & , const CaloCell_ID::CaloSample , const double , const Trk::PropDirection = Trk::alongMomentum, const Trk::ParticleHypothesis = Trk::undefined ) const

inline

Definition at line 144 of file TBExtrapolTrackToCaloTool.h.

                                                     {std::cout<<"Not Implemented !!!!"<<std::endl; return 0;}  

extrapolate() [3/8]

const Trk::TrackParameters * TBExtrapolTrackToCaloTool::extrapolate	(	const Trk::Track *	trk,
		const Trk::Surface *	surf )

will use the last measured hit, will not work on AOD's

Definition at line 460 of file TBExtrapolTrackToCaloTool.cxx.

{
 
  const Trk::TrackParameters* param=0;
  if (!trk) {
    ATH_MSG_WARNING ("extrapolate Trk called with null Trk::Track*");
    return param;
  }
 
  if (!surf) {
    ATH_MSG_WARNING ("extrapolate Trk called with null Trk::Surface*" );
    return param;
  }
 
 
 
 
  ATH_MSG_DEBUG ("Trying to propagate to Surface ... " << (*surf) );
  
  param = m_extrapolator->extrapolateTrack( 
    Gaudi::Hive::currentContext(),
    *trk, *surf,
    Trk::alongMomentum,
    true, Trk::nonInteracting).release();
  
  // the other way to do it:
  //
  // const TrackParameters* extrapolate(const Trk::Propagator& prop,
  // const Trk::Track& trk,
  // const Trk::Surface& sf,
  // Trk::PropDirectiondir=anyDirection,Trk::BoundaryCheck bcheck = true) 
  //        const;
 
  if (param)
    ATH_MSG_DEBUG ("Propagation successful " );
  else
    ATH_MSG_DEBUG ("Propagation failed ");
 
  return param;
}

extrapolate() [4/8]

const Trk::TrackParameters * TBExtrapolTrackToCaloTool::extrapolate ( const Trk::TrackParameters & , const CaloCell_ID::CaloSample , const double , Trk::ParticleHypothesis , const Trk::PropDirection = Trk::alongMomentum ) const

inline

Definition at line 156 of file TBExtrapolTrackToCaloTool.h.

                                                      {std::cout<<"Not Implemented !!!!"<<std::endl; return 0;}

extrapolate() [5/8]

const Trk::TrackParameters * TBExtrapolTrackToCaloTool::extrapolate	(	const Trk::TrackParameters *	parm,
		const Trk::Surface *	surf )

to be used on AOD's or to extrapolate from perigee

Definition at line 421 of file TBExtrapolTrackToCaloTool.cxx.

{
 
 
  const Trk::TrackParameters* param=0;
 
  if (!parm) {
    ATH_MSG_WARNING ("extrapolate TrkParam called with null Trk::TrackParameters*" ) ;
    return param;
  }
 
  if (!surf) {
    ATH_MSG_WARNING ("extrapolate TrkParam called with null Trk::Surface*" << endmsg );
    return param;
  }
 
 
 
 
  ATH_MSG_DEBUG ( "Trying to propagate TrackParameters to Surface ... " 
      << (*surf));
 
  // for the moment use nonInteracting to avoid the navigation   
  param = m_extrapolator->extrapolate( 
    Gaudi::Hive::currentContext(),
    *parm, *surf,
    Trk::alongMomentum,
    true, Trk::nonInteracting).release();
  
  if (param)
    ATH_MSG_DEBUG ("Propagation successful ");
  else
    ATH_MSG_DEBUG ("Propagation failed ");
 
  return param;
}

extrapolate() [6/8]

const Trk::TrackParameters * TBExtrapolTrackToCaloTool::extrapolate ( const Trk::TrackParticleBase & , const CaloCell_ID::CaloSample , const double , const Trk::PropDirection = Trk::alongMomentum, const Trk::ParticleHypothesis = Trk::undefined ) const

inline

Definition at line 150 of file TBExtrapolTrackToCaloTool.h.

                                                      {std::cout<<"Not Implemented !!!!"<<std::endl; return 0;}

extrapolate() [7/8]

virtual const Trk::NeutralParameters * TBExtrapolTrackToCaloTool::extrapolate ( const xAOD::NeutralParticle & , const CaloCell_ID::CaloSample , const double , const Trk::PropDirection = Trk::alongMomentum ) const

inlinevirtual

get Trk::NeutralParameters at the calorimeter sample from xAOD::NeutralParticle

Definition at line 176 of file TBExtrapolTrackToCaloTool.h.

    {std::cout<<"Not Implemented !!!!"<<std::endl; return 0;}

extrapolate() [8/8]

virtual const Trk::TrackParameters * TBExtrapolTrackToCaloTool::extrapolate ( const xAOD::TrackParticle & , const CaloCell_ID::CaloSample , const double , const Trk::PropDirection = Trk::alongMomentum, const Trk::ParticleHypothesis = Trk::undefined ) const

inlinevirtual

Definition at line 168 of file TBExtrapolTrackToCaloTool.h.

      {std::cout<<"Not Implemented !!!!"<<std::endl; return 0;}

finalize()

StatusCode TBExtrapolTrackToCaloTool::finalize ( )

overridevirtual

Definition at line 115 of file TBExtrapolTrackToCaloTool.cxx.

{
    StatusCode sc = StatusCode::SUCCESS;
    return sc;
}

getCaloDepth()

CaloDepthTool * TBExtrapolTrackToCaloTool::getCaloDepth

(

)

access to the private tool used to define the extrapolation depth, needed to play with delta-eta

Definition at line 412 of file TBExtrapolTrackToCaloTool.cxx.

{
  if (m_calosurf==0) return nullptr;
  
  // getCaloDepth from the surface builder
  return m_calosurf->getCaloDepth();
}

getImpactInCalo() [1/4]

virtual ImpactInCalo * TBExtrapolTrackToCaloTool::getImpactInCalo ( const Trk::NeutralParameters & , Trk::ParticleHypothesis , const Trk::PropDirection = Trk::alongMomentum ) const

inlinevirtual

Definition at line 215 of file TBExtrapolTrackToCaloTool.h.

                                                             {std::cout<<"Not Implemented !!!!"<<std::endl; return 0;}

getImpactInCalo() [2/4]

ImpactInCalo * TBExtrapolTrackToCaloTool::getImpactInCalo ( const Trk::Track & , const Trk::ParticleHypothesis = Trk::undefined, const Trk::PropDirection = Trk::alongMomentum ) const

inline

Definition at line 203 of file TBExtrapolTrackToCaloTool.h.

                                                                                    {std::cout<<"Not Implemented !!!!"<<std::endl; return 0;}

getImpactInCalo() [3/4]

virtual ImpactInCalo * TBExtrapolTrackToCaloTool::getImpactInCalo ( const Trk::TrackParameters & , Trk::ParticleHypothesis , const Trk::PropDirection = Trk::alongMomentum ) const

inlinevirtual

Definition at line 211 of file TBExtrapolTrackToCaloTool.h.

                                                             {std::cout<<"Not Implemented !!!!"<<std::endl; return 0;}

getImpactInCalo() [4/4]

ImpactInCalo * TBExtrapolTrackToCaloTool::getImpactInCalo ( const Trk::TrackParticleBase & , const Trk::ParticleHypothesis = Trk::undefined, const Trk::PropDirection = Trk::alongMomentum ) const

inline

Definition at line 207 of file TBExtrapolTrackToCaloTool.h.

                                                                                    {std::cout<<"Not Implemented !!!!"<<std::endl; return 0;}

getMomentumAtVertex()

Amg::Vector3D TBExtrapolTrackToCaloTool::getMomentumAtVertex ( const xAOD::Vertex & vertex, bool  ) const

virtual

Definition at line 503 of file TBExtrapolTrackToCaloTool.cxx.

{
  const EventContext& ctx = Gaudi::Hive::currentContext();
  Amg::Vector3D momentum(0., 0., 0.);  
  if (vertex.vxTrackAtVertexAvailable())
  {
    // Use the parameters at the vertex 
    // (the tracks should be parallel but we will do the sum anyway)
    for (const auto& trkAtVertex : vertex.vxTrackAtVertex())
    {
      const Trk::TrackParameters* paramAtVertex = trkAtVertex.perigeeAtVertex();
      if (!paramAtVertex)
        ATH_MSG_WARNING("VxTrackAtVertex does not have perigee at vertex");
      else
        momentum += paramAtVertex->momentum();
    }
  }
  else if (vertex.nTrackParticles() == 1)
  {
    // Use the first measurement
    const xAOD::TrackParticle *tp = vertex.trackParticle(0);
    unsigned int index(0);
    if (!tp || !tp->indexOfParameterAtPosition(index, xAOD::FirstMeasurement))
    {
      ATH_MSG_WARNING("No TrackParticle or no have first measurement");
    }
    else
      momentum += tp->curvilinearParameters(index).momentum();
    // OR last 3 values of trackParameters(index)
  }
  else
  {
    // Extrapolate track particles to vertex
    // (the tracks should be parallel but we will do the sum anyway)
    const Trk::PerigeeSurface *surface = new Trk::PerigeeSurface(vertex.position());
    for (unsigned int i = 0; i < vertex.nTrackParticles(); ++i)
    {
      const xAOD::TrackParticle* tp = vertex.trackParticle( i );
      if (!tp)
      {
        ATH_MSG_WARNING("NULL pointer to TrackParticle in vertex");
        continue;
      }
      const Trk::TrackParameters* params = m_extrapolator->extrapolate(ctx, 
                                                                       tp->perigeeParameters(), 
                                                                       *surface, 
                                                                       Trk::alongMomentum).release();
      if (!params)
        ATH_MSG_DEBUG("Extrapolation to vertex (perigee) failed");
      else
      {
        momentum += params->momentum();
        delete params;
      }
    }
    delete surface;
  }
 
  return momentum;
}

getParametersInCalo() [1/5]

virtual const DataVector< const Trk::NeutralParameters > * TBExtrapolTrackToCaloTool::getParametersInCalo ( const Trk::NeutralParameters & , Trk::ParticleHypothesis , const Trk::PropDirection = Trk::alongMomentum ) const

inlinevirtual

Definition at line 186 of file TBExtrapolTrackToCaloTool.h.

                                                      {std::cout<<"Not Implemented !!!!"<<std::endl; return 0;}

getParametersInCalo() [2/5]

virtual const DataVector< const Trk::TrackParameters > * TBExtrapolTrackToCaloTool::getParametersInCalo ( const Trk::Track & , const Trk::ParticleHypothesis = Trk::undefined, const Trk::PropDirection = Trk::alongMomentum ) const

inlinevirtual

Definition at line 194 of file TBExtrapolTrackToCaloTool.h.

                                                      {std::cout<<"Not Implemented !!!!"<<std::endl; return 0;}

getParametersInCalo() [3/5]

virtual const DataVector< const Trk::TrackParameters > * TBExtrapolTrackToCaloTool::getParametersInCalo ( const Trk::TrackParameters & , Trk::ParticleHypothesis , const Trk::PropDirection = Trk::alongMomentum ) const

inlinevirtual

Definition at line 182 of file TBExtrapolTrackToCaloTool.h.

                                                      {std::cout<<"Not Implemented !!!!"<<std::endl; return 0;}

getParametersInCalo() [4/5]

virtual const DataVector< const Trk::TrackParameters > * TBExtrapolTrackToCaloTool::getParametersInCalo ( const Trk::TrackParticleBase & , const Trk::ParticleHypothesis = Trk::undefined, const Trk::PropDirection = Trk::alongMomentum ) const

inlinevirtual

Definition at line 190 of file TBExtrapolTrackToCaloTool.h.

                                                      {std::cout<<"Not Implemented !!!!"<<std::endl; return 0;}

getParametersInCalo() [5/5]

virtual const DataVector< const Trk::TrackParameters > * TBExtrapolTrackToCaloTool::getParametersInCalo ( const xAOD::TrackParticle & , const Trk::ParticleHypothesis = Trk::undefined, const Trk::PropDirection = Trk::alongMomentum ) const

inlinevirtual

Definition at line 198 of file TBExtrapolTrackToCaloTool.h.

                                                                                 {std::cout<<"Not Implemented !!!!"<<std::endl; return 0;}

initialize()

StatusCode TBExtrapolTrackToCaloTool::initialize ( )

overridevirtual

Definition at line 56 of file TBExtrapolTrackToCaloTool.cxx.

{
 
  // at this point the joboption should have been read
  ATH_CHECK(m_caloMgrKey.initialize());
  ATH_CHECK(detStore()->retrieve(m_calo_id,"CaloCell_ID"));
  
  
    
  ATH_MSG_DEBUG ( " getting started ");
 
 
    
  // Get TrkExtrapolator from ToolService
  StatusCode s=m_extrapolator.retrieve();
    
  if (s.isFailure())
    {
      ATH_MSG_FATAL ( "Could not find Tool " 
            << m_extrapolator.name() << " with parent " << m_extrapolator.parentName() );
      return s;
    } else
    {
      ATH_MSG_INFO ( "Successfully retrieved tool  " << m_extrapolator.typeAndName()  << " with parent " << m_extrapolator.parentName() ) ;
    }
 
 
  IAlgTool* tool;    
  s = toolSvc()->retrieveTool("TBCaloCoordinate",tool);
  if (s.isFailure())
    { 
      ATH_MSG_FATAL ("Could not find Tool TBCaloCoordinate" );
      
      return s;
    }     
  m_calo_tb_coord = dynamic_cast<ICaloCoordinateTool*>(tool);
 
 
    
  // Get the CaloSurface tool and sets the depthtool it should use:
  s=m_calosurf.retrieve();
    
  if (s.isFailure())
    { 
    ATH_MSG_FATAL ("Could not find Tool CaloSurfaceBuilder" 
               << m_calosurf.typeAndName());
    return s;
    } else {
    ATH_MSG_INFO ("Successfully retrieved Tool CaloSurfaceBuilder " 
          << m_calosurf.typeAndName());
 
  }
 
 
  StatusCode sc = StatusCode::SUCCESS;
  return sc;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

interfaceID()

const InterfaceID & TBExtrapolTrackToCaloTool::interfaceID ( )

inlinestatic

Definition at line 87 of file TBExtrapolTrackToCaloTool.h.

{ return IID_TBExtrapolTrackToCaloTool; } 

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

TrackSeenByCalo() [1/5]

bool TBExtrapolTrackToCaloTool::TrackSeenByCalo	(	const Trk::Track *	trk,
		const bool	barrel,
		const CaloCell_ID::SUBCALO	subcalo,
		const int	sampling_or_module,
		const double	offset,
		Amg::Vector3D *	pt_ctb,
		Amg::Vector3D *	pt_local )

Definition at line 312 of file TBExtrapolTrackToCaloTool.cxx.

{
 
 
  CaloCell_ID::CaloSample sample;
  CaloDetDescrManager::build_sample ( subcalo, barrel ,sampling_or_module, sample);
  return TrackSeenByCalo(trk,sample,offset,pt_ctb,pt_local);
} 

TrackSeenByCalo() [2/5]

bool TBExtrapolTrackToCaloTool::TrackSeenByCalo	(	const Trk::Track *	trk,
		const CaloCell_ID::CaloSample	sample,
		const double	offset,
		Amg::Vector3D *	pt_ctb,
		Amg::Vector3D *	pt_local )

The "do-it-all" method which combines the 3 steps.

Definition at line 207 of file TBExtrapolTrackToCaloTool.cxx.

{
 
  if (!trk) {
    ATH_MSG_WARNING ("TrackSeenByCalo Trk called with null Trk::TrackParameters*" );
    return false;
  }
 
  if (!pt_local) {
    ATH_MSG_WARNING ("TrackSeenByCalo Trk called with null Amg::Vector3D* pt_local");
    
    return false;
  }
 
  if (!pt_ctb) {
    ATH_MSG_WARNING ("TrackSeenByCalo Trk called with null Amg::Vector3D* pt_ctb");
    
    return false;
  }
 
 
  Trk::Surface* surf = 0;
  bool success = false;
  double trketa = 0.;
  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{ m_caloMgrKey };
  const CaloDetDescrManager* caloDDMgr = *caloMgrHandle;
  // Take eta of the last measured hit as best guess and create surface :
  const DataVector<const Trk::TrackParameters>* paramvec =
    trk->trackParameters();
  if (paramvec) {
    for (const Trk::TrackParameters* params : *paramvec)
      trketa = params->eta();
    surf = m_calosurf->CreateUserSurface(sample, offset, trketa, caloDDMgr);
  }
  if (!surf)
    return success;
 
  //std::cout << " here we go : " << std::endl;
  const Trk::TrackParameters* param = extrapolate(trk,surf);
 
 
  
  if(param) {
    CaloLocalPoint (param,pt_ctb, pt_local);
    success = true;
    delete param;  
  }
  delete surf;
 
  return success;
}

TrackSeenByCalo() [3/5]

bool TBExtrapolTrackToCaloTool::TrackSeenByCalo	(	const Trk::Track *	trk,
		const CaloCell_ID::CaloSample	sample,
		const double	offset,
		Amg::Vector3D *	pt_ctb,
		Amg::Vector3D *	pt_local,
		double &	trketa_atcalo,
		double &	trkphi_atcalo )

Definition at line 342 of file TBExtrapolTrackToCaloTool.cxx.

{
 
 
  if (!trk) {
    ATH_MSG_WARNING ("TrackSeenByCalo Trk called with null Trk::TrackParameters*" );
    return false;
  }
 
  if (!pt_local) {
    ATH_MSG_WARNING ("TrackSeenByCalo Trk called with null Amg::Vector3D* pt_local" ) ;
    return false;
  }
 
  if (!pt_ctb) {
    ATH_MSG_WARNING ("TrackSeenByCalo Trk called with null Amg::Vector3D* pt_ctb" );
    return false;
  }
 
  Trk::Surface* surf = 0;
  bool success = false;
  double trketa = 0.;
  
  // Take eta of the last measured hit as best guess and create surface :
  const DataVector<const Trk::TrackParameters>* paramvec =
    trk->trackParameters();
  if (paramvec) {
    SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{ m_caloMgrKey };
    if ((*caloMgrHandle)->lar_geometry() == "H8") {
      trketa = m_calo_tb_coord->beam_local_eta();
    } else {
      for (const Trk::TrackParameters* params : *paramvec)
        trketa = params->eta();
    }
 
    surf = m_calosurf->CreateUserSurface(sample, offset, trketa, (*caloMgrHandle));
  }
  if (!surf)
    return success;
 
  const Trk::TrackParameters* param = extrapolate(trk,surf);
  
 
  
  if(param) {
    CaloLocalPoint (param,pt_ctb, pt_local);
    trketa_atcalo = param->eta();
    if ( sin(param->parameters()[Trk::phi]) > 0.)
      trkphi_atcalo = std::acos(cos(param->parameters()[Trk::phi]));
    else 
      trkphi_atcalo = -1. * std::acos(cos(param->parameters()[Trk::phi]));
    trkphi_atcalo = m_range.fix(trkphi_atcalo);
    success = true;
    delete param;  
  }
  else {
    trketa_atcalo = 999999.;
    trkphi_atcalo = 999999.;
  }
  delete surf;
  
  return success;
}

TrackSeenByCalo() [4/5]

bool TBExtrapolTrackToCaloTool::TrackSeenByCalo	(	const Trk::TrackParameters *	parm,
		const bool	barrel,
		const CaloCell_ID::SUBCALO	subcalo,
		const int	sampling_or_module,
		const double	offset,
		Amg::Vector3D *	pt_ctb,
		Amg::Vector3D *	pt_local )

Definition at line 328 of file TBExtrapolTrackToCaloTool.cxx.

{
  CaloCell_ID::CaloSample sample;
  CaloDetDescrManager::build_sample ( subcalo, barrel ,sampling_or_module, sample);
  return TrackSeenByCalo(parm,sample,offset,pt_ctb,pt_local);
} 

TrackSeenByCalo() [5/5]

bool TBExtrapolTrackToCaloTool::TrackSeenByCalo	(	const Trk::TrackParameters *	parm,
		const CaloCell_ID::CaloSample	sample,
		const double	offset,
		Amg::Vector3D *	pt_ctb,
		Amg::Vector3D *	pt_local )

Definition at line 264 of file TBExtrapolTrackToCaloTool.cxx.

{
  bool success = false;
 
 
  if (!parm) {
    ATH_MSG_WARNING ("TrackSeenByCalo TrkParam called with null Trk::TrackParameters*" );
    return false;
  }
 
  if (!pt_local) {
 
    ATH_MSG_WARNING("TrackSeenByCalo TrkParam called with null Amg::Vector3D* pt_local" );
    return false;
  }
 
  if (!pt_ctb) {
    ATH_MSG_WARNING ("TrackSeenByCalo TrkParam called with null Amg::Vector3D* pt_ctb" );
    return false;
  }
 
 
  // Take eta as best guess of track direction and create surface :
  double trketa = parm->eta();
  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{ m_caloMgrKey };
  const CaloDetDescrManager* caloDDMgr = *caloMgrHandle;
  Trk::Surface* surf = m_calosurf->CreateUserSurface (sample,offset,trketa,caloDDMgr);
  if (!surf) return success;
 
  const Trk::TrackParameters* resparam = extrapolate(parm,surf);
 
 
  
  if(resparam) {
    CaloLocalPoint (resparam,pt_ctb, pt_local);
    success = true;
    delete resparam;  
  }
  delete surf;
 
  return success;
} 

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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* TBExtrapolTrackToCaloTool::m_calo_id {nullptr}

private

Definition at line 248 of file TBExtrapolTrackToCaloTool.h.

{nullptr};

m_calo_tb_coord

ICaloCoordinateTool* TBExtrapolTrackToCaloTool::m_calo_tb_coord {nullptr}

private

Definition at line 249 of file TBExtrapolTrackToCaloTool.h.

{nullptr};

m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> TBExtrapolTrackToCaloTool::m_caloMgrKey

private

Initial value:

{ this
      , "CaloDetDescrManager"
      , "CaloDetDescrManager"
      , "SG Key for CaloDetDescrManager in the Condition Store" }

Definition at line 243 of file TBExtrapolTrackToCaloTool.h.

                                                        { this
      , "CaloDetDescrManager"
      , "CaloDetDescrManager"
      , "SG Key for CaloDetDescrManager in the Condition Store" };

m_calosurf

ToolHandle<ICaloSurfaceBuilder> TBExtrapolTrackToCaloTool::m_calosurf

private

Definition at line 254 of file TBExtrapolTrackToCaloTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extrapolator

ToolHandle< Trk::IExtrapolator > TBExtrapolTrackToCaloTool::m_extrapolator

private

Definition at line 258 of file TBExtrapolTrackToCaloTool.h.

m_range

CaloPhiRange TBExtrapolTrackToCaloTool::m_range

private

Definition at line 251 of file TBExtrapolTrackToCaloTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• TBExtrapolTrackToCaloTool.h
• TBExtrapolTrackToCaloTool.cxx