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 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 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 (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 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 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 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::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 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 *	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 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 xAOD::Muon *mu) const
const Trk::TrackParameters *	extTrackToTGC (const xAOD::TrackParticle *track) const
const Trk::TrackParameters *	extTrackToRPC (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::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 352 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 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

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 438 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(track);
    if(!extRPC){
      isBarrel = false;
      extTGC = extTrackToTGC(track);
    }
    else{
      isBarrel = true;
      extEta = extRPC->position().eta();
      if(fabs(extEta)>=1.05){
    extTGC = extTrackToTGC(track);
    isBarrel = (extTGC) == nullptr; 
      }
    }
  }
  else if( fabs(trkEta)>=1.05 ){
    extTGC = extTrackToTGC(track);
    if(!extTGC){
      isBarrel = true;
      extRPC = extTrackToRPC(track);
    }
    else{
      isBarrel = false;
      extEta = extTGC->position().eta();
      if(fabs(extEta)<1.05){
    extRPC = extTrackToRPC(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 xAOD::TrackParticle * track ) const

private

Definition at line 511 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(Gaudi::Hive::currentContext(),
                                                                  trk->perigeeParameters(),
                                                                  *barrel,
                                                                  Trk::anyDirection,
                                                                  boundaryCheck,
                                                                  Trk::muon).release();
  return param;
}

extTrackToTGC()

const Trk::TrackParameters * MuonMatchingTool::extTrackToTGC ( const xAOD::TrackParticle * track ) const

private

Definition at line 487 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(Gaudi::Hive::currentContext(),
                                                                  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 432 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_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 422 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 427 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 410 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 353 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 125 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 120 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 201 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 196 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 208 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 216 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 132 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 140 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 222 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 228 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 264 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 70 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 85 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 146 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 161 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 166 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 182 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 90 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 106 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;
}

matchL1() [1/3]

const xAOD::MuonRoI * MuonMatchingTool::matchL1	(	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 378 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(mu);
    if(extPos.norm()>ZERO_LIMIT){
      refEta = extPos.eta();
      refPhi = extPos.phi();
    }
  }
  return matchL1(refEta, refPhi, reqdR, trig, pass); 
}

matchL1() [2/3]

const xAOD::MuonRoI * MuonMatchingTool::matchL1	(	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 394 of file MuonMatchingTool.cxx.

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

matchL1() [3/3]

const xAOD::MuonRoI * MuonMatchingTool::matchL1	(	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 332 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, Gaudi::Hive::currentContext());
    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(), Gaudi::Hive::currentContext());
        
        // 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){
            std::shared_ptr<TrigConf::L1Threshold_MU> thr = std::static_pointer_cast<TrigConf::L1Threshold_MU>(L1thr.first);
            if (L1toMatch == thr->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()

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

                                                                                                              {
  ATH_MSG_DEBUG("MuonMonitoring::matchL2CB()");
  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 326 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 405 of file MuonMatchingTool.cxx.

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

matchL2SA()

const xAOD::L2StandAloneMuon * MuonMatchingTool::matchL2SA	(	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(mu);
    if(extPos.norm()>ZERO_LIMIT){
      return match<xAOD::L2StandAloneMuon>( &extPos, trig, reqdR, pass);
    }
  }
  return match<xAOD::L2StandAloneMuon>( mu, trig, reqdR, 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 292 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(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 401 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 xAOD::Muon * mu ) const

private

Definition at line 38 of file MuonMatchingTool.cxx.

                                                                                {
  const xAOD::TrackParticle* track = mu->primaryTrackParticle();
  std::unique_ptr<const Trk::TrackParameters> extPars(extTrackToPivot(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 64 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 59 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 528 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 234 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;
 
}

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 320 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 286 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 >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

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

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

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 55 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 51 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 449 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 447 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 445 of file MuonMatchingTool.h.

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

m_EFreqdR

const float MuonMatchingTool::m_EFreqdR = 0.03

private

Definition at line 365 of file MuonMatchingTool.h.

m_EFSAFSMuonContainerKey

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

private

Definition at line 446 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 444 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 459 of file MuonMatchingTool.h.

{"Trk::Extrapolator/AtlasExtrapolator"};

m_L2CBreqdR

const float MuonMatchingTool::m_L2CBreqdR = 0.03

private

Definition at line 363 of file MuonMatchingTool.h.

m_L2InsideOutreqdR

const float MuonMatchingTool::m_L2InsideOutreqdR = 0.01

private

Definition at line 364 of file MuonMatchingTool.h.

m_L2muCombContainerKey

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

private

Definition at line 443 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 442 of file MuonMatchingTool.h.

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

m_L2SAreqdR

const float MuonMatchingTool::m_L2SAreqdR = 0.25

private

Definition at line 362 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 448 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 441 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 440 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 455 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 458 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 452 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