#include <MuTagMatchingTool.h>

Inheritance diagram for MuTagMatchingTool:

Collaboration diagram for MuTagMatchingTool:

Public Types
using	SurfDef = MuonCombined::MuonSegmentTagSurfaces::SurfDef
	Enum encoding the StationNames (BI, BO, EIA, etc.) More...

Public Member Functions
	MuTagMatchingTool (const std::string &t, const std::string &n, const IInterface *p)

virtual	~MuTagMatchingTool ()=default

virtual StatusCode	initialize () override

bool	match (const Trk::TrackParameters &atSurface, const Muon::MuonSegment &segment, int surfaceName) const override

bool	surfaceMatch (const Muon::MuonSegment &segment, int surfaceName) const override

bool	phiMatch (const Trk::TrackParameters &atSurface, const Muon::MuonSegment &segment) const override

bool	thetaMatch (const Trk::TrackParameters &atSurface, const Muon::MuonSegment &segment) const override

bool	rMatch (const Trk::TrackParameters &atSurface, const Muon::MuonSegment &segment) const override

std::unique_ptr< Trk::TrackParameters >	ExtrapolateTrktoMSEntrance (const EventContext &ctx, const Trk::Track &pTrack, Trk::PropDirection direction) const override
	Get extrapolation at MS entrance level. More...

std::unique_ptr< Trk::TrackParameters >	ExtrapolateTrktoMSSurface (const EventContext &ctx, const Trk::Surface &surface, const Trk::TrackParameters &pTrack, Trk::PropDirection direction) const override
	Get extrapolation at MSSurface level. More...

std::shared_ptr< Trk::AtaPlane >	ExtrapolateTrktoSegmentSurface (const EventContext &ctx, const Muon::MuonSegment &segment, const Trk::TrackParameters &pTrack, Trk::PropDirection direction) const override
	Get extrapolation at Segment Plane Surface level. More...

bool	matchSegmentPosition (const MuonCombined::MuonSegmentInfo &info, bool idHasEtaHits) const override

bool	matchSegmentDirection (const MuonCombined::MuonSegmentInfo &info, bool idHasEtaHits) const override

bool	matchPtDependentPull (const MuonCombined::MuonSegmentInfo &info, const Trk::Track &trk) const override

bool	matchDistance (const MuonCombined::MuonSegmentInfo &info) const override

bool	matchCombinedPull (const MuonCombined::MuonSegmentInfo &info) const override

MuonCombined::MuonSegmentInfo	muTagSegmentInfo (const EventContext &ctx, const Trk::Track *track, const Muon::MuonSegment &segment, std::shared_ptr< const Trk::AtaPlane > exTrack) const override

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	testExtrapolation (const Trk::Surface &pSurface, const Trk::Track &pTrack) const

bool	isCscSegment (const Muon::MuonSegment &seg) const

unsigned int	cscHits (const Muon::MuonSegment &seg) const

void	nrTriggerHits (const Muon::MuonSegment &seg, int &nRPC, int &nTGC) const

bool	hasPhi (const Muon::MuonSegment &seg) const

double	errorProtection (double exTrk_Err, bool isAngle) const

std::unique_ptr< Trk::Perigee >	flipDirection (const Trk::Perigee &inputPars) const

double	matchingDistanceCorrection (double resPos, double resAngle)

void	calculateLocalAngleErrors (const Trk::AtaPlane &expPars, double &exTrkErrXZ, double &exTrkErrYZ, double &covLocYYZ) const

void	calculateLocalAngleErrors (const Muon::MuonSegment &segment, double &exTrkErrXZ, double &exTrkErrYZ) const

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

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
ToolHandle< Trk::IExtrapolator >	m_IExtrapolator
	Pointer on IExtrapolator. More...

ToolHandle< Trk::IPropagator >	m_propagator
	Pointer on propagator for SL propagation. More...

PublicToolHandle< Muon::MuonEDMPrinterTool >	m_printer {this,"Printer", ""}

ToolHandle< Muon::IMuonSegmentHitSummaryTool >	m_hitSummaryTool

ToolHandle< Muon::IMuonSegmentSelectionTool >	m_selectionTool

ToolHandle< Trk::IResidualPullCalculator >	m_pullCalculator

ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc

ServiceHandle< Muon::IMuonEDMHelperSvc >	m_edmHelperSvc

std::string	m_t0Location

StoreGateSvc *	p_StoreGateSvc {}
	Pointer On StoreGateSvc. More...

SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_DetectorManagerKey

SG::ReadCondHandleKey< Trk::TrackingGeometry >	m_trackingGeometryReadKey

bool	m_assumeLocalErrors

bool	m_extrapolatePerigee

double	m_GLOBAL_THETA_CUT

double	m_GLOBAL_PHI_CUT

double	m_GLOBAL_R_CUT

double	m_MATCH_THETA

double	m_MATCH_PHI

double	m_MATCH_THETAANGLE

double	m_MATCH_PHIANGLE

double	m_ERROR_EX_POS_CUT

double	m_ERROR_EX_ANGLE_CUT

bool	m_doDistCut

double	m_DIST_POS

double	m_DIST_ANGLE

double	m_SAFE_THETA

double	m_SAFE_PHI

double	m_SAFE_THETAANGLE

double	m_SAFE_PHIANGLE

double	m_chamberPullCut

double	m_combinedPullCut

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 38 of file MuTagMatchingTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

◆ SurfDef

using IMuTagMatchingTool::SurfDef = MuonCombined::MuonSegmentTagSurfaces::SurfDef

inherited

Enum encoding the StationNames (BI, BO, EIA, etc.)

Definition at line 33 of file IMuTagMatchingTool.h.

Constructor & Destructor Documentation

◆ MuTagMatchingTool()

MuTagMatchingTool::MuTagMatchingTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 28 of file MuTagMatchingTool.cxx.

                                                                                                 : AthAlgTool(t, n, p) {
     declareInterface<IMuTagMatchingTool>(this);
  
     declareProperty("GlobalThetaCut", m_GLOBAL_THETA_CUT = 0.1);
     declareProperty("GlobalPhiCut", m_GLOBAL_PHI_CUT = 0.5);
     declareProperty("GlobalRCut", m_GLOBAL_R_CUT = 1000.);
  
     declareProperty("ThetaCut", m_MATCH_THETA = 5.);            // pull cut in local precision position (bending plane)
     declareProperty("PhiCut", m_MATCH_PHI = 30.);               // pull cut in local NON precision position
     declareProperty("ThetaAngleCut", m_MATCH_THETAANGLE = 5.);  // pull cut in local precision direction
     declareProperty("PhiAngleCut", m_MATCH_PHIANGLE = 30.);     // pull cut in local NON precision direction
  
     declareProperty("ErrorProtectionPosCut", m_ERROR_EX_POS_CUT = 5000.);
     declareProperty("ErrorProtectionDirCut", m_ERROR_EX_ANGLE_CUT = 0.35);
  
     declareProperty("DoDistanceCut", m_doDistCut = true);
     declareProperty("PositionDistance", m_DIST_POS = 2000.);
     declareProperty("AngleDistance", m_DIST_ANGLE = 0.7);
  
     declareProperty("ThetaSafety",
                     m_SAFE_THETA = 25.);              // additional uncertainty on precision plane position (bendig plane)
     declareProperty("PhiSafety", m_SAFE_PHI = 100.);  //  additional uncertainty on NON precision plane position
     declareProperty("ThetaAngleSafety",
                     m_SAFE_THETAANGLE = 0.0015);  //  additional uncertainty on precision plane direction
     declareProperty("PhiAngleSafety",
                     m_SAFE_PHIANGLE = 0.25);  //  additional uncertainty on NON precision plane direction
  
     declareProperty("ChamberPullCut",
                     m_chamberPullCut = 5.);  // Inside chamber pull is negative for outside chamber pull > 5 standard
                                              // deviations (from edge) in non precision plane
     declareProperty("CombinedPullCut",
                     m_combinedPullCut = 5.);  // Combined pull build from local precision position and angle including the correlation
  
     declareProperty("AssumeLocalErrors", m_assumeLocalErrors = true);
     declareProperty("ExtrapolatePerigee", m_extrapolatePerigee = false);
     declareProperty("MuonChamberT0s", m_t0Location = "MooreMuonChamberT0s");
 }

