#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< StoreGateSvc >	StoreGateSvc_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::JetContainer >	m_jetContainerKey1

SG::ReadHandleKey< xAOD::JetContainer >	m_jetContainerKey2

MatchType	m_matchType {MatchType::undeclared}

SG::ReadHandleKey< xAOD::JetRoIContainer >	m_l1jetContainerKey1

SG::ReadHandleKey< xAOD::jFexSRJetRoIContainer >	m_jFexSRJetRoIKey

SG::ReadHandleKey< xAOD::jFexLRJetRoIContainer >	m_jFexLRJetRoIKey

SG::ReadHandleKey< xAOD::gFexJetRoIContainer >	m_gFexJetRoIKey

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

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

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

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

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

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

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

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

SG::WriteDecorHandleKey< xAOD::JetContainer >	m_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::JetRoIContainer >	m_l1matchedKey {this, "l1matched", "l1matched", "SG key for output matched decoration"}

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

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

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

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

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

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

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

SG::WriteDecorHandleKey< xAOD::JetRoIContainer >	m_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::jFexSRJetRoIContainer >	m_l1jFexSRmatchedKey {this, "l1jFexSRmatched", "l1jFexSRmatched", "SG key for output matched decoration"}

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

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

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

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

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

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

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

SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer >	m_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::jFexLRJetRoIContainer >	m_l1jFexLRmatchedKey {this, "l1jFexLRmatched", "l1jFexLRmatched", "SG key for output matched decoration"}

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

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

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

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

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

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

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

SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer >	m_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::gFexJetRoIContainer >	m_l1gFexmatchedKey {this, "l1gFexmatched", "l1gFexmatched", "SG key for output matched decoration"}

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

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

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

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

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

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

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

SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer >	m_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.

                        {
     undeclared, xAODJet, JetRoI,
     jFexSRJetRoI, jFexLRJetRoI,
     gFexJetRoI
   };

Constructor & Destructor Documentation

◆ JetMatcherAlg()

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

Definition at line 10 of file JetMatcherAlg.cxx.

                                                                               : AthReentrantAlgorithm(name,pSvcLocator)
 {
   declareProperty("JetContainerName1"  ,m_jetContainerKey1="");
   declareProperty("JetContainerName2"  ,m_jetContainerKey2="");
  
   declareProperty("L1JetContainerName1",m_l1jetContainerKey1="");
   declareProperty("L1jFexSRJetRoIContainerName",m_jFexSRJetRoIKey="");
   declareProperty("L1jFexLRJetRoIContainerName",m_jFexLRJetRoIKey="");
   declareProperty("L1gFexJetRoIContainerName",m_gFexJetRoIKey="");
 }

Member Function Documentation

◆ AthReentrantAlgorithm()

AthReentrantAlgorithm::AthReentrantAlgorithm

Constructor with parameters:

Definition at line 90 of file AthReentrantAlgorithm.cxx.

                                                                          :
   ::AthCommonDataStore<AthCommonMsg<Gaudi::Algorithm>>   ( name, pSvcLocator )
 {
  
   // Set up to run AthAlgorithmDHUpdate in sysInitialize before
   // merging depedency lists.  This extends the output dependency
   // list with any symlinks implied by inheritance relations.
   m_updateDataHandles =
     std::make_unique<AthenaBaseComps::AthAlgorithmDHUpdate>
     (m_extendedExtraObjects,
      std::move (m_updateDataHandles));
 }

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

Definition at line 55 of file AthReentrantAlgorithm.cxx.

 {
   return 0;
 }

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

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

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

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

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

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

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

   {
     return PBASE::declareProperty(t);
   }

◆ 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

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation 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.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ 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

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation 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.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

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

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ 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

name	Name of the property.
property	Object holding the property value.
doc	Documentation 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.

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

◆ 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

name	Name of the property.
property	Object holding the property value.
doc	Documentation 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.

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

