#include <JetMatcherAlg.h>

Inheritance 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
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
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`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
enum class	MatchType { undeclared , xAODJet , JetRoI , jFexSRJetRoI , jFexLRJetRoI , 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, const SG::WriteDecorHandleKey< DataVector< T > > &matchedHandleKey, const std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< DataVector< T > > > > &varHandleKeys, const EventContext &ctx) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 27 of file Reconstruction/Jet/JetMonitoring/JetMonitoring/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 class JetMatcherAlg::MatchType

strongprivate

Enumerator
undeclared
xAODJet
JetRoI
jFexSRJetRoI
jFexLRJetRoI
gFexJetRoI

Definition at line 57 of file Reconstruction/Jet/JetMonitoring/JetMonitoring/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 Reconstruction/Jet/JetMonitoring/src/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

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleKeyType &	)

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

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; }

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

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

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

override

Definition at line 269 of file Reconstruction/Jet/JetMonitoring/src/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(std::move(jets1), std::move(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(std::move(jets1), std::move(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(std::move(jets1), std::move(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(std::move(jets1), std::move(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(std::move(jets1), std::move(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 & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.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 BaseAlg::extraOutputDeps();
}

◆ filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

◆ finalize()

StatusCode JetMatcherAlg::finalize ( )

override

Definition at line 129 of file Reconstruction/Jet/JetMonitoring/src/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 Reconstruction/Jet/JetMonitoring/src/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 Reconstruction/Jet/JetMonitoring/src/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 Reconstruction/Jet/JetMonitoring/src/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 Reconstruction/Jet/JetMonitoring/src/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 Reconstruction/Jet/JetMonitoring/src/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 Reconstruction/Jet/JetMonitoring/src/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 Reconstruction/Jet/JetMonitoring/src/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 Reconstruction/Jet/JetMonitoring/src/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 Reconstruction/Jet/JetMonitoring/src/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 Reconstruction/Jet/JetMonitoring/src/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 Reconstruction/Jet/JetMonitoring/src/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 Reconstruction/Jet/JetMonitoring/src/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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

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

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

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

◆ jetMatching()

template<typename T>

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

private

Definition at line 181 of file Reconstruction/Jet/JetMonitoring/src/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()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ 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 Reconstruction/Jet/JetMonitoring/src/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 Reconstruction/Jet/JetMonitoring/src/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 Reconstruction/Jet/JetMonitoring/src/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 Reconstruction/Jet/JetMonitoring/src/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 Reconstruction/Jet/JetMonitoring/src/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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed	(	bool	state,
		const EventContext &	ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

45{this, "JetCalibScale", "", "Calibration Scale at which to evaluate jet pT"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

74{this, "energydiff", "energydiff", "SG key for output energy difference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

77{this, "energyresp", "energyresp", "SG key for output energy response decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

80{this, "etaRef", "etaRef", "SG key for output eta reference decoration"};

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

privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_gFexJetRoIKey

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

private

Definition at line 69 of file Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

◆ m_jetContainerKey1

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

private

Definition at line 53 of file Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

◆ m_jetContainerKey2

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

private

Definition at line 54 of file Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

◆ m_jetVarHandleKeys

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

private

Definition at line 82 of file Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

◆ m_jFexLRJetRoIKey

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

private

Definition at line 68 of file Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

◆ m_jFexSRJetRoIKey

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

private

Definition at line 67 of file Reconstruction/Jet/JetMonitoring/JetMonitoring/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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

86{this, "l1energydiff", "l1energydiff", "SG key for output energy difference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

89{this, "l1energyresp", "l1energyresp", "SG key for output energy response decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

92{this, "l1etaRef", "l1etaRef", "SG key for output eta reference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

122{this, "l1gFexenergydiff", "l1gFexenergydiff", "SG key for output energy difference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

125{this, "l1gFexenergyresp", "l1gFexenergyresp", "SG key for output energy response decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

128{this, "l1gFexetaRef", "l1gFexetaRef", "SG key for output eta reference decoration"};

◆ m_l1gFexJetVarHandleKeys

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

private

Definition at line 129 of file Reconstruction/Jet/JetMonitoring/JetMonitoring/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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

123{this, "l1gFexmassdiff", "l1gFexmassdiff", "SG key for output mass difference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

126{this, "l1gFexmassresp", "l1gFexmassresp", "SG key for output mass response decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

120{this, "l1gFexmatched", "l1gFexmatched", "SG key for output matched decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

121{this, "l1gFexptdiff", "l1gFexptdiff", "SG key for output pt difference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

127{this, "l1gFexptRef", "l1gFexptRef", "SG key for output pt reference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

124{this, "l1gFexptresp", "l1gFexptresp", "SG key for output pt response decoration"};

◆ m_l1jetContainerKey1

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

private

Definition at line 66 of file Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

◆ m_l1JetVarHandleKeys

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

private

Definition at line 93 of file Reconstruction/Jet/JetMonitoring/JetMonitoring/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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

110{this, "l1jFexLRenergydiff", "l1jFexLRenergydiff", "SG key for output energy difference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

113{this, "l1jFexLRenergyresp", "l1jFexLRenergyresp", "SG key for output energy response decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

116{this, "l1jFexLRetaRef", "l1jFexLRetaRef", "SG key for output eta reference decoration"};

◆ m_l1jFexLRJetVarHandleKeys

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

private

Definition at line 117 of file Reconstruction/Jet/JetMonitoring/JetMonitoring/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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

111{this, "l1jFexLRmassdiff", "l1jFexLRmassdiff", "SG key for output mass difference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

114{this, "l1jFexLRmassresp", "l1jFexLRmassresp", "SG key for output mass response decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

108{this, "l1jFexLRmatched", "l1jFexLRmatched", "SG key for output matched decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

109{this, "l1jFexLRptdiff", "l1jFexLRptdiff", "SG key for output pt difference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

115{this, "l1jFexLRptRef", "l1jFexLRptRef", "SG key for output pt reference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

112{this, "l1jFexLRptresp", "l1jFexLRptresp", "SG key for output pt response decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

98{this, "l1jFexSRenergydiff", "l1jFexSRenergydiff", "SG key for output energy difference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

101{this, "l1jFexSRenergyresp", "l1jFexSRenergyresp", "SG key for output energy response decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

104{this, "l1jFexSRetaRef", "l1jFexSRetaRef", "SG key for output eta reference decoration"};

◆ m_l1jFexSRJetVarHandleKeys

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

private

Definition at line 105 of file Reconstruction/Jet/JetMonitoring/JetMonitoring/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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

99{this, "l1jFexSRmassdiff", "l1jFexSRmassdiff", "SG key for output mass difference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

102{this, "l1jFexSRmassresp", "l1jFexSRmassresp", "SG key for output mass response decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

96{this, "l1jFexSRmatched", "l1jFexSRmatched", "SG key for output matched decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

97{this, "l1jFexSRptdiff", "l1jFexSRptdiff", "SG key for output pt difference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

103{this, "l1jFexSRptRef", "l1jFexSRptRef", "SG key for output pt reference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

100{this, "l1jFexSRptresp", "l1jFexSRptresp", "SG key for output pt response decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

87{this, "l1massdiff", "l1massdiff", "SG key for output mass difference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

90{this, "l1massresp", "l1massresp", "SG key for output mass response decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

84{this, "l1matched", "l1matched", "SG key for output matched decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

85{this, "l1ptdiff", "l1ptdiff", "SG key for output pt difference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

91{this, "l1ptRef", "l1ptRef", "SG key for output pt reference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

88{this, "l1ptresp", "l1ptresp", "SG key for output pt response decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

75{this, "massdiff", "massdiff", "SG key for output mass difference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

78{this, "massresp", "massresp", "SG key for output mass response decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

72{this, "matched", "matched", "SG key for output matched decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

50{this, "MatchL1", false, "Whether to match an L1 jet collection or actual online/offline jets"};

◆ m_matchType

MatchType JetMatcherAlg::m_matchType {MatchType::undeclared}

private

Definition at line 63 of file Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

63{MatchType::undeclared};

JetMatcherAlg::MatchType::undeclared

@ undeclared

Definition Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h:58

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

73{this, "ptdiff", "ptdiff", "SG key for output pt difference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

79{this, "ptRef", "ptRef", "SG key for output pt reference decoration"};

◆ 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 Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

76{this, "ptresp", "ptresp", "SG key for output pt response decoration"};

◆ m_Rmatch

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

private

Definition at line 43 of file Reconstruction/Jet/JetMonitoring/JetMonitoring/JetMatcherAlg.h.

43{this, "Rmatch", 0.3, "R matching"};

◆ 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

◆ cardinality()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ 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()

◆ 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

◆ m_l1etaRefKey

◆ m_l1gFexenergyDiffKey

◆ m_l1gFexenergyRespKey

◆ m_l1gFexetaRefKey

◆ m_l1gFexJetVarHandleKeys

◆ m_l1gFexmassDiffKey

◆ m_l1gFexmassRespKey

◆ m_l1gFexmatchedKey

◆ m_l1gFexptDiffKey

◆ m_l1gFexptRefKey

◆ m_l1gFexptRespKey