TrackDepositInCaloTool Class Reference

Tool to get the energy that is deposited by a particle in the calorimeter. More...

#include <TrackDepositInCaloTool.h>

Inheritance diagram for TrackDepositInCaloTool:

Collaboration diagram for TrackDepositInCaloTool:

Classes
struct	Hists
struct	LayerMaps

Public Member Functions
	TrackDepositInCaloTool (const std::string &type, const std::string &name, const IInterface *pInterface)
virtual	~TrackDepositInCaloTool ()=default
StatusCode	initialize () override
std::vector< DepositInCalo >	getDeposits (const Trk::TrackParameters *par, const CaloCellContainer *caloCellCont) const override
	Fills the vector of DepositInCalo using TrackParameters as input.
std::vector< DepositInCalo >	getDeposits (const xAOD::TrackParticle *tp, const CaloCellContainer *caloCellCont, const CaloExtensionCollection *extensionCache) const override
std::vector< DepositInCalo >	deposits (const Trk::TrackParameters *par, const CaloCellContainer *cellContainer) const override
Trk::Surface *	createSurface (const CaloDetDescriptor *descr, CaloSurfaceType type) const override
	Creates a Trk::Surface for a calorimeter region that is described by CaloDetDescr.
double	calcEnergy (const Trk::TrackParameters *par, const Trk::ParticleHypothesis &particleHypo) const override
	Calculate the energy using \( E^2 = m^2 + p^2 \).
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

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
std::unique_ptr< const Trk::TrackParameters >	extrapolateToSolenoid (const EventContext &ctx, const Trk::TrackParameters *par, bool oppositeMomentum=false) const
StatusCode	bookHistos ()
	Create histograms and register them to HistSvc.
const CaloCell *	getClosestCell (const CaloDetDescrManager *caloDDM, const Trk::TrackParameters *par, const CaloDetDescriptor *descr, const CaloCellContainer *cellContainer) const
	Retrieve the CaloCell for which its center is closest to the position of the particle.
const CaloCell *	getClosestCellTile (const CaloDetDescrManager *caloDDM, const Trk::TrackParameters *par, const CaloDetDescriptor *descr, const CaloCellContainer *caloCellCont) const
std::vector< const CaloCell * >	getCaloCellsForLayer (const CaloDetDescrManager *caloDDM, const CaloDetDescriptor *descr, const Trk::TrackParameters *parEntrance, const Trk::TrackParameters *parExit, const CaloCellContainer *caloCellCont) const
std::vector< const CaloCell * >	getCaloCellsForTile (const CaloDetDescrManager *caloDDM, const CaloDetDescriptor *descr, const Trk::TrackParameters *parEntrance, const Trk::TrackParameters *parExit, const CaloCellContainer *caloCellCont) const
StatusCode	getTraversedLayers (const CaloDetDescrManager *caloDDM, const Trk::TrackParameters *par, std::map< double, const CaloDetDescriptor * > &caloInfo, std::vector< Amg::Vector3D > &extrapolations) const
	This function determines which calorimeter regions the tracks traverses.
std::unique_ptr< const Trk::TrackParameters >	extrapolateToEntranceOfLayer (const EventContext &ctx, const Trk::TrackParameters *par, const CaloDetDescriptor *descr) const
std::unique_ptr< const Trk::TrackParameters >	extrapolateToExitOfLayer (const EventContext &ctx, const Trk::TrackParameters *par, const CaloDetDescriptor *descr) const
LayerMaps	initializeDetectorInfo (const CaloDetDescrManager *caloDDM) const
Hists &	getHists () const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static std::unique_ptr< Amg::Vector3D >	extrapolateR (const Amg::Vector3D &initialPosition, double phi0, double theta0, double r)
	Extrapolate track to cylinder surface along straight line.
static std::unique_ptr< Amg::Vector3D >	extrapolateZ (const Amg::Vector3D &initialPosition, double phi0, double theta0, double z)
	Extrapolate track to disc surface along straight line.
static const CaloCell *	getClosestCellLAr (const CaloDetDescrManager *caloDDM, const Trk::TrackParameters *par, const CaloDetDescriptor *descr, const CaloCellContainer *caloCellCont)
static double	distance (const Amg::Vector3D &p1, const Amg::Vector3D &p2)
static bool	isInsideDomain (double position, double domainCenter, double domainWidth, bool phiVariable=false)
static bool	isInsideCell (const Amg::Vector3D &position, const CaloCell *cell)
static bool	inCell (const CaloCell *cell, const Amg::Vector3D &pos)

Private Attributes
ServiceHandle< ITHistSvc >	m_histSvc
ToolHandle< Trk::IExtrapolator >	m_extrapolator {this, "ExtrapolatorHandle", ""}
const TileDetDescrManager *	m_tileDDM {nullptr}
ToolHandle< Trk::IParticleCaloExtensionTool >	m_caloExtensionTool
ToolHandle< Rec::IParticleCaloCellAssociationTool >	m_caloCellAssociationTool {this, "ParticleCaloCellAssociationTool", ""}
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloDetDescrMgrKey
bool	m_doExtr
	Flag to perform extrapolations using m_extrapolator.
bool	m_doHist
	Flag to write histograms to track performance.
CxxUtils::CachedValue< LayerMaps >	m_layerMaps
std::unique_ptr< Hists >	m_h
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

Tool to get the energy that is deposited by a particle in the calorimeter.

The core method of this tool is the deposits function that returns a std::vector of DepositInCalo. All other methods are essentially helper functions for this one.

Author

Gustavo.Ordonez.Sanz Gusta.nosp@m.vo.O.nosp@m.rdone.nosp@m.z.Sa.nosp@m.nz@ce.nosp@m.rn.c.nosp@m.h

Marcel Raas marce.nosp@m.lra@.nosp@m.cern..nosp@m.ch

Definition at line 41 of file TrackDepositInCaloTool.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

TrackDepositInCaloTool()

TrackDepositInCaloTool::TrackDepositInCaloTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	pInterface )

Definition at line 43 of file TrackDepositInCaloTool.cxx.

                                                                                                                         :
    AthAlgTool(type, name, pInterface),
    m_histSvc("THistSvc", name) {
    declareInterface<ITrackDepositInCaloTool>(this);
    declareProperty("doExtrapolation", m_doExtr = true);
    declareProperty("doEDeposHist", m_doHist = false);
}

~TrackDepositInCaloTool()

virtual TrackDepositInCaloTool::~TrackDepositInCaloTool ( )

virtualdefault

Member Function Documentation

bookHistos()

StatusCode TrackDepositInCaloTool::bookHistos ( )

private

Create histograms and register them to HistSvc.

Definition at line 1007 of file TrackDepositInCaloTool.cxx.

                                              {
    ATH_MSG_DEBUG("Booking the ROOT Histos");
    if (SG::getNSlots() > 1) {
      ATH_MSG_FATAL("Filling histograms not supported in MT jobs.");
      return StatusCode::FAILURE;
    }
    ATH_CHECK( m_histSvc.retrieve() );
 
    m_h = std::make_unique<Hists>();
    ATH_CHECK( m_h->book (*m_histSvc) );
    return StatusCode::SUCCESS;
}

calcEnergy()

double TrackDepositInCaloTool::calcEnergy ( const Trk::TrackParameters * par, const Trk::ParticleHypothesis & particleHypo ) const

override

Calculate the energy using \( E^2 = m^2 + p^2 \).

Parameters

par	Input TrackParameters
particleHypo	Particle type. This determines the mass.

