#include <MuonTrackQuery.h>

Inheritance diagram for Rec::MuonTrackQuery:

Collaboration diagram for Rec::MuonTrackQuery:

Public Member Functions
	MuonTrackQuery (const std::string &type, const std::string &name, const IInterface *parent)
	~MuonTrackQuery ()=default
StatusCode	initialize () override
const CaloEnergy *	caloEnergy (const Trk::Track &track) const override
	IMuonTrackQuery interface: caloEnergy from appropriate TSOS.
double	caloEnergyDeposit (const Trk::Track &track, const EventContext &ctx) const override
	IMuonTrackQuery interface: track energy deposit in calorimeters (as fitted or otherwise applied)
FieldIntegral	fieldIntegral (const Trk::Track &track, const EventContext &ctx) const override
	IMuonTrackQuery interface: field integral along track from momentum kick between measurements.
bool	isCaloAssociated (const Trk::Track &track, const EventContext &ctx) const override
	IMuonTrackQuery interface: does track have at least 3 TSOS's representing calorimeter ?
bool	isCombined (const Trk::Track &track, const EventContext &ctx) const override
	IMuonTrackQuery interface: does track have measurements from indet and spectrometer ?
bool	isExtrapolated (const Trk::Track &track, const EventContext &ctx) const override
	IMuonTrackQuery interface: does track have perigee inside indet ?
bool	isLineFit (const Trk::Track &track) const override
	IMuonTrackQuery interface: does track have fitted curvature ?
bool	isProjective (const Trk::Track &track) const override
	IMuonTrackQuery interface: is track (roughly) projective towards IP?
bool	isSectorOverlap (const Trk::Track &track) const override
	IMuonTrackQuery interface: is there a long/short chamber overlap?
bool	isSlimmed (const Trk::Track &track) const override
	IMuonTrackQuery interface: does track have TrackParameters at every TSOS ?
double	momentumBalanceSignificance (const Trk::Track &track, const EventContext &ctx) const override
	IMuonTrackQuery interface: significance of momentum balance for combined tracks (biassed residual)
unsigned	numberPseudoMeasurements (const Trk::Track &track) const override
	IMuonTrackQuery interface: number of PseudoMeasurements on track (counts one for any vertex measurement)
std::unique_ptr< const Trk::Perigee >	outgoingPerigee (const Trk::Track &track) const override
	IMuonTrackQuery interface: perigee expressed outgoing from IP.
ScatteringAngleSignificance	scatteringAngleSignificance (const Trk::Track &track, const EventContext &ctx) const override
	IMuonTrackQuery interface: significance of early scattering angle pattern for combined tracks (wider than gaussian)
std::unique_ptr< Trk::TrackParameters >	spectrometerParameters (const Trk::Track &track, const EventContext &ctx) const override
	IMuonTrackQuery interface: trackParameters at innermost measurement TSOS in MS.
unsigned	spectrometerPhiQuality (const Trk::Track &track, const EventContext &ctx) const override
	IMuonTrackQuery interface: assess the number of additional phi measurements needed for MS (or SA) track fit.
std::unique_ptr< const Trk::TrackParameters >	triggerStationParameters (const Trk::Track &track, const EventContext &ctx) const override
	IMuonTrackQuery interface: trackParameters at innermost trigger chamber TSOS in MS.
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
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
const Trk::TrackingVolume *	getVolume (const std::string &&vol_name, const EventContext &ctx) 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< Trk::TrackParameters >	flippedParameters (const Trk::TrackParameters &params)

Private Attributes
ToolHandle< Trk::ITrackFitter >	m_fitter {this, "Fitter", "", "Track fitter tool"}
ServiceHandle< Muon::IMuonEDMHelperSvc >	m_edmHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
ToolHandle< Muon::IMdtDriftCircleOnTrackCreator >	m_mdtRotCreator
SG::ReadCondHandleKey< Trk::TrackingGeometry >	m_trackingGeometryReadKey
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 20 of file MuonTrackQuery.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

◆ MuonTrackQuery()

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

Definition at line 43 of file MuonTrackQuery.cxx.

                                                                                                         :
        AthAlgTool(type, name, parent) {
        declareInterface<IMuonTrackQuery>(this);
    }

◆ ~MuonTrackQuery()

Rec::MuonTrackQuery::~MuonTrackQuery ( )

default

Member Function Documentation

◆ caloEnergy()

const CaloEnergy * Rec::MuonTrackQuery::caloEnergy ( const Trk::Track & track ) const

overridevirtual

IMuonTrackQuery interface: caloEnergy from appropriate TSOS.

Implements Rec::IMuonTrackQuery.

Definition at line 79 of file MuonTrackQuery.cxx.

                                                                            {
        const CaloEnergy* caloEnergy = nullptr;
 
        for (const Trk::TrackStateOnSurface* tsos : *track.trackStateOnSurfaces()) {
            // select MaterialEffects inside calorimeter volume
            if (!tsos->type(Trk::TrackStateOnSurface::CaloDeposit) || !tsos->materialEffectsOnTrack()) { continue; }
 
            const Trk::MaterialEffectsOnTrack* meot = dynamic_cast<const Trk::MaterialEffectsOnTrack*>(tsos->materialEffectsOnTrack());
 
            if (!meot) { continue; }
 
            caloEnergy = dynamic_cast<const CaloEnergy*>(meot->energyLoss());
            if (caloEnergy) { break; }
        }
 
        ATH_MSG_VERBOSE("caloEnergy " << caloEnergy);
 
        return caloEnergy;
    }

◆ caloEnergyDeposit()

double Rec::MuonTrackQuery::caloEnergyDeposit	(	const Trk::Track &	track,
		const EventContext &	ctx ) const

overridevirtual

IMuonTrackQuery interface: track energy deposit in calorimeters (as fitted or otherwise applied)

Implements Rec::IMuonTrackQuery.