◆ declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< 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.

                                                                {
  
   // Retrieve jet containers and call appropriate matching function
   SG::ReadHandle<xAOD::JetContainer> jets2(m_jetContainerKey2, ctx);
   if (!jets2.isValid() ) {
     ATH_MSG_ERROR("evtStore() does not contain jet Collection with name "<< m_jetContainerKey2);
     return StatusCode::FAILURE;
   }
   
   if (m_matchType == MatchType::xAODJet) { // perform jet matching for online/offline xAODJet containers
     SG::ReadHandle<xAOD::JetContainer> jets1(m_jetContainerKey1, ctx);
     if (!jets1.isValid() ) {
       ATH_MSG_ERROR("evtStore() does not contain jet Collection with name "<< m_jetContainerKey1);
       return StatusCode::FAILURE;
     }
     return jetMatching(jets1, jets2, m_matchedKey, m_jetVarHandleKeys, ctx);
  
   } else if(m_matchType == MatchType::JetRoI) { // perform jet matching for L1 JetRoI container
     SG::ReadHandle<xAOD::JetRoIContainer> jets1(m_l1jetContainerKey1, ctx);
     if (!jets1.isValid() ) {
       ATH_MSG_ERROR("evtStore() does not contain L1 jet Collection with name "<< m_l1jetContainerKey1);
       return StatusCode::FAILURE;
     }
     return jetMatching(jets1, jets2, m_l1matchedKey, m_l1JetVarHandleKeys, ctx);
  
   } else if (m_matchType == MatchType::jFexSRJetRoI) { // perform jet matching for L1 jFexSRJetRoI container
     SG::ReadHandle<xAOD::jFexSRJetRoIContainer> jets1(m_jFexSRJetRoIKey, ctx);
     if (!jets1.isValid() ) {
       ATH_MSG_ERROR("evtStore() does not contain L1 jet Collection with name "<< m_jFexSRJetRoIKey);
       return StatusCode::FAILURE;
     } 
     return jetMatching(jets1, jets2, m_l1jFexSRmatchedKey, m_l1jFexSRJetVarHandleKeys, ctx);
  
     
   } else if (m_matchType == MatchType::jFexLRJetRoI) { // perform jet matching for L1 jFexLRJetRoI container
     SG::ReadHandle<xAOD::jFexLRJetRoIContainer> jets1(m_jFexLRJetRoIKey, ctx);
     if (!jets1.isValid() ) {
       ATH_MSG_ERROR("evtStore() does not contain L1 jet Collection with name "<< m_jFexSRJetRoIKey);
       return StatusCode::FAILURE;
     } 
     return jetMatching(jets1, jets2, m_l1jFexLRmatchedKey, m_l1jFexLRJetVarHandleKeys, ctx);
     
   } else if (m_matchType == MatchType::gFexJetRoI) { // perform jet matching for L1 gFexJetRoI container
     SG::ReadHandle<xAOD::gFexJetRoIContainer> jets1(m_gFexJetRoIKey, ctx);
     if (!jets1.isValid() ) {
       ATH_MSG_ERROR("evtStore() does not contain L1 jet Collection with name "<< m_gFexJetRoIKey);
       return StatusCode::FAILURE;
     } 
     return jetMatching(jets1, jets2, m_l1gFexmatchedKey, m_l1gFexJetVarHandleKeys, ctx);
   }
  
   ATH_MSG_ERROR("unsupported type for jet matching targe");
   return StatusCode::FAILURE;
  
 }

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

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

◆ filterPassed()

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

inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

                                                            {
     return execState( ctx ).filterPassed();
   }

◆ finalize()

StatusCode JetMatcherAlg::finalize ( )

override

Definition at line 129 of file JetMatcherAlg.cxx.

                                    {
   ATH_MSG_INFO ("Finalizing " << name());
   return StatusCode::SUCCESS;
 }

◆ GetTLV() [1/5]

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

private

Definition at line 170 of file JetMatcherAlg.cxx.

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

◆ GetTLV() [2/5]

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

private

Definition at line 136 of file JetMatcherAlg.cxx.

                                                                               {
  
   if (m_calibScale == "" ) {
     tlv.SetPtEtaPhiE(jet->pt(),jet->eta(),jet->phi(),jet->e());
   } else { //retrieve fourmomentum at specified calibration scale
     xAOD::JetFourMom_t fourVec;
     bool status = jet->getAttribute<xAOD::JetFourMom_t>( "Jet"+m_calibScale+"Momentum", fourVec );
     if(!status) {
       ATH_MSG_WARNING("evtStore() cannot retrieve JetFourMomentum at " << m_calibScale);
       return StatusCode::FAILURE;
     }
     tlv.SetPtEtaPhiE(fourVec.Pt(),fourVec.Eta(),fourVec.Phi(),fourVec.E());
   }
   return StatusCode::SUCCESS;
 }

◆ GetTLV() [3/5]

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

private

Definition at line 152 of file JetMatcherAlg.cxx.

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

◆ GetTLV() [4/5]

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