Definition at line 629 of file TrackDepositInCaloTool.cxx.

                                                                                                                        {
    double mass = Trk::ParticleMasses::mass[particleHypo];
    if (!par) return 0.;
    double pX = par->momentum().x();
    double pY = par->momentum().y();
    double pZ = par->momentum().z();
    return std::sqrt(mass * mass + pX * pX + pY * pY + pZ * pZ);
}

createSurface()

Trk::Surface * TrackDepositInCaloTool::createSurface ( const CaloDetDescriptor * descr, CaloSurfaceType type ) const

override

Creates a Trk::Surface for a calorimeter region that is described by CaloDetDescr.

Works for both cylindrical and disc-like surfaces. The side of a cylindrical detector element is a disc and vice-versa. Don't forget to clear memory. CaloSurfaceType can be Entrance, Middle, Exit, Inside, Outside. Inside is the boundary of the region closest to the center of the detector, outside is the boundary that is furthest away.

Parameters

descr	The CaloDetDescriptor for the surface that you want to create.
type	What type of surface to create.

Definition at line 831 of file TrackDepositInCaloTool.cxx.

                                                                                                            {
    /*
    Creates a Calorimeter surface for parameter descr. For barrel layers CaloSurfaceType Entrance, Middle and Exit yield
    a Trk::CylinderSurface. For CaloSurfaceTypes Inside and Outside the result will be a Trk::DiscSurface. Inside in
    this case is the smallest abs(z) and Outside the largest abs(z) for the two possible sides. For EndCap layers,
    Inside is the cylinder surface with smallest radius, and Outside the one with the largest radius. It all makes sense
    when you realize that CaloTrkMuId extrapolates a track outwards from the Inner Detector. The ownership of the
    transforms is passed to the Trk::Surface result.
    */
    Trk::Surface* res = nullptr;
    if (descr->is_tile() || descr->is_lar_em_barrel()) {
        // --- Cylindrical calo elements ---
        if (type >= Entrance && type <= Exit) {
            double thickness = descr->calo_r_max() - descr->calo_r_min();
            double halfLength = (descr->calo_z_max() - descr->calo_z_min()) / 2;
            double middle = descr->calo_z_min() + halfLength;
            double radius = type / 2.0 * thickness + descr->calo_r_min();
            // ATH_MSG_INFO("r = " << radius << " for type " << type << " and sample " << descr->getSampling());
            //    HepGeom::Transform3D* trans = new HepGeom::Translate3D(0,0,descr->calo_sign()*middle);
            res = new Trk::CylinderSurface(Amg::Transform3D(Amg::Translation3D(0., 0., descr->calo_sign() * middle)), radius, halfLength);
            return res;
        } else if (type == Inside || type == Outside) {
            double offset;
            if (type == Inside) {
                offset = descr->calo_z_min() * descr->calo_sign();
            } else {
                offset = descr->calo_z_max() * descr->calo_sign();
            }
            res = new Trk::DiscSurface(Amg::Transform3D(Amg::Translation3D(0., 0., offset)), descr->calo_r_min(), descr->calo_r_max());
            return res;
        } else {
            ATH_MSG_WARNING("Type error in CaloTrkMuIdDetStore::createSurface().");
            return nullptr;
        }
    } else {
        // --- Disc-like calo elements (EndCap) ---
        if (type >= Entrance && type <= Exit) {
            double thickness = descr->calo_z_max() - descr->calo_z_min();
            double offset = descr->calo_sign() * (thickness * type / 2.0 + descr->calo_z_min());
            res = new Trk::DiscSurface(Amg::Transform3D(Amg::Translation3D(0., 0., offset)), descr->calo_r_min(), descr->calo_r_max());
            return res;
        } else if (type == Inside || type == Outside) {
            double radius;
            if (type == Inside) {
                radius = descr->calo_r_min();
            } else {
                radius = descr->calo_r_max();
            }
            double halfLength = (descr->calo_z_max() - descr->calo_z_min()) / 2.0;
            double offset = descr->calo_sign() * (descr->calo_z_min() + halfLength);
            res = new Trk::CylinderSurface(Amg::Transform3D(Amg::Translation3D(0., 0., offset)), radius, halfLength);
            return res;
        } else {
            ATH_MSG_WARNING("Type error in CaloTrkMuIdDetStore::createSurface().");
            return nullptr;
        }
    }
    return nullptr;
}

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

deposits()

std::vector< DepositInCalo > TrackDepositInCaloTool::deposits ( const Trk::TrackParameters * par, const CaloCellContainer * cellContainer ) const

override