◆ ~MuTagMatchingTool()

virtual MuTagMatchingTool::~MuTagMatchingTool ( )

virtualdefault

Member Function Documentation

◆ calculateLocalAngleErrors() [1/2]

void MuTagMatchingTool::calculateLocalAngleErrors	(	const Muon::MuonSegment &	segment,
		double &	exTrkErrXZ,
		double &	exTrkErrYZ
	)		const

private

Definition at line 758 of file MuTagMatchingTool.cxx.

                                                                                                                                   {
     const Amg::MatrixX& segGlobCov = segment.localCovariance();
     angleXZerror = 999.;
     angleYZerror = 999.;
     //
     // the segment errors are stored in local angles (m_assumeLocalErrors = true);
     //
  
     if (m_assumeLocalErrors) {
         if (segGlobCov(Trk::phi, Trk::phi) >= 0 && segGlobCov(Trk::phi, Trk::phi) <= 999.0)
             angleXZerror = std::sqrt(segGlobCov(Trk::phi, Trk::phi));
         if (segGlobCov(Trk::theta, Trk::theta) >= 0 && segGlobCov(Trk::theta, Trk::theta) <= 999.0)
             angleYZerror = std::sqrt(segGlobCov(Trk::theta, Trk::theta));
     }
 }

◆ calculateLocalAngleErrors() [2/2]

void MuTagMatchingTool::calculateLocalAngleErrors	(	const Trk::AtaPlane &	expPars,
		double &	exTrkErrXZ,
		double &	exTrkErrYZ,
		double &	covLocYYZ
	)		const

private

Definition at line 774 of file MuTagMatchingTool.cxx.

                                                                            {
     
     if (!exTrack.covariance()) return;
     // Parameters are described as Trk::LocX, Trk::locY, Trk::phi, Trk::theta
     // So the errormatrix of the track 'localErrorMatrix' still holds global angle representation!!!!
     // retrieve Jabcobian to transform the global errors err_phi,err_theta to local errors err_alphaXZ, err_alphaYZ
     const Amg::RotationMatrix3D glob2loc = exTrack.associatedSurface().transform().rotation().inverse();
     const AmgVector(5)& exTrkParms = exTrack.parameters();
     Trk::JacobianPhiThetaLocalAngles jacobianExTrk(exTrkParms[Trk::phi], exTrkParms[Trk::theta], glob2loc);
  
     // start with global angles error matrix
     Amg::MatrixX anglesCovGlob(2, 2);
     anglesCovGlob(0, 0) = (*exTrack.covariance())(Trk::phi, Trk::phi);
     anglesCovGlob(1, 0) = (*exTrack.covariance())(Trk::theta, Trk::phi);
     anglesCovGlob(0, 1) = (*exTrack.covariance())(Trk::phi, Trk::theta);
     anglesCovGlob(1, 1) = (*exTrack.covariance())(Trk::theta, Trk::theta);
  
     // NEW METHOD
     const AmgSymMatrix(2)& anglesCovLoc = anglesCovGlob.similarity(jacobianExTrk);
  
     if (anglesCovLoc(0, 0) >= 0) angleXZerror = std::sqrt(anglesCovLoc(0, 0));
     if (anglesCovLoc(1, 1) >= 0) angleYZerror = std::sqrt(anglesCovLoc(1, 1));
  
     covLocYYZ = (*exTrack.covariance())(Trk::locY, Trk::phi) * jacobianExTrk(0, 1) +
                 (*exTrack.covariance())(Trk::locY, Trk::theta) * jacobianExTrk(1, 1);
     ATH_MSG_DEBUG(" covLocYYZ " << covLocYYZ << " covlocytheta " << (*exTrack.covariance())(Trk::locY, Trk::theta) << " J01 "
                                 << jacobianExTrk(0, 1) << " J11 " << jacobianExTrk(0, 1));
     // some printout
     ATH_MSG_DEBUG(std::setw(20) << "Angles Jacobian used for TRACK angle errors below: " << jacobianExTrk);
  
     ATH_MSG_DEBUG(std::setw(20) << "NEW TRACK angleXZ error = " << std::setprecision(6) << std::setw(10) << angleXZerror << std::setw(20)
                                 << " and angleYZ error = " << std::setw(10) << angleYZerror);
 }

◆ cscHits()

unsigned int MuTagMatchingTool::cscHits ( const Muon::MuonSegment & seg ) const

private

Definition at line 841 of file MuTagMatchingTool.cxx.

                                                                         {
     unsigned int nrHits{0};
     for (const Trk::MeasurementBase* seg_meas : seg.containedMeasurements()) {
         const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*>(seg_meas);
         if (!rot) {
             const Trk::CompetingRIOsOnTrack* crot = dynamic_cast<const Trk::CompetingRIOsOnTrack*>(seg_meas);
             if (crot) rot = &crot->rioOnTrack(0);
         }
         if (!rot) { continue; }
         if (m_idHelperSvc->isCsc(rot->identify())) ++nrHits;
     }
  
     return nrHits;
 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyArrayType &
	)

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleType &
	)

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

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

◆ errorProtection()

double MuTagMatchingTool::errorProtection	(	double	exTrk_Err,
		bool	isAngle
	)		const

private

Definition at line 290 of file MuTagMatchingTool.cxx.

                                                                               {
     double newError = exTrk_Err;
     if (!isAngle && (exTrk_Err > m_ERROR_EX_POS_CUT)) newError = m_ERROR_EX_POS_CUT;
     if (isAngle && (exTrk_Err > m_ERROR_EX_ANGLE_CUT)) newError = m_ERROR_EX_ANGLE_CUT;
  
     return newError;
 }

