tool to match segments using a curved trajectory. More...

#include <MuonSegmentMatchingTool.h>

Inheritance diagram for Muon::MuonSegmentMatchingTool:

Collaboration diagram for Muon::MuonSegmentMatchingTool:

Public Member Functions
	MuonSegmentMatchingTool (const std::string &, const std::string &, const IInterface *)
	constructor More...

virtual	~MuonSegmentMatchingTool ()=default
	destructor More...

StatusCode	initialize ()
	AlgTool initilize. More...

StatusCode	finalize ()
	AlgTool finalize. More...

bool	match (const EventContext &ctx, const MuonSegment &seg1, const MuonSegment &seg2) const
	match two segments More...

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 ()
	access to tool interface More...

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
bool	straightLineMatch (const MuonSegment &seg1, const MuonSegment &seg2) const
	perform straight line matching using SL extrapolation More...

bool	curvedMatch (const MuonSegment &seg1, const MuonSegment &seg2) const
	perform curved matching More...

bool	overlapMatch (const EventContext &ctx, const MuonSegment &seg1, const MuonSegment &seg2) const
	perform overlap matching More...

bool	initializeField () const
	setup field More...

bool	hasStereoAngle (const Identifier &id1, const Identifier &id2) const
	check whether the two segments have a stereo angle More...

bool	isSLMatch (const Identifier &chid1, const Identifier &chid2) const
	check whether we should perform a straight line match More...

bool	suppressNoise (const MuonSegment &seg1, const MuonSegment &seg2, const bool &useTightCuts) const
	Suppress noise from cavern background/pile up using basic cuts More...

bool	suppressNoisePhi (const MuonSegment &seg1, const MuonSegment &seg2, const bool &useTightCuts) const
	Suppress noise from cavern background/pile up using basic cuts in phi. More...

void	simpleEndcapExtrapolate (double x_segment, double y_segment, double z_segment, double theta_segment, double z_extrapolated, double &r_expected, double &theta_expected, double &rhoInv) const
	extrapolate segment in middle or outer endcap station to inner layer assuming the particle came from the IP More...

bool	endcapExtrapolationMatch (const MuonSegment &seg1, const MuonSegment &seg2, bool useTightCuts) const
	match an endcap middle or outer segment with an inner segment using a simple analytic extrapolation model More...

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
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc

ServiceHandle< Muon::IMuonEDMHelperSvc >	m_edmHelperSvc
	EDM Helper tool. More...

PublicToolHandle< Muon::MuonEDMPrinterTool >	m_printer
	EDM printer tool. More...

ToolHandle< Muon::IMuonSegmentInOverlapResolvingTool >	m_overlapResolvingTool
	matching tool to handle the overlaps More...

ToolHandle< Muon::IMuonSegmentPairMatchingTool >	m_pairMatchingTool
	matching tool to handle the pairs of segments More...

Gaudi::Property< bool >	m_toroidOn {this, "ToroidOn", true, "Status of toroidal B-Field"}

std::atomic_uint	m_straightLineMatches {0}

std::atomic_uint	m_straightLineMatchesGood {0}

std::atomic_uint	m_overlapMatches {0}

std::atomic_uint	m_overlapMatchesGood {0}

std::atomic_uint	m_curvedMatches {0}

std::atomic_uint	m_curvedMatchesGood {0}

std::atomic_uint	m_duplicateHitUses {0}

bool	m_isCosmics

bool	m_doOverlapMatch

bool	m_doStraightLineMatch

bool	m_doCurvedMatch

bool	m_thetaMatch

bool	m_phiMatch

bool	m_useLocalAngles {}

double	m_straightLineMatchAngleCut

double	m_straightLineMatchPositionCut

double	m_overlapMatchAngleDPhiCut
	cut of the angular difference between phi from phi match and phi from positions More...

double	m_overlapMatchAngleDYZCut
	cut of the angular difference between phi from phi match and phi from positions More...

double	m_overlapMatchPositionCut
	cut on the distance of best position from the chamber bounds More...

double	m_overlapMatchPositionResidualCut
	cut on the position residual for the best position match More...

double	m_overlapMatchPhiHitPullCut
	cut on the average pull of the phi hits with the new segment parameters More...

double	m_angleABCut {}

double	m_maxDistSegments
	cut on the maximum distance between the segments More...

double	m_minDistSegmentsCosmics {}
	cut on the minimum distance between the segments, if the distance is larger More...

double	m_matchingbibm_lphisec

double	m_matchingbibo_lphisec

double	m_matchingbmbo_lphisec

double	m_matchingeiem_lphisec

double	m_matchingeieo_lphisec

double	m_matchingemeo_lphisec

double	m_matchingbibm_sphisec

double	m_matchingbibo_sphisec

double	m_matchingbmbo_sphisec

double	m_matchingeiem_sphisec

double	m_matchingeieo_sphisec

double	m_matchingemeo_sphisec

double	m_matchingbee_sphisec {}

bool	m_onlySameSectorIfTight
	reject all segments in different sectors if in tight matching More...

bool	m_useTightCuts
	only apply tight selection for busy combinations More...

bool	m_dumpAngles
	dump matching angle info to screen More...

bool	m_useEndcapExtrapolationMatching

double	m_drExtrapRMS

double	m_drExtrapAlignmentOffset

double	m_dthetaExtrapRMS

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

tool to match segments using a curved trajectory.

The tool decides whether the matching should be performed with curvature or with a straight line. Cases in which a straight line will be used:

no magnetic field in the muon spectrometer
endcap middle/outer combination
small/large overlap in one station layer

Definition at line 33 of file MuonSegmentMatchingTool.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

◆ MuonSegmentMatchingTool()

Muon::MuonSegmentMatchingTool::MuonSegmentMatchingTool	(	const std::string &	ty,
		const std::string &	na,
		const IInterface *	pa
	)

constructor