Definition at line 478 of file TrackDepositInCaloTool.cxx.

                                                                                                                                     {
    /*
       This method retrieves a vector of DepositInCalo (sample, energy, energyloss, et) containing one entry for each
       calorimeter sample traversed. The method is written for muons which are MIPs, so they don't shower very much. This is the
       reason why only the one sample is returned that is closest to the muon track.
       The algorithm for finding the deposits works as follows. First a preselection is done by getTraversedLayers(). This returns
       a vector of CaloDetDescriptors*. From these CaloDetDescriptors surfaces are built to which the extrapolator extrapolates
       the track parameters . The extrapolator first tries to hit the entrance surface, but if it fails it will try to hit the
       sides. From there on, the track is extrapolated to the middle of the Calorimeter and the CaloCell that is closest to this point
       is retrieved using the function getClosestCell. Eventually the parameters are extrapolated to the exit, or outer side of the
       sample.
     */
    ATH_MSG_DEBUG("In TrackDepositInCaloTool::deposits()");
    std::vector<DepositInCalo> result;
    const EventContext& ctx = Gaudi::Hive::currentContext();
 
    // --- Possible crash prevention ---
    if (!par) { return result; }
 
    SG::ReadCondHandle<CaloDetDescrManager> caloDetDescrMgrHandle{ m_caloDetDescrMgrKey, ctx };
    if (!caloDetDescrMgrHandle.isValid()) {
      return result;
    }
 
    const CaloDetDescrManager* caloDDM = *caloDetDescrMgrHandle;
 
    const Trk::ParticleHypothesis muonHypo = Trk::muon;
    bool checkBoundary = true;
 
    // --- Preselection of track's crossing with detector elements ---
    std::vector<Amg::Vector3D> extrapolations;
    std::map<double, const CaloDetDescriptor*> caloInfo;
    std::unique_ptr<const Trk::TrackParameters> parAtSolenoid = extrapolateToSolenoid(ctx, par);
    if (parAtSolenoid) {
        if (getTraversedLayers(caloDDM, parAtSolenoid.get(), caloInfo, extrapolations).isFailure()) {
            ATH_MSG_WARNING("Failure in finding getTraversedLayers. ");
            return result;
        }
    } else {
        ATH_MSG_WARNING("Failure in extrapolating to solenoid surface.");
        return result;
    }
    // --- Loop over the cells from preselection ---
    std::vector<Amg::Vector3D>::iterator itP = extrapolations.begin();
    for (const std::pair<const double, const CaloDetDescriptor*>& it : caloInfo) {
        // --- Initialization of variables to be determined below ---
        double energyEntrance{0}, energyExit{0}, energyDeposit{0}, ETDeposit{0}, energyLoss{0};
        bool eLossFound = false;
        const CaloDetDescriptor* descr = it.second;
        CaloCell_ID::CaloSample sample = descr->getSampling();
        ATH_MSG_VERBOSE("Analysing crossing of calo sample " << sample << " ");
 
        // --- Extrapolate to entrance of layer ---
        std::unique_ptr<const Trk::Surface> surfEntrance{createSurface(descr, Entrance)};
        if (!surfEntrance) {
            continue;
            ATH_MSG_VERBOSE("Could not create entrance surface.");
        }
        std::unique_ptr<const Trk::TrackParameters> paramEntrance{
            m_extrapolator->extrapolate(ctx, *par, *surfEntrance, Trk::alongMomentum, !checkBoundary, muonHypo)};
        if (!paramEntrance) {
            ATH_MSG_VERBOSE("Could not extrapolate to entrance of calo.");
            continue;
        }
        const Amg::Vector3D& posVecEntrance = paramEntrance->position();
        if (!surfEntrance->isOnSurface(posVecEntrance, checkBoundary)) {
            std::unique_ptr<Trk::Surface> surfInside{createSurface(descr, Inside)};
            if (surfInside) {
                std::unique_ptr<const Trk::TrackParameters> paramOnInside{
                    m_extrapolator->extrapolate(ctx, *paramEntrance, *surfInside, Trk::alongMomentum, checkBoundary, muonHypo)};
                if (paramOnInside) {
                    ATH_MSG_VERBOSE("Succesfully extrapolated to inner side of calo for sample " << sample);
                    paramEntrance.swap(paramOnInside);
                } else {
                    ATH_MSG_WARNING("Extrapolation failed to inner side of calo " << sample);
                }
            } else {
                ATH_MSG_WARNING("Could not create surface for inside of calo for sample " << sample);
            }
        }
        energyEntrance = calcEnergy(paramEntrance.get(), muonHypo);
        // --- Extrapolate to middle of layer ---
        std::unique_ptr<Trk::Surface> surfMiddle{createSurface(descr, Middle)};
        if (surfMiddle) {
            std::unique_ptr<const Trk::TrackParameters> paramMiddle{
                m_extrapolator->extrapolate(ctx, *paramEntrance, *surfMiddle, Trk::alongMomentum, checkBoundary, muonHypo)};
            if (paramMiddle) {
                // Get energy:
                const CaloCell* cell = getClosestCell(caloDDM, paramMiddle.get(), descr, cellContainer);
                if (cell) {
                    energyDeposit = cell->energy();
                    ETDeposit = cell->et();
                }
                // --- Extrapolate to exit of layer ---
                std::unique_ptr<Trk::Surface> surfExit{createSurface(descr, Exit)};
                std::unique_ptr<const Trk::TrackParameters> paramExit;
                if (surfExit) {
                    paramExit = m_extrapolator->extrapolate(ctx, *paramMiddle, *surfExit, Trk::alongMomentum, checkBoundary, muonHypo);
                    if (paramExit) {
                        ATH_MSG_VERBOSE("Extrapolated to exit. ");
                        energyExit = calcEnergy(paramExit.get(), muonHypo);
                        eLossFound = true;
                    } else {
                        // Try to extrapolate to outside
                        std::unique_ptr<Trk::Surface> surfOutside{createSurface(descr, Outside)};
                        if (surfOutside) {
                            paramExit = 
                                m_extrapolator->extrapolate(ctx, *paramMiddle, *surfOutside, Trk::alongMomentum, checkBoundary, muonHypo);
                            if (paramExit) {
                                ATH_MSG_VERBOSE("Succesfully extrapolated to outer side of calo for sample " << sample);
                                energyExit = calcEnergy(paramExit.get(), muonHypo);
                                eLossFound = true;
                            } else {
                                ATH_MSG_VERBOSE("Could not extrapolate to exit of calo.");
                            }
                        } else {
                            ATH_MSG_WARNING("Could not create surface for outside of calo for sample " << sample);
                        }
                    }
                } else {
                    ATH_MSG_WARNING("Could not create exit surface.");
                }
 
            } else {
                ATH_MSG_VERBOSE("Could not extrapolate to middle of calo.");
            }
        } else {
            ATH_MSG_VERBOSE("Could not create middle surface.");
        }
 
        energyLoss = eLossFound ? -(energyExit - energyEntrance) : 0;
        result.emplace_back(sample, energyDeposit, energyLoss, ETDeposit);
        ATH_MSG_DEBUG("Sample: " << sample << "\tEnergyDeposit: " << energyDeposit << "\tEnergyLoss: " << energyLoss);
 
        if (m_doHist) {
            Hists& h = getHists();
            h.m_hParELossEta->Fill(energyLoss, itP->eta());
            h.m_hParELossSample->Fill(energyLoss, sample);
        }
 
        // itP++;
        // it++;
    }
 
    ATH_MSG_VERBOSE("---TRACKDEPOSITINCALOTOOL---TRACKDEPOSITINCALOTOOL---TRACKDEPOSITINCALOTOOL");
    return result;
}

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

distance()

double TrackDepositInCaloTool::distance ( const Amg::Vector3D & p1, const Amg::Vector3D & p2 )

staticprivate

Definition at line 1124 of file TrackDepositInCaloTool.cxx.

                                                                                    {
    double diff_x = p1.x() - p2.x();
    double diff_y = p1.y() - p2.y();
    double diff_z = p1.z() - p2.z();
    return std::hypot(diff_x, diff_y, diff_z);
}

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

extrapolateR()

std::unique_ptr< Amg::Vector3D > TrackDepositInCaloTool::extrapolateR ( const Amg::Vector3D & initialPosition, double phi0, double theta0, double r )

staticprivate

Extrapolate track to cylinder surface along straight line.

(x0, y0, z0) is the starting position, (phi0,theta0) is the direction of the momentum, r is the bound of the cylinder. The values are returned in (xe, ye, ze).

Definition at line 701 of file TrackDepositInCaloTool.cxx.

                                                                              {
    double x0 = initialPosition.x();
    double y0 = initialPosition.y();
    double z0 = initialPosition.z();
 
    double b = 2 * x0 * std::cos(phi0) + 2 * y0 * std::sin(phi0);
    double c = x0 * x0 + y0 * y0 - r * r;
    double det = b * b - 4 * c;
    double lsin = 0;
    if (det < 0) {
        return nullptr;
    } else
        lsin = (-b + std::sqrt(det)) / 2;
 
    double xe = x0 + lsin * std::cos(phi0);
    double ye = y0 + lsin * std::sin(phi0);
    double ze = z0 + lsin * std::cos(theta0) / std::sin(theta0);
 
    if (std::abs(xe * xe + ye * ye - r * r) > 10 && det > 0) {
        // ATH_MSG_WARNING("ExtrapoateR(): extrapolation did not succeed!");
        return nullptr;
    }
    // ATH_MSG_INFO("ExtrapolateR(): Extrapolation succeeded.");
    return std::make_unique<Amg::Vector3D>(xe, ye, ze);
}

extrapolateToEntranceOfLayer()

std::unique_ptr< const Trk::TrackParameters > TrackDepositInCaloTool::extrapolateToEntranceOfLayer ( const EventContext & ctx, const Trk::TrackParameters * par, const CaloDetDescriptor * descr ) const

private

Definition at line 361 of file TrackDepositInCaloTool.cxx.

                                                                                                                                       {
    // --- Initialization ---
    std::unique_ptr<const Trk::TrackParameters> paramEntrance;
    bool checkBoundary = true;
    Trk::ParticleHypothesis muonHypo = Trk::muon;
 
    std::unique_ptr<Trk::Surface> surfEntrance{createSurface(descr, Entrance)};
    if (!surfEntrance) {
        ATH_MSG_DEBUG("Error in extrapolateToBeginOfLayer()");
        return nullptr;
    }
    // --- Try to extrapolate to entrance ---
    paramEntrance = m_extrapolator->extrapolate(ctx, *par, *surfEntrance, Trk::alongMomentum, !checkBoundary, muonHypo);
    if (!paramEntrance) {
        ATH_MSG_DEBUG("Extrapolation to entrance failed without boundary check.");
        return nullptr;
    }
    const Amg::Vector3D& posVecEntrance = paramEntrance->position();
    // --- If the parameters are not on surface, extrapolate to side of calorimeter ---
    if (surfEntrance->isOnSurface(posVecEntrance, checkBoundary)) {
        ATH_MSG_VERBOSE("Successfully extrapolated to entrance of calo for sample " << descr->getSampling());
        return paramEntrance;
    }
    std::unique_ptr<Trk::Surface> surfInside{createSurface(descr, Inside)};
    if (surfInside) {
        std::unique_ptr<const Trk::TrackParameters> paramOnInside{
            m_extrapolator->extrapolate(ctx, *paramEntrance, *surfInside, Trk::alongMomentum, checkBoundary, muonHypo)};
        if (paramOnInside) {
            ATH_MSG_VERBOSE("Successfully extrapolated to inner side of calo for sample " << descr->getSampling());
            paramEntrance.swap(paramOnInside);
        } else {
            ATH_MSG_DEBUG("Extrapolation to entrance failed!");
            return nullptr;
        }
    }
    return paramEntrance;
}

