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
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	isMatchedL2CB (const xAOD::L2CombinedMuon *, const xAOD::Muon *) const
bool	isMatchedL2InsideOut (const xAOD::L2CombinedMuon *, const xAOD::Muon *) const
const 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)
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, 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::tuple< bool, double, double >(*offlinePosForMatchFunc)(const xAOD::Muon *), std::tuple< bool, double, double >(*trigPosForMatchFunc)(const T *)=&MuonMatchingTool::trigPosForMatch< T >) const
	Function that searches for an offline muon candidate matched to online muon of type T.
const Amg::Vector3D	offlineMuonAtPivot (const EventContext &ctx, const xAOD::Muon *mu) const
const Trk::TrackParameters *	extTrackToTGC (const EventContext &ctx, const xAOD::TrackParticle *track) const
const 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
static double	FermiFunction (double x, double x0, double w)
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_MuonRoIContainerKey {this, "MuonRoIContainerName", "LVL1MuonRoIs", "Level 1 muon container"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_MuonContainerKey {this, "MuonContainerName", "Muons", "Offline muon container"}
SG::ReadHandleKey< xAOD::L2StandAloneMuonContainer >	m_L2MuonSAContainerKey {this, "L2StandAloneMuonContainerName", "HLT_MuonL2SAInfo", "L2MuonSA container"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_EFFastRecoContainerKey {this, "EFFastRecoSAContainerName", "HLT_FastMuonsInfo", "EFFastRecoSA container (Phase2)"}
SG::ReadHandleKey< xAOD::L2CombinedMuonContainer >	m_L2muCombContainerKey {this, "L2CombinedMuonContainerName", "HLT_MuonL2CBInfo", "L2muComb container"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_EFSAMuonContainerKey {this, "EFSAMuonContainerName", "HLT_Muons_RoI", "EFSAMuon container"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_EFCBMuonContainerKey {this, "EFCBMuonContainerName", "HLT_MuonsCB_RoI", "EFCBMuon container"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_EFSAFSMuonContainerKey {this, "EFSAFSMuonContainerName", "HLT_Muons_FS", "EFSAFSMuon container"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_EFCBFSMuonContainerKey {this, "EFCBFSMuonContainerName", "HLT_MuonsCB_FS", "EFCBFSMuon container"}
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_MStrackContainerKey {this, "ExtrapolatedMStrackConntainner", "HLT_MSExtrapolatedMuons_RoITrackParticles", "ExtrapolatedMuons track container"}
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_CBtrackContainerKey {this, "CBtrackContainerName", "HLT_CBCombinedMuon_RoITrackParticles", "CombinedMuon track container"}
Gaudi::Property< bool >	m_use_extrapolator {this, "UseExtrapolator", false, "Flag to enable the extrapolator for matching offline and trigger muons"}
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 29 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 411 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 11 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()

const 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 496 of file MuonMatchingTool.cxx.

                                                                                                                           {
 
  const Trk::TrackParameters *extRPC = nullptr;
  const Trk::TrackParameters *extTGC = nullptr;
 
  if(!track) return extTGC;
  double trkEta = track->eta();
  double extEta =0.;
  bool isBarrel = true;
 
  if( fabs(trkEta)<1.05){
    extRPC = extTrackToRPC(ctx, track);
    if(!extRPC){
      isBarrel = false;
      extTGC = extTrackToTGC(ctx, track);
    }
    else{
      isBarrel = true;
      extEta = extRPC->position().eta();
      if(fabs(extEta)>=1.05){
    extTGC = extTrackToTGC(ctx, track);
    isBarrel = (extTGC) == nullptr; 
      }
    }
  }
  else if( fabs(trkEta)>=1.05 ){
    extTGC = extTrackToTGC(ctx, track);
    if(!extTGC){
      isBarrel = true;
      extRPC = extTrackToRPC(ctx, track);
    }
    else{
      isBarrel = false;
      extEta = extTGC->position().eta();
      if(fabs(extEta)<1.05){
    extRPC = extTrackToRPC(ctx, track);
    isBarrel = (extRPC) != nullptr;
      }
    }
  }
 
  ATH_MSG_DEBUG("extTGC=" << extTGC << " extRPC=" << extRPC << " isBarrel=" << isBarrel);
  if(   isBarrel) delete extTGC;
  else if(!isBarrel) delete extRPC;
  return (isBarrel) ? extRPC : extTGC;
}

extTrackToRPC()

const Trk::TrackParameters * MuonMatchingTool::extTrackToRPC ( const EventContext & ctx, const xAOD::TrackParticle * track ) const

private

Definition at line 569 of file MuonMatchingTool.cxx.

                                                                                                                         {
  ATH_MSG_DEBUG("extTrackToRPC");
  if(!trk) return nullptr;
  std::unique_ptr<Trk::CylinderSurface> barrel(new Trk::CylinderSurface(  7478., 15000. ));
  const bool boundaryCheck = true;
 
  const Trk::TrackParameters* param = m_extrapolator->extrapolate(ctx,
                                                                  trk->perigeeParameters(),
                                                                  *barrel,
                                                                  Trk::anyDirection,
                                                                  boundaryCheck,
                                                                  Trk::muon).release();
  return param;
}

extTrackToTGC()

const Trk::TrackParameters * MuonMatchingTool::extTrackToTGC ( const EventContext & ctx, const xAOD::TrackParticle * track ) const

private

Definition at line 545 of file MuonMatchingTool.cxx.

                                                                                                                         {
  ATH_MSG_DEBUG("extTrackToTGC");
  if(!trk) return nullptr;
  double TGC_Z = ( trk->eta()>0 )? 15153.0:-15153.0;
  Amg::Transform3D matrix = Amg::Transform3D( Amg::Vector3D( 0.,0.,TGC_Z ) );
  //object pointed by matrix will be deleted in destructer of DiscSurface, therefore release it
  std::unique_ptr<Trk::DiscSurface> disc(new Trk::DiscSurface( matrix, 0., 15000.));
  const bool boundaryCheck = true;
 
  const Trk::TrackParameters* param = m_extrapolator->extrapolate(ctx,
                                                                  trk->perigeeParameters(),
                                                                  *disc,
                                                                  Trk::anyDirection,
                                                                  boundaryCheck,
                                                                  Trk::muon).release();
 
  ATH_MSG_DEBUG("param=" << param 
        << " eta=" << ((param) ? param->position().eta() : 0) 
        << " phi=" << ((param) ? param->position().phi() : 0));;
  return param;
}

FermiFunction()

double MuonMatchingTool::FermiFunction ( double x, double x0, double w )

staticprivate

Definition at line 490 of file MuonMatchingTool.cxx.

                                                                      {
  return 1/(1+TMath::Exp(-10*(x-x0)/w));
}

initialize()

StatusCode MuonMatchingTool::initialize ( )

overridevirtual

Definition at line 16 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_MuonContainerKey.initialize() );
  ATH_CHECK( m_MuonRoIContainerKey.initialize() );
  ATH_CHECK( m_L2MuonSAContainerKey.initialize() );
  ATH_CHECK( m_EFFastRecoContainerKey.initialize(!m_EFFastRecoContainerKey.empty()) );
  ATH_CHECK( m_L2muCombContainerKey.initialize() );
  ATH_CHECK( m_EFSAMuonContainerKey.initialize() );
  ATH_CHECK( m_EFCBMuonContainerKey.initialize() );
  ATH_CHECK( m_EFSAFSMuonContainerKey.initialize() );
  ATH_CHECK( m_EFCBFSMuonContainerKey.initialize() );
  ATH_CHECK( m_MStrackContainerKey.initialize() );
  ATH_CHECK( m_CBtrackContainerKey.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.

isMatchedL2CB()

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

Definition at line 480 of file MuonMatchingTool.cxx.

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

isMatchedL2InsideOut()

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

Definition at line 485 of file MuonMatchingTool.cxx.

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

isMatchedL2SA()

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

Definition at line 468 of file MuonMatchingTool.cxx.

                                                                                                {
  float offlEta = mu->eta();
  float offlPhi = mu->phi();
  float trigEta = samu->roiEta();
  float trigPhi = samu->roiPhi();
 
  float deta = offlEta - trigEta;
  float dphi = xAOD::P4Helpers::deltaPhi(offlPhi, trigPhi);
  float dR = sqrt(deta*deta + dphi*dphi);
  return dR < m_L2SAreqdR;
}

L1ItemStringToInt()

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

inlineprivate

Definition at line 412 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 126 of file MuonMatchingTool.cxx.

                                                                                                    {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFCB()");
  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::Primary);
  ATH_MSG_DEBUG("HLT_Muons_RoI CB Muon");
  return MuonTrack ? match<xAOD::Muon>( MuonTrack, std::move(trig), m_EFreqdR, pass, "HLT_MuonsCB_RoI*.*", &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 121 of file MuonMatchingTool.cxx.

                                                                                                             {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFCB() for TruthParticle");
  return mu ? match<xAOD::Muon>( mu, std::move(trig), m_EFreqdR, pass, "HLT_MuonsCB_RoI*.*", &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 202 of file MuonMatchingTool.cxx.

                                                                                                     {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFCBFS()");
  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::Primary);
  ATH_MSG_DEBUG("HLT_Muons_FS CB Muon");
  return MuonTrack ? match<xAOD::Muon>( MuonTrack, std::move(trig), m_EFreqdR, pass, "HLT_MuonsCB_FS.*", &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 197 of file MuonMatchingTool.cxx.

                                                                                                               {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFCBFS() for TruthParticle");
  return mu ? match<xAOD::Muon>( mu, std::move(trig), m_EFreqdR, pass, "HLT_MuonsCB_FS.*", &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 209 of file MuonMatchingTool.cxx.

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

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 217 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_EFCBFSMuonContainerKey, 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 133 of file MuonMatchingTool.cxx.

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

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 141 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_EFCBMuonContainerKey, 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 223 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 229 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 265 of file MuonMatchingTool.cxx.

                                                                                                                                    {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFCBLinkInfo()");
  bool pass = false;
  TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> muonLinkInfo;
  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) : muonLinkInfo;
}

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 71 of file MuonMatchingTool.cxx.

                                                                                                  {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFSA()");
  const xAOD::TrackParticle* MuonTrack = nullptr;
  using Type = xAOD::Muon::TrackParticleType;
  std::vector<Type> types { Type::ExtrapolatedMuonSpectrometerTrackParticle,
                            Type::MSOnlyExtrapolatedMuonSpectrometerTrackParticle,
                            Type::MuonSpectrometerTrackParticle};
  for (Type type : types){
    MuonTrack = mu->trackParticle(type);
    ATH_MSG_DEBUG("HLT_Muons_RoI SA Muon");
    if (MuonTrack) break;
  }
  return MuonTrack ? match<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, "HLT_Muons_RoI.*", &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 86 of file MuonMatchingTool.cxx.

                                                                                                           {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFSA() for truth particle");
  return mu ? match<xAOD::Muon>(mu, std::move(trig), m_EFreqdR, pass, "HLT_Muons_RoI.*", &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 147 of file MuonMatchingTool.cxx.

                                                                                                    {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFSAFS()");
  const xAOD::TrackParticle* MuonTrack = nullptr;
  using Type = xAOD::Muon::TrackParticleType;
  std::vector<Type> types { Type::ExtrapolatedMuonSpectrometerTrackParticle,
                            Type::MSOnlyExtrapolatedMuonSpectrometerTrackParticle,
                            Type::MuonSpectrometerTrackParticle};
  for (Type type : types){
    MuonTrack = mu->trackParticle(type);
    ATH_MSG_DEBUG("HLT_Muons_FS SA Muon");
    if (MuonTrack) break;
  }
  return MuonTrack ? match<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, "HLT_Muons_FS.*", &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 162 of file MuonMatchingTool.cxx.

                                                                                                             {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFSAFS() for truth particle");
  return mu ? match<xAOD::Muon>(mu, std::move(trig), m_EFreqdR, pass, "HLT_Muons_FS.*", &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 167 of file MuonMatchingTool.cxx.

                                                                                                                                    {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFSAFSLinkInfo()");
  bool pass = false;
  TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> muonLinkInfo;
  const xAOD::TrackParticle* MuonTrack = nullptr;
  using Type = xAOD::Muon::TrackParticleType;
  std::vector<Type> types { Type::ExtrapolatedMuonSpectrometerTrackParticle,
                            Type::MSOnlyExtrapolatedMuonSpectrometerTrackParticle,
                            Type::MuonSpectrometerTrackParticle};
  for (Type type : types){
    MuonTrack = mu->trackParticle(type);
    if (MuonTrack) break;
  }
  return MuonTrack ? matchLinkInfo<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, "HLT_Muons_FS.*", &MuonMatchingTool::trigPosForMatchSATrack) : muonLinkInfo;
}

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 183 of file MuonMatchingTool.cxx.

                                                                                                            {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFSAFSReadHandle()");
  const xAOD::TrackParticle* MuonTrack = nullptr;
  using Type = xAOD::Muon::TrackParticleType;
  std::vector<Type> types { Type::ExtrapolatedMuonSpectrometerTrackParticle,
                            Type::MSOnlyExtrapolatedMuonSpectrometerTrackParticle,
                            Type::MuonSpectrometerTrackParticle};
  for (Type type : types){
    MuonTrack = mu->trackParticle(type);
    if (MuonTrack) break;
  }
  return MuonTrack ? matchReadHandle<xAOD::Muon>( MuonTrack, m_EFreqdR, m_EFSAFSMuonContainerKey, 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 91 of file MuonMatchingTool.cxx.

                                                                                                                                  {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFSALinkInfo()");
  bool pass = false;
  TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> muonLinkInfo;
  const xAOD::TrackParticle* MuonTrack = nullptr;
  using Type = xAOD::Muon::TrackParticleType;
  std::vector<Type> types { Type::ExtrapolatedMuonSpectrometerTrackParticle,
                            Type::MSOnlyExtrapolatedMuonSpectrometerTrackParticle,
                            Type::MuonSpectrometerTrackParticle};
  for (Type type : types){
    MuonTrack = mu->trackParticle(type);
    if (MuonTrack) break;
  }
  return MuonTrack ? matchLinkInfo<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, "HLT_Muons_RoI.*", &MuonMatchingTool::trigPosForMatchSATrack) : muonLinkInfo;
}

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 107 of file MuonMatchingTool.cxx.

                                                                                                          {
  ATH_MSG_DEBUG("MuonMonitoring::matchEFSAReadHandle()");
  const xAOD::TrackParticle* MuonTrack = nullptr;
  using Type = xAOD::Muon::TrackParticleType;
  std::vector<Type> types { Type::ExtrapolatedMuonSpectrometerTrackParticle,
                            Type::MSOnlyExtrapolatedMuonSpectrometerTrackParticle,
                            Type::MuonSpectrometerTrackParticle};
  for (Type type : types){
    MuonTrack = mu->trackParticle(type);
    if (MuonTrack) break;
  }
  return MuonTrack ? matchReadHandle<xAOD::Muon>( MuonTrack, m_EFreqdR, m_EFSAMuonContainerKey, 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 286 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, "HLT_FastMuonsInfo");
}

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 304 of file MuonMatchingTool.cxx.

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

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 343 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_EFFastRecoContainerKey, ctx);
    }
  }
  const xAOD::TrackParticle* MuonTrack = nullptr;
  using Type = xAOD::Muon::TrackParticleType;
  std::vector<Type> types { Type::ExtrapolatedMuonSpectrometerTrackParticle,
                            Type::MSOnlyExtrapolatedMuonSpectrometerTrackParticle,
                            Type::MuonSpectrometerTrackParticle};
  for (Type type : types){
    MuonTrack = mu->trackParticle(type);
    if (MuonTrack) break;
  }
  return MuonTrack ? matchReadHandle<xAOD::Muon>( MuonTrack, reqdR, m_EFFastRecoContainerKey, 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 459 of file MuonMatchingTool.cxx.

                                                                                                            {
  return matchOff(ctx, samu, m_L2SAreqdR, &MuonMatchingTool::PosForMatchSATrack);
}

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 432 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 448 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 387 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_MuonRoIContainerKey, 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 365 of file MuonMatchingTool.cxx.

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

matchL2CB() [2/2]

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

Definition at line 370 of file MuonMatchingTool.cxx.

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

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 381 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_L2muCombContainerKey, 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 463 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 273 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, "HLT_MuonL2SAInfo");
}

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 299 of file MuonMatchingTool.cxx.

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

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 321 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_L2MuonSAContainerKey, ctx);
    }
  }
  const xAOD::TrackParticle* MuonTrack = nullptr;
  using Type = xAOD::Muon::TrackParticleType;
  std::vector<Type> types { Type::ExtrapolatedMuonSpectrometerTrackParticle,
                            Type::MSOnlyExtrapolatedMuonSpectrometerTrackParticle,
                            Type::MuonSpectrometerTrackParticle};
  for (Type type : types){
    MuonTrack = mu->trackParticle(type);
    if (MuonTrack) break;
  }
  return MuonTrack ? matchReadHandle<xAOD::L2StandAloneMuon>( MuonTrack, reqdR, m_L2MuonSAContainerKey, 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 455 of file MuonMatchingTool.cxx.

                                                                                                                   {
  return matchOff(ctx, samu, m_L2SAreqdR, &MuonMatchingTool::PosForMatchSATrack);
}

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::tuple< bool, double, double >(* offlinePosForMatchFunc )(const xAOD::Muon *), std::tuple< bool, double, double >(* trigPosForMatchFunc )(const T *) = &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, 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()

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

private

Definition at line 39 of file MuonMatchingTool.cxx.

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

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 65 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 )

static

Definition at line 60 of file MuonMatchingTool.cxx.

                                                                                      {
  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::ExtrapolatedMuonSpectrometerTrackParticle);
  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 586 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 235 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 315 of file MuonMatchingTool.cxx.

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

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 375 of file MuonMatchingTool.cxx.

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

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 309 of file MuonMatchingTool.cxx.

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

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 56 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 52 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_CBtrackContainerKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> MuonMatchingTool::m_CBtrackContainerKey {this, "CBtrackContainerName", "HLT_CBCombinedMuon_RoITrackParticles", "CombinedMuon track container"}

private

Definition at line 509 of file MuonMatchingTool.h.

{this, "CBtrackContainerName", "HLT_CBCombinedMuon_RoITrackParticles", "CombinedMuon track container"};

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_EFCBFSMuonContainerKey

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

private

Definition at line 507 of file MuonMatchingTool.h.

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

m_EFCBMuonContainerKey

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

private

Definition at line 505 of file MuonMatchingTool.h.

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

m_EFFastRecoContainerKey

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

private

Definition at line 502 of file MuonMatchingTool.h.

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

m_EFreqdR

const float MuonMatchingTool::m_EFreqdR = 0.03

private

Definition at line 424 of file MuonMatchingTool.h.

m_EFSAFSMuonContainerKey

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

private

Definition at line 506 of file MuonMatchingTool.h.

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

m_EFSAMuonContainerKey

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

private

Definition at line 504 of file MuonMatchingTool.h.

{this, "EFSAMuonContainerName", "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 519 of file MuonMatchingTool.h.

{"Trk::Extrapolator/AtlasExtrapolator"};

m_L2CBreqdR

const float MuonMatchingTool::m_L2CBreqdR = 0.03

private

Definition at line 422 of file MuonMatchingTool.h.

m_L2InsideOutreqdR

const float MuonMatchingTool::m_L2InsideOutreqdR = 0.01

private

Definition at line 423 of file MuonMatchingTool.h.

m_L2muCombContainerKey

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

private

Definition at line 503 of file MuonMatchingTool.h.

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

m_L2MuonSAContainerKey

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

private

Definition at line 501 of file MuonMatchingTool.h.

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

m_L2SAreqdR

const float MuonMatchingTool::m_L2SAreqdR = 0.25

private

Definition at line 421 of file MuonMatchingTool.h.

m_MStrackContainerKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> MuonMatchingTool::m_MStrackContainerKey {this, "ExtrapolatedMStrackConntainner", "HLT_MSExtrapolatedMuons_RoITrackParticles", "ExtrapolatedMuons track container"}

private

Definition at line 508 of file MuonMatchingTool.h.

{this, "ExtrapolatedMStrackConntainner", "HLT_MSExtrapolatedMuons_RoITrackParticles", "ExtrapolatedMuons track container"};

m_MuonContainerKey

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

private

Definition at line 500 of file MuonMatchingTool.h.

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

m_MuonRoIContainerKey

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

private

Definition at line 499 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 515 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 518 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 512 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