Definition at line 98 of file MuonTrackQuery.cxx.

                                                                                                 {
        const Trk::TrackingVolume* calorimeterVolume = getVolume("Calo::Container", ctx);
 
        if (!calorimeterVolume) {
            ATH_MSG_WARNING("Failed to retrieve Calo volume ");
            return 0.;
        }
 
        const Trk::TrackingVolume* indetVolume = getVolume("InDet::Containers::InnerDetector", ctx);
 
        if (!indetVolume) {
            ATH_MSG_WARNING("Failed to retrieve InDeT volume ");
            return 0.;
        }
 
        const Trk::TrackParameters* indetExitParameters = nullptr;
        const Trk::TrackParameters* caloExitParameters = nullptr;
 
        for (const Trk::TrackStateOnSurface* tsos : *track.trackStateOnSurfaces()) {
            if (!tsos->trackParameters()) continue;
 
            if (indetVolume->inside(tsos->trackParameters()->position())) {
                indetExitParameters = tsos->trackParameters();
                continue;
            }
 
            if (!calorimeterVolume->inside(tsos->trackParameters()->position()) && caloExitParameters) { break; }
 
            caloExitParameters = tsos->trackParameters();
        }
 
        if (!indetExitParameters || !caloExitParameters) { return 0.; }
 
        double energyDeposit = indetExitParameters->momentum().mag() - caloExitParameters->momentum().mag();
 
        ATH_MSG_VERBOSE(" calo energy deposit ");
 
        return energyDeposit;
    }

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

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

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

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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

◆ fieldIntegral()

FieldIntegral Rec::MuonTrackQuery::fieldIntegral	(	const Trk::Track &	track,
		const EventContext &	ctx ) const

overridevirtual

IMuonTrackQuery interface: field integral along track from momentum kick between measurements.

Implements Rec::IMuonTrackQuery.

Definition at line 138 of file MuonTrackQuery.cxx.

                                                                                                    {
        // field integral null for straight tracks + method is not valid for slimmed tracks
        if (isLineFit(track) || isSlimmed(track)) { return FieldIntegral(); }
 
        const Trk::TrackingVolume* calorimeterVolume = getVolume("Calo::Container", ctx);
 
        if (!calorimeterVolume) {
            ATH_MSG_WARNING("Failed to retrieve Calo volume ");
            return FieldIntegral();
        }
 
        const Trk::TrackingVolume* indetVolume = getVolume("InDet::Containers::InnerDetector", ctx);
 
        if (!indetVolume) {
            ATH_MSG_WARNING("Failed to retrieve InDeT volume ");
            return FieldIntegral();
        }
 
        // sum Bdl between measurements
        double betweenInDetMeasurements = 0.;
        double betweenSpectrometerMeasurements = 0.;
 
        bool haveInDet = false;
        bool haveSpectrometer = false;
 
        Amg::Vector3D integratedMomentumKick = origin;
 
        const Trk::TrackParameters* parameters = nullptr;
 
        // loop over TSOS to integrate vector Bdl
        for (const Trk::TrackStateOnSurface* tsos : *track.trackStateOnSurfaces()) {
            // not going to use trigger hits, outliers or pseudoMeasurements
            bool isPreciseHit = (tsos->measurementOnTrack() && dynamic_cast<const Trk::MeasurementBase*>(tsos->measurementOnTrack()) &&
                                 !dynamic_cast<const Trk::PseudoMeasurementOnTrack*>(tsos->measurementOnTrack()) &&
                                 !tsos->type(Trk::TrackStateOnSurface::Outlier));
 
            // skip slimmed measurements
            if (!tsos->trackParameters() || dynamic_cast<const Trk::Perigee*>(tsos->trackParameters())) { continue; }
 
            // skip spectrometer phi measurements
            if (isPreciseHit && !calorimeterVolume->inside(tsos->trackParameters()->position())) {
                Identifier id = m_edmHelperSvc->getIdentifier(*tsos->measurementOnTrack());
                isPreciseHit = (id.is_valid() && !m_idHelperSvc->measuresPhi(id));
            }
 
            if (!tsos->materialEffectsOnTrack() && !isPreciseHit) { continue; }
 
            // careful with first hit + skip any flipped parameters
            if (!parameters) { parameters = tsos->trackParameters(); }
 
            Amg::Vector3D startMomentum = parameters->momentum();
            parameters = tsos->trackParameters();
            Amg::Vector3D endDirection = parameters->momentum().unit();
 
            if (startMomentum.dot(endDirection) < 0.) continue;
 
            // subtract scattering angle
            if (tsos->materialEffectsOnTrack()) {
                const Trk::MaterialEffectsOnTrack* meot = dynamic_cast<const Trk::MaterialEffectsOnTrack*>(tsos->materialEffectsOnTrack());
 
                if (meot && meot->scatteringAngles()) {
                    const double theta = endDirection.theta() - meot->scatteringAngles()->deltaTheta();
                    const double phi = xAOD::P4Helpers::deltaPhi(endDirection.phi() , meot->scatteringAngles()->deltaPhi());
                    const CxxUtils::sincos sc_theta {theta}, sc_phi{phi};
                    endDirection = Amg::Vector3D(sc_theta.sn * sc_phi.cs, sc_theta.sn * sc_phi.sn, sc_theta.cs);
                }
            }
 
            Amg::Vector3D momentumKick = startMomentum.cross(endDirection) / (0.3 * Units::GeV);
            integratedMomentumKick += momentumKick;
 
            // accumulate abs(Bdl) between measurements (distinguish indet and spectrometer)
            if (!isPreciseHit) continue;
 
            if (indetVolume->inside(parameters->position())) {
                if (haveInDet) {
                    betweenInDetMeasurements += integratedMomentumKick.mag();
                    integratedMomentumKick = origin;
                } else {
                    haveInDet = true;
                    integratedMomentumKick = origin;
                }
            } else {
                if (haveSpectrometer) {
                    betweenSpectrometerMeasurements += integratedMomentumKick.mag();
                    integratedMomentumKick = origin;
                } else {
                    haveSpectrometer = true;
                    integratedMomentumKick = origin;
                }
            }
        }
 
        ATH_MSG_DEBUG(std::setiosflags(std::ios::fixed)
                      << " field integrals for track at eta, phi " << std::setw(6) << std::setprecision(2)
                      << track.perigeeParameters()->momentum().eta() << "," << std::setw(6) << std::setprecision(2)
                      << track.perigeeParameters()->momentum().phi() << " : betweenInDetMeasurements " << std::setw(8)
                      << std::setprecision(3) << betweenInDetMeasurements << "   betweenSpectrometerMeasurements " << std::setw(8)
                      << std::setprecision(3) << betweenSpectrometerMeasurements);
 
        return FieldIntegral(betweenInDetMeasurements, betweenSpectrometerMeasurements, 0., 0.);
    }

◆ flippedParameters()

std::unique_ptr< Trk::TrackParameters > Rec::MuonTrackQuery::flippedParameters ( const Trk::TrackParameters & params )

staticprivate