extrapolateToExitOfLayer()

std::unique_ptr< const Trk::TrackParameters > TrackDepositInCaloTool::extrapolateToExitOfLayer ( const EventContext & ctx, const Trk::TrackParameters * par, const CaloDetDescriptor * descr ) const

private

Definition at line 404 of file TrackDepositInCaloTool.cxx.

                                                                                                                                   {
    std::unique_ptr<const Trk::TrackParameters> paramExit;
    bool checkBoundary = true;
    Trk::ParticleHypothesis muonHypo = Trk::muon;
 
    // --- Create surface parallel to layer ---
    std::unique_ptr<Trk::Surface> surfExit{createSurface(descr, Exit)};
    if (!surfExit) {
        ATH_MSG_WARNING("Could not create exit surface.");
        return nullptr;
    }
    // --- Try to extrapolate to exit of layer ---
    paramExit = m_extrapolator->extrapolate(ctx, *par, *surfExit, Trk::alongMomentum, checkBoundary, muonHypo);
    if (paramExit) {
        ATH_MSG_VERBOSE("Extrapolated to exit. ");
        return paramExit;
    }
    // --- Try to extrapolate to side ---
    std::unique_ptr<Trk::Surface> surfOutside{createSurface(descr, Outside)};
    if (!surfOutside) { return nullptr; }
    paramExit = m_extrapolator->extrapolate(ctx, *par, *surfOutside, Trk::alongMomentum, checkBoundary, muonHypo);
    if (paramExit) {
        ATH_MSG_VERBOSE("Succesfully extrapolated to outer side of calo for sample " << descr->getSampling());
    } else {
        ATH_MSG_VERBOSE("Could not extrapolate to exit of calo.");
    }
    return paramExit;
}

extrapolateToSolenoid()

std::unique_ptr< const Trk::TrackParameters > TrackDepositInCaloTool::extrapolateToSolenoid ( const EventContext & ctx, const Trk::TrackParameters * par, bool oppositeMomentum = false ) const

private

Definition at line 438 of file TrackDepositInCaloTool.cxx.

                                                                                                                       {
    Trk::PropDirection direction = Trk::alongMomentum;
    if (oppositeMomentum) { direction = Trk::oppositeMomentum; }
 
    // --- First extrapolate to solenoid radius or EndCap disk ---
    // --- Ownership of the HepTransform3Ds is passed to the Surfaces ---
    constexpr double halfLengthOfCylinder = 3700;
    bool checkBoundary = true;
    Trk::CylinderSurface solenoid(solenoidRadius, halfLengthOfCylinder);
    Trk::ParticleHypothesis muonHypo = Trk::muon;
 
    std::unique_ptr<const Trk::TrackParameters> parAtSolenoid{
        m_extrapolator->extrapolate(ctx, *par, solenoid, direction, checkBoundary, muonHypo)};
    if (!parAtSolenoid) {
        // --- Guess EndCap side by direction ---
        double zTrans = par->eta() > 0 ? halfLengthOfCylinder : -halfLengthOfCylinder;
        Trk::DiscSurface disc(Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., zTrans))), 0, solenoidRadius);
 
        parAtSolenoid = m_extrapolator->extrapolate(ctx, *par, disc, direction, checkBoundary, muonHypo);
 
        if (!parAtSolenoid) {
            ATH_MSG_VERBOSE("extrapolateToSolenoid(): Extrapolation to cap of solenoid failed. Trying opposite side.");
            Trk::DiscSurface discOpp(Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., -zTrans))), 0, solenoidRadius);
            parAtSolenoid = m_extrapolator->extrapolate(ctx, *par, discOpp, direction, checkBoundary, muonHypo);
        }
 
        if (parAtSolenoid) { ATH_MSG_VERBOSE("extrapolateToSolenoid(): Extrapolation succeeded for disc-type surface."); }
 
    } else {
        ATH_MSG_VERBOSE("extrapolateToSolenoid(): Extrapolation succeeded for cylinder-type surface.");
    }
 
    return parAtSolenoid;
}

extrapolateZ()

std::unique_ptr< Amg::Vector3D > TrackDepositInCaloTool::extrapolateZ ( const Amg::Vector3D & initialPosition, double phi0, double theta0, double z )

staticprivate

Extrapolate track to disc surface along straight line.

Parameter explanation in the same line as for extrapolateR().

Definition at line 731 of file TrackDepositInCaloTool.cxx.

                                                                              {
    double x0 = initialPosition.x();
    double y0 = initialPosition.y();
    double z0 = initialPosition.z();
    double cosTheta0 = std::cos(theta0);
    if (cosTheta0) {
        double dist = z - z0;
        double lambda = dist / cosTheta0;
        if (lambda < 0) {
            // ATH_MSG_WARNING("ExtrapolateZ(): extrapolation did not succeed!");
            return nullptr;
        }
        double xe = x0 + lambda * std::sin(theta0) * std::cos(phi0);
        double ye = y0 + lambda * std::sin(theta0) * std::sin(phi0);
        double ze = z;
        // ATH_MSG_INFO("ExtrapolateZ(): Extrapolation succeeded.");
        return std::make_unique<Amg::Vector3D>(xe, ye, ze);
    } else {
        // ATH_MSG_WARNING("ExtrapolateZ(): extrapolation did not succeed!");
        return nullptr;
    }
}

getCaloCellsForLayer()

std::vector< const CaloCell * > TrackDepositInCaloTool::getCaloCellsForLayer ( const CaloDetDescrManager * caloDDM, const CaloDetDescriptor * descr, const Trk::TrackParameters * parEntrance, const Trk::TrackParameters * parExit, const CaloCellContainer * caloCellCont ) const

private

Definition at line 234 of file TrackDepositInCaloTool.cxx.

                                                                                                                       {
  if (descr->is_tile()) {
    // --- Tile implemention is lengthy and therefore put in seperate function
    // ---
    return getCaloCellsForTile(caloDDM, descr, parEntrance, parExit, caloCellCont);
  } else {
    // --- LAr implementation is short, quick and simple ---
    const CaloCell* cellEntrance =
      getClosestCellLAr(caloDDM, parEntrance, descr, caloCellCont);
    const CaloCell* cellExit =
      getClosestCellLAr(caloDDM, parExit, descr, caloCellCont);
    std::vector<const CaloCell*> result;
    result.push_back(cellEntrance);
    if (cellEntrance != cellExit) {
      result.push_back(cellExit);
    }
    return result;
  }
}

getCaloCellsForTile()

std::vector< const CaloCell * > TrackDepositInCaloTool::getCaloCellsForTile ( const CaloDetDescrManager * caloDDM, const CaloDetDescriptor * descr, const Trk::TrackParameters * parEntrance, const Trk::TrackParameters * parExit, const CaloCellContainer * caloCellCont ) const

