ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
JetMatcherAlg Class Reference

#include <JetMatcherAlg.h>

Inheritance diagram for JetMatcherAlg:
Collaboration diagram for JetMatcherAlg:

Public Member Functions

 JetMatcherAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
StatusCode initialize () override
 
StatusCode execute (const EventContext &ctx) const override
 
StatusCode finalize () override
 
 AthReentrantAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
 Constructor with parameters: More...
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 
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 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
 

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  MatchType {
  MatchType::undeclared, MatchType::xAODJet, MatchType::JetRoI, MatchType::jFexSRJetRoI,
  MatchType::jFexLRJetRoI, MatchType::gFexJetRoI
}
 
typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

StatusCode set_xAODJet_varHandleKeys ()
 
StatusCode set_JetRoI_varHandleKeys ()
 
StatusCode set_jFexSRJetRoI_varHandleKeys ()
 
StatusCode set_jFexLRJetRoI_varHandleKeys ()
 
StatusCode set_gFexJetRoI_varHandleKeys ()
 
StatusCode initialize_varHandleKeys ()
 
StatusCode initialize_xAODJet_varHandleKeys (bool)
 
StatusCode initialize_JetRoI_varHandleKeys (bool)
 
StatusCode initialize_jFexSRJetRoI_varHandleKeys (bool)
 
StatusCode initialize_jFexLRJetRoI_varHandleKeys (bool)
 
StatusCode initialize_gFexJetRoI_varHandleKeys (bool)
 
StatusCode GetTLV (const xAOD::Jet *jet, TLorentzVector &) const
 
StatusCode GetTLV (const xAOD::JetRoI *jet, TLorentzVector &) const
 
StatusCode GetTLV (const xAOD::jFexSRJetRoI *jet, TLorentzVector &) const
 
StatusCode GetTLV (const xAOD::jFexLRJetRoI *jet, TLorentzVector &) const
 
StatusCode GetTLV (const xAOD::gFexJetRoI *jet, TLorentzVector &) const
 
template<typename T >
StatusCode jetMatching (SG::ReadHandle< DataVector< T >> jets1, SG::ReadHandle< xAOD::JetContainer > jets2, SG::WriteDecorHandleKey< DataVector< T >> matchedHandleKey, std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< DataVector< T >>>> varHandleKeys, const EventContext &ctx) 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...
 

Private Attributes

Gaudi::Property< float > m_Rmatch {this, "Rmatch", 0.3, "R matching"}
 
Gaudi::Property< std::string > m_calibScale {this, "JetCalibScale", "", "Calibration Scale at which to evaluate jet pT"}
 
Gaudi::Property< bool > m_matchL1 {this, "MatchL1", false, "Whether to match an L1 jet collection or actual online/offline jets"}
 
SG::ReadHandleKey< xAOD::JetContainerm_jetContainerKey1
 
SG::ReadHandleKey< xAOD::JetContainerm_jetContainerKey2
 
MatchType m_matchType {MatchType::undeclared}
 
SG::ReadHandleKey< xAOD::JetRoIContainerm_l1jetContainerKey1
 
SG::ReadHandleKey< xAOD::jFexSRJetRoIContainerm_jFexSRJetRoIKey
 
SG::ReadHandleKey< xAOD::jFexLRJetRoIContainerm_jFexLRJetRoIKey
 
SG::ReadHandleKey< xAOD::gFexJetRoIContainerm_gFexJetRoIKey
 
SG::WriteDecorHandleKey< xAOD::JetContainerm_matchedKey {this, "matched", "matched", "SG key for output matched decoration"}
 
SG::WriteDecorHandleKey< xAOD::JetContainerm_ptDiffKey {this, "ptdiff", "ptdiff", "SG key for output pt difference decoration"}
 
SG::WriteDecorHandleKey< xAOD::JetContainerm_energyDiffKey {this, "energydiff", "energydiff", "SG key for output energy difference decoration"}
 
SG::WriteDecorHandleKey< xAOD::JetContainerm_massDiffKey {this, "massdiff", "massdiff", "SG key for output mass difference decoration"}
 
SG::WriteDecorHandleKey< xAOD::JetContainerm_ptRespKey {this, "ptresp", "ptresp", "SG key for output pt response decoration"}
 
SG::WriteDecorHandleKey< xAOD::JetContainerm_energyRespKey {this, "energyresp", "energyresp", "SG key for output energy response decoration"}
 
SG::WriteDecorHandleKey< xAOD::JetContainerm_massRespKey {this, "massresp", "massresp", "SG key for output mass response decoration"}
 
SG::WriteDecorHandleKey< xAOD::JetContainerm_ptRefKey {this, "ptRef", "ptRef", "SG key for output pt reference decoration"}
 
SG::WriteDecorHandleKey< xAOD::JetContainerm_etaRefKey {this, "etaRef", "etaRef", "SG key for output eta reference decoration"}
 
std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< xAOD::JetContainer > > > m_jetVarHandleKeys
 
SG::WriteDecorHandleKey< xAOD::JetRoIContainerm_l1matchedKey {this, "l1matched", "l1matched", "SG key for output matched decoration"}
 
SG::WriteDecorHandleKey< xAOD::JetRoIContainerm_l1ptDiffKey {this, "l1ptdiff", "l1ptdiff", "SG key for output pt difference decoration"}
 
SG::WriteDecorHandleKey< xAOD::JetRoIContainerm_l1energyDiffKey {this, "l1energydiff", "l1energydiff", "SG key for output energy difference decoration"}
 
SG::WriteDecorHandleKey< xAOD::JetRoIContainerm_l1massDiffKey {this, "l1massdiff", "l1massdiff", "SG key for output mass difference decoration"}
 
SG::WriteDecorHandleKey< xAOD::JetRoIContainerm_l1ptRespKey {this, "l1ptresp", "l1ptresp", "SG key for output pt response decoration"}
 
SG::WriteDecorHandleKey< xAOD::JetRoIContainerm_l1energyRespKey {this, "l1energyresp", "l1energyresp", "SG key for output energy response decoration"}
 
SG::WriteDecorHandleKey< xAOD::JetRoIContainerm_l1massRespKey {this, "l1massresp", "l1massresp", "SG key for output mass response decoration"}
 
SG::WriteDecorHandleKey< xAOD::JetRoIContainerm_l1ptRefKey {this, "l1ptRef", "l1ptRef", "SG key for output pt reference decoration"}
 
SG::WriteDecorHandleKey< xAOD::JetRoIContainerm_l1etaRefKey {this, "l1etaRef", "l1etaRef", "SG key for output eta reference decoration"}
 
std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< xAOD::JetRoIContainer > > > m_l1JetVarHandleKeys
 
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainerm_l1jFexSRmatchedKey {this, "l1jFexSRmatched", "l1jFexSRmatched", "SG key for output matched decoration"}
 
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainerm_l1jFexSRptDiffKey {this, "l1jFexSRptdiff", "l1jFexSRptdiff", "SG key for output pt difference decoration"}
 
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainerm_l1jFexSRenergyDiffKey {this, "l1jFexSRenergydiff", "l1jFexSRenergydiff", "SG key for output energy difference decoration"}
 
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainerm_l1jFexSRmassDiffKey {this, "l1jFexSRmassdiff", "l1jFexSRmassdiff", "SG key for output mass difference decoration"}
 
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainerm_l1jFexSRptRespKey {this, "l1jFexSRptresp", "l1jFexSRptresp", "SG key for output pt response decoration"}
 
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainerm_l1jFexSRenergyRespKey {this, "l1jFexSRenergyresp", "l1jFexSRenergyresp", "SG key for output energy response decoration"}
 
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainerm_l1jFexSRmassRespKey {this, "l1jFexSRmassresp", "l1jFexSRmassresp", "SG key for output mass response decoration"}
 
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainerm_l1jFexSRptRefKey {this, "l1jFexSRptRef", "l1jFexSRptRef", "SG key for output pt reference decoration"}
 
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainerm_l1jFexSRetaRefKey {this, "l1jFexSRetaRef", "l1jFexSRetaRef", "SG key for output eta reference decoration"}
 