Definition at line 889 of file MuonTrackQuery.cxx.

                                                                                                            {
        double phi = parameters.parameters()[Trk::phi0];
        if (phi > 0.) {
            phi -= M_PI;
        } else {
            phi += M_PI;
        }
 
        double theta = M_PI - parameters.parameters()[Trk::theta];
        double qOverP = -parameters.parameters()[Trk::qOverP];
        const Trk::Surface* surface = &(parameters.associatedSurface());
 
        return surface->createUniqueTrackParameters(
            parameters.parameters()[Trk::d0], parameters.parameters()[Trk::z0], phi, theta, qOverP,
            parameters.covariance() ? std::optional<AmgSymMatrix(5)>(*parameters.covariance()) : std::nullopt);
    }

◆ getVolume()

const Trk::TrackingVolume * Rec::MuonTrackQuery::getVolume	(	const std::string &&	vol_name,
		const EventContext &	ctx ) const

inlineprivate

Tracking geometry is provided by the TrackingGeometryAlg

Definition at line 117 of file MuonTrackQuery.h.

                                                                                                             {
            SG::ReadCondHandle<Trk::TrackingGeometry> handle(m_trackingGeometryReadKey, ctx);
            if (!handle.isValid()) {
                ATH_MSG_WARNING("Could not retrieve a valid tracking geometry");
                return nullptr;
            }
            return handle->trackingVolume(vol_name);
            
        }

◆ initialize()

StatusCode Rec::MuonTrackQuery::initialize ( )

override

Definition at line 48 of file MuonTrackQuery.cxx.

                                          {
        ATH_MSG_DEBUG("Initializing MuonTrackQuery");
 
        // tool needed to refit slimmed tracks
        if (!m_fitter.empty()) {
            ATH_CHECK(m_fitter.retrieve());
            ATH_MSG_DEBUG("Retrieved tool " << m_fitter);
        }
 
        // multipurpose and identifier helper tools for spectrometer
        ATH_CHECK(m_edmHelperSvc.retrieve());
        ATH_MSG_DEBUG("Retrieved tool " << m_edmHelperSvc);
 
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_MSG_DEBUG("Retrieved tool " << m_idHelperSvc);
 
        // tools needed when flipping tracks to outgoing
        if (!m_mdtRotCreator.empty()) {
            ATH_CHECK(m_mdtRotCreator.retrieve());
            ATH_MSG_DEBUG("Retrieved tool " << m_mdtRotCreator);
        }
 
        // need to know which TrackingVolume we are in: indet/calo/spectrometer
        if (!m_trackingGeometryReadKey.empty()) {
            ATH_CHECK(m_trackingGeometryReadKey.initialize());
        } else {
            ATH_MSG_ERROR("Could not retrieve a valid tracking geometry");
        }
        return StatusCode::SUCCESS;
    }

◆ 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::IMuonTrackQuery::interfaceID ( )

inlinestaticinherited

AlgTool and IAlgTool interface methods.

Definition at line 33 of file IMuonTrackQuery.h.

                                                {
            static const InterfaceID IID_IMuonTrackQuery("IMuonTrackQuery", 1, 0);
            return IID_IMuonTrackQuery;
        }

◆ isCaloAssociated()

bool Rec::MuonTrackQuery::isCaloAssociated	(	const Trk::Track &	track,
		const EventContext &	ctx ) const

overridevirtual

IMuonTrackQuery interface: does track have at least 3 TSOS's representing calorimeter ?

Implements Rec::IMuonTrackQuery.

Definition at line 241 of file MuonTrackQuery.cxx.

                                                                                              {
        const Trk::TrackingVolume* calorimeterVolume = getVolume("Calo::Container", ctx);
 
        if (!calorimeterVolume) {
            ATH_MSG_WARNING("Failed to retrieve Calo volume ");
            return false;
        }
 
        const Trk::TrackingVolume* indetVolume = getVolume("InDet::Containers::InnerDetector", ctx);
 
        if (!indetVolume) {
            ATH_MSG_WARNING("Failed to retrieve InDeT volume ");
            return false;
        }
 
        bool haveCaloDeposit = false;
        int numberCaloTSOS = 0;
 
        for (const Trk::TrackStateOnSurface* s : *track.trackStateOnSurfaces()) {
            // CaloDeposit?
            if (s->type(Trk::TrackStateOnSurface::CaloDeposit)) {
                ATH_MSG_VERBOSE("haveCaloDeposit, " << numberCaloTSOS << " TSOS in calo volume");
                haveCaloDeposit = true;
            }
 
            // select MaterialEffects inside calorimeter volume
            if (!s->materialEffectsOnTrack()) { continue; }
 
            Amg::Vector3D position = s->materialEffectsOnTrack()->associatedSurface().globalReferencePoint();
 
            if (indetVolume->inside(position)) { continue; }
            if (!calorimeterVolume->inside(position)) { break; }
            if (++numberCaloTSOS > 2 && haveCaloDeposit) { return true; }
        }
 
        ATH_MSG_VERBOSE("association false, " << numberCaloTSOS << " TSOS in calo volume");
 
        return false;
    }

◆ isCombined()

bool Rec::MuonTrackQuery::isCombined	(	const Trk::Track &	track,
		const EventContext &	ctx ) const

overridevirtual

IMuonTrackQuery interface: does track have measurements from indet and spectrometer ?

Implements Rec::IMuonTrackQuery.

Definition at line 281 of file MuonTrackQuery.cxx.

                                                                                        {
        const Trk::TrackingVolume* calorimeterVolume = getVolume("Calo::Container", ctx);
 
        if (!calorimeterVolume) {
            ATH_MSG_WARNING("Failed to retrieve Calo volume ");
            return false;
        }
 
        const Trk::TrackingVolume* indetVolume = getVolume("InDet::Containers::InnerDetector", ctx);
 
        if (!indetVolume) {
            ATH_MSG_WARNING("Failed to retrieve InDeT volume ");
            return false;
        }
 
        // combined tracks have indet and spectrometer active measurements
        bool indet = false;
        bool spectrometer = false;
 
        // find innermost measurement (assume some degree of measurement ordering)
        for (const Trk::TrackStateOnSurface* tsos : *track.trackStateOnSurfaces()) {
            if (!tsos->measurementOnTrack() || tsos->type(Trk::TrackStateOnSurface::Outlier) ||
                dynamic_cast<const Trk::PseudoMeasurementOnTrack*>(tsos->measurementOnTrack())) {
                continue;
            }
 
            if (indetVolume->inside(tsos->measurementOnTrack()->globalPosition())) {
                indet = true;
                break;
            } else if (!calorimeterVolume->inside(tsos->measurementOnTrack()->globalPosition())) {
                spectrometer = true;
                break;
            }
        }
 
        // find outermost measurement
        Trk::TrackStates::const_reverse_iterator rs = track.trackStateOnSurfaces()->rbegin();
        for (; rs != track.trackStateOnSurfaces()->rend(); ++rs) {
            if (!(**rs).measurementOnTrack() || (**rs).type(Trk::TrackStateOnSurface::Outlier) ||
                dynamic_cast<const Trk::PseudoMeasurementOnTrack*>((**rs).measurementOnTrack())) {
                continue;
            }
 
            if (indetVolume->inside((**rs).measurementOnTrack()->globalPosition())) {
                indet = true;
                break;
            } else if (!calorimeterVolume->inside((**rs).measurementOnTrack()->globalPosition())) {
                spectrometer = true;
                break;
            }
        }
 
        return indet && spectrometer;
    }