private

Definition at line 261 of file TrackDepositInCaloTool.cxx.

                                                                                                                      {
    /*
      ...to be written...
    */
    ATH_MSG_VERBOSE("in getCaloCellsForTileLayer()...");
 
    std::vector<const CaloCell*> result{};
    // --- Get all the relevant kinematical variables ---
    double phiPar = parEntrance->position().phi();
    double phiParEntrance = phiPar;
    double zParEntrance = parEntrance->position().z();
    double phiParExit = parExit->position().phi();
    double zParExit = parExit->position().z();
    double diffZPar = zParExit - zParEntrance;
    double etaPar = parEntrance->position().eta();
    // --- Determine granularity ---
    double etaWidth = 2 * (descr->calo_eta_max() - descr->calo_eta_min()) / descr->n_eta();
    double etaMin = etaPar - etaWidth;
    double etaMax = etaPar + etaWidth;
    double phiWidth = (descr->calo_phi_max() - descr->calo_phi_min()) / descr->n_phi();
    // TODO: HOW TO DEAL WITH PHI ~ PI?
    double phiMin = phiPar - phiWidth;
    double phiMax = phiPar + phiWidth;
    // --- Fill vecHash ---
    CaloCell_ID::CaloSample sample = descr->getSampling();
 
    std::vector<IdentifierHash> vecHash;
    caloDDM->cellsInZone(etaMin, etaMax, phiMin, phiMax, sample, vecHash);
 
    // --- Iterate and find closest to track (around 12-15 elements in loop) ---
    std::map<double, const CaloCell*> neighbourMap0;
    std::map<double, const CaloCell*> neighbourMap1;
 
    for (const IdentifierHash& id : vecHash) {
        const CaloCell* cell = caloCellCont->findCell(id);
        if (!cell) continue;
        const CaloDetDescrElement* dde = cell->caloDDE();
        if (!dde) continue;
 
        double dPhiCell = dde->dphi();
        double phiCellMin = dde->phi() - dPhiCell / 2;
        double phiCellMax = phiCellMin + dPhiCell;
        if (!(phiParEntrance > phiCellMin && phiParExit < phiCellMax) && !(phiParExit > phiCellMin && phiParExit < phiCellMax)) {
            continue;
        }
 
        // --- There are two z dimensions for the BC cells ---
        double zCellMin0{0}, zCellMax0{0}, zCellMin1{0}, zCellMax1{0};
        TileCellDim* cellDim = m_tileDDM->get_cell_dim(cell->ID());
        if (!cellDim) {
            ATH_MSG_WARNING("TileCellDim object not found for cell " << cell->ID());
            continue;
        }
        // --- This is valid for the BC cells ---
        if (cellDim->getNRows() == 6) {
            zCellMin0 = cellDim->getZMin(0);
            zCellMax0 = cellDim->getZMax(0);
            zCellMin1 = cellDim->getZMin(3);
            zCellMax1 = cellDim->getZMax(3);
        } else {
            zCellMin0 = cellDim->getZMin(0);
            zCellMax0 = cellDim->getZMax(0);
            zCellMin1 = zCellMin0;
            zCellMax1 = zCellMax0;
        }
 
        // --- Check wether entrance parameters are within cell acceptance at entrance ---
        // --- The equal signs (>=, <=) are very important for the boundary cells ---
        if (zParEntrance >= zCellMin0 && zParEntrance <= zCellMax0 && phiParEntrance > phiCellMin && phiParEntrance < phiCellMax) {
            result.push_back(cell);
            continue;
        }
        // --- Check wether exit parameters are within cell acceptance at exit ---
        if (zParExit >= zCellMin1 && zParExit <= zCellMax1 && phiParExit > phiCellMin && phiParExit < phiCellMax) {
            result.push_back(cell);
            continue;
        }
        // --- Check wether it crosses a cell ---
        if (diffZPar > 0) {
            if (zParEntrance < zCellMin0 && zParExit > zCellMax1) {
                result.push_back(cell);
                continue;
            }
        } else {
            if (zParEntrance > zCellMax0 && zParExit < zCellMin1) {
                result.push_back(cell);
                continue;
            }
        }
    }
    return result;
}

getClosestCell()

const CaloCell * TrackDepositInCaloTool::getClosestCell ( const CaloDetDescrManager * caloDDM, const Trk::TrackParameters * par, const CaloDetDescriptor * descr, const CaloCellContainer * cellContainer ) const

private

Retrieve the CaloCell for which its center is closest to the position of the particle.

Parameters

par	TrackParameters of the particle.
descr	Calorimeter detector region information. Only cells from this detector region are considered.

Definition at line 895 of file TrackDepositInCaloTool.cxx.

{
  /*
  Get closest cell near the TrackParameters par. For LAr this can be done using the get_element function of the
  CaloDetDescrManager. This should be really fast since it is nothing more than a sequence of lookups.
  For the non-projective tile cells one has to select cells in a certain (eta,phi) region and then select the one
  that is closest to the track.
  */
 
  const CaloCell* cell = nullptr;
  if (descr->is_tile()) {
    cell = getClosestCellTile(caloDDM, par, descr, caloCellCont);
  } else {
    cell = getClosestCellLAr(caloDDM, par, descr, caloCellCont);
  }
  return cell;
}

getClosestCellLAr()

const CaloCell * TrackDepositInCaloTool::getClosestCellLAr ( const CaloDetDescrManager * caloDDM, const Trk::TrackParameters * par, const CaloDetDescriptor * descr, const CaloCellContainer * caloCellCont )

staticprivate

Definition at line 920 of file TrackDepositInCaloTool.cxx.

{
  CaloCell_ID::CaloSample sample = descr->getSampling();
  // ATH_MSG_INFO("Sampling = " << sample);
  const CaloDetDescrElement* cellDescr = caloDDM->get_element(sample, par->position().eta(), par->position().phi());
  if (cellDescr) {
    IdentifierHash hash = cellDescr->calo_hash();
    const CaloCell* cell = caloCellCont->findCell(hash);
    return cell;
  }
  return nullptr;
}

getClosestCellTile()

const CaloCell * TrackDepositInCaloTool::getClosestCellTile ( const CaloDetDescrManager * caloDDM, const Trk::TrackParameters * par, const CaloDetDescriptor * descr, const CaloCellContainer * caloCellCont ) const

private

Definition at line 940 of file TrackDepositInCaloTool.cxx.

{
  std::map<double, const CaloCell*> neighbourMap;
  const CaloCell* result = nullptr;
  // --- Determine granularity ---
  double etaPar = par->position().eta();
  double phiPar = par->position().phi();
  double etaWidth = 2 * (descr->calo_eta_max() - descr->calo_eta_min()) / descr->n_eta();
  double etaMin = etaPar - etaWidth;
  double etaMax = etaPar + etaWidth;
  double phiWidth = (descr->calo_phi_max() - descr->calo_phi_min()) / descr->n_phi();
  // TODO: HOW TO DEAL WITH PHI ~ PI?
  double phiMin = phiPar - phiWidth;
  double phiMax = phiPar + phiWidth;
  // --- Fill vecHash ---
  CaloCell_ID::CaloSample sample = descr->getSampling();
 
  // Cannot do this in initialize: see ATLASRECTS-5012
 
  std::vector<IdentifierHash> vecHash;
  caloDDM->cellsInZone(etaMin, etaMax, phiMin, phiMax, sample, vecHash);
 
  // --- Iterate and find closest to track (around 12-15 elements in loop) ---
  double dR2Min{ 999 };
  for (const IdentifierHash& id : vecHash) {
    const CaloCell* cell = caloCellCont->findCell(id);
    if (!cell)
      continue;
 
    const CaloDetDescrElement* dde = cell->caloDDE();
    if (!dde)
      continue;
    const double etaCell = dde->eta();
    const double phiCell = dde->phi();
    const double dEta = etaPar - etaCell;
    const double dPhi = xAOD::P4Helpers::deltaPhi(phiPar, phiCell);
    const double dR2 = dEta * dEta + dPhi * dPhi;
    neighbourMap[sqrt(dR2)] = cell;
    if (dR2 < dR2Min) {
      dR2Min = dR2;
      result = cell;
    }
  }
 
  // --- Show deposits near this track (only if debugMode is on) ---
  if (msgLevel(MSG::VERBOSE)) {
    ATH_MSG_INFO("SAMPLE = " << sample);
    for (const std::pair<const double, const CaloCell*>& mapIt : neighbourMap) {
      const CaloCell* cell = mapIt.second;
      double distance = mapIt.first;
      if (cell) {
        ATH_MSG_VERBOSE("dR2 = " << distance << ", energy = " << cell->energy());
      } else {
        ATH_MSG_VERBOSE("dR2 = " << distance << ", NULL pointer!");
      }
    }
  }
  return result;
}