◆ evtStore() [1/2]

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

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { 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

◆ ExtrapolateTrktoMSEntrance()

std::unique_ptr< Trk::TrackParameters > MuTagMatchingTool::ExtrapolateTrktoMSEntrance	(	const EventContext &	ctx,
		const Trk::Track &	pTrack,
		Trk::PropDirection	direction
	)		const

overridevirtual

Get extrapolation at MS entrance level.

Get extrapolation at MS entrance: this will be the starting point to following extrapolations.

Implements IMuTagMatchingTool.

Definition at line 142 of file MuTagMatchingTool.cxx.

                                                                                                                             {
  
  
     const Trk::TrackingVolume* MSEntranceVolume = getVolume(ctx, "MuonSpectrometerEntrance");
     if (!MSEntranceVolume) { return nullptr; }
  
     std::unique_ptr<Trk::TrackParameters> exTrk{
         m_IExtrapolator->extrapolateToVolume(ctx, *(pTrack.perigeeParameters()), *MSEntranceVolume, direction, Trk::muon)};
  
     if (!exTrk)
         ATH_MSG_DEBUG("Track could not be extrapolated to MS entrance...");
     else
         ATH_MSG_DEBUG("Track extrapolated to MS entrance Radius " << exTrk->position().perp() << " Z " << exTrk->position().z());
  
     return exTrk;
 }

◆ ExtrapolateTrktoMSSurface()

std::unique_ptr< Trk::TrackParameters > MuTagMatchingTool::ExtrapolateTrktoMSSurface	(	const EventContext &	ctx,
		const Trk::Surface &	surface,
		const Trk::TrackParameters &	pTrack,
		Trk::PropDirection	direction
	)		const

overridevirtual

Get extrapolation at MSSurface level.

Implements IMuTagMatchingTool.

Definition at line 161 of file MuTagMatchingTool.cxx.

                                                                                                                            {
     std::unique_ptr<Trk::TrackParameters> exTrk{m_IExtrapolator->extrapolate(ctx, pTrack, pSurface, direction, false, Trk::muon)};
     if (!exTrk) {
         ATH_MSG_DEBUG(" didn't manage to extrapolate TrackParameters to abstract surface Radius " << pSurface.center().perp() << " Z "
                                                                                                   << pSurface.center().z());
     }
     return exTrk;
 }

◆ ExtrapolateTrktoSegmentSurface()

std::shared_ptr< Trk::AtaPlane > MuTagMatchingTool::ExtrapolateTrktoSegmentSurface	(	const EventContext &	ctx,
		const Muon::MuonSegment &	segment,
		const Trk::TrackParameters &	pTrack,
		Trk::PropDirection	direction
	)		const

overridevirtual

Get extrapolation at Segment Plane Surface level.

Implements IMuTagMatchingTool.

Definition at line 191 of file MuTagMatchingTool.cxx.

                                                                                                                    {
  
     unsigned int hits{cscHits(segment)};
     bool isCsc{hits>0};
     if (isCsc) {
         ATH_MSG_DEBUG("CSC segment has " << hits << " hits");
         if (hits < 5) {
             ATH_MSG_DEBUG("CSC segment is identified to be 2D. Not extrapolating.");
             return nullptr;
         }
     }
  
     std::shared_ptr<Trk::TrackParameters> atap{
         m_IExtrapolator->extrapolate(ctx, pTrack, segment.associatedSurface(), direction, false, Trk::muon)};
     if (!atap) {
         ATH_MSG_DEBUG(" didn't manage to extrapolate TrackParameters to segment surface Radius"
                       << segment.associatedSurface().center().perp() << " Z " << segment.associatedSurface().center().z());
         return nullptr;
     }
  
     std::shared_ptr<Trk::AtaPlane> matap = std::dynamic_pointer_cast<Trk::AtaPlane>(atap);
  
     if (!matap) {
         ATH_MSG_DEBUG(" didn't manage to extrapolate MeasuredTrackParameters to segment surface atap Radius "
                       << atap->position().perp() << " Z" << atap->position().z());
         return nullptr;
     } else {
         ATH_MSG_DEBUG(" Succesfull extrapolation segment surface matap Radius " << matap->position().perp() << " Z"
                                                                                 << matap->position().z());
     }
     return matap;
 }

◆ flipDirection()

std::unique_ptr< Trk::Perigee > MuTagMatchingTool::flipDirection ( const Trk::Perigee & inputPars ) const

private

Definition at line 173 of file MuTagMatchingTool.cxx.

                                                                                             {
     const AmgVector(5)& pars = inputPars.parameters();
  
     double flippedPhi = pars[2] + M_PI;
     if (flippedPhi > M_PI) flippedPhi -= 2 * M_PI;
     double flippedTheta = M_PI - pars[3];
     if (flippedTheta < 0.) flippedTheta += M_PI;
     if (inputPars.covariance()) {
         AmgSymMatrix(5) covMat = AmgSymMatrix(5)(*inputPars.covariance());
         const Trk::PerigeeSurface perSurf;
         return std::make_unique<Trk::Perigee>(-pars[0], pars[1], flippedPhi, flippedTheta, pars[4], perSurf, covMat);
     } else {
         ATH_MSG_DEBUG("flipDirection: no covariance associated to input parameters " << inputPars);
         return nullptr;
     }
 }

◆ getVolume()

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

inlineprivate

Definition at line 192 of file MuTagMatchingTool.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.cptr()->trackingVolume(vol_name);
     }

◆ hasPhi()

bool MuTagMatchingTool::hasPhi ( const Muon::MuonSegment & seg ) const

private

Definition at line 257 of file MuTagMatchingTool.cxx.

                                                                {
     Muon::IMuonSegmentHitSummaryTool::HitCounts hitCounts = m_hitSummaryTool->getHitCounts(seg);
     return hitCounts.nexpectedTrigHitLayers > 1;
 }

◆ initialize()

StatusCode MuTagMatchingTool::initialize ( )

overridevirtual