◆ isExtrapolated()

bool Rec::MuonTrackQuery::isExtrapolated	(	const Trk::Track &	track,
		const EventContext &	ctx ) const

overridevirtual

IMuonTrackQuery interface: does track have perigee inside indet ?

Implements Rec::IMuonTrackQuery.

Definition at line 336 of file MuonTrackQuery.cxx.

                                                                                            {
        const Trk::TrackingVolume* calorimeterVolume = getVolume("Calo::Container", ctx);
 
        if (!calorimeterVolume) {
            ATH_MSG_WARNING("Failed to retrieve Calo volume ");
            return false;
        }
 
        const Trk::TrackingVolume* indetVolume = getVolume("InDet::Containers::InnerDetector", ctx);
 
        if (!indetVolume) {
            ATH_MSG_WARNING("Failed to retrieve InDeT volume ");
            return false;
        }
 
        // perigee needs to be inside indet
        const Trk::TrackParameters* parameters = track.perigeeParameters();
        if (!parameters || !indetVolume->inside(parameters->position())) { return false; }
 
        // extrapolated tracks have indet TSOS but not active measurements
        // and spectrometer active measurements
        bool indet = false;
        bool spectrometer = false;
 
        // find innermost measurement (assume some degree of measurement ordering)
        for (const Trk::TrackStateOnSurface* tsos : *track.trackStateOnSurfaces()) {
            if (!tsos->measurementOnTrack() || tsos->type(Trk::TrackStateOnSurface::Outlier) ||
                dynamic_cast<const Trk::PseudoMeasurementOnTrack*>(tsos->measurementOnTrack())) {
                continue;
            }
 
            if (indetVolume->inside(tsos->measurementOnTrack()->globalPosition())) {
                indet = true;
                break;
            } else if (!calorimeterVolume->inside(tsos->measurementOnTrack()->globalPosition())) {
                spectrometer = true;
                break;
            }
        }
 
        // find outermost measurement (assume some degree of measurement ordering)
        Trk::TrackStates::const_reverse_iterator rs = track.trackStateOnSurfaces()->rbegin();
        for (; rs != track.trackStateOnSurfaces()->rend(); ++rs) {
            if (!(**rs).measurementOnTrack() || (**rs).type(Trk::TrackStateOnSurface::Outlier) ||
                dynamic_cast<const Trk::PseudoMeasurementOnTrack*>((**rs).measurementOnTrack())) {
                continue;
            }
 
            if (indetVolume->inside((**rs).measurementOnTrack()->globalPosition())) {
                indet = true;
                break;
            } else if (!calorimeterVolume->inside((**rs).measurementOnTrack()->globalPosition())) {
                spectrometer = true;
                break;
            }
        }
 
        return !indet && spectrometer;
    }

◆ isLineFit()

bool Rec::MuonTrackQuery::isLineFit ( const Trk::Track & track ) const

overridevirtual

IMuonTrackQuery interface: does track have fitted curvature ?

Implements Rec::IMuonTrackQuery.

Definition at line 396 of file MuonTrackQuery.cxx.

                                                              {
        if (track.info().trackProperties(Trk::TrackInfo::StraightTrack)) { return true; }
 
        // for backwards compatibility
        const Trk::Perigee* measuredPerigee = track.perigeeParameters();
 
        if (!measuredPerigee) return false;
 
        if (!measuredPerigee->covariance()) {
            ATH_MSG_WARNING(" measured Perigee has no covariance!");
            return false;
        }
 
        double momentumCovariance = (*measuredPerigee->covariance())(Trk::qOverP, Trk::qOverP);
 
        double relativeMomentumCovariance = momentumCovariance * measuredPerigee->momentum().mag2();
 
        // unphysically small value used to signal SL
        if (momentumCovariance < 1.E-19 || relativeMomentumCovariance < 1.E-6) return true;
 
        // or if curvature unmeasured (error > 1000%)
        if (relativeMomentumCovariance > 100.) return true;
 
        return false;
    }

◆ isProjective()

bool Rec::MuonTrackQuery::isProjective ( const Trk::Track & track ) const

overridevirtual

IMuonTrackQuery interface: is track (roughly) projective towards IP?

Implements Rec::IMuonTrackQuery.

Definition at line 422 of file MuonTrackQuery.cxx.

                                                                 {
        // get start and end measured positions
        Amg::Vector3D startPosition{origin};
        for (const Trk::TrackStateOnSurface* tsos : *track.trackStateOnSurfaces()) {
            if (tsos->measurementOnTrack() && !tsos->type(Trk::TrackStateOnSurface::Outlier) &&
                !dynamic_cast<const Trk::PseudoMeasurementOnTrack*>(tsos->measurementOnTrack())) {
                startPosition = tsos->measurementOnTrack()->globalPosition();
                break;
            }
        }
 
        Amg::Vector3D endPosition{origin};
        Trk::TrackStates::const_reverse_iterator rs = track.trackStateOnSurfaces()->rbegin();
        for (; rs != track.trackStateOnSurfaces()->rend(); ++rs) {
            if ((**rs).measurementOnTrack() && !(**rs).type(Trk::TrackStateOnSurface::Outlier) &&
                !dynamic_cast<const Trk::PseudoMeasurementOnTrack*>((**rs).measurementOnTrack())) {
                endPosition = (**rs).measurementOnTrack()->globalPosition();
                break;
            }
        }
 
        // same-side check: kill if through (up-down) track
        double side = endPosition.dot(startPosition);
        if (side < 0.) {
            ATH_MSG_DEBUG("track is not projective: fails same-side check ");
            return false;
        }
 
        // hence change in phi between these measurements
        const CxxUtils::sincos sc_dPhi{startPosition.deltaPhi(endPosition)};
        // cut on change of long phi sector
        constexpr double PiOver8 = M_PI / 8.;
        if (std::abs(sc_dPhi.sn) > PiOver8) {
            ATH_MSG_DEBUG("track is not projective: sinDeltaPhi " << sc_dPhi.sn);
            return false;
        }
 
        // cut on change of hemisphere (except for far forward tracks)
        if (sc_dPhi.cs < 0.) {
            double cotTheta = startPosition.z() / startPosition.perp();
            if (std::abs(startPosition.z()) > std::abs(endPosition.z())) { cotTheta = endPosition.z() / endPosition.perp(); }
 
            // FIXME: isn't this same-side again?
            if (startPosition.z() * endPosition.z() < 0. || std::abs(cotTheta) < 2.0) {
                ATH_MSG_DEBUG("track is not projective: cosDeltaPhi " << sc_dPhi.cs);
                return false;
            }
 
            ATH_MSG_WARNING("forward track changes hemisphere: cotTheta " << cotTheta << "  cosDeltaPhi " << sc_dPhi.cs);
        }
 
        // OK - the track is at least roughly projective
        return true;
    }