getDeposits() [1/2]

std::vector< DepositInCalo > TrackDepositInCaloTool::getDeposits ( const Trk::TrackParameters * par, const CaloCellContainer * caloCellCont ) const

override

Fills the vector of DepositInCalo using TrackParameters as input.

Parameters

par	TrackParameters to be used as input. The parameters are assumed to be within the solenoid volume.
deltaR	Unused parameter. Kept for backward compatibility.
inCell	Unused parameter. Kept for backward compatibility.

Definition at line 70 of file TrackDepositInCaloTool.cxx.

                                                                                                            {
    const EventContext& ctx = Gaudi::Hive::currentContext();
    ATH_MSG_DEBUG("In TrackDepositInCaloTool::getDeposits()");
    std::vector<DepositInCalo> result;
 
    // --- from now on, par can be assumed to exist ---
    if (!par) { return result; }
 
    if (!caloCellCont) return result;
 
    SG::ReadCondHandle<CaloDetDescrManager> caloDetDescrMgrHandle{ m_caloDetDescrMgrKey,ctx };
    if (!caloDetDescrMgrHandle.isValid()) {
      return result;
    }
 
    const CaloDetDescrManager* caloDDM = *caloDetDescrMgrHandle;
 
    const Trk::ParticleHypothesis muonHypo = Trk::muon;
 
    // --- Preselection of track's crossing with detector elements ---
    std::vector<Amg::Vector3D> extrapolations;
    std::map<double, const CaloDetDescriptor*> caloInfo;
    std::unique_ptr<const Trk::TrackParameters> currentPar = extrapolateToSolenoid(ctx, par);
    if (!currentPar) {
        ATH_MSG_WARNING("Extrapolation to solenoid did not succeed!");
        return result;
    }
    if (getTraversedLayers(caloDDM,currentPar.get(), caloInfo, extrapolations).isFailure()) {
        ATH_MSG_WARNING("Failure in getTraversedLayers(). ");
        return result;
    }
 
    // --- Iterate over all the detector regions ---
    for (const std::pair<const double, const CaloDetDescriptor*>& detDescrIt : caloInfo) {
        const CaloDetDescriptor* descr = detDescrIt.second;
        // ---- extrapolate to entrance of layer ---
        std::unique_ptr<const Trk::TrackParameters> parEntrance = extrapolateToEntranceOfLayer(ctx, currentPar.get(), descr);
        if (!parEntrance) {
            ATH_MSG_DEBUG("Could not extrapolate to entrance.");
            continue;
        }
        // ---- extrapolate to exit of layer ---
        std::unique_ptr<const Trk::TrackParameters> parExit = extrapolateToExitOfLayer(ctx, parEntrance.get(), descr);
        if (!parExit) {
            ATH_MSG_DEBUG("Could not extrapolate to exit.");
            // delete parEntrance;
            currentPar.swap(parEntrance);
            continue;
        }
        // --- Calculate energy loss ---
        double energyLoss = calcEnergy(parEntrance.get(), muonHypo) - calcEnergy(parExit.get(), muonHypo);
        double distance = (parEntrance->position() - parExit->position()).mag();
        // --- Retrieve crossed cells ---
        std::vector<const CaloCell*> cells =
          getCaloCellsForLayer(caloDDM, descr, parEntrance.get(), parExit.get(), caloCellCont);
 
        // --- Add contributions ---
        double sumEnergy = 0;
        double sumEt = 0;
        for (const CaloCell* cell : cells) {
            if (cell) {
                sumEnergy += cell->energy();
                sumEt += cell->et();
            } else {
                ATH_MSG_VERBOSE("Cell NULL pointer found!");
            }
        }
        // --- Write DepositInCalo ---
        ATH_MSG_DEBUG("Energy = " << sumEnergy << " for sample " << descr->getSampling() << " in " << cells.size() << " cells.");
        if (distance) { result.emplace_back(descr->getSampling(), sumEnergy, energyLoss, sumEt); }
 
        // --- Free memory and prepare for next round ---
        currentPar.swap(parEntrance);
    }
    return result;
}

getDeposits() [2/2]

std::vector< DepositInCalo > TrackDepositInCaloTool::getDeposits ( const xAOD::TrackParticle * tp, const CaloCellContainer * caloCellCont, const CaloExtensionCollection * extensionCache ) const

override

Definition at line 151 of file TrackDepositInCaloTool.cxx.

                                                                                                                    {
    ATH_MSG_DEBUG("In TrackDepositsInCaloTool::getDeposits() - new");
    std::vector<DepositInCalo> result;
    const unsigned int nSamples = CaloSampling::getNumberOfSamplings();
 
    // - associate calocells to trackparticle, cone size 0.2, use cache
 
    std::unique_ptr<const Rec::ParticleCellAssociation> association =
        m_caloCellAssociationTool->particleCellAssociation(*tp, 0.2, caloCellCont, extensionCache);
 
    if (!association) return result;
    ATH_MSG_VERBOSE(" particleCellAssociation done  " << association.get());
 
    // - pick up the cell intersections
 
    std::vector<std::pair<const CaloCell*, Rec::ParticleCellIntersection*>> cellIntersections = association->cellIntersections();
 
    const Trk::CaloExtension& caloExtension = association->caloExtension();
 
    if (!caloExtension.caloEntryLayerIntersection()) {
        ATH_MSG_WARNING(" No caloEntryLayerIntersection found ");
        return result;
    }
 
    ATH_MSG_DEBUG(" nr of cell intersections " << cellIntersections.size());
    if (cellIntersections.size() < 3) ATH_MSG_WARNING(" Strange nr of calorimeter cell intersections " << cellIntersections.size());
 
    CaloExtensionHelpers::EntryExitLayerMap entryExitLayerMap;
    CaloExtensionHelpers::entryExitLayerMap(caloExtension, entryExitLayerMap);
    ATH_MSG_VERBOSE("EntryExitLayerMap " << entryExitLayerMap.size());
 
    CaloExtensionHelpers::ScalarLayerMap eLossLayerMap;
    CaloExtensionHelpers::eLossLayerMap(caloExtension, eLossLayerMap);
    ATH_MSG_VERBOSE("eLossLayerMap " << eLossLayerMap.size());
 
    std::vector<float> exp_E(nSamples, 0.0);
    std::vector<float> meas_E(nSamples, 0.0);
    std::vector<float> meas_Et(nSamples, 0.0);
    std::vector<int> LayerHit(nSamples, 0);
    CaloSampling::CaloSample sample;
    Amg::Vector3D lEntry, lExit;
 
    // loop over cellIntersections, there can be more than one cell hit in a layer
 
    for (auto& it : cellIntersections) {
        const CaloCell* curr_cell = it.first;
        if (curr_cell->badcell()) continue;
        int cellSampling = curr_cell->caloDDE()->getSampling();
        CaloSampling::CaloSample sample = static_cast<CaloSampling::CaloSample>(cellSampling);
        // bool badCell     = curr_cell->badcell();
        auto pos = entryExitLayerMap.find(sample);
        if (pos == entryExitLayerMap.end()) continue;
        lEntry = pos->second.first;
        lExit = pos->second.second;
        if (TrackDepositInCaloTool::inCell(curr_cell, lEntry) || TrackDepositInCaloTool::inCell(curr_cell, lExit)) {
            meas_E[cellSampling] += Float_t(curr_cell->energy());
            meas_Et[cellSampling] += Float_t(curr_cell->energy() * curr_cell->sinTh());
            exp_E[cellSampling] = Float_t((it.second)->expectedEnergyLoss());
            LayerHit[cellSampling]++;
            ATH_MSG_VERBOSE(" Layer : " << cellSampling << "   Energy = " << curr_cell->energy()
                                        << " Exp : " << (it.second)->expectedEnergyLoss());
        }
    }
 
    // sum cells per layer and fill samples per layer
 
    for (int i = CaloSampling::PreSamplerB; i < CaloSampling::CaloSample::Unknown; i++) {
        if (LayerHit[i] > 0) {
            sample = static_cast<CaloSampling::CaloSample>(i);
            result.emplace_back(sample, meas_E[i], exp_E[i], meas_Et[i]);
            ATH_MSG_DEBUG(" Layer : " << sample << "   Energy = " << meas_E[i] << " nCells : " << LayerHit[i] << " Exp: " << exp_E[i]);
        }
    }
 
    return result;
}