Definition at line 14 of file MuonSegmentMatchingTool.cxx.

     : AthAlgTool(ty, na, pa) {
     declareInterface<IMuonSegmentMatchingTool>(this);
     declareProperty("UseCosmicsSettings", m_isCosmics = false, "Pick up settings for cosmics");
     declareProperty("DoOverlapMatch", m_doOverlapMatch = true,
                     "Perform matching for segments in a small/large overlap");
     declareProperty("DoStraightLineMatch", m_doStraightLineMatch = true,
                     "Perform matching for segments in regions without field");
     declareProperty("DoCurvedMatch", m_doCurvedMatch = true, "Perform matching for segments in a field regions");
     declareProperty("doThetaMatching", m_thetaMatch = false, "Pre-matching in theta");
     declareProperty("doPhiMatching", m_phiMatch = false, "Pre-matching in phi");
  
     declareProperty(
         "OverlapMatchAngleDPhiCut", m_overlapMatchAngleDPhiCut = 0.15,
         "Cut on the angular difference between the best phi and the one consistent with the chamber bounds");
     declareProperty(
         "OverlapMatchAngleDYZCut", m_overlapMatchAngleDYZCut = 0.05,
         "Cut on the angular difference between the best phi and the one consistent with the chamber bounds");
     declareProperty("OverlapMatchPositionCut", m_overlapMatchPositionCut = 100.,
                     "Cut on the distance of recalculated position to the tube edge");
     declareProperty("OverlapMatchPositionResidualCut", m_overlapMatchPositionResidualCut = 30.,
                     "Cut on the segment position residual after recalculation of the paramters");
     declareProperty("OverlapMatchAveragePhiHitPullCut", m_overlapMatchPhiHitPullCut = 20.,
                     "Cut on the average pull of the phi hits with the new segment parameters");
  
     declareProperty("StraightLineMatchAngleCut", m_straightLineMatchAngleCut = 0.1,
                     "Cut on the angular difference between the extrapolated segment angle and reference");
     declareProperty("StraightLineMatchPositionCut", m_straightLineMatchPositionCut = 200.,
                     "Cut on the distance of extrapolated segment position and reference");
     declareProperty("MaxDistanceBetweenSegments", m_maxDistSegments = 5000.,
                     "If the two segments are further apart than this distance, they are considered to not match");
  
     declareProperty("OnlySameSectorIfTight", m_onlySameSectorIfTight = true,
                     "Accept only segments that are in the same sector for tight matching");
     declareProperty("TightSegmentMatching", m_useTightCuts = false,
                     "Use tight selection for busy event to suppress combinatorics and improve CPU");
  
     declareProperty("DumpAngles", m_dumpAngles = false,
                     "Print matching angle information to screen. WARNING: always returns True for suppressNoise");
     declareProperty("DoMatchingCutsBIBM_S", m_matchingbibm_sphisec = 0.015,
                     "Cut on sumDeltaYZ, segments in BI and BM, small phi sec");
     declareProperty("DoMatchingCutsBIBO_S", m_matchingbibo_sphisec = 0.015,
                     "Cut on sumDeltaYZ, segments in BI and BO, small phi sec");
     declareProperty("DoMatchingCutsBMBO_S", m_matchingbmbo_sphisec = 0.015,
                     "Cut on sumDeltaYZ, segments in BM and BO, small phi sec");
     declareProperty("DoMatchingCutsEIEM_S", m_matchingeiem_sphisec = 0.010 * 2,
                     "Cut on sumDeltaYZ, segments in EI and EM, small phi sec");
     declareProperty("DoMatchingCutsEIEO_S", m_matchingeieo_sphisec = 0.020 * 2,
                     "Cut on sumDeltaYZ, segments in EI and EO, small phi sec");
     declareProperty("DoMatchingCutsEMEO_S", m_matchingemeo_sphisec = 0.002,
                     "Cut on sumDeltaYZ, segments in EM and EO, small phi sec");
     declareProperty("DoMatchingCutsBIBM_L", m_matchingbibm_lphisec = 0.005,
                     "Cut on sumDeltaYZ, segments in BI and BM, large phi sec");
     declareProperty("DoMatchingCutsBIBO_L", m_matchingbibo_lphisec = 0.015,
                     "Cut on sumDeltaYZ, segments in BI and BO, large phi sec");
     declareProperty("DoMatchingCutsBMBO_L", m_matchingbmbo_lphisec = 0.010,
                     "Cut on sumDeltaYZ, segments in BM and BO, large phi sec");
     declareProperty("DoMatchingCutsEIEM_L", m_matchingeiem_lphisec = 0.015 * 2,
                     "Cut on sumDeltaYZ, segments in EI and EM, large phi sec");
     declareProperty("DoMatchingCutsEIEO_L", m_matchingeieo_lphisec = 0.025 * 2,
                     "Cut on sumDeltaYZ, segments in EI and EO, large phi sec");
     declareProperty("DoMatchingCutsEMEO_L", m_matchingemeo_lphisec = 0.002,
                     "Cut on sumDeltaYZ, segments in EM and EO, large phi sec");
     declareProperty("UseEndcapExtrapolationMatching", m_useEndcapExtrapolationMatching = true);
     declareProperty("DrExtrapolationRMS", m_drExtrapRMS = 10);
     declareProperty("DThetaExtrapolationRMS", m_dthetaExtrapRMS = 0.01 * 2);
     declareProperty("DrExtrapolationAlignementOffset", m_drExtrapAlignmentOffset = 50);
 }

◆ ~MuonSegmentMatchingTool()

virtual Muon::MuonSegmentMatchingTool::~MuonSegmentMatchingTool ( )

virtualdefault

destructor

Member Function Documentation

◆ curvedMatch()

bool Muon::MuonSegmentMatchingTool::curvedMatch	(	const MuonSegment &	seg1,
		const MuonSegment &	seg2
	)		const

private

perform curved matching

Definition at line 192 of file MuonSegmentMatchingTool.cxx.

 {
     ++m_curvedMatches;
  
     ATH_MSG_VERBOSE(" curved match ");
  
     // Suppress cavern background noise and combinatorics using both theta and phi matching
     if (m_thetaMatch)
         if (!suppressNoise(seg1, seg2, m_useTightCuts)) {
             return false;
         }
  
     // Suppress cavern background noise and combinatorics using phi matching
     if (m_phiMatch) {
         if (!suppressNoisePhi(seg1, seg2, m_useTightCuts)) return false;
     }
  
     ++m_curvedMatchesGood;
     return true;
 }

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

◆ endcapExtrapolationMatch()

bool Muon::MuonSegmentMatchingTool::endcapExtrapolationMatch	(	const MuonSegment &	seg1,
		const MuonSegment &	seg2,
		bool	useTightCuts
	)		const

private

match an endcap middle or outer segment with an inner segment using a simple analytic extrapolation model

Definition at line 780 of file MuonSegmentMatchingTool.cxx.

 {
  
     if (!m_useEndcapExtrapolationMatching) return true;
  
     Identifier chid1 = m_edmHelperSvc->chamberId(seg1);
     Identifier chid2 = m_edmHelperSvc->chamberId(seg2);
     if (chid1 == chid2) return false;
  
     MuonStationIndex::StIndex stIndex1 = m_idHelperSvc->stationIndex(chid1);
     MuonStationIndex::StIndex stIndex2 = m_idHelperSvc->stationIndex(chid2);
     if (stIndex1 == stIndex2) return false;
  
     const MuonSegment* segInner = nullptr;
     if (stIndex1 == MuonStationIndex::EI) segInner = &seg1;
     if (stIndex2 == MuonStationIndex::EI) segInner = &seg2;
  
     const MuonSegment* segOuter = nullptr;
     if (stIndex1 == MuonStationIndex::EM || stIndex1 == MuonStationIndex::EO) segOuter = &seg1;
     if (stIndex2 == MuonStationIndex::EM || stIndex2 == MuonStationIndex::EO) segOuter = &seg2;
  
     if (!segInner || !segOuter) {
         return false;
     }
     const Amg::Vector3D& pos1 = segOuter->globalPosition();
     const Amg::Vector3D& dir1 = segOuter->globalDirection();
     const Amg::Vector3D& pos2 = segInner->globalPosition();
     const Amg::Vector3D& dir2 = segInner->globalDirection();
  
     // extrapolate the first segment to the inner layer
     double r_expected{0.}, theta_expected{0.}, rhoInv{0.};
     simpleEndcapExtrapolate(pos1.x(), pos1.y(), pos1.z(), dir1.theta(), pos2.z(), r_expected, theta_expected, rhoInv);
  
     if (rhoInv < 0) rhoInv *= -1.;
     double dr     = pos2.perp() - r_expected;
     double dtheta = dir2.theta() - theta_expected;
  
       
     double drCut = m_drExtrapRMS + 5.e6 * rhoInv;
     if (useTightCuts)
         drCut *= 2;
     else
         drCut *= 4;
  
     if ((stIndex1 == MuonStationIndex::EM && stIndex2 == MuonStationIndex::BI)
         || (stIndex1 == MuonStationIndex::BI && stIndex2 == MuonStationIndex::EM))
     {
         drCut += 3 * m_drExtrapAlignmentOffset;
     } else {
         drCut += m_drExtrapAlignmentOffset;
     }
  
     double dthetaCut = m_dthetaExtrapRMS + 1.5e3 * rhoInv;
     if (useTightCuts)
         dthetaCut *= 2;
     else
         dthetaCut *= 4;
  
     ATH_MSG_VERBOSE(" simple match " << m_printer->print(seg1) << std::endl
                                      << "              " << m_printer->print(seg2) << std::endl
                                      << " dr " << dr << " cut " << drCut << " dtheta " << dtheta << " cut " << dthetaCut
                                      << " rhoInv " << 1e6 * rhoInv);
  
     if (std::abs(dr) > drCut) return false;
     if (std::abs(dtheta) > dthetaCut) return false;
     return true;
 }