◆ isSectorOverlap()

bool Rec::MuonTrackQuery::isSectorOverlap ( const Trk::Track & track ) const

overridevirtual

IMuonTrackQuery interface: is there a long/short chamber overlap?

Use the taylor expansion that sin(x) = x for small x

Implements Rec::IMuonTrackQuery.

Definition at line 477 of file MuonTrackQuery.cxx.

                                                                    {
        constexpr double sectorOffset = M_PI / 16.;
        bool isOverlap = true;
        double cosPhi = 0.;
        double sinPhi = 0.;
        for (const Trk::TrackStateOnSurface* tsos : *track.trackStateOnSurfaces()) {
            if (!tsos->measurementOnTrack() || dynamic_cast<const Trk::PseudoMeasurementOnTrack*>(tsos->measurementOnTrack())) { continue; }
 
            if (isOverlap) {
                isOverlap = false;
                const Amg::Vector3D& position = tsos->measurementOnTrack()->associatedSurface().globalReferencePoint();
 
                cosPhi = position.x() / position.perp();
                sinPhi = position.y() / position.perp();
            } else {
                const Amg::Vector3D& position = tsos->measurementOnTrack()->associatedSurface().globalReferencePoint();
 
                double sinDeltaPhi = (position.x() * sinPhi - position.y() * cosPhi) / position.perp();
                if (std::abs(sinDeltaPhi) > sectorOffset) {
                    ATH_MSG_DEBUG("found overlap: sinDeltaPhi " << sinDeltaPhi);
                    isOverlap = true;
                    break;
                }
            }
        }
 
        return isOverlap;
    }

◆ isSlimmed()

bool Rec::MuonTrackQuery::isSlimmed ( const Trk::Track & track ) const

overridevirtual

IMuonTrackQuery interface: does track have TrackParameters at every TSOS ?

Implements Rec::IMuonTrackQuery.

Definition at line 507 of file MuonTrackQuery.cxx.

                                                              {
        Trk::TrackStates::const_iterator s = track.trackStateOnSurfaces()->begin();
        for (; s != track.trackStateOnSurfaces()->end(); ++s) {
            if ((**s).trackParameters()) continue;
 
            ATH_MSG_VERBOSE("track is slimmed (found TSOS without trackParameters) ");
            return true;
        }
 
        ATH_MSG_VERBOSE("track is not slimmed (all TSOS have trackParameters) ");
 
        return false;
    }

◆ momentumBalanceSignificance()

double Rec::MuonTrackQuery::momentumBalanceSignificance	(	const Trk::Track &	track,
		const EventContext &	ctx ) const

overridevirtual

IMuonTrackQuery interface: significance of momentum balance for combined tracks (biassed residual)

Implements Rec::IMuonTrackQuery.

Definition at line 521 of file MuonTrackQuery.cxx.

                                                                                                           {
        // significance only defined for combined muons
        if (!isCombined(track, ctx)) return 0.;
 
        // find the TSOS carrying caloEnergy (TSOS type CaloDeposit)
        // compare parameters with those from previous TSOS
        double energyBalance = 0.;
 
        const Trk::EnergyLoss* energyLoss = nullptr;
        const Trk::TrackParameters* previousParameters = nullptr;
 
        for (const Trk::TrackStateOnSurface* tsos : *track.trackStateOnSurfaces()) {
            if (!tsos->trackParameters()) continue;
 
            if (tsos->materialEffectsOnTrack()) {
                const Trk::MaterialEffectsOnTrack* meot = dynamic_cast<const Trk::MaterialEffectsOnTrack*>(tsos->materialEffectsOnTrack());
 
                if (!meot) continue;
                energyLoss = meot->energyLoss();
 
                if (tsos->type(Trk::TrackStateOnSurface::CaloDeposit) && energyLoss && previousParameters) {
                    energyBalance = previousParameters->momentum().mag() - energyLoss->deltaE() - tsos->trackParameters()->momentum().mag();
 
                    if (std::abs(energyBalance) < energyLoss->sigmaDeltaE()) {
                        ATH_MSG_DEBUG(std::setiosflags(std::ios::fixed)
                                      << " momentum balance  " << std::setw(6) << std::setprecision(2) << energyBalance / Units::GeV
                                      << "   significance " << std::setw(6) << std::setprecision(1)
                                      << energyBalance / energyLoss->sigmaDeltaE() << "  p before/after calo" << std::setw(7)
                                      << std::setprecision(2) << previousParameters->momentum().mag() / Units::GeV << " /" << std::setw(7)
                                      << std::setprecision(2) << tsos->trackParameters()->momentum().mag() / Units::GeV
                                      << "   energy deposit sigma  " << energyLoss->sigmaDeltaE() / Units::GeV << " GeV");
 
                        energyBalance /= energyLoss->sigmaDeltaE();
                    } else if (energyBalance < 0.) {
                        ATH_MSG_DEBUG(std::setiosflags(std::ios::fixed)
                                      << " momentum balance  " << std::setw(6) << std::setprecision(2) << energyBalance / Units::GeV
                                      << "   significance " << std::setw(6) << std::setprecision(1)
                                      << energyBalance / energyLoss->sigmaDeltaE() << "  p before/after calo" << std::setw(7)
                                      << std::setprecision(2) << previousParameters->momentum().mag() / Units::GeV << " /" << std::setw(7)
                                      << std::setprecision(2) << tsos->trackParameters()->momentum().mag() / Units::GeV
                                      << "   energy deposit sigma- " << energyLoss->sigmaMinusDeltaE() / Units::GeV << " GeV");
 
                        energyBalance /= energyLoss->sigmaMinusDeltaE();
                    } else {
                        ATH_MSG_DEBUG(std::setiosflags(std::ios::fixed)
                                      << " momentum balance  " << std::setw(6) << std::setprecision(2) << energyBalance / Units::GeV
                                      << "   significance " << std::setw(6) << std::setprecision(1)
                                      << energyBalance / energyLoss->sigmaDeltaE() << "  p before/after calo" << std::setw(7)
                                      << std::setprecision(2) << previousParameters->momentum().mag() / Units::GeV << " /" << std::setw(7)
                                      << std::setprecision(2) << tsos->trackParameters()->momentum().mag() / Units::GeV
                                      << "   energy deposit sigma+ " << energyLoss->sigmaPlusDeltaE() / Units::GeV << " GeV");
 
                        energyBalance /= energyLoss->sigmaPlusDeltaE();
                    }
                    break;
                }
            }
 
            // update previous parameters
            previousParameters = tsos->trackParameters();
        }
 
        return energyBalance;
    }

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