getHists()

TrackDepositInCaloTool::Hists & TrackDepositInCaloTool::getHists ( ) const

private

Definition at line 1070 of file TrackDepositInCaloTool.cxx.

{
  // We earlier checked that no more than one thread is being used.
  Hists* h ATLAS_THREAD_SAFE = m_h.get();
  return *h;
}

getTraversedLayers()

StatusCode TrackDepositInCaloTool::getTraversedLayers ( const CaloDetDescrManager * caloDDM, const Trk::TrackParameters * par, std::map< double, const CaloDetDescriptor * > & caloInfo, std::vector< Amg::Vector3D > & extrapolations ) const

private

This function determines which calorimeter regions the tracks traverses.

The vector caloInfo and extrapolations are returned. Straight line approximation is employed in the calorimeter regions after the parameters are extrapolated to the surface of the solenoid. This accounts for the magnetic field bending. Covers EMB, TileBar, TileExt, EME and HEC acceptance. The FCAL and TileGap regions are not included. Do not forget to check the StatusCode.

Parameters

par	Input track parameters
caloInfo	Resulting vector of CaloDetDescriptor that is traversed.
extrapolations	Resulting vector of straight-line extrapolations that were obtained.

Definition at line 758 of file TrackDepositInCaloTool.cxx.

                                                                                                    {
    // Cannot do this in initialize: see ATLASRECTS-5012
    if (!m_layerMaps.isValid()) {
      m_layerMaps.set (initializeDetectorInfo (caloDDM));
    }
    const LayerMaps& layerMaps = *m_layerMaps.ptr();
 
    const Trk::TrackParameters* parAtSolenoid = nullptr;
    // --- To be replaced by a check, possibly extrapolating to solenoid surface if needed ---
    bool parIsAtSolenoid = true;
    if (parIsAtSolenoid) parAtSolenoid = par;
 
    // --- This performs a straight line extrapolation and determines wether it is in calorimeter layer acceptance. ---
    if (parAtSolenoid) {
        // ATH_MSG_INFO("Parameters at solenoid are well-defined.");
 
        double deltaR_solLast = std::abs(parAtSolenoid->position().perp() - par->position().perp());
        double deltaEta_solLast = std::abs(parAtSolenoid->position().eta() - par->position().eta());
        if (m_doHist) {
            Hists& h = getHists();
            h.m_hDeltaEtaLastPar->Fill(deltaEta_solLast);
            h.m_hDeltaRadiusLastPar->Fill(deltaR_solLast);
        }
 
        const Amg::Vector3D positionAtSolenoid = parAtSolenoid->position();
        double theta0 = parAtSolenoid->momentum().theta();
        double phi0 = parAtSolenoid->momentum().phi();
 
        // --- This Code fragment determines the Barrel crossings ---
        for (const std::pair<const double, std::vector<const CaloDetDescriptor*>>& mapIt : layerMaps.m_barrelLayerMap) {
            const double& radius = mapIt.first;
            std::unique_ptr<Amg::Vector3D> extrapolation = extrapolateR(positionAtSolenoid, phi0, theta0, radius);
            if (!extrapolation) { continue; }
            for (const CaloDetDescriptor* descr : mapIt.second) {
                double zSigned = extrapolation->z() * descr->calo_sign();
                if (zSigned >= descr->calo_z_min() && zSigned <= descr->calo_z_max()) {
                    double distance = (*extrapolation - positionAtSolenoid).mag();
                    caloInfo[distance] = descr;
                    extrapolations.emplace_back(*extrapolation);
                }
            }
        }
 
        // This code fragment determines the EndCap crossings
        for (const std::pair<const double, std::vector<const CaloDetDescriptor*>>& mapIt : layerMaps.m_endCapLayerMap) {
            const double& zCenter = mapIt.first;
            for (const CaloDetDescriptor* descr : mapIt.second) {
                double z = zCenter * descr->calo_sign();
                std::unique_ptr<Amg::Vector3D> extrapolation = extrapolateZ(positionAtSolenoid, phi0, theta0, z);
                if (!extrapolation) continue;
 
                double radius = extrapolation->perp();
                if (radius >= descr->calo_r_min() && radius <= descr->calo_r_max()) {
                    double distance = (*extrapolation - positionAtSolenoid).mag();
                    caloInfo[distance] = descr;
                    extrapolations.emplace_back(*extrapolation);
                }
            }
        }
 
    } else {
        return StatusCode::FAILURE;
    }
 
    return StatusCode::SUCCESS;
}

inCell()

bool TrackDepositInCaloTool::inCell ( const CaloCell * cell, const Amg::Vector3D & pos )

staticprivate

Definition at line 1115 of file TrackDepositInCaloTool.cxx.

                                                                                {
    bool result = std::abs(CaloPhiRange::diff(pos.phi(), cell->phi())) < cell->caloDDE()->dphi() / 2;
    if (cell->caloDDE()->getSubCalo() != CaloCell_ID::TILE)
        result &= std::abs(pos.eta() - cell->eta()) < cell->caloDDE()->deta() / 2;
    else if (cell->caloDDE()->getSampling() != CaloCell_ID::TileBar1)  // still need to deal with tilebar1
        result &= std::abs(pos.z() - cell->z()) < cell->caloDDE()->dz() / 2;
    return result;
}

initialize()

StatusCode TrackDepositInCaloTool::initialize ( )

override

Definition at line 54 of file TrackDepositInCaloTool.cxx.

                                              {
    ATH_CHECK(detStore()->retrieve(m_tileDDM));
    if (!m_tileDDM) { return StatusCode::FAILURE; }
    if (m_doHist) { ATH_CHECK(bookHistos()); }
 
    ATH_CHECK(m_extrapolator.retrieve());
    ATH_CHECK(m_caloExtensionTool.retrieve());
    ATH_CHECK(m_caloCellAssociationTool.retrieve());
    ATH_CHECK(m_caloDetDescrMgrKey.initialize());
    ATH_MSG_INFO("initialize() successful in " << name());
    return StatusCode::SUCCESS;
}