std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > > > m_l1jFexSRJetVarHandleKeys
 
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainerm_l1jFexLRmatchedKey {this, "l1jFexLRmatched", "l1jFexLRmatched", "SG key for output matched decoration"}
 
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainerm_l1jFexLRptDiffKey {this, "l1jFexLRptdiff", "l1jFexLRptdiff", "SG key for output pt difference decoration"}
 
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainerm_l1jFexLRenergyDiffKey {this, "l1jFexLRenergydiff", "l1jFexLRenergydiff", "SG key for output energy difference decoration"}
 
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainerm_l1jFexLRmassDiffKey {this, "l1jFexLRmassdiff", "l1jFexLRmassdiff", "SG key for output mass difference decoration"}
 
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainerm_l1jFexLRptRespKey {this, "l1jFexLRptresp", "l1jFexLRptresp", "SG key for output pt response decoration"}
 
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainerm_l1jFexLRenergyRespKey {this, "l1jFexLRenergyresp", "l1jFexLRenergyresp", "SG key for output energy response decoration"}
 
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainerm_l1jFexLRmassRespKey {this, "l1jFexLRmassresp", "l1jFexLRmassresp", "SG key for output mass response decoration"}
 
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainerm_l1jFexLRptRefKey {this, "l1jFexLRptRef", "l1jFexLRptRef", "SG key for output pt reference decoration"}
 
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainerm_l1jFexLRetaRefKey {this, "l1jFexLRetaRef", "l1jFexLRetaRef", "SG key for output eta reference decoration"}
 
std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > > > m_l1jFexLRJetVarHandleKeys
 
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainerm_l1gFexmatchedKey {this, "l1gFexmatched", "l1gFexmatched", "SG key for output matched decoration"}
 
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainerm_l1gFexptDiffKey {this, "l1gFexptdiff", "l1gFexptdiff", "SG key for output pt difference decoration"}
 
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainerm_l1gFexenergyDiffKey {this, "l1gFexenergydiff", "l1gFexenergydiff", "SG key for output energy difference decoration"}
 
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainerm_l1gFexmassDiffKey {this, "l1gFexmassdiff", "l1gFexmassdiff", "SG key for output mass difference decoration"}
 
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainerm_l1gFexptRespKey {this, "l1gFexptresp", "l1gFexptresp", "SG key for output pt response decoration"}
 
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainerm_l1gFexenergyRespKey {this, "l1gFexenergyresp", "l1gFexenergyresp", "SG key for output energy response decoration"}
 
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainerm_l1gFexmassRespKey {this, "l1gFexmassresp", "l1gFexmassresp", "SG key for output mass response decoration"}
 
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainerm_l1gFexptRefKey {this, "l1gFexptRef", "l1gFexptRef", "SG key for output pt reference decoration"}
 
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainerm_l1gFexetaRefKey {this, "l1gFexetaRef", "l1gFexetaRef", "SG key for output eta reference decoration"}
 
std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > > > m_l1gFexJetVarHandleKeys
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
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

Definition at line 27 of file JetMatcherAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ MatchType

enum JetMatcherAlg::MatchType
strongprivate
Enumerator
undeclared 
xAODJet 
JetRoI 
jFexSRJetRoI 
jFexLRJetRoI 
gFexJetRoI 

Definition at line 57 of file JetMatcherAlg.h.

57  {
58  undeclared, xAODJet, JetRoI,
61  };

Constructor & Destructor Documentation

◆ JetMatcherAlg()

JetMatcherAlg::JetMatcherAlg ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 10 of file JetMatcherAlg.cxx.

10  : AthReentrantAlgorithm(name,pSvcLocator)
11 {
12  declareProperty("JetContainerName1" ,m_jetContainerKey1="");
13  declareProperty("JetContainerName2" ,m_jetContainerKey2="");
14 
15  declareProperty("L1JetContainerName1",m_l1jetContainerKey1="");
16  declareProperty("L1jFexSRJetRoIContainerName",m_jFexSRJetRoIKey="");
17  declareProperty("L1jFexLRJetRoIContainerName",m_jFexLRJetRoIKey="");
18  declareProperty("L1gFexJetRoIContainerName",m_gFexJetRoIKey="");
19 }

Member Function Documentation

◆ AthReentrantAlgorithm()

AthReentrantAlgorithm::AthReentrantAlgorithm

Constructor with parameters:

Definition at line 90 of file AthReentrantAlgorithm.cxx.

22  :
24 {
25 
26  // Set up to run AthAlgorithmDHUpdate in sysInitialize before
27  // merging depedency lists. This extends the output dependency
28  // list with any symlinks implied by inheritance relations.
29  m_updateDataHandles =
30  std::make_unique<AthenaBaseComps::AthAlgorithmDHUpdate>
32  std::move (m_updateDataHandles));
33 }

◆ cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const
overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

56 {
57  return 0;
58 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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; }

◆ execute()

StatusCode JetMatcherAlg::execute ( const EventContext &  ctx) const
override

Definition at line 269 of file JetMatcherAlg.cxx.