◆ numberPseudoMeasurements()

unsigned Rec::MuonTrackQuery::numberPseudoMeasurements ( const Trk::Track & track ) const

overridevirtual

IMuonTrackQuery interface: number of PseudoMeasurements on track (counts one for any vertex measurement)

Implements Rec::IMuonTrackQuery.

Definition at line 586 of file MuonTrackQuery.cxx.

                                                                                 {
        unsigned numberPseudo = 0;
 
        Trk::TrackStates::const_iterator s = track.trackStateOnSurfaces()->begin();
        for (; s != track.trackStateOnSurfaces()->end(); ++s) {
            if ((**s).measurementOnTrack() && dynamic_cast<const Trk::PseudoMeasurementOnTrack*>((**s).measurementOnTrack())) {
                ++numberPseudo;
            }
        }
 
        ATH_MSG_VERBOSE(" track has " << numberPseudo << " PseudoMeasurements");
 
        return numberPseudo;
    }

◆ outgoingPerigee()

std::unique_ptr< const Trk::Perigee > Rec::MuonTrackQuery::outgoingPerigee ( const Trk::Track & track ) const

overridevirtual

IMuonTrackQuery interface: perigee expressed outgoing from IP.

Implements Rec::IMuonTrackQuery.

Definition at line 601 of file MuonTrackQuery.cxx.

                                                                                               {
        // only flip Perigee
        const Trk::Perigee* perigee = track.perigeeParameters();
        if (!perigee) {
            ATH_MSG_WARNING(" input track without Perigee");
            return nullptr;
        }
 
        const Trk::PerigeeSurface& surface = perigee->associatedSurface();
 
        const Trk::TrackStateOnSurface* outerTSOS = track.trackStateOnSurfaces()->back();
        if (!perigee->covariance()) {
            ATH_MSG_WARNING(" perigee has no covariance");
            return std::make_unique<Trk::Perigee>(*perigee);
        }
 
        if (outerTSOS->trackParameters() == perigee && perigee->momentum().dot(perigee->position()) <= 0.) {
            const AmgSymMatrix(5)& perigeeCov = (*perigee->covariance());
 
            // need to flip
            return std::make_unique<Trk::Perigee>(perigee->position(), -perigee->momentum(), -perigee->charge(), surface, perigeeCov);
        }
 
        return std::make_unique<Trk::Perigee>(*perigee);
    }

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

◆ scatteringAngleSignificance()

ScatteringAngleSignificance Rec::MuonTrackQuery::scatteringAngleSignificance	(	const Trk::Track &	track,
		const EventContext &	ctx ) const

overridevirtual

IMuonTrackQuery interface: significance of early scattering angle pattern for combined tracks (wider than gaussian)

Implements Rec::IMuonTrackQuery.

