MuonMatchingTool Class Reference

Class that provides functionalities for searching for online muons close to a given offline muon and judging they are matched with the specific criteria. More...

#include <MuonMatchingTool.h>

Inheritance diagram for MuonMatchingTool:

Collaboration diagram for MuonMatchingTool:

Public Member Functions
	MuonMatchingTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
const xAOD::MuonRoI *	matchL1 (const EventContext &ctx, const xAOD::Muon *mu, const std::string &trigger, bool &pass) const
	Function that searches for a Level 1 muon candidate and judges if it is matched to a given offline muon.
const xAOD::MuonRoI *	matchL1 (const EventContext &ctx, const xAOD::TruthParticle *mu, const std::string &trigger, bool &pass) const
	Function that searches for a Level 1 truth muon candidate and judges if it is matched to a given offline muon.
const xAOD::MuonRoI *	matchL1 (const EventContext &ctx, double eta, double phi, double dR, const std::string &trigger, bool &pass) const
	Function that dR matches L1 muon candidates.
const xAOD::L2StandAloneMuon *	matchL2SA (const EventContext &ctx, const xAOD::Muon *mu, const std::string &trigger, bool &pass) const
	Function that searches for an L2 standalone muon (L2MuonSA) candidate and judges if it is matched to a given offline muon.
const xAOD::Muon *	matchFastRecoSA (const EventContext &ctx, const xAOD::Muon *mu, const std::string &trigger, bool &pass) const
	Function that searches for a EF fast reco muon (PhaseII) candidate and judges if it is matched to a given offline muon.
const xAOD::L2StandAloneMuon *	matchL2SA (const xAOD::TruthParticle *mu, const std::string &trigger, bool &pass) const
	Function that searches for an L2 standalone muon (L2MuonSA) candidate and judges if it is matched to a given truth particle.
const xAOD::Muon *	matchFastRecoSA (const xAOD::TruthParticle *mu, const std::string &trigger, bool &pass) const
	Function that searches for a EF fast reco standalone muon (PhaseII) candidate and judges if it is matched to a given truth particle.
const TrigCompositeUtils::LinkInfo< xAOD::L2StandAloneMuonContainer >	searchL2SALinkInfo (const xAOD::Muon *mu, std::string trigger) const
	Function that searches for the L2 standalone muon (L2MuonSA) candidate closest to a given offline muon.
const TrigCompositeUtils::LinkInfo< xAOD::MuonContainer >	searchFastRecoSALinkInfo (const xAOD::Muon *mu, std::string trigger) const
	Function that searches for the EF fast reco standalone candidate closest to a given offline muon.
const xAOD::L2StandAloneMuon *	matchL2SAReadHandle (const EventContext &ctx, const xAOD::Muon *mu) const
	Function that searches for an L2 standalone muon (L2MuonSA) candidate by ReadHandle and judges if it is matched to a given offlineSA muon.
const xAOD::Muon *	matchFastRecoSAReadHandle (const EventContext &ctx, const xAOD::Muon *mu) const
	Function that searches for a EF fast reco standalone muon (PhaseII) candidate by ReadHandle and judges if it is matched to a given offlineSA muon.
const xAOD::L2CombinedMuon *	matchL2CB (const xAOD::Muon *mu, std::string trigger, bool &pass) const
	Function that searches for an L2 combined muon (L2muComb) candidate and judges if it is matched to a given offline muon.
const xAOD::L2CombinedMuon *	matchL2CB (const xAOD::TruthParticle *mu, std::string trigger, bool &pass) const
	Function that searches for an L2 combined muon (L2muComb) candidate and judges if it is matched to a given truth muon.
const TrigCompositeUtils::LinkInfo< xAOD::L2CombinedMuonContainer >	searchL2CBLinkInfo (const xAOD::Muon *mu, std::string trigger) const
	Function that searches for the L2 combined muon (L2muComb) candidate closest to a given offline muon.
const xAOD::L2CombinedMuon *	matchL2CBReadHandle (const EventContext &ctx, const xAOD::Muon *mu) const
	Function that searches for an L2 combined muon (L2muComb) candidate by ReadHandle and judges if it is matched to a given offlineCB muon.
const xAOD::Muon *	matchEFSA (const xAOD::Muon *mu, std::string trigger, bool &pass) const
	Function that searches for an EF standalone muon (EFSA) candidate and judges if it is matched to a given offline muon.
const xAOD::Muon *	matchEFSA (const xAOD::TruthParticle *mu, std::string trigger, bool &pass) const
	Function that searches for an EF standalone muon (EFSA) candidate and judges if it is matched to a given truth muon.
const TrigCompositeUtils::LinkInfo< xAOD::MuonContainer >	matchEFSALinkInfo (const xAOD::Muon *mu, std::string trig) const
	Function that searches for an EF standalone muon (EFSA) candidate and judges if it is matched to a given track particle.
const xAOD::Muon *	matchEFSAReadHandle (const EventContext &ctx, const xAOD::Muon *mu) const
	Function that searches for an EF standalone muon (EFSA) candidate by ReadHandle and judges if it is matched to a given offlineSA muon.
const xAOD::Muon *	matchEFCB (const xAOD::Muon *mu, std::string trigger, bool &pass) const
	Function that searches for an EF combined muon (EFCB) candidate and judges if it is matched to a given offline muon.
const xAOD::Muon *	matchEFCB (const xAOD::TruthParticle *mu, std::string trig, bool &pass) const
	Function that searches for an EF combined muon (EFCB) candidate and judges if it is matched to a given truth muon.
const TrigCompositeUtils::LinkInfo< xAOD::MuonContainer >	matchEFCBLinkInfo (const xAOD::Muon *mu, std::string trig) const
	Function that searches for an EF combined muon (EFCB) candidate and judges if it is matched to a given track particle.
const xAOD::Muon *	matchEFCBReadHandle (const EventContext &ctx, const xAOD::Muon *mu) const
	Function that searches for an EF combined muon (EFCB) candidate by ReadHandle and judges if it is matched to a given offlineCB muon.
const xAOD::Muon *	matchEFSAFS (const xAOD::Muon *mu, std::string trigger, bool &pass) const
	Function that searches for an EF FS standalone muon (EFSAFS) candidate and judges if it is matched to a given offline muon.
const xAOD::Muon *	matchEFSAFS (const xAOD::TruthParticle *mu, std::string trigger, bool &pass) const
	Function that searches for an EF standalone muon (EFSAFS) candidate and judges if it is matched to a given truth muon.
const TrigCompositeUtils::LinkInfo< xAOD::MuonContainer >	matchEFSAFSLinkInfo (const xAOD::Muon *mu, std::string trig) const
	Function that searches for an EF standalone muon (EFSAFS) candidate and judges if it is matched to a given track particle.
const xAOD::Muon *	matchEFSAFSReadHandle (const EventContext &ctx, const xAOD::Muon *mu) const
	Function that searches for an EF standalone muon (EFSAFS) candidate by ReadHandle and judges if it is matched to a given offlineSAFS muon.
const xAOD::Muon *	matchEFCBFS (const xAOD::Muon *mu, std::string trigger, bool &pass) const
	Function that searches for an EF combined muon (EFCBFS) candidate and judges if it is matched to a given offline muon.
const xAOD::Muon *	matchEFCBFS (const xAOD::TruthParticle *mu, std::string trig, bool &pass) const
	Function that searches for an EF combined muon (EFCBFS) candidate and judges if it is matched to a given truth muon.
const TrigCompositeUtils::LinkInfo< xAOD::MuonContainer >	matchEFCBFSLinkInfo (const xAOD::Muon *mu, std::string trig) const
	Function that searches for an EF combined muon (EFCBFS) candidate and judges if it is matched to a given track particle.
const xAOD::Muon *	matchEFCBFSReadHandle (const EventContext &ctx, const xAOD::Muon *mu) const
	Function that searches for an EF combined muon (EFCBFS) candidate by ReadHandle and judges if it is matched to a given offlineCB muon.
const xAOD::Muon *	matchEFIso (const xAOD::Muon *mu, std::string trigger, bool &pass) const
	Function that searches for an EF isolation muon (EFIso) candidate and judges if it is matched to a given offline muon.
const xAOD::Muon *	matchEFIso (const xAOD::TruthParticle *mu, std::string trigger, bool &pass) const
	Function that searches for an EF isolation muon (EFIso) candidate and judges if it is matched to a given truth muon.
const TrigCompositeUtils::LinkInfo< xAOD::MuonContainer >	matchEFIsoLinkInfo (const xAOD::Muon *mu, std::string trig) const
	Function that searches for an EF isolation muon (EFIso) candidate and judges if it is matched to a given track particle.