269  {
270 
271  // Retrieve jet containers and call appropriate matching function
273  if (!jets2.isValid() ) {
274  ATH_MSG_ERROR("evtStore() does not contain jet Collection with name "<< m_jetContainerKey2);
275  return StatusCode::FAILURE;
276  }
277 
278  if (m_matchType == MatchType::xAODJet) { // perform jet matching for online/offline xAODJet containers
280  if (!jets1.isValid() ) {
281  ATH_MSG_ERROR("evtStore() does not contain jet Collection with name "<< m_jetContainerKey1);
282  return StatusCode::FAILURE;
283  }
284  return jetMatching(jets1, jets2, m_matchedKey, m_jetVarHandleKeys, ctx);
285 
286  } else if(m_matchType == MatchType::JetRoI) { // perform jet matching for L1 JetRoI container
288  if (!jets1.isValid() ) {
289  ATH_MSG_ERROR("evtStore() does not contain L1 jet Collection with name "<< m_l1jetContainerKey1);
290  return StatusCode::FAILURE;
291  }
292  return jetMatching(jets1, jets2, m_l1matchedKey, m_l1JetVarHandleKeys, ctx);
293 
294  } else if (m_matchType == MatchType::jFexSRJetRoI) { // perform jet matching for L1 jFexSRJetRoI container
296  if (!jets1.isValid() ) {
297  ATH_MSG_ERROR("evtStore() does not contain L1 jet Collection with name "<< m_jFexSRJetRoIKey);
298  return StatusCode::FAILURE;
299  }
300  return jetMatching(jets1, jets2, m_l1jFexSRmatchedKey, m_l1jFexSRJetVarHandleKeys, ctx);
301 
302 
303  } else if (m_matchType == MatchType::jFexLRJetRoI) { // perform jet matching for L1 jFexLRJetRoI container
305  if (!jets1.isValid() ) {
306  ATH_MSG_ERROR("evtStore() does not contain L1 jet Collection with name "<< m_jFexSRJetRoIKey);
307  return StatusCode::FAILURE;
308  }
309  return jetMatching(jets1, jets2, m_l1jFexLRmatchedKey, m_l1jFexLRJetVarHandleKeys, ctx);
310 
311  } else if (m_matchType == MatchType::gFexJetRoI) { // perform jet matching for L1 gFexJetRoI container
313  if (!jets1.isValid() ) {
314  ATH_MSG_ERROR("evtStore() does not contain L1 jet Collection with name "<< m_gFexJetRoIKey);
315  return StatusCode::FAILURE;
316  }
317  return jetMatching(jets1, jets2, m_l1gFexmatchedKey, m_l1gFexJetVarHandleKeys, ctx);
318  }
319 
320  ATH_MSG_ERROR("unsupported type for jet matching targe");
321  return StatusCode::FAILURE;
322 
323 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

◆ extraOutputDeps()

const DataObjIDColl & AthReentrantAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 79 of file AthReentrantAlgorithm.cxx.

80 {
81  // If we didn't find any symlinks to add, just return the collection
82  // from the base class. Otherwise, return the extended collection.
83  if (!m_extendedExtraObjects.empty()) {
85  }
86  return Algorithm::extraOutputDeps();
87 }

◆ filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

135  {
136  return execState( ctx ).filterPassed();
137  }

◆ finalize()

StatusCode JetMatcherAlg::finalize ( )
override

Definition at line 129 of file JetMatcherAlg.cxx.

129  {
130  ATH_MSG_INFO ("Finalizing " << name());
131  return StatusCode::SUCCESS;
132 }

◆ GetTLV() [1/5]

StatusCode JetMatcherAlg::GetTLV ( const xAOD::gFexJetRoI jet,
TLorentzVector &  tlv 
) const
private

Definition at line 170 of file JetMatcherAlg.cxx.

170  {
171 
172  tlv.SetPtEtaPhiM(jet->et(),jet->eta(),jet->phi(),0.);
173  return StatusCode::SUCCESS;
174 }

◆ GetTLV() [2/5]

StatusCode JetMatcherAlg::GetTLV ( const xAOD::Jet jet,
TLorentzVector &  tlv 
) const
private

Definition at line 136 of file JetMatcherAlg.cxx.

136  {
137 
138  if (m_calibScale == "" ) {
139  tlv.SetPtEtaPhiE(jet->pt(),jet->eta(),jet->phi(),jet->e());
140  } else { //retrieve fourmomentum at specified calibration scale
141  xAOD::JetFourMom_t fourVec;
142  bool status = jet->getAttribute<xAOD::JetFourMom_t>( "Jet"+m_calibScale+"Momentum", fourVec );
143  if(!status) {
144  ATH_MSG_WARNING("evtStore() cannot retrieve JetFourMomentum at " << m_calibScale);
145  return StatusCode::FAILURE;
146  }
147  tlv.SetPtEtaPhiE(fourVec.Pt(),fourVec.Eta(),fourVec.Phi(),fourVec.E());
148  }
149  return StatusCode::SUCCESS;
150 }

◆ GetTLV() [3/5]

StatusCode JetMatcherAlg::GetTLV ( const xAOD::JetRoI jet,
TLorentzVector &  tlv 
) const
private

Definition at line 152 of file JetMatcherAlg.cxx.

152  {
153 
154  tlv.SetPtEtaPhiM(jet->et8x8(),jet->eta(),jet->phi(),0.);
155  return StatusCode::SUCCESS;
156 }

◆ GetTLV() [4/5]

StatusCode JetMatcherAlg::GetTLV ( const xAOD::jFexLRJetRoI jet,
TLorentzVector &  tlv 
) const
private

Definition at line 164 of file JetMatcherAlg.cxx.

164  {
165 
166  tlv.SetPtEtaPhiM(jet->et(),jet->eta(),jet->phi(),0.);
167  return StatusCode::SUCCESS;
168 }

◆ GetTLV() [5/5]

StatusCode JetMatcherAlg::GetTLV ( const xAOD::jFexSRJetRoI jet,
TLorentzVector &  tlv 
) const
private

Definition at line 158 of file JetMatcherAlg.cxx.

158  {
159 
160  tlv.SetPtEtaPhiM(jet->et(),jet->eta(),jet->phi(),0.);
161  return StatusCode::SUCCESS;
162 }

◆ initialize()

StatusCode JetMatcherAlg::initialize ( )
override

Definition at line 23 of file JetMatcherAlg.cxx.

23  {
24  /* Initialise ReadHandle keys for the two xAOD jet containers
25  and various L1 xAOD jet containers.
26 
27  xAOD jet containers are produced by the both hlt and offline
28  reconstruction programs. The L1 trigger system produces various
29  container types.
30 
31  The attribute m_jetContainerKey2 must not be initialised to "NONE".
32 
33  An instance of JetMatcher Alg will work with two containers only.
34  However, all ReadHandles must be initialised.
35 
36 
37 
38  */
39 
40  ATH_MSG_INFO(" Initializing " << name());
41 
42  if ( m_jetContainerKey2.key().empty() ) {
43 
44  std::string msg = "JetContainerKey2 has not been configured correctly - "
45  "has value NONE";
47 
48  return StatusCode::FAILURE;
49  }
50 
51  int key_count{0};
52 
53  if (!m_jetContainerKey1.key().empty()) {
54  ++key_count;
56  ATH_MSG_INFO("will match xAODJet to xAODJet");
57  }
58 
59  if (!m_l1jetContainerKey1.key().empty()) {
60  ++key_count;
62  ATH_MSG_INFO("will match JetRoI (L1) to xAODJet");
63  }
64 
65  if (!m_jFexSRJetRoIKey.key().empty()) {
66  ++key_count;
68  ATH_MSG_INFO("will match jFexSRJetRoI (L1) to xAODJet");
69  }
70 
71 
72  if (!m_jFexLRJetRoIKey.key().empty()) {
73  ++key_count;
75  ATH_MSG_INFO("will match jFexLRJetRoI (L1) to xAODJet");
76  }
77 
78 
79  if (!m_gFexJetRoIKey.key().empty()) {
80  ++key_count;
82  ATH_MSG_INFO("will match gFexSRJetRoI (L1) to xAODJet");
83  }
84 
85  if (key_count != 1) {
86  ATH_MSG_ERROR(key_count <<
87  " containers requested. This should be exactly 1");
88  return StatusCode::FAILURE;
89  }
90 
91  // code was originally written to use m_matchL1 to determine
92  // if matching was to be done with the L1 jet container. At that
93  // time, there was a single L1 jet container type.
94  // The existence of m_matchL1 has been maintained to allow
95  // older configuration code to continue to work.
96  //
97  bool l1_match =
102 
103  if (l1_match != m_matchL1) {
104  ATH_MSG_ERROR("m_matchL1 is misconfigured");
105  return StatusCode::FAILURE;
106  }
107 
108 
112  ATH_CHECK( m_jFexSRJetRoIKey.initialize( SG::AllowEmpty ) );
113  ATH_CHECK( m_jFexLRJetRoIKey.initialize( SG::AllowEmpty ) );
114  ATH_CHECK( m_gFexJetRoIKey.initialize( SG::AllowEmpty ) );
115 
121 
123 
124  return StatusCode::SUCCESS;
125 }

◆ initialize_gFexJetRoI_varHandleKeys()

StatusCode JetMatcherAlg::initialize_gFexJetRoI_varHandleKeys ( bool  do_it)
private

Definition at line 568 of file JetMatcherAlg.cxx.

568  {
569  for (auto& key : m_l1gFexJetVarHandleKeys) {
570  ATH_CHECK(key.get().initialize(do_it));
571  ATH_CHECK(m_l1gFexmatchedKey.initialize(do_it));
572  }
573  return StatusCode::SUCCESS;
574 }

◆ initialize_JetRoI_varHandleKeys()

StatusCode JetMatcherAlg::initialize_JetRoI_varHandleKeys ( bool  do_it)
private

Definition at line 542 of file JetMatcherAlg.cxx.

542  {
543  for (auto& key : m_l1JetVarHandleKeys) {
544  ATH_CHECK(key.get().initialize(do_it));
545  ATH_CHECK(m_l1matchedKey.initialize(do_it));
546  }
547  return StatusCode::SUCCESS;
548 }

◆ initialize_jFexLRJetRoI_varHandleKeys()

StatusCode JetMatcherAlg::initialize_jFexLRJetRoI_varHandleKeys ( bool  do_it)
private

Definition at line 559 of file JetMatcherAlg.cxx.

559  {
560  for (auto& key : m_l1jFexLRJetVarHandleKeys) {
561  ATH_CHECK(key.get().initialize(do_it));
562  ATH_CHECK(m_l1jFexLRmatchedKey.initialize(do_it));
563  }
564  return StatusCode::SUCCESS;
565 }

◆ initialize_jFexSRJetRoI_varHandleKeys()

StatusCode JetMatcherAlg::initialize_jFexSRJetRoI_varHandleKeys ( bool  do_it)
private

Definition at line 551 of file JetMatcherAlg.cxx.

551  {
552  for (auto& key : m_l1jFexSRJetVarHandleKeys) {
553  ATH_CHECK(key.get().initialize(do_it));
554  ATH_CHECK(m_l1jFexSRmatchedKey.initialize(do_it));
555  }
556  return StatusCode::SUCCESS;
557 }

◆ initialize_varHandleKeys()

StatusCode JetMatcherAlg::initialize_varHandleKeys ( )
private

Definition at line 494 of file JetMatcherAlg.cxx.

494  {
495 
502  } else if (m_matchType == MatchType::JetRoI) {
508  } else if (m_matchType == MatchType::jFexSRJetRoI) {
514  } else if (m_matchType == MatchType::jFexLRJetRoI) {
520  } else if (m_matchType == MatchType::gFexJetRoI) {
526  } else {
527  ATH_MSG_FATAL("uknown match type");
528  return StatusCode::FAILURE;
529  }
530  return StatusCode::SUCCESS;
531 }

◆ initialize_xAODJet_varHandleKeys()

StatusCode JetMatcherAlg::initialize_xAODJet_varHandleKeys ( bool  do_it)
private

Definition at line 533 of file JetMatcherAlg.cxx.