private

Definition at line 164 of file JetMatcherAlg.cxx.

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

◆ GetTLV() [5/5]

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

private

Definition at line 158 of file JetMatcherAlg.cxx.

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

◆ initialize()

StatusCode JetMatcherAlg::initialize ( )

override

Definition at line 23 of file JetMatcherAlg.cxx.

                                      {
   /* Initialise ReadHandle keys for the two xAOD jet containers 
      and various L1 xAOD jet containers.
  
      xAOD jet containers are produced by the both hlt and offline
      reconstruction programs. The L1 trigger system produces various
      container types.
  
      The attribute m_jetContainerKey2 must not be initialised to "NONE".
  
      An instance of JetMatcher Alg will work with two containers only.
      However, all ReadHandles must be initialised.
  
  
      
    */
   
   ATH_MSG_INFO(" Initializing " << name());
  
   if ( m_jetContainerKey2.key().empty() ) {
  
     std::string msg = "JetContainerKey2 has not been configured correctly - "
       "has value NONE";
     ATH_MSG_ERROR(msg);
     
     return StatusCode::FAILURE;
   }
       
   int key_count{0};
  
   if (!m_jetContainerKey1.key().empty()) {
     ++key_count;
     m_matchType = MatchType::xAODJet;
     ATH_MSG_INFO("will match xAODJet to xAODJet");
   }
  
   if (!m_l1jetContainerKey1.key().empty()) {
     ++key_count;
     m_matchType = MatchType::JetRoI;
     ATH_MSG_INFO("will match JetRoI (L1)  to xAODJet");
   }
  
   if (!m_jFexSRJetRoIKey.key().empty()) {
     ++key_count;
     m_matchType = MatchType::jFexSRJetRoI;
     ATH_MSG_INFO("will match jFexSRJetRoI (L1)  to xAODJet");
   }
  
   
   if (!m_jFexLRJetRoIKey.key().empty()) {
     ++key_count;
     m_matchType = MatchType::jFexLRJetRoI;
     ATH_MSG_INFO("will match jFexLRJetRoI (L1)  to xAODJet");
   }
  
   
   if (!m_gFexJetRoIKey.key().empty()) {
     ++key_count;
     m_matchType = MatchType::gFexJetRoI;
     ATH_MSG_INFO("will match gFexSRJetRoI (L1)  to xAODJet");
   }
  
   if (key_count != 1) {
     ATH_MSG_ERROR(key_count <<
           " containers requested. This should be exactly 1");
     return StatusCode::FAILURE;
   }
  
   // code was originally written to use m_matchL1 to determine
   // if matching was to be done with the L1 jet container. At that
   // time, there was a  single L1 jet container type.
   // The existence of m_matchL1 has been maintained to allow
   // older configuration code to continue to work.
   //
   bool l1_match =  
     m_matchType == MatchType::JetRoI ||
     m_matchType == MatchType::jFexSRJetRoI ||
     m_matchType == MatchType::jFexLRJetRoI ||
     m_matchType == MatchType::gFexJetRoI;
  
   if (l1_match != m_matchL1) {
     ATH_MSG_ERROR("m_matchL1 is misconfigured");
     return StatusCode::FAILURE;
   }
   
  
   ATH_CHECK( m_jetContainerKey1.initialize( SG::AllowEmpty ) );
   ATH_CHECK( m_jetContainerKey2.initialize( SG::AllowEmpty ) );
   ATH_CHECK( m_l1jetContainerKey1.initialize( SG::AllowEmpty ) );
   ATH_CHECK( m_jFexSRJetRoIKey.initialize( SG::AllowEmpty ) );
   ATH_CHECK( m_jFexLRJetRoIKey.initialize( SG::AllowEmpty ) );
   ATH_CHECK( m_gFexJetRoIKey.initialize( SG::AllowEmpty ) );
  
   ATH_CHECK(set_xAODJet_varHandleKeys());
   ATH_CHECK(set_JetRoI_varHandleKeys());
   ATH_CHECK(set_jFexSRJetRoI_varHandleKeys());
   ATH_CHECK(set_jFexLRJetRoI_varHandleKeys());
   ATH_CHECK(set_gFexJetRoI_varHandleKeys());
  
   ATH_CHECK(initialize_varHandleKeys());
  
   return StatusCode::SUCCESS;
 }

◆ initialize_gFexJetRoI_varHandleKeys()

StatusCode JetMatcherAlg::initialize_gFexJetRoI_varHandleKeys ( bool do_it )