◆ 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

◆ finalize()

StatusCode Muon::MuonSegmentMatchingTool::finalize ( )

AlgTool finalize.

Definition at line 96 of file MuonSegmentMatchingTool.cxx.

 {
     double goodOverlapMatchFraction =
         m_overlapMatches != 0 ? (double)m_overlapMatchesGood / ((double)m_overlapMatches) : 0.;
     ATH_MSG_INFO("Overlap matches:      total " << std::setw(7) << m_overlapMatches << " good " << std::setw(7)
                                                 << m_overlapMatchesGood << " fraction " << goodOverlapMatchFraction);
  
     double goodStraightLineMatchFraction =
         m_straightLineMatches != 0 ? (double)m_straightLineMatchesGood / ((double)m_straightLineMatches) : 0.;
     ATH_MSG_INFO("StraightLine matches: total " << std::setw(7) << m_straightLineMatches << " good " << std::setw(7)
                                                 << m_straightLineMatchesGood << " fraction "
                                                 << goodStraightLineMatchFraction);
  
     double goodCurvedMatchFraction =
         m_curvedMatches != 0 ? (double)m_curvedMatchesGood / ((double)m_curvedMatches) : 0.;
     ATH_MSG_INFO("Curved matches:       total " << std::setw(7) << m_curvedMatches << " good " << std::setw(7)
                                                 << m_curvedMatchesGood << " fraction " << goodCurvedMatchFraction);
  
     ATH_MSG_INFO("Segments sharing hits:       total " << std::setw(7) << m_duplicateHitUses);
  
  
     return StatusCode::SUCCESS;
 }

◆ hasStereoAngle()

bool Muon::MuonSegmentMatchingTool::hasStereoAngle	(	const Identifier &	id1,
		const Identifier &	id2
	)		const

private

check whether the two segments have a stereo angle

Definition at line 304 of file MuonSegmentMatchingTool.cxx.

 {
  
     // check whether same phi, else stereo angle (need correction for cosmic up-down tracks)
     int phi1 = m_idHelperSvc->mdtIdHelper().stationPhi(id1);
     int phi2 = m_idHelperSvc->mdtIdHelper().stationPhi(id2);
  
     if (phi1 != phi2) return true;
  
     // check whether there is a small/large overlap
     bool isSmallChamber1 = m_idHelperSvc->isSmallChamber(id1);
     bool isSmallChamber2 = m_idHelperSvc->isSmallChamber(id2);
  
     return isSmallChamber1 != isSmallChamber2;
 }

◆ initialize()

StatusCode Muon::MuonSegmentMatchingTool::initialize ( )

AlgTool initilize.

Definition at line 84 of file MuonSegmentMatchingTool.cxx.

 {
     ATH_CHECK(AthAlgTool::initialize());
     ATH_CHECK(m_edmHelperSvc.retrieve());
     ATH_CHECK(m_printer.retrieve());
     ATH_CHECK(m_idHelperSvc.retrieve());
     ATH_CHECK(m_pairMatchingTool.retrieve());
     ATH_CHECK(m_overlapResolvingTool.retrieve());
     return StatusCode::SUCCESS;
 }

◆ initializeField()

bool Muon::MuonSegmentMatchingTool::initializeField ( ) const

private

setup field

◆ 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& Muon::IMuonSegmentMatchingTool::interfaceID ( )

inlinestaticinherited

access to tool interface

Definition at line 29 of file IMuonSegmentMatchingTool.h.

                                                 {
             static const InterfaceID IID_IMuonSegmentMatchingTool("Muon::IMuonSegmentMatchingTool", 1, 0);
  
             return IID_IMuonSegmentMatchingTool;
         }

◆ isSLMatch()

bool Muon::MuonSegmentMatchingTool::isSLMatch	(	const Identifier &	chid1,
		const Identifier &	chid2
	)		const

private

check whether we should perform a straight line match

Definition at line 282 of file MuonSegmentMatchingTool.cxx.

 {
  
     // check whether there is field
     if (!m_toroidOn) return true;
  
     MuonStationIndex::StIndex stIndex1 = m_idHelperSvc->stationIndex(chid1);
     MuonStationIndex::StIndex stIndex2 = m_idHelperSvc->stationIndex(chid2);
  
     // check whether segments in same station
     if (stIndex1 == stIndex2) return true;
  
     // check whether segments in endcap EM/EO region
     if ((stIndex1 == MuonStationIndex::EO && stIndex2 == MuonStationIndex::EM)
         || (stIndex1 == MuonStationIndex::EM && stIndex2 == MuonStationIndex::EO))
         return true;
  
     // all other cases should be treated with curvature
     return false;
 }

◆ match()

bool Muon::MuonSegmentMatchingTool::match	(	const EventContext &	ctx,
		const MuonSegment &	seg1,
		const MuonSegment &	seg2
	)		const

virtual

match two segments

Implements Muon::IMuonSegmentMatchingTool.

Definition at line 120 of file MuonSegmentMatchingTool.cxx.

                                                                                                               {
  
     ATH_MSG_VERBOSE(" match: segments " << std::endl << m_printer->print(seg1) << std::endl << m_printer->print(seg2));
  
     // get identifiers
     Identifier chid1 = m_edmHelperSvc->chamberId(seg1);
     Identifier chid2 = m_edmHelperSvc->chamberId(seg2);
     if (chid1 == chid2) return false;
  
     MuonStationIndex::StIndex stIndex1 = m_idHelperSvc->stationIndex(chid1);
     MuonStationIndex::StIndex stIndex2 = m_idHelperSvc->stationIndex(chid2);
  
     if (isSLMatch(chid1, chid2)) {
         if (!m_idHelperSvc->isMdt(chid1) || !m_idHelperSvc->isMdt(chid2)) return false;
         // if there is a stereo angle match using overlap matching tool
  
         if (stIndex1 == stIndex2) {
  
             if (hasStereoAngle(chid1, chid2)) {
                 if (!m_doOverlapMatch) return true;
                 const int eta1 = m_idHelperSvc->mdtIdHelper().stationEta(chid1);
                 const int eta2 = m_idHelperSvc->mdtIdHelper().stationEta(chid2);
                 const int phi1 = m_idHelperSvc->sector(chid1);
                 const int phi2 = m_idHelperSvc->sector(chid2);
                 // require that the two segments are close in eta AND are in adjecent sectors
                 if (  std::abs(eta1-eta2) <=1 
                     && ( std::abs(phi1 - phi2) == 1 || (phi1 == 1 && phi2 == 16)
                         || (phi1 == 16 && phi2 == 1)))
                 {
                     return overlapMatch(ctx, seg1, seg2);
                 } else
                     return false;
             }
         }
         if (!m_doStraightLineMatch) return true;
  
         if (stIndex1 == stIndex2) return false;
  
         return straightLineMatch(seg1, seg2);
     }
  
     // if we get here perform a curved matching
     if (!m_doCurvedMatch) return true;
     if (stIndex1 == stIndex2) return false;
  
     return curvedMatch(seg1, seg2);
 }

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

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