const xAOD::TrackParticle *	SearchEFTrack (const EventContext &ctx, const TrigCompositeUtils::LinkInfo< xAOD::MuonContainer > &muLinkInfo, const SG::ReadHandleKey< xAOD::TrackParticleContainer > &ReadHandleKey) const
	Function that searches for an EF muon track (e.g.
const xAOD::Muon *	matchL2SAtoOff (const EventContext &ctx, const xAOD::L2StandAloneMuon *samu) const
	Function that searches for an offline muon matched to L2SA muon.
const xAOD::Muon *	matchFastRecoSAtoOff (const EventContext &ctx, const xAOD::Muon *samu) const
	Function that searches for an offline muon matched to EF Fast Reco SA muon.
const xAOD::Muon *	matchL2CBtoOff (const EventContext &ctx, const xAOD::L2CombinedMuon *cbmu) const
	Function that searches for an offline muon matched to L2CB muon.
bool	isMatchedL2SA (const xAOD::L2StandAloneMuon *, const xAOD::Muon *) const
bool	isMatchedFastRecoSA (const xAOD::Muon *, const xAOD::Muon *) const
bool	isMatchedL2CB (const xAOD::L2CombinedMuon *, const xAOD::Muon *) const
bool	isMatchedL2InsideOut (const xAOD::L2CombinedMuon *, const xAOD::Muon *) const
std::unique_ptr< Trk::TrackParameters >	extTrackToPivot (const EventContext &ctx, const xAOD::TrackParticle *track) const
	Function to extrapolate a Inner Detector track to the pivot plane i.e.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static double	reqdRL1byPt (double mupt)
	Function compute dR used for matching offline muons and level 1 RoIs at the pivot plane.
static std::tuple< bool, double, double >	trigPosForMatchSATrack (const xAOD::Muon *mu)
static std::tuple< bool, double, double >	trigPosForMatchCBTrack (const xAOD::Muon *mu)
static std::tuple< bool, double, double >	PosForMatchSATrack (const xAOD::Muon *mu, const bool isPhaseII=false)
static std::tuple< bool, double, double >	PosForMatchCBTrack (const xAOD::Muon *mu)

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
enum	L1Items {   L1B_MU3V =1 , L1B_MU5VF =2 , L1B_MU8F =3 , L1B_MU14FCH =6 ,   L1B_MU14FCHR =6 , L1E_MU3V =1 , L1E_MU5VF =3 , L1E_MU8F =6 ,   L1E_MU14FCH =12 , L1E_MU14FCHR =12 , ERROR }
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
int	L1ItemStringToInt (const std::string &l1item, int roiSource) const
template<class T, class OFFL>
const T *	matchReadHandle (const OFFL *offl, float reqdR, const SG::ReadHandleKey< DataVector< T > > &ReadHandleKey, const EventContext &ctx, std::tuple< bool, double, double >(*trigPosForMatchFunc)(const T *)=&MuonMatchingTool::trigPosForMatch< T >) const
	Function that searches for an online muon candidate of type T by ReadHandle and judges if it is matched to a given offline muon.
template<class T, class OFFL>
const TrigCompositeUtils::LinkInfo< DataVector< T > >	matchLinkInfo (const OFFL *offl, std::string trigger, float reqdR, bool &pass, const std::string &containerSGKey="", std::tuple< bool, double, double >(*trigPosForMatchFunc)(const T *)=&MuonMatchingTool::trigPosForMatch< T >) const
	Function that searches for an online muon candidate of type T closest to a given offline muon.
template<class T, class OFFL>
const T *	match (const OFFL *offl, std::string trigger, float reqdR, bool &pass, const std::string &containerSGKey="", std::tuple< bool, double, double >(*trigPosForMatchFunc)(const T *)=&MuonMatchingTool::trigPosForMatch< T >) const
	Function that searches for an online muon candidate of type T and judges if it is matched to a given offline muon.
template<class T>
const xAOD::Muon *	matchOff (const EventContext &ctx, const T *trig, float reqdR, std::function< std::tuple< bool, double, double >(const xAOD::Muon *)> offlinePosForMatchFunc, std::function< std::tuple< bool, double, double >(const T *)> trigPosForMatchFunc=&MuonMatchingTool::trigPosForMatch< T >) const
	Function that searches for an offline muon candidate matched to online muon of type T.
Amg::Vector3D	offlineMuonAtPivot (const EventContext &ctx, const xAOD::Muon &mu) const
std::unique_ptr< Trk::TrackParameters >	extTrackToTGC (const EventContext &ctx, const xAOD::TrackParticle &track) const
std::unique_ptr< Trk::TrackParameters >	extTrackToRPC (const EventContext &ctx, const xAOD::TrackParticle &track) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
template<class T>
static std::tuple< bool, double, double >	trigPosForMatch (const T *trig)

Private Attributes
const float	m_L2SAreqdR = 0.25
const float	m_L2CBreqdR = 0.03
const float	m_L2InsideOutreqdR = 0.01
const float	m_EFreqdR = 0.03
SG::ReadHandleKey< xAOD::MuonRoIContainer >	m_MuonRoIKey {this, "MuonRoIContainerName", "LVL1MuonRoIs", "Level 1 muon container"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_MuonKey {this, "MuonContainerName", "Muons", "Offline muon container"}
SG::ReadHandleKey< xAOD::L2StandAloneMuonContainer >	m_L2SAMuonKey {this, "L2StandAloneMuonContainerName", "HLT_FastMuons_RoI", "L2MuonSA container"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_FastRecoSAMuonKey {this, "FastRecoSAContainerName", "HLT_FastMuonsInfo", "EFFastRecoSA container (Phase2)"}
SG::ReadHandleKey< xAOD::L2CombinedMuonContainer >	m_L2CBMuonKey {this, "L2CombinedMuonContainerName", "HLT_MuonL2CBInfo", "L2muComb container"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_EFSAMuonKey {this, "EFSAMuonContainerName", "HLT_Muons_RoI", "EFSAMuon container"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_EFSAMlbktMuonKey {this, "EFSAMlbktMuonContainerName", "HLT_Muons_RoI", "EFSAMuon container"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_EFSANewFastMuonKey {this, "EFSANewFastMuonContainerName", "HLT_Muons_RoI", "EFSAMuon container"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_EFCBMuonKey {this, "EFCBMuonContainerName", "HLT_MuonsCB_RoI", "EFCBMuon container"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_EFSAFSMuonKey {this, "EFSAFSMuonContainerName", "HLT_Muons_FS", "EFSAFSMuon container"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_EFSAFSMlbktMuonKey {this, "EFSAFSMlbktMuonContainerName", "HLT_Muons_FS", "EFSAFSMuon container"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_EFSAFSNewFastMuonKey {this, "EFSAFSNewFastMuonContainerName", "HLT_Muons_FS", "EFSAFSMuon container"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_EFCBFSMuonKey {this, "EFCBFSMuonContainerName", "HLT_MuonsCB_FS", "EFCBFSMuon container"}
Gaudi::Property< bool >	m_use_extrapolator {this, "UseExtrapolator", false, "Flag to enable the extrapolator for matching offline and trigger muons"}
BooleanProperty	m_isPhII {this, "isPhaseII", false, "Whether the muons have been processed with Phase II software"}
ToolHandle< LVL1::ITrigThresholdDecisionTool >	m_thresholdTool
PublicToolHandle< Trig::TrigDecisionTool >	m_trigDec {this, "TrigDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool", "TrigDecisionTool"}
PublicToolHandle< Trk::IExtrapolator >	m_extrapolator {"Trk::Extrapolator/AtlasExtrapolator"}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Class that provides functionalities for searching for online muons close to a given offline muon and judging they are matched with the specific criteria.

Definition at line 28 of file MuonMatchingTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

L1Items

enum MuonMatchingTool::L1Items

private

Enumerator
L1B_MU3V
L1B_MU5VF
L1B_MU8F
L1B_MU14FCH
L1B_MU14FCHR
L1E_MU3V
L1E_MU5VF
L1E_MU8F
L1E_MU14FCH
L1E_MU14FCHR
ERROR

Definition at line 419 of file MuonMatchingTool.h.

{ L1B_MU3V=1, L1B_MU5VF=2, L1B_MU8F=3, L1B_MU14FCH=6, L1B_MU14FCHR=6 , L1E_MU3V=1, L1E_MU5VF=3, L1E_MU8F=6, L1E_MU14FCH=12, L1E_MU14FCHR=12, ERROR};

Constructor & Destructor Documentation

MuonMatchingTool()

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

Definition at line 28 of file MuonMatchingTool.cxx.

  : AthAlgTool(type, name, parent)
{}

Member Function Documentation

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

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

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extTrackToPivot()

std::unique_ptr< Trk::TrackParameters > MuonMatchingTool::extTrackToPivot	(	const EventContext &	ctx,
		const xAOD::TrackParticle *	track ) const

Function to extrapolate a Inner Detector track to the pivot plane i.e.

the middle layers of the Muon Spectrometer where the level 1 RoI is defined. This functionality is not available yet.

Parameters

ctx	Reference to the EventContext
track	Inner Detector track that is extrapolated.

Returns

Pointer to the extrapolated track parameters.

See also

reqdRL1byPt

Todo

Return std::unique_ptr when this is available.

Definition at line 640 of file MuonMatchingTool.cxx.

                                                                        {
  if (!track) return nullptr;
 
  double trkEta = track->eta();
  using Return_t = std::unique_ptr<Trk::TrackParameters>;
  
  // BARREL REGION
  if (std::abs(trkEta) < 1.05) {
    Return_t extRPC = extTrackToRPC(ctx, *track);
    if (!extRPC) {
      return extTrackToTGC(ctx, *track);
    }
    //If the extrapolated eta is in the endcap region, return the TGC extrapolation
    if (std::abs(extRPC->position().eta()) >= 1.05){
      if (Return_t extTGC = extTrackToTGC(ctx, *track)) {
        return extTGC;
      }
    }
    //If the extrapolated eta is still in the barrel region, or the TGC extrapolation fails, return the RPC extrapolation
    return extRPC;
  }
 
  // ENDCAP REGION (same logic as above, but reversed)
  Return_t extTGC = extTrackToTGC(ctx, *track);
  if (!extTGC) {
    return extTrackToRPC(ctx, *track);
  }
  if (std::abs(extTGC->position().eta()) < 1.05) {
    if (Return_t extRPC = extTrackToRPC(ctx, *track)) {
      return extRPC;
    }
  }
  return extTGC;
}

extTrackToRPC()

std::unique_ptr< Trk::TrackParameters > MuonMatchingTool::extTrackToRPC ( const EventContext & ctx, const xAOD::TrackParticle & track ) const

private

Definition at line 693 of file MuonMatchingTool.cxx.

                                                                    {
  Trk::CylinderSurface barrel {7478., 15000.};
  const bool boundaryCheck = true;
 
  return m_extrapolator->extrapolate(ctx,
                                     trk.perigeeParameters(),
                                     barrel,
                                     Trk::anyDirection,
                                     boundaryCheck,
                                     Trk::muon);
}

extTrackToTGC()

std::unique_ptr< Trk::TrackParameters > MuonMatchingTool::extTrackToTGC ( const EventContext & ctx, const xAOD::TrackParticle & track ) const

private

Definition at line 677 of file MuonMatchingTool.cxx.

                                                                    {
  double TGC_Z = ( trk.eta()>0 )? 15153.0:-15153.0;
  Amg::Transform3D matrix = Amg::Transform3D(Amg::Vector3D( 0.,0.,TGC_Z));
  Trk::DiscSurface disc{matrix, 0., 15000.};
  const bool boundaryCheck = true;
 
  return m_extrapolator->extrapolate(ctx,
                                     trk.perigeeParameters(),
                                     disc,
                                     Trk::anyDirection,
                                     boundaryCheck,
                                     Trk::muon);
}

initialize()

StatusCode MuonMatchingTool::initialize ( )

overridevirtual

Definition at line 33 of file MuonMatchingTool.cxx.

                                       {
 
  ATH_CHECK(m_trigDec.retrieve() );
  ATH_CHECK(m_thresholdTool.retrieve() );
  if(m_use_extrapolator){
    ATH_CHECK(m_extrapolator.retrieve() );
  }
  ATH_CHECK(m_MuonKey.initialize(!m_MuonKey.empty()));
  ATH_CHECK(m_MuonRoIKey.initialize());
  ATH_CHECK(m_L2SAMuonKey.initialize());
  ATH_CHECK(m_FastRecoSAMuonKey.initialize(!m_FastRecoSAMuonKey.empty()));
  ATH_CHECK(m_L2CBMuonKey.initialize());
  ATH_CHECK(m_EFSAMuonKey.initialize());
  ATH_CHECK(m_EFSAMlbktMuonKey.initialize(!m_EFSAMlbktMuonKey.empty()));
  ATH_CHECK(m_EFSANewFastMuonKey.initialize(!m_EFSANewFastMuonKey.empty()));
  ATH_CHECK(m_EFCBMuonKey.initialize());
  ATH_CHECK(m_EFSAFSMuonKey.initialize());
  ATH_CHECK(m_EFSAFSMlbktMuonKey.initialize(!m_EFSAFSMlbktMuonKey.empty()));
  ATH_CHECK(m_EFSAFSNewFastMuonKey.initialize(!m_EFSAFSNewFastMuonKey.empty()));
  ATH_CHECK(m_EFCBFSMuonKey.initialize());
 
  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.

isMatchedFastRecoSA()

bool MuonMatchingTool::isMatchedFastRecoSA	(	const xAOD::Muon *	samu,
		const xAOD::Muon *	mu ) const

Definition at line 621 of file MuonMatchingTool.cxx.

                                                                {
  return xAOD::P4Helpers::deltaR(mu, samu, false) < m_L2SAreqdR;
}

isMatchedL2CB()

bool MuonMatchingTool::isMatchedL2CB	(	const xAOD::L2CombinedMuon *	cbmu,
		const xAOD::Muon *	mu ) const

Definition at line 628 of file MuonMatchingTool.cxx.

                                                          {
  return xAOD::P4Helpers::deltaR(cbmu, mu, false) < m_L2CBreqdR;
}

isMatchedL2InsideOut()

bool MuonMatchingTool::isMatchedL2InsideOut	(	const xAOD::L2CombinedMuon *	cbiomu,
		const xAOD::Muon *	mu ) const

Definition at line 634 of file MuonMatchingTool.cxx.

                                                                 {
  return xAOD::P4Helpers::deltaR(cbiomu, mu, false) < m_L2InsideOutreqdR;
}

isMatchedL2SA()

bool MuonMatchingTool::isMatchedL2SA	(	const xAOD::L2StandAloneMuon *	samu,
		const xAOD::Muon *	mu ) const

Definition at line 615 of file MuonMatchingTool.cxx.

                                                          {
  return xAOD::P4Helpers::deltaR(mu, samu, false) < m_L2SAreqdR;
}

L1ItemStringToInt()

int MuonMatchingTool::L1ItemStringToInt ( const std::string & l1item, int roiSource ) const

inlineprivate

Definition at line 420 of file MuonMatchingTool.h.

                                                                      {
    if( "L1_MU3V"==l1item) return roiSource==0 ? L1Items::L1B_MU3V : L1Items::L1E_MU3V;
    if( "L1_MU5VF"==l1item) return roiSource==0 ? L1Items::L1B_MU5VF : L1Items::L1E_MU5VF;
    if( "L1_MU8F"==l1item) return roiSource==0 ? L1Items::L1B_MU8F : L1Items::L1E_MU8F;
    if( "L1_MU14FCH"==l1item) return roiSource==0 ? L1Items::L1B_MU14FCH : L1Items::L1E_MU14FCH;
    if( "L1_MU14FCHR"==l1item) return roiSource==0 ? L1Items::L1B_MU14FCHR : L1Items::L1E_MU14FCHR;
    return L1Items::ERROR;
  }

match()

template<class T, class OFFL>

const T * MuonMatchingTool::match ( const OFFL * offl, std::string trigger, float reqdR, bool & pass, const std::string & containerSGKey = "", std::tuple< bool, double, double >(* trigPosForMatchFunc )(const T *) = &MuonMatchingTool::trigPosForMatch< T > ) const

private

Function that searches for an online muon candidate of type T and judges if it is matched to a given offline muon.

Parameters

offl	Position of the offline muon used for computing dR.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
reqdR	Requirement of dR used for the matching. Note that reqdR is updated with the dR of the found candidate.
pass	True if the matched candidate passed the hypothesis step.
trigPosForMatchFunc	Function pointer that implements cuts for the online muon candidates.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

See also

MuonMatchingTool.icc for the implementation and MuonMatchingTool.cxx for the instantiation.

Todo

Consider improving the argument list.

matchEFCB() [1/2]

const xAOD::Muon * MuonMatchingTool::matchEFCB	(	const xAOD::Muon *	mu,
		std::string	trigger,
		bool &	pass ) const

Function that searches for an EF combined muon (EFCB) candidate and judges if it is matched to a given offline muon.

Parameters

mu	Offline muon around which EFCB candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if the matched candidate passed the hypothesis step.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 173 of file MuonMatchingTool.cxx.

                                              {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFCB()");
  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::Primary);
 
  return MuonTrack 
    ? match<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, m_EFCBMuonKey.key() + "*.*", &MuonMatchingTool::trigPosForMatchCBTrack) 
    : nullptr;
}

matchEFCB() [2/2]

const xAOD::Muon * MuonMatchingTool::matchEFCB	(	const xAOD::TruthParticle *	mu,
		std::string	trig,
		bool &	pass ) const

Function that searches for an EF combined muon (EFCB) candidate and judges if it is matched to a given truth muon.

Parameters

mu	Truth muon around which EFCB candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if the matched candidate passed the hypothesis step.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 163 of file MuonMatchingTool.cxx.

                                              {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFCB() for TruthParticle");
  return mu
    ? match<xAOD::Muon>(mu, std::move(trig), m_EFreqdR, pass, m_EFCBMuonKey.key() + "*.*", &MuonMatchingTool::trigPosForMatchCBTrack) 
    : nullptr;
}

matchEFCBFS() [1/2]

const xAOD::Muon * MuonMatchingTool::matchEFCBFS	(	const xAOD::Muon *	mu,
		std::string	trigger,
		bool &	pass ) const

Function that searches for an EF combined muon (EFCBFS) candidate and judges if it is matched to a given offline muon.

Parameters

mu	Offline muon around which EFCBFS candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if the matched candidate passed the hypothesis step.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 275 of file MuonMatchingTool.cxx.

                                                {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFCBFS()");
  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::Primary);
 
  return MuonTrack ? 
    match<xAOD::Muon>( MuonTrack, std::move(trig), m_EFreqdR, pass, m_EFCBFSMuonKey.key() + ".*", &MuonMatchingTool::trigPosForMatchCBTrack) 
    : nullptr;
}

matchEFCBFS() [2/2]

const xAOD::Muon * MuonMatchingTool::matchEFCBFS	(	const xAOD::TruthParticle *	mu,
		std::string	trig,
		bool &	pass ) const

Function that searches for an EF combined muon (EFCBFS) candidate and judges if it is matched to a given truth muon.

Parameters

mu	Truth muon around which EFCBFS candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if the matched candidate passed the hypothesis step.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 265 of file MuonMatchingTool.cxx.

                                                {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFCBFS() for TruthParticle");
  return mu 
    ? match<xAOD::Muon>( mu, std::move(trig), m_EFreqdR, pass, m_EFCBFSMuonKey.key() + ".*", &MuonMatchingTool::trigPosForMatchCBTrack) 
    : nullptr;
}

matchEFCBFSLinkInfo()

const TrigCompositeUtils::LinkInfo< xAOD::MuonContainer > MuonMatchingTool::matchEFCBFSLinkInfo	(	const xAOD::Muon *	mu,
		std::string	trig ) const

Function that searches for an EF combined muon (EFCBFS) candidate and judges if it is matched to a given track particle.

Parameters

mu	Offline muon around which EFCBFS candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.

Returns

Pointer to the matched candidate. This is inValid link when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 287 of file MuonMatchingTool.cxx.

                                                            {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFCBFSLinkInfo()");
  bool pass = false;
  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::Primary);
 
  return MuonTrack 
    ? matchLinkInfo<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, m_EFCBFSMuonKey.key() + ".*", &MuonMatchingTool::trigPosForMatchCBTrack) 
    : TrigCompositeUtils::LinkInfo<xAOD::MuonContainer>{};
}

matchEFCBFSReadHandle()

const xAOD::Muon * MuonMatchingTool::matchEFCBFSReadHandle	(	const EventContext &	ctx,
		const xAOD::Muon *	mu ) const

Function that searches for an EF combined muon (EFCBFS) candidate by ReadHandle and judges if it is matched to a given offlineCB muon.

Parameters

mu	Offline muon around which EFCBFS candidates are searched.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found.

Definition at line 299 of file MuonMatchingTool.cxx.

                                                                  {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFCBFSReadHandle()");
  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::Primary);
 
  return MuonTrack 
    ? matchReadHandle<xAOD::Muon>(MuonTrack, m_EFreqdR, m_EFCBFSMuonKey, ctx, &MuonMatchingTool::trigPosForMatchCBTrack) 
    : nullptr;
}

matchEFCBLinkInfo()

const TrigCompositeUtils::LinkInfo< xAOD::MuonContainer > MuonMatchingTool::matchEFCBLinkInfo	(	const xAOD::Muon *	mu,
		std::string	trig ) const

Function that searches for an EF combined muon (EFCB) candidate and judges if it is matched to a given track particle.

Parameters

mu	Offline muon around which EFCB candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.

Returns

Pointer to the matched candidate. This is inValid link when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 185 of file MuonMatchingTool.cxx.

                                                          {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFCBLinkInfo()");
  bool pass = false;
  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::Primary);
 
  return MuonTrack 
    ? matchLinkInfo<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, m_EFCBMuonKey.key() + "*.*", &MuonMatchingTool::trigPosForMatchCBTrack) 
    : TrigCompositeUtils::LinkInfo<xAOD::MuonContainer>{};
}

matchEFCBReadHandle()

const xAOD::Muon * MuonMatchingTool::matchEFCBReadHandle	(	const EventContext &	ctx,
		const xAOD::Muon *	mu ) const

Function that searches for an EF combined muon (EFCB) candidate by ReadHandle and judges if it is matched to a given offlineCB muon.

Parameters

mu	Offline muon around which EFCB candidates are searched.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found.

Definition at line 197 of file MuonMatchingTool.cxx.

                                                                {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFCBReadHandle()");
  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::Primary);
 
  return MuonTrack 
    ? matchReadHandle<xAOD::Muon>( MuonTrack, m_EFreqdR, m_EFCBMuonKey, ctx, &MuonMatchingTool::trigPosForMatchCBTrack) 
    : nullptr;
}

matchEFIso() [1/2]

const xAOD::Muon * MuonMatchingTool::matchEFIso	(	const xAOD::Muon *	mu,
		std::string	trigger,
		bool &	pass ) const

Function that searches for an EF isolation muon (EFIso) candidate and judges if it is matched to a given offline muon.

Parameters

mu	Offline muon around which EFIso candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if the matched candidate passed the hypothesis step.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 310 of file MuonMatchingTool.cxx.

                                               {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFIso()");
  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::Primary);
 
  return MuonTrack 
    ? match<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, "HLT_MuonsIso", &MuonMatchingTool::trigPosForMatchCBTrack) 
    : nullptr;
}

matchEFIso() [2/2]

const xAOD::Muon * MuonMatchingTool::matchEFIso	(	const xAOD::TruthParticle *	mu,
		std::string	trigger,
		bool &	pass ) const

Function that searches for an EF isolation muon (EFIso) candidate and judges if it is matched to a given truth muon.

Parameters

mu	Truth muon around which EFIso candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if the matched candidate passed the hypothesis step.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 322 of file MuonMatchingTool.cxx.

                                               {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFIso() for truth particle");
  return mu 
    ? match<xAOD::Muon>( mu, std::move(trig), m_EFreqdR, pass, "HLT_MuonsIso", &MuonMatchingTool::trigPosForMatchCBTrack) 
    : nullptr;
}

matchEFIsoLinkInfo()

const TrigCompositeUtils::LinkInfo< xAOD::MuonContainer > MuonMatchingTool::matchEFIsoLinkInfo	(	const xAOD::Muon *	mu,
		std::string	trig ) const

Function that searches for an EF isolation muon (EFIso) candidate and judges if it is matched to a given track particle.

Parameters

mu	Offline muon around which EFIso candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.

Returns

Pointer to the matched candidate. This is inValid link when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 363 of file MuonMatchingTool.cxx.

                                                           {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFCBLinkInfo()");
  bool pass = false;
  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::Primary);
 
  return MuonTrack 
    ? matchLinkInfo<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, "HLT_MuonsIso", &MuonMatchingTool::trigPosForMatchCBTrack) 
    : TrigCompositeUtils::LinkInfo<xAOD::MuonContainer>{};
}