private

Definition at line 568 of file JetMatcherAlg.cxx.

                                                                        {
   for (auto& key : m_l1gFexJetVarHandleKeys) {
     ATH_CHECK(key.get().initialize(do_it));
     ATH_CHECK(m_l1gFexmatchedKey.initialize(do_it));
  }
   return StatusCode::SUCCESS;
 }

◆ initialize_JetRoI_varHandleKeys()

StatusCode JetMatcherAlg::initialize_JetRoI_varHandleKeys ( bool do_it )

private

Definition at line 542 of file JetMatcherAlg.cxx.

                                                                    {
   for (auto& key : m_l1JetVarHandleKeys) {
     ATH_CHECK(key.get().initialize(do_it));
     ATH_CHECK(m_l1matchedKey.initialize(do_it));
   }
   return StatusCode::SUCCESS;
 }

◆ initialize_jFexLRJetRoI_varHandleKeys()

StatusCode JetMatcherAlg::initialize_jFexLRJetRoI_varHandleKeys ( bool do_it )

private

Definition at line 559 of file JetMatcherAlg.cxx.

                                                                          {
   for (auto& key : m_l1jFexLRJetVarHandleKeys) {
     ATH_CHECK(key.get().initialize(do_it));
     ATH_CHECK(m_l1jFexLRmatchedKey.initialize(do_it));
  }
   return StatusCode::SUCCESS;
 }

◆ initialize_jFexSRJetRoI_varHandleKeys()

StatusCode JetMatcherAlg::initialize_jFexSRJetRoI_varHandleKeys ( bool do_it )

private

Definition at line 551 of file JetMatcherAlg.cxx.

                                                                          {
   for (auto& key : m_l1jFexSRJetVarHandleKeys) {
     ATH_CHECK(key.get().initialize(do_it));
     ATH_CHECK(m_l1jFexSRmatchedKey.initialize(do_it));
  }
   return StatusCode::SUCCESS;
 }

◆ initialize_varHandleKeys()

StatusCode JetMatcherAlg::initialize_varHandleKeys ( )

private

Definition at line 494 of file JetMatcherAlg.cxx.

                                                   {
  
   if (m_matchType ==  MatchType::xAODJet) {
     ATH_CHECK(initialize_xAODJet_varHandleKeys(true));
     ATH_CHECK(initialize_JetRoI_varHandleKeys(false));
     ATH_CHECK(initialize_jFexSRJetRoI_varHandleKeys(false));
     ATH_CHECK(initialize_jFexLRJetRoI_varHandleKeys(false));
     ATH_CHECK(initialize_gFexJetRoI_varHandleKeys(false));
   } else if (m_matchType ==  MatchType::JetRoI) {
     ATH_CHECK(initialize_xAODJet_varHandleKeys(false));
     ATH_CHECK(initialize_JetRoI_varHandleKeys(true));
     ATH_CHECK(initialize_jFexSRJetRoI_varHandleKeys(false));
     ATH_CHECK(initialize_jFexLRJetRoI_varHandleKeys(false));
     ATH_CHECK(initialize_gFexJetRoI_varHandleKeys(false));
   } else if (m_matchType ==  MatchType::jFexSRJetRoI) {
     ATH_CHECK(initialize_xAODJet_varHandleKeys(false));
     ATH_CHECK(initialize_JetRoI_varHandleKeys(false));
     ATH_CHECK(initialize_jFexSRJetRoI_varHandleKeys(true));
     ATH_CHECK(initialize_jFexLRJetRoI_varHandleKeys(false));
     ATH_CHECK(initialize_gFexJetRoI_varHandleKeys(false));
   } else if (m_matchType ==  MatchType::jFexLRJetRoI) {
     ATH_CHECK(initialize_xAODJet_varHandleKeys(false));
     ATH_CHECK(initialize_JetRoI_varHandleKeys(false));
     ATH_CHECK(initialize_jFexSRJetRoI_varHandleKeys(false));
     ATH_CHECK(initialize_jFexLRJetRoI_varHandleKeys(true));
     ATH_CHECK(initialize_gFexJetRoI_varHandleKeys(false));
   } else if (m_matchType ==  MatchType::gFexJetRoI) {
     ATH_CHECK(initialize_xAODJet_varHandleKeys(false));
     ATH_CHECK(initialize_JetRoI_varHandleKeys(false));
     ATH_CHECK(initialize_jFexSRJetRoI_varHandleKeys(false));
     ATH_CHECK(initialize_jFexLRJetRoI_varHandleKeys(false));
     ATH_CHECK(initialize_gFexJetRoI_varHandleKeys(true));
   } else {
     ATH_MSG_FATAL("uknown match type");
     return  StatusCode::FAILURE;
   }
   return StatusCode::SUCCESS;
 }