◆ overlapMatch()

bool Muon::MuonSegmentMatchingTool::overlapMatch	(	const EventContext &	ctx,
		const MuonSegment &	seg1,
		const MuonSegment &	seg2
	)		const

private

perform overlap matching

Definition at line 214 of file MuonSegmentMatchingTool.cxx.

 {
     ++m_overlapMatches;
  
     ATH_MSG_VERBOSE(" overlap match ");
  
     Identifier chid = m_edmHelperSvc->chamberId(seg1);
  
     // check the distance between the two segments
     const float segDist = (seg1.globalPosition() - seg2.globalPosition()).mag();
     ATH_MSG_VERBOSE(" Distance between segments " << segDist);
     if (m_isCosmics && segDist > m_minDistSegmentsCosmics) {
         ATH_MSG_DEBUG(" Too far appart, accepting ");
         return true;
     }
     if (segDist > m_maxDistSegments) return false;
    
     if (!m_idHelperSvc->isMdt(chid)) {
         ATH_MSG_DEBUG(" not a mdt segment " << m_idHelperSvc->toString(chid));
         return true;
     }
  
     IMuonSegmentInOverlapResolvingTool::SegmentMatchResult result = m_overlapResolvingTool->matchResult(ctx, seg1, seg2);
  
     ATH_MSG_VERBOSE(result.toString());
  
     if (!result.goodMatch()) {
         ATH_MSG_DEBUG(" bad match ");
         return false;
     }
  
     result.phiResult = m_overlapResolvingTool->bestPhiMatch(seg1, seg2);
     if (std::abs(result.angularDifferencePhi) > m_overlapMatchAngleDPhiCut
         || std::abs(result.phiResult.deltaYZ) > m_overlapMatchAngleDYZCut)
     {
         ATH_MSG_DEBUG(" failed angle cut: diff phi  " << result.angularDifferencePhi << "  deltaYZ "
                                                       << result.phiResult.deltaYZ);
         return false;
     }
  
     if (std::abs(result.averagePhiHitPullSegment1) > m_overlapMatchPhiHitPullCut
         || std::abs(result.averagePhiHitPullSegment2) > m_overlapMatchPhiHitPullCut)
     {
         ATH_MSG_DEBUG(" failed phi hit pull cut: seg1 " << result.averagePhiHitPullSegment1 << "  seg2 "
                                                         << result.averagePhiHitPullSegment2);
         return false;
     }
  
     if (!result.segmentResult1.inBounds(m_overlapMatchPositionCut)
         || !result.segmentResult2.inBounds(m_overlapMatchPositionCut))
     {
         ATH_MSG_DEBUG(" failed position cut ");
         return false;
     }
  
     if (std::abs(result.segmentResult1.positionResidual) > m_overlapMatchPositionResidualCut
         || std::abs(result.segmentResult2.positionResidual) > m_overlapMatchPositionResidualCut)
     {
         ATH_MSG_DEBUG(" failed position residual cut: seg1 " << result.segmentResult1.positionResidual << "  seg2 "
                                                              << result.segmentResult2.positionResidual);
         return false;
     }
  
     ++m_overlapMatchesGood;
     return true;
 }

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

◆ simpleEndcapExtrapolate()

void Muon::MuonSegmentMatchingTool::simpleEndcapExtrapolate	(	double	x_segment,
		double	y_segment,
		double	z_segment,
		double	theta_segment,
		double	z_extrapolated,
		double &	r_expected,
		double &	theta_expected,
		double &	rhoInv
	)		const

private

extrapolate segment in middle or outer endcap station to inner layer assuming the particle came from the IP

Definition at line 851 of file MuonSegmentMatchingTool.cxx.

 {
     //
     // Endcap extrapolation with a parabolic track model
     //
     //     In the region z = z start - z end of the Toroid one has:
     //        r_expected  = z tan(theta) + (z  - z start)*(z  - z start)/ rho
     //
     //        outside this region No field
     //
     //     here z start = 6 000 z end = 10 000
     //     theta = direction at the vertex rho is the effective curvature
     //
     double z_start = 7000.;
     double z_end   = 12000.;
  
     if (z_extrapolated < 0) z_start = -z_start;
     if (z_extrapolated < 0) z_end = -z_end;
  
     double r_segment = std::hypot(x_segment , y_segment);
  
     if (std::abs(z_extrapolated) > std::abs(z_segment)) {
         ATH_MSG_WARNING(" extrapolate outwards is not implemented for z " << z_extrapolated);
         r_expected     = 0;
         theta_expected = 0.;
         return;
     }
     if (std::abs(z_segment) < std::abs(z_end)) {
         ATH_MSG_WARNING(" segment before end of Toroid: SL extrapolation is used implemented " << z_segment);
     }
  
     // use SL extrapolation to go to the z_end of the Toroid
     const double tan_seg = std::tan(theta_segment);
    
     double r_end = r_segment + (z_end - z_segment) * tan_seg;
  
     double zgeo     = (z_end - z_start) * (z_end - z_start) - 2 * z_end * (z_end - z_start);
     rhoInv          = (r_end - z_end * tan_seg) / zgeo;
     double tantheta = tan_seg - 2 * (z_end - z_start) * rhoInv;
     r_expected      = z_extrapolated * tantheta + (z_extrapolated - z_start) * (z_extrapolated - z_start) * rhoInv;
     //
     // increase radius by 30% wrt straight line
     //
     double r_SL    = r_segment + (z_extrapolated - z_segment) * tan_seg;
     r_expected     = r_expected + 0.3 * (r_expected - r_SL);
     theta_expected = std::atan(tantheta + 2 * (z_extrapolated - z_start) * rhoInv);
  
     if (tan_seg < 0 && theta_expected < 0) theta_expected += M_PI;
     if (tan_seg > 0 && theta_expected < 0) theta_expected = -theta_expected;
 }

◆ straightLineMatch()

bool Muon::MuonSegmentMatchingTool::straightLineMatch	(	const MuonSegment &	seg1,
		const MuonSegment &	seg2
	)		const

private

perform straight line matching using SL extrapolation

Definition at line 170 of file MuonSegmentMatchingTool.cxx.

 {
     ++m_straightLineMatches;
  
     ATH_MSG_VERBOSE(" straight line match ");
  
     // Suppress cavern background noise and combinatorics using both theta and phi matching
     if (m_thetaMatch)
         if (!suppressNoise(seg1, seg2, m_useTightCuts)) {
             return false;
         }
  
     // Suppress cavern background noise and combinatorics using phi matching
     if (m_phiMatch) {
         if (!suppressNoisePhi(seg1, seg2, m_useTightCuts)) return false;
     }
  
     ++m_straightLineMatchesGood;
     return true;
 }

◆ suppressNoise()

bool Muon::MuonSegmentMatchingTool::suppressNoise	(	const MuonSegment &	seg1,
		const MuonSegment &	seg2,
		const bool &	useTightCuts
	)		const

private

Suppress noise from cavern background/pile up using basic cuts

