ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
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::MuonRoImatchL1 (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. More...
 
const xAOD::MuonRoImatchL1 (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. More...
 
const xAOD::MuonRoImatchL1 (double eta, double phi, double dR, const std::string &trigger, bool &pass) const
 Function that dR matches L1 muon candidates. More...
 
const xAOD::L2StandAloneMuonmatchL2SA (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. More...
 
const TrigCompositeUtils::LinkInfo< xAOD::L2StandAloneMuonContainersearchL2SALinkInfo (const xAOD::Muon *mu, std::string trigger) const
 Function that searches for the L2 standalone muon (L2MuonSA) candidate closest to a given offline muon. More...
 
const xAOD::L2StandAloneMuonmatchL2SAReadHandle (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. More...
 
const xAOD::L2CombinedMuonmatchL2CB (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. More...
 
const TrigCompositeUtils::LinkInfo< xAOD::L2CombinedMuonContainersearchL2CBLinkInfo (const xAOD::Muon *mu, std::string trigger) const
 Function that searches for the L2 combined muon (L2muComb) candidate closest to a given offline muon. More...
 
const xAOD::L2CombinedMuonmatchL2CBReadHandle (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. More...
 
const xAOD::MuonmatchEFSA (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. More...
 
const xAOD::MuonmatchEFSA (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. More...
 
const TrigCompositeUtils::LinkInfo< xAOD::MuonContainermatchEFSALinkInfo (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. More...
 
const xAOD::MuonmatchEFSAReadHandle (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. More...
 
const xAOD::MuonmatchEFCB (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. More...
 
const xAOD::MuonmatchEFCB (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. More...
 
const TrigCompositeUtils::LinkInfo< xAOD::MuonContainermatchEFCBLinkInfo (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. More...
 
const xAOD::MuonmatchEFCBReadHandle (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. More...
 
const xAOD::MuonmatchEFSAFS (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. More...
 
const xAOD::MuonmatchEFSAFS (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. More...
 
const TrigCompositeUtils::LinkInfo< xAOD::MuonContainermatchEFSAFSLinkInfo (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. More...
 
const xAOD::MuonmatchEFSAFSReadHandle (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. More...
 
const xAOD::MuonmatchEFCBFS (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. More...
 
const xAOD::MuonmatchEFCBFS (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. More...
 
const TrigCompositeUtils::LinkInfo< xAOD::MuonContainermatchEFCBFSLinkInfo (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. More...
 
const xAOD::MuonmatchEFCBFSReadHandle (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. More...
 
const xAOD::MuonmatchEFIso (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. More...
 
const xAOD::MuonmatchEFIso (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. More...
 
const TrigCompositeUtils::LinkInfo< xAOD::MuonContainermatchEFIsoLinkInfo (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. More...
 
const xAOD::TrackParticleSearchEFTrack (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. More...
 
const xAOD::MuonmatchL2SAtoOff (const EventContext &ctx, const xAOD::L2StandAloneMuon *samu) const
 Function that searches for an offline muon matched to L2SA muon. More...
 
const xAOD::MuonmatchL2CBtoOff (const EventContext &ctx, const xAOD::L2CombinedMuon *cbmu) const
 Function that searches for an offline muon matched to L2CB muon. More...
 
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::TrackParametersextTrackToPivot (const xAOD::TrackParticle *track) const
 Function to extrapolate a Inner Detector track to the pivot plane i.e. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static double reqdRL1byPt (double mupt)
 Function compute dR used for matching offline muons and level 1 RoIs at the pivot plane. More...
 
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 More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

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< StoreGateSvcStoreGateSvc_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. More...
 
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. More...
 
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. More...
 
template<class T >
const xAOD::MuonmatchOff (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. More...
 
const Amg::Vector3D offlineMuonAtPivot (const xAOD::Muon *mu) const
 
const Trk::TrackParametersextTrackToTGC (const xAOD::TrackParticle *track) const
 
const Trk::TrackParametersextTrackToRPC (const xAOD::TrackParticle *track) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

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::MuonRoIContainerm_MuonRoIContainerKey {this, "MuonRoIContainerName", "LVL1MuonRoIs", "Level 1 muon container"}
 
SG::ReadHandleKey< xAOD::MuonContainerm_MuonContainerKey {this, "MuonContainerName", "Muons", "Offline muon container"}
 
SG::ReadHandleKey< xAOD::L2StandAloneMuonContainerm_L2MuonSAContainerKey {this, "L2StandAloneMuonContainerName", "HLT_MuonL2SAInfo", "L2MuonSA container"}
 
SG::ReadHandleKey< xAOD::L2CombinedMuonContainerm_L2muCombContainerKey {this, "L2CombinedMuonContainerName", "HLT_MuonL2CBInfo", "L2muComb container"}
 
SG::ReadHandleKey< xAOD::MuonContainerm_EFSAMuonContainerKey {this, "EFSAMuonContainerName", "HLT_Muons_RoI", "EFSAMuon container"}
 
SG::ReadHandleKey< xAOD::MuonContainerm_EFCBMuonContainerKey {this, "EFCBMuonContainerName", "HLT_MuonsCB_RoI", "EFCBMuon container"}
 
SG::ReadHandleKey< xAOD::MuonContainerm_EFSAFSMuonContainerKey {this, "EFSAFSMuonContainerName", "HLT_Muons_FS", "EFSAFSMuon container"}
 
SG::ReadHandleKey< xAOD::MuonContainerm_EFCBFSMuonContainerKey {this, "EFCBFSMuonContainerName", "HLT_MuonsCB_FS", "EFCBFSMuon container"}
 
SG::ReadHandleKey< xAOD::TrackParticleContainerm_MStrackContainerKey {this, "ExtrapolatedMStrackConntainner", "HLT_MSExtrapolatedMuons_RoITrackParticles", "ExtrapolatedMuons track container"}
 
SG::ReadHandleKey< xAOD::TrackParticleContainerm_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"}
 
PublicToolHandle< Trig::TrigDecisionToolm_trigDec {this, "TrigDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool", "TrigDecisionTool"}
 
PublicToolHandle< Trk::IExtrapolatorm_extrapolator {"Trk::Extrapolator/AtlasExtrapolator"}
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

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

Definition at line 28 of file MuonMatchingTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ L1Items

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 351 of file MuonMatchingTool.h.

Constructor & Destructor Documentation

◆ MuonMatchingTool()

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

Definition at line 14 of file MuonMatchingTool.cxx.

16 {}

Member Function Documentation

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

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

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

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

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ 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
trackInner 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 430 of file MuonMatchingTool.cxx.

430  {
431 
432  const Trk::TrackParameters *extRPC = nullptr;
433  const Trk::TrackParameters *extTGC = nullptr;
434 
435  if(!track) return extTGC;
436  double trkEta = track->eta();
437  double extEta =0.;
438  bool isBarrel = true;
439 
440  if( fabs(trkEta)<1.05){
441  extRPC = extTrackToRPC(track);
442  if(!extRPC){
443  isBarrel = false;
444  extTGC = extTrackToTGC(track);
445  }
446  else{
447  isBarrel = true;
448  extEta = extRPC->position().eta();
449  if(fabs(extEta)>=1.05){
450  extTGC = extTrackToTGC(track);
451  isBarrel = (extTGC) == nullptr;
452  }
453  }
454  }
455  else if( fabs(trkEta)>=1.05 ){
456  extTGC = extTrackToTGC(track);
457  if(!extTGC){
458  isBarrel = true;
459  extRPC = extTrackToRPC(track);
460  }
461  else{
462  isBarrel = false;
463  extEta = extTGC->position().eta();
464  if(fabs(extEta)<1.05){
465  extRPC = extTrackToRPC(track);
466  isBarrel = (extRPC) != nullptr;
467  }
468  }
469  }
470 
471  ATH_MSG_DEBUG("extTGC=" << extTGC << " extRPC=" << extRPC << " isBarrel=" << isBarrel);
472  if( isBarrel) delete extTGC;
473  else if(!isBarrel) delete extRPC;
474  return (isBarrel) ? extRPC : extTGC;
475 }

◆ extTrackToRPC()

const Trk::TrackParameters * MuonMatchingTool::extTrackToRPC ( const xAOD::TrackParticle track) const
private

Definition at line 503 of file MuonMatchingTool.cxx.

503  {
504  ATH_MSG_DEBUG("extTrackToRPC");
505  if(!trk) return nullptr;
506  std::unique_ptr<Trk::CylinderSurface> barrel(new Trk::CylinderSurface( 7478., 15000. ));
507  const bool boundaryCheck = true;
508 
509  const Trk::TrackParameters* param = m_extrapolator->extrapolate(Gaudi::Hive::currentContext(),
510  trk->perigeeParameters(),
511  *barrel,
513  boundaryCheck,
514  Trk::muon).release();
515  return param;
516 }

◆ extTrackToTGC()

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

Definition at line 479 of file MuonMatchingTool.cxx.

479  {
480  ATH_MSG_DEBUG("extTrackToTGC");
481  if(!trk) return nullptr;
482  double TGC_Z = ( trk->eta()>0 )? 15153.0:-15153.0;
484  //object pointed by matrix will be deleted in destructer of DiscSurface, therefore release it
485  std::unique_ptr<Trk::DiscSurface> disc(new Trk::DiscSurface( matrix, 0., 15000.));
486  const bool boundaryCheck = true;
487 
488  const Trk::TrackParameters* param = m_extrapolator->extrapolate(Gaudi::Hive::currentContext(),
489  trk->perigeeParameters(),
490  *disc,
492  boundaryCheck,
493  Trk::muon).release();
494 
495  ATH_MSG_DEBUG("param=" << param
496  << " eta=" << ((param) ? param->position().eta() : 0)
497  << " phi=" << ((param) ? param->position().phi() : 0));;
498  return param;
499 }

◆ FermiFunction()

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

Definition at line 424 of file MuonMatchingTool.cxx.

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

◆ initialize()

StatusCode MuonMatchingTool::initialize ( )
overridevirtual

Definition at line 19 of file MuonMatchingTool.cxx.

19  {
20 
21  ATH_CHECK( m_trigDec.retrieve() );
23  ATH_CHECK( m_extrapolator.retrieve() );
24  }
25  ATH_CHECK( m_MuonContainerKey.initialize() );
26  ATH_CHECK( m_MuonRoIContainerKey.initialize() );
27  ATH_CHECK( m_L2MuonSAContainerKey.initialize() );
28  ATH_CHECK( m_L2muCombContainerKey.initialize() );
29  ATH_CHECK( m_EFSAMuonContainerKey.initialize() );
30  ATH_CHECK( m_EFCBMuonContainerKey.initialize() );
31  ATH_CHECK( m_EFSAFSMuonContainerKey.initialize() );
32  ATH_CHECK( m_EFCBFSMuonContainerKey.initialize() );
35 
36  return StatusCode::SUCCESS;
37 }

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

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

◆ isMatchedL2InsideOut()

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

Definition at line 419 of file MuonMatchingTool.cxx.

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

◆ isMatchedL2SA()

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

Definition at line 402 of file MuonMatchingTool.cxx.

402  {
403  float offlEta = mu->eta();
404  float offlPhi = mu->phi();
405  float trigEta = samu->roiEta();
406  float trigPhi = samu->roiPhi();
407 
408  float deta = offlEta - trigEta;
409  float dphi = xAOD::P4Helpers::deltaPhi(offlPhi, trigPhi);
410  float dR = sqrt(deta*deta + dphi*dphi);
411  return dR < m_L2SAreqdR;
412 }

◆ L1ItemStringToInt()

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

Definition at line 352 of file MuonMatchingTool.h.

352  {
353  if( "L1_MU3V"==l1item) return roiSource==0 ? L1Items::L1B_MU3V : L1Items::L1E_MU3V;
354  if( "L1_MU5VF"==l1item) return roiSource==0 ? L1Items::L1B_MU5VF : L1Items::L1E_MU5VF;
355  if( "L1_MU8F"==l1item) return roiSource==0 ? L1Items::L1B_MU8F : L1Items::L1E_MU8F;
356  if( "L1_MU14FCH"==l1item) return roiSource==0 ? L1Items::L1B_MU14FCH : L1Items::L1E_MU14FCH;
357  if( "L1_MU14FCHR"==l1item) return roiSource==0 ? L1Items::L1B_MU14FCHR : L1Items::L1E_MU14FCHR;
358  return L1Items::ERROR;
359  }

◆ 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 >(*)(const T *)  trigPosForMatchFunc = &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
offlPosition of the offline muon used for computing dR.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
reqdRRequirement of dR used for the matching. Note that reqdR is updated with the dR of the found candidate.
passTrue if the matched candidate passed the hypothesis step.
trigPosForMatchFuncFunction 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
muOffline muon around which EFCB candidates are searched.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
passTrue 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 127 of file MuonMatchingTool.cxx.

127  {
128  ATH_MSG_DEBUG("MuonMonitoring::matchEFCB()");
129  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::Primary);
130  ATH_MSG_DEBUG("HLT_Muons_RoI CB Muon");
131  return MuonTrack ? match<xAOD::Muon>( MuonTrack, std::move(trig), m_EFreqdR, pass, "HLT_MuonsCB_RoI.*", &MuonMatchingTool::trigPosForMatchCBTrack) : nullptr;
132 }

◆ 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
muTruth muon around which EFCB candidates are searched.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
passTrue 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 122 of file MuonMatchingTool.cxx.

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

◆ 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
muOffline muon around which EFCBFS candidates are searched.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
passTrue 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 203 of file MuonMatchingTool.cxx.

203  {
204  ATH_MSG_DEBUG("MuonMonitoring::matchEFCBFS()");
205  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::Primary);
206  ATH_MSG_DEBUG("HLT_Muons_FS CB Muon");
207  return MuonTrack ? match<xAOD::Muon>( MuonTrack, std::move(trig), m_EFreqdR, pass, "HLT_MuonsCB_FS.*", &MuonMatchingTool::trigPosForMatchCBTrack) : nullptr;
208 }

◆ 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
muTruth muon around which EFCBFS candidates are searched.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
passTrue 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 198 of file MuonMatchingTool.cxx.

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

◆ 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
muOffline muon around which EFCBFS candidates are searched.
triggerConsidered 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 210 of file MuonMatchingTool.cxx.

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

◆ 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
muOffline 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 218 of file MuonMatchingTool.cxx.

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

◆ 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
muOffline muon around which EFCB candidates are searched.
triggerConsidered 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 134 of file MuonMatchingTool.cxx.

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

◆ 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
muOffline 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 142 of file MuonMatchingTool.cxx.

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

◆ 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
muOffline muon around which EFIso candidates are searched.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
passTrue if the matched candidate passed the hypothesis step.
Returns
Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 224 of file MuonMatchingTool.cxx.

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

◆ 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
muTruth muon around which EFIso candidates are searched.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
passTrue 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 230 of file MuonMatchingTool.cxx.

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

◆ 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
muOffline muon around which EFIso candidates are searched.
triggerConsidered 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 266 of file MuonMatchingTool.cxx.

266  {
267  ATH_MSG_DEBUG("MuonMonitoring::matchEFCBLinkInfo()");
268  bool pass = false;
270  const xAOD::TrackParticle* MuonTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::Primary);
271  return MuonTrack ? matchLinkInfo<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, "HLT_MuonsIso", &MuonMatchingTool::trigPosForMatchCBTrack) : muonLinkInfo;
272 }

◆ 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
muOffline muon around which EFSA candidates are searched.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
passTrue 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 72 of file MuonMatchingTool.cxx.

72  {
73  ATH_MSG_DEBUG("MuonMonitoring::matchEFSA()");
74  const xAOD::TrackParticle* MuonTrack = nullptr;
75  using Type = xAOD::Muon::TrackParticleType;
76  std::vector<Type> types { Type::ExtrapolatedMuonSpectrometerTrackParticle,
77  Type::MSOnlyExtrapolatedMuonSpectrometerTrackParticle,
78  Type::MuonSpectrometerTrackParticle};
79  for (Type type : types){
80  MuonTrack = mu->trackParticle(type);
81  ATH_MSG_DEBUG("HLT_Muons_RoI SA Muon");
82  if (MuonTrack) break;
83  }
84  return MuonTrack ? match<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, "HLT_Muons_RoI.*", &MuonMatchingTool::trigPosForMatchSATrack) : nullptr;
85 }

◆ 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
muTruth muon around which EFSA candidates are searched.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
passTrue 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 87 of file MuonMatchingTool.cxx.

87  {
88  ATH_MSG_DEBUG("MuonMonitoring::matchEFSA() for truth particle");
89  return mu ? match<xAOD::Muon>(mu, std::move(trig), m_EFreqdR, pass, "HLT_Muons_RoI.*", &MuonMatchingTool::trigPosForMatchSATrack) : nullptr;
90 }

◆ 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
muOffline muon around which EFSAFS candidates are searched.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
passTrue 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 148 of file MuonMatchingTool.cxx.

148  {
149  ATH_MSG_DEBUG("MuonMonitoring::matchEFSAFS()");
150  const xAOD::TrackParticle* MuonTrack = nullptr;
151  using Type = xAOD::Muon::TrackParticleType;
152  std::vector<Type> types { Type::ExtrapolatedMuonSpectrometerTrackParticle,
153  Type::MSOnlyExtrapolatedMuonSpectrometerTrackParticle,
154  Type::MuonSpectrometerTrackParticle};
155  for (Type type : types){
156  MuonTrack = mu->trackParticle(type);
157  ATH_MSG_DEBUG("HLT_Muons_FS SA Muon");
158  if (MuonTrack) break;
159  }
160  return MuonTrack ? match<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, "HLT_Muons_FS.*", &MuonMatchingTool::trigPosForMatchSATrack) : nullptr;
161 }

◆ 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
muTruth muon around which EFSAFS candidates are searched.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
passTrue if the matched candidate passed the hypothesis step.
Returns
Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 163 of file MuonMatchingTool.cxx.

163  {
164  ATH_MSG_DEBUG("MuonMonitoring::matchEFSAFS() for truth particle");
165  return mu ? match<xAOD::Muon>(mu, std::move(trig), m_EFreqdR, pass, "HLT_Muons_FS.*", &MuonMatchingTool::trigPosForMatchSATrack) : nullptr;
166 }

◆ 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
muOffline muon around which EFSAFS candidates are searched.
triggerConsidered 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 168 of file MuonMatchingTool.cxx.

168  {
169  ATH_MSG_DEBUG("MuonMonitoring::matchEFSAFSLinkInfo()");
170  bool pass = false;
172  const xAOD::TrackParticle* MuonTrack = nullptr;
173  using Type = xAOD::Muon::TrackParticleType;
174  std::vector<Type> types { Type::ExtrapolatedMuonSpectrometerTrackParticle,
175  Type::MSOnlyExtrapolatedMuonSpectrometerTrackParticle,
176  Type::MuonSpectrometerTrackParticle};
177  for (Type type : types){
178  MuonTrack = mu->trackParticle(type);
179  if (MuonTrack) break;
180  }
181  return MuonTrack ? matchLinkInfo<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, "HLT_Muons_FS.*", &MuonMatchingTool::trigPosForMatchSATrack) : muonLinkInfo;
182 }

◆ 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
muOffline 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 184 of file MuonMatchingTool.cxx.

184  {
185  ATH_MSG_DEBUG("MuonMonitoring::matchEFSAFSReadHandle()");
186  const xAOD::TrackParticle* MuonTrack = nullptr;
187  using Type = xAOD::Muon::TrackParticleType;
188  std::vector<Type> types { Type::ExtrapolatedMuonSpectrometerTrackParticle,
189  Type::MSOnlyExtrapolatedMuonSpectrometerTrackParticle,
190  Type::MuonSpectrometerTrackParticle};
191  for (Type type : types){
192  MuonTrack = mu->trackParticle(type);
193  if (MuonTrack) break;
194  }
195  return MuonTrack ? matchReadHandle<xAOD::Muon>( MuonTrack, m_EFreqdR, m_EFSAFSMuonContainerKey, ctx, &MuonMatchingTool::trigPosForMatchSATrack) : nullptr;
196 }

◆ 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
muOffline muon around which EFSA candidates are searched.
triggerConsidered 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 92 of file MuonMatchingTool.cxx.

92  {
93  ATH_MSG_DEBUG("MuonMonitoring::matchEFSALinkInfo()");
94  bool pass = false;
96  const xAOD::TrackParticle* MuonTrack = nullptr;
97  using Type = xAOD::Muon::TrackParticleType;
98  std::vector<Type> types { Type::ExtrapolatedMuonSpectrometerTrackParticle,
99  Type::MSOnlyExtrapolatedMuonSpectrometerTrackParticle,
100  Type::MuonSpectrometerTrackParticle};
101  for (Type type : types){
102  MuonTrack = mu->trackParticle(type);
103  if (MuonTrack) break;
104  }
105  return MuonTrack ? matchLinkInfo<xAOD::Muon>(MuonTrack, std::move(trig), m_EFreqdR, pass, "HLT_Muons_RoI.*", &MuonMatchingTool::trigPosForMatchSATrack) : muonLinkInfo;
106 }

◆ 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
muOffline 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 108 of file MuonMatchingTool.cxx.

108  {
109  ATH_MSG_DEBUG("MuonMonitoring::matchEFSAReadHandle()");
110  const xAOD::TrackParticle* MuonTrack = nullptr;
111  using Type = xAOD::Muon::TrackParticleType;
112  std::vector<Type> types { Type::ExtrapolatedMuonSpectrometerTrackParticle,
113  Type::MSOnlyExtrapolatedMuonSpectrometerTrackParticle,
114  Type::MuonSpectrometerTrackParticle};
115  for (Type type : types){
116  MuonTrack = mu->trackParticle(type);
117  if (MuonTrack) break;
118  }
119  return MuonTrack ? matchReadHandle<xAOD::Muon>( MuonTrack, m_EFreqdR, m_EFSAMuonContainerKey, ctx, &MuonMatchingTool::trigPosForMatchSATrack) : nullptr;
120 }

◆ 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
muOffline muon around which Level 1 candidates are searched.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
passTrue if a candidate is found.
Returns
Pointer to the matched candidate. This is nullptr when there is no candidate found.

Definition at line 369 of file MuonMatchingTool.cxx.

369  {
370  double refEta = mu->eta();
371  double refPhi = mu->phi();
372  double reqdR = 0.25;
373 
374  if(m_use_extrapolator){
375  reqdR = reqdRL1byPt(mu->pt());
376  const Amg::Vector3D extPos = offlineMuonAtPivot(mu);
377  if(extPos.norm()>ZERO_LIMIT){
378  refEta = extPos.eta();
379  refPhi = extPos.phi();
380  }
381  }
382  return matchL1(refEta, refPhi, reqdR, trig, pass);
383 }

◆ 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
muTruth muon around which Level 1 candidates are searched.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
passTrue if a candidate is found.
Returns
Pointer to the matched candidate. This is nullptr when there is no candidate found.

Definition at line 385 of file MuonMatchingTool.cxx.

385  {
386  double refEta = mu->eta();
387  double refPhi = mu->phi();
388  double reqdR = 0.25;
389  return matchL1(refEta, refPhi, reqdR, trig, pass);
390 }

◆ 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
etaEta of muon around which Level 1 candidates are searched.
phiPhi of muon around which Level 1 candidates are searched.
dRdR limit within which a match is accepted.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
passTrue if a candidate is found.
Returns
Pointer to the matched candidate. This is nullptr when there is no candidate found.

Definition at line 334 of file MuonMatchingTool.cxx.

334  {
335  ATH_MSG_DEBUG("Chain: " << trig);
336  pass = false;
337  const xAOD::MuonRoI *closest = nullptr;
338  Trig::FeatureRequestDescriptor featureRequestDescriptor(trig,TrigDefs::includeFailedDecisions);
339  auto l2muonFeatures = m_trigDec->features<xAOD::L2StandAloneMuonContainer>(featureRequestDescriptor);
340  for( const auto& linkInfo : l2muonFeatures){ // loop on L2 muon features
341  // get L1 muon associated with this L2 muon
342  auto l1muonLinkInfo = TrigCompositeUtils::findLink<xAOD::MuonRoIContainer>(linkInfo.source, "initialRecRoI");
343  auto l1muonLink = l1muonLinkInfo.link;
344  if(!l1muonLink.isValid()){
345  ATH_MSG_ERROR("Invalid link to L1 muon");
346  continue;
347  }
348  const xAOD::MuonRoI* l1muon = *l1muonLink;
349  double l1muonEta = l1muon->eta();
350  double l1muonPhi = l1muon->phi();
351 
352  double deta = refEta - l1muonEta;
353  double dphi = xAOD::P4Helpers::deltaPhi(refPhi, l1muonPhi);
354  double dR = std::sqrt(deta*deta + dphi*dphi);
355  ATH_MSG_DEBUG("L1 muon candidate eta=" << l1muonEta << " phi=" << l1muonPhi << " dR=" << dR);
356  if( dR<reqdR ){
357  reqdR = dR;
358  pass = true;
359  closest = l1muon;
360  ATH_MSG_DEBUG("*** L1 muon eta=" << l1muonEta << " phi=" << l1muonPhi << " dR=" << dR << " isPassed=true" );
361  }
362  else{
363  ATH_MSG_DEBUG("*** L1 muon eta=" << l1muonEta << " phi=" << l1muonPhi << " dR=" << dR << " isPassed=false" );
364  }
365  }
366  return closest;
367 }

◆ 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
muOffline muon around which L2muComb candidates are searched.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
passTrue 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 317 of file MuonMatchingTool.cxx.

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

◆ 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
muOffline 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 328 of file MuonMatchingTool.cxx.

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

◆ 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
ctxReference to the EventContext needed for accessing the Muons container.
cbmuthe given online muon
Returns
Pointer to the matched offline muon. This is nullptr when there is no muon found.

Definition at line 397 of file MuonMatchingTool.cxx.

397  {
399 }

◆ 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
muOffline muon around which L2MuonSA candidates are searched.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
passTrue if the matched candidate passed the hypothesis step.
Returns
Pointer to the matched candidate. This is nullptr when there is no candidate found. Important: a valid pointer doesn't mean that it passed the hypothesis, users should check pass for the decision.

Definition at line 275 of file MuonMatchingTool.cxx.

275  {
276  ATH_MSG_DEBUG("MuonMonitoring::matchL2SA()");
277  float reqdR = m_L2SAreqdR;
278  if(m_use_extrapolator){
279  reqdR = reqdRL1byPt(mu->pt());
280  const Amg::Vector3D extPos = offlineMuonAtPivot(mu);
281  if(extPos.norm()>ZERO_LIMIT){
282  return match<xAOD::L2StandAloneMuon>( &extPos, trig, reqdR, pass);
283  }
284  }
285  return match<xAOD::L2StandAloneMuon>( mu, trig, reqdR, pass, "HLT_MuonL2SAInfo");
286 }

◆ 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
muOffline 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 294 of file MuonMatchingTool.cxx.

294  {
295  ATH_MSG_DEBUG("MuonMonitoring::matchL2SAReadHandle()");
296  float reqdR = m_L2SAreqdR;
297  if(m_use_extrapolator){
298  reqdR = reqdRL1byPt(mu->pt());
299  const Amg::Vector3D extPos = offlineMuonAtPivot(mu);
300  if(extPos.norm()>ZERO_LIMIT){
301  return matchReadHandle<xAOD::L2StandAloneMuon>( &extPos, reqdR, m_L2MuonSAContainerKey, ctx);
302  }
303  }
304  const xAOD::TrackParticle* MuonTrack = nullptr;
305  using Type = xAOD::Muon::TrackParticleType;
306  std::vector<Type> types { Type::ExtrapolatedMuonSpectrometerTrackParticle,
307  Type::MSOnlyExtrapolatedMuonSpectrometerTrackParticle,
308  Type::MuonSpectrometerTrackParticle};
309  for (Type type : types){
310  MuonTrack = mu->trackParticle(type);
311  if (MuonTrack) break;
312  }
313  return MuonTrack ? matchReadHandle<xAOD::L2StandAloneMuon>( MuonTrack, reqdR, m_L2MuonSAContainerKey, ctx) : nullptr;
314 }

◆ 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
ctxReference to the EventContext needed for accessing the Muons container.
samuthe given online muon
Returns
Pointer to the matched offline muon. This is nullptr when there is no muon found.

Definition at line 393 of file MuonMatchingTool.cxx.

393  {
395 }

◆ 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 >(*)(const T *)  trigPosForMatchFunc = &MuonMatchingTool::trigPosForMatch< T > 
) const
private

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

Parameters
offlPosition of the offline muon used for computing dR.
triggerConsidered chain name, e.g. HLT_mu26_ivarmedium_L1MU20, etc.
trigPosForMatchFuncFunction 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 >(*)(const xAOD::Muon *)  offlinePosForMatchFunc,
std::tuple< bool, double, double >(*)(const T *)  trigPosForMatchFunc = &MuonMatchingTool::trigPosForMatch< T > 
) const
private

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

Parameters
trigPosition of the online muon used for computing dR.
reqdRRequirement of dR used for the matching. Note that reqdR is updated with the dR of the found candidate.
offlinePosForMatchFuncFunction pointer that implements cuts for the offline muon candidates.
trigPosForMatchFuncFunction 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 >(*)(const T *)  trigPosForMatchFunc = &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
offlPosition of the offline muon used for computing dR.
reqdRRequirement of dR used for the matching. Note that reqdR is updated with the dR of the found candidate.
ReadHandleKeySG::ReadHandleKey of online muon.
ctxEventContext.
trigPosForMatchFuncFunction 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() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ offlineMuonAtPivot()

const Amg::Vector3D MuonMatchingTool::offlineMuonAtPivot ( const xAOD::Muon mu) const
private

Definition at line 40 of file MuonMatchingTool.cxx.

40  {
41  const xAOD::TrackParticle* track = mu->primaryTrackParticle();
42  std::unique_ptr<const Trk::TrackParameters> extPars(extTrackToPivot(track));
43  return extPars ? extPars->position() : Amg::Vector3D(0.,0.,0.);
44 }

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

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

◆ PosForMatchSATrack()

std::tuple< bool, double, double > MuonMatchingTool::PosForMatchSATrack ( const xAOD::Muon mu)
static

Definition at line 61 of file MuonMatchingTool.cxx.

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

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

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

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

364  {
365  handlesArray.renounce();
366  }

◆ 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
muptOffline muon pt
Returns
Required dR between the offline muon and Level 1 muons

Definition at line 520 of file MuonMatchingTool.cxx.

520  {
521  double dR = 0.08;
522  if( mupt < 10000. ) {
523  dR = -0.00001*mupt + 0.18;
524  }
525  return dR;
526 }

◆ 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
ctxReference to the EventContext needed for accessing the TrackParticle container.
muLinkInfoLinkInfo of EF muon.
ReadHandleKeyof TrackParticle container.
Returns
Pointer to the matched TrackParticle. This is nullpt rwhen there is no TrackParticle found.

Definition at line 236 of file MuonMatchingTool.cxx.

236  {
237  const xAOD::TrackParticle* MatchedTrack = nullptr;
238  const ElementLink<xAOD::MuonContainer> muEL = muLinkInfo.link;
239  float EFEta = (*muEL)->eta();
240  float EFPhi = (*muEL)->phi();
241  float mindR = 999.;
242 
243  SG::ReadHandle<xAOD::TrackParticleContainer> trackHandle(ReadHandleKey, ctx);
244  if ( !trackHandle.isValid() ) return MatchedTrack;
245 
246  const auto track = m_trigDec->associateToEventView<xAOD::TrackParticleContainer>(trackHandle, muLinkInfo);
249 
251 
252  float deta = EFEta - (*it)->eta();
253  float dphi = xAOD::P4Helpers::deltaPhi(EFPhi, (*it)->phi() );
254  float dR = std::sqrt(deta*deta + dphi*dphi);
255 
256  if( dR< mindR ){
257  mindR = dR;
258  MatchedTrack = (*it);
259  }
260  }
261 
262  return MatchedTrack;
263 
264 }

◆ 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
muOffline muon around which L2MuonSA candidates are searched.
triggerConsidered 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 322 of file MuonMatchingTool.cxx.

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

◆ 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
muOffline muon around which L2MuonSA candidates are searched.
triggerConsidered 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 288 of file MuonMatchingTool.cxx.

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

◆ sysInitialize()

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

Perform system initialization for an algorithm.

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

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

◆ sysStart()

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

Handle START transition.

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

◆ trigPosForMatch()

template<class T >
static 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 57 of file MuonMatchingTool.cxx.

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

◆ trigPosForMatchSATrack()

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

Definition at line 53 of file MuonMatchingTool.cxx.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_CBtrackContainerKey

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

Definition at line 448 of file MuonMatchingTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_EFCBFSMuonContainerKey

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

Definition at line 446 of file MuonMatchingTool.h.

◆ m_EFCBMuonContainerKey

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

Definition at line 444 of file MuonMatchingTool.h.

◆ m_EFreqdR

const float MuonMatchingTool::m_EFreqdR = 0.03
private

Definition at line 364 of file MuonMatchingTool.h.

◆ m_EFSAFSMuonContainerKey

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

Definition at line 445 of file MuonMatchingTool.h.

◆ m_EFSAMuonContainerKey

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

Definition at line 443 of file MuonMatchingTool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extrapolator

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

Definition at line 455 of file MuonMatchingTool.h.

◆ m_L2CBreqdR

const float MuonMatchingTool::m_L2CBreqdR = 0.03
private

Definition at line 362 of file MuonMatchingTool.h.

◆ m_L2InsideOutreqdR

const float MuonMatchingTool::m_L2InsideOutreqdR = 0.01
private

Definition at line 363 of file MuonMatchingTool.h.

◆ m_L2muCombContainerKey

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

Definition at line 442 of file MuonMatchingTool.h.

◆ m_L2MuonSAContainerKey

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

Definition at line 441 of file MuonMatchingTool.h.

◆ m_L2SAreqdR

const float MuonMatchingTool::m_L2SAreqdR = 0.25
private

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

◆ m_MuonContainerKey

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

Definition at line 440 of file MuonMatchingTool.h.

◆ m_MuonRoIContainerKey

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

Definition at line 439 of file MuonMatchingTool.h.

◆ m_trigDec

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

Definition at line 454 of file MuonMatchingTool.h.

◆ 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 451 of file MuonMatchingTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.


The documentation for this class was generated from the following files:
MuonMatchingTool::L1B_MU8F
@ L1B_MU8F
Definition: MuonMatchingTool.h:351
Trk::anyDirection
@ anyDirection
Definition: PropDirection.h:22
Trig::FeatureRequestDescriptor
Definition: FeatureRequestDescriptor.h:37
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TrigCompositeUtils::LinkInfo::link
ElementLink< T > link
Link to the feature.
Definition: LinkInfo.h:61
MuonMatchingTool::L1B_MU3V
@ L1B_MU3V
Definition: MuonMatchingTool.h:351
MuonMatchingTool::m_L2CBreqdR
const float m_L2CBreqdR
Definition: MuonMatchingTool.h:362
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
MuonMatchingTool::m_EFreqdR
const float m_EFreqdR
Definition: MuonMatchingTool.h:364
MuonMatchingTool::m_extrapolator
PublicToolHandle< Trk::IExtrapolator > m_extrapolator
Definition: MuonMatchingTool.h:455
MuonMatchingTool::L1B_MU14FCHR
@ L1B_MU14FCHR
Definition: MuonMatchingTool.h:351
MuonMatchingTool::m_MStrackContainerKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_MStrackContainerKey
Definition: MuonMatchingTool.h:447
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
skel.it
it
Definition: skel.GENtoEVGEN.py:396
python.Constants.ERROR
int ERROR
Definition: Control/AthenaCommon/python/Constants.py:18
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
xAOD::MuonRoI_v1::eta
float eta() const
The pseudorapidity ( ) of the muon candidate.
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
xAOD::P4Helpers::deltaPhi
double deltaPhi(double phiA, double phiB)
delta Phi in range [-pi,pi[
Definition: xAODP4Helpers.h:69
MuonMatchingTool::trigPosForMatchSATrack
static std::tuple< bool, double, double > trigPosForMatchSATrack(const xAOD::Muon *mu)
Definition: MuonMatchingTool.cxx:53
MuonMatchingTool::m_EFCBFSMuonContainerKey
SG::ReadHandleKey< xAOD::MuonContainer > m_EFCBFSMuonContainerKey
Definition: MuonMatchingTool.h:446
Trk::DiscSurface
Definition: DiscSurface.h:54
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
MuonMatchingTool::extTrackToRPC
const Trk::TrackParameters * extTrackToRPC(const xAOD::TrackParticle *track) const
Definition: MuonMatchingTool.cxx:503
x
#define x
MuonMatchingTool::PosForMatchSATrack
static std::tuple< bool, double, double > PosForMatchSATrack(const xAOD::Muon *mu)
Definition: MuonMatchingTool.cxx:61
MuonMatchingTool::extTrackToPivot
const Trk::TrackParameters * extTrackToPivot(const xAOD::TrackParticle *track) const
Function to extrapolate a Inner Detector track to the pivot plane i.e.
Definition: MuonMatchingTool.cxx:430
MuonMatchingTool::m_CBtrackContainerKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_CBtrackContainerKey
Definition: MuonMatchingTool.h:448
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
InDet::ExclusiveOrigin::Primary
@ Primary
Definition: InDetTrackTruthOriginDefs.h:163
MuonMatchingTool::m_L2MuonSAContainerKey
SG::ReadHandleKey< xAOD::L2StandAloneMuonContainer > m_L2MuonSAContainerKey
Definition: MuonMatchingTool.h:441
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
MuonMatchingTool::m_EFSAFSMuonContainerKey
SG::ReadHandleKey< xAOD::MuonContainer > m_EFSAFSMuonContainerKey
Definition: MuonMatchingTool.h:445
AthCommonDataStore
Definition: AthCommonDataStore.h:52
MuonMatchingTool::L1E_MU14FCHR
@ L1E_MU14FCHR
Definition: MuonMatchingTool.h:351
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::L2StandAloneMuon_v2::roiPhi
float roiPhi() const
Get and set RoI phi.
xAOD::P4Helpers::deltaR
double deltaR(double rapidity1, double phi1, double rapidity2, double phi2)
from bare bare rapidity,phi
Definition: xAODP4Helpers.h:150
MuonMatchingTool::ERROR
@ ERROR
Definition: MuonMatchingTool.h:351
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Trk::CylinderSurface
Definition: CylinderSurface.h:55
MuonMatchingTool::L1E_MU8F
@ L1E_MU8F
Definition: MuonMatchingTool.h:351
MuonMatchingTool::m_L2InsideOutreqdR
const float m_L2InsideOutreqdR
Definition: MuonMatchingTool.h:363
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
MuonMatchingTool::L1B_MU14FCH
@ L1B_MU14FCH
Definition: MuonMatchingTool.h:351
MuonMatchingTool::m_L2muCombContainerKey
SG::ReadHandleKey< xAOD::L2CombinedMuonContainer > m_L2muCombContainerKey
Definition: MuonMatchingTool.h:442
MuonMatchingTool::m_trigDec
PublicToolHandle< Trig::TrigDecisionTool > m_trigDec
Definition: MuonMatchingTool.h:454
xAOD::MuonRoI_v1
Class describing a LVL1 muon region of interest.
Definition: MuonRoI_v1.h:29
test_pyathena.parent
parent
Definition: test_pyathena.py:15
MuonMatchingTool::L1B_MU5VF
@ L1B_MU5VF
Definition: MuonMatchingTool.h:351
MuonMatchingTool::matchL1
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 mu...
Definition: MuonMatchingTool.cxx:369
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Trk::ParametersBase
Definition: ParametersBase.h:55
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
Trk::muon
@ muon
Definition: ParticleHypothesis.h:28
xAODType
Definition: ObjectType.h:13
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
Trk::Combined
@ Combined
Definition: TrackSummaryTool.h:32
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
python.root_lsr_rank.types
types
Definition: root_lsr_rank.py:35
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
MuonMatchingTool::offlineMuonAtPivot
const Amg::Vector3D offlineMuonAtPivot(const xAOD::Muon *mu) const
Definition: MuonMatchingTool.cxx:40
MuonMatchingTool::L1E_MU14FCH
@ L1E_MU14FCH
Definition: MuonMatchingTool.h:351
MuonMatchingTool::m_use_extrapolator
Gaudi::Property< bool > m_use_extrapolator
Definition: MuonMatchingTool.h:451
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
MuonMatchingTool::m_MuonContainerKey
SG::ReadHandleKey< xAOD::MuonContainer > m_MuonContainerKey
Definition: MuonMatchingTool.h:440
MuonMatchingTool::PosForMatchCBTrack
static std::tuple< bool, double, double > PosForMatchCBTrack(const xAOD::Muon *mu)
Definition: MuonMatchingTool.cxx:66
python.testIfMatch.matrix
matrix
Definition: testIfMatch.py:66
TrigCompositeUtils::LinkInfo
Helper to keep a Decision object, ElementLink and ActiveState (with respect to some requested ChainGr...
Definition: LinkInfo.h:28
a
TList * a
Definition: liststreamerinfos.cxx:10
MuonMatchingTool::trigPosForMatchCBTrack
static std::tuple< bool, double, double > trigPosForMatchCBTrack(const xAOD::Muon *mu)
Definition: MuonMatchingTool.cxx:57
MuonMatchingTool::m_EFCBMuonContainerKey
SG::ReadHandleKey< xAOD::MuonContainer > m_EFCBMuonContainerKey
Definition: MuonMatchingTool.h:444
h
xAOD::L2StandAloneMuon_v2::roiEta
float roiEta() const
Get and set RoI eta.
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
DetectorZone::barrel
@ barrel
python.LArCondContChannels.isBarrel
isBarrel
Definition: LArCondContChannels.py:659
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
MuonMatchingTool::extTrackToTGC
const Trk::TrackParameters * extTrackToTGC(const xAOD::TrackParticle *track) const
Definition: MuonMatchingTool.cxx:479
MuonMatchingTool::m_EFSAMuonContainerKey
SG::ReadHandleKey< xAOD::MuonContainer > m_EFSAMuonContainerKey
Definition: MuonMatchingTool.h:443
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
MuonMatchingTool::L1E_MU3V
@ L1E_MU3V
Definition: MuonMatchingTool.h:351
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
MuonMatchingTool::m_L2SAreqdR
const float m_L2SAreqdR
Definition: MuonMatchingTool.h:361
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:200
MuonMatchingTool::L1E_MU5VF
@ L1E_MU5VF
Definition: MuonMatchingTool.h:351
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
MuonMatchingTool::matchOff
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.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
MuonMatchingTool::m_MuonRoIContainerKey
SG::ReadHandleKey< xAOD::MuonRoIContainer > m_MuonRoIContainerKey
Definition: MuonMatchingTool.h:439
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
fitman.k
k
Definition: fitman.py:528
MuonMatchingTool::reqdRL1byPt
static double reqdRL1byPt(double mupt)
Function compute dR used for matching offline muons and level 1 RoIs at the pivot plane.
Definition: MuonMatchingTool.cxx:520
xAOD::MuonRoI_v1::phi
float phi() const
The azimuthal angle ( ) of the muon candidate.