Definition at line 66 of file MuTagMatchingTool.cxx.

                                          {
     ATH_MSG_DEBUG("================================");
     ATH_MSG_DEBUG("=Proprieties are ");
     ATH_MSG_DEBUG("GlobalThetaCut" << std::setw(10) << m_GLOBAL_THETA_CUT);
     ATH_MSG_DEBUG("GlobaPhiCut" << std::setw(10) << m_GLOBAL_PHI_CUT);
     ATH_MSG_DEBUG("GlobalRCut" << std::setw(10) << m_GLOBAL_R_CUT);
     ATH_MSG_DEBUG("ThetaCut" << std::setw(10) << m_MATCH_THETA);
     ATH_MSG_DEBUG("PhiCut" << std::setw(10) << m_MATCH_PHI);
     ATH_MSG_DEBUG("ThetaAngleCut" << std::setw(10) << m_MATCH_THETAANGLE);
     ATH_MSG_DEBUG("PhiAngleCut" << std::setw(10) << m_MATCH_PHIANGLE);
     ATH_MSG_DEBUG("DoDistanceCut" << std::setw(10) << m_doDistCut);
     ATH_MSG_DEBUG("ThetaDistance" << std::setw(10) << m_DIST_POS);
     ATH_MSG_DEBUG("ThetaAngleDistance" << std::setw(10) << m_DIST_ANGLE);
     ATH_MSG_DEBUG("ThetaSafety" << std::setw(10) << m_SAFE_THETA);
     ATH_MSG_DEBUG("PhiSafety" << std::setw(10) << m_SAFE_PHI);
     ATH_MSG_DEBUG("ThetaAngleSafety" << std::setw(10) << m_SAFE_THETAANGLE);
     ATH_MSG_DEBUG("PhiAngleSafety" << std::setw(10) << m_SAFE_PHIANGLE);
  
     ATH_MSG_DEBUG("AssumeLocalErrors " << std::setw(10) << m_assumeLocalErrors);
     ATH_MSG_DEBUG("ExtrapolatePerigee " << std::setw(10) << m_extrapolatePerigee);
     ATH_MSG_DEBUG("================================");
  
     // Retrieve m_IExtrapolator
     ATH_CHECK(m_IExtrapolator.retrieve());
     ATH_MSG_DEBUG("Retrieved tool " << m_IExtrapolator);
  
     ATH_CHECK(m_propagator.retrieve());
  
     ATH_CHECK(m_hitSummaryTool.retrieve());
     ATH_CHECK(m_selectionTool.retrieve());
  
     // MuonDetectorManager from the conditions store
     ATH_CHECK(m_DetectorManagerKey.initialize());
  
     ATH_CHECK(m_idHelperSvc.retrieve());
     ATH_CHECK(m_edmHelperSvc.retrieve());
     ATH_CHECK(m_printer.retrieve());
     ATH_CHECK(m_pullCalculator.retrieve());
  
     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()

static const InterfaceID& IMuTagMatchingTool::interfaceID ( )

inlinestaticinherited

Definition at line 27 of file IMuTagMatchingTool.h.

                                             {
         static const InterfaceID IID_IMuTagMatchingTool("IMuTagMatchingTool", 1, 0);
         return IID_IMuTagMatchingTool;
     }

◆ isCscSegment()

bool MuTagMatchingTool::isCscSegment ( const Muon::MuonSegment & seg ) const

private

Definition at line 827 of file MuTagMatchingTool.cxx.

                                                                      {
     for (const Trk::MeasurementBase* seg_meas : seg.containedMeasurements()) {
         const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*>(seg_meas);
         if (!rot) {
             const Trk::CompetingRIOsOnTrack* crot = dynamic_cast<const Trk::CompetingRIOsOnTrack*>(seg_meas);
             if (crot) rot = &crot->rioOnTrack(0);
         }
         if (!rot) { continue; }
         if (m_idHelperSvc->isCsc(rot->identify())) return true;
     }
  
     return false;
 }

◆ match()

bool MuTagMatchingTool::match	(	const Trk::TrackParameters &	atSurface,
		const Muon::MuonSegment &	segment,
		int	surfaceName
	)		const

overridevirtual

We need a barrel function here

Implements IMuTagMatchingTool.

Definition at line 114 of file MuTagMatchingTool.cxx.

                                                      {
     // performs a rough match to an abstract MS surface (disc or cylinder)
     // by matching on station name (I M O, S L, B E) and a crude phi-position
     // match, followed by either a match in theta-position or r-position
     if (!surfaceMatch(segment, surfaceName)) return false;
  
     if (!phiMatch(atSurface, segment)) return false;
  
     const Identifier id = m_edmHelperSvc->chamberId(segment);
  
     if (m_idHelperSvc->regionIndex(id) == Muon::MuonStationIndex::Barrel)
         return thetaMatch(atSurface, segment);
     else
         return rMatch(atSurface, segment);
 }

◆ matchCombinedPull()

bool MuTagMatchingTool::matchCombinedPull ( const MuonCombined::MuonSegmentInfo & info ) const

overridevirtual

Implements IMuTagMatchingTool.

Definition at line 325 of file MuTagMatchingTool.cxx.

                                                                                        {
     bool pass(true);
     if (!info.segment || !info.trackAtSegment) {
         ATH_MSG_DEBUG(" No segment and or trackAtSegment pointer matchCombinedPull ");
         return false;
     }
     if (info.pullChamber > m_chamberPullCut) pass = false;
     if (std::abs(info.pullCY) > m_combinedPullCut) pass = false;
  
     ATH_MSG_DEBUG(" matchCombinedPull MuTagSegmentInfo hasPhi "
                   << info.hasPhi << " minimumPullPhi " << info.minimumPullPhi << " pullChamber " << info.pullChamber << " cut "
                   << m_chamberPullCut << " pullCY " << info.pullCY << " cut m_combinedPullCut " << m_combinedPullCut << " pass " << pass);
  
     return pass;
 }

◆ matchDistance()

bool MuTagMatchingTool::matchDistance ( const MuonCombined::MuonSegmentInfo & info ) const

overridevirtual

Implements IMuTagMatchingTool.

Definition at line 808 of file MuTagMatchingTool.cxx.

                                                                                    {
     bool pass(true);
     if (!info.segment || !info.trackAtSegment) {
         ATH_MSG_DEBUG(" No segment and or trackAtSegment pointer matchDistance ");
         return false;
     }
     if (!m_doDistCut) return pass;
  
     if (info.hasPhi) {
         if (std::abs(info.resX) > m_DIST_POS) pass = false;
         if (std::abs(info.dangleXZ) > m_DIST_ANGLE) pass = false;
     }
     if (info.maximumResidualAlongTube > m_DIST_POS) pass = false;
     if (std::abs(info.resY) > m_DIST_POS) pass = false;
     if (std::abs(info.dangleYZ) > m_DIST_ANGLE) pass = false;
  
     return pass;
 }

◆ matchingDistanceCorrection()

double MuTagMatchingTool::matchingDistanceCorrection	(	double	resPos,
		double	resAngle
	)

private

◆ matchPtDependentPull()

bool MuTagMatchingTool::matchPtDependentPull	(	const MuonCombined::MuonSegmentInfo &	info,
		const Trk::Track &	trk
	)		const

overridevirtual

Implements IMuTagMatchingTool.

Definition at line 341 of file MuTagMatchingTool.cxx.

                                                                                                                {
     bool pass(true);
     if (!info.segment || !info.trackAtSegment) {
         ATH_MSG_DEBUG(" No segment and or trackAtSegment pointermatchPtDependentPull ");
         return false;
     }
     double pT(100.);
     const Trk::Perigee* aMeasPer = trk.perigeeParameters();
     if (aMeasPer) {
         pT = aMeasPer->pT();
     }
     double Pullcut = 2.0;
  
     if (pT > 2.) { Pullcut = 5.0 - 6.0 / pT; }
     if (Pullcut > m_combinedPullCut) Pullcut = m_combinedPullCut;
  
     if (std::abs(info.pullCY) > Pullcut) pass = false;
  
     return pass;
 }

◆ matchSegmentDirection()

bool MuTagMatchingTool::matchSegmentDirection	(	const MuonCombined::MuonSegmentInfo &	info,
		bool	idHasEtaHits
	)		const

overridevirtual

Implements IMuTagMatchingTool.

Definition at line 314 of file MuTagMatchingTool.cxx.

                                                                                                               {
     if (!info.segment || !info.trackAtSegment) {
         ATH_MSG_DEBUG(" No segment and or trackAtSegment pointer matchSegmentDirection ");
         return false;
     }
     if (idHasEtaHits) {
         return std::abs(info.pullYZ) < m_MATCH_THETAANGLE || std::abs(info.pullCY) <  m_combinedPullCut;
     }
      return true;
 }

◆ matchSegmentPosition()

bool MuTagMatchingTool::matchSegmentPosition	(	const MuonCombined::MuonSegmentInfo &	info,
		bool	idHasEtaHits
	)		const

overridevirtual

Implements IMuTagMatchingTool.

Definition at line 298 of file MuTagMatchingTool.cxx.

                                                                                                              {
     if (!info.segment || !info.trackAtSegment) {
         ATH_MSG_DEBUG(" No segment and or trackAtSegment pointer matchSegmentPosition ");
         return false;
     }
  
     bool pass(false);
  
     if (idHasEtaHits) {
         if (std::abs(info.pullY) < m_MATCH_THETA || std::abs(info.pullCY) <  m_combinedPullCut) pass = true;
     } else {
         if (std::abs(info.pullX) < m_MATCH_PHI) pass = true;
     }
  
     return pass;
 }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ muTagSegmentInfo()

MuonCombined::MuonSegmentInfo MuTagMatchingTool::muTagSegmentInfo	(	const EventContext &	ctx,
		const Trk::Track *	track,
		const Muon::MuonSegment &	segment,
		std::shared_ptr< const Trk::AtaPlane >	exTrack
	)		const

overridevirtual

The cut off variable is used to avoid FPEs risen where one of the matrix enties exceeds a large number and hence the determinant becomes tremendously larger

What do these magic numbers represent?

Implements IMuTagMatchingTool.

Definition at line 466 of file MuTagMatchingTool.cxx.

                                                                                                                   {
     MuonCombined::MuonSegmentInfo info;
  
     //  segment and track pointers
  
     info.track = track;
     info.segment = &segment;
     info.trackAtSegment = exTrack;
  
     Muon::IMuonSegmentHitSummaryTool::HitCounts hitCounts = m_hitSummaryTool->getHitCounts(segment);
  
     // quality
  
     info.quality = m_selectionTool->quality(segment);
  
     // Global angular differences
  
     info.dtheta = exTrack->momentum().theta() - segment.globalDirection().theta();
     info.dphi =  exTrack->momentum().deltaPhi(segment.globalDirection());
  
     // Global angular differences for position
  
     info.dthetaPos = exTrack->position().theta() - segment.globalPosition().theta();
     info.dphiPos = exTrack->position().deltaPhi (segment.globalPosition());
  
     // Local positions
  
     info.resY = exTrack->parameters()[Trk::locY] - segment.localParameters()[Trk::locY];  // delta_theta
     info.resX = exTrack->parameters()[Trk::locX] - segment.localParameters()[Trk::locX];  // delta_phi
  
     // Local errors and covariance Matrix
  
     info.exCovYTheta = 0.;
     if (exTrack->covariance()) {
         ATH_MSG_DEBUG("Measured Parameters: error x " << (*exTrack->covariance())(Trk::locX, Trk::locX) << " y "
                                                       << (*exTrack->covariance())(Trk::locY, Trk::locY) << " pull x "
                                                       << info.resX / std::sqrt((*exTrack->covariance())(Trk::locX, Trk::locX)) << " pull y "
                                                       << info.resY / std::sqrt((*exTrack->covariance())(Trk::locY, Trk::locY)));
         info.exErrorX = std::sqrt((*exTrack->covariance())(Trk::locX, Trk::locX));
         info.exErrorY = std::sqrt((*exTrack->covariance())(Trk::locY, Trk::locY));
         if ((*exTrack->covariance())(Trk::theta, Trk::locY) != 0) { info.exCovYTheta = (*exTrack->covariance())(Trk::theta, Trk::locY); }
     } else {
         info.exErrorX = -999.;
         info.exErrorY = -999.;
     }
  
     // Segment local errors
     info.segErrorX = std::sqrt((segment.localCovariance())(Trk::locX, Trk::locX));
     info.segErrorY = std::sqrt((segment.localCovariance())(Trk::locY, Trk::locY));
  
     // Pull local X and Y
     double erexX = errorProtection(info.exErrorX, false);
     double erexY = errorProtection(info.exErrorY, false);
     info.pullX = info.resX / std::hypot(erexX, info.segErrorX, m_SAFE_PHI);
     info.pullY = info.resY / std::hypot(erexY, info.segErrorY, m_SAFE_THETA);
  
     // Local angles
  
     Trk::LocalDirection segLocDir = segment.localDirection();
     Trk::LocalDirection exTrkLocDir;
     exTrack->associatedSurface().globalToLocalDirection(exTrack->momentum(), exTrkLocDir);
     info.dangleYZ = exTrkLocDir.angleYZ() - segLocDir.angleYZ();  // deltaYZ
     info.dangleXZ = exTrkLocDir.angleXZ() - segLocDir.angleXZ();  // deltaXZ
     // delete exTrkLocDir;
  
     // Errors on local angles
     double exTrkErrXZ(0.), exTrkErrYZ(0.), segErrXZ(0.), segErrYZ(0.), covLocYYZ(0.);
  
     calculateLocalAngleErrors(*exTrack, exTrkErrXZ, exTrkErrYZ, covLocYYZ);
     info.exErrorXZ = exTrkErrXZ;
     info.exErrorYZ = exTrkErrYZ;
     info.exCovYZY = covLocYYZ;
     calculateLocalAngleErrors(segment, segErrXZ, segErrYZ);
     info.segErrorXZ = segErrXZ;
     info.segErrorYZ = segErrYZ;
     double erexXZ = errorProtection(info.exErrorXZ, true);
     double erexYZ = errorProtection(info.exErrorYZ, true);
  
     ATH_MSG_DEBUG(" exTrkLocDir.angleYZ() " << exTrkLocDir.angleYZ() << " segLocDir.angleYZ() " << segLocDir.angleYZ());
     ATH_MSG_DEBUG(" exTrkLocDir.angleXZ() " << exTrkLocDir.angleXZ() << " segLocDir.angleXZ() " << segLocDir.angleXZ());
  
     ATH_MSG_DEBUG(" info.exErrorYZ  " << info.exErrorYZ << " info.segErrorYZ " << info.segErrorYZ << " info.exCovYZY " << info.exCovYZY);
     ATH_MSG_DEBUG(" info.exErrorXZ  " << info.exErrorXZ << " info.segErrorXZ " << info.segErrorXZ);
  
     info.pullXZ = info.dangleXZ / std::hypot(erexXZ, info.segErrorXZ, m_SAFE_PHIANGLE);
     info.pullYZ = info.dangleYZ / std::hypot(erexYZ, info.segErrorYZ, m_SAFE_THETAANGLE);
  
     ATH_MSG_DEBUG(" info.pullXZ " << info.pullXZ);
  
     Identifier chId = m_edmHelperSvc->chamberId(segment);
     Muon::MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(chId);
     //
     //  residuals and pulls in X coordinate (along tube)
     //
  
     // MuonDetectorManager from the conditions store
     SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey, ctx};
     const MuonGM::MuonDetectorManager* MuonDetMgr = DetectorManagerHandle.cptr();
     if (!MuonDetMgr) {
         ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object");
         return info;
     }
     double maxResXMdt{-1e9}, maxResPhi{-1e9}, maxPullPhi{-1e9}, minResPhi{1e9}, minPullPhi{1e9};
     // loop over hits
     for (const Trk::MeasurementBase* seg_it : segment.containedMeasurements()) {
         const Muon::MdtDriftCircleOnTrack* mdt = dynamic_cast<const Muon::MdtDriftCircleOnTrack*>(seg_it);
         if (mdt) {
             // get id and check that it is a muon hit id
             Identifier id = mdt->identify();
  
             // get layer index
             int lay = m_idHelperSvc->mdtIdHelper().tubeLayer(id);
             int tube = m_idHelperSvc->mdtIdHelper().tube(id);
  
             const MuonGM::MdtReadoutElement* detEl =
                 mdt->prepRawData() ? mdt->prepRawData()->detectorElement() : MuonDetMgr->getMdtReadoutElement(id);
             if (!detEl) {
                 ATH_MSG_WARNING(" could not get MdtReadoutElement for tube " << m_idHelperSvc->toString(id));
                 continue;
             }
             double tubeLen = detEl->getActiveTubeLength(lay, tube);
  
             // use SL within station to speed up extrapolation
             // lifetime only in this scope
             std::unique_ptr<Trk::TrackParameters> exP = m_propagator->propagate(ctx, *exTrack, mdt->associatedSurface(), Trk::anyDirection, false, Trk::NoField);
             if (!exP) {
                 ATH_MSG_WARNING("Failed to extrapolate to " << m_idHelperSvc->toString(id));
                 continue;
             }
             ATH_MSG_DEBUG(m_idHelperSvc->toString(id)
                           << " exPos " << exP->parameters()[Trk::locR] << " y " << exP->parameters()[Trk::locZ] << " tubeL " << tubeLen);
             double exResidual = std::abs(exP->parameters()[Trk::locZ]) - 0.5 * tubeLen;
             if (maxResXMdt < exResidual) maxResXMdt = exResidual;
             if (exResidual > 0.) ATH_MSG_DEBUG("Extrapolated position outside tube, " << exResidual);
         } else {
             // get id and check that it is a muon hit id
             Identifier id = m_edmHelperSvc->getIdentifier(*seg_it);
             if (!id.is_valid() || !m_idHelperSvc->isMuon(id)) continue;
             if (!m_idHelperSvc->measuresPhi(id)) continue;
             // lifetime only in this scope
             std::unique_ptr<Trk::TrackParameters> exP{
                 m_propagator->propagate(ctx, *exTrack, seg_it->associatedSurface(), Trk::anyDirection, false, Trk::NoField)};
             if (!exP) {
                 ATH_MSG_WARNING("Failed to extrapolate to " << m_idHelperSvc->toString(id));
                 continue;
             }
             std::optional<Trk::ResidualPull> resPull{
                 m_pullCalculator->residualPull(seg_it, exP.get(), Trk::ResidualPull::Unbiased)};
             if (!resPull) {
                 ATH_MSG_WARNING(" calculation of residual/pull failed !!!!! ");
                 // delete exP;
                 continue;
             }
             const double residual = resPull->residual().front();
             const double pull = resPull->pull().front();
  
             maxResPhi = std::max(residual, maxResPhi);
             minResPhi = std::min(residual, minResPhi);
             maxPullPhi = std::max(pull, maxPullPhi);
             minPullPhi = std::min(pull, minPullPhi);
  
             ATH_MSG_DEBUG(m_idHelperSvc->toString(id) << " residual " << residual << " pull " << pull);
         }
     }
     ATH_MSG_DEBUG("Residual phi min " << minResPhi << " max " << maxResPhi << " pull min " << minPullPhi << " max " << maxPullPhi
                                       << " dist from tube end " << maxResXMdt);
  
     //
     //   Store the local X variables
     //
     info.maximumResidualAlongTube = maxResXMdt;
     info.maximumResidualPhi = maxResPhi;
     info.maximumPullPhi = maxPullPhi;
  
     info.minimumResidualPhi = minResPhi;
     info.minimumPullPhi = minPullPhi;
  
     info.pullChamber = maxResXMdt / info.exErrorX;
  
     //  Scale covariance Matrix (if needed)
     constexpr double matrix_cutoff = 1.e20;
     double a = std::pow(std::min(matrix_cutoff, info.exErrorY), 2);
     double b = std::abs(info.exCovYZY) < matrix_cutoff ? info.exCovYZY : (info.exCovYZY < 0 ? -1. : 1) * matrix_cutoff;
     double d = std::pow(std::min(matrix_cutoff, info.exErrorYZ), 2);
     double det = a * d - b * b;
  
     double scale = 1.;
     if (det < 0.1 * a * d) {
         scale = std::sqrt(0.9 * a * d) / std::abs(b);
         det = a * d - scale * b * scale * b;
     }
     if (det ==0.) {
         ATH_MSG_DEBUG("Found singular determinant");
         return info;
     }
     double dydyz = scale * info.exCovYZY;
     double correction = dydyz / std::max(info.exErrorYZ * info.exErrorYZ, DBL_EPSILON);
  
     //
     //  residual after taking into account the correlation with the angle YZ
     //
  
     info.resCY = info.resY - correction * info.dangleYZ;
  
     ATH_MSG_DEBUG(" segment direction theta " << segment.globalDirection().theta() << " position theta "
                                               << segment.globalPosition().theta() << " correction " << correction);
     ATH_MSG_DEBUG(" resY " << info.resY << " dangleYZ " << info.dangleYZ << " resCY " << info.resCY);
     double error_rescy = info.exErrorY * info.exErrorY - correction * correction * info.exErrorYZ * info.exErrorYZ;
     double error_segcy = info.segErrorY * info.segErrorY + correction * correction * info.segErrorYZ * info.segErrorYZ;
     if (error_rescy > 0) {
         error_rescy = std::sqrt(error_rescy + error_segcy);
     } else {
         error_rescy = std::sqrt(info.exErrorY * info.exErrorY + error_segcy);
     }
  
     //  pull after taking into account the correlation with the angle YZ
  
     info.pullCY = info.resCY / std::hypot(error_rescy, m_SAFE_THETA, correction * m_SAFE_THETAANGLE);
  
     // chi2 with full covariance matrix in Y and YZ plane
  
     double chi2Y = d * info.resY * info.resY - 2 * b * scale * info.resY * info.dangleYZ + a * info.dangleYZ * info.dangleYZ;
     info.chi2Y = 0.5*( chi2Y / det);
     if (info.chi2Y < 0) ATH_MSG_DEBUG(" NEGATIVE chi2Y " << chi2Y << " dydyz " << dydyz << " determinant " << det);
  
     bool hasPhi = hitCounts.nexpectedTrigHitLayers > 1;
  
     //
     // Store hasphi
     //
     info.hasPhi = hasPhi;
     info.t0 = 0.;
  
     // station layer
     info.stationLayer = 0;
     if (stIndex == Muon::MuonStationIndex::BI) info.stationLayer = 1;
     if (stIndex == Muon::MuonStationIndex::BM) info.stationLayer = 2;
     if (stIndex == Muon::MuonStationIndex::BO) info.stationLayer = 3;
     if (stIndex == Muon::MuonStationIndex::BE) info.stationLayer = 4;
     if (stIndex == Muon::MuonStationIndex::EI) info.stationLayer = m_idHelperSvc->isMdt(chId) ? 11 : 21;
     if (stIndex == Muon::MuonStationIndex::EM) info.stationLayer = 12;
     if (stIndex == Muon::MuonStationIndex::EO) info.stationLayer = 13;
     if (stIndex == Muon::MuonStationIndex::EE) info.stationLayer = 14;
  
     ATH_MSG_DEBUG("stationLayer " << info.stationLayer);
     // number of holes
     info.nholes = 0;
     const Muon::MuonSegmentQuality* q = dynamic_cast<const Muon::MuonSegmentQuality*>(segment.fitQuality());
     if (q) info.nholes = q->numberOfHoles();
  
     // number of segments
     info.nsegments = 1;
  
     // single ML
     info.singleML = 1;
     if (hitCounts.nmdtHitsMl1 > 0 && hitCounts.nmdtHitsMl2 > 0) info.singleML = 0;
  
     //   RLocY parametrized rejection as a function of locY
     //   RAYZ parametrized rejection as a function of Angle YZ
  
     //   parameters are used for selecting best segment in ambiguity solver
  
     constexpr double a_locY{13.8269}, b_locY{1.23548}, c_locY{2.73400}, a_AYZ{12.0655}, b_AYZ{1.87578}, c_AYZ{1.88660}, width_locY{20.},
         width_AYZ{0.004};
  
     double dlocY = info.resY;
     double dAYZ = info.dangleYZ;
  
     double logLocY = std::log(1 + std::abs(dlocY / width_locY));
     double logAYZ = std::log(1 + std::abs(dAYZ / width_AYZ));
  
     info.RLocY = a_locY / (1. + b_locY * (logLocY) * (logLocY) + c_locY * (logLocY) * (logLocY) * (logLocY));
     info.RAYZ = a_AYZ / (1. + b_AYZ * (logAYZ) * (logAYZ) + c_AYZ * (logAYZ) * (logAYZ) * (logAYZ));
  
     int selected = 0;
     scale = 1.;
  
     if (std::abs(info.pullY) < m_MATCH_THETA && std::abs(info.pullYZ) < m_MATCH_THETAANGLE &&
         std::abs(info.pullCY) < scale * m_combinedPullCut && info.pullChamber < m_chamberPullCut) {
         bool pass = true;
         if (pass) selected = 1;
     }
  
     info.selected = selected;
  
     return info;
 }