◆ initialize_xAODJet_varHandleKeys()

StatusCode JetMatcherAlg::initialize_xAODJet_varHandleKeys ( bool do_it )

private

Definition at line 533 of file JetMatcherAlg.cxx.

                                                                     {
   for (auto& key : m_jetVarHandleKeys) {
     ATH_CHECK(key.get().initialize(do_it));
     ATH_CHECK(m_matchedKey.initialize(do_it));
     
   }
   return StatusCode::SUCCESS;
 }

◆ 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

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in Simulation::BeamEffectsAlg, InDet::SiTrackerSpacePointFinder, InDet::SCT_Clusterization, InDet::SiSPSeededTrackFinder, SCTRawDataProvider, InDet::GNNSeedingTrackMaker, SCT_PrepDataToxAOD, RoIBResultToxAOD, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, InDet::SiSPGNNTrackMaker, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, ITkStripCablingAlg, SCTEventFlagWriter, SCT_ConditionsSummaryTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_TdaqEnabledTestAlg, SCT_SiliconConditionsTestAlg, SCTSiLorentzAngleTestAlg, SCT_ByteStreamErrorsTestAlg, SCT_ConditionsParameterTestAlg, SCT_FlaggedConditionTestAlg, SCT_StripVetoTestAlg, SCT_RawDataToxAOD, and SCTSiPropertiesTestAlg.

Definition at line 44 of file AthReentrantAlgorithm.cxx.

 {
   // Reentrant algorithms are clonable.
   return true;
 }

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

                                               {
  
   SG::WriteDecorHandle<DataVector<T>, double> ptDiffHandle(varHandleKeys[0].get(), ctx);
   SG::WriteDecorHandle<DataVector<T>, double> energyDiffHandle(varHandleKeys[1].get(), ctx);
   SG::WriteDecorHandle<DataVector<T>, double> massDiffHandle(varHandleKeys[2].get(), ctx);
   SG::WriteDecorHandle<DataVector<T>, double> ptRespHandle(varHandleKeys[3].get(), ctx);
   SG::WriteDecorHandle<DataVector<T>, double> energyRespHandle(varHandleKeys[4].get(), ctx);
   SG::WriteDecorHandle<DataVector<T>, double> massRespHandle(varHandleKeys[5].get(), ctx);
   SG::WriteDecorHandle<DataVector<T>, double> ptRefHandle(varHandleKeys[6].get(), ctx);
   SG::WriteDecorHandle<DataVector<T>, double> etaRefHandle(varHandleKeys[7].get(), ctx);
   SG::WriteDecorHandle<DataVector<T>, char> matchedHandle(matchedHandleKey, ctx);
  
   std::vector<int> matchedIndices; //remembers which jets in jets2 are already matched, so they are not considered in future matching
   // Loop over first jet collection
   for (const T *j1 : *jets1) {
     TLorentzVector tlvjet1 = TLorentzVector(); 
     StatusCode status = GetTLV(j1, tlvjet1);
     if (!status) {
         ATH_MSG_WARNING("Could not retrieve full jet 4-momentum. Skipping jet matching.");
         return StatusCode::SUCCESS;
     }
     bool j1matched = false;
     double ptDiff  = -999., energyDiff = -999., massDiff = -999., ptResp = -999., energyResp = -999., massResp = -999., ptRef = -999., etaRef = -999.;
     if (tlvjet1.Pt() < 10000.) { // minimum pT cut of 10 GeV for jet matching
       matchedHandle(*j1)    = j1matched; // set default values for match decorations and move to next jet
       ptDiffHandle(*j1)     = ptDiff;
       energyDiffHandle(*j1) = energyDiff;
       massDiffHandle(*j1)   = massDiff;
       ptRespHandle(*j1)     = ptResp;
       energyRespHandle(*j1) = energyResp;
       massRespHandle(*j1)   = massResp;
       ptRefHandle(*j1)      = ptRef;
       etaRefHandle(*j1)     = etaRef;
       continue;
     }
     double Rmin = 1E8;
     int jetIndex = 0, jetMatchIndex = 0;
     // Loop over second jet collection
     for(const xAOD::Jet* j2 : *jets2){
       if (j2->pt() < 10000.) { jetIndex++; continue; } // minimum pT cut of 10 GeV for jet matching
       bool alreadymatched = false;
       for (int jetIndexIterator : matchedIndices) { //Loop over indices of already matched jets to skip them
         if (jetIndex == jetIndexIterator) { alreadymatched = true; break; }
       }
       if (alreadymatched) { jetIndex++; continue; }
       TLorentzVector tlvjet2 = TLorentzVector();
       tlvjet2.SetPtEtaPhiE(j2->pt(),j2->eta(),j2->phi(),j2->e());
       // calculate DeltaR(jet1,jet2)
       double dr = tlvjet1.DeltaR(tlvjet2);
       if(dr<m_Rmatch && dr<Rmin){ // decorate matching jets
     j1matched     = true;
     ptDiff        = tlvjet1.Pt()-tlvjet2.Pt();
         energyDiff    = tlvjet1.E()-tlvjet2.E();
         massDiff      = tlvjet1.M()-tlvjet2.M();
         ptResp        = ptDiff/tlvjet2.Pt();
         if (tlvjet2.E() == 0.) energyResp = -999.;
         else energyResp = energyDiff/tlvjet2.E();
         if (tlvjet2.M() == 0.) massResp = -999.;
         else massResp = massDiff/tlvjet2.M();
         ptRef         = tlvjet2.Pt(); //second jet collection (=offline) is taken for reference pT and eta
         etaRef        = tlvjet2.Eta();
     Rmin          = dr;
         jetMatchIndex = jetIndex;
       }
       jetIndex++;
     }//End Loop over second jet collection
     matchedHandle(*j1)    = j1matched;
     ptDiffHandle(*j1)     = ptDiff;
     energyDiffHandle(*j1) = energyDiff;
     massDiffHandle(*j1)   = massDiff;
     ptRespHandle(*j1)     = ptResp;
     energyRespHandle(*j1) = energyResp;
     massRespHandle(*j1)   = massResp;
     ptRefHandle(*j1)      = ptRef;
     etaRefHandle(*j1)     = etaRef;
     if (j1matched) matchedIndices.push_back(jetMatchIndex);
   }
   return StatusCode::SUCCESS;
  
 }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

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

   {
     h.renounce();
     PBASE::renounce (h);
   }

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

                                                           {
     handlesArray.renounce();
   }