Definition at line 325 of file MuonSegmentMatchingTool.cxx.

 {
  
     // calculate matching variables
     IMuonSegmentPairMatchingTool::SegmentMatchResult result = m_pairMatchingTool->matchResult(seg1, seg2);
  
     MuonStationIndex::StIndex station_a = m_idHelperSvc->stationIndex(result.chid_a);
     MuonStationIndex::StIndex station_b = m_idHelperSvc->stationIndex(result.chid_b);
  
     bool isEndcap_a = m_idHelperSvc->isEndcap(result.chid_a);
     bool isCSC_a    = m_idHelperSvc->isCsc(result.chid_a);
     bool isBEE_a    = station_a == MuonStationIndex::BE;
  
     bool isEndcap_b = m_idHelperSvc->isEndcap(result.chid_b);
     bool isCSC_b    = m_idHelperSvc->isCsc(result.chid_b);
     bool isBEE_b    = station_b == MuonStationIndex::BE;
  
  
     if (m_dumpAngles) {
  
         std::cout << "SegmentPositionChange "
                   << " " << m_idHelperSvc->chamberNameString(result.chid_a) << " "
                   << m_idHelperSvc->chamberNameString(result.chid_b) << " " << result.phiSector_a << " "
                   << result.phiSector_b << " " << result.deltaTheta_a << " " << result.deltaTheta_b << " "
                   << result.deltaTheta << " " << result.angleAC << " " << result.angleBC << " " << result.angleAB
                   << std::endl;
         //      return true; // to get the maximum statistics and not be hindered by current cuts
     }
  
     ATH_MSG_VERBOSE("matching " << m_idHelperSvc->chamberNameString(result.chid_a) << " "
                                 << m_idHelperSvc->chamberNameString(result.chid_b) << " phis " << result.phiSector_a
                                 << " " << result.phiSector_b << " thetas " << result.deltaTheta_a << " "
                                 << result.deltaTheta_b << " thetaSum " << result.deltaTheta << " tight cuts "
                                 << useTightCuts);
  
     // The difference between the segment direction in the inner and outer stations ~< 60 degrees in all cases
     if (result.angleAB > 1.0) return false;
  
  
     // First: loose selection
     if (!useTightCuts) {
         if (isCSC_a || isCSC_b) {
             ATH_MSG_VERBOSE(" check CSC result ");
             if (result.phiSector_a != result.phiSector_b) {
                 return false;
             }
             if ((isCSC_a && !isEndcap_b) || (isCSC_b && !isEndcap_a)) return false;
             return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
         }
         // BEE
         else if (isBEE_a || isBEE_b)
         {
             ATH_MSG_VERBOSE(" check BEE result ");
             return result.deltaTheta <= 0.300;
         }
         // Barrel/endcap overlap
         else if (isEndcap_a != isEndcap_b)
         {
             ATH_MSG_VERBOSE(" check B-E result ");
             return result.deltaTheta <= 0.300;
         }
         // Phi-sector overlap
         else if (result.phiSector_a != result.phiSector_b)
         {
             ATH_MSG_VERBOSE(" check phiSector result ");
             if (result.deltaTheta > 0.300) {
                 ATH_MSG_VERBOSE(" check phiSector reject ");
                 return false;
             } else {
                 return true;
             }
         }
         // Barrel inner to middle station
         else if (station_a == MuonStationIndex::BI && station_b == MuonStationIndex::BM)
         {
             ATH_MSG_VERBOSE(" check BI BM result ");
             if (result.phiSector_a % 2 == 0) {
                 return result.deltaTheta <= 6.67 * m_matchingbibm_sphisec;
             } else if (result.phiSector_a % 2 == 1) {
                 return result.deltaTheta <= 6.67 * m_matchingbibm_lphisec;
             }
         }
         // Barrel inner to outer station
         else if (station_a == MuonStationIndex::BI && station_b == MuonStationIndex::BO)
         {
             ATH_MSG_VERBOSE(" check BI BO result ");
             if (result.phiSector_a % 2 == 0) {
                 return result.deltaTheta <= 6.67 * m_matchingbibo_sphisec;
             } else if (result.phiSector_a % 2 == 1) {
                 return result.deltaTheta <= 6.67 * m_matchingbibo_lphisec;
             }
         }
  
         // Barrel middle to outer station
         else if (station_a == MuonStationIndex::BM && station_b == MuonStationIndex::BO)
         {
             ATH_MSG_VERBOSE(" check BM BO result ");
             if (result.phiSector_a % 2 == 0) {
                 return result.deltaTheta <= 6.67 * m_matchingbmbo_sphisec;
             } else if (result.phiSector_a % 2 == 1) {
                 return result.deltaTheta <= 6.67 * m_matchingbmbo_lphisec;
             }
         }
         // Endcap inner to middle station
         else if (station_a == MuonStationIndex::EI && (station_b == MuonStationIndex::EM))
         {
             ATH_MSG_VERBOSE(" check EI EM result ");
             if (result.phiSector_a % 2 == 0) {
                 if (result.deltaTheta > 6.67 * m_matchingeiem_sphisec) {
                     ATH_MSG_VERBOSE(" reject EI EM S result ");
                     return false;
                 } else {
                     return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
                 }
             } else if (result.phiSector_a % 2 == 1) {
                 if (result.deltaTheta > 6.67 * m_matchingeiem_lphisec) {
                     ATH_MSG_VERBOSE(" reject EI EM L result ");
                     return false;
                 } else {
                     return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
                 }
             }
         }
         // Endcap inner to outer station
         else if (station_a == MuonStationIndex::EI && (station_b == MuonStationIndex::EO))
         {
             ATH_MSG_VERBOSE(" check EI EO result ");
             if (result.phiSector_a % 2 == 0) {
                 if (result.deltaTheta > 6.67 * m_matchingeieo_sphisec) {
                     ATH_MSG_VERBOSE(" reject EI EO S result ");
                     return false;
                 } else {
                     return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
                 }
             } else if (result.phiSector_a % 2 == 1) {
                 if (result.deltaTheta > 6.67 * m_matchingeieo_lphisec) {
                     ATH_MSG_VERBOSE(" reject EI EO L result ");
                     return false;
                 } else {
                     return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
                 }
             }
         }
         // Endcap middle to outer station
         else if (station_a == MuonStationIndex::EM && station_b == MuonStationIndex::EO)
         {
             // 5 mrad
             ATH_MSG_VERBOSE(" check EM EO result ");
             if (result.phiSector_a % 2 == 0) {
                 return result.deltaTheta <= 6.67 * m_matchingemeo_sphisec;
             } else if (result.phiSector_a % 2 == 1) {
                 return result.deltaTheta <= 6.67 * m_matchingemeo_lphisec;
             }
         }
  
         return true;
     }
  
     ATH_MSG_VERBOSE(" check further matching result ");
  
     // Second: tight selection if only if requested
     if (m_onlySameSectorIfTight && result.phiSector_a != result.phiSector_b) {
         ATH_MSG_VERBOSE(" rejection pair as in different sector and using tight cuts");
         return false;
     }
     if (isCSC_a || isCSC_b) {
         if (result.phiSector_a != result.phiSector_b) {
             return false;
         } else {
             if (result.deltaTheta > 0.100) {
                 return false;
             } else {
                 if ((isCSC_a && !isEndcap_b) || (isCSC_b && !isEndcap_a)) return false;
                 return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
             }
         }
  
  
     }
     // BEE
     else if (isBEE_a || isBEE_b)
     {
         return result.deltaTheta <= 0.200;
     }
     // Looser cut for segment in two different phi sectors
     else if (result.phiSector_a != result.phiSector_b)
     {
         return result.deltaTheta <= 0.150;
     }
     // Barrel/endcap overlap
     else if (isEndcap_a != isEndcap_b)
     {
         return result.deltaTheta <= 0.150;
     }
     // Phi-sector overlap
     else if (result.phiSector_a != result.phiSector_b)
     {
         unsigned nChambers_a = m_edmHelperSvc->chamberIds(seg1).size();
         unsigned nChambers_b = m_edmHelperSvc->chamberIds(seg2).size();
         if (nChambers_a < 2 && nChambers_b < 2) {
             return false;
         } else if (result.deltaTheta > 0.150) {
             return false;
         } else {
             return true;
         }
     }
     // Barrel inner to middle station
     else if (station_a == MuonStationIndex::BI && station_b == MuonStationIndex::BM)
     {
         if (result.phiSector_a % 2 == 0) {
             return result.deltaTheta <= m_matchingbibm_sphisec;
         } else if (result.phiSector_a % 2 == 1) {
             return result.deltaTheta <= m_matchingbibm_lphisec;
         }
     }
     // Barrel inner to outer station
     else if (station_a == MuonStationIndex::BI && station_b == MuonStationIndex::BO)
     {
         if (result.phiSector_a % 2 == 0) {
             return result.deltaTheta <= m_matchingbibo_sphisec;
         } else if (result.phiSector_a % 2 == 1) {
             return result.deltaTheta <= m_matchingbibo_lphisec;
         }
     }
     // Barrel middle to outer station
     else if (station_a == MuonStationIndex::BM && station_b == MuonStationIndex::BO)
     {
         if (result.phiSector_a % 2 == 0) {
             return result.deltaTheta <= m_matchingbmbo_sphisec;
         } else if (result.phiSector_a % 2 == 1) {
             return result.deltaTheta <= m_matchingbmbo_lphisec;
         }
     }
     // Endcap inner to middle station
     else if ((station_a == MuonStationIndex::EI || station_a == MuonStationIndex::BI)
              && station_b == MuonStationIndex::EM)
     {
         if (result.phiSector_a % 2 == 0) {
             if (result.deltaTheta > m_matchingeiem_sphisec) {
                 return false;
             } else {
                 return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
             }
         } else if (result.phiSector_a % 2 == 1) {
             if (result.deltaTheta > m_matchingeiem_lphisec) {
                 return false;
             } else {
                 return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
             }
         }
     }
     // Endcap inner to outer station
     else if (station_a == MuonStationIndex::EI && (station_b == MuonStationIndex::EO))
     {
         if (result.phiSector_a % 2 == 0) {
             if (result.deltaTheta > m_matchingeieo_sphisec) {
                 return false;
             } else {
                 return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
             }
         } else if (result.phiSector_a % 2 == 1) {
             if (result.deltaTheta > m_matchingeieo_lphisec) {
                 return false;
             } else {
                 return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
             }
         }
     }
     // Endcap middle to outer station
     else if (station_a == MuonStationIndex::EM && station_b == MuonStationIndex::EO)
     {
         if (result.phiSector_a % 2 == 0) {
             return result.deltaTheta <= m_matchingemeo_sphisec;
         } else if (result.phiSector_a % 2 == 1) {
             return result.deltaTheta <= m_matchingemeo_lphisec;
         }
     }
  
     return true;
 }  // if m_useLocalAngles