matchEFSA() [1/2]

const xAOD::Muon * MuonMatchingTool::matchEFSA	(	const xAOD::Muon *	mu,
		std::string	trigger,
		bool &	pass ) const

Function that searches for an EF standalone muon (EFSA) candidate and judges if it is matched to a given offline muon.

Parameters

mu	Offline muon around which EFSA candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if the matched candidate passed the hypothesis step.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 105 of file MuonMatchingTool.cxx.

                                              {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFSA()");
  const xAOD::TrackParticle* MuonTrack = getMSTrack(*mu);
 
  const std::string& containerKey {trig.contains("newFast") 
    ? m_EFSANewFastMuonKey.key() 
    : (trig.contains("mlbkt") ? m_EFSAMlbktMuonKey.key() : m_EFSAMuonKey.key())};
 
  return MuonTrack
    ? match<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, containerKey + ".*", &MuonMatchingTool::trigPosForMatchSATrack) 
    : nullptr;
}

matchEFSA() [2/2]

const xAOD::Muon * MuonMatchingTool::matchEFSA	(	const xAOD::TruthParticle *	mu,
		std::string	trigger,
		bool &	pass ) const

Function that searches for an EF standalone muon (EFSA) candidate and judges if it is matched to a given truth muon.

Parameters

mu	Truth muon around which EFSA candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if the matched candidate passed the hypothesis step.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 121 of file MuonMatchingTool.cxx.

                                              {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFSA() for truth particle");
 
  const std::string& containerKey {trig.contains("newFast") 
    ? m_EFSANewFastMuonKey.key() 
    : (trig.contains("mlbkt") ? m_EFSAMlbktMuonKey.key() : m_EFSAMuonKey.key())};
 
  return mu
    ? match<xAOD::Muon>(mu, std::move(trig), m_EFreqdR, pass, containerKey + ".*", &MuonMatchingTool::trigPosForMatchSATrack) 
    : nullptr;
}