◆ set_gFexJetRoI_varHandleKeys()

StatusCode JetMatcherAlg::set_gFexJetRoI_varHandleKeys ( )

private

Definition at line 462 of file JetMatcherAlg.cxx.

                                                        {
  
   if (m_matchType == MatchType::gFexJetRoI) {
  
   std::string keyAppendix = m_jetContainerKey2.key();
   std::string prepend = m_gFexJetRoIKey.key();
   
   m_l1gFexptDiffKey = prepend+".ptdiff_" + keyAppendix;
   m_l1gFexenergyDiffKey = prepend+".energydiff_" + keyAppendix;
   m_l1gFexmassDiffKey = prepend+".massdiff_" + keyAppendix;
   m_l1gFexptRespKey = prepend+".ptresp_" + keyAppendix;
   m_l1gFexenergyRespKey = prepend+".energyresp_" + keyAppendix;
   m_l1gFexmassRespKey = prepend+".massresp_" + keyAppendix;
   m_l1gFexptRefKey = prepend+".ptRef_" + keyAppendix;
   m_l1gFexetaRefKey = prepend+".etaRef_" + keyAppendix;
   m_l1gFexmatchedKey = prepend+".matched_" + keyAppendix;
   }
   
   
   m_l1gFexJetVarHandleKeys = {
     m_l1gFexptDiffKey,
     m_l1gFexenergyDiffKey,
     m_l1gFexmassDiffKey,
     m_l1gFexptRespKey,
     m_l1gFexenergyRespKey,
     m_l1gFexmassRespKey,
     m_l1gFexptRefKey,
     m_l1gFexetaRefKey};
   
   return StatusCode::SUCCESS;
 }

◆ set_JetRoI_varHandleKeys()

StatusCode JetMatcherAlg::set_JetRoI_varHandleKeys ( )

private