533  {
534  for (auto& key : m_jetVarHandleKeys) {
535  ATH_CHECK(key.get().initialize(do_it));
536  ATH_CHECK(m_matchedKey.initialize(do_it));
537 
538  }
539  return StatusCode::SUCCESS;
540 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

◆ isClonable()

bool AthReentrantAlgorithm::isClonable ( ) const
overridevirtualinherited

◆ jetMatching()

template<typename T >
StatusCode JetMatcherAlg::jetMatching ( SG::ReadHandle< DataVector< T >>  jets1,
SG::ReadHandle< xAOD::JetContainer jets2,
SG::WriteDecorHandleKey< DataVector< T >>  matchedHandleKey,
std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< DataVector< T >>>>  varHandleKeys,
const EventContext &  ctx 
) const
private

Definition at line 181 of file JetMatcherAlg.cxx.

185  {
186 
187  SG::WriteDecorHandle<DataVector<T>, double> ptDiffHandle(varHandleKeys[0].get(), ctx);
188  SG::WriteDecorHandle<DataVector<T>, double> energyDiffHandle(varHandleKeys[1].get(), ctx);
189  SG::WriteDecorHandle<DataVector<T>, double> massDiffHandle(varHandleKeys[2].get(), ctx);
190  SG::WriteDecorHandle<DataVector<T>, double> ptRespHandle(varHandleKeys[3].get(), ctx);
191  SG::WriteDecorHandle<DataVector<T>, double> energyRespHandle(varHandleKeys[4].get(), ctx);
192  SG::WriteDecorHandle<DataVector<T>, double> massRespHandle(varHandleKeys[5].get(), ctx);
193  SG::WriteDecorHandle<DataVector<T>, double> ptRefHandle(varHandleKeys[6].get(), ctx);
194  SG::WriteDecorHandle<DataVector<T>, double> etaRefHandle(varHandleKeys[7].get(), ctx);
195  SG::WriteDecorHandle<DataVector<T>, char> matchedHandle(matchedHandleKey, ctx);
196 
197  std::vector<int> matchedIndices; //remembers which jets in jets2 are already matched, so they are not considered in future matching
198  // Loop over first jet collection
199  for (const T *j1 : *jets1) {
200  TLorentzVector tlvjet1 = TLorentzVector();
201  StatusCode status = GetTLV(j1, tlvjet1);
202  if (!status) {
203  ATH_MSG_WARNING("Could not retrieve full jet 4-momentum. Skipping jet matching.");
204  return StatusCode::SUCCESS;
205  }
206  bool j1matched = false;
207  double ptDiff = -999., energyDiff = -999., massDiff = -999., ptResp = -999., energyResp = -999., massResp = -999., ptRef = -999., etaRef = -999.;
208  if (tlvjet1.Pt() < 10000.) { // minimum pT cut of 10 GeV for jet matching
209  matchedHandle(*j1) = j1matched; // set default values for match decorations and move to next jet
210  ptDiffHandle(*j1) = ptDiff;
211  energyDiffHandle(*j1) = energyDiff;
212  massDiffHandle(*j1) = massDiff;
213  ptRespHandle(*j1) = ptResp;
214  energyRespHandle(*j1) = energyResp;
215  massRespHandle(*j1) = massResp;
216  ptRefHandle(*j1) = ptRef;
217  etaRefHandle(*j1) = etaRef;
218  continue;
219  }
220  double Rmin = 1E8;
221  int jetIndex = 0, jetMatchIndex = 0;
222  // Loop over second jet collection
223  for(const xAOD::Jet* j2 : *jets2){
224  if (j2->pt() < 10000.) { jetIndex++; continue; } // minimum pT cut of 10 GeV for jet matching
225  bool alreadymatched = false;
226  for (int jetIndexIterator : matchedIndices) { //Loop over indices of already matched jets to skip them
227  if (jetIndex == jetIndexIterator) { alreadymatched = true; break; }
228  }
229  if (alreadymatched) { jetIndex++; continue; }
230  TLorentzVector tlvjet2 = TLorentzVector();
231  tlvjet2.SetPtEtaPhiE(j2->pt(),j2->eta(),j2->phi(),j2->e());
232  // calculate DeltaR(jet1,jet2)
233  double dr = tlvjet1.DeltaR(tlvjet2);
234  if(dr<m_Rmatch && dr<Rmin){ // decorate matching jets
235  j1matched = true;
236  ptDiff = tlvjet1.Pt()-tlvjet2.Pt();
237  energyDiff = tlvjet1.E()-tlvjet2.E();
238  massDiff = tlvjet1.M()-tlvjet2.M();
239  ptResp = ptDiff/tlvjet2.Pt();
240  if (tlvjet2.E() == 0.) energyResp = -999.;
241  else energyResp = energyDiff/tlvjet2.E();
242  if (tlvjet2.M() == 0.) massResp = -999.;
243  else massResp = massDiff/tlvjet2.M();
244  ptRef = tlvjet2.Pt(); //second jet collection (=offline) is taken for reference pT and eta
245  etaRef = tlvjet2.Eta();
246  Rmin = dr;
247  jetMatchIndex = jetIndex;
248  }
249  jetIndex++;
250  }//End Loop over second jet collection
251  matchedHandle(*j1) = j1matched;
252  ptDiffHandle(*j1) = ptDiff;
253  energyDiffHandle(*j1) = energyDiff;
254  massDiffHandle(*j1) = massDiff;
255  ptRespHandle(*j1) = ptResp;
256  energyRespHandle(*j1) = energyResp;
257  massRespHandle(*j1) = massResp;
258  ptRefHandle(*j1) = ptRef;
259  etaRefHandle(*j1) = etaRef;
260  if (j1matched) matchedIndices.push_back(jetMatchIndex);
261  }
262  return StatusCode::SUCCESS;
263 
264 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::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< Gaudi::Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

◆ 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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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  }

◆ set_gFexJetRoI_varHandleKeys()

StatusCode JetMatcherAlg::set_gFexJetRoI_varHandleKeys ( )
private

Definition at line 462 of file JetMatcherAlg.cxx.

462  {
463 
465 
466  std::string keyAppendix = m_jetContainerKey2.key();
467  std::string prepend = m_gFexJetRoIKey.key();
468 
469  m_l1gFexptDiffKey = prepend+".ptdiff_" + keyAppendix;
470  m_l1gFexenergyDiffKey = prepend+".energydiff_" + keyAppendix;
471  m_l1gFexmassDiffKey = prepend+".massdiff_" + keyAppendix;
472  m_l1gFexptRespKey = prepend+".ptresp_" + keyAppendix;
473  m_l1gFexenergyRespKey = prepend+".energyresp_" + keyAppendix;
474  m_l1gFexmassRespKey = prepend+".massresp_" + keyAppendix;
475  m_l1gFexptRefKey = prepend+".ptRef_" + keyAppendix;
476  m_l1gFexetaRefKey = prepend+".etaRef_" + keyAppendix;
477  m_l1gFexmatchedKey = prepend+".matched_" + keyAppendix;
478  }
479 
480 
490 
491  return StatusCode::SUCCESS;
492 }

◆ set_JetRoI_varHandleKeys()

StatusCode JetMatcherAlg::set_JetRoI_varHandleKeys ( )
private

Definition at line 364 of file JetMatcherAlg.cxx.

364  {
365 
366 
368  std::string keyAppendix{m_jetContainerKey2.key()};
369  std::string prepend{m_l1jetContainerKey1.key()};
370 
371  m_l1ptDiffKey = prepend+".ptdiff_" + keyAppendix;
372  m_l1energyDiffKey = prepend+".energydiff_" + keyAppendix;
373  m_l1massDiffKey = prepend+".massdiff_" + keyAppendix;
374  m_l1ptRespKey = prepend+".ptresp_" + keyAppendix;
375  m_l1energyRespKey = prepend+".energyresp_" + keyAppendix;
376  m_l1massRespKey = prepend+".massresp_" + keyAppendix;
377  m_l1ptRefKey = prepend+".ptRef_" + keyAppendix;
378  m_l1etaRefKey = prepend+".etaRef_" + keyAppendix;
379  m_l1matchedKey = prepend+".matched_" + keyAppendix;
380  }
381 
389  m_l1ptRefKey,
391  };
392 
393  return StatusCode::SUCCESS;
394 
395 }

◆ set_jFexLRJetRoI_varHandleKeys()

StatusCode JetMatcherAlg::set_jFexLRJetRoI_varHandleKeys ( )
private

Definition at line 430 of file JetMatcherAlg.cxx.

430  {
431 
433 
434  std::string keyAppendix = m_jetContainerKey2.key();
435  std::string prepend = m_jFexLRJetRoIKey.key();
436 
437  m_l1jFexLRptDiffKey = prepend+".ptdiff_" + keyAppendix;
438  m_l1jFexLRenergyDiffKey = prepend+".energydiff_" + keyAppendix;
439  m_l1jFexLRmassDiffKey = prepend+".massdiff_" + keyAppendix;
440  m_l1jFexLRptRespKey = prepend+".ptresp_" + keyAppendix;
441  m_l1jFexLRenergyRespKey = prepend+".energyresp_" + keyAppendix;
442  m_l1jFexLRmassRespKey = prepend+".massresp_" + keyAppendix;
443  m_l1jFexLRptRefKey = prepend+".ptRef_" + keyAppendix;
444  m_l1jFexLRetaRefKey = prepend+".etaRef_" + keyAppendix;
445  m_l1jFexLRmatchedKey = prepend+".matched_" + keyAppendix;
446  }
447 
448 
458 
459  return StatusCode::SUCCESS;
460 }