Definition at line 626 of file MuonTrackQuery.cxx.

                                                                                                                                {
        const Trk::TrackingVolume* calorimeterVolume = getVolume("Calo::Container", ctx);
        if (!calorimeterVolume) {
            ATH_MSG_WARNING("Failed to retrieve Calo volume ");
            return ScatteringAngleSignificance{};
        }
 
        const Trk::TrackingVolume* indetVolume = getVolume("InDet::Containers::InnerDetector", ctx);
 
        if (!indetVolume) {
            ATH_MSG_WARNING("Failed to retrieve InDeT volume ");
            return ScatteringAngleSignificance{};
        }
 
        // provide refit for slimmed tracks
        std::unique_ptr<const Trk::Track> refittedTrack;
 
        if (isSlimmed(track)) {
            if (!m_fitter.empty()) {
                ATH_MSG_VERBOSE(" perform refit as track has been slimmed");
                refittedTrack = m_fitter->fit(ctx, track, false, Trk::muon);
            }
            if (!refittedTrack) return ScatteringAngleSignificance(0);
        } else {
            refittedTrack = std::make_unique<Trk::Track>(track);
        }
 
        // collect sigma of scatterer up to TSOS carrying caloEnergy
        double charge = refittedTrack->perigeeParameters()->charge();
        bool haveMeasurement = false;
        unsigned scatterers = 0;
        double totalSigma = 0.;
 
        std::vector<bool> isMeasurement;
        std::vector<double> sigmas;
        std::vector<double> radii;
 
        for (const Trk::TrackStateOnSurface* tsos : *refittedTrack->trackStateOnSurfaces()) {
            // skip leading material
            if (!haveMeasurement) {
                if (tsos->measurementOnTrack()) { haveMeasurement = true; }
                continue;
            }
 
            // select MaterialEffects up to calorimeter volume
            if (!tsos->materialEffectsOnTrack()) continue;
 
            const Trk::MaterialEffectsOnTrack* meot = dynamic_cast<const Trk::MaterialEffectsOnTrack*>(tsos->materialEffectsOnTrack());
 
            const Amg::Vector3D& position = meot->associatedSurface().globalReferencePoint();
 
            if (!calorimeterVolume->inside(position)) break;
 
            if (!indetVolume->inside(position) && meot->energyLoss()) break;
 
            // get scattering angle
            const Trk::ScatteringAngles* scattering = meot->scatteringAngles();
            if (!scattering) continue;
 
            ++scatterers;
 
            if (tsos->measurementOnTrack()) {
                isMeasurement.push_back(true);
            } else {
                isMeasurement.push_back(false);
            }
 
            radii.push_back(tsos->trackParameters()->position().perp());
            double sigma = charge * scattering->deltaPhi() / scattering->sigmaDeltaPhi();
            totalSigma += sigma;
            sigmas.push_back(sigma);
 
            ATH_MSG_VERBOSE(scatterers << " radius " << tsos->trackParameters()->position().perp() << "   deltaPhi "
                                       << scattering->deltaPhi() << "   significance " << sigma << "  totalSignificance " << totalSigma);
        }
 
        if (!scatterers) { return ScatteringAngleSignificance(0); }
 
        // search for discontinuity point (sign change of integral scattering)
        // and maximum of neighbouring scatterers
        // FIXME: neighbouring means scatterers spanning neighbouring measurements
        double curvatureSignificance = totalSigma;
        double curvatureRadius = 0.;
        double neighbourSignificance = 0.;
        double neighbourRadius = 0.;
        double previousSignificance = 0.;
        double previousRadius = 0.;
        unsigned index = scatterers - 1;
 
        std::vector<double>::const_reverse_iterator rs = sigmas.rbegin();
        for (; rs != sigmas.rend(); ++rs, --index) {
            totalSigma -= 2. * (*rs);
 
            if (std::abs(totalSigma) > std::abs(curvatureSignificance)) {
                curvatureSignificance = totalSigma;
                curvatureRadius = radii[index];
            }
 
            if (std::abs(sigmas[index] + previousSignificance) > std::abs(neighbourSignificance)) {
                neighbourSignificance = sigmas[index] + previousSignificance;
 
                if (std::abs(neighbourSignificance) > 0.) {
                    neighbourRadius = (sigmas[index] * radii[index] + previousSignificance * previousRadius) / neighbourSignificance;
                } else {
                    neighbourRadius = 0.;
                }
            }
 
            previousSignificance = sigmas[index];
            previousRadius = radii[index];
        }
 
        // normalize
        curvatureSignificance /= std::sqrt(static_cast<double>(scatterers));
        neighbourSignificance *= OneOverSqrt2;
 
        ATH_MSG_DEBUG(" scatteringAngleSignificance " << curvatureSignificance << " at radius " << curvatureRadius
                                                      << " neighbourSignificance " << neighbourSignificance << " at radius "
                                                      << neighbourRadius << " from " << scatterers << " scatterers");
 
        return ScatteringAngleSignificance(scatterers, curvatureRadius, curvatureSignificance, neighbourRadius, neighbourSignificance);
    }

◆ spectrometerParameters()

std::unique_ptr< Trk::TrackParameters > Rec::MuonTrackQuery::spectrometerParameters	(	const Trk::Track &	track,
		const EventContext &	ctx ) const

overridevirtual

IMuonTrackQuery interface: trackParameters at innermost measurement TSOS in MS.

Implements Rec::IMuonTrackQuery.

Definition at line 749 of file MuonTrackQuery.cxx.

                                                                                                                                 {
        const Trk::TrackingVolume* calorimeterVolume = getVolume("Calo::Container", ctx);
 
        if (!calorimeterVolume) {
            ATH_MSG_WARNING("Failed to retrieve Calo volume ");
            return nullptr;
        }
 
        // find parameters at innermost spectrometer measurement
        // clone perigee if track has been slimmed
        const Trk::TrackParameters* parametersView{};
        for (const Trk::TrackStateOnSurface* pThisTrackState : *track.trackStateOnSurfaces()) {
            if (!pThisTrackState->measurementOnTrack() || pThisTrackState->type(Trk::TrackStateOnSurface::Outlier) ||
                !pThisTrackState->trackParameters() ||
                dynamic_cast<const Trk::PseudoMeasurementOnTrack*>(pThisTrackState->measurementOnTrack()) ||
                calorimeterVolume->inside(pThisTrackState->trackParameters()->position())) {
                continue;
            }
 
            if (parametersView && pThisTrackState->trackParameters()->position().mag() > parametersView->position().mag()) { break; }
            parametersView = pThisTrackState->trackParameters();
        }
 
        if (!parametersView) { parametersView = track.perigeeParameters(); }
 
        // if necessary, flip to outgoing parameters
        if (parametersView->momentum().dot(parametersView->position()) > 0.) {
            return parametersView->uniqueClone();  // creates new parameters as clone
        } else {
            ATH_MSG_VERBOSE(" flip spectrometer parameters ");
            return flippedParameters(*parametersView);  // creates new parameters as flipped clone
        }
    }

◆ spectrometerPhiQuality()

unsigned Rec::MuonTrackQuery::spectrometerPhiQuality	(	const Trk::Track &	track,
		const EventContext &	ctx ) const

overridevirtual

IMuonTrackQuery interface: assess the number of additional phi measurements needed for MS (or SA) track fit.

Implements Rec::IMuonTrackQuery.