Definition at line 364 of file JetMatcherAlg.cxx.

                                                    {
  
  
   if (m_matchType == MatchType::JetRoI) {
     std::string keyAppendix{m_jetContainerKey2.key()};
     std::string prepend{m_l1jetContainerKey1.key()};
     
     m_l1ptDiffKey = prepend+".ptdiff_" + keyAppendix;
     m_l1energyDiffKey = prepend+".energydiff_" + keyAppendix;
     m_l1massDiffKey = prepend+".massdiff_" + keyAppendix;
     m_l1ptRespKey = prepend+".ptresp_" + keyAppendix;
     m_l1energyRespKey = prepend+".energyresp_" + keyAppendix;
     m_l1massRespKey = prepend+".massresp_" + keyAppendix;
     m_l1ptRefKey = prepend+".ptRef_" + keyAppendix;
     m_l1etaRefKey = prepend+".etaRef_" + keyAppendix;
     m_l1matchedKey = prepend+".matched_" + keyAppendix;
   }
    
   m_l1JetVarHandleKeys = {
     m_l1ptDiffKey,
     m_l1energyDiffKey,
     m_l1massDiffKey,
     m_l1ptRespKey,
     m_l1energyRespKey,
     m_l1massRespKey,
     m_l1ptRefKey,
     m_l1etaRefKey
   };
   
   return StatusCode::SUCCESS;
  
 }

◆ set_jFexLRJetRoI_varHandleKeys()

StatusCode JetMatcherAlg::set_jFexLRJetRoI_varHandleKeys ( )

private

Definition at line 430 of file JetMatcherAlg.cxx.

                                                          {
  
   if (m_matchType == MatchType::jFexLRJetRoI) {
  
   std::string keyAppendix = m_jetContainerKey2.key();
   std::string prepend = m_jFexLRJetRoIKey.key();
   
   m_l1jFexLRptDiffKey = prepend+".ptdiff_" + keyAppendix;
   m_l1jFexLRenergyDiffKey = prepend+".energydiff_" + keyAppendix;
   m_l1jFexLRmassDiffKey = prepend+".massdiff_" + keyAppendix;
   m_l1jFexLRptRespKey = prepend+".ptresp_" + keyAppendix;
   m_l1jFexLRenergyRespKey = prepend+".energyresp_" + keyAppendix;
   m_l1jFexLRmassRespKey = prepend+".massresp_" + keyAppendix;
   m_l1jFexLRptRefKey = prepend+".ptRef_" + keyAppendix;
   m_l1jFexLRetaRefKey = prepend+".etaRef_" + keyAppendix;
   m_l1jFexLRmatchedKey = prepend+".matched_" + keyAppendix;
   }
   
   
   m_l1jFexLRJetVarHandleKeys = {
     m_l1jFexLRptDiffKey,
     m_l1jFexLRenergyDiffKey,
     m_l1jFexLRmassDiffKey,
     m_l1jFexLRptRespKey,
     m_l1jFexLRenergyRespKey,
     m_l1jFexLRmassRespKey,
     m_l1jFexLRptRefKey,
     m_l1jFexLRetaRefKey};
   
   return StatusCode::SUCCESS;
 }

◆ set_jFexSRJetRoI_varHandleKeys()

StatusCode JetMatcherAlg::set_jFexSRJetRoI_varHandleKeys ( )

private

Definition at line 398 of file JetMatcherAlg.cxx.

                                                          {
  
   if (m_matchType == MatchType::jFexSRJetRoI) {
  
   std::string keyAppendix = m_jetContainerKey2.key();
   std::string prepend = m_jFexSRJetRoIKey.key();
   
   m_l1jFexSRptDiffKey = prepend+".ptdiff_" + keyAppendix;
   m_l1jFexSRenergyDiffKey = prepend+".energydiff_" + keyAppendix;
   m_l1jFexSRmassDiffKey = prepend+".massdiff_" + keyAppendix;
   m_l1jFexSRptRespKey = prepend+".ptresp_" + keyAppendix;
   m_l1jFexSRenergyRespKey = prepend+".energyresp_" + keyAppendix;
   m_l1jFexSRmassRespKey = prepend+".massresp_" + keyAppendix;
   m_l1jFexSRptRefKey = prepend+".ptRef_" + keyAppendix;
   m_l1jFexSRetaRefKey = prepend+".etaRef_" + keyAppendix;
   m_l1jFexSRmatchedKey = prepend+".matched_" + keyAppendix;
   }
   
   
   m_l1jFexSRJetVarHandleKeys = {
     m_l1jFexSRptDiffKey,
     m_l1jFexSRenergyDiffKey,
     m_l1jFexSRmassDiffKey,
     m_l1jFexSRptRespKey,
     m_l1jFexSRenergyRespKey,
     m_l1jFexSRmassRespKey,
     m_l1jFexSRptRefKey,
     m_l1jFexSRetaRefKey};
   
   return StatusCode::SUCCESS;
 }