◆ set_jFexSRJetRoI_varHandleKeys()

StatusCode JetMatcherAlg::set_jFexSRJetRoI_varHandleKeys ( )
private

Definition at line 398 of file JetMatcherAlg.cxx.

398  {
399 
401 
402  std::string keyAppendix = m_jetContainerKey2.key();
403  std::string prepend = m_jFexSRJetRoIKey.key();
404 
405  m_l1jFexSRptDiffKey = prepend+".ptdiff_" + keyAppendix;
406  m_l1jFexSRenergyDiffKey = prepend+".energydiff_" + keyAppendix;
407  m_l1jFexSRmassDiffKey = prepend+".massdiff_" + keyAppendix;
408  m_l1jFexSRptRespKey = prepend+".ptresp_" + keyAppendix;
409  m_l1jFexSRenergyRespKey = prepend+".energyresp_" + keyAppendix;
410  m_l1jFexSRmassRespKey = prepend+".massresp_" + keyAppendix;
411  m_l1jFexSRptRefKey = prepend+".ptRef_" + keyAppendix;
412  m_l1jFexSRetaRefKey = prepend+".etaRef_" + keyAppendix;
413  m_l1jFexSRmatchedKey = prepend+".matched_" + keyAppendix;
414  }
415 
416 
426 
427  return StatusCode::SUCCESS;
428 }

◆ set_xAODJet_varHandleKeys()

StatusCode JetMatcherAlg::set_xAODJet_varHandleKeys ( )
private

Definition at line 326 of file JetMatcherAlg.cxx.

326  {
327 
328 
330  std::string prepend{m_jetContainerKey1.key()};
331  std::string keyAppendix{m_jetContainerKey2.key()};
332  if (m_calibScale != "") {
333  keyAppendix = m_calibScale + "_" + m_jetContainerKey2.key();
334  }
335 
336  m_ptDiffKey = prepend+".ptdiff_" + keyAppendix;
337  m_energyDiffKey = prepend+".energydiff_" + keyAppendix;
338  m_massDiffKey = prepend+".massdiff_" + keyAppendix;
339  m_ptRespKey = prepend+".ptresp_" + keyAppendix;
340  m_energyRespKey = prepend+".energyresp_" + keyAppendix;
341  m_massRespKey = prepend+".massresp_" + keyAppendix;
342  m_ptRefKey = prepend+".ptRef_" + keyAppendix;
343  m_etaRefKey = prepend+".etaRef_" + keyAppendix;
344  m_matchedKey = prepend+".matched_" + keyAppendix;
345  }
346 
348  m_ptDiffKey,
351  m_ptRespKey,
354  m_ptRefKey,
356  };
357 
358 
359  return StatusCode::SUCCESS;
360 
361 }

◆ setFilterPassed()

virtual void AthReentrantAlgorithm::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

139  {
140  execState( ctx ).setFilterPassed( state );
141  }

◆ sysExecute()

StatusCode AthReentrantAlgorithm::sysExecute ( const EventContext &  ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 67 of file AthReentrantAlgorithm.cxx.

68 {
69  return Gaudi::Algorithm::sysExecute (ctx);
70 }

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

96  {
98 
99  if (sc.isFailure()) {
100  return sc;
101  }
102 
103  ServiceHandle<ICondSvc> cs("CondSvc",name());
104  for (auto h : outputHandles()) {
105  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
106  // do this inside the loop so we don't create the CondSvc until needed
107  if ( cs.retrieve().isFailure() ) {
108  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
109  return StatusCode::SUCCESS;
110  }
111  if (cs->regHandle(this,*h).isFailure()) {
112  sc = StatusCode::FAILURE;
113  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
114  << " with CondSvc");
115  }
116  }
117  }
118  return sc;
119 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

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

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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_calibScale

Gaudi::Property<std::string> JetMatcherAlg::m_calibScale {this, "JetCalibScale", "", "Calibration Scale at which to evaluate jet pT"}
private

Definition at line 45 of file JetMatcherAlg.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_energyDiffKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetMatcherAlg::m_energyDiffKey {this, "energydiff", "energydiff", "SG key for output energy difference decoration"}
private

Definition at line 74 of file JetMatcherAlg.h.

◆ m_energyRespKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetMatcherAlg::m_energyRespKey {this, "energyresp", "energyresp", "SG key for output energy response decoration"}
private

Definition at line 77 of file JetMatcherAlg.h.

◆ m_etaRefKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetMatcherAlg::m_etaRefKey {this, "etaRef", "etaRef", "SG key for output eta reference decoration"}
private

Definition at line 80 of file JetMatcherAlg.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthReentrantAlgorithm::m_extendedExtraObjects
privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

◆ m_gFexJetRoIKey

SG::ReadHandleKey<xAOD::gFexJetRoIContainer> JetMatcherAlg::m_gFexJetRoIKey
private

Definition at line 69 of file JetMatcherAlg.h.

◆ m_jetContainerKey1

SG::ReadHandleKey<xAOD::JetContainer> JetMatcherAlg::m_jetContainerKey1
private

Definition at line 53 of file JetMatcherAlg.h.

◆ m_jetContainerKey2

SG::ReadHandleKey<xAOD::JetContainer> JetMatcherAlg::m_jetContainerKey2
private

Definition at line 54 of file JetMatcherAlg.h.

◆ m_jetVarHandleKeys

std::vector<std::reference_wrapper<SG::WriteDecorHandleKey<xAOD::JetContainer> > > JetMatcherAlg::m_jetVarHandleKeys
private

Definition at line 82 of file JetMatcherAlg.h.

◆ m_jFexLRJetRoIKey

SG::ReadHandleKey<xAOD::jFexLRJetRoIContainer> JetMatcherAlg::m_jFexLRJetRoIKey
private

Definition at line 68 of file JetMatcherAlg.h.

◆ m_jFexSRJetRoIKey

SG::ReadHandleKey<xAOD::jFexSRJetRoIContainer> JetMatcherAlg::m_jFexSRJetRoIKey
private

Definition at line 67 of file JetMatcherAlg.h.

◆ m_l1energyDiffKey

SG::WriteDecorHandleKey<xAOD::JetRoIContainer> JetMatcherAlg::m_l1energyDiffKey {this, "l1energydiff", "l1energydiff", "SG key for output energy difference decoration"}
private

Definition at line 86 of file JetMatcherAlg.h.

◆ m_l1energyRespKey

SG::WriteDecorHandleKey<xAOD::JetRoIContainer> JetMatcherAlg::m_l1energyRespKey {this, "l1energyresp", "l1energyresp", "SG key for output energy response decoration"}
private

Definition at line 89 of file JetMatcherAlg.h.

◆ m_l1etaRefKey

SG::WriteDecorHandleKey<xAOD::JetRoIContainer> JetMatcherAlg::m_l1etaRefKey {this, "l1etaRef", "l1etaRef", "SG key for output eta reference decoration"}
private

Definition at line 92 of file JetMatcherAlg.h.

◆ m_l1gFexenergyDiffKey

SG::WriteDecorHandleKey<xAOD::gFexJetRoIContainer> JetMatcherAlg::m_l1gFexenergyDiffKey {this, "l1gFexenergydiff", "l1gFexenergydiff", "SG key for output energy difference decoration"}
private

Definition at line 122 of file JetMatcherAlg.h.

◆ m_l1gFexenergyRespKey

SG::WriteDecorHandleKey<xAOD::gFexJetRoIContainer> JetMatcherAlg::m_l1gFexenergyRespKey {this, "l1gFexenergyresp", "l1gFexenergyresp", "SG key for output energy response decoration"}
private

Definition at line 125 of file JetMatcherAlg.h.

◆ m_l1gFexetaRefKey

SG::WriteDecorHandleKey<xAOD::gFexJetRoIContainer> JetMatcherAlg::m_l1gFexetaRefKey {this, "l1gFexetaRef", "l1gFexetaRef", "SG key for output eta reference decoration"}
private

Definition at line 128 of file JetMatcherAlg.h.

◆ m_l1gFexJetVarHandleKeys

std::vector<std::reference_wrapper<SG::WriteDecorHandleKey<xAOD::gFexJetRoIContainer> > > JetMatcherAlg::m_l1gFexJetVarHandleKeys
private

Definition at line 129 of file JetMatcherAlg.h.

◆ m_l1gFexmassDiffKey

SG::WriteDecorHandleKey<xAOD::gFexJetRoIContainer> JetMatcherAlg::m_l1gFexmassDiffKey {this, "l1gFexmassdiff", "l1gFexmassdiff", "SG key for output mass difference decoration"}
private