initializeDetectorInfo()

TrackDepositInCaloTool::LayerMaps TrackDepositInCaloTool::initializeDetectorInfo ( const CaloDetDescrManager * caloDDM ) const

private

Definition at line 642 of file TrackDepositInCaloTool.cxx.

                                                                                       {
    LayerMaps maps;
 
    ATH_MSG_DEBUG("In CaloTrkMuIdDetStore::initialize()");
    // Initialize LAr
    for (const CaloDetDescriptor* descr : caloDDM->calo_descriptors_range()) {
        if (descr) {
            CaloCell_ID::CaloSample sample = descr->getSampling();
            ATH_MSG_VERBOSE("Detector Description element for sample " << sample);
            if (descr->is_lar_em_barrel()) {
                ATH_MSG_VERBOSE("  this is a cylindrical detector element.");
                double thickness = descr->calo_r_max() - descr->calo_r_min();
                double r = descr->calo_r_min() + thickness / 2.0;
                ATH_MSG_VERBOSE("  R = " << r);
                ATH_MSG_VERBOSE("  sign = " << descr->calo_sign());
                ATH_MSG_VERBOSE("  range_low  = " << descr->calo_z_min());
                ATH_MSG_VERBOSE("  range_high = " << descr->calo_z_max());
                if (sample != CaloCell_ID::PreSamplerB) maps.m_barrelLayerMap[r].push_back(descr);
            } else {
                ATH_MSG_VERBOSE("  this is a disk-like detector element.");
                double thickness = descr->calo_z_max() - descr->calo_z_min();
                double z = descr->calo_z_min() + thickness / 2.0;
                ATH_MSG_VERBOSE("  Z = " << z);
                ATH_MSG_VERBOSE("  sign = " << descr->calo_sign());
                ATH_MSG_VERBOSE("  range_low  = " << descr->calo_r_min());
                ATH_MSG_VERBOSE("  range_high = " << descr->calo_r_max());
                if (sample != CaloCell_ID::PreSamplerE) { maps.m_endCapLayerMap[z].push_back(descr); }
            }
        } else
            ATH_MSG_VERBOSE("CaloDetDescriptor was not available!");
    }
 
    ATH_MSG_VERBOSE("Processing tiles... ");
    for (const CaloDetDescriptor* descr : caloDDM->tile_descriptors_range()) {
        if (descr) {
            ATH_MSG_VERBOSE("Detector Description element for sample " << descr->getSampling());
            if (!descr->is_tile()) { ATH_MSG_VERBOSE("This is not a isTile()==true element."); }
            CaloCell_ID::CaloSample sample = descr->getSampling();
            if (sample >= 15 && sample <= 17) {
                // --- Skip the TileGap detector elements ---
                continue;
            }
            ATH_MSG_VERBOSE("  this is a cylindrical detector element.");
            double thickness = descr->calo_r_max() - descr->calo_r_min();
            double r = descr->calo_r_min() + thickness / 2.0;
            ATH_MSG_VERBOSE("  r = " << r);
            ATH_MSG_VERBOSE("  sign = " << descr->calo_sign());
            ATH_MSG_VERBOSE("  range_low  = " << descr->calo_z_min());
            ATH_MSG_VERBOSE("  range_high = " << descr->calo_z_max());
            maps.m_barrelLayerMap[r].push_back(descr);
        } else
            ATH_MSG_VERBOSE("CaloDetDescriptor was not available!");
    }
    return maps;
}

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.

isInsideCell()

bool TrackDepositInCaloTool::isInsideCell ( const Amg::Vector3D & position, const CaloCell * cell )

staticprivate

Definition at line 1098 of file TrackDepositInCaloTool.cxx.

                                                                                           {
    const CaloDetDescrElement* dde = cell->caloDDE();
    if (!dde) return false;
    if (dde->is_tile()) {
        if (!isInsideDomain(position.z(), dde->z(), dde->dz())) return false;
    } else {
        if (!isInsideDomain(position.eta(), dde->eta(), dde->eta())) return false;
    }
    if (!isInsideDomain(position.phi(), dde->phi(), dde->dphi(), true)) { return false; }
    // if (!isInsideDomain(position.r(), dde->r(), dde->dr()))
    //   return false;
    return true;
}

isInsideDomain()

bool TrackDepositInCaloTool::isInsideDomain ( double position, double domainCenter, double domainWidth, bool phiVariable = false )

staticprivate

Definition at line 1081 of file TrackDepositInCaloTool.cxx.

                                                                                                                      {
    double halfWidth = domainWidth / 2;
    if (phiVariable) {
        if (std::abs(std::abs(domainCenter) - M_PI) < domainWidth) {
            position += M_PI;
            domainCenter += M_PI;
            if (position > M_PI) { position -= 2 * M_PI; }
            if (domainCenter > M_PI) { domainCenter -= 2 * M_PI; }
        }
    }
    double boundLow = domainCenter - halfWidth;
    double boundHigh = domainCenter + halfWidth;
    if (position < boundLow) return false;
    if (position > boundHigh) return false;
    return true;
}

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.

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_caloCellAssociationTool

ToolHandle<Rec::IParticleCaloCellAssociationTool> TrackDepositInCaloTool::m_caloCellAssociationTool {this, "ParticleCaloCellAssociationTool", ""}

private

Definition at line 182 of file TrackDepositInCaloTool.h.

{this, "ParticleCaloCellAssociationTool", ""};

m_caloDetDescrMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> TrackDepositInCaloTool::m_caloDetDescrMgrKey

private

Initial value:

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

Definition at line 184 of file TrackDepositInCaloTool.h.

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

m_caloExtensionTool

ToolHandle<Trk::IParticleCaloExtensionTool> TrackDepositInCaloTool::m_caloExtensionTool

private

Initial value:

{this, "ParticleCaloExtensionTool", "",
                                                                    "Tool to make the step-wise extrapolation"}

Definition at line 180 of file TrackDepositInCaloTool.h.

                                                                 {this, "ParticleCaloExtensionTool", "",
                                                                    "Tool to make the step-wise extrapolation"};

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_doExtr

bool TrackDepositInCaloTool::m_doExtr

private

Flag to perform extrapolations using m_extrapolator.

Definition at line 192 of file TrackDepositInCaloTool.h.

m_doHist

bool TrackDepositInCaloTool::m_doHist

private

Flag to write histograms to track performance.

Definition at line 193 of file TrackDepositInCaloTool.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> TrackDepositInCaloTool::m_extrapolator {this, "ExtrapolatorHandle", ""}

private

Definition at line 176 of file TrackDepositInCaloTool.h.

{this, "ExtrapolatorHandle", ""};

m_h

std::unique_ptr<Hists> TrackDepositInCaloTool::m_h

private

Definition at line 231 of file TrackDepositInCaloTool.h.

m_histSvc

ServiceHandle<ITHistSvc> TrackDepositInCaloTool::m_histSvc

private

Definition at line 175 of file TrackDepositInCaloTool.h.

m_layerMaps

CxxUtils::CachedValue<LayerMaps> TrackDepositInCaloTool::m_layerMaps

private

Definition at line 201 of file TrackDepositInCaloTool.h.

m_tileDDM

const TileDetDescrManager* TrackDepositInCaloTool::m_tileDDM {nullptr}

private

Definition at line 178 of file TrackDepositInCaloTool.h.

{nullptr};

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:

• TrackDepositInCaloTool.h
• TrackDepositInCaloTool.cxx