◆ set_xAODJet_varHandleKeys()

StatusCode JetMatcherAlg::set_xAODJet_varHandleKeys ( )

private

Definition at line 326 of file JetMatcherAlg.cxx.

                                                     {
  
  
   if (m_matchType == MatchType::xAODJet) {
     std::string prepend{m_jetContainerKey1.key()};
     std::string keyAppendix{m_jetContainerKey2.key()};
     if (m_calibScale != "") {
       keyAppendix = m_calibScale + "_" + m_jetContainerKey2.key();
     }
  
     m_ptDiffKey = prepend+".ptdiff_" + keyAppendix;
     m_energyDiffKey = prepend+".energydiff_" + keyAppendix;
     m_massDiffKey = prepend+".massdiff_" + keyAppendix;
     m_ptRespKey = prepend+".ptresp_" + keyAppendix;
     m_energyRespKey = prepend+".energyresp_" + keyAppendix;
     m_massRespKey = prepend+".massresp_" + keyAppendix;
     m_ptRefKey = prepend+".ptRef_" + keyAppendix;
     m_etaRefKey = prepend+".etaRef_" + keyAppendix;
     m_matchedKey = prepend+".matched_" + keyAppendix;
   }
  
   m_jetVarHandleKeys = {
     m_ptDiffKey,
     m_energyDiffKey,
     m_massDiffKey,
     m_ptRespKey,
     m_energyRespKey,
     m_massRespKey,
     m_ptRefKey,
     m_etaRefKey
   };
   
  
   return StatusCode::SUCCESS;
  
 }

◆ setFilterPassed()

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

inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

                                                                             {
     execState( ctx ).setFilterPassed( state );
   }

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

 {
   return Gaudi::Algorithm::sysExecute (ctx);
 }

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

                                                 {
   StatusCode sc=AthCommonDataStore<AthCommonMsg<Gaudi::Algorithm>>::sysInitialize();
  
   if (sc.isFailure()) {
     return sc;
   }
   
   ServiceHandle<ICondSvc> cs("CondSvc",name());
   for (auto h : outputHandles()) {
     if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
       // do this inside the loop so we don't create the CondSvc until needed
       if ( cs.retrieve().isFailure() ) {
         ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
         return StatusCode::SUCCESS;
       }      
       if (cs->regHandle(this,*h).isFailure()) {
         sc = StatusCode::FAILURE;
         ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                       << " with CondSvc");
       }
     }
   }
   return sc;  
 }

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

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

Member Data Documentation

◆ m_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:

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Member Enumeration Documentation

◆ MatchType

Constructor & Destructor Documentation

◆ JetMatcherAlg()

Member Function Documentation

◆ AthReentrantAlgorithm()

◆ cardinality()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ filterPassed()

◆ finalize()

◆ GetTLV() [1/5]

◆ GetTLV() [2/5]

◆ GetTLV() [3/5]

◆ GetTLV() [4/5]

◆ GetTLV() [5/5]

◆ initialize()

◆ initialize_gFexJetRoI_varHandleKeys()

◆ initialize_JetRoI_varHandleKeys()

◆ initialize_jFexLRJetRoI_varHandleKeys()

◆ initialize_jFexSRJetRoI_varHandleKeys()

◆ initialize_varHandleKeys()

◆ initialize_xAODJet_varHandleKeys()

◆ inputHandles()

◆ isClonable()

◆ jetMatching()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ set_gFexJetRoI_varHandleKeys()

◆ set_JetRoI_varHandleKeys()

◆ set_jFexLRJetRoI_varHandleKeys()

◆ set_jFexSRJetRoI_varHandleKeys()

◆ set_xAODJet_varHandleKeys()

◆ setFilterPassed()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_calibScale

◆ m_detStore

◆ m_energyDiffKey

◆ m_energyRespKey

◆ m_etaRefKey

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_gFexJetRoIKey

◆ m_jetContainerKey1

◆ m_jetContainerKey2

◆ m_jetVarHandleKeys

◆ m_jFexLRJetRoIKey

◆ m_jFexSRJetRoIKey

◆ m_l1energyDiffKey

◆ m_l1energyRespKey