Definition at line 123 of file JetMatcherAlg.h.

◆ m_l1gFexmassRespKey

SG::WriteDecorHandleKey<xAOD::gFexJetRoIContainer> JetMatcherAlg::m_l1gFexmassRespKey {this, "l1gFexmassresp", "l1gFexmassresp", "SG key for output mass response decoration"}
private

Definition at line 126 of file JetMatcherAlg.h.

◆ m_l1gFexmatchedKey

SG::WriteDecorHandleKey<xAOD::gFexJetRoIContainer> JetMatcherAlg::m_l1gFexmatchedKey {this, "l1gFexmatched", "l1gFexmatched", "SG key for output matched decoration"}
private

Definition at line 120 of file JetMatcherAlg.h.

◆ m_l1gFexptDiffKey

SG::WriteDecorHandleKey<xAOD::gFexJetRoIContainer> JetMatcherAlg::m_l1gFexptDiffKey {this, "l1gFexptdiff", "l1gFexptdiff", "SG key for output pt difference decoration"}
private

Definition at line 121 of file JetMatcherAlg.h.

◆ m_l1gFexptRefKey

SG::WriteDecorHandleKey<xAOD::gFexJetRoIContainer> JetMatcherAlg::m_l1gFexptRefKey {this, "l1gFexptRef", "l1gFexptRef", "SG key for output pt reference decoration"}
private

Definition at line 127 of file JetMatcherAlg.h.

◆ m_l1gFexptRespKey

SG::WriteDecorHandleKey<xAOD::gFexJetRoIContainer> JetMatcherAlg::m_l1gFexptRespKey {this, "l1gFexptresp", "l1gFexptresp", "SG key for output pt response decoration"}
private

Definition at line 124 of file JetMatcherAlg.h.

◆ m_l1jetContainerKey1

SG::ReadHandleKey<xAOD::JetRoIContainer> JetMatcherAlg::m_l1jetContainerKey1
private

Definition at line 66 of file JetMatcherAlg.h.

◆ m_l1JetVarHandleKeys

std::vector<std::reference_wrapper<SG::WriteDecorHandleKey<xAOD::JetRoIContainer> > > JetMatcherAlg::m_l1JetVarHandleKeys
private

Definition at line 93 of file JetMatcherAlg.h.

◆ m_l1jFexLRenergyDiffKey

SG::WriteDecorHandleKey<xAOD::jFexLRJetRoIContainer> JetMatcherAlg::m_l1jFexLRenergyDiffKey {this, "l1jFexLRenergydiff", "l1jFexLRenergydiff", "SG key for output energy difference decoration"}
private

Definition at line 110 of file JetMatcherAlg.h.

◆ m_l1jFexLRenergyRespKey

SG::WriteDecorHandleKey<xAOD::jFexLRJetRoIContainer> JetMatcherAlg::m_l1jFexLRenergyRespKey {this, "l1jFexLRenergyresp", "l1jFexLRenergyresp", "SG key for output energy response decoration"}
private

Definition at line 113 of file JetMatcherAlg.h.

◆ m_l1jFexLRetaRefKey

SG::WriteDecorHandleKey<xAOD::jFexLRJetRoIContainer> JetMatcherAlg::m_l1jFexLRetaRefKey {this, "l1jFexLRetaRef", "l1jFexLRetaRef", "SG key for output eta reference decoration"}
private

Definition at line 116 of file JetMatcherAlg.h.

◆ m_l1jFexLRJetVarHandleKeys

std::vector<std::reference_wrapper<SG::WriteDecorHandleKey<xAOD::jFexLRJetRoIContainer> > > JetMatcherAlg::m_l1jFexLRJetVarHandleKeys
private

Definition at line 117 of file JetMatcherAlg.h.

◆ m_l1jFexLRmassDiffKey

SG::WriteDecorHandleKey<xAOD::jFexLRJetRoIContainer> JetMatcherAlg::m_l1jFexLRmassDiffKey {this, "l1jFexLRmassdiff", "l1jFexLRmassdiff", "SG key for output mass difference decoration"}
private

Definition at line 111 of file JetMatcherAlg.h.

◆ m_l1jFexLRmassRespKey

SG::WriteDecorHandleKey<xAOD::jFexLRJetRoIContainer> JetMatcherAlg::m_l1jFexLRmassRespKey {this, "l1jFexLRmassresp", "l1jFexLRmassresp", "SG key for output mass response decoration"}
private

Definition at line 114 of file JetMatcherAlg.h.

◆ m_l1jFexLRmatchedKey

SG::WriteDecorHandleKey<xAOD::jFexLRJetRoIContainer> JetMatcherAlg::m_l1jFexLRmatchedKey {this, "l1jFexLRmatched", "l1jFexLRmatched", "SG key for output matched decoration"}
private

Definition at line 108 of file JetMatcherAlg.h.

◆ m_l1jFexLRptDiffKey

SG::WriteDecorHandleKey<xAOD::jFexLRJetRoIContainer> JetMatcherAlg::m_l1jFexLRptDiffKey {this, "l1jFexLRptdiff", "l1jFexLRptdiff", "SG key for output pt difference decoration"}
private

Definition at line 109 of file JetMatcherAlg.h.

◆ m_l1jFexLRptRefKey

SG::WriteDecorHandleKey<xAOD::jFexLRJetRoIContainer> JetMatcherAlg::m_l1jFexLRptRefKey {this, "l1jFexLRptRef", "l1jFexLRptRef", "SG key for output pt reference decoration"}
private

Definition at line 115 of file JetMatcherAlg.h.

◆ m_l1jFexLRptRespKey

SG::WriteDecorHandleKey<xAOD::jFexLRJetRoIContainer> JetMatcherAlg::m_l1jFexLRptRespKey {this, "l1jFexLRptresp", "l1jFexLRptresp", "SG key for output pt response decoration"}
private

Definition at line 112 of file JetMatcherAlg.h.

◆ m_l1jFexSRenergyDiffKey

SG::WriteDecorHandleKey<xAOD::jFexSRJetRoIContainer> JetMatcherAlg::m_l1jFexSRenergyDiffKey {this, "l1jFexSRenergydiff", "l1jFexSRenergydiff", "SG key for output energy difference decoration"}
private

Definition at line 98 of file JetMatcherAlg.h.

◆ m_l1jFexSRenergyRespKey

SG::WriteDecorHandleKey<xAOD::jFexSRJetRoIContainer> JetMatcherAlg::m_l1jFexSRenergyRespKey {this, "l1jFexSRenergyresp", "l1jFexSRenergyresp", "SG key for output energy response decoration"}
private

Definition at line 101 of file JetMatcherAlg.h.

◆ m_l1jFexSRetaRefKey

SG::WriteDecorHandleKey<xAOD::jFexSRJetRoIContainer> JetMatcherAlg::m_l1jFexSRetaRefKey {this, "l1jFexSRetaRef", "l1jFexSRetaRef", "SG key for output eta reference decoration"}
private

Definition at line 104 of file JetMatcherAlg.h.

◆ m_l1jFexSRJetVarHandleKeys

std::vector<std::reference_wrapper<SG::WriteDecorHandleKey<xAOD::jFexSRJetRoIContainer> > > JetMatcherAlg::m_l1jFexSRJetVarHandleKeys
private

Definition at line 105 of file JetMatcherAlg.h.

◆ m_l1jFexSRmassDiffKey

SG::WriteDecorHandleKey<xAOD::jFexSRJetRoIContainer> JetMatcherAlg::m_l1jFexSRmassDiffKey {this, "l1jFexSRmassdiff", "l1jFexSRmassdiff", "SG key for output mass difference decoration"}
private

Definition at line 99 of file JetMatcherAlg.h.

◆ m_l1jFexSRmassRespKey

SG::WriteDecorHandleKey<xAOD::jFexSRJetRoIContainer> JetMatcherAlg::m_l1jFexSRmassRespKey {this, "l1jFexSRmassresp", "l1jFexSRmassresp", "SG key for output mass response decoration"}
private

Definition at line 102 of file JetMatcherAlg.h.

◆ m_l1jFexSRmatchedKey

SG::WriteDecorHandleKey<xAOD::jFexSRJetRoIContainer> JetMatcherAlg::m_l1jFexSRmatchedKey {this, "l1jFexSRmatched", "l1jFexSRmatched", "SG key for output matched decoration"}
private

Definition at line 96 of file JetMatcherAlg.h.

◆ m_l1jFexSRptDiffKey

SG::WriteDecorHandleKey<xAOD::jFexSRJetRoIContainer> JetMatcherAlg::m_l1jFexSRptDiffKey {this, "l1jFexSRptdiff", "l1jFexSRptdiff", "SG key for output pt difference decoration"}
private