◆ suppressNoisePhi()

bool Muon::MuonSegmentMatchingTool::suppressNoisePhi	(	const MuonSegment &	seg1,
		const MuonSegment &	seg2,
		const bool &	useTightCuts
	)		const

private

Suppress noise from cavern background/pile up using basic cuts in phi.

Definition at line 608 of file MuonSegmentMatchingTool.cxx.

 {
     // calculate matching variables
     IMuonSegmentPairMatchingTool::SegmentMatchResult result = m_pairMatchingTool->matchResult(seg1, seg2);
  
     MuonStationIndex::StIndex station_a = m_idHelperSvc->stationIndex(result.chid_a);
     MuonStationIndex::StIndex station_b = m_idHelperSvc->stationIndex(result.chid_b);
  
     bool isEndcap_a = m_idHelperSvc->isEndcap(result.chid_a);
  
     bool isEndcap_b = m_idHelperSvc->isEndcap(result.chid_b);
  
     if (m_dumpAngles) {
         std::cout << "SegmentPositionChange Phi"
                   << " " << m_idHelperSvc->chamberNameString(result.chid_a) << " "
                   << m_idHelperSvc->chamberNameString(result.chid_b) << " deltaPhipos " << result.deltaPhipos
                   << " deltaPhidir " << result.deltaPhidir << " phiposerr_a " << result.phiposerr_a << " phiposerr_b "
                   << result.phiposerr_b << " phidirerr_a " << result.phidirerr_a << " phidirerr_b "
                   << result.phidirerr_b << " shorttube_a " << result.shorttube_a << " shorttube_b "
                   << result.shorttube_b << std::endl;
         //      return true; // to get the maximum statistics and not be hindered by current cuts
     }
  
     // Keep segments only if they are in the same or adjacent phi sectors
     if (result.phiSector_a != result.phiSector_b
         && ((result.phiSector_a != 16 && result.phiSector_b != 1)
             && (result.phiSector_a != 1 && result.phiSector_b != 16))
         && (result.phiSector_a != (result.phiSector_b + 1) && result.phiSector_a != (result.phiSector_b - 1)))
         return false;
  
     // First: loose selection
     if (!useTightCuts) {
         // cuts on second coordinate
         if (result.phiSector_a == result.phiSector_b) {
             if (result.phiposerr_a < 10001.000 && result.phiposerr_b < 10001.000) {
  
                 if (!isEndcap_a && !isEndcap_b) {
                     return result.deltaPhipos <= 0.1;
                 }
                 if (isEndcap_a && isEndcap_b) {
                     // small sectors
                     if (result.phiSector_a % 2 == 0) {
                         return result.deltaPhipos <= 0.1;
                     }
                     // large sectors
                     if (result.phiSector_a % 2 == 1) {
                         return result.deltaPhipos <= 0.2;
                     }
                 }
             }
         }
  
         if (result.phiSector_a != result.phiSector_b) {
             if (result.phiposerr_a < 10001.000 && result.phiposerr_b < 10001.000) {
                 if (!isEndcap_a && !isEndcap_b) {
                     return result.deltaPhipos <= 0.1;
                 }
                 if (isEndcap_a && isEndcap_b) {
                     return result.deltaPhipos <= 0.2;
                 }
             }
          }
  
         // cuts on distance to tube edge
         // only if in a different phi sector
         if (result.phiSector_a != result.phiSector_b) {
             // measured inner segment
             if (result.phiposerr_a < 10001.000) {
                 if (station_a == MuonStationIndex::BM && station_b == MuonStationIndex::BO) {
                     return result.shorttube_a <= 800;
                 }
                 if (station_a == MuonStationIndex::EI && station_b == MuonStationIndex::EM) {
                     // MM or STGC have result.shorttube = 99999.
                     return result.shorttube_a <= 3500 || result.shorttube_a == 99999.;
                 }
                 if (station_a == MuonStationIndex::EI && station_b == MuonStationIndex::EO) {
                     return result.shorttube_a <= 3500 || result.shorttube_a == 99999.;
                 }
                 if (station_a == MuonStationIndex::EM && station_b == MuonStationIndex::EO) {
                     return result.shorttube_a <= 800;
                 }
             }
             // measured outer segment
             if (result.phiposerr_b < 10001.000) {
                 if (station_a == MuonStationIndex::BI && station_b == MuonStationIndex::BM) {
                     return result.shorttube_b <= 800;
                 }
                 if (station_a == MuonStationIndex::BI && station_b == MuonStationIndex::BO) {
                     return result.shorttube_b <= 800;
                 }
                 if (station_a == MuonStationIndex::BM && station_b == MuonStationIndex::BO) {
                     return result.shorttube_b <= 800;
                 }
                 if (station_a == MuonStationIndex::EI && station_b == MuonStationIndex::EM) {
                     return result.shorttube_b <= 1400;
                 }
             }
         }
         return true;
     }
  
  
     // Second: tight selection if only if requested
     // cuts on second coordinate
     if (result.phiSector_a == result.phiSector_b) {
         if (result.phiposerr_a < 10001.000 && result.phiposerr_b < 10001.000) {
             if (!isEndcap_a && !isEndcap_b) {
                 return result.deltaPhipos <= 0.1;
             }
             if (isEndcap_a && isEndcap_b) {
                 // small sectors
                 if (result.phiSector_a % 2 == 0) {
                     return result.deltaPhipos <= 0.08;
                 }
                 // large sectors
                 if (result.phiSector_a % 2 == 1) {
                     return result.deltaPhipos <= 0.1;
                 }
             }
         }
     }
     // cuts on distance to tube edge
     // only if in a different phi sector
     if (result.phiSector_a != result.phiSector_b) {
         if (result.phiposerr_a < 10001.000 && result.phiposerr_b < 10001.000) {
             if (!isEndcap_a && !isEndcap_b) {
                 return result.deltaPhipos <= 0.05;
             }
             if (isEndcap_a && isEndcap_b) {
                 return result.deltaPhipos <= 0.1;
             }
         }
         
        
         // measured inner segment
         if (result.phiposerr_a < 10001.000) {
             if (station_a == MuonStationIndex::BM && station_b == MuonStationIndex::BO) {
                 return result.shorttube_a <= 600;
             }
             if (station_a == MuonStationIndex::EI && station_b == MuonStationIndex::EM) {
                 return result.shorttube_a <= 3500 || result.shorttube_a == 99999.;
             }
             if (station_a == MuonStationIndex::EI && station_b == MuonStationIndex::EO) {
                 return result.shorttube_a <= 3500 || result.shorttube_a == 99999.;
             }
             if (station_a == MuonStationIndex::EM && station_b == MuonStationIndex::EO) {
                 return result.shorttube_a <= 500;
             }
         }
         // measured outer segment
         if (result.phiposerr_b < 10001.000) {
             if (station_a == MuonStationIndex::BI && station_b == MuonStationIndex::BM) {
                 return result.shorttube_b <= 600;
             }
             if (station_a == MuonStationIndex::BI && station_b == MuonStationIndex::BO) {
                 return result.shorttube_b <= 700;
             }
             if (station_a == MuonStationIndex::BM && station_b == MuonStationIndex::BO) {
                 return result.shorttube_b <= 700;
             }
             if (station_a == MuonStationIndex::EI && station_b == MuonStationIndex::EM) {
                 return result.shorttube_b <= 700;
             }
         }
         
     }
     return true;
 }  // if m_useLocalAngles

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

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