◆ nrTriggerHits()

void MuTagMatchingTool::nrTriggerHits	(	const Muon::MuonSegment &	seg,
		int &	nRPC,
		int &	nTGC
	)		const

private

Definition at line 451 of file MuTagMatchingTool.cxx.

                                                                                             {
     nRPC = 0;
     nTGC = 0;
     for (const Trk::MeasurementBase* seg_meas : seg.containedMeasurements()) {
         const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*>(seg_meas);
         if (!rot) {
             const Trk::CompetingRIOsOnTrack* crot = dynamic_cast<const Trk::CompetingRIOsOnTrack*>(seg_meas);
             if (crot) rot = &crot->rioOnTrack(0);
         }
         if (!rot) { continue; }
         if (m_idHelperSvc->isRpc(rot->identify())) ++nRPC;
         if (m_idHelperSvc->isTgc(rot->identify())) ++nTGC;
     }
 }

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

◆ phiMatch()

bool MuTagMatchingTool::phiMatch	(	const Trk::TrackParameters &	atSurface,
		const Muon::MuonSegment &	segment
	)		const

overridevirtual

Implements IMuTagMatchingTool.

Definition at line 227 of file MuTagMatchingTool.cxx.

                                                                                                           {
     double PHI_CUT = m_GLOBAL_PHI_CUT;
     if (hasPhi(segment)) PHI_CUT = m_GLOBAL_PHI_CUT / 2.;
  
     const Amg::Vector3D exTrkPos = atSurface.position();
     const Amg::Vector3D& segPos = segment.globalPosition();
  
     const double deltaPhi = exTrkPos.deltaPhi(segPos);
  
     double sigma_phi = 0.;
     if (atSurface.associatedSurface().type() == Trk::SurfaceType::Cylinder) {
         const AmgSymMatrix(5)& covAtCyl = *atSurface.covariance();
         double r = atSurface.associatedSurface().bounds().r();
         if ( r > 0 && covAtCyl(Trk::locRPhi, Trk::locRPhi) >= 0.) sigma_phi = Amg::error(covAtCyl, Trk::locRPhi) / r;
     } else if (atSurface.associatedSurface().type() == Trk::SurfaceType::Plane) {
             const AmgSymMatrix(5)& covAtPlane = *atSurface.covariance();
             sigma_phi = Amg::error(covAtPlane, Trk::phi0);
     } else if (atSurface.associatedSurface().type() == Trk::SurfaceType::Disc) {  // error in endcap
         const AmgSymMatrix(5)& covAtDisc = *atSurface.covariance();
         if (covAtDisc(Trk::locPhi, Trk::locPhi) >= 0.) sigma_phi = Amg::error(covAtDisc, Trk::locPhi);
     }
     double errPhi = std::hypot(PHI_CUT, sigma_phi);
     // if the difference between exTrk and Segment phi position falls within the errPhi, accept as rough match
     if (std::abs(deltaPhi) < errPhi)
         return true;  // BRes: TEMPORARY - segment direction not sure, so I'm making this match symmetric wrt Pi/2
     ATH_MSG_DEBUG(std::setw(30) << "roughPhi failed:  d_phi = " << std::setw(10) << std::abs(deltaPhi)  // BRes: TEMPORARY - same
                                     << " while the cut is set on " << std::setw(10) << errPhi);
     return false;
 }

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