Definition at line 97 of file JetMatcherAlg.h.

◆ m_l1jFexSRptRefKey

SG::WriteDecorHandleKey<xAOD::jFexSRJetRoIContainer> JetMatcherAlg::m_l1jFexSRptRefKey {this, "l1jFexSRptRef", "l1jFexSRptRef", "SG key for output pt reference decoration"}
private

Definition at line 103 of file JetMatcherAlg.h.

◆ m_l1jFexSRptRespKey

SG::WriteDecorHandleKey<xAOD::jFexSRJetRoIContainer> JetMatcherAlg::m_l1jFexSRptRespKey {this, "l1jFexSRptresp", "l1jFexSRptresp", "SG key for output pt response decoration"}
private

Definition at line 100 of file JetMatcherAlg.h.

◆ m_l1massDiffKey

SG::WriteDecorHandleKey<xAOD::JetRoIContainer> JetMatcherAlg::m_l1massDiffKey {this, "l1massdiff", "l1massdiff", "SG key for output mass difference decoration"}
private

Definition at line 87 of file JetMatcherAlg.h.

◆ m_l1massRespKey

SG::WriteDecorHandleKey<xAOD::JetRoIContainer> JetMatcherAlg::m_l1massRespKey {this, "l1massresp", "l1massresp", "SG key for output mass response decoration"}
private

Definition at line 90 of file JetMatcherAlg.h.

◆ m_l1matchedKey

SG::WriteDecorHandleKey<xAOD::JetRoIContainer> JetMatcherAlg::m_l1matchedKey {this, "l1matched", "l1matched", "SG key for output matched decoration"}
private

Definition at line 84 of file JetMatcherAlg.h.

◆ m_l1ptDiffKey

SG::WriteDecorHandleKey<xAOD::JetRoIContainer> JetMatcherAlg::m_l1ptDiffKey {this, "l1ptdiff", "l1ptdiff", "SG key for output pt difference decoration"}
private

Definition at line 85 of file JetMatcherAlg.h.

◆ m_l1ptRefKey

SG::WriteDecorHandleKey<xAOD::JetRoIContainer> JetMatcherAlg::m_l1ptRefKey {this, "l1ptRef", "l1ptRef", "SG key for output pt reference decoration"}
private

Definition at line 91 of file JetMatcherAlg.h.

◆ m_l1ptRespKey

SG::WriteDecorHandleKey<xAOD::JetRoIContainer> JetMatcherAlg::m_l1ptRespKey {this, "l1ptresp", "l1ptresp", "SG key for output pt response decoration"}
private

Definition at line 88 of file JetMatcherAlg.h.

◆ m_massDiffKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetMatcherAlg::m_massDiffKey {this, "massdiff", "massdiff", "SG key for output mass difference decoration"}
private

Definition at line 75 of file JetMatcherAlg.h.

◆ m_massRespKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetMatcherAlg::m_massRespKey {this, "massresp", "massresp", "SG key for output mass response decoration"}
private

Definition at line 78 of file JetMatcherAlg.h.

◆ m_matchedKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetMatcherAlg::m_matchedKey {this, "matched", "matched", "SG key for output matched decoration"}
private

Definition at line 72 of file JetMatcherAlg.h.

◆ m_matchL1

Gaudi::Property<bool> JetMatcherAlg::m_matchL1 {this, "MatchL1", false, "Whether to match an L1 jet collection or actual online/offline jets"}
private

Definition at line 50 of file JetMatcherAlg.h.

◆ m_matchType

MatchType JetMatcherAlg::m_matchType {MatchType::undeclared}
private

Definition at line 63 of file JetMatcherAlg.h.

◆ m_ptDiffKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetMatcherAlg::m_ptDiffKey {this, "ptdiff", "ptdiff", "SG key for output pt difference decoration"}
private

Definition at line 73 of file JetMatcherAlg.h.

◆ m_ptRefKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetMatcherAlg::m_ptRefKey {this, "ptRef", "ptRef", "SG key for output pt reference decoration"}
private

Definition at line 79 of file JetMatcherAlg.h.

◆ m_ptRespKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetMatcherAlg::m_ptRespKey {this, "ptresp", "ptresp", "SG key for output pt response decoration"}
private

Definition at line 76 of file JetMatcherAlg.h.

◆ m_Rmatch

Gaudi::Property<float> JetMatcherAlg::m_Rmatch {this, "Rmatch", 0.3, "R matching"}
private

Definition at line 43 of file JetMatcherAlg.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.