Definition at line 785 of file MuonTrackQuery.cxx.

                                                                                                        {
        const Trk::TrackingVolume* calorimeterVolume = getVolume("Calo::Container", ctx);
 
        if (!calorimeterVolume) {
            ATH_MSG_WARNING("Failed to retrieve Calo volume ");
            return false;
        }
 
        // quality 0 - no additional phi measurement needed
        //         1 - phi direction un- (or poorly) constrained
        //         2 - no phi hits on track
        const Trk::TrackStateOnSurface* leadingPhiMeasurement = nullptr;
        const Trk::TrackStateOnSurface* trailingPhiMeasurement = nullptr;
 
        Trk::TrackStates::const_iterator s = track.trackStateOnSurfaces()->begin();
        for (; s != track.trackStateOnSurfaces()->end(); ++s) {
            if (!(**s).measurementOnTrack() || (**s).type(Trk::TrackStateOnSurface::Outlier) ||
                dynamic_cast<const Trk::PseudoMeasurementOnTrack*>((**s).measurementOnTrack()) || !(**s).trackParameters() ||
                calorimeterVolume->inside((**s).trackParameters()->position())) {
                continue;
            }
 
            Identifier id = m_edmHelperSvc->getIdentifier(*(**s).measurementOnTrack());
            if (!id.is_valid() || !m_idHelperSvc->measuresPhi(id)) { continue; }
 
            // require phi measurement from CSC or CompetingROT
            if (!dynamic_cast<const Muon::CompetingMuonClustersOnTrack*>((**s).measurementOnTrack()) && !m_idHelperSvc->isCsc(id)) {
                continue;
            }
 
            leadingPhiMeasurement = *s;
            break;
        }
 
        if (!leadingPhiMeasurement) return 2;
 
        Trk::TrackStates::const_reverse_iterator r = track.trackStateOnSurfaces()->rbegin();
        for (; r != track.trackStateOnSurfaces()->rend(); ++r) {
            if (!(**r).measurementOnTrack() || (**r).type(Trk::TrackStateOnSurface::Outlier) ||
                dynamic_cast<const Trk::PseudoMeasurementOnTrack*>((**r).measurementOnTrack()) || !(**r).trackParameters()) {
                continue;
            }
 
            if (calorimeterVolume->inside((**r).trackParameters()->position())) { break; }
 
            Identifier id = m_edmHelperSvc->getIdentifier(*(**r).measurementOnTrack());
 
            if (!id.is_valid() || !m_idHelperSvc->measuresPhi(id)) { continue; }
 
            if (*r != leadingPhiMeasurement) { trailingPhiMeasurement = *r; }
 
            break;
        }
 
        if (!trailingPhiMeasurement) { return 1; }
 
        // FIXME: check separation between phi meas
        double separation =
            (leadingPhiMeasurement->trackParameters()->position() - trailingPhiMeasurement->trackParameters()->position()).mag();
 
        if (separation < 2. * Units::meter) { return 1; }
 
        return 0;
    }

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

◆ triggerStationParameters()

std::unique_ptr< const Trk::TrackParameters > Rec::MuonTrackQuery::triggerStationParameters	(	const Trk::Track &	track,
		const EventContext &	ctx ) const

overridevirtual

IMuonTrackQuery interface: trackParameters at innermost trigger chamber TSOS in MS.

Implements Rec::IMuonTrackQuery.

Definition at line 850 of file MuonTrackQuery.cxx.

                                                                                                                        {
        const Trk::TrackingVolume* calorimeterVolume = getVolume("Calo::Container", ctx);
 
        if (!calorimeterVolume) {
            ATH_MSG_WARNING("Failed to retrieve Calo volume ");
            return nullptr;
        }
 
        // find parameters at innermost trigger station measurement
        // fails if track has been slimmed
        std::unique_ptr<const Trk::TrackParameters> parameters;
 
        Trk::TrackStates::const_iterator s = track.trackStateOnSurfaces()->begin();
        for (; s != track.trackStateOnSurfaces()->end(); ++s) {
            if (!(**s).measurementOnTrack() || (**s).type(Trk::TrackStateOnSurface::Outlier) || !(**s).trackParameters() ||
                !dynamic_cast<const Muon::CompetingMuonClustersOnTrack*>((**s).measurementOnTrack()) ||
                calorimeterVolume->inside((**s).trackParameters()->position())) {
                continue;
            }
 
            if (parameters && (**s).trackParameters()->position().mag() > parameters->position().mag()) { break; }
 
            parameters = (**s).trackParameters()->uniqueClone();
        }
 
        if (!parameters) return nullptr;
 
        // if necessary, flip to outgoing parameters
        if (parameters->momentum().dot(parameters->position()) > 0.) {
            parameters = parameters->uniqueClone();
        } else {
            ATH_MSG_VERBOSE(" flip spectrometer parameters ");
            parameters = flippedParameters(*parameters);
        }
 
        return parameters;
    }

◆ 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_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_edmHelperSvc

ServiceHandle<Muon::IMuonEDMHelperSvc> Rec::MuonTrackQuery::m_edmHelperSvc

private

Initial value:

{
            this,
            "edmHelper",
            "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
            "Handle to the service providing the IMuonEDMHelperSvc interface",
        }

Definition at line 102 of file MuonTrackQuery.h.

                                                           {
            this,
            "edmHelper",
            "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
            "Handle to the service providing the IMuonEDMHelperSvc interface",
        };

◆ 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_fitter

ToolHandle<Trk::ITrackFitter> Rec::MuonTrackQuery::m_fitter {this, "Fitter", "", "Track fitter tool"}

private

Definition at line 100 of file MuonTrackQuery.h.

100{this, "Fitter", "", "Track fitter tool"};

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Rec::MuonTrackQuery::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 109 of file MuonTrackQuery.h.

109{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

◆ m_mdtRotCreator

ToolHandle<Muon::IMdtDriftCircleOnTrackCreator> Rec::MuonTrackQuery::m_mdtRotCreator

private

Initial value:

{

this, "MdtRotCreator", "Muon::MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator", "MdtDriftCircleOnTrackCreator tool"}

Definition at line 111 of file MuonTrackQuery.h.

111 {

112 this, "MdtRotCreator", "Muon::MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator", "MdtDriftCircleOnTrackCreator tool"};

◆ m_trackingGeometryReadKey

SG::ReadCondHandleKey<Trk::TrackingGeometry> Rec::MuonTrackQuery::m_trackingGeometryReadKey

private

Initial value:

{this, "TrackingGeometryReadKey", "",

"Key of the TrackingGeometry conditions data."}

Definition at line 114 of file MuonTrackQuery.h.

114 {this, "TrackingGeometryReadKey", "",

115 "Key of the TrackingGeometry conditions data."};

◆ 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:

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ MuonTrackQuery()

◆ ~MuonTrackQuery()

Member Function Documentation

◆ caloEnergy()

◆ caloEnergyDeposit()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ extraDeps_update_handler()

◆ fieldIntegral()

◆ flippedParameters()

◆ getVolume()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ isCaloAssociated()

◆ isCombined()

◆ isExtrapolated()

◆ isLineFit()

◆ isProjective()

◆ isSectorOverlap()

◆ isSlimmed()

◆ momentumBalanceSignificance()

◆ msg()

◆ msgLvl()

◆ numberPseudoMeasurements()

◆ outgoingPerigee()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ scatteringAngleSignificance()

◆ spectrometerParameters()

◆ spectrometerPhiQuality()

◆ sysInitialize()

◆ sysStart()

◆ triggerStationParameters()

◆ updateVHKA()

Member Data Documentation

◆ m_detStore

◆ m_edmHelperSvc

◆ m_evtStore

◆ m_fitter

◆ m_idHelperSvc

◆ m_mdtRotCreator

◆ m_trackingGeometryReadKey

◆ m_varHandleArraysDeclared

◆ m_vhka