Rec::MuidCaloTrackStateOnSurface Class Reference

#include <MuidCaloTrackStateOnSurface.h>

Inheritance diagram for Rec::MuidCaloTrackStateOnSurface:

Collaboration diagram for Rec::MuidCaloTrackStateOnSurface:

Public Member Functions
	MuidCaloTrackStateOnSurface (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~MuidCaloTrackStateOnSurface ()=default
StatusCode	initialize () override
StatusCode	finalize () override
std::vector< std::unique_ptr< const Trk::TrackStateOnSurface > >	caloTSOS (const EventContext &ctx, const Trk::TrackParameters &parameters) const override
	IMuidCaloTrackStateOnSurface interface: to get the 3 scattering and energy deposit TSOS'es representing the calorimeter.
std::unique_ptr< Trk::TrackStateOnSurface >	innerTSOS (const EventContext &ctx, const Trk::TrackParameters &parameters) const override
	IMuidCaloTrackStateOnSurface interface: to get individually the scattering TSOS'es representing the calorimeter.
std::unique_ptr< Trk::TrackStateOnSurface >	outerTSOS (const EventContext &ctx, const Trk::TrackParameters &parameters) const override
std::unique_ptr< Trk::TrackStateOnSurface >	middleTSOS (const EventContext &ctx, const Trk::TrackParameters &middleParameters, const Trk::TrackParameters *innerParameters, const Trk::TrackParameters *outerParameters) const override
	IMuidCaloTrackStateOnSurface interface: to get the energy deposit TSOS representing the calorimeter.
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 ()
	AlgTool and IAlgTool interface methods.

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
enum	SurfaceLayer { Inner , Middle , Outer }
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
const Trk::Surface *	getCaloSurface (const double eta, const short layer) const
std::unique_ptr< const Trk::TrackParameters >	getExtrapolatedParameters (const EventContext &ctx, const Trk::TrackParameters &parameters, const short layer) 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 bool	useEtaPhiFromDirection (const Trk::TrackParameters &parameters)

Private Attributes
ToolHandle< Rec::IMuidCaloEnergy >	m_caloEnergyDeposit
ToolHandle< Rec::IMuidCaloEnergy >	m_caloEnergyParam
ToolHandle< Rec::IMuidCaloMaterialParam >	m_caloMaterialParam
ToolHandle< Trk::IPropagator >	m_propagator
Trk::MagneticFieldProperties	m_magFieldProperties {Trk::FullField}
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCacheCondObjInputKey
double	m_minCaloRadius
double	m_minRemainingEnergy
double	m_paramPtCut
std::atomic_int	m_count {0}
std::atomic_int	m_countArbitrarySolution {0}
std::atomic_int	m_countCompleteFailure {0}
std::atomic_int	m_countInnerFailure {0}
std::atomic_int	m_countOuterFailure {0}
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

Definition at line 39 of file MuidCaloTrackStateOnSurface.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

SurfaceLayer

enum Rec::MuidCaloTrackStateOnSurface::SurfaceLayer

private

Enumerator
Inner
Middle
Outer

Definition at line 70 of file MuidCaloTrackStateOnSurface.h.

{ Inner, Middle, Outer };

Constructor & Destructor Documentation

MuidCaloTrackStateOnSurface()

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

Definition at line 38 of file MuidCaloTrackStateOnSurface.cxx.

                                                                                                                                   :
        AthAlgTool(type, name, parent),
        m_minCaloRadius(0.4 * Gaudi::Units::meter),
        m_minRemainingEnergy(0.5 * Gaudi::Units::GeV),
        m_paramPtCut(15.0 * Gaudi::Units::GeV) {
        declareInterface<IMuidCaloTrackStateOnSurface>(this);
        declareProperty("MinCaloRadius", m_minCaloRadius);
        declareProperty("MinRemainingEnergy", m_minRemainingEnergy);
        declareProperty("ParamPtCut", m_paramPtCut);
    }

~MuidCaloTrackStateOnSurface()

virtual Rec::MuidCaloTrackStateOnSurface::~MuidCaloTrackStateOnSurface ( )

virtualdefault

Member Function Documentation

caloTSOS()

std::vector< std::unique_ptr< const Trk::TrackStateOnSurface > > MuidCaloTrackStateOnSurface::caloTSOS ( const EventContext & ctx, const Trk::TrackParameters & parameters ) const

overridevirtual

IMuidCaloTrackStateOnSurface interface: to get the 3 scattering and energy deposit TSOS'es representing the calorimeter.

The input TrackParameters may be anywhere along the track.

Implements Rec::IMuidCaloTrackStateOnSurface.

Definition at line 84 of file MuidCaloTrackStateOnSurface.cxx.

                                                                             {
        std::vector<std::unique_ptr<const Trk::TrackStateOnSurface>> caloTSOS;
        caloTSOS.reserve(3);
 
        std::unique_ptr<Trk::TrackStateOnSurface> innerTS, middleTS, outerTS;
        std::unique_ptr<const Trk::TrackParameters> inParams, midParams;
        const Trk::TrackParameters* innerParams = nullptr;
        const Trk::TrackParameters* middleParams = nullptr;
        const Trk::TrackParameters* outerParams = nullptr;
 
        MagField::AtlasFieldCache fieldCache;
        // Get field cache object
        SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCacheCondObjInputKey, ctx};
        const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
 
        if (!fieldCondObj) {
            ATH_MSG_ERROR("Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCacheCondObjInputKey.key());
            return caloTSOS;
        }
        fieldCondObj->getInitializedCache(fieldCache);
 
        // track to calo surfaces - first decide in or outwards
        bool trackOutwards = true;
        if (dynamic_cast<const Trk::PerigeeSurface*>(&parameters.associatedSurface())) {
            if (parameters.associatedSurface().center().perp() > 0.5 * Gaudi::Units::meter) trackOutwards = false;
        } else if (std::abs(parameters.position().z()) > 4.0 * Gaudi::Units::meter ||
                   parameters.position().perp() > 1.2 * Gaudi::Units::meter) {
            trackOutwards = false;
        }
 
        if (trackOutwards)  // forward tracking
        {
            innerTS = innerTSOS(ctx, parameters);
            if (innerTS) {
                innerParams = innerTS->trackParameters();
                if (innerParams->momentum().dot(innerParams->position()) > 0.) {
                    midParams = getExtrapolatedParameters(ctx, *innerParams, SurfaceLayer::Middle);
                    middleParams = midParams.get();
                } else {
                    ATH_MSG_VERBOSE(" quit as looper " << innerParams);
                }
                if (middleParams) {
                    // get calo energy deposit
                    middleTS = m_caloEnergyParam->trackStateOnSurface(ctx, *midParams, innerParams, outerParams);
                    if (!middleTS) { middleParams = nullptr; }
                }
 
                if (middleParams) {
                    // apply energy deposit to give outgoing middleParams,
                    // note the iteration required to get optimum energy correction
                    std::unique_ptr<const Trk::TrackParameters> params;
                    for (int iterate = 0; iterate != 2; ++iterate) {
                        if (!middleTS) break;
 
                        const Trk::MaterialEffectsOnTrack* meot =
                            dynamic_cast<const Trk::MaterialEffectsOnTrack*>(middleTS->materialEffectsOnTrack());
                        const double energyDeposit = meot ? meot->energyLoss()->deltaE() : 0.;
                        middleParams = middleTS->trackParameters();
                        Amg::Vector3D momentum = middleParams->momentum();
                        double correctedEnergy = innerParams->momentum().mag() - energyDeposit;
 
                        // fail potential loopers
                        if (fieldCache.toroidOn() && correctedEnergy < m_minRemainingEnergy) {
                            middleTS.reset();
                            ATH_MSG_VERBOSE(" fail tracking outwards: momentum " << momentum.mag() / Gaudi::Units::GeV
                                                                                 << "   energyDeposit " << energyDeposit / Gaudi::Units::GeV
                                                                                 << "   correctedEnergy "
                                                                                 << correctedEnergy / Gaudi::Units::GeV << " (GeV units)");
                            break;
                        }
                        // toroid off: set floor for remaining energy
                        if (correctedEnergy < m_minRemainingEnergy) {
                            momentum *= m_minRemainingEnergy / momentum.mag();
                        } else {
                            momentum *= correctedEnergy / momentum.mag();
                        }
 
                        const Trk::CylinderSurface* cylinder =
                            dynamic_cast<const Trk::CylinderSurface*>(&middleParams->associatedSurface());
                        if (cylinder) {
                            params =
                                std::make_unique<Trk::AtaCylinder>(middleParams->position(), momentum, middleParams->charge(), *cylinder);
                        } else {
                            const Trk::DiscSurface* disc = dynamic_cast<const Trk::DiscSurface*>(&middleParams->associatedSurface());
                            if (disc) {
                                params = std::make_unique<Trk::AtaDisc>(middleParams->position(), momentum, middleParams->charge(), *disc);
                            } else {
                                ATH_MSG_WARNING(" caloTSOS: unexpected TrackParameters type ");
                            }
                        }
 
                        // delete middle and outer,
                        // then recompute with parameters as for backwards tracking
                        if (!params) {
                            middleTS.reset();
                        } else if (params->momentum().perp() > m_paramPtCut) {
                            middleTS = m_caloEnergyDeposit->trackStateOnSurface(ctx, *params, innerParams, outerParams);
                        } else {
                            middleTS = m_caloEnergyParam->trackStateOnSurface(ctx, *params, innerParams, outerParams);
                        }
                        if (middleTS) { outerTS = outerTSOS(ctx, *params); }
                    }
                    if (!middleTS) { ATH_MSG_VERBOSE(" fail tracking outwards: no intersect at middle surface"); }
                }
            } else {
                ATH_MSG_VERBOSE(" fail tracking ouwards: no intersect at inner surface");
            }
        } else  // backward tracking
        {
            outerTS = outerTSOS(ctx, parameters);
            if (outerTS) {
                outerParams = outerTS->trackParameters();
                midParams = getExtrapolatedParameters(ctx, *outerParams, SurfaceLayer::Middle);
                middleParams = midParams.get();
                if (middleParams) {
                    inParams = getExtrapolatedParameters(ctx, *midParams, SurfaceLayer::Inner);
                    innerParams = inParams.get();
                    if (inParams) {
                        // get calo energy deposit
                        if (middleParams->momentum().perp() > m_paramPtCut) {
                            middleTS = m_caloEnergyDeposit->trackStateOnSurface(ctx, *middleParams, inParams.get(), outerParams);
                        } else {
                            middleTS = m_caloEnergyParam->trackStateOnSurface(ctx, *middleParams, inParams.get(), outerParams);
                        }
                        // apply energy deposit
                        const Trk::MaterialEffectsOnTrack* meot =
                            middleTS ? dynamic_cast<const Trk::MaterialEffectsOnTrack*>(middleTS->materialEffectsOnTrack()) : nullptr;
                        const double energyDeposit = meot ? meot->energyLoss()->deltaE() : 0.;
                        Amg::Vector3D momentum = middleParams->momentum();
                        double correctedEnergy = momentum.mag() + energyDeposit;
 
                        // fail potential loopers
                        if (correctedEnergy < 0.5 * Gaudi::Units::GeV) {
                            middleTS.reset();
                            ATH_MSG_VERBOSE(" fail tracking inwards: momentum " << momentum.mag() / Gaudi::Units::GeV << "   energyDeposit "
                                                                                << energyDeposit / Gaudi::Units::GeV
                                                                                << "   correctedEnergy "
                                                                                << correctedEnergy / Gaudi::Units::GeV << " (GeV units)");
                        } else {
                            momentum *= 1. + energyDeposit / momentum.mag();
                            std::unique_ptr<const Trk::TrackParameters> params;
                            const Trk::CylinderSurface* cylinder =
                                dynamic_cast<const Trk::CylinderSurface*>(&middleParams->associatedSurface());
                            std::optional<AmgSymMatrix(5)> cov =
                                middleParams->covariance() ? std::optional<AmgSymMatrix(5)>(*middleParams->covariance()) : std::nullopt;
                            if (cylinder) {
                                params = std::make_unique<Trk::AtaCylinder>(middleParams->position(), momentum, middleParams->charge(),
                                                                            *cylinder, cov);
                            } else {
                                const Trk::DiscSurface* disc = dynamic_cast<const Trk::DiscSurface*>(&middleParams->associatedSurface());
                                if (disc) {
                                    params = std::make_unique<Trk::AtaDisc>(middleParams->position(), momentum, middleParams->charge(),
                                                                            *disc, cov);
                                } else {
                                    ATH_MSG_WARNING(" caloTSOS: unexpected TrackParameters type ");
                                }
                            }
                            if (params && middleTS) { innerTS = innerTSOS(ctx, *params); }
                        }
                    } else {
                        ATH_MSG_VERBOSE(" fail tracking inwards: no intersect at inner surface");
                    }
                } else {
                    ATH_MSG_VERBOSE(" fail tracking inwards: no intersect at middle surface");
                }
            }
        }
 
        if (innerTS)
            caloTSOS.push_back(std::move(innerTS));
        else
            ++m_countInnerFailure;
        if (middleTS) caloTSOS.push_back(std::move(middleTS));
        if (outerTS)
            caloTSOS.push_back(std::move(outerTS));
        else
            ++m_countOuterFailure;
 
        // keep some statistics
        ++m_count;
 
        if (caloTSOS.empty()) { ++m_countCompleteFailure; }
        return caloTSOS;
    }

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

finalize()

StatusCode MuidCaloTrackStateOnSurface::finalize ( )

override

Definition at line 73 of file MuidCaloTrackStateOnSurface.cxx.

                                                     {
        ATH_MSG_INFO("finalized with " << m_count << " muons asking for calo association, out of which: " << endmsg << "     "
                                       << m_countInnerFailure << " failed to find the inner calo scattering plane," << endmsg << "     "
                                       << m_countOuterFailure << " failed to find the outer calo scattering plane," << endmsg
                                       << "     while another " << m_countCompleteFailure
                                       << " completely failed to intersect the calorimeter." << endmsg << "     "
                                       << m_countArbitrarySolution << " with oscillation resolved by taking an arbitrary solution");
 
        return StatusCode::SUCCESS;
    }

getCaloSurface()

const Trk::Surface * MuidCaloTrackStateOnSurface::getCaloSurface ( const double eta, const short layer ) const

private

Definition at line 309 of file MuidCaloTrackStateOnSurface.cxx.

                                                                                                           {
        if (layer == SurfaceLayer::Inner) return m_caloMaterialParam->innerSurface(eta);
        if (layer == SurfaceLayer::Middle) return m_caloMaterialParam->middleSurface(eta);
        if (layer == SurfaceLayer::Outer) return m_caloMaterialParam->outerSurface(eta);
        ATH_MSG_WARNING("Invalid layer id given " << layer);
        return nullptr;
    }

getExtrapolatedParameters()

std::unique_ptr< const Trk::TrackParameters > MuidCaloTrackStateOnSurface::getExtrapolatedParameters ( const EventContext & ctx, const Trk::TrackParameters & parameters, const short layer ) const

private

The TrackParameters own their dedicated instance of the track surface... In cases, where the loop below resets the extrapolation we need to clone the surface as well this pointer is just the surface garbage collection

Definition at line 316 of file MuidCaloTrackStateOnSurface.cxx.

                                                                                                {
        // will need to know whether forward or back tracking
        Trk::PropDirection momentumDirection = Trk::alongMomentum;
        Trk::PropDirection oppositeDirection = Trk::oppositeMomentum;
        Trk::PropDirection propDirection = Trk::anyDirection;
        const std::string surf_layer_str = layer == SurfaceLayer::Inner ? "Inner" : (layer == SurfaceLayer::Middle ? "Middle" : "Outer");
        // initial surface at track eta -
        //   using position or direction according to distance from origin
        double startingPhi = 0.;
        const Trk::Surface* surface = nullptr;
        if (useEtaPhiFromDirection(parameters)) {
            startingPhi = parameters.momentum().phi();
            surface = getCaloSurface(parameters.momentum().eta(), layer);
        } else {
            startingPhi = parameters.position().phi();
            surface = getCaloSurface(parameters.position().eta(), layer);
            if (parameters.momentum().dot(parameters.position()) < 0.) {
                momentumDirection = Trk::oppositeMomentum;
                oppositeDirection = Trk::alongMomentum;
            }
        }
        if (!surface) return nullptr;
 
        // extrapolate to calo surface (take care to get correct cylinder intersect)
        unsigned extrapolations = 0;
        if (surface->type() == Trk::SurfaceType::Cylinder) {
            if (parameters.position().perp() < surface->globalReferencePoint().perp()) {
                propDirection = momentumDirection;
            } else {
                propDirection = oppositeDirection;
            }
        }
        // tidy up ownership later
        std::unique_ptr<const Trk::TrackParameters> extrapolation{
            m_propagator->propagate(ctx, parameters, *surface, propDirection, false, m_magFieldProperties, Trk::nonInteracting)};
        if (!extrapolation) return nullptr;
 
        // phi flip means track has crossed beam-axis (so quit)
        double deltaPhi = xAOD::P4Helpers::deltaPhi(extrapolation->position().phi(), startingPhi);
        if (std::abs(deltaPhi) > M_PI_2) { return nullptr; }
 
        // also quit wrong rz-direction in endcap
        if (surface->type() != Trk::SurfaceType::Cylinder) {
            double signRZ = (extrapolation->position().perp() - parameters.position().perp()) *
                            (extrapolation->position().z() - parameters.position().z());
            if (signRZ * extrapolation->position().z() < 0.) {
                ATH_MSG_VERBOSE(" wrong way in endcap ");
                return nullptr;
            }
        }
 
        // iterate if extrapolated surface is different
        bool restart = false;
        const Trk::Surface* oldSurface = surface;
        const Trk::Surface* extrapolatedSurface = getCaloSurface(extrapolation->position().eta(), layer);
        std::unique_ptr<const Trk::Surface> reset_surface;
        while (++extrapolations < 5 && extrapolatedSurface != oldSurface) {
            // take care to get correct solution for cylinder when starting from inside
            if (surface->type() == Trk::SurfaceType::Cylinder) {
                if (extrapolation->position().perp() < surface->globalReferencePoint().perp()) {
                    propDirection = momentumDirection;
                } else {
                    propDirection = oppositeDirection;
                }
            } else {
                propDirection = Trk::anyDirection;
            }
            std::unique_ptr<const Trk::TrackParameters> oldParameters = std::move(extrapolation);
            extrapolation = m_propagator->propagate(ctx, *oldParameters, *extrapolatedSurface, propDirection, false, m_magFieldProperties,
                                                    Trk::nonInteracting);
            if (!extrapolation) {
                // restart from input parameters (if not already done)
                //   trap no solution after restart
                if ((*oldParameters) == parameters) {
                    ATH_MSG_VERBOSE(" innerParameters:  extrap fails ");
                    return nullptr;
                }
                if (restart) {
                    ATH_MSG_DEBUG(surf_layer_str << " Parameters:  oscillating => arbitrary solution chosen");
                    ++m_countArbitrarySolution;
                    extrapolation = std::move(oldParameters);
                    reset_surface.reset(extrapolation->associatedSurface().clone());
                    extrapolatedSurface = reset_surface.get();
                    surface = extrapolatedSurface;
                    restart = false;
                } else {
                    ATH_MSG_VERBOSE(surf_layer_str << " Parameters:  restart extrap after " << extrapolations << " extrapolations");
                    restart = true;
                    extrapolations -= 2;
                    extrapolation = parameters.uniqueClone();
                    surface = oldSurface;
                }
            } else {
                // update surface
                ATH_MSG_DEBUG(surf_layer_str << " Parameters: Extrapolation succeeded go to next iteration");
                oldSurface = surface;
                surface = extrapolatedSurface;
                extrapolatedSurface = getCaloSurface(extrapolation->position().eta(), layer);
            }
        }
 
        // final check for phi flip
        deltaPhi = xAOD::P4Helpers::deltaPhi(extrapolation->position().phi(), startingPhi);
        if (std::abs(deltaPhi) > M_PI_2) { return nullptr; }
 
        ATH_MSG_VERBOSE(surf_layer_str << " Parameters:  success after " << extrapolations << " extrapolation step(s). "
                                       << std::setiosflags(std::ios::fixed) << "  Intersection at: r,phi,z " << std::setw(7)
                                       << std::setprecision(1) << extrapolation->position().perp() << std::setw(7) << std::setprecision(3)
                                       << extrapolation->position().phi() << std::setw(8) << std::setprecision(1)
                                       << extrapolation->position().z() << "  Direction: eta,phi " << std::setw(7) << std::setprecision(3)
                                       << extrapolation->momentum().eta() << std::setw(7) << std::setprecision(3)
                                       << extrapolation->momentum().phi());
 
        return extrapolation;
    }

initialize()

StatusCode MuidCaloTrackStateOnSurface::initialize ( )

override

handle to the magnetic field cache

Definition at line 51 of file MuidCaloTrackStateOnSurface.cxx.

                                                       {
        ATH_MSG_DEBUG("Initializing CombinedMuonTrackStateOnSurface");
 
        // get the Tools
        ATH_CHECK(m_caloEnergyDeposit.retrieve());
        ATH_MSG_DEBUG("Retrieved tool " << m_caloEnergyDeposit);
 
        ATH_CHECK(m_caloEnergyParam.retrieve());
        ATH_MSG_DEBUG("Retrieved tool " << m_caloEnergyParam);
 
        ATH_CHECK(m_caloMaterialParam.retrieve());
        ATH_MSG_DEBUG("Retrieved tool " << m_caloMaterialParam);

        ATH_CHECK(m_fieldCacheCondObjInputKey.initialize());
 
        ATH_CHECK(m_propagator.retrieve());
        ATH_MSG_DEBUG("Retrieved tool " << m_propagator);
 
        return StatusCode::SUCCESS;
    }

innerTSOS()

std::unique_ptr< Trk::TrackStateOnSurface > MuidCaloTrackStateOnSurface::innerTSOS ( const EventContext & ctx, const Trk::TrackParameters & parameters ) const

overridevirtual

IMuidCaloTrackStateOnSurface interface: to get individually the scattering TSOS'es representing the calorimeter.

The input TrackParameters may be anywhere along the track.

Implements Rec::IMuidCaloTrackStateOnSurface.

Definition at line 270 of file MuidCaloTrackStateOnSurface.cxx.

                                                                                                                                       {
        std::unique_ptr<const Trk::TrackParameters> extrapolation = getExtrapolatedParameters(ctx, parameters, SurfaceLayer::Inner);
        if (!extrapolation || extrapolation->position().perp() < m_minCaloRadius) {
            ATH_MSG_DEBUG(" innerTSOS:  extrapolation fails ");
            return nullptr;
        }
        return m_caloMaterialParam->trackStateOnSurface(*extrapolation);
    }

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 & Rec::IMuidCaloTrackStateOnSurface::interfaceID ( )

inlinestaticinherited

AlgTool and IAlgTool interface methods.

Interface ID for IMuidCaloTrackStateOnSurface

Definition at line 40 of file IMuidCaloTrackStateOnSurface.h.

                                                { 
            static const InterfaceID IID_IMuidCaloTrackStateOnSurface("IMuidCaloTrackStateOnSurface", 1, 0);
            return IID_IMuidCaloTrackStateOnSurface;
        }

middleTSOS()

std::unique_ptr< Trk::TrackStateOnSurface > MuidCaloTrackStateOnSurface::middleTSOS ( const EventContext & ctx, const Trk::TrackParameters & middleParameters, const Trk::TrackParameters * innerParameters, const Trk::TrackParameters * outerParameters ) const

overridevirtual

IMuidCaloTrackStateOnSurface interface: to get the energy deposit TSOS representing the calorimeter.

The input TrackParameters may be anywhere along the track, but when the inner or outer parameters are provided they must be expressed at the appropriate surface. The return TSOS surface is at the material midpoint.

Implements Rec::IMuidCaloTrackStateOnSurface.

Definition at line 288 of file MuidCaloTrackStateOnSurface.cxx.

                                                                                                                                         {
        std::unique_ptr<const Trk::TrackParameters> extrapolation = getExtrapolatedParameters(ctx, middleParams, SurfaceLayer::Middle);
 
        if (!extrapolation || extrapolation->position().perp() < m_minCaloRadius) {
            ATH_MSG_DEBUG(" middleTSOS:  extrapolation fails ");
            return nullptr;
        }
        std::unique_ptr<Trk::TrackStateOnSurface> TSOS;
        if (extrapolation->momentum().perp() > m_paramPtCut) {
            TSOS = m_caloEnergyDeposit->trackStateOnSurface(ctx, *extrapolation, innerParams, outerParams);
        } else {
            TSOS = m_caloEnergyParam->trackStateOnSurface(ctx, *extrapolation, innerParams, outerParams);
        }
        return TSOS;
    }

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

outerTSOS()

std::unique_ptr< Trk::TrackStateOnSurface > MuidCaloTrackStateOnSurface::outerTSOS ( const EventContext & ctx, const Trk::TrackParameters & parameters ) const

overridevirtual

Implements Rec::IMuidCaloTrackStateOnSurface.

Definition at line 279 of file MuidCaloTrackStateOnSurface.cxx.

                                                                                                                                       {
        std::unique_ptr<const Trk::TrackParameters> extrapolation = getExtrapolatedParameters(ctx, parameters, SurfaceLayer::Outer);
        if (!extrapolation || extrapolation->position().perp() < m_minCaloRadius) {
            ATH_MSG_DEBUG(" outerTSOS:  extrapolation fails ");
            return nullptr;
        }
        return m_caloMaterialParam->trackStateOnSurface(*extrapolation);
    }

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

useEtaPhiFromDirection()

bool MuidCaloTrackStateOnSurface::useEtaPhiFromDirection ( const Trk::TrackParameters & parameters )

staticprivate

Definition at line 436 of file MuidCaloTrackStateOnSurface.cxx.

                                                                                                 {
        // estimate eta,phi for the track intersect with the calo from the track direction when the
        // parameters are expressed near the beam-line, further out it's better to use the track position
        double parameterDistance = parameters.position().mag();
        if (dynamic_cast<const Trk::PerigeeSurface*>(&parameters.associatedSurface()))
            parameterDistance = parameters.associatedSurface().center().perp();
 
        return parameterDistance < 0.5 * Gaudi::Units::meter;
    }

Member Data Documentation

m_caloEnergyDeposit

ToolHandle<Rec::IMuidCaloEnergy> Rec::MuidCaloTrackStateOnSurface::m_caloEnergyDeposit

private

Initial value:

{
            this,
            "CaloEnergyDeposit",
            "Rec::MuidCaloEnergyTool/MuidCaloEnergyTool",
        }

Definition at line 80 of file MuidCaloTrackStateOnSurface.h.

                                                          {
            this,
            "CaloEnergyDeposit",
            "Rec::MuidCaloEnergyTool/MuidCaloEnergyTool",
        };

m_caloEnergyParam

ToolHandle<Rec::IMuidCaloEnergy> Rec::MuidCaloTrackStateOnSurface::m_caloEnergyParam

private

Initial value:

{
            this,
            "CaloEnergyParam",
            "Rec::MuidCaloEnergyTool/MuidCaloEnergyToolParam",
        }

Definition at line 85 of file MuidCaloTrackStateOnSurface.h.

                                                        {
            this,
            "CaloEnergyParam",
            "Rec::MuidCaloEnergyTool/MuidCaloEnergyToolParam",
        };

m_caloMaterialParam

ToolHandle<Rec::IMuidCaloMaterialParam> Rec::MuidCaloTrackStateOnSurface::m_caloMaterialParam

private

Initial value:

{
            this,
            "CaloMaterialParam",
            "Rec::MuidCaloMaterialParam/MuidCaloMaterialParam",
        }

Definition at line 90 of file MuidCaloTrackStateOnSurface.h.

                                                                 {
            this,
            "CaloMaterialParam",
            "Rec::MuidCaloMaterialParam/MuidCaloMaterialParam",
        };

m_count

std::atomic_int Rec::MuidCaloTrackStateOnSurface::m_count {0}

mutableprivate

Definition at line 113 of file MuidCaloTrackStateOnSurface.h.

{0};

m_countArbitrarySolution

std::atomic_int Rec::MuidCaloTrackStateOnSurface::m_countArbitrarySolution {0}

mutableprivate

Definition at line 114 of file MuidCaloTrackStateOnSurface.h.

{0};

m_countCompleteFailure

std::atomic_int Rec::MuidCaloTrackStateOnSurface::m_countCompleteFailure {0}

mutableprivate

Definition at line 115 of file MuidCaloTrackStateOnSurface.h.

{0};

m_countInnerFailure

std::atomic_int Rec::MuidCaloTrackStateOnSurface::m_countInnerFailure {0}

mutableprivate

Definition at line 116 of file MuidCaloTrackStateOnSurface.h.

{0};

m_countOuterFailure

std::atomic_int Rec::MuidCaloTrackStateOnSurface::m_countOuterFailure {0}

mutableprivate

Definition at line 117 of file MuidCaloTrackStateOnSurface.h.

{0};

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_fieldCacheCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> Rec::MuidCaloTrackStateOnSurface::m_fieldCacheCondObjInputKey

private

Initial value:

{this, "AtlasFieldCacheCondObj", "fieldCondObj",
                                                                                  "Name of the Magnetic Field conditions object key"}

Definition at line 104 of file MuidCaloTrackStateOnSurface.h.

                                                                               {this, "AtlasFieldCacheCondObj", "fieldCondObj",
                                                                                  "Name of the Magnetic Field conditions object key"};

m_magFieldProperties

Trk::MagneticFieldProperties Rec::MuidCaloTrackStateOnSurface::m_magFieldProperties {Trk::FullField}

private

Definition at line 101 of file MuidCaloTrackStateOnSurface.h.

{Trk::FullField};

m_minCaloRadius

double Rec::MuidCaloTrackStateOnSurface::m_minCaloRadius

private

Definition at line 108 of file MuidCaloTrackStateOnSurface.h.

m_minRemainingEnergy

double Rec::MuidCaloTrackStateOnSurface::m_minRemainingEnergy

private

Definition at line 109 of file MuidCaloTrackStateOnSurface.h.

m_paramPtCut

double Rec::MuidCaloTrackStateOnSurface::m_paramPtCut

private

Definition at line 110 of file MuidCaloTrackStateOnSurface.h.

m_propagator

ToolHandle<Trk::IPropagator> Rec::MuidCaloTrackStateOnSurface::m_propagator

private

Initial value:

{
            this,
            "Propagator",
            "Trk::IntersectorWrapper/IntersectorWrapper",
        }

Definition at line 95 of file MuidCaloTrackStateOnSurface.h.

                                               {
            this,
            "Propagator",
            "Trk::IntersectorWrapper/IntersectorWrapper",
        };

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:

• MuidCaloTrackStateOnSurface.h
• MuidCaloTrackStateOnSurface.cxx