◆ rMatch()

bool MuTagMatchingTool::rMatch	(	const Trk::TrackParameters &	atSurface,
		const Muon::MuonSegment &	segment
	)		const

overridevirtual

Implements IMuTagMatchingTool.

Definition at line 275 of file MuTagMatchingTool.cxx.

                                                                                                         {
     const Amg::Vector3D exTrkPos = atSurface.position();
     double L = exTrkPos.mag();
     double R_CUT = m_GLOBAL_R_CUT * (L / 7500.);  // mm
  
     const Amg::Vector3D& segPos = segment.globalPosition();
     const double dPerp = std::abs(exTrkPos.perp() - segPos.perp());
     if (dPerp < R_CUT)
         return true;
  
     ATH_MSG_DEBUG(std::setw(30) << "rough  R   failed:   d_R    = " << std::setw(10) << dPerp << " while the cut is set on "
                                     << std::setw(10) << R_CUT);
     return false;
 }

◆ surfaceMatch()

bool MuTagMatchingTool::surfaceMatch	(	const Muon::MuonSegment &	segment,
		int	surfaceName
	)		const

overridevirtual

Implements IMuTagMatchingTool.

Definition at line 136 of file MuTagMatchingTool.cxx.

                                                                                           {
     const Identifier id = m_edmHelperSvc->chamberId(segment);
     return surfaceName == MuonCombined::MuonSegmentTagSurfaces::stIdxToSurfDef(m_idHelperSvc->stationIndex(id), m_idHelperSvc->stationEta(id)>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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

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

◆ testExtrapolation()

void MuTagMatchingTool::testExtrapolation	(	const Trk::Surface &	pSurface,
		const Trk::Track &	pTrack
	)		const

private

Definition at line 362 of file MuTagMatchingTool.cxx.

                                                                                                   {
     const Trk::Perigee* oriPerigee = pTrack.perigeeParameters();
     if (!oriPerigee) {
         ATH_MSG_DEBUG("Couldn't get the measured Perigee from TP");
         return;
     }
     const EventContext& ctx = Gaudi::Hive::currentContext();
     const AmgVector(5)& oripars = oriPerigee->parameters();
     const Trk::PerigeeSurface periSurf;
     std::unique_ptr<Trk::Perigee> pPerigee = std::make_unique<Trk::Perigee>(oripars[0], oripars[1], oripars[2], oripars[3], 0., periSurf, std::nullopt);
     const Amg::Vector3D startPos = pPerigee->position();
     const Amg::Vector3D startMom = pPerigee->momentum();
     const AmgVector(5)& pars = pPerigee->parameters();
  
     ATH_MSG_DEBUG("==============================================================================");
     ATH_MSG_DEBUG("======= INITIAL TRACK PARAMETERS (PERIGEE)");
     ATH_MSG_DEBUG("=== parameters are " << pars[0] << "  " << pars[1] << " " << pars[2] << "  " << pars[3] << " " << pars[4]);
     ATH_MSG_DEBUG("=== global position " << startPos.x() << "  " << startPos.y() << "  " << startPos.z());
     ATH_MSG_DEBUG("=== global directn  " << startMom.phi() << "  " << startMom.theta());
  
     std::unique_ptr<Trk::TrackParameters> alongPars{
         m_IExtrapolator->extrapolate(ctx, *pPerigee, pSurface, Trk::alongMomentum, false, Trk::muon)};
  
     ATH_MSG_DEBUG("======= EXTRAPOLATED ALONG MOMENTUM ORIGINAL PERIGEE");
     if (alongPars) {
         const Amg::Vector3D alongPos = alongPars->position();
         const Amg::Vector3D alongMom = alongPars->momentum();
  
         ATH_MSG_DEBUG("=== global position " << alongPos.x() << "  " << alongPos.y() << "  " << alongPos.z());
         ATH_MSG_DEBUG("=== global position phi theta " << alongPos.phi() << "  " << alongPos.theta());
         ATH_MSG_DEBUG("=== global directn  " << alongMom.phi() << "  " << alongMom.theta());
     } else
         ATH_MSG_DEBUG("======= NOT EXTRAPOLATED");
  
     ATH_MSG_DEBUG("======= EXTRAPOLATED OPPOSITE MOMENTUM ORIGINAL PERIGEE");
     std::unique_ptr<const Trk::TrackParameters> oppositePars{
         m_IExtrapolator->extrapolate(ctx, *pPerigee, pSurface, Trk::oppositeMomentum, false, Trk::muon)};
     if (oppositePars) {
         const Amg::Vector3D oppositePos = oppositePars->position();
         const Amg::Vector3D oppositeMom = oppositePars->momentum();
         ATH_MSG_DEBUG("=== global position " << oppositePos.x() << "  " << oppositePos.y() << "  " << oppositePos.z());
         ATH_MSG_DEBUG("=== global position phi theta " << oppositePos.phi() << "  " << oppositePos.theta());
         ATH_MSG_DEBUG("=== global directn  " << oppositeMom.phi() << "  " << oppositeMom.theta());
     } else
         ATH_MSG_DEBUG("======= NOT EXTRAPOLATED");
  
  ;
     std::unique_ptr<const Trk::Perigee> flippedPerigee = flipDirection(*pPerigee);
     const AmgVector(5)& flipPars = flippedPerigee->parameters();
     const Amg::Vector3D flipPos = flippedPerigee->position();
     const Amg::Vector3D flipMom = flippedPerigee->momentum();
  
     ATH_MSG_DEBUG("======= FLIPPED TRACK PARAMETERS (PERIGEE)");
     ATH_MSG_DEBUG("=== phi and theta were " << pars[2] << "  " << pars[3] << " and are flipped to ");
     ATH_MSG_DEBUG("=== parameters are " << flipPars[0] << "  " << flipPars[1] << "  " << flipPars[2] << "  " << flipPars[3] << "  "
                                         << flipPars[4]);
     ATH_MSG_DEBUG("=== global position " << flipPos.x() << "  " << flipPos.y() << "  " << flipPos.z());
     ATH_MSG_DEBUG("=== global directn  " << flipMom.phi() << "  " << flipMom.theta());
  
     std::unique_ptr<const Trk::TrackParameters> alongFlipPars{
         m_IExtrapolator->extrapolate(ctx,*flippedPerigee, pSurface, Trk::alongMomentum, false, Trk::muon)};
  
     ATH_MSG_DEBUG("======= EXTRAPOLATED ALONGFLIP MOMENTUM ORIGINAL PERIGEE");
     if (alongFlipPars) {
         const Amg::Vector3D alongFlipPos = alongFlipPars->position();
         const Amg::Vector3D alongFlipMom = alongFlipPars->momentum();
         ATH_MSG_DEBUG("=== global position " << alongFlipPos.x() << "  " << alongFlipPos.y() << "  " << alongFlipPos.z());
         ATH_MSG_DEBUG("=== global position phi theta " << alongFlipPos.phi() << "  " << alongFlipPos.theta());
         ATH_MSG_DEBUG("=== global directn  " << alongFlipMom.phi() << "  " << alongFlipMom.theta());
     } else
         ATH_MSG_DEBUG("======= NOT EXTRAPOLATED");
  
     ATH_MSG_DEBUG("======= EXTRAPOLATED OPPOSITEFLIP MOMENTUM ORIGINAL PERIGEE");
     std::unique_ptr<const Trk::TrackParameters> oppositeFlipPars{
         m_IExtrapolator->extrapolate(ctx, *flippedPerigee, pSurface, Trk::oppositeMomentum, false, Trk::muon)};
     if (oppositeFlipPars) {
         const Amg::Vector3D oppositeFlipPos = oppositeFlipPars->position();
         const Amg::Vector3D oppositeFlipMom = oppositeFlipPars->momentum();
         ATH_MSG_DEBUG("=== global position " << oppositeFlipPos.x() << "  " << oppositeFlipPos.y() << "  " << oppositeFlipPos.z());
         ATH_MSG_DEBUG("=== global position phi theta " << oppositeFlipPos.phi() << "  " << oppositeFlipPos.theta());
         ATH_MSG_DEBUG("=== global directn  " << oppositeFlipMom.phi() << "  " << oppositeFlipMom.theta());
     } else
         ATH_MSG_DEBUG("======= NOT EXTRAPOLATED");
  
     ATH_MSG_DEBUG("==============================================================================");
  
 }

◆ thetaMatch()

bool MuTagMatchingTool::thetaMatch	(	const Trk::TrackParameters &	atSurface,
		const Muon::MuonSegment &	segment
	)		const

overridevirtual

Implements IMuTagMatchingTool.

Definition at line 262 of file MuTagMatchingTool.cxx.

                                                                                                             {
     double THETA_CUT = m_GLOBAL_THETA_CUT;
     const Amg::Vector3D exTrkPos = atSurface.position();
     const Amg::Vector3D& segPos = segment.globalPosition();
     const double dTheta = std::abs(exTrkPos.theta() - segPos.theta());
     if (dTheta < THETA_CUT)
         return true;
  
     ATH_MSG_DEBUG(std::setw(30) << "roughTheta failed: d_theta = " << std::setw(10) << dTheta << " while the cut is set on "
                                     << std::setw(10) << THETA_CUT);
     return false;
 }

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

bool MuTagMatchingTool::m_assumeLocalErrors

private

Definition at line 165 of file MuTagMatchingTool.h.

◆ m_chamberPullCut

double MuTagMatchingTool::m_chamberPullCut

private

Definition at line 189 of file MuTagMatchingTool.h.

◆ m_combinedPullCut

double MuTagMatchingTool::m_combinedPullCut

private

Definition at line 190 of file MuTagMatchingTool.h.

◆ m_DetectorManagerKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> MuTagMatchingTool::m_DetectorManagerKey

private

Initial value:

{
        this,
        "DetectorManagerKey",
        "MuonDetectorManager",
        "Key of input MuonDetectorManager condition data",
    }

Definition at line 155 of file MuTagMatchingTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_DIST_ANGLE

double MuTagMatchingTool::m_DIST_ANGLE

private

Definition at line 182 of file MuTagMatchingTool.h.

◆ m_DIST_POS

double MuTagMatchingTool::m_DIST_POS

private

Definition at line 181 of file MuTagMatchingTool.h.

◆ m_doDistCut

bool MuTagMatchingTool::m_doDistCut

private

Definition at line 180 of file MuTagMatchingTool.h.

◆ m_edmHelperSvc

ServiceHandle<Muon::IMuonEDMHelperSvc> MuTagMatchingTool::m_edmHelperSvc

private

Initial value:

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

Definition at line 144 of file MuTagMatchingTool.h.

◆ m_ERROR_EX_ANGLE_CUT

double MuTagMatchingTool::m_ERROR_EX_ANGLE_CUT

private

Definition at line 178 of file MuTagMatchingTool.h.

◆ m_ERROR_EX_POS_CUT

double MuTagMatchingTool::m_ERROR_EX_POS_CUT

private

Definition at line 177 of file MuTagMatchingTool.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_extrapolatePerigee

bool MuTagMatchingTool::m_extrapolatePerigee

private

Definition at line 166 of file MuTagMatchingTool.h.

◆ m_GLOBAL_PHI_CUT

double MuTagMatchingTool::m_GLOBAL_PHI_CUT

private

Definition at line 169 of file MuTagMatchingTool.h.

◆ m_GLOBAL_R_CUT

double MuTagMatchingTool::m_GLOBAL_R_CUT

private

Definition at line 170 of file MuTagMatchingTool.h.

◆ m_GLOBAL_THETA_CUT

double MuTagMatchingTool::m_GLOBAL_THETA_CUT

private

Definition at line 168 of file MuTagMatchingTool.h.

◆ m_hitSummaryTool

ToolHandle<Muon::IMuonSegmentHitSummaryTool> MuTagMatchingTool::m_hitSummaryTool

private

Initial value:

{
        this,
        "MuonSegmentHitSummary",
        "Muon::MuonSegmentHitSummaryTool/MuonSegmentHitSummaryTool",
    }

Definition at line 123 of file MuTagMatchingTool.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuTagMatchingTool::m_idHelperSvc

private

Initial value:

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

Definition at line 139 of file MuTagMatchingTool.h.

◆ m_IExtrapolator

ToolHandle<Trk::IExtrapolator> MuTagMatchingTool::m_IExtrapolator

private

Initial value:

{
        this,
        "IExtrapolator",
        "Trk::Extrapolator/AtlasExtrapolator",
    }

Pointer on IExtrapolator.

Definition at line 112 of file MuTagMatchingTool.h.

◆ m_MATCH_PHI

double MuTagMatchingTool::m_MATCH_PHI

private

Definition at line 173 of file MuTagMatchingTool.h.

◆ m_MATCH_PHIANGLE

double MuTagMatchingTool::m_MATCH_PHIANGLE

private

Definition at line 175 of file MuTagMatchingTool.h.

◆ m_MATCH_THETA

double MuTagMatchingTool::m_MATCH_THETA

private

Definition at line 172 of file MuTagMatchingTool.h.

◆ m_MATCH_THETAANGLE

double MuTagMatchingTool::m_MATCH_THETAANGLE

private

Definition at line 174 of file MuTagMatchingTool.h.

◆ m_printer

PublicToolHandle<Muon::MuonEDMPrinterTool> MuTagMatchingTool::m_printer {this,"Printer", ""}

private

Definition at line 122 of file MuTagMatchingTool.h.

◆ m_propagator

ToolHandle<Trk::IPropagator> MuTagMatchingTool::m_propagator

private

Initial value:

{
        this,
        "Propagator",
        "Trk::RungeKuttaPropagator/AtlasRungeKuttaPropagator",
    }

Pointer on propagator for SL propagation.

Definition at line 117 of file MuTagMatchingTool.h.

◆ m_pullCalculator

ToolHandle<Trk::IResidualPullCalculator> MuTagMatchingTool::m_pullCalculator

private

Initial value:

{
        this,
        "ResidualPullCalculator",
        "Trk::ResidualPullCalculator/ResidualPullCalculator",
    }

Definition at line 133 of file MuTagMatchingTool.h.

◆ m_SAFE_PHI

double MuTagMatchingTool::m_SAFE_PHI

private

Definition at line 185 of file MuTagMatchingTool.h.

◆ m_SAFE_PHIANGLE

double MuTagMatchingTool::m_SAFE_PHIANGLE

private

Definition at line 187 of file MuTagMatchingTool.h.

◆ m_SAFE_THETA

double MuTagMatchingTool::m_SAFE_THETA

private

Definition at line 184 of file MuTagMatchingTool.h.

◆ m_SAFE_THETAANGLE

double MuTagMatchingTool::m_SAFE_THETAANGLE

private

Definition at line 186 of file MuTagMatchingTool.h.

◆ m_selectionTool

ToolHandle<Muon::IMuonSegmentSelectionTool> MuTagMatchingTool::m_selectionTool

private

Initial value:

{
        this,
        "MuonSegmentSelection",
        "Muon::MuonSegmentSelectionTool/MuonSegmentSelectionTool",
    }

Definition at line 128 of file MuTagMatchingTool.h.

◆ m_t0Location

std::string MuTagMatchingTool::m_t0Location

private

Definition at line 151 of file MuTagMatchingTool.h.

◆ m_trackingGeometryReadKey

SG::ReadCondHandleKey<Trk::TrackingGeometry> MuTagMatchingTool::m_trackingGeometryReadKey

private

Initial value:

{this, "TrackingGeometryReadKey", "",

"Key of input TrackingGeometry"}

Definition at line 162 of file MuTagMatchingTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ p_StoreGateSvc

StoreGateSvc* MuTagMatchingTool::p_StoreGateSvc {}

private

Pointer On StoreGateSvc.

Definition at line 152 of file MuTagMatchingTool.h.

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

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

◆ SurfDef

Constructor & Destructor Documentation

◆ MuTagMatchingTool()

◆ ~MuTagMatchingTool()

Member Function Documentation

◆ calculateLocalAngleErrors() [1/2]

◆ calculateLocalAngleErrors() [2/2]

◆ cscHits()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ errorProtection()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ ExtrapolateTrktoMSEntrance()

◆ ExtrapolateTrktoMSSurface()

◆ ExtrapolateTrktoSegmentSurface()

◆ flipDirection()

◆ getVolume()

◆ hasPhi()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ isCscSegment()

◆ match()

◆ matchCombinedPull()

◆ matchDistance()

◆ matchingDistanceCorrection()

◆ matchPtDependentPull()

◆ matchSegmentDirection()

◆ matchSegmentPosition()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ muTagSegmentInfo()

◆ nrTriggerHits()

◆ outputHandles()

◆ phiMatch()

◆ renounce()

◆ renounceArray()

◆ rMatch()

◆ surfaceMatch()

◆ sysInitialize()

◆ sysStart()

◆ testExtrapolation()

◆ thetaMatch()

◆ updateVHKA()

Member Data Documentation

◆ m_assumeLocalErrors

◆ m_chamberPullCut

◆ m_combinedPullCut

◆ m_DetectorManagerKey

◆ m_detStore

◆ m_DIST_ANGLE

◆ m_DIST_POS

◆ m_doDistCut

◆ m_edmHelperSvc

◆ m_ERROR_EX_ANGLE_CUT

◆ m_ERROR_EX_POS_CUT

◆ m_evtStore

◆ m_extrapolatePerigee