double Muon::MuonSegmentMatchingTool::m_angleABCut {}

private

Definition at line 146 of file MuonSegmentMatchingTool.h.

◆ m_curvedMatches

std::atomic_uint Muon::MuonSegmentMatchingTool::m_curvedMatches {0}

mutableprivate

Definition at line 120 of file MuonSegmentMatchingTool.h.

◆ m_curvedMatchesGood

std::atomic_uint Muon::MuonSegmentMatchingTool::m_curvedMatchesGood {0}

mutableprivate

Definition at line 121 of file MuonSegmentMatchingTool.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_doCurvedMatch

bool Muon::MuonSegmentMatchingTool::m_doCurvedMatch

private

Definition at line 127 of file MuonSegmentMatchingTool.h.

◆ m_doOverlapMatch

bool Muon::MuonSegmentMatchingTool::m_doOverlapMatch

private

Definition at line 125 of file MuonSegmentMatchingTool.h.

◆ m_doStraightLineMatch

bool Muon::MuonSegmentMatchingTool::m_doStraightLineMatch

private

Definition at line 126 of file MuonSegmentMatchingTool.h.

◆ m_drExtrapAlignmentOffset

double Muon::MuonSegmentMatchingTool::m_drExtrapAlignmentOffset

private

Definition at line 171 of file MuonSegmentMatchingTool.h.

◆ m_drExtrapRMS

double Muon::MuonSegmentMatchingTool::m_drExtrapRMS

private

Definition at line 170 of file MuonSegmentMatchingTool.h.

◆ m_dthetaExtrapRMS

double Muon::MuonSegmentMatchingTool::m_dthetaExtrapRMS

private

Definition at line 172 of file MuonSegmentMatchingTool.h.

◆ m_dumpAngles

bool Muon::MuonSegmentMatchingTool::m_dumpAngles

private

dump matching angle info to screen

Definition at line 167 of file MuonSegmentMatchingTool.h.

◆ m_duplicateHitUses

std::atomic_uint Muon::MuonSegmentMatchingTool::m_duplicateHitUses {0}

mutableprivate

Definition at line 122 of file MuonSegmentMatchingTool.h.

◆ m_edmHelperSvc

ServiceHandle<Muon::IMuonEDMHelperSvc> Muon::MuonSegmentMatchingTool::m_edmHelperSvc

private

Initial value:

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

EDM Helper tool.

Definition at line 91 of file MuonSegmentMatchingTool.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_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::MuonSegmentMatchingTool::m_idHelperSvc

private

Initial value:

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

Definition at line 86 of file MuonSegmentMatchingTool.h.

◆ m_isCosmics

bool Muon::MuonSegmentMatchingTool::m_isCosmics

private

Definition at line 124 of file MuonSegmentMatchingTool.h.

◆ m_matchingbee_sphisec

double Muon::MuonSegmentMatchingTool::m_matchingbee_sphisec {}

private

Definition at line 163 of file MuonSegmentMatchingTool.h.

◆ m_matchingbibm_lphisec

double Muon::MuonSegmentMatchingTool::m_matchingbibm_lphisec

private

Definition at line 150 of file MuonSegmentMatchingTool.h.

◆ m_matchingbibm_sphisec

double Muon::MuonSegmentMatchingTool::m_matchingbibm_sphisec

private

Definition at line 156 of file MuonSegmentMatchingTool.h.

◆ m_matchingbibo_lphisec

double Muon::MuonSegmentMatchingTool::m_matchingbibo_lphisec

private

Definition at line 151 of file MuonSegmentMatchingTool.h.

◆ m_matchingbibo_sphisec

double Muon::MuonSegmentMatchingTool::m_matchingbibo_sphisec

private

Definition at line 157 of file MuonSegmentMatchingTool.h.

◆ m_matchingbmbo_lphisec

double Muon::MuonSegmentMatchingTool::m_matchingbmbo_lphisec

private

Definition at line 152 of file MuonSegmentMatchingTool.h.

◆ m_matchingbmbo_sphisec

double Muon::MuonSegmentMatchingTool::m_matchingbmbo_sphisec

private

Definition at line 158 of file MuonSegmentMatchingTool.h.

◆ m_matchingeiem_lphisec

double Muon::MuonSegmentMatchingTool::m_matchingeiem_lphisec

private

Definition at line 153 of file MuonSegmentMatchingTool.h.

◆ m_matchingeiem_sphisec

double Muon::MuonSegmentMatchingTool::m_matchingeiem_sphisec

private

Definition at line 159 of file MuonSegmentMatchingTool.h.

◆ m_matchingeieo_lphisec

double Muon::MuonSegmentMatchingTool::m_matchingeieo_lphisec

private

Definition at line 154 of file MuonSegmentMatchingTool.h.

◆ m_matchingeieo_sphisec