matchEFSAFS() [1/2]

const xAOD::Muon * MuonMatchingTool::matchEFSAFS	(	const xAOD::Muon *	mu,
		std::string	trigger,
		bool &	pass ) const

Function that searches for an EF FS standalone muon (EFSAFS) candidate and judges if it is matched to a given offline muon.

Parameters

mu	Offline muon around which EFSAFS candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if the matched candidate passed the hypothesis step.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 208 of file MuonMatchingTool.cxx.

                                                {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFSAFS()");
  const xAOD::TrackParticle* MuonTrack = getMSTrack(*mu);
 
  const std::string& containerKey {trig.contains("newFast") 
    ? m_EFSAFSNewFastMuonKey.key() 
    : (trig.contains("mlbkt") ? m_EFSAFSMlbktMuonKey.key() : m_EFSAFSMuonKey.key())};
 
  return MuonTrack
    ? match<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, containerKey + ".*", &MuonMatchingTool::trigPosForMatchSATrack) 
    : nullptr;
}

matchEFSAFS() [2/2]

const xAOD::Muon * MuonMatchingTool::matchEFSAFS	(	const xAOD::TruthParticle *	mu,
		std::string	trigger,
		bool &	pass ) const

Function that searches for an EF standalone muon (EFSAFS) candidate and judges if it is matched to a given truth muon.

Parameters

mu	Truth muon around which EFSAFS candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if the matched candidate passed the hypothesis step.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 224 of file MuonMatchingTool.cxx.

                                                {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFSAFS() for truth particle");
 
  const std::string& containerKey {trig.contains("newFast") 
    ? m_EFSAFSNewFastMuonKey.key() 
    : (trig.contains("mlbkt") ? m_EFSAFSMlbktMuonKey.key() : m_EFSAFSMuonKey.key())};
 
  return mu
    ? match<xAOD::Muon>(mu, std::move(trig), m_EFreqdR, pass, containerKey + ".*", &MuonMatchingTool::trigPosForMatchSATrack) 
    : nullptr;
}

matchEFSAFSLinkInfo()

const TrigCompositeUtils::LinkInfo< xAOD::MuonContainer > MuonMatchingTool::matchEFSAFSLinkInfo	(	const xAOD::Muon *	mu,
		std::string	trig ) const

Function that searches for an EF standalone muon (EFSAFS) candidate and judges if it is matched to a given track particle.