The documentation for this class was generated from the following files:
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
JetMatcherAlg::MatchType::gFexJetRoI
@ gFexJetRoI
JetMatcherAlg::m_ptRefKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_ptRefKey
Definition: JetMatcherAlg.h:79
JetMatcherAlg::m_ptDiffKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_ptDiffKey
Definition: JetMatcherAlg.h:73
JetMatcherAlg::initialize_JetRoI_varHandleKeys
StatusCode initialize_JetRoI_varHandleKeys(bool)
Definition: JetMatcherAlg.cxx:542
JetMatcherAlg::m_l1gFexmatchedKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexmatchedKey
Definition: JetMatcherAlg.h:120
JetMatcherAlg::initialize_jFexSRJetRoI_varHandleKeys
StatusCode initialize_jFexSRJetRoI_varHandleKeys(bool)
Definition: JetMatcherAlg.cxx:551
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::jFexLRJetRoI
jFexLRJetRoI_v1 jFexLRJetRoI
Define the latest version of the jFexLRJetRoI class
Definition: jFexLRJetRoI.h:13
JetMatcherAlg::m_l1jFexLRenergyDiffKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRenergyDiffKey
Definition: JetMatcherAlg.h:110
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
JetMatcherAlg::MatchType::JetRoI
@ JetRoI
JetMatcherAlg::set_jFexSRJetRoI_varHandleKeys
StatusCode set_jFexSRJetRoI_varHandleKeys()
Definition: JetMatcherAlg.cxx:398
JetMatcherAlg::m_l1gFexetaRefKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexetaRefKey
Definition: JetMatcherAlg.h:128
JetMatcherAlg::set_gFexJetRoI_varHandleKeys
StatusCode set_gFexJetRoI_varHandleKeys()
Definition: JetMatcherAlg.cxx:462
AthCommonDataStore::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 > renounce(T &h)
Definition: AthCommonDataStore.h:380
JetMatcherAlg::initialize_varHandleKeys
StatusCode initialize_varHandleKeys()
Definition: JetMatcherAlg.cxx:494
JetMatcherAlg::m_l1jFexLRmatchedKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRmatchedKey
Definition: JetMatcherAlg.h:108
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
JetMatcherAlg::m_jetContainerKey2
SG::ReadHandleKey< xAOD::JetContainer > m_jetContainerKey2
Definition: JetMatcherAlg.h:54
JetMatcherAlg::m_l1jFexSRptRespKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRptRespKey
Definition: JetMatcherAlg.h:100
JetMatcherAlg::m_l1gFexJetVarHandleKeys
std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > > > m_l1gFexJetVarHandleKeys
Definition: JetMatcherAlg.h:129
JetMatcherAlg::m_l1energyRespKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1energyRespKey
Definition: JetMatcherAlg.h:89
JetMatcherAlg::jetMatching
StatusCode jetMatching(SG::ReadHandle< DataVector< T >> jets1, SG::ReadHandle< xAOD::JetContainer > jets2, SG::WriteDecorHandleKey< DataVector< T >> matchedHandleKey, std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< DataVector< T >>>> varHandleKeys, const EventContext &ctx) const
Definition: JetMatcherAlg.cxx:181
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:112
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
JetMatcherAlg::m_calibScale
Gaudi::Property< std::string > m_calibScale
Definition: JetMatcherAlg.h:45
JetMatcherAlg::m_l1jFexLRptRespKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRptRespKey
Definition: JetMatcherAlg.h:112
JetMatcherAlg::m_matchType
MatchType m_matchType
Definition: JetMatcherAlg.h:63
JetMatcherAlg::m_l1jFexSRmatchedKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRmatchedKey
Definition: JetMatcherAlg.h:96
JetMatcherAlg::m_l1ptRefKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1ptRefKey
Definition: JetMatcherAlg.h:91
JetMatcherAlg::m_matchL1
Gaudi::Property< bool > m_matchL1
Definition: JetMatcherAlg.h:50
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
JetMatcherAlg::m_massRespKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_massRespKey
Definition: JetMatcherAlg.h:78
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
JetMatcherAlg::m_jetContainerKey1
SG::ReadHandleKey< xAOD::JetContainer > m_jetContainerKey1
Definition: JetMatcherAlg.h:53
JetMatcherAlg::m_l1ptRespKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1ptRespKey
Definition: JetMatcherAlg.h:88
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
JetMatcherAlg::set_JetRoI_varHandleKeys
StatusCode set_JetRoI_varHandleKeys()
Definition: JetMatcherAlg.cxx:364
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthReentrantAlgorithm::AthReentrantAlgorithm
AthReentrantAlgorithm()
Default constructor:
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
doubleTestComp.j1
j1
Definition: doubleTestComp.py:21
JetMatcherAlg::m_l1gFexenergyDiffKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexenergyDiffKey
Definition: JetMatcherAlg.h:122
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
JetMatcherAlg::m_gFexJetRoIKey
SG::ReadHandleKey< xAOD::gFexJetRoIContainer > m_gFexJetRoIKey
Definition: JetMatcherAlg.h:69
JetMatcherAlg::m_l1jFexSRenergyDiffKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRenergyDiffKey
Definition: JetMatcherAlg.h:98
JetMatcherAlg::m_l1jFexSRmassRespKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRmassRespKey
Definition: JetMatcherAlg.h:102
JetMatcherAlg::m_l1jFexSRetaRefKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRetaRefKey
Definition: JetMatcherAlg.h:104
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
xAOD::JetRoI
JetRoI_v2 JetRoI
Definition: JetRoI.h:16
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:100
JetMatcherAlg::initialize_jFexLRJetRoI_varHandleKeys
StatusCode initialize_jFexLRJetRoI_varHandleKeys(bool)
Definition: JetMatcherAlg.cxx:559
JetMatcherAlg::m_l1ptDiffKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1ptDiffKey
Definition: JetMatcherAlg.h:85
JetMatcherAlg::m_matchedKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_matchedKey
Definition: JetMatcherAlg.h:72
JetMatcherAlg::m_jFexLRJetRoIKey
SG::ReadHandleKey< xAOD::jFexLRJetRoIContainer > m_jFexLRJetRoIKey
Definition: JetMatcherAlg.h:68
JetMatcherAlg::m_l1jFexSRptDiffKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRptDiffKey
Definition: JetMatcherAlg.h:97
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::jFexSRJetRoI
jFexSRJetRoI_v1 jFexSRJetRoI
Define the latest version of the jFexSRJetRoI class
Definition: jFexSRJetRoI.h:14
JetMatcherAlg::m_l1jFexLRetaRefKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRetaRefKey
Definition: JetMatcherAlg.h:116
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
JetMatcherAlg::m_energyDiffKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_energyDiffKey
Definition: JetMatcherAlg.h:74
JetMatcherAlg::m_l1etaRefKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1etaRefKey
Definition: JetMatcherAlg.h:92
JetMatcherAlg::m_l1jFexSRmassDiffKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRmassDiffKey
Definition: JetMatcherAlg.h:99
JetMatcherAlg::m_l1jFexLRptRefKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRptRefKey
Definition: JetMatcherAlg.h:115
JetMatcherAlg::GetTLV
StatusCode GetTLV(const xAOD::Jet *jet, TLorentzVector &) const
Definition: JetMatcherAlg.cxx:136
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
JetMatcherAlg::m_l1jFexSRenergyRespKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRenergyRespKey
Definition: JetMatcherAlg.h:101
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
JetMatcherAlg::m_l1energyDiffKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1energyDiffKey
Definition: JetMatcherAlg.h:86
xAOD::JetFourMom_t
ROOT::Math::LorentzVector< ROOT::Math::PtEtaPhiM4D< double > > JetFourMom_t
Base 4 Momentum type for Jet.
Definition: JetTypes.h:17
JetMatcherAlg::m_energyRespKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_energyRespKey
Definition: JetMatcherAlg.h:77
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
JetMatcherAlg::m_l1jFexSRptRefKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRptRefKey
Definition: JetMatcherAlg.h:103
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
xAOD::gFexJetRoI
gFexJetRoI_v1 gFexJetRoI
Define the latest version of the gFexJetRoI class.
Definition: gFexJetRoI.h:16
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
JetMatcherAlg::m_l1jetContainerKey1
SG::ReadHandleKey< xAOD::JetRoIContainer > m_l1jetContainerKey1
Definition: JetMatcherAlg.h:66
JetMatcherAlg::m_l1gFexptDiffKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexptDiffKey
Definition: JetMatcherAlg.h:121
JetMatcherAlg::m_l1gFexptRefKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexptRefKey
Definition: JetMatcherAlg.h:127
JetMatcherAlg::m_l1jFexSRJetVarHandleKeys
std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > > > m_l1jFexSRJetVarHandleKeys
Definition: JetMatcherAlg.h:105
JetMatcherAlg::m_Rmatch
Gaudi::Property< float > m_Rmatch
Definition: JetMatcherAlg.h:43
JetMatcherAlg::m_massDiffKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_massDiffKey
Definition: JetMatcherAlg.h:75
JetMatcherAlg::m_etaRefKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_etaRefKey
Definition: JetMatcherAlg.h:80
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
JetMatcherAlg::MatchType::jFexSRJetRoI
@ jFexSRJetRoI
a
TList * a
Definition: liststreamerinfos.cxx:10
h
JetMatcherAlg::m_ptRespKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_ptRespKey
Definition: JetMatcherAlg.h:76
JetMatcherAlg::m_l1JetVarHandleKeys
std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< xAOD::JetRoIContainer > > > m_l1JetVarHandleKeys
Definition: JetMatcherAlg.h:93
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
JetMatcherAlg::m_l1jFexLRenergyRespKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRenergyRespKey
Definition: JetMatcherAlg.h:113
JetMatcherAlg::m_l1gFexmassRespKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexmassRespKey
Definition: JetMatcherAlg.h:126
JetMatcherAlg::set_jFexLRJetRoI_varHandleKeys
StatusCode set_jFexLRJetRoI_varHandleKeys()
Definition: JetMatcherAlg.cxx:430
AthCommonMsg< Gaudi::Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition: hcg.cxx:127
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
Rmin
double Rmin
Definition: LArDetectorConstructionTBEC.cxx:56
JetMatcherAlg::initialize_xAODJet_varHandleKeys
StatusCode initialize_xAODJet_varHandleKeys(bool)
Definition: JetMatcherAlg.cxx:533
JetMatcherAlg::MatchType::jFexLRJetRoI
@ jFexLRJetRoI
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
merge.status
status
Definition: merge.py:17
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
JetMatcherAlg::m_l1massRespKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1massRespKey
Definition: JetMatcherAlg.h:90
JetMatcherAlg::m_l1jFexLRJetVarHandleKeys
std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > > > m_l1jFexLRJetVarHandleKeys
Definition: JetMatcherAlg.h:117
JetMatcherAlg::m_l1jFexLRmassDiffKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRmassDiffKey
Definition: JetMatcherAlg.h:111
JetMatcherAlg::m_l1massDiffKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1massDiffKey
Definition: JetMatcherAlg.h:87
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
JetMatcherAlg::m_jFexSRJetRoIKey
SG::ReadHandleKey< xAOD::jFexSRJetRoIContainer > m_jFexSRJetRoIKey
Definition: JetMatcherAlg.h:67
JetMatcherAlg::initialize_gFexJetRoI_varHandleKeys
StatusCode initialize_gFexJetRoI_varHandleKeys(bool)
Definition: JetMatcherAlg.cxx:568
JetMatcherAlg::m_l1matchedKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1matchedKey
Definition: JetMatcherAlg.h:84
JetMatcherAlg::m_l1jFexLRptDiffKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRptDiffKey
Definition: JetMatcherAlg.h:109
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
JetMatcherAlg::m_l1jFexLRmassRespKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRmassRespKey
Definition: JetMatcherAlg.h:114
JetMatcherAlg::m_l1gFexenergyRespKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexenergyRespKey
Definition: JetMatcherAlg.h:125
JetMatcherAlg::m_l1gFexptRespKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexptRespKey
Definition: JetMatcherAlg.h:124
doubleTestComp.j2
j2
Definition: doubleTestComp.py:22
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
JetMatcherAlg::m_jetVarHandleKeys
std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< xAOD::JetContainer > > > m_jetVarHandleKeys
Definition: JetMatcherAlg.h:82
JetMatcherAlg::set_xAODJet_varHandleKeys
StatusCode set_xAODJet_varHandleKeys()
Definition: JetMatcherAlg.cxx:326
fitman.k
k
Definition: fitman.py:528
ServiceHandle< ICondSvc >
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
JetMatcherAlg::MatchType::xAODJet
@ xAODJet
JetMatcherAlg::m_l1gFexmassDiffKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexmassDiffKey
Definition: JetMatcherAlg.h:123