double Muon::MuonSegmentMatchingTool::m_matchingeieo_sphisec

private

Definition at line 160 of file MuonSegmentMatchingTool.h.

◆ m_matchingemeo_lphisec

double Muon::MuonSegmentMatchingTool::m_matchingemeo_lphisec

private

Definition at line 155 of file MuonSegmentMatchingTool.h.

◆ m_matchingemeo_sphisec

double Muon::MuonSegmentMatchingTool::m_matchingemeo_sphisec

private

Definition at line 161 of file MuonSegmentMatchingTool.h.

◆ m_maxDistSegments

double Muon::MuonSegmentMatchingTool::m_maxDistSegments

private

cut on the maximum distance between the segments

Definition at line 147 of file MuonSegmentMatchingTool.h.

◆ m_minDistSegmentsCosmics

double Muon::MuonSegmentMatchingTool::m_minDistSegmentsCosmics {}

private

cut on the minimum distance between the segments, if the distance is larger

than the cut the segments are always matched (for cosmics)

Definition at line 148 of file MuonSegmentMatchingTool.h.

◆ m_onlySameSectorIfTight

bool Muon::MuonSegmentMatchingTool::m_onlySameSectorIfTight

private

reject all segments in different sectors if in tight matching

Definition at line 165 of file MuonSegmentMatchingTool.h.

◆ m_overlapMatchAngleDPhiCut

double Muon::MuonSegmentMatchingTool::m_overlapMatchAngleDPhiCut

private

cut of the angular difference between phi from phi match and phi from positions

Definition at line 137 of file MuonSegmentMatchingTool.h.

◆ m_overlapMatchAngleDYZCut

double Muon::MuonSegmentMatchingTool::m_overlapMatchAngleDYZCut

private

cut of the angular difference between phi from phi match and phi from positions

Definition at line 140 of file MuonSegmentMatchingTool.h.

◆ m_overlapMatches

std::atomic_uint Muon::MuonSegmentMatchingTool::m_overlapMatches {0}

mutableprivate

Definition at line 118 of file MuonSegmentMatchingTool.h.

◆ m_overlapMatchesGood

std::atomic_uint Muon::MuonSegmentMatchingTool::m_overlapMatchesGood {0}

mutableprivate

Definition at line 119 of file MuonSegmentMatchingTool.h.

◆ m_overlapMatchPhiHitPullCut

double Muon::MuonSegmentMatchingTool::m_overlapMatchPhiHitPullCut

private

cut on the average pull of the phi hits with the new segment parameters

Definition at line 143 of file MuonSegmentMatchingTool.h.

◆ m_overlapMatchPositionCut

double Muon::MuonSegmentMatchingTool::m_overlapMatchPositionCut

private

cut on the distance of best position from the chamber bounds

Definition at line 141 of file MuonSegmentMatchingTool.h.

◆ m_overlapMatchPositionResidualCut

double Muon::MuonSegmentMatchingTool::m_overlapMatchPositionResidualCut

private

cut on the position residual for the best position match

Definition at line 142 of file MuonSegmentMatchingTool.h.

◆ m_overlapResolvingTool

ToolHandle<Muon::IMuonSegmentInOverlapResolvingTool> Muon::MuonSegmentMatchingTool::m_overlapResolvingTool

private

Initial value:

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

matching tool to handle the overlaps

Definition at line 103 of file MuonSegmentMatchingTool.h.

◆ m_pairMatchingTool

ToolHandle<Muon::IMuonSegmentPairMatchingTool> Muon::MuonSegmentMatchingTool::m_pairMatchingTool

private

Initial value:

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

matching tool to handle the pairs of segments

Definition at line 108 of file MuonSegmentMatchingTool.h.

◆ m_phiMatch

bool Muon::MuonSegmentMatchingTool::m_phiMatch

private

Definition at line 129 of file MuonSegmentMatchingTool.h.

◆ m_printer

PublicToolHandle<Muon::MuonEDMPrinterTool> Muon::MuonSegmentMatchingTool::m_printer

private

Initial value:

{
        this,
        "Printer",
        "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
    }

EDM printer tool.

Definition at line 98 of file MuonSegmentMatchingTool.h.

◆ m_straightLineMatchAngleCut

double Muon::MuonSegmentMatchingTool::m_straightLineMatchAngleCut

private

Definition at line 133 of file MuonSegmentMatchingTool.h.

◆ m_straightLineMatches

std::atomic_uint Muon::MuonSegmentMatchingTool::m_straightLineMatches {0}

mutableprivate

Definition at line 116 of file MuonSegmentMatchingTool.h.

◆ m_straightLineMatchesGood

std::atomic_uint Muon::MuonSegmentMatchingTool::m_straightLineMatchesGood {0}

mutableprivate

Definition at line 117 of file MuonSegmentMatchingTool.h.

◆ m_straightLineMatchPositionCut

double Muon::MuonSegmentMatchingTool::m_straightLineMatchPositionCut

private

Definition at line 134 of file MuonSegmentMatchingTool.h.

◆ m_thetaMatch

bool Muon::MuonSegmentMatchingTool::m_thetaMatch

private

Definition at line 128 of file MuonSegmentMatchingTool.h.

◆ m_toroidOn

Gaudi::Property<bool> Muon::MuonSegmentMatchingTool::m_toroidOn {this, "ToroidOn", true, "Status of toroidal B-Field"}

private

Definition at line 114 of file MuonSegmentMatchingTool.h.

◆ m_useEndcapExtrapolationMatching

bool Muon::MuonSegmentMatchingTool::m_useEndcapExtrapolationMatching

private

Definition at line 169 of file MuonSegmentMatchingTool.h.

◆ m_useLocalAngles

bool Muon::MuonSegmentMatchingTool::m_useLocalAngles {}

private

Definition at line 130 of file MuonSegmentMatchingTool.h.

◆ m_useTightCuts

bool Muon::MuonSegmentMatchingTool::m_useTightCuts

private

only apply tight selection for busy combinations

Definition at line 166 of file MuonSegmentMatchingTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ MuonSegmentMatchingTool()

◆ ~MuonSegmentMatchingTool()

Member Function Documentation

◆ curvedMatch()

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

◆ endcapExtrapolationMatch()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ finalize()

◆ hasStereoAngle()

◆ initialize()

◆ initializeField()

◆ inputHandles()

◆ interfaceID()

◆ isSLMatch()

◆ match()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ overlapMatch()

◆ renounce()

◆ renounceArray()

◆ simpleEndcapExtrapolate()

◆ straightLineMatch()

◆ suppressNoise()

◆ suppressNoisePhi()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_angleABCut

◆ m_curvedMatches

◆ m_curvedMatchesGood

◆ m_detStore

◆ m_doCurvedMatch

◆ m_doOverlapMatch

◆ m_doStraightLineMatch

◆ m_drExtrapAlignmentOffset

◆ m_drExtrapRMS

◆ m_dthetaExtrapRMS

◆ m_dumpAngles

◆ m_duplicateHitUses

◆ m_edmHelperSvc

◆ m_evtStore

◆ m_idHelperSvc

◆ m_isCosmics

◆ m_matchingbee_sphisec

◆ m_matchingbibm_lphisec

◆ m_matchingbibm_sphisec

◆ m_matchingbibo_lphisec

◆ m_matchingbibo_sphisec

◆ m_matchingbmbo_lphisec

◆ m_matchingbmbo_sphisec

◆ m_matchingeiem_lphisec

◆ m_matchingeiem_sphisec

◆ m_matchingeieo_lphisec

◆ m_matchingeieo_sphisec

◆ m_matchingemeo_lphisec