Parameters

mu	Offline muon around which EFSAFS candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.

Returns

Pointer to the matched candidate. This is inValid link when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 239 of file MuonMatchingTool.cxx.

                                                            {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFSAFSLinkInfo()");
  bool pass = false;
  const xAOD::TrackParticle* MuonTrack = getMSTrack(*mu);
 
  const std::string& containerKey {trig.contains("newFast") 
    ? m_EFSAFSNewFastMuonKey.key() 
    : (trig.contains("mlbkt") ? m_EFSAFSMlbktMuonKey.key() : m_EFSAFSMuonKey.key())};
 
  return MuonTrack
    ? matchLinkInfo<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, containerKey + ".*", &MuonMatchingTool::trigPosForMatchSATrack) 
    : TrigCompositeUtils::LinkInfo<xAOD::MuonContainer>{};
}

matchEFSAFSReadHandle()

const xAOD::Muon * MuonMatchingTool::matchEFSAFSReadHandle	(	const EventContext &	ctx,
		const xAOD::Muon *	mu ) const

Function that searches for an EF standalone muon (EFSAFS) candidate by ReadHandle and judges if it is matched to a given offlineSAFS muon.

Parameters

mu	Offline muon around which EFSAFS candidates are searched.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found.

Definition at line 255 of file MuonMatchingTool.cxx.

                                                                  {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFSAFSReadHandle()");
  const xAOD::TrackParticle* MuonTrack = getMSTrack(*mu);
  return MuonTrack 
    ? matchReadHandle<xAOD::Muon>(MuonTrack, m_EFreqdR, m_EFSAFSMuonKey, ctx, &MuonMatchingTool::trigPosForMatchSATrack) 
    : nullptr;
}

matchEFSALinkInfo()

const TrigCompositeUtils::LinkInfo< xAOD::MuonContainer > MuonMatchingTool::matchEFSALinkInfo	(	const xAOD::Muon *	mu,
		std::string	trig ) const

Function that searches for an EF standalone muon (EFSA) candidate and judges if it is matched to a given track particle.

Parameters

mu	Offline muon around which EFSA candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.

Returns

Pointer to the matched candidate. This is inValid link when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 136 of file MuonMatchingTool.cxx.

                                                          {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFSALinkInfo()");
  bool pass = false;
  const xAOD::TrackParticle* MuonTrack = getMSTrack(*mu);
  
  const std::string& containerKey {trig.contains("newFast") 
    ? m_EFSANewFastMuonKey.key() 
    : (trig.contains("mlbkt") ? m_EFSAMlbktMuonKey.key() : m_EFSAMuonKey.key())};
 
  return MuonTrack
    ? matchLinkInfo<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, containerKey + ".*", &MuonMatchingTool::trigPosForMatchSATrack) 
    : TrigCompositeUtils::LinkInfo<xAOD::MuonContainer>{};
}

matchEFSAReadHandle()

const xAOD::Muon * MuonMatchingTool::matchEFSAReadHandle	(	const EventContext &	ctx,
		const xAOD::Muon *	mu ) const

Function that searches for an EF standalone muon (EFSA) candidate by ReadHandle and judges if it is matched to a given offlineSA muon.

Parameters

mu	Offline muon around which EFSA candidates are searched.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found.

Definition at line 152 of file MuonMatchingTool.cxx.

                                                                {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFSAReadHandle()");
  const xAOD::TrackParticle* MuonTrack = getMSTrack(*mu);
 
  return MuonTrack
    ? matchReadHandle<xAOD::Muon>(MuonTrack, m_EFreqdR, m_EFSAMuonKey, ctx, &MuonMatchingTool::trigPosForMatchSATrack)
    : nullptr;
}

matchFastRecoSA() [1/2]

const xAOD::Muon * MuonMatchingTool::matchFastRecoSA	(	const EventContext &	ctx,
		const xAOD::Muon *	mu,
		const std::string &	trigger,
		bool &	pass ) const

Function that searches for a EF fast reco muon (PhaseII) candidate and judges if it is matched to a given offline muon.

Parameters

mu	Offline muon around which L2MuonSA candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_newfast_ivarmedium_L1MU20, etc.
pass	True if the matched candidate passed the hypothesis step.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 392 of file MuonMatchingTool.cxx.

                                                    {
  ATH_MSG_DEBUG("MuonMonitoring::matchFastRecoSA()");
  float reqdR = m_L2SAreqdR;
  if(m_use_extrapolator){
    reqdR = reqdRL1byPt(mu->pt());
    const Amg::Vector3D extPos = offlineMuonAtPivot(ctx, *mu);
    if(extPos.norm()>ZERO_LIMIT){
      return match<xAOD::Muon>( &extPos, trig, reqdR, pass);
    }
  }
  return match<xAOD::Muon>( mu, trig, reqdR, pass, m_FastRecoSAMuonKey.key());
}

matchFastRecoSA() [2/2]

const xAOD::Muon * MuonMatchingTool::matchFastRecoSA	(	const xAOD::TruthParticle *	mu,
		const std::string &	trigger,
		bool &	pass ) const

Function that searches for a EF fast reco standalone muon (PhaseII) candidate and judges if it is matched to a given truth particle.

Parameters

mu	Truth particle around which the candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_newfast_ivarmedium_L1MU20, etc.
pass	True if the matched candidate passed the hypothesis step.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 417 of file MuonMatchingTool.cxx.

                                                    {
  ATH_MSG_DEBUG("MuonMonitoring::matchFastRecoSA() from TruthParticle");
  return match<xAOD::Muon>( mu, trig, m_L2SAreqdR, pass, m_FastRecoSAMuonKey.key());
}

matchFastRecoSAReadHandle()

const xAOD::Muon * MuonMatchingTool::matchFastRecoSAReadHandle	(	const EventContext &	ctx,
		const xAOD::Muon *	mu ) const

Function that searches for a EF fast reco standalone muon (PhaseII) candidate by ReadHandle and judges if it is matched to a given offlineSA muon.

Parameters

mu	Offline muon around which L2MuonSA candidates are searched.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found.

Definition at line 459 of file MuonMatchingTool.cxx.

                                                                      {
  ATH_MSG_DEBUG("MuonMonitoring::matchFastRecoSAReadHandle()");
  float reqdR = m_L2SAreqdR;
  if(m_use_extrapolator){
    reqdR = reqdRL1byPt(mu->pt());
    const Amg::Vector3D extPos = offlineMuonAtPivot(ctx, *mu);
    if(extPos.norm()>ZERO_LIMIT){
      return matchReadHandle<xAOD::Muon>(&extPos, reqdR, m_FastRecoSAMuonKey, ctx);
    }
  }
  const xAOD::TrackParticle* MuonTrack = getMSTrack(*mu);
  return MuonTrack 
    ? matchReadHandle<xAOD::Muon>(MuonTrack, reqdR, m_FastRecoSAMuonKey, ctx) 
    : nullptr;
}

matchFastRecoSAtoOff()

const xAOD::Muon * MuonMatchingTool::matchFastRecoSAtoOff	(	const EventContext &	ctx,
		const xAOD::Muon *	samu ) const

Function that searches for an offline muon matched to EF Fast Reco SA muon.

Parameters

ctx	Reference to the EventContext needed for accessing the Muons container.
samu	the given online muon

Returns

Pointer to the matched offline muon. This is nullptr when there is no muon found.

Definition at line 601 of file MuonMatchingTool.cxx.

                                                                   {
  return matchOff(ctx, samu, m_L2SAreqdR, 
    [this](const xAOD::Muon* mu) {return MuonMatchingTool::PosForMatchSATrack(mu, m_isPhII);});
}

matchL1() [1/3]

const xAOD::MuonRoI * MuonMatchingTool::matchL1	(	const EventContext &	ctx,
		const xAOD::Muon *	mu,
		const std::string &	trigger,
		bool &	pass ) const

Function that searches for a Level 1 muon candidate and judges if it is matched to a given offline muon.

Parameters

mu	Offline muon around which Level 1 candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if a candidate is found.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found.

Definition at line 563 of file MuonMatchingTool.cxx.

                                            {
  double refEta = mu->eta();
  double refPhi = mu->phi();
  double reqdR = 0.25;
 
  if(m_use_extrapolator){
    reqdR = reqdRL1byPt(mu->pt());
    const Amg::Vector3D extPos = offlineMuonAtPivot(ctx, *mu);
    if(extPos.norm()>ZERO_LIMIT){
      refEta = extPos.eta();
      refPhi = extPos.phi();
    }
  }
  return matchL1(ctx, refEta, refPhi, reqdR, trig, pass);
}

matchL1() [2/3]

const xAOD::MuonRoI * MuonMatchingTool::matchL1	(	const EventContext &	ctx,
		const xAOD::TruthParticle *	mu,
		const std::string &	trigger,
		bool &	pass ) const

Function that searches for a Level 1 truth muon candidate and judges if it is matched to a given offline muon.

Parameters

mu	Truth muon around which Level 1 candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if a candidate is found.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found.

Definition at line 583 of file MuonMatchingTool.cxx.

                                            {
  double refEta = mu->eta();
  double refPhi = mu->phi();
  double reqdR = 0.25;
  return matchL1(ctx, refEta, refPhi, reqdR, trig, pass);
}

matchL1() [3/3]

const xAOD::MuonRoI * MuonMatchingTool::matchL1	(	const EventContext &	ctx,
		double	eta,
		double	phi,
		double	dR,
		const std::string &	trigger,
		bool &	pass ) const

Function that dR matches L1 muon candidates.

Parameters

eta	Eta of muon around which Level 1 candidates are searched.
phi	Phi of muon around which Level 1 candidates are searched.
dR	dR limit within which a match is accepted.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if a candidate is found.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found.

Retrieve the chain configuration and the lower name corresponding to the L1 threshold

Definition at line 512 of file MuonMatchingTool.cxx.

                                            {

    const TrigConf::HLTChain* chainCfg = m_trigDec->ExperimentalAndExpertMethods().getChainConfigurationDetails(trig);
    const std::string L1toMatch = chainCfg->lower_chain_name().substr(3);
    
    SG::ReadHandle<xAOD::MuonRoIContainer> L1rois(m_MuonRoIKey, ctx);
    const xAOD::MuonRoI* closest = nullptr;
 
    for (const xAOD::MuonRoI* l1muon : *L1rois){
 
        // get all L1 thresholds from the L1 menu along with whether the L1roi passed each of those or not
        const std::vector<std::pair<std::shared_ptr<TrigConf::L1Threshold>, bool> > L1thr_list = m_thresholdTool-> getThresholdDecisions(
                    l1muon->roiWord(), ctx);
        
        // check the L1 threshold we are looking for
        bool L1thr_isMatch = false;
        for(const std::pair<std::shared_ptr<TrigConf::L1Threshold>, bool>&  L1thr : L1thr_list){
            if (L1toMatch == L1thr.first->name()){
                L1thr_isMatch = L1thr.second;
                break;
            }
        }
        if (!L1thr_isMatch) continue;
 
        double l1muonEta = l1muon->eta();
        double l1muonPhi = l1muon->phi();
        
        double deta = refEta - l1muonEta;
        double dphi = xAOD::P4Helpers::deltaPhi(refPhi, l1muonPhi);
        double dR = std::sqrt(deta*deta + dphi*dphi);
        ATH_MSG_DEBUG("L1 muon candidate eta=" << l1muonEta << " phi=" << l1muonPhi << " dR=" << dR);
        if( dR<reqdR ){
            reqdR = dR;
            pass = true;
            closest = l1muon;
            ATH_MSG_DEBUG("*** L1 muon eta=" << l1muonEta << " phi=" << l1muonPhi << " dR=" << dR <<  " isPassed=true" ); 
        }
        else{
            ATH_MSG_DEBUG("*** L1 muon eta=" << l1muonEta << " phi=" << l1muonPhi << " dR=" << dR <<  " isPassed=false" );
        }
    }
    return closest;
}

matchL2CB() [1/2]

const xAOD::L2CombinedMuon * MuonMatchingTool::matchL2CB	(	const xAOD::Muon *	mu,
		std::string	trigger,
		bool &	pass ) const

Function that searches for an L2 combined muon (L2muComb) candidate and judges if it is matched to a given offline muon.

Parameters

mu	Offline muon around which L2muComb candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if the matched candidate passed the hypothesis step.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 477 of file MuonMatchingTool.cxx.

                                              {
  ATH_MSG_DEBUG("MuonMonitoring::matchL2CB()");
  return match<xAOD::L2CombinedMuon>(mu, std::move(trig), m_L2CBreqdR, pass, m_L2CBMuonKey.key());
}

matchL2CB() [2/2]

const xAOD::L2CombinedMuon * MuonMatchingTool::matchL2CB	(	const xAOD::TruthParticle *	mu,
		std::string	trigger,
		bool &	pass ) const

Function that searches for an L2 combined muon (L2muComb) candidate and judges if it is matched to a given truth muon.

Parameters

mu	Truth muon around which L2muComb candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if the matched candidate passed the hypothesis step.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 485 of file MuonMatchingTool.cxx.

                                              {
  ATH_MSG_DEBUG("MuonMonitoring::matchL2CB() from TruthParticle");
  return match<xAOD::L2CombinedMuon>(mu, std::move(trig), m_L2CBreqdR, pass, m_L2CBMuonKey.key());
}

matchL2CBReadHandle()

const xAOD::L2CombinedMuon * MuonMatchingTool::matchL2CBReadHandle	(	const EventContext &	ctx,
		const xAOD::Muon *	mu ) const

Function that searches for an L2 combined muon (L2muComb) candidate by ReadHandle and judges if it is matched to a given offlineCB muon.

Parameters

mu	Offline muon around which L2muComb candidates are searched.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found.

Definition at line 501 of file MuonMatchingTool.cxx.

                                                                {
  ATH_MSG_DEBUG("MuonMonitoring::matchL2CBReadHandle()");
  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::Primary);
 
  return MuonTrack 
    ? matchReadHandle<xAOD::L2CombinedMuon>(MuonTrack, m_L2CBreqdR, m_L2CBMuonKey, ctx) 
    : nullptr;
}

matchL2CBtoOff()

const xAOD::Muon * MuonMatchingTool::matchL2CBtoOff	(	const EventContext &	ctx,
		const xAOD::L2CombinedMuon *	cbmu ) const

Function that searches for an offline muon matched to L2CB muon.

Parameters

ctx	Reference to the EventContext needed for accessing the Muons container.
cbmu	the given online muon

Returns

Pointer to the matched offline muon. This is nullptr when there is no muon found.

Definition at line 608 of file MuonMatchingTool.cxx.

                                                                       {
  return matchOff(ctx, cbmu, m_L2CBreqdR, &MuonMatchingTool::PosForMatchCBTrack);
}

matchL2SA() [1/2]

const xAOD::L2StandAloneMuon * MuonMatchingTool::matchL2SA	(	const EventContext &	ctx,
		const xAOD::Muon *	mu,
		const std::string &	trigger,
		bool &	pass ) const

Function that searches for an L2 standalone muon (L2MuonSA) candidate and judges if it is matched to a given offline muon.

Parameters

mu	Offline muon around which L2MuonSA candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if the matched candidate passed the hypothesis step.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 375 of file MuonMatchingTool.cxx.

                                              {
  ATH_MSG_DEBUG("MuonMonitoring::matchL2SA()");
  float reqdR = m_L2SAreqdR;
  if(m_use_extrapolator){
    reqdR = reqdRL1byPt(mu->pt());
    const Amg::Vector3D extPos = offlineMuonAtPivot(ctx, *mu);
    if(extPos.norm()>ZERO_LIMIT){
      return match<xAOD::L2StandAloneMuon>( &extPos, trig, reqdR, pass);
    }
  }
  return match<xAOD::L2StandAloneMuon>(mu, trig, reqdR, pass, m_L2SAMuonKey.key());
}

matchL2SA() [2/2]

const xAOD::L2StandAloneMuon * MuonMatchingTool::matchL2SA	(	const xAOD::TruthParticle *	mu,
		const std::string &	trigger,
		bool &	pass ) const

Function that searches for an L2 standalone muon (L2MuonSA) candidate and judges if it is matched to a given truth particle.

Parameters

mu	Truth particle around which L2MuonSA candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
pass	True if the matched candidate passed the hypothesis step.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 409 of file MuonMatchingTool.cxx.

                                              {
  ATH_MSG_DEBUG("MuonMonitoring::matchL2SA() from TruthParticle");
  return match<xAOD::L2StandAloneMuon>( mu, trig, m_L2SAreqdR, pass, m_L2SAMuonKey.key());
}

matchL2SAReadHandle()

const xAOD::L2StandAloneMuon * MuonMatchingTool::matchL2SAReadHandle	(	const EventContext &	ctx,
		const xAOD::Muon *	mu ) const

Function that searches for an L2 standalone muon (L2MuonSA) candidate by ReadHandle and judges if it is matched to a given offlineSA muon.

Parameters

mu	Offline muon around which L2MuonSA candidates are searched.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found.

Definition at line 441 of file MuonMatchingTool.cxx.

                                                                {
  ATH_MSG_DEBUG("MuonMonitoring::matchL2SAReadHandle()");
  float reqdR = m_L2SAreqdR;
  if(m_use_extrapolator){
    reqdR = reqdRL1byPt(mu->pt());
    const Amg::Vector3D extPos = offlineMuonAtPivot(ctx, *mu);
    if(extPos.norm()>ZERO_LIMIT){
      return matchReadHandle<xAOD::L2StandAloneMuon>(&extPos, reqdR, m_L2SAMuonKey, ctx);
    }
  }
  const xAOD::TrackParticle* MuonTrack = getMSTrack(*mu);
  return MuonTrack 
    ? matchReadHandle<xAOD::L2StandAloneMuon>(MuonTrack, reqdR, m_L2SAMuonKey, ctx) 
    : nullptr;
}

matchL2SAtoOff()

const xAOD::Muon * MuonMatchingTool::matchL2SAtoOff	(	const EventContext &	ctx,
		const xAOD::L2StandAloneMuon *	samu ) const

Function that searches for an offline muon matched to L2SA muon.

Parameters

ctx	Reference to the EventContext needed for accessing the Muons container.
samu	the given online muon

Returns

Pointer to the matched offline muon. This is nullptr when there is no muon found.

Definition at line 594 of file MuonMatchingTool.cxx.

                                                                         {
  return matchOff(ctx, samu, m_L2SAreqdR, 
    [this](const xAOD::Muon* mu) {return MuonMatchingTool::PosForMatchSATrack(mu, m_isPhII);});
}

matchLinkInfo()

template<class T, class OFFL>

const TrigCompositeUtils::LinkInfo< DataVector< T > > MuonMatchingTool::matchLinkInfo ( const OFFL * offl, std::string trigger, float reqdR, bool & pass, const std::string & containerSGKey = "", std::tuple< bool, double, double >(* trigPosForMatchFunc )(const T *) = &MuonMatchingTool::trigPosForMatch< T > ) const

private

Function that searches for an online muon candidate of type T closest to a given offline muon.

Parameters

offl	Position of the offline muon used for computing dR.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
trigPosForMatchFunc	Function pointer that implements cuts for the online muon candidates.

Returns

LinkInfo to the matched candidate. This is inValid link when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

See also

MuonMatchingTool.icc for the implementation and MuonMatchingTool.cxx for the instantiation.

Todo

Consider improving the argument list.

matchOff()

template<class T>

const xAOD::Muon * MuonMatchingTool::matchOff ( const EventContext & ctx, const T * trig, float reqdR, std::function< std::tuple< bool, double, double >(const xAOD::Muon *)> offlinePosForMatchFunc, std::function< std::tuple< bool, double, double >(const T *)> trigPosForMatchFunc = &MuonMatchingTool::trigPosForMatch< T > ) const

private

Function that searches for an offline muon candidate matched to online muon of type T.

Parameters

trig	Position of the online muon used for computing dR.
reqdR	Requirement of dR used for the matching. Note that reqdR is updated with the dR of the found candidate.
offlinePosForMatchFunc	Function pointer that implements cuts for the offline muon candidates.
trigPosForMatchFunc	Function pointer that implements cuts for the online muon candidates.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

See also

MuonMatchingTool.icc for the implementation and MuonMatchingTool.cxx for the instantiation.

Todo

Consider improving the argument list.

matchReadHandle()

template<class T, class OFFL>

const T * MuonMatchingTool::matchReadHandle ( const OFFL * offl, float reqdR, const SG::ReadHandleKey< DataVector< T > > & ReadHandleKey, const EventContext & ctx, std::tuple< bool, double, double >(* trigPosForMatchFunc )(const T *) = &MuonMatchingTool::trigPosForMatch< T > ) const

private

Function that searches for an online muon candidate of type T by ReadHandle and judges if it is matched to a given offline muon.

Parameters

offl	Position of the offline muon used for computing dR.
reqdR	Requirement of dR used for the matching. Note that reqdR is updated with the dR of the found candidate.
ReadHandleKey	SG::ReadHandleKey of online muon.
ctx	EventContext.
trigPosForMatchFunc	Function pointer that implements cuts for the online muon candidates.

Returns

Pointer to the matched candidate. This is nullptr when there is no candidate found.

See also

MuonMatchingTool.icc for the implementation and MuonMatchingTool.cxx for the instantiation.

Todo

Consider improving the argument list.

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

offlineMuonAtPivot()

Amg::Vector3D MuonMatchingTool::offlineMuonAtPivot ( const EventContext & ctx, const xAOD::Muon & mu ) const

private

Definition at line 57 of file MuonMatchingTool.cxx.

                                                                             {
  const xAOD::TrackParticle* track{mu.trackParticle(xAOD::Muon::TrackParticleType::Primary)};
  std::unique_ptr<Trk::TrackParameters> extPars{extTrackToPivot(ctx, track)};
  return extPars ? extPars->position() : Amg::Vector3D::Zero();
}

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.

PosForMatchCBTrack()

std::tuple< bool, double, double > MuonMatchingTool::PosForMatchCBTrack ( const xAOD::Muon * mu )

static

Definition at line 97 of file MuonMatchingTool.cxx.

                                                      {
  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::CombinedTrackParticle);
  return MuonTrack 
    ? std::forward_as_tuple(true, MuonTrack->eta(), MuonTrack->phi()) 
    : std::forward_as_tuple(false, 0., 0.);
}

PosForMatchSATrack()

std::tuple< bool, double, double > MuonMatchingTool::PosForMatchSATrack ( const xAOD::Muon * mu, const bool isPhaseII = false )

static

Definition at line 85 of file MuonMatchingTool.cxx.

                                                          {
  const xAOD::Muon::TrackParticleType type {isPhaseII 
    ? xAOD::Muon::TrackParticleType::Primary 
    : xAOD::Muon::TrackParticleType::ExtrapolatedMuonSpectrometerTrackParticle};  
  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(type);
  return MuonTrack 
    ? std::forward_as_tuple(true, MuonTrack->eta(), MuonTrack->phi()) 
    : std::forward_as_tuple(false, 0., 0.);
}

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

reqdRL1byPt()

double MuonMatchingTool::reqdRL1byPt ( double mupt )

static

Function compute dR used for matching offline muons and level 1 RoIs at the pivot plane.

This is needed that the accuracy of the extrapolation by extTrackToPivot is dependent on the pt of the offline muon.

Parameters

mupt	Offline muon pt

Returns

Required dR between the offline muon and Level 1 muons

Definition at line 707 of file MuonMatchingTool.cxx.

                                        {
  double dR = 0.08;
  if( mupt < 10000. ) {
    dR = -0.00001*mupt + 0.18;
  } 
  return dR;
}

SearchEFTrack()

const xAOD::TrackParticle * MuonMatchingTool::SearchEFTrack	(	const EventContext &	ctx,
		const TrigCompositeUtils::LinkInfo< xAOD::MuonContainer > &	muLinkInfo,
		const SG::ReadHandleKey< xAOD::TrackParticleContainer > &	ReadHandleKey ) const

Function that searches for an EF muon track (e.g.

ExtrapolatedMuonSpectrometerTrackParticle, CombinedTrackParticle) matched to a EF muon.

Parameters

ctx	Reference to the EventContext needed for accessing the TrackParticle container.
muLinkInfo	LinkInfo of EF muon.
ReadHandleKey	of TrackParticle container.

Returns

Pointer to the matched TrackParticle. This is nullpt rwhen there is no TrackParticle found.

Definition at line 332 of file MuonMatchingTool.cxx.

                                                                                                        {
  const xAOD::TrackParticle* MatchedTrack = nullptr;
  const ElementLink<xAOD::MuonContainer> muEL = muLinkInfo.link;
  float EFEta = (*muEL)->eta();
  float EFPhi = (*muEL)->phi();
  float mindR = 999.;
 
  SG::ReadHandle<xAOD::TrackParticleContainer> trackHandle(ReadHandleKey, ctx);
  if ( !trackHandle.isValid() ) return MatchedTrack;
 
  const auto track = m_trigDec->associateToEventView<xAOD::TrackParticleContainer>(trackHandle, muLinkInfo);
  const xAOD::TrackParticleContainer::const_iterator begin = track.first;
  const xAOD::TrackParticleContainer::const_iterator end  = track.second;
 
  for (xAOD::TrackParticleContainer::const_iterator it = begin; it != end; ++it) {
 
    float deta = EFEta - (*it)->eta();
    float dphi = xAOD::P4Helpers::deltaPhi(EFPhi, (*it)->phi() );
    float dR = std::sqrt(deta*deta + dphi*dphi);
 
    if( dR< mindR ){
      mindR = dR;
      MatchedTrack = (*it);
    }
  }
  return MatchedTrack;
}

searchFastRecoSALinkInfo()

const TrigCompositeUtils::LinkInfo< xAOD::MuonContainer > MuonMatchingTool::searchFastRecoSALinkInfo	(	const xAOD::Muon *	mu,
		std::string	trigger ) const

Function that searches for the EF fast reco standalone candidate closest to a given offline muon.

Parameters

mu	Offline muon around which L2MuonSA candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_newfast_ivarmedium_L1MU20, etc.

Returns

LinkInfo to the found candidate. This is inValid link when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis and matched, users should check pass for the decision and pass for knowing if it is really matched.

Todo

Consider improving the argument list.

Definition at line 433 of file MuonMatchingTool.cxx.

                                                                 {
  ATH_MSG_DEBUG("MuonMonitoring::searchFastRecoLinkInfo()");
  bool pass = false;
  return matchLinkInfo<xAOD::Muon>(mu, std::move(trig), 1000., pass, m_FastRecoSAMuonKey.key());
}

searchL2CBLinkInfo()

const TrigCompositeUtils::LinkInfo< xAOD::L2CombinedMuonContainer > MuonMatchingTool::searchL2CBLinkInfo	(	const xAOD::Muon *	mu,
		std::string	trigger ) const

Function that searches for the L2 combined muon (L2muComb) candidate closest to a given offline muon.

Parameters

mu	Offline muon around which L2MuonSA candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.

Returns

LinkInfo to the found candidate. This is inValid link when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis and matched, users should check pass for the decision and pass for knowing if it is really matched.

Todo

Consider improving the argument list.

Definition at line 493 of file MuonMatchingTool.cxx.

                                                           {
  ATH_MSG_DEBUG("MuonMonitoring::searchL2CBLinkInfo()");
  bool pass = false;
  return matchLinkInfo<xAOD::L2CombinedMuon>(mu, std::move(trig),  1000., pass, m_L2CBMuonKey.key());
}

searchL2SALinkInfo()

const TrigCompositeUtils::LinkInfo< xAOD::L2StandAloneMuonContainer > MuonMatchingTool::searchL2SALinkInfo	(	const xAOD::Muon *	mu,
		std::string	trigger ) const

Function that searches for the L2 standalone muon (L2MuonSA) candidate closest to a given offline muon.

Parameters

mu	Offline muon around which L2MuonSA candidates are searched.
trigger	Considered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.

Returns

LinkInfo to the found candidate. This is inValid link when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis and matched, users should check pass for the decision and pass for knowing if it is really matched.

Todo

Consider improving the argument list.

Definition at line 425 of file MuonMatchingTool.cxx.

                                                           {
  ATH_MSG_DEBUG("MuonMonitoring::searchL2SALinkInfo()");
  bool pass = false;
  return matchLinkInfo<xAOD::L2StandAloneMuon>(mu, std::move(trig), 1000., pass, m_L2SAMuonKey.key());
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

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.

trigPosForMatch()

template<class T>

std::tuple< bool, double, double > MuonMatchingTool::trigPosForMatch ( const T * trig )

inlinestaticprivate

trigPosForMatchCBTrack()

std::tuple< bool, double, double > MuonMatchingTool::trigPosForMatchCBTrack ( const xAOD::Muon * mu )

static

Definition at line 78 of file MuonMatchingTool.cxx.

                                                          {
  return mu->muonType() == xAOD::Muon::MuonType::Combined 
    ? std::forward_as_tuple(true, mu->eta(), mu->phi()) 
    : std::forward_as_tuple(false, 0., 0.);
}

trigPosForMatchSATrack()

std::tuple< bool, double, double > MuonMatchingTool::trigPosForMatchSATrack ( const xAOD::Muon * mu )

static

Definition at line 71 of file MuonMatchingTool.cxx.

                                                          {
  return mu->muonType() == xAOD::Muon::MuonType::MuonStandAlone 
    ? std::forward_as_tuple(true, mu->eta(), mu->phi()) 
    : std::forward_as_tuple(false, 0., 0.);
}

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_EFCBFSMuonKey

SG::ReadHandleKey<xAOD::MuonContainer> MuonMatchingTool::m_EFCBFSMuonKey {this, "EFCBFSMuonContainerName", "HLT_MuonsCB_FS", "EFCBFSMuon container"}

private

Definition at line 518 of file MuonMatchingTool.h.

{this, "EFCBFSMuonContainerName", "HLT_MuonsCB_FS", "EFCBFSMuon container"};

m_EFCBMuonKey

SG::ReadHandleKey<xAOD::MuonContainer> MuonMatchingTool::m_EFCBMuonKey {this, "EFCBMuonContainerName", "HLT_MuonsCB_RoI", "EFCBMuon container"}

private

Definition at line 514 of file MuonMatchingTool.h.

{this, "EFCBMuonContainerName", "HLT_MuonsCB_RoI", "EFCBMuon container"};

m_EFreqdR

const float MuonMatchingTool::m_EFreqdR = 0.03

private

Definition at line 432 of file MuonMatchingTool.h.

m_EFSAFSMlbktMuonKey

SG::ReadHandleKey<xAOD::MuonContainer> MuonMatchingTool::m_EFSAFSMlbktMuonKey {this, "EFSAFSMlbktMuonContainerName", "HLT_Muons_FS", "EFSAFSMuon container"}

private

Definition at line 516 of file MuonMatchingTool.h.

{this, "EFSAFSMlbktMuonContainerName", "HLT_Muons_FS", "EFSAFSMuon container"};

m_EFSAFSMuonKey

SG::ReadHandleKey<xAOD::MuonContainer> MuonMatchingTool::m_EFSAFSMuonKey {this, "EFSAFSMuonContainerName", "HLT_Muons_FS", "EFSAFSMuon container"}

private

Definition at line 515 of file MuonMatchingTool.h.

{this, "EFSAFSMuonContainerName", "HLT_Muons_FS", "EFSAFSMuon container"};

m_EFSAFSNewFastMuonKey

SG::ReadHandleKey<xAOD::MuonContainer> MuonMatchingTool::m_EFSAFSNewFastMuonKey {this, "EFSAFSNewFastMuonContainerName", "HLT_Muons_FS", "EFSAFSMuon container"}

private

Definition at line 517 of file MuonMatchingTool.h.

{this, "EFSAFSNewFastMuonContainerName", "HLT_Muons_FS", "EFSAFSMuon container"};

m_EFSAMlbktMuonKey

SG::ReadHandleKey<xAOD::MuonContainer> MuonMatchingTool::m_EFSAMlbktMuonKey {this, "EFSAMlbktMuonContainerName", "HLT_Muons_RoI", "EFSAMuon container"}

private

Definition at line 512 of file MuonMatchingTool.h.

{this, "EFSAMlbktMuonContainerName", "HLT_Muons_RoI", "EFSAMuon container"};

m_EFSAMuonKey

SG::ReadHandleKey<xAOD::MuonContainer> MuonMatchingTool::m_EFSAMuonKey {this, "EFSAMuonContainerName", "HLT_Muons_RoI", "EFSAMuon container"}

private

Definition at line 511 of file MuonMatchingTool.h.

{this, "EFSAMuonContainerName", "HLT_Muons_RoI", "EFSAMuon container"};

m_EFSANewFastMuonKey

SG::ReadHandleKey<xAOD::MuonContainer> MuonMatchingTool::m_EFSANewFastMuonKey {this, "EFSANewFastMuonContainerName", "HLT_Muons_RoI", "EFSAMuon container"}

private

Definition at line 513 of file MuonMatchingTool.h.

{this, "EFSANewFastMuonContainerName", "HLT_Muons_RoI", "EFSAMuon container"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_extrapolator

PublicToolHandle<Trk::IExtrapolator> MuonMatchingTool::m_extrapolator {"Trk::Extrapolator/AtlasExtrapolator"}

private

Definition at line 529 of file MuonMatchingTool.h.

{"Trk::Extrapolator/AtlasExtrapolator"};

m_FastRecoSAMuonKey

SG::ReadHandleKey<xAOD::MuonContainer> MuonMatchingTool::m_FastRecoSAMuonKey {this, "FastRecoSAContainerName", "HLT_FastMuonsInfo", "EFFastRecoSA container (Phase2)"}

private

Definition at line 509 of file MuonMatchingTool.h.

{this, "FastRecoSAContainerName", "HLT_FastMuonsInfo", "EFFastRecoSA container (Phase2)"};

m_isPhII

BooleanProperty MuonMatchingTool::m_isPhII {this, "isPhaseII", false, "Whether the muons have been processed with Phase II software"}

private

Definition at line 522 of file MuonMatchingTool.h.

{this, "isPhaseII", false, "Whether the muons have been processed with Phase II software"};

m_L2CBMuonKey

SG::ReadHandleKey<xAOD::L2CombinedMuonContainer> MuonMatchingTool::m_L2CBMuonKey {this, "L2CombinedMuonContainerName", "HLT_MuonL2CBInfo", "L2muComb container"}

private

Definition at line 510 of file MuonMatchingTool.h.

{this, "L2CombinedMuonContainerName", "HLT_MuonL2CBInfo", "L2muComb container"};

m_L2CBreqdR

const float MuonMatchingTool::m_L2CBreqdR = 0.03

private

Definition at line 430 of file MuonMatchingTool.h.

m_L2InsideOutreqdR

const float MuonMatchingTool::m_L2InsideOutreqdR = 0.01

private

Definition at line 431 of file MuonMatchingTool.h.

m_L2SAMuonKey

SG::ReadHandleKey<xAOD::L2StandAloneMuonContainer> MuonMatchingTool::m_L2SAMuonKey {this, "L2StandAloneMuonContainerName", "HLT_FastMuons_RoI", "L2MuonSA container"}

private

Definition at line 508 of file MuonMatchingTool.h.

{this, "L2StandAloneMuonContainerName", "HLT_FastMuons_RoI", "L2MuonSA container"};

m_L2SAreqdR

const float MuonMatchingTool::m_L2SAreqdR = 0.25

private

Definition at line 429 of file MuonMatchingTool.h.

m_MuonKey

SG::ReadHandleKey<xAOD::MuonContainer> MuonMatchingTool::m_MuonKey {this, "MuonContainerName", "Muons", "Offline muon container"}

private

Definition at line 507 of file MuonMatchingTool.h.

{this, "MuonContainerName", "Muons", "Offline muon container"};

m_MuonRoIKey

SG::ReadHandleKey<xAOD::MuonRoIContainer> MuonMatchingTool::m_MuonRoIKey {this, "MuonRoIContainerName", "LVL1MuonRoIs", "Level 1 muon container"}

private

Definition at line 506 of file MuonMatchingTool.h.

{this, "MuonRoIContainerName", "LVL1MuonRoIs", "Level 1 muon container"};

m_thresholdTool

ToolHandle<LVL1::ITrigThresholdDecisionTool> MuonMatchingTool::m_thresholdTool

private

Initial value:

{
    this, "TrigThresholdDecisionTool", "LVL1::TrigThresholdDecisionTool/LVL1__TrigThresholdDecisionTool",
    "Tool to get pass/fail of each trigger threshold"}

Definition at line 525 of file MuonMatchingTool.h.

                                                            {
    this, "TrigThresholdDecisionTool", "LVL1::TrigThresholdDecisionTool/LVL1__TrigThresholdDecisionTool",
    "Tool to get pass/fail of each trigger threshold"};

m_trigDec

PublicToolHandle<Trig::TrigDecisionTool> MuonMatchingTool::m_trigDec {this, "TrigDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool", "TrigDecisionTool"}

private

Definition at line 528 of file MuonMatchingTool.h.

{this, "TrigDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool", "TrigDecisionTool"};

m_use_extrapolator

Gaudi::Property<bool> MuonMatchingTool::m_use_extrapolator {this, "UseExtrapolator", false, "Flag to enable the extrapolator for matching offline and trigger muons"}

private

Definition at line 521 of file MuonMatchingTool.h.

{this, "UseExtrapolator", false, "Flag to enable the extrapolator for matching offline and trigger muons"};

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:

• MuonMatchingTool.h
• MuonMatchingTool.cxx