met::ColumnarMETMaker Class Reference

#include <ColumnarMETMaker.h>

Inheritance diagram for met::ColumnarMETMaker:

Public Member Functions
	ColumnarMETMaker (const std::string &name)
	Constructor with parameters:
virtual	~ColumnarMETMaker ()
	Destructor:
virtual StatusCode	initialize () override final
	Dummy implementation of the initialisation function.
virtual StatusCode	rebuildMET (const std::string &metKey, xAOD::Type::ObjectType metType, xAOD::MissingETContainer *metCont, const xAOD::IParticleContainer *collection, xAOD::MissingETAssociationHelper &helper, MissingETBase::UsageHandler::Policy objScale) const override final
StatusCode	rebuildMET (const std::string &metKey, xAOD::Type::ObjectType metType, columnar::MutableMetRange metCont, columnar::ParticleRange collection, columnar::MetAssociationHelper<> helper, MissingETBase::UsageHandler::Policy objScale) const
virtual StatusCode	rebuildMET (xAOD::MissingET *met, const xAOD::IParticleContainer *collection, xAOD::MissingETAssociationHelper &helper, MissingETBase::UsageHandler::Policy objScale) const override final
StatusCode	rebuildMET (columnar::MutableMetId met, columnar::ParticleRange collection, columnar::MetAssociationHelper<> helper, MissingETBase::UsageHandler::Policy objScale) const
virtual StatusCode	rebuildMET (xAOD::MissingET *met, const xAOD::IParticleContainer *collection, xAOD::MissingETAssociationHelper &helper, MissingETBase::UsageHandler::Policy p, bool removeOverlap, MissingETBase::UsageHandler::Policy objScale) const override final
StatusCode	rebuildMET (columnar::MutableMetId met, columnar::ParticleRange collection, columnar::MetAssociationHelper<> helper, MissingETBase::UsageHandler::Policy p, bool removeOverlap, MissingETBase::UsageHandler::Policy objScale) const
virtual StatusCode	rebuildJetMET (const std::string &metJetKey, const std::string &softClusKey, const std::string &softTrkKey, xAOD::MissingETContainer *metCont, const xAOD::JetContainer *jets, const xAOD::MissingETContainer *metCoreCont, xAOD::MissingETAssociationHelper &helper, bool doJetJVT) const override final
StatusCode	rebuildJetMET (const std::string &metJetKey, const std::string &softClusKey, const std::string &softTrkKey, columnar::MutableMetRange metCont, columnar::JetRange jets, columnar::Met1Range metCoreCont, columnar::MetAssociationHelper<> helper, bool doJetJVT) const
virtual StatusCode	rebuildJetMET (const std::string &metJetKey, const std::string &metSoftKey, xAOD::MissingETContainer *metCont, const xAOD::JetContainer *jets, const xAOD::MissingETContainer *metCoreCont, xAOD::MissingETAssociationHelper &helper, bool doJetJVT) const override final
StatusCode	rebuildJetMET (const std::string &metJetKey, const std::string &metSoftKey, columnar::MutableMetRange metCont, columnar::JetRange jets, columnar::Met1Range metCoreCont, columnar::MetAssociationHelper<> helper, bool doJetJVT) const
virtual StatusCode	rebuildJetMET (xAOD::MissingET *metJet, const xAOD::JetContainer *jets, xAOD::MissingETAssociationHelper &helper, xAOD::MissingET *metSoftClus, const xAOD::MissingET *coreSoftClus, xAOD::MissingET *metSoftTrk, const xAOD::MissingET *coreSoftTrk, bool doJetJVT, bool tracksForHardJets=false, std::vector< const xAOD::IParticle * > *softConst=0) const override final
StatusCode	rebuildJetMET (columnar::MutableMetId metJet, columnar::MutableMetRange metCont, columnar::JetRange jets, columnar::MetAssociationHelper<> helper, columnar::OptMutableMetId metSoftClus, columnar::OptMet1Id coreSoftClus, columnar::OptMutableMetId metSoftTrk, columnar::OptMet1Id coreSoftTrk, bool doJetJVT, bool tracksForHardJets=false, std::vector< const xAOD::IParticle * > *softConst=0) const
virtual StatusCode	rebuildTrackMET (const std::string &metJetKey, const std::string &softTrkKey, xAOD::MissingETContainer *metCont, const xAOD::JetContainer *jets, const xAOD::MissingETContainer *metCoreCont, xAOD::MissingETAssociationHelper &helper, bool doJetJVT) const override final
StatusCode	rebuildTrackMET (const std::string &metJetKey, const std::string &softTrkKey, columnar::MutableMetRange metCont, columnar::JetRange jets, columnar::Met1Range metCoreCont, columnar::MetAssociationHelper<> helper, bool doJetJVT) const
virtual StatusCode	rebuildTrackMET (xAOD::MissingET *metJet, const xAOD::JetContainer *jets, xAOD::MissingETAssociationHelper &helper, xAOD::MissingET *metSoftTrk, const xAOD::MissingET *coreSoftTrk, bool doJetJVT) const override final
StatusCode	rebuildTrackMET (columnar::MutableMetId metJet, columnar::MutableMetRange metCont, columnar::JetRange jets, columnar::MetAssociationHelper<> helper, columnar::MutableMetId metSoftTrk, columnar::Met1Id coreSoftTrk, bool doJetJVT) const
virtual StatusCode	markInvisible (const xAOD::IParticleContainer *collection, xAOD::MissingETAssociationHelper &helper, xAOD::MissingETContainer *metCont) const override final
StatusCode	markInvisible (columnar::ParticleRange collection, columnar::MetAssociationHelper<> helper, columnar::MutableMetRange metCont) const
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
virtual StatusCode	evaluateNNMET (const std::string &, xAOD::MissingETContainer *) const
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

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
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	acceptTrack (const xAOD::TrackParticle *trk, const xAOD::Vertex *vx) const
const xAOD::Vertex *	getPV () const
	ColumnarMETMaker ()
	Default constructor:
void	callEvents (columnar::EventContextRange events) const override
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< xAOD::VertexContainer >	m_PVkey
float	m_missObjWarningPtThreshold
bool	m_jetCorrectPhi {}
double	m_jetMinEfrac {}
double	m_jetMinWeightedPt {}
std::string	m_jetConstitScaleMom
std::string	m_jetJvtMomentName
std::string	m_jetRejectionDec
double	m_CenJetPtCut {}
double	m_FwdJetPtCut {}
double	m_JvtCut {}
double	m_JvtPtMax {}
double	m_JetEtaMax {}
double	m_JetEtaForw {}
std::string	m_jetSelection
std::string	m_JvtWP
double	m_customCenJetPtCut {}
double	m_customFwdJetPtCut {}
double	m_customJvtPtMax {}
std::string	m_customJvtWP
bool	m_doPFlow {}
bool	m_doSoftTruth {}
bool	m_doConstJet {}
bool	m_useGhostMuons {}
bool	m_doRemoveMuonJets {}
bool	m_doRemoveElecTrks {}
bool	m_doRemoveElecTrksEM {}
bool	m_doSetMuonJetEMScale {}
bool	m_skipSystematicJetSelection {}
bool	m_muEloss {}
bool	m_orCaloTaggedMuon {}
bool	m_greedyPhotons {}
bool	m_veryGreedyPhotons {}
int	m_jetTrkNMuOlap {}
double	m_jetWidthMuOlap {}
double	m_jetPsEMuOlap {}
double	m_jetEmfMuOlap {}
double	m_jetTrkPtMuPt {}
double	m_muIDPTJetPtRatioMuOlap {}
ToolHandle< InDet::IInDetTrackSelectionTool >	m_trkseltool
ToolHandle< IAsgSelectionTool >	m_JvtTool
SG::ReadHandleKey< xAOD::JetContainer >	m_jetContainer {this, "JetContainer", "", "Name of input jet container (required if JVT decisions computed by internal tool)"}
columnar::MutableMetAccessor< columnar::ObjectColumn >	m_outputMetHandle {*this, "OutputMET"}
columnar::Met1Accessor< columnar::ObjectColumn >	m_inputMetHandle {*this, "METCore", {.addMTDependency=true}}
columnar::ColumnAccessor< columnar::ContainerId::metAssociation, columnar::ObjectColumn >	m_metAssocHandle {*this, "MetAssoc", {.addMTDependency=true}}
columnar::ParticleAccessor< columnar::ObjectColumn >	m_particlesHandle {*this, "Particles"}
columnar::JetAccessor< columnar::ObjectColumn >	m_jetsHandle {*this, "Jets"}
columnar::ElectronAccessor< columnar::ObjectColumn >	m_electronsHandle {*this, "Electrons"}
columnar::PhotonAccessor< columnar::ObjectColumn >	m_photonsHandle {*this, "Photons"}
columnar::MuonAccessor< columnar::ObjectColumn >	m_muonsHandle {*this, "Muons"}
columnar::MutableMetAccessor< std::string >	m_outputMetNameAcc {*this, "name"}
columnar::MetHelpers::MapLookupAccessor< columnar::ContainerId::mutableMet >	m_outputMetMapAcc {*this}
columnar::MetHelpers::MetMomentumAccessors< columnar::ContainerId::mutableMet >	m_outputMetMomAcc {*this}
columnar::Met1Accessor< std::string >	m_inputMetNameAcc {*this, "name"}
columnar::MetHelpers::MapLookupAccessor< columnar::ContainerId::met1 >	m_inputMetMapAcc {*this}
columnar::MetHelpers::MetMomentumAccessors< columnar::ContainerId::met1 >	m_inputMetMomAcc {*this}
columnar::Met1Accessor< MissingETBase::Types::bitmask_t >	m_inputMetSourceAcc {*this, "source"}
columnar::MetAssocationAccessors	m_assocAcc {*this}
columnar::MetHelpers::InputMomentumAccessors	m_inputMomAcc {*this}
Gaudi::Property< std::string >	m_inputPreselectionName {this, "inputPreselection", ""}
std::optional< columnar::ParticleAccessor< char > >	m_inputPreselectionAcc
columnar::ParticleAccessor< columnar::RetypeColumn< xAOD::Muon::MuonType, std::uint16_t > >	m_inputMuonTypeAcc {*this, "muonType", {.isOptional = true}}
columnar::MetHelpers::ObjectTypeAccessor< columnar::ContainerId::particle >	m_inputObjTypeAcc {*this, "objectType"}
columnar::MetHelpers::ObjectWeightDecorator	m_outputMetWeightDecRegular {*this, "", true}
columnar::MetHelpers::InputMomentumAccessors< columnar::ContainerId::jet >	m_jetMomAcc {*this}
columnar::JetAccessor< float >	m_acc_emf {*this, "EMFrac"}
columnar::JetAccessor< float >	m_acc_psf {*this, "PSFrac"}
columnar::JetAccessor< float >	m_acc_width {*this, "Width"}
columnar::JetAccessor< std::vector< int > >	m_acc_trkN {*this, "NumTrkPt500"}
columnar::JetAccessor< std::vector< float > >	m_acc_trksumpt {*this, "SumPtTrkPt500"}
columnar::JetAccessor< std::vector< float > >	m_acc_sampleE {*this, "EnergyPerSampling"}
std::optional< columnar::MetHelpers::InputMomentumAccessors< columnar::ContainerId::jet > >	m_jetConstitScaleMomAcc
std::optional< columnar::MetHelpers::InputMomentumAccessors< columnar::ContainerId::jet > >	m_jetConstitScaleMomFixedAcc
std::optional< columnar::JetAccessor< char > >	m_acc_jetRejectionDec
columnar::MetHelpers::ObjectWeightDecorator< columnar::ContainerId::mutableMet, columnar::ContainerId::jet >	m_jetOutputMetWeightDecRegular {*this, "", true}
columnar::MetHelpers::ObjectWeightDecorator< columnar::ContainerId::mutableMet, columnar::ContainerId::jet >	m_jetOutputMetWeightDecSoft {*this, "Soft", false}
columnar::ElectronAccessor< columnar::RetypeColumn< double, float > >	m_electronPtAcc {*this, "pt"}
Gaudi::Property< unsigned >	m_columnarOperation {this, "columnarOperation", 0}
Gaudi::Property< std::string >	m_columnarTermName {this, "columnarTermName", ""}
Gaudi::Property< unsigned >	m_columnarParticleType {this, "columnarParticleType", 0}
Gaudi::Property< std::string >	m_columnarJetKey {this, "columnarJetKey", ""}
Gaudi::Property< std::string >	m_columnarSoftClusKey {this, "columnarSoftClusKey", ""}
Gaudi::Property< bool >	m_columnarDoJetJVT {this, "columnarDoJetJVT", false}
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 49 of file ColumnarMETMaker.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

ColumnarMETMaker() [1/2]

met::ColumnarMETMaker::ColumnarMETMaker

(

const std::string &

name

)

Constructor with parameters:

Definition at line 79 of file ColumnarMETMaker.cxx.

                                                          :
    AsgTool(name),
    m_PVkey("PrimaryVertices"),
    m_trkseltool(""),
    m_JvtTool("", this)
  {
    //
    // Property declaration
    //
    declareProperty("JetJvtMomentName",   m_jetJvtMomentName   = "Jvt"               );
    declareProperty("JetRejectionDec",    m_jetRejectionDec    = ""                  );
    declareProperty("JetMinEFrac",        m_jetMinEfrac        = 0.0                 );
    declareProperty("JetMinWeightedPt",   m_jetMinWeightedPt   = 20.0e3              );
    declareProperty("JetConstitScaleMom", m_jetConstitScaleMom = "JetConstitScaleMomentum");
    declareProperty("CorrectJetPhi",      m_jetCorrectPhi      = false               );
    declareProperty("DoPFlow",            m_doPFlow            = false               );
    declareProperty("DoSoftTruth",        m_doSoftTruth        = false               );
    declareProperty("DoJetTruth",         m_doConstJet         = false               );
 
    declareProperty("JetSelection",       m_jetSelection       = "Tight"             );
    declareProperty("JetEtaMax",          m_JetEtaMax          = 4.5                 );
    declareProperty("JetEtaForw",         m_JetEtaForw         = 2.5                 );
    declareProperty("CustomCentralJetPt", m_customCenJetPtCut  = 20e3                );
    declareProperty("CustomForwardJetPt", m_customFwdJetPtCut  = 20e3                );
    declareProperty("CustomJetJvtPtMax",  m_customJvtPtMax     = 60e3                );
    declareProperty("CustomJetJvtWP",     m_customJvtWP        = "FixedEffPt"        );
 
    declareProperty("DoMuonEloss",        m_muEloss            = false               );
    declareProperty("ORCaloTaggedMuons",  m_orCaloTaggedMuon   = true                );
    declareProperty("GreedyPhotons",      m_greedyPhotons      = false               );
    declareProperty("VeryGreedyPhotons",  m_veryGreedyPhotons  = false               );
 
    declareProperty("UseGhostMuons",      m_useGhostMuons      = false               );
    declareProperty("DoRemoveMuonJets",   m_doRemoveMuonJets   = true                );
    declareProperty("DoSetMuonJetEMScale", m_doSetMuonJetEMScale = true              );
 
    declareProperty("DoRemoveElecTrks",   m_doRemoveElecTrks   = true                );
    declareProperty("DoRemoveElecTrksEM", m_doRemoveElecTrksEM = false               );
 
    declareProperty("skipSystematicJetSelection", m_skipSystematicJetSelection = false,
            "EXPERIMENTAL: whether to use simplified OR based on nominal jets "
            "and for jet-related systematics only. "
            "WARNING: this property is strictly for doing physics studies of the feasibility "
            "of this OR scheme, it should not be used in a regular analysis");
 
    // muon overlap variables (expert use only)
    declareProperty("JetTrkNMuOlap",      m_jetTrkNMuOlap = 5                        );
    declareProperty("JetWidthMuOlap",     m_jetWidthMuOlap = 0.1                     );
    declareProperty("JetPsEMuOlap",       m_jetPsEMuOlap = 2.5e3                     );
    declareProperty("JetEmfMuOlap",       m_jetEmfMuOlap = 0.9                       );
    declareProperty("JetTrkPtMuPt",       m_jetTrkPtMuPt = 0.8                       );
    declareProperty("muIDPTJetPtRatioMuOlap", m_muIDPTJetPtRatioMuOlap = 2.0         );
 
    declareProperty("MissingObjWarnThreshold", m_missObjWarningPtThreshold = 7.0e3   );
 
    declareProperty("TrackSelectorTool",  m_trkseltool                               );
    declareProperty("JvtSelTool",         m_JvtTool                                  );
  }

~ColumnarMETMaker()

met::ColumnarMETMaker::~ColumnarMETMaker ( )

virtualdefault

Destructor:

ColumnarMETMaker() [2/2]

met::ColumnarMETMaker::ColumnarMETMaker ( )

private

Default constructor:

Member Function Documentation

acceptTrack()

bool met::ColumnarMETMaker::acceptTrack ( const xAOD::TrackParticle * trk, const xAOD::Vertex * vx ) const

private

Definition at line 1221 of file ColumnarMETMaker.cxx.

  {
    return static_cast<bool>(m_trkseltool->accept( *trk, vx ));
  }

callEvents()

void met::ColumnarMETMaker::callEvents ( columnar::EventContextRange events ) const

overrideprivate

Definition at line 1244 of file ColumnarMETMaker.cxx.

  {
    for (columnar::EventContextId event : events)
    {
      auto met = m_outputMetHandle (event);
      auto metcore = m_inputMetHandle (event);
      auto metassoc = m_metAssocHandle (event);
      if (m_columnarOperation.value() == 0u)
      {
        auto particles = m_particlesHandle (event);
        if (rebuildMET (m_columnarTermName.value(), xAODType::ObjectType(m_columnarParticleType.value()), met, particles, m_assocAcc(metassoc), MissingETBase::UsageHandler::PhysicsObject).isFailure())
          throw std::runtime_error ("Failed to rebuild MET");
      } else if (m_columnarOperation.value() == 1u)
      {
        auto jets = m_jetsHandle (event);
        if (rebuildJetMET (m_columnarJetKey.value(), m_columnarSoftClusKey.value(), met, jets, metcore, m_assocAcc(metassoc), m_columnarDoJetJVT.value()).isFailure())
          throw std::runtime_error ("Failed to rebuild jet MET");
      } else if (m_columnarOperation.value() == 2u)
      {
        auto jets = m_jetsHandle (event);
        if (rebuildTrackMET (m_columnarJetKey.value(), m_columnarSoftClusKey.value(), met, jets, metcore, m_assocAcc(metassoc), m_columnarDoJetJVT.value()).isFailure())
          throw std::runtime_error ("Failed to rebuild track MET");
      } else
      {
        throw std::runtime_error ("Unknown columnar operation");
      }
    }
  }

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evaluateNNMET()

virtual StatusCode IMETMaker::evaluateNNMET ( const std::string & , xAOD::MissingETContainer *  ) const

inlinevirtualinherited

Reimplemented in met::METNet.

Definition at line 115 of file IMETMaker.h.

                                                                                        {
    return StatusCode::FAILURE;
  }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void * ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                    {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getKey( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      return ( proxy == nullptr ? 0 : proxy->sgkey() );
#endif // XAOD_STANDALONE
   }

getName()

const std::string & asg::AsgTool::getName ( const void * ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                            {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getName( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      static const std::string dummy = "";
      return ( proxy == nullptr ? dummy : proxy->name() );
#endif // XAOD_STANDALONE
   }

getProperty()

template<class T>

const T * asg::AsgTool::getProperty ( const std::string & name ) const

inherited

Get one of the tool's properties.

getPV()

const xAOD::Vertex * met::ColumnarMETMaker::getPV ( ) const

private

Definition at line 1226 of file ColumnarMETMaker.cxx.

                                                  {
 
    SG::ReadHandle<xAOD::VertexContainer> h_PV(m_PVkey);
 
    if(!h_PV.isValid()) {
      ATH_MSG_WARNING("Unable to retrieve primary vertex container PrimaryVertices");
      return nullptr;
    }
    ATH_MSG_DEBUG("Successfully retrieved primary vertex container");
    if(h_PV->empty()) ATH_MSG_WARNING("Event has no primary vertices!");
    for(const xAOD::Vertex* vx : *h_PV) {
      if(vx->vertexType()==xAOD::VxType::PriVtx) return vx;
    }
    return nullptr;
  }

initialize()

StatusCode met::ColumnarMETMaker::initialize ( void )

finaloverridevirtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented from asg::AsgTool.

Definition at line 145 of file ColumnarMETMaker.cxx.

  {
    ATH_MSG_INFO ("Initializing " << name() << "...");
 
    ATH_MSG_INFO("Use jet selection criterion: " << m_jetSelection << " PFlow: " << m_doPFlow);
    if (m_jetSelection == "Loose")       { m_CenJetPtCut = 20e3; m_FwdJetPtCut = 20e3; m_JvtWP = "FixedEffPt"; m_JvtPtMax = 60e3; }
    else if (m_jetSelection == "Tight")  { m_CenJetPtCut = 20e3; m_FwdJetPtCut = 30e3; m_JvtWP = "FixedEffPt"; m_JvtPtMax = 60e3; }
    else if (m_jetSelection == "Tighter"){ m_CenJetPtCut = 20e3; m_FwdJetPtCut = 35e3; m_JvtWP = "FixedEffPt"; m_JvtPtMax = 60e3; }
    else if (m_jetSelection == "Tenacious"){ m_CenJetPtCut = 20e3; m_FwdJetPtCut = 40e3; m_JvtWP = "FixedEffPt"; m_JvtPtMax = 60e3; }
    else if (m_jetSelection == "Tier0")  { m_CenJetPtCut = 0;    m_FwdJetPtCut = 0; m_JvtWP = "None"; }
    else if (m_jetSelection == "Expert")  {
      ATH_MSG_INFO("Custom jet selection configured. *** FOR EXPERT USE ONLY ***");
      m_CenJetPtCut = m_customCenJetPtCut;
      m_FwdJetPtCut = m_customFwdJetPtCut;
      m_JvtPtMax = m_customJvtPtMax;
      m_JvtWP = m_customJvtWP;
    }
    else if (m_jetSelection == "HRecoil")  {
      ATH_MSG_INFO("Jet selection for hadronic recoil calculation is configured.");
      m_CenJetPtCut = 9999e3;
      m_FwdJetPtCut = 9999e3;
      m_JetEtaMax   = 5;
      m_JvtWP       = "None";
    }
    else {
      if (m_jetSelection == "Default") ATH_MSG_WARNING( "WARNING:  Default is now deprecated" );
      ATH_MSG_ERROR( "Error: No available jet selection found! Please update JetSelection in ColumnarMETMaker. Choose one: Loose, Tight (recommended), Tighter, Tenacious" );
      return StatusCode::FAILURE;
    }
 
    if (!m_trkseltool.empty()) ATH_CHECK( m_trkseltool.retrieve() );
 
    if (m_JvtWP != "None"){
      if (m_JvtTool.empty()) {
        asg::AsgToolConfig config_jvt ("CP::NNJvtSelectionTool/JvtSelTool");
        ATH_CHECK(config_jvt.setProperty("JetContainer", m_jetContainer.key()));
        ATH_CHECK(config_jvt.setProperty("WorkingPoint", m_JvtWP));
        ATH_CHECK(config_jvt.setProperty("JvtMomentName", "NNJvt"));
        ATH_CHECK(config_jvt.setProperty("MaxPtForJvt", m_JvtPtMax));
        ATH_CHECK(config_jvt.makePrivateTool(m_JvtTool));
      }
      ATH_CHECK(m_JvtTool.retrieve());
    }
 
    // ReadHandleKey(s)
    ATH_CHECK( m_PVkey.initialize() );
 
    // configurable accessors
    if (!m_jetRejectionDec.empty()) {
      m_acc_jetRejectionDec.emplace (*this, m_jetRejectionDec);
      ATH_MSG_INFO("Applying additional jet rejection criterium in MET calculation: " << m_jetRejectionDec);
    }
 
    ATH_MSG_INFO("Suppressing warnings of objects missing in METAssociationMap for objects with pT < " << m_missObjWarningPtThreshold/1e3 << " GeV.");
 
    // overlap removal simplification?
    if (m_skipSystematicJetSelection) {
      ATH_MSG_INFO("Requesting simplified overlap removal procedure in MET calculation");
    }
    
    if (!m_inputPreselectionName.empty()) {
      m_inputPreselectionAcc.emplace(*this, m_inputPreselectionName);
    }
    if (!m_jetConstitScaleMom.empty()) {
      m_jetConstitScaleMomAcc.emplace(*this, m_jetConstitScaleMom);
      m_jetConstitScaleMomFixedAcc.emplace(*this, "JetConstitScaleMomentum");
    }
    return StatusCode::SUCCESS;
  }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

markInvisible() [1/2]

StatusCode met::ColumnarMETMaker::markInvisible	(	columnar::ParticleRange	collection,
		columnar::MetAssociationHelper<>	helper,
		columnar::MutableMetRange	metCont ) const

Definition at line 1213 of file ColumnarMETMaker.cxx.

  {
    columnar::MutableMetId met = m_outputMetMapAcc.fillMET (metCont, "Invisibles", invisSource);
    return rebuildMET(met,collection,helper,MissingETBase::UsageHandler::PhysicsObject);
  }

markInvisible() [2/2]

StatusCode met::ColumnarMETMaker::markInvisible ( const xAOD::IParticleContainer * collection, xAOD::MissingETAssociationHelper & helper, xAOD::MissingETContainer * metCont ) const

finaloverridevirtual

Implements IMETMaker.

Definition at line 1197 of file ColumnarMETMaker.cxx.

  {
    if (!collection) {
      ATH_MSG_ERROR("No object container provided for marking invisible");
      return StatusCode::FAILURE;
    }
    if (!metCont) {
      ATH_MSG_ERROR("No MET container provided for marking invisible");
      return StatusCode::FAILURE;
    }
 
    return markInvisible(columnar::ParticleRange(*collection),m_assocAcc(helper),columnar::MutableMetRange(*metCont));
  }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns

The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

bool AthCommonMsg< AlgTool >::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< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, KtDeltaRTool, and LundVariablesTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

rebuildJetMET() [1/6]

StatusCode met::ColumnarMETMaker::rebuildJetMET	(	columnar::MutableMetId	metJet,
		columnar::MutableMetRange	metCont,
		columnar::JetRange	jets,
		columnar::MetAssociationHelper<>	helper,
		columnar::OptMutableMetId	metSoftClus,
		columnar::OptMet1Id	coreSoftClus,
		columnar::OptMutableMetId	metSoftTrk,
		columnar::OptMet1Id	coreSoftTrk,
		bool	doJetJVT,
		bool	tracksForHardJets = false,
		std::vector< const xAOD::IParticle * > *	softConst = 0 ) const

Definition at line 626 of file ColumnarMETMaker.cxx.

                                                                                       {
    if(softConst && m_trkseltool.empty() && !m_doPFlow && !m_doSoftTruth) {
      ATH_MSG_WARNING( "Requested soft track element links, but no track selection tool supplied.");
    }
    const xAOD::Vertex *pv = softConst?getPV():nullptr;
 
    if(helper.map().empty()) {
      ATH_MSG_WARNING("Incomplete association map received. Cannot rebuild MET.");
      ATH_MSG_WARNING("Note: ColumnarMETMaker should only be run on events containing at least one PV");
      return StatusCode::SUCCESS;
    }
 
    if(doJetJVT && m_JvtWP == "None"){
      ATH_MSG_WARNING("rebuildJetMET requested JVT, which is inconsistent with jet selection " << m_jetSelection << ". Ignoring JVT.");
      doJetJVT = false;
    }
 
    ATH_MSG_VERBOSE("Building MET jet term " << metJet(m_outputMetNameAcc));
    if(!metSoftClus && !metSoftTrk) {
      ATH_MSG_WARNING("Neither soft cluster nor soft track term has been supplied!");
      return StatusCode::SUCCESS;
    }
    static const SG::AuxElement::ConstAccessor<std::vector<ElementLink<IParticleContainer> > > acc_softConst("softConstituents");
    std::optional<columnar::MetHelpers::ObjectWeightHandle<columnar::ContainerId::mutableMet,columnar::ContainerId::jet>> metSoftClusLinks;
    if(metSoftClus) {
      metSoftClusLinks.emplace(*this,m_jetOutputMetWeightDecSoft,metSoftClus.value(),jets);
      if(!coreSoftClus) {
        ATH_MSG_ERROR("Soft cluster term provided without a core term!");
        return StatusCode::FAILURE;
      }
      ATH_MSG_VERBOSE("Building MET soft cluster term " << metSoftClus.value()(m_outputMetNameAcc));
      ATH_MSG_VERBOSE("Core soft cluster mpx " << m_inputMetMomAcc.mpx(coreSoftClus.value())
                      << ", mpy " << m_inputMetMomAcc.mpy(coreSoftClus.value())
                      << " sumet " << m_inputMetMomAcc.sumet(coreSoftClus.value()));
      m_outputMetMomAcc.addMet (metSoftClus.value(), m_inputMetMomAcc, coreSoftClus.value());
      // Fill a vector with the soft constituents, if one was provided.
      // For now, only setting up to work with those corresponding to the jet constituents.
      // Can expand if needed.
      if(softConst && acc_softConst.isAvailable(*coreSoftClus.getXAODObject())) {
        for(const auto& constit : acc_softConst(*coreSoftClus.getXAODObject())) {
          softConst->push_back(*constit);
        }
        ATH_MSG_DEBUG(softConst->size() << " soft constituents from core term");
      }
    }
    std::optional<columnar::MetHelpers::ObjectWeightHandle<columnar::ContainerId::mutableMet,columnar::ContainerId::jet>> metSoftTrkLinks;
    if(metSoftTrk) {
      metSoftTrkLinks.emplace(*this,m_jetOutputMetWeightDecSoft,metSoftTrk.value(),jets);
      if(!coreSoftTrk) {
        ATH_MSG_ERROR("Soft track term provided without a core term!");
        return StatusCode::FAILURE;
      }
      ATH_MSG_VERBOSE("Building MET soft track term " << metSoftTrk.value()(m_outputMetNameAcc));
      ATH_MSG_VERBOSE("Core soft track mpx " << m_inputMetMomAcc.mpx(coreSoftTrk.value())
                      << ", mpy " << m_inputMetMomAcc.mpy(coreSoftTrk.value())
                      << " sumet " << m_inputMetMomAcc.sumet(coreSoftTrk.value()));
      m_outputMetMomAcc.addMet (metSoftTrk.value(), m_inputMetMomAcc, coreSoftTrk.value());
      if(softConst && acc_softConst.isAvailable(*coreSoftTrk.getXAODObject()) && !m_doPFlow && !m_doSoftTruth) {
        for(const auto& constit : acc_softConst(*coreSoftTrk.getXAODObject())) {
          softConst->push_back(*constit);
        }
        ATH_MSG_DEBUG(softConst->size() << " soft constituents from trk core term");
      }
    }
 
    columnar::MetHelpers::ObjectWeightHandle<columnar::ContainerId::mutableMet,columnar::ContainerId::jet> metJetWeights(*this,m_jetOutputMetWeightDecRegular,metJet,jets);
 
    // Get the hashed key of this jet, if we can. Though his only works if
    //   1. the container is an owning container, and not just a view;
    //   2. the container is in the event store already.
    // Since we will be creating ElementLink-s to these jets later on in the
    // code, and it should work in AnalysisBase, only the first one of these
    // is checked. Since the code can not work otherwise.
 
    columnar::MetHelpers::OriginalObjectHandle<columnar::ContainerId::jet> jetsOriginals(*this,jets);
    for(auto jet : jets) {
      auto originalJet = jetsOriginals.getOriginal(jet);
      auto assoc = helper.getJetAssociation(originalJet);
      if(!assoc || m_assocAcc.isMisc(*assoc)) {
        ATH_MSG_WARNING( "Jet without association found!" );
        continue;
      }
 
      if(m_skipSystematicJetSelection) {
        // retrieve nominal calibrated jet
        if (acc_nominalObject.isAvailable(jet.getXAODObject())){
          ATH_MSG_VERBOSE( "Jet pt before nominal replacement = " << m_jetMomAcc.pt(jet));
          jet = *static_cast<const xAOD::Jet*>(*acc_nominalObject(jet.getXAODObject()));
        }
        else
          ATH_MSG_ERROR("No nominal calibrated jet available for jet " << jet << ". Cannot simplify overlap removal!");
      }
      ATH_MSG_VERBOSE( "Jet pt = " << m_jetMomAcc.pt(jet));
 
      bool selected = (std::abs(m_jetMomAcc.eta(jet))<m_JetEtaForw && m_jetMomAcc.pt(jet)>m_CenJetPtCut) || (std::abs(m_jetMomAcc.eta(jet))>=m_JetEtaForw && m_jetMomAcc.pt(jet)>m_FwdJetPtCut );
      bool JVT_reject(false);
      bool isMuFSRJet(false);
 
      // Apply a cut on the maximum jet eta. This restricts jets to those with calibration. Excluding more forward jets was found to have a minimal impact on the MET in Zee events
      if (m_JetEtaMax > 0.0 && std::abs(m_jetMomAcc.eta(jet)) > m_JetEtaMax)
        JVT_reject = true;
 
      if(doJetJVT) {
        // intrinsically checks that is within range to apply Jvt requirement
        JVT_reject  = !bool(m_JvtTool->accept(&jet.getXAODObject()));
        ATH_MSG_VERBOSE("Jet " << (JVT_reject ? "fails" : "passes") <<" JVT selection");
      }
 
      // if defined apply additional jet criterium
      if (m_acc_jetRejectionDec && (*m_acc_jetRejectionDec)(jet)==0) JVT_reject = true;
      bool hardJet(false);
      MissingETBase::Types::constvec_t calvec = helper.overlapCalVec(*assoc);
      bool caloverlap = false;
      caloverlap = calvec.ce()>0;
      ATH_MSG_DEBUG("Jet " << jet << " is " << ( caloverlap ? "" : "non-") << "overlapping");
 
      if(m_veryGreedyPhotons && caloverlap) {
        for(const auto object : m_assocAcc.objects(*assoc)) {
          // Correctly handle this jet if we're using very greedy photons
          if (object && object.getXAODObject()->type() == xAOD::Type::Photon) hardJet = true;
        }
      }
 
      xAOD::JetFourMom_t constjet;
      double constSF(1);
      if(m_jetConstitScaleMom.empty() && m_assocAcc.hasAlternateConstVec(*assoc)){
        constjet = m_assocAcc.getAlternateConstVec(*assoc);
      } else {
        constjet = m_jetConstitScaleMomAcc.value().jetP4(jet);//grab a constituent scale added by the JetMomentTool/JetConstitFourMomTool.cxx
        double denom = (m_assocAcc.hasAlternateConstVec(*assoc) ? m_assocAcc.getAlternateConstVec(*assoc) : m_jetConstitScaleMomFixedAcc.value().jetP4(jet)).E();
        constSF = denom>1e-9 ? constjet.E()/denom : 0.;
        ATH_MSG_VERBOSE("Scale const jet by factor " << constSF);
        calvec *= constSF;
      }
      double jpx = constjet.Px();
      double jpy = constjet.Py();
      double jpt = constjet.Pt();
      double opx = jpx - calvec.cpx();
      double opy = jpy - calvec.cpy();
 
      columnar::OptMutableMetId met_muonEloss;
      if(m_muEloss || m_doSetMuonJetEMScale) {
        // Get a term to hold the Eloss corrections
        met_muonEloss = m_outputMetMapAcc.getRequired(metCont, "MuonEloss");
        if(!met_muonEloss) {
          ATH_MSG_WARNING("Attempted to apply muon Eloss correction, but corresponding MET term does not exist!");
          return StatusCode::FAILURE;
        }
      }
 
      float total_eloss(0);
      MissingETBase::Types::bitmask_t muons_selflags(0);
      std::vector<columnar::MuonId> muons_in_jet;
      std::vector<columnar::ElectronId> electrons_in_jet;
      bool passJetForEl=false;
      if(m_useGhostMuons) { // for backwards-compatibility
        if(!acc_ghostMuons.isAvailable(jet.getXAODObject())){
          ATH_MSG_ERROR("Ghost muons requested but not found!");
          return StatusCode::FAILURE;
        }
        for(const auto& el : acc_ghostMuons(jet.getXAODObject())) {
          if(!el.isValid()){
            ATH_MSG_ERROR("Invalid element link to ghost muon! Quitting.");
            return StatusCode::FAILURE;
          }
          muons_in_jet.push_back(*static_cast<const xAOD::Muon*>(*el));
        }
      }
      for(const auto obj : m_assocAcc.objects(*assoc)) {
        if(!obj) continue;
        if(!m_useGhostMuons && obj.isContainer<columnar::ContainerId::muon>()) {
          auto mu_test = obj.tryGetVariant<columnar::ContainerId::muon>().value();
          ATH_MSG_VERBOSE("Muon " << mu_test << " found in jet " << jet);
          if((m_doRemoveMuonJets || m_doSetMuonJetEMScale)) {
            if constexpr (columnar::ColumnarModeDefault::isXAOD) {
              if(acc_originalObject.isAvailable(mu_test.getXAODObject())) mu_test = *static_cast<const xAOD::Muon*>(*acc_originalObject(mu_test.getXAODObject()));
            }
            if(helper.objSelected(mu_test)) { //
              muons_in_jet.push_back(mu_test);
              ATH_MSG_VERBOSE("Muon is selected by MET.");
            }
          }
        } else if(m_doRemoveElecTrks && obj.isContainer<columnar::ContainerId::electron>()) {
          auto el_test = obj.tryGetVariant<columnar::ContainerId::electron>().value();
          ATH_MSG_VERBOSE("Electron " << el_test << " found in jet " << jet);
          if constexpr (columnar::ColumnarModeDefault::isXAOD) {
            if(acc_originalObject.isAvailable(el_test.getXAODObject())) el_test = *static_cast<const xAOD::Electron*>(*acc_originalObject(el_test.getXAODObject()));
          }
          if(helper.objSelected(*assoc,el_test)){
            if(el_test(m_electronPtAcc)>90.0e3) { // only worry about high-pt electrons?
              electrons_in_jet.push_back(el_test);
              ATH_MSG_VERBOSE("High-pt electron is selected by MET.");
            }
          }
        }
      }
      if(m_doRemoveElecTrks) {
        MissingETBase::Types::constvec_t initialTrkMom = m_assocAcc.jetTrkVec(*assoc);
        float jet_ORtrk_sumpt = helper.overlapTrkVec(*assoc).sumpt();
        float jet_all_trk_pt =  initialTrkMom.sumpt();
        float jet_unique_trk_pt = jet_all_trk_pt - jet_ORtrk_sumpt;
        MissingETBase::Types::constvec_t el_calvec;
        MissingETBase::Types::constvec_t el_trkvec;
        for(const auto& elec : electrons_in_jet) {
            el_calvec += m_assocAcc.calVec(*assoc,elec);
            el_trkvec += m_assocAcc.trkVec(*assoc,&elec.getXAODObject());
        }
        float el_cal_pt = el_calvec.cpt();
        float el_trk_pt = el_trkvec.cpt();
        ATH_MSG_VERBOSE("Elec trk: " << el_trk_pt
                        << " jetalltrk: " << jet_all_trk_pt
                        << " jetORtrk: " << jet_ORtrk_sumpt
                        << " electrk-jetORtrk: " << (el_trk_pt-jet_ORtrk_sumpt)
                        << " elec cal: " << el_cal_pt
                        << " jetalltrk-electrk: " << (jet_all_trk_pt-el_trk_pt)
                        << " jetalltrk-jetORtrk: " << (jet_all_trk_pt-jet_ORtrk_sumpt) );
        // Want to use the jet calo measurement if we had at least one electron
        // and the jet has a lot of residual track pt
        // Is the cut appropriate?
        if(el_trk_pt>1e-9 && jet_unique_trk_pt>10.0e3) passJetForEl=true;
      } // end ele-track removal
 
      for(auto mu_in_jet : muons_in_jet) {
        float mu_Eloss = acc_Eloss(mu_in_jet.getXAODObject());
 
        if(!JVT_reject) {
          if (m_doRemoveMuonJets) {
            // need to investigate how this is affected by the recording of muon clusters in the map
            float mu_id_pt = mu_in_jet.getXAODObject().trackParticle(xAOD::Muon::InnerDetectorTrackParticle) ? mu_in_jet.getXAODObject().trackParticle(xAOD::Muon::InnerDetectorTrackParticle)->pt() : 0.;
            float jet_trk_sumpt = m_acc_trksumpt.isAvailable(jet) && this->getPV() ? m_acc_trksumpt(jet)[this->getPV()->index()] : 0.;
 
            // missed the muon, so we should add it back
            if(0.9999*mu_id_pt>jet_trk_sumpt)
              jet_trk_sumpt+=mu_id_pt;
            float jet_trk_N = m_acc_trkN.isAvailable(jet) && this->getPV() ? m_acc_trkN(jet)[this->getPV()->index()] : 0.;
            ATH_MSG_VERBOSE("Muon has ID pt " << mu_id_pt);
            ATH_MSG_VERBOSE("Jet has pt " << m_jetMomAcc.pt(jet) << ", trk sumpt " << jet_trk_sumpt << ", trk N " << jet_trk_N);
            bool jet_from_muon = mu_id_pt>1e-9 && jet_trk_sumpt>1e-9 && (m_jetMomAcc.pt(jet)/mu_id_pt < m_muIDPTJetPtRatioMuOlap && mu_id_pt/jet_trk_sumpt>m_jetTrkPtMuPt) && jet_trk_N<m_jetTrkNMuOlap;
            if(jet_from_muon) {
              ATH_MSG_VERBOSE("Jet is from muon -- remove.");
              JVT_reject = true;
            }
          }
 
          if (m_doSetMuonJetEMScale) {
            // need to investigate how this is affected by the recording of muon clusters in the map
            float mu_id_pt = mu_in_jet.getXAODObject().trackParticle(xAOD::Muon::InnerDetectorTrackParticle) ? mu_in_jet.getXAODObject().trackParticle(xAOD::Muon::InnerDetectorTrackParticle)->pt() : 0.;
            float jet_trk_sumpt = m_acc_trksumpt.isAvailable(jet) && this->getPV() ? m_acc_trksumpt(jet)[this->getPV()->index()] : 0.;
            // missed the muon, so we should add it back
            if(0.9999*mu_id_pt>jet_trk_sumpt)
              jet_trk_sumpt+=mu_id_pt;
            float jet_trk_N = m_acc_trkN.isAvailable(jet) && this->getPV() ? m_acc_trkN(jet)[this->getPV()->index()] : 0.;
 
            float jet_psE = 0.;
            if (m_acc_psf.isAvailable(jet)){
              jet_psE = m_acc_psf(jet);
            } else if (m_acc_sampleE.isAvailable(jet)){
              jet_psE = m_acc_sampleE(jet)[0] + m_acc_sampleE(jet)[4];
            } else {
              ATH_MSG_ERROR("Jet PS fraction or sampling energy must be available to calculate MET with doSetMuonJetEMScale");
              return StatusCode::FAILURE;
            }
 
            bool jet_from_muon = jet_trk_sumpt>1e-9 && jet_trk_N<3 && mu_id_pt / jet_trk_sumpt > m_jetTrkPtMuPt && m_acc_emf(jet)>m_jetEmfMuOlap && m_acc_width(jet)<m_jetWidthMuOlap && jet_psE>m_jetPsEMuOlap;
            ATH_MSG_VERBOSE("Muon has ID pt " << mu_id_pt);
            ATH_MSG_VERBOSE("Jet has trk sumpt " << jet_trk_sumpt << ", trk N " << jet_trk_N << ", PS E " << jet_psE << ", width " << m_acc_width(jet) << ", emfrac " << m_acc_emf(jet));
 
            if(jet_from_muon) {
              ATH_MSG_VERBOSE("Jet is from muon -- set to EM scale and subtract Eloss.");
              // Using constjet now because we focus on AntiKt4EMTopo.
              // Probably not a massive difference to LC, but PF needs some consideration
              ATH_MSG_VERBOSE("Jet e: " << constjet.E() << ", mu Eloss: " << mu_Eloss);
              float elosscorr = mu_Eloss >= constjet.e() ? 0. : 1.-mu_Eloss/constjet.e();
              // Effectively, take the unique fraction of the jet times the eloss-corrected fraction
              // This might in some cases oversubtract, but should err on the side of undercounting the jet contribution
              opx *= elosscorr;
              opy *= elosscorr;
              ATH_MSG_VERBOSE(" Jet eloss factor " << elosscorr << ", final pt: " << sqrt(opx*opx+opy*opy));
              // Don't treat this jet normally. Instead, just add to the Eloss term
              isMuFSRJet = true;
            }
          }
        } // end muon-jet overlap-removal
 
        switch(mu_in_jet.getXAODObject().energyLossType()) {
          case xAOD::Muon::Parametrized:
          case xAOD::Muon::MOP:
          case xAOD::Muon::Tail:
          case xAOD::Muon::FSRcandidate:
          case xAOD::Muon::NotIsolated:
            // For now don't differentiate the behaviour
            // Remove the Eloss assuming the parameterised value
            // The correction is limited to the selected clusters
            total_eloss += mu_Eloss;
            muons_selflags |= (1<<m_assocAcc.findIndex(*assoc,mu_in_jet));
        }
      }
      ATH_MSG_VERBOSE("Muon selection flags: " << muons_selflags);
      ATH_MSG_VERBOSE("Muon total eloss: " << total_eloss);
 
      MissingETBase::Types::constvec_t mu_calovec;
      // borrowed from overlapCalVec
      for(size_t iKey = 0; iKey < m_assocAcc.sizeCal(*assoc); iKey++) {
        bool selector = (muons_selflags & m_assocAcc.calkey(*assoc)[iKey]);
        if(selector) mu_calovec += m_assocAcc.calVec(*assoc,iKey);
        ATH_MSG_VERBOSE("This key: " << m_assocAcc.calkey(*assoc)[iKey] << ", selector: " << selector);
      }
      ATH_MSG_VERBOSE("Mu calovec pt, no Eloss:   " << mu_calovec.cpt());
      if(m_muEloss) mu_calovec *= std::max<float>(0.,1-(total_eloss/mu_calovec.ce()));
      ATH_MSG_VERBOSE("Mu calovec pt, with Eloss: " << mu_calovec.cpt());
 
      // re-add calo components of muons beyond Eloss correction
      ATH_MSG_VERBOSE("Jet " << jet << " const pT before OR " << jpt);
      ATH_MSG_VERBOSE("Jet " << jet << " const pT after OR " << sqrt(opx*opx+opy*opy));
      opx += mu_calovec.cpx();
      opy += mu_calovec.cpy();
      double opt = sqrt( opx*opx+opy*opy );
      ATH_MSG_VERBOSE("Jet " << jet << " const pT diff after OR readding muon clusters " << opt-jpt);
      double uniquefrac = 1. - (calvec.ce() - mu_calovec.ce()) / constjet.E();
      ATH_MSG_VERBOSE( "Jet constscale px, py, pt, E = " << jpx << ", " << jpy << ", " << jpt << ", " << constjet.E() );
      ATH_MSG_VERBOSE( "Jet overlap E = " << calvec.ce() - mu_calovec.ce() );
      ATH_MSG_VERBOSE( "Jet OR px, py, pt, E = " << opx << ", " << opy << ", " << opt << ", " << constjet.E() - calvec.ce() );
 
      if(isMuFSRJet) {
        if(!met_muonEloss){
          ATH_MSG_ERROR("Attempted to apply muon Eloss correction, but corresponding MET term does not exist!");
          return StatusCode::FAILURE;
        }
        m_outputMetMomAcc.addParticle(met_muonEloss.value(),opx,opy,opt);
        continue;
      }
 
      if(selected && !JVT_reject) {
        if(!caloverlap) {
          // add jet full four-vector
          hardJet = true;
          if (!tracksForHardJets) {
            if(m_doConstJet)
              m_outputMetMomAcc.addParticle(metJet,jpx,jpy,jpt);
            else
              m_outputMetMomAcc.addParticle(metJet,m_jetMomAcc,jet);
          }
        }
        else if((uniquefrac>m_jetMinEfrac || passJetForEl) && opt>m_jetMinWeightedPt){
          // add jet corrected for overlaps if sufficient unique fraction
          hardJet = true;
          if(!tracksForHardJets) {
            if(m_jetCorrectPhi) {
              if (m_doConstJet)
                m_outputMetMomAcc.addParticle(metJet,opx,opy,opt);
              else {
                double jesF = m_jetMomAcc.pt(jet) / jpt;
                m_outputMetMomAcc.addParticle(metJet,opx*jesF,opy*jesF,opt*jesF);
              }
            } else {
              if (m_doConstJet)
                m_outputMetMomAcc.addParticle(metJet,uniquefrac*jpx,uniquefrac*jpy,uniquefrac*jpt);
              else{
                if(passJetForEl && m_doRemoveElecTrksEM)
                  m_outputMetMomAcc.addParticle(metJet,opx,opy,opt);
                else
                  m_outputMetMomAcc.addParticle(metJet,uniquefrac*m_jetMomAcc.px(jet),uniquefrac*m_jetMomAcc.py(jet),uniquefrac*m_jetMomAcc.pt(jet));
              }
            }
          }
        }
      }  // hard jet selection
 
      if(hardJet){
        ATH_MSG_VERBOSE("Jet added at full scale");
        metJetWeights.emplace_back(jet, uniquefrac);
      } else {
        if(metSoftClus && !JVT_reject) {
          // add fractional contribution
          ATH_MSG_VERBOSE("Jet added at const scale");
          if (std::abs(m_jetMomAcc.eta(jet))<2.5 || !(coreSoftClus.value()(m_inputMetSourceAcc)&MissingETBase::Source::Region::Central)) {
            metSoftClusLinks->emplace_back (jet, uniquefrac);
            m_outputMetMomAcc.addParticle(metSoftClus.value(),opx,opy,opt);
          }
 
          // Fill a vector with the soft constituents, if one was provided.
          // For now, only setting up to work with those corresponding to the jet constituents.
          // Can expand if needed.
          // This ignores overlap removal.
          //
          if(softConst) {
            for(size_t iConst=0; iConst<jet.getXAODObject().numConstituents(); ++iConst) {
              const IParticle* constit = jet.getXAODObject().rawConstituent(iConst);
              softConst->push_back(constit);
            }
          }
        }
      } // hard jet or CST
 
      if(!metSoftTrk || (hardJet && !tracksForHardJets)) continue;
 
      // use jet tracks
      // remove any tracks already used by other objects
      MissingETBase::Types::constvec_t trkvec = helper.overlapTrkVec(*assoc);
      MissingETBase::Types::constvec_t jettrkvec = m_assocAcc.jetTrkVec(*assoc);
      if(jettrkvec.ce()>1e-9) {
        jpx = jettrkvec.cpx();
        jpy = jettrkvec.cpy();
        jpt = jettrkvec.sumpt();
        jettrkvec -= trkvec;
        opx = jettrkvec.cpx();
        opy = jettrkvec.cpy();
        opt = jettrkvec.sumpt();
        ATH_MSG_VERBOSE( "Jet track px, py, sumpt = " << jpx << ", " << jpy << ", " << jpt );
        ATH_MSG_VERBOSE( "Jet OR px, py, sumpt = " << opx << ", " << opy << ", " << opt );
      } else {
        opx = opy = opt = 0;
        ATH_MSG_VERBOSE( "This jet has no associated tracks" );
      }
      if (hardJet) m_outputMetMomAcc.addParticle(metJet,opx,opy,opt);
      else if (std::abs(m_jetMomAcc.eta(jet))<2.5 || !(coreSoftTrk.value()(m_inputMetSourceAcc)&MissingETBase::Source::Region::Central)) {
        m_outputMetMomAcc.addParticle(metSoftTrk.value(),opx,opy,opt);
        // Don't need to add if already done for softclus.
        if(!metSoftClus) {
          if (metSoftTrkLinks) metSoftTrkLinks->emplace_back (jet, uniquefrac);
        }
 
        // Fill a vector with the soft constituents, if one was provided.
        // For now, only setting up to work with those corresponding to the jet constituents.
        // Can expand if needed.
        // This ignores overlap removal.
        //
        if(softConst && !m_doPFlow && !m_doSoftTruth) {
          std::vector<const IParticle*> jettracks;
          jet.getXAODObject().getAssociatedObjects<IParticle>(xAOD::JetAttribute::GhostTrack,jettracks);
          for(size_t iConst=0; iConst<jettracks.size(); ++iConst) {
            const TrackParticle* pTrk = static_cast<const TrackParticle*>(jettracks[iConst]);
            if (acceptTrack(pTrk,pv)) softConst->push_back(pTrk);
          }
        }
      }
    } // jet loop
 
    ATH_MSG_DEBUG("Number of selected jets: " << metJetWeights.size());
 
    if(metSoftTrk) {
      ATH_MSG_DEBUG("Number of softtrk jets: " << metSoftTrkLinks->size());
    }
 
    if(metSoftClus) {
      ATH_MSG_DEBUG("Number of softclus jets: " << metSoftClusLinks->size());
    }
 
    if(softConst) ATH_MSG_DEBUG(softConst->size() << " soft constituents from core term + jets");
 
    auto assoc = helper.getMiscAssociation();
    if(!assoc) return StatusCode::SUCCESS;
 
    if(metSoftTrk) {
      // supplement track term with any tracks associated to isolated muons
      // these are recorded in the misc association
      MissingETBase::Types::constvec_t trkvec = helper.overlapTrkVec(*assoc);
      double opx = trkvec.cpx();
      double opy = trkvec.cpy();
      double osumpt = trkvec.sumpt();
      ATH_MSG_VERBOSE( "Misc track px, py, sumpt = " << opx << ", " << opy << ", " << osumpt );
      m_outputMetMomAcc.addParticle(metSoftTrk.value(),opx,opy,osumpt);
      ATH_MSG_VERBOSE("Final soft track mpx " << m_outputMetMomAcc.mpx(metSoftTrk.value())
                      << ", mpy " << m_outputMetMomAcc.mpy(metSoftTrk.value())
                      << " sumet " << m_outputMetMomAcc.sumet(metSoftTrk.value()));
    }
 
    if(metSoftClus) {
      // supplement cluster term with any clusters associated to isolated e/gamma
      // these are recorded in the misc association
      float total_eloss(0.);
      MissingETBase::Types::bitmask_t muons_selflags(0);
      MissingETBase::Types::constvec_t calvec = helper.overlapCalVec(*assoc);
      double opx = calvec.cpx();
      double opy = calvec.cpy();
      double osumpt = calvec.sumpt();
      for(const auto objId : m_assocAcc.objects(*assoc)) {
        auto *obj = objId.getXAODObject();
        if (!obj || obj->type() != xAOD::Type::Muon) continue;
        const xAOD::Muon* mu_test(static_cast<const xAOD::Muon*>(obj));
        if(acc_originalObject.isAvailable(*mu_test)) mu_test = static_cast<const xAOD::Muon*>(*acc_originalObject(*mu_test));
        if(helper.objSelected(mu_test)) { //
          float mu_Eloss = acc_Eloss(*mu_test);
          switch(mu_test->energyLossType()) {
          case xAOD::Muon::Parametrized:
          case xAOD::Muon::MOP:
          case xAOD::Muon::Tail:
          case xAOD::Muon::FSRcandidate:
          case xAOD::Muon::NotIsolated:
            // For now don't differentiate the behaviour
            // Remove the Eloss assuming the parameterised value
            // The correction is limited to the selected clusters
            total_eloss += mu_Eloss;
            muons_selflags |= (1<<m_assocAcc.findIndex(*assoc,mu_test));
          }
          ATH_MSG_VERBOSE("Mu index " << mu_test->index());
        }
      }
      ATH_MSG_VERBOSE("Mu selection flags " << muons_selflags);
      ATH_MSG_VERBOSE("Mu total eloss " << total_eloss);
 
      MissingETBase::Types::constvec_t mu_calovec;
      // borrowed from overlapCalVec
      for(size_t iKey = 0; iKey < m_assocAcc.sizeCal(*assoc); iKey++) {
        bool selector = (muons_selflags & m_assocAcc.calkey(*assoc)[iKey]);
        ATH_MSG_VERBOSE("This key: " << m_assocAcc.calkey(*assoc)[iKey] << ", selector: " << selector
                        << " this calvec E: " << m_assocAcc.calVec(*assoc,iKey).ce());
        if(selector) mu_calovec += m_assocAcc.calVec(*assoc,iKey);
      }
      if(m_muEloss){
        mu_calovec *= std::max<float>(0.,1-(total_eloss/mu_calovec.ce()));
        opx += mu_calovec.cpx();
        opy += mu_calovec.cpy();
        osumpt += mu_calovec.sumpt();
      }
      ATH_MSG_VERBOSE("Mu cluster sumpt " << mu_calovec.sumpt());
 
      ATH_MSG_VERBOSE( "Misc cluster px, py, sumpt = " << opx << ", " << opy << ", " << osumpt );
      m_outputMetMomAcc.addParticle(metSoftClus.value(),opx,opy,osumpt);
      ATH_MSG_VERBOSE("Final soft cluster mpx " << m_outputMetMomAcc.mpx(metSoftClus.value())
                      << ", mpy " << m_outputMetMomAcc.mpy(metSoftClus.value())
                      << " sumet " << m_outputMetMomAcc.sumet(metSoftClus.value()));
    }
 
    return StatusCode::SUCCESS;
  }

rebuildJetMET() [2/6]

StatusCode met::ColumnarMETMaker::rebuildJetMET	(	const std::string &	metJetKey,
		const std::string &	metSoftKey,
		columnar::MutableMetRange	metCont,
		columnar::JetRange	jets,
		columnar::Met1Range	metCoreCont,
		columnar::MetAssociationHelper<>	helper,
		bool	doJetJVT ) const

Definition at line 462 of file ColumnarMETMaker.cxx.

  {
    ATH_MSG_VERBOSE("Rebuild jet term: " << metJetKey << " and soft term: " << softKey);
 
    columnar::MutableMetId metJet {m_outputMetMapAcc.fillMET (metCont, metJetKey, MissingETBase::Source::jet())};
 
    columnar::OptMet1Id coreSoftClus, coreSoftTrk;
    columnar::OptMutableMetId metSoftClus, metSoftTrk;
 
    columnar::OptMet1Id coreSoft = m_inputMetMapAcc(metCoreCont,softKey+"Core");
    if(!coreSoft) {
      ATH_MSG_WARNING("Invalid soft term key supplied: " << softKey);
      return StatusCode::FAILURE;
    }
    if(MissingETBase::Source::isTrackTerm(coreSoft.value()(m_inputMetSourceAcc))) {
      coreSoftTrk = coreSoft;
 
      metSoftTrk = m_outputMetMapAcc.fillMET (metCont, softKey, coreSoftTrk.value()(m_inputMetSourceAcc));
    } else {
      coreSoftClus = coreSoft;
 
      metSoftClus = m_outputMetMapAcc.fillMET (metCont, softKey, coreSoftClus.value()(m_inputMetSourceAcc));
    }
 
    return rebuildJetMET(metJet, metCont, jets, helper,
                         metSoftClus, coreSoftClus,
                         metSoftTrk,  coreSoftTrk,
                         doJetJVT);
  }

rebuildJetMET() [3/6]

StatusCode met::ColumnarMETMaker::rebuildJetMET ( const std::string & metJetKey, const std::string & metSoftKey, xAOD::MissingETContainer * metCont, const xAOD::JetContainer * jets, const xAOD::MissingETContainer * metCoreCont, xAOD::MissingETAssociationHelper & helper, bool doJetJVT ) const

finaloverridevirtual

Implements IMETMaker.

Definition at line 440 of file ColumnarMETMaker.cxx.

  {
    if (!metCont || !metCoreCont)
    {
      ATH_MSG_ERROR("No MET container provided");
      return StatusCode::FAILURE;
    }
    if (!jets)
    {
      ATH_MSG_ERROR("No input collection provided for MET term \"" << metJetKey << "\" and soft term: " << softKey);
      return StatusCode::FAILURE;
    }
 
    return rebuildJetMET(metJetKey,softKey,columnar::MutableMetRange(*metCont),columnar::JetRange(*jets),columnar::Met1Range(*metCoreCont),m_assocAcc(helper),doJetJVT);
  }

rebuildJetMET() [4/6]

StatusCode met::ColumnarMETMaker::rebuildJetMET	(	const std::string &	metJetKey,
		const std::string &	softClusKey,
		const std::string &	softTrkKey,
		columnar::MutableMetRange	metCont,
		columnar::JetRange	jets,
		columnar::Met1Range	metCoreCont,
		columnar::MetAssociationHelper<>	helper,
		bool	doJetJVT ) const

Definition at line 569 of file ColumnarMETMaker.cxx.

  {
 
    ATH_MSG_VERBOSE("Create Jet MET " << metJetKey);
    columnar::MutableMetId metJet {m_outputMetMapAcc.fillMET (metCont, metJetKey, MissingETBase::Source::jet())};
    ATH_MSG_VERBOSE("Create SoftClus MET " << softClusKey);
    auto coreSoftClus = m_inputMetMapAcc(metCoreCont,softClusKey+"Core");
    ATH_MSG_VERBOSE("Create SoftTrk MET " << softTrkKey);
    auto coreSoftTrk = m_inputMetMapAcc(metCoreCont,softTrkKey+"Core");
    if(!coreSoftClus) {
      ATH_MSG_WARNING("Invalid cluster soft term key supplied: " << softClusKey);
      return StatusCode::FAILURE;
    }
    if(!coreSoftTrk) {
      ATH_MSG_WARNING("Invalid track soft term key supplied: " << softTrkKey);
      return StatusCode::FAILURE;
    }
    columnar::MutableMetId metSoftClus {m_outputMetMapAcc.fillMET (metCont, softClusKey, m_inputMetSourceAcc(coreSoftClus.value()))};
 
    columnar::MutableMetId metSoftTrk {m_outputMetMapAcc.fillMET (metCont, softTrkKey, m_inputMetSourceAcc(coreSoftTrk.value()))};
 
    return rebuildJetMET(metJet, metCont, jets, helper,
                         metSoftClus, coreSoftClus,
                         metSoftTrk, coreSoftTrk,
                         doJetJVT);
  }

rebuildJetMET() [5/6]

StatusCode met::ColumnarMETMaker::rebuildJetMET ( const std::string & metJetKey, const std::string & softClusKey, const std::string & softTrkKey, xAOD::MissingETContainer * metCont, const xAOD::JetContainer * jets, const xAOD::MissingETContainer * metCoreCont, xAOD::MissingETAssociationHelper & helper, bool doJetJVT ) const

finaloverridevirtual

Implements IMETMaker.

Definition at line 546 of file ColumnarMETMaker.cxx.

  {
    if (!metCont)
    {
      ATH_MSG_ERROR("No MET container provided");
      return StatusCode::FAILURE;
    }
    if (!jets)
    {
      ATH_MSG_ERROR("No input collection provided for MET term \"" << metJetKey << "\" and soft term: " << softClusKey << " and " << softTrkKey);
      return StatusCode::FAILURE;
    }
 
    return rebuildJetMET(metJetKey,softClusKey,softTrkKey,columnar::MutableMetRange(*metCont),columnar::JetRange(*jets),columnar::Met1Range(*metCoreCont),m_assocAcc(helper),doJetJVT);
  }

rebuildJetMET() [6/6]

StatusCode met::ColumnarMETMaker::rebuildJetMET ( xAOD::MissingET * metJet, const xAOD::JetContainer * jets, xAOD::MissingETAssociationHelper & helper, xAOD::MissingET * metSoftClus, const xAOD::MissingET * coreSoftClus, xAOD::MissingET * metSoftTrk, const xAOD::MissingET * coreSoftTrk, bool doJetJVT, bool tracksForHardJets = false, std::vector< const xAOD::IParticle * > * softConst = 0 ) const

finaloverridevirtual

Implements IMETMaker.

Definition at line 603 of file ColumnarMETMaker.cxx.

                                                                                       {
    if(!metJet || !jets) {
      ATH_MSG_ERROR("Invalid pointer supplied for "
                      << "MET (" << metJet << ") or "
                      << "jet collection (" << jets << ").");
      return StatusCode::FAILURE;
    }
    columnar::MutableMetRange metCont (*static_cast<MissingETContainer*>(metJet->container()));
    return rebuildJetMET(columnar::MutableMetId(*metJet), metCont, columnar::JetRange(*jets), m_assocAcc(helper),
                         columnar::OptMutableMetId(metSoftClus), columnar::OptMet1Id (coreSoftClus),
                         columnar::OptMutableMetId(metSoftTrk), columnar::OptMet1Id (coreSoftTrk),
                         doJetJVT, tracksForHardJets, softConst);
  }

rebuildMET() [1/6]

StatusCode met::ColumnarMETMaker::rebuildMET	(	columnar::MutableMetId	met,
		columnar::ParticleRange	collection,
		columnar::MetAssociationHelper<>	helper,
		MissingETBase::UsageHandler::Policy	objScale ) const

Definition at line 300 of file ColumnarMETMaker.cxx.

  {
    MissingETBase::UsageHandler::Policy p = MissingETBase::UsageHandler::OnlyCluster;
    bool removeOverlap = true;
    if (m_inputObjTypeAcc(collection) == xAOD::Type::Muon) {
        p = MissingETBase::UsageHandler::OnlyTrack;
        removeOverlap = false;
    }
    if (m_doSoftTruth) p = MissingETBase::UsageHandler::TruthParticle;
    if (m_doPFlow) p = MissingETBase::UsageHandler::ParticleFlow;
    return rebuildMET(met,collection,helper,p,removeOverlap,objScale);
  }

rebuildMET() [2/6]

StatusCode met::ColumnarMETMaker::rebuildMET	(	columnar::MutableMetId	met,
		columnar::ParticleRange	collection,
		columnar::MetAssociationHelper<>	helper,
		MissingETBase::UsageHandler::Policy	p,
		bool	removeOverlap,
		MissingETBase::UsageHandler::Policy	objScale ) const

Definition at line 332 of file ColumnarMETMaker.cxx.

                                                                                  {
    if(helper.map().empty()) {
      ATH_MSG_WARNING("Incomplete association map received. Cannot rebuild MET.");
      ATH_MSG_WARNING("Note: ColumnarMETMaker should only be run on events containing at least one PV");
      return StatusCode::SUCCESS;
    }
    ATH_MSG_VERBOSE("Building MET term " << met(m_outputMetNameAcc));
    columnar::MetHelpers::ObjectWeightHandle<> metWeights(*this,m_outputMetWeightDecRegular,met,collection);
 
    if(collection.empty()) return StatusCode::SUCCESS;
    columnar::MetHelpers::OriginalObjectHandle collectionOriginals(*this,collection);
 
    if(collectionOriginals.isShallowCopy() && collectionOriginals.originalInputs()) {
      ATH_MSG_WARNING("Shallow copy provided without \"originalObjectLinks\" decoration! "
                      << "Overlap removal cannot be done. "
                      << "Will not compute this term.");
      ATH_MSG_WARNING("Please apply xAOD::setOriginalObjectLink() from xAODBase/IParticleHelpers.h");
      return StatusCode::SUCCESS;
    }
    ATH_MSG_VERBOSE("Original inputs? " << collectionOriginals.originalInputs());
    for(const auto obj : collection) {
      if (m_inputPreselectionAcc&&!(*m_inputPreselectionAcc)(obj)) continue;
      bool selected = false;
      auto orig = collectionOriginals.getOriginal(obj);
      auto assocs = helper.getAssociations(orig);
      if(assocs.empty()) {
        std::string message = "Object is not in association map. Did you make a deep copy but fail to set the \"originalObjectLinks\" decoration? "
                              "If not, Please apply xAOD::setOriginalObjectLink() from xAODBase/IParticleHelpers.h";
        // Avoid warnings for leptons with pT below threshold for association map
        if (m_inputMomAcc.pt(orig)>m_missObjWarningPtThreshold) {
            ATH_MSG_WARNING(message);
        } else {
            ATH_MSG_DEBUG(message);
        }
        // if this is an uncalibrated electron below the threshold, then we put it into the soft term
        if(m_inputObjTypeAcc(orig)==xAOD::Type::Electron){
          metWeights.emplace_back( obj, 0 );
          message = "Missing an electron from the MET map. Included as a track in the soft term. pT: " + std::to_string(m_inputMomAcc.pt(obj)/1e3) + " GeV";
          if (m_inputMomAcc.pt(orig)>m_missObjWarningPtThreshold) {
              ATH_MSG_WARNING(message);
          } else {
              ATH_MSG_DEBUG(message);
          }
          continue;
        } else {
          ATH_MSG_ERROR("Missing an object: " << m_inputObjTypeAcc(orig) << " pT: " << m_inputMomAcc.pt(obj)/1e3 << " GeV, may be duplicated in the soft term.");
        }
      }
 
      // If the object has already been selected and processed, ignore it.
      if(helper.objSelected(orig)) continue;
      selected = helper.selectIfNoOverlaps(orig,p) || !removeOverlap;
      ATH_MSG_VERBOSE(m_inputObjTypeAcc(obj) << " (" << orig <<") with pt " << m_inputMomAcc.pt(obj)
                      << " is " << ( selected ? "non-" : "") << "overlapping");
 
      // Greedy photon options: set selection flags
      if ((m_greedyPhotons || m_veryGreedyPhotons) && selected && m_inputObjTypeAcc(obj) == xAOD::Type::Photon){
        for(auto assoc : assocs){
          auto indices = m_assocAcc.overlapIndices(assoc,orig);
          auto allObjects = m_assocAcc.objects(assoc);
          for (size_t index : indices){
            const xAOD::IParticle* thisObj = allObjects[index].getXAODObject();
            if(!thisObj) continue;
            if ((thisObj->type() == xAOD::Type::Jet && m_veryGreedyPhotons) ||
                  thisObj->type() == xAOD::Type::Electron)
              helper.setObjSelectionFlag(assoc, thisObj, true);
          }
        }
      }
 
      //Do special overlap removal for calo tagged muons
      if(m_orCaloTaggedMuon && !removeOverlap && m_inputObjTypeAcc(orig)==xAOD::Type::Muon && m_inputMuonTypeAcc.getOptional(orig)==xAOD::Muon::CaloTagged) {
        for (decltype(auto) assoc : assocs) {
          auto ind = m_assocAcc.overlapIndices(assoc,orig);
          auto allObjects = m_assocAcc.objects(assoc);
          for (size_t indi = 0; indi < ind.size(); indi++) if (allObjects[ind[indi]]) {
              if (allObjects[ind[indi]].isContainer<columnar::ContainerId::electron>()
                  && helper.objSelected(assoc, ind[indi])) {
                selected = false;
                break;
              }
            }
        }
      }
      // Don't overlap remove muons, but flag the non-overlapping muons to take out their tracks from jets
      // Removed eloss from here -- clusters already flagged.
      // To be handled in rebuildJetMET
      if(selected) {
        if(objScale==MissingETBase::UsageHandler::PhysicsObject) {
          ATH_MSG_VERBOSE("Add object with pt " << m_inputMomAcc.pt(obj));
          m_outputMetMomAcc.addParticle (met, m_inputMomAcc, obj);
        } else {
          MissingETBase::Types::constvec_t constvec = helper.getConstVec(obj,objScale);
          ATH_MSG_VERBOSE("Add truth object with pt " << constvec.cpt());
          m_outputMetMomAcc.addParticle (met, constvec.cpx(),constvec.cpy(),constvec.cpt());
        }
        metWeights.emplace_back( obj, 1. );
      }
    }
    ATH_MSG_DEBUG("Built met term " << met(m_outputMetNameAcc) << ", with magnitude " << m_outputMetMomAcc.met(met));
    return StatusCode::SUCCESS;
  }

rebuildMET() [3/6]

StatusCode met::ColumnarMETMaker::rebuildMET	(	const std::string &	metKey,
		xAOD::Type::ObjectType	metType,
		columnar::MutableMetRange	metCont,
		columnar::ParticleRange	collection,
		columnar::MetAssociationHelper<>	helper,
		MissingETBase::UsageHandler::Policy	objScale ) const

Definition at line 239 of file ColumnarMETMaker.cxx.

  {
    MissingETBase::Types::bitmask_t metSource;
    switch(metType) {
    case xAOD::Type::Electron:
      metSource = MissingETBase::Source::electron();
      break;
    case xAOD::Type::Photon:
      metSource = MissingETBase::Source::photon();
      break;
    case xAOD::Type::Tau:
      metSource = MissingETBase::Source::tau();
      break;
    case xAOD::Type::Muon:
      metSource = MissingETBase::Source::muon();
      break;
    case xAOD::Type::Jet:
      ATH_MSG_WARNING("Incorrect use of rebuildMET -- use rebuildJetMET for RefJet term");
      return StatusCode::FAILURE;
    default:
      ATH_MSG_WARNING("Invalid object type provided: " << metType);
      return StatusCode::FAILURE;
    }
 
    columnar::MutableMetId met = m_outputMetMapAcc.fillMET (metCont, metKey, metSource);
 
    // If muon eloss corrections are required, create a new term to hold these if it doesn't already exist
    if(metType==xAOD::Type::Muon && (m_muEloss || m_doSetMuonJetEMScale)) {
      if (m_outputMetMapAcc.tryCreateIfMissing (metCont, "MuonEloss", MissingETBase::Source::Type::Muon | MissingETBase::Source::Category::Calo) != StatusCode::SUCCESS) {
        ATH_MSG_ERROR("failed to create Muon Eloss MET term");
        return StatusCode::FAILURE;
      }
    }
 
    return rebuildMET(met,collection,helper,objScale);
  }

rebuildMET() [4/6]

StatusCode met::ColumnarMETMaker::rebuildMET ( const std::string & metKey, xAOD::Type::ObjectType metType, xAOD::MissingETContainer * metCont, const xAOD::IParticleContainer * collection, xAOD::MissingETAssociationHelper & helper, MissingETBase::UsageHandler::Policy objScale ) const

finaloverridevirtual

Implements IMETMaker.

Definition at line 218 of file ColumnarMETMaker.cxx.

  {
    if (!metCont)
    {
      ATH_MSG_ERROR("No MET container provided");
      return StatusCode::FAILURE;
    }
    if (!collection)
    {
      ATH_MSG_ERROR("No input collection provided for MET term \"" << metKey << "\"");
      return StatusCode::FAILURE;
    }
 
    return rebuildMET(metKey,metType,columnar::MutableMetRange (*metCont),columnar::ParticleRange (*collection),m_assocAcc(helper),objScale);
  }

rebuildMET() [5/6]

StatusCode met::ColumnarMETMaker::rebuildMET ( xAOD::MissingET * met, const xAOD::IParticleContainer * collection, xAOD::MissingETAssociationHelper & helper, MissingETBase::UsageHandler::Policy objScale ) const

finaloverridevirtual

Implements IMETMaker.

Definition at line 281 of file ColumnarMETMaker.cxx.

  {
    if (!met)
    {
      ATH_MSG_ERROR("No MET object provided");
      return StatusCode::FAILURE;
    }
    if (!collection)
    {
      ATH_MSG_ERROR("No input collection provided for MET term \"" << met->name() << "\"");
      return StatusCode::FAILURE;
    }
 
    return rebuildMET(columnar::MutableMetId(*met), columnar::ParticleRange(*collection), m_assocAcc(helper), objScale);
  }

rebuildMET() [6/6]

StatusCode met::ColumnarMETMaker::rebuildMET ( xAOD::MissingET * met, const xAOD::IParticleContainer * collection, xAOD::MissingETAssociationHelper & helper, MissingETBase::UsageHandler::Policy p, bool removeOverlap, MissingETBase::UsageHandler::Policy objScale ) const

finaloverridevirtual

Implements IMETMaker.

Definition at line 316 of file ColumnarMETMaker.cxx.

                                                                                  {
    if(!met || !collection) {
      ATH_MSG_ERROR("Invalid pointer supplied for "
                      << "MET (" << met << ") or "
                      << "collection (" << collection << ").");
      return StatusCode::FAILURE;
    }
 
    return rebuildMET(columnar::MutableMetId(*met),columnar::ParticleRange (*collection),m_assocAcc(helper),p,removeOverlap,objScale);
  }

rebuildTrackMET() [1/4]

StatusCode met::ColumnarMETMaker::rebuildTrackMET	(	columnar::MutableMetId	metJet,
		columnar::MutableMetRange	metCont,
		columnar::JetRange	jets,
		columnar::MetAssociationHelper<>	helper,
		columnar::MutableMetId	metSoftTrk,
		columnar::Met1Id	coreSoftTrk,
		bool	doJetJVT ) const

Definition at line 1186 of file ColumnarMETMaker.cxx.

                                                            {
    return rebuildJetMET(metJet,metCont,jets,helper,std::nullopt,nullptr,metSoftTrk,coreSoftTrk,doJetJVT,true);
  }

rebuildTrackMET() [2/4]

StatusCode met::ColumnarMETMaker::rebuildTrackMET	(	const std::string &	metJetKey,
		const std::string &	softTrkKey,
		columnar::MutableMetRange	metCont,
		columnar::JetRange	jets,
		columnar::Met1Range	metCoreCont,
		columnar::MetAssociationHelper<>	helper,
		bool	doJetJVT ) const

Definition at line 520 of file ColumnarMETMaker.cxx.

  {
    ATH_MSG_VERBOSE("Rebuild jet term: " << metJetKey << " and soft term: " << softKey);
 
    columnar::MutableMetId metJet {m_outputMetMapAcc.fillMET (metCont, metJetKey, MissingETBase::Source::jet() | MissingETBase::Source::track())};
 
    columnar::OptMet1Id coreSoft = m_inputMetMapAcc(metCoreCont,softKey+"Core");
    if(!coreSoft) {
      ATH_MSG_WARNING("Invalid soft term key supplied: " << softKey);
      return StatusCode::FAILURE;
    }
    auto coreSoftTrk = coreSoft.value();
 
    columnar::MutableMetId metSoftTrk {m_outputMetMapAcc.fillMET (metCont, softKey, coreSoftTrk(m_inputMetSourceAcc))};
 
    return rebuildTrackMET(metJet, metCont, jets, helper,
                           metSoftTrk,  coreSoftTrk,
                           doJetJVT);
  }

rebuildTrackMET() [3/4]

StatusCode met::ColumnarMETMaker::rebuildTrackMET ( const std::string & metJetKey, const std::string & softTrkKey, xAOD::MissingETContainer * metCont, const xAOD::JetContainer * jets, const xAOD::MissingETContainer * metCoreCont, xAOD::MissingETAssociationHelper & helper, bool doJetJVT ) const

finaloverridevirtual

Implements IMETMaker.

Definition at line 498 of file ColumnarMETMaker.cxx.

  {
    if (!metCont)
    {
      ATH_MSG_ERROR("No MET container provided");
      return StatusCode::FAILURE;
    }
    if (!jets)
    {
      ATH_MSG_ERROR("No input collection provided for MET term \"" << metJetKey << "\" and soft term: " << softKey);
      return StatusCode::FAILURE;
    }
 
    return rebuildTrackMET(metJetKey,softKey,columnar::MutableMetRange(*metCont),columnar::JetRange(*jets),columnar::Met1Range(*metCoreCont),m_assocAcc(helper),doJetJVT);
  }

rebuildTrackMET() [4/4]

StatusCode met::ColumnarMETMaker::rebuildTrackMET ( xAOD::MissingET * metJet, const xAOD::JetContainer * jets, xAOD::MissingETAssociationHelper & helper, xAOD::MissingET * metSoftTrk, const xAOD::MissingET * coreSoftTrk, bool doJetJVT ) const

finaloverridevirtual

Implements IMETMaker.

Definition at line 1163 of file ColumnarMETMaker.cxx.

                                                            {
    if (!metJet) {
      ATH_MSG_ERROR("No MET object provided for track MET rebuilding");
      return StatusCode::FAILURE;
    }
    if (!metSoftTrk) {
      ATH_MSG_ERROR("No MET object provided for soft track MET rebuilding");
      return StatusCode::FAILURE;
    }
    if (!jets) {
      ATH_MSG_ERROR("No jet container provided for track MET rebuilding");
      return StatusCode::FAILURE;
    }
 
    columnar::MutableMetRange metCont (*static_cast<MissingETContainer*>(metJet->container()));
    return rebuildJetMET(columnar::MutableMetId(*metJet),metCont,columnar::JetRange(*jets),m_assocAcc(helper),std::nullopt,nullptr,columnar::MutableMetId(*metSoftTrk),coreSoftTrk,doJetJVT,true);
  }

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

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

overridevirtualinherited

Perform system initialization for an algorithm.

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

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

m_acc_emf

columnar::JetAccessor<float> met::ColumnarMETMaker::m_acc_emf {*this, "EMFrac"}

private

Definition at line 309 of file ColumnarMETMaker.h.

{*this, "EMFrac"};

m_acc_jetRejectionDec

std::optional<columnar::JetAccessor<char> > met::ColumnarMETMaker::m_acc_jetRejectionDec

private

Definition at line 318 of file ColumnarMETMaker.h.

m_acc_psf

columnar::JetAccessor<float> met::ColumnarMETMaker::m_acc_psf {*this, "PSFrac"}

private

Definition at line 310 of file ColumnarMETMaker.h.

{*this, "PSFrac"};

m_acc_sampleE

columnar::JetAccessor<std::vector<float> > met::ColumnarMETMaker::m_acc_sampleE {*this, "EnergyPerSampling"}

private

Definition at line 314 of file ColumnarMETMaker.h.

{*this, "EnergyPerSampling"};

m_acc_trkN

columnar::JetAccessor<std::vector<int> > met::ColumnarMETMaker::m_acc_trkN {*this, "NumTrkPt500"}

private

Definition at line 312 of file ColumnarMETMaker.h.

{*this, "NumTrkPt500"};

m_acc_trksumpt

columnar::JetAccessor<std::vector<float> > met::ColumnarMETMaker::m_acc_trksumpt {*this, "SumPtTrkPt500"}

private

Definition at line 313 of file ColumnarMETMaker.h.

{*this, "SumPtTrkPt500"};

m_acc_width

columnar::JetAccessor<float> met::ColumnarMETMaker::m_acc_width {*this, "Width"}

private

Definition at line 311 of file ColumnarMETMaker.h.

{*this, "Width"};

m_assocAcc

columnar::MetAssocationAccessors met::ColumnarMETMaker::m_assocAcc {*this}

private

Definition at line 298 of file ColumnarMETMaker.h.

{*this};

m_CenJetPtCut

double met::ColumnarMETMaker::m_CenJetPtCut {}

private

Definition at line 235 of file ColumnarMETMaker.h.

{}, m_FwdJetPtCut{} ; // jet pt cut for central/forward jets

m_columnarDoJetJVT

Gaudi::Property<bool> met::ColumnarMETMaker::m_columnarDoJetJVT {this, "columnarDoJetJVT", false}

private

Definition at line 330 of file ColumnarMETMaker.h.

{this, "columnarDoJetJVT", false};

m_columnarJetKey

Gaudi::Property<std::string> met::ColumnarMETMaker::m_columnarJetKey {this, "columnarJetKey", ""}

private

Definition at line 328 of file ColumnarMETMaker.h.

{this, "columnarJetKey", ""};

m_columnarOperation

Gaudi::Property<unsigned> met::ColumnarMETMaker::m_columnarOperation {this, "columnarOperation", 0}

private

Definition at line 325 of file ColumnarMETMaker.h.

{this, "columnarOperation", 0};

m_columnarParticleType

Gaudi::Property<unsigned> met::ColumnarMETMaker::m_columnarParticleType {this, "columnarParticleType", 0}

private

Definition at line 327 of file ColumnarMETMaker.h.

{this, "columnarParticleType", 0};

m_columnarSoftClusKey

Gaudi::Property<std::string> met::ColumnarMETMaker::m_columnarSoftClusKey {this, "columnarSoftClusKey", ""}

private

Definition at line 329 of file ColumnarMETMaker.h.

{this, "columnarSoftClusKey", ""};

m_columnarTermName

Gaudi::Property<std::string> met::ColumnarMETMaker::m_columnarTermName {this, "columnarTermName", ""}

private

Definition at line 326 of file ColumnarMETMaker.h.

{this, "columnarTermName", ""};

m_customCenJetPtCut

double met::ColumnarMETMaker::m_customCenJetPtCut {}

private

Definition at line 244 of file ColumnarMETMaker.h.

{},m_customFwdJetPtCut{};

m_customFwdJetPtCut

double met::ColumnarMETMaker::m_customFwdJetPtCut {}

private

Definition at line 244 of file ColumnarMETMaker.h.

{},m_customFwdJetPtCut{};

m_customJvtPtMax

double met::ColumnarMETMaker::m_customJvtPtMax {}

private

Definition at line 245 of file ColumnarMETMaker.h.

{};

m_customJvtWP

std::string met::ColumnarMETMaker::m_customJvtWP

private

Definition at line 246 of file ColumnarMETMaker.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doConstJet

bool met::ColumnarMETMaker::m_doConstJet {}

private

Definition at line 250 of file ColumnarMETMaker.h.

{};

m_doPFlow

bool met::ColumnarMETMaker::m_doPFlow {}

private

Definition at line 248 of file ColumnarMETMaker.h.

{};

m_doRemoveElecTrks

bool met::ColumnarMETMaker::m_doRemoveElecTrks {}

private

Definition at line 254 of file ColumnarMETMaker.h.

{};

m_doRemoveElecTrksEM

bool met::ColumnarMETMaker::m_doRemoveElecTrksEM {}

private

Definition at line 255 of file ColumnarMETMaker.h.

{};

m_doRemoveMuonJets

bool met::ColumnarMETMaker::m_doRemoveMuonJets {}

private

Definition at line 253 of file ColumnarMETMaker.h.

{};

m_doSetMuonJetEMScale

bool met::ColumnarMETMaker::m_doSetMuonJetEMScale {}

private

Definition at line 256 of file ColumnarMETMaker.h.

{};

m_doSoftTruth

bool met::ColumnarMETMaker::m_doSoftTruth {}

private

Definition at line 249 of file ColumnarMETMaker.h.

{};

m_electronPtAcc

columnar::ElectronAccessor<columnar::RetypeColumn<double,float> > met::ColumnarMETMaker::m_electronPtAcc {*this, "pt"}

private

Definition at line 323 of file ColumnarMETMaker.h.

{*this, "pt"};

m_electronsHandle

columnar::ElectronAccessor<columnar::ObjectColumn> met::ColumnarMETMaker::m_electronsHandle {*this, "Electrons"}

private

Definition at line 285 of file ColumnarMETMaker.h.

{*this, "Electrons"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_FwdJetPtCut

double met::ColumnarMETMaker::m_FwdJetPtCut {}

private

Definition at line 235 of file ColumnarMETMaker.h.

{}, m_FwdJetPtCut{} ; // jet pt cut for central/forward jets

m_greedyPhotons

bool met::ColumnarMETMaker::m_greedyPhotons {}

private

Definition at line 261 of file ColumnarMETMaker.h.

{};

m_inputMetHandle

columnar::Met1Accessor<columnar::ObjectColumn> met::ColumnarMETMaker::m_inputMetHandle {*this, "METCore", {.addMTDependency=true}}

private

Definition at line 281 of file ColumnarMETMaker.h.

{*this, "METCore", {.addMTDependency=true}};

m_inputMetMapAcc

columnar::MetHelpers::MapLookupAccessor<columnar::ContainerId::met1> met::ColumnarMETMaker::m_inputMetMapAcc {*this}

private

Definition at line 294 of file ColumnarMETMaker.h.

{*this};

m_inputMetMomAcc

columnar::MetHelpers::MetMomentumAccessors<columnar::ContainerId::met1> met::ColumnarMETMaker::m_inputMetMomAcc {*this}

private

Definition at line 295 of file ColumnarMETMaker.h.

{*this};

m_inputMetNameAcc

columnar::Met1Accessor<std::string> met::ColumnarMETMaker::m_inputMetNameAcc {*this, "name"}

private

Definition at line 293 of file ColumnarMETMaker.h.

{*this, "name"};

m_inputMetSourceAcc

columnar::Met1Accessor<MissingETBase::Types::bitmask_t> met::ColumnarMETMaker::m_inputMetSourceAcc {*this, "source"}

private

Definition at line 296 of file ColumnarMETMaker.h.

{*this, "source"};

m_inputMomAcc

columnar::MetHelpers::InputMomentumAccessors met::ColumnarMETMaker::m_inputMomAcc {*this}

private

Definition at line 300 of file ColumnarMETMaker.h.

{*this};

m_inputMuonTypeAcc

columnar::ParticleAccessor<columnar::RetypeColumn<xAOD::Muon::MuonType,std::uint16_t> > met::ColumnarMETMaker::m_inputMuonTypeAcc {*this, "muonType", {.isOptional = true}}

private

Definition at line 303 of file ColumnarMETMaker.h.

{*this, "muonType", {.isOptional = true}};

m_inputObjTypeAcc

columnar::MetHelpers::ObjectTypeAccessor<columnar::ContainerId::particle> met::ColumnarMETMaker::m_inputObjTypeAcc {*this, "objectType"}

private

Definition at line 304 of file ColumnarMETMaker.h.

{*this, "objectType"};

m_inputPreselectionAcc

std::optional<columnar::ParticleAccessor<char> > met::ColumnarMETMaker::m_inputPreselectionAcc

private

Definition at line 302 of file ColumnarMETMaker.h.

m_inputPreselectionName

Gaudi::Property<std::string> met::ColumnarMETMaker::m_inputPreselectionName {this, "inputPreselection", ""}

private

Definition at line 301 of file ColumnarMETMaker.h.

{this, "inputPreselection", ""};

m_jetConstitScaleMom

std::string met::ColumnarMETMaker::m_jetConstitScaleMom

private

Definition at line 231 of file ColumnarMETMaker.h.

m_jetConstitScaleMomAcc

std::optional<columnar::MetHelpers::InputMomentumAccessors<columnar::ContainerId::jet> > met::ColumnarMETMaker::m_jetConstitScaleMomAcc

private

Definition at line 316 of file ColumnarMETMaker.h.

m_jetConstitScaleMomFixedAcc

std::optional<columnar::MetHelpers::InputMomentumAccessors<columnar::ContainerId::jet> > met::ColumnarMETMaker::m_jetConstitScaleMomFixedAcc

private

Definition at line 317 of file ColumnarMETMaker.h.

m_jetContainer

SG::ReadHandleKey<xAOD::JetContainer> met::ColumnarMETMaker::m_jetContainer {this, "JetContainer", "", "Name of input jet container (required if JVT decisions computed by internal tool)"}

private

Definition at line 275 of file ColumnarMETMaker.h.

{this, "JetContainer", "", "Name of input jet container (required if JVT decisions computed by internal tool)"};

m_jetCorrectPhi

bool met::ColumnarMETMaker::m_jetCorrectPhi {}

private

Definition at line 228 of file ColumnarMETMaker.h.

{};

m_jetEmfMuOlap

double met::ColumnarMETMaker::m_jetEmfMuOlap {}

private

Definition at line 268 of file ColumnarMETMaker.h.

{};

m_JetEtaForw

double met::ColumnarMETMaker::m_JetEtaForw {}

private

Definition at line 238 of file ColumnarMETMaker.h.

{};

m_JetEtaMax

double met::ColumnarMETMaker::m_JetEtaMax {}

private

Definition at line 237 of file ColumnarMETMaker.h.

{};

m_jetJvtMomentName

std::string met::ColumnarMETMaker::m_jetJvtMomentName

private

Definition at line 232 of file ColumnarMETMaker.h.

m_jetMinEfrac

double met::ColumnarMETMaker::m_jetMinEfrac {}

private

Definition at line 229 of file ColumnarMETMaker.h.

{};

m_jetMinWeightedPt

double met::ColumnarMETMaker::m_jetMinWeightedPt {}

private

Definition at line 230 of file ColumnarMETMaker.h.

{};

m_jetMomAcc

columnar::MetHelpers::InputMomentumAccessors<columnar::ContainerId::jet> met::ColumnarMETMaker::m_jetMomAcc {*this}

private

Definition at line 308 of file ColumnarMETMaker.h.

{*this};

m_jetOutputMetWeightDecRegular

columnar::MetHelpers::ObjectWeightDecorator<columnar::ContainerId::mutableMet,columnar::ContainerId::jet> met::ColumnarMETMaker::m_jetOutputMetWeightDecRegular {*this, "", true}

private

Definition at line 320 of file ColumnarMETMaker.h.

{*this, "", true};

m_jetOutputMetWeightDecSoft

columnar::MetHelpers::ObjectWeightDecorator<columnar::ContainerId::mutableMet,columnar::ContainerId::jet> met::ColumnarMETMaker::m_jetOutputMetWeightDecSoft {*this, "Soft", false}

private

Definition at line 321 of file ColumnarMETMaker.h.

{*this, "Soft", false};

m_jetPsEMuOlap

double met::ColumnarMETMaker::m_jetPsEMuOlap {}

private

Definition at line 267 of file ColumnarMETMaker.h.

{};

m_jetRejectionDec

std::string met::ColumnarMETMaker::m_jetRejectionDec

private

Definition at line 233 of file ColumnarMETMaker.h.

m_jetSelection

std::string met::ColumnarMETMaker::m_jetSelection

private

Definition at line 240 of file ColumnarMETMaker.h.

m_jetsHandle

columnar::JetAccessor<columnar::ObjectColumn> met::ColumnarMETMaker::m_jetsHandle {*this, "Jets"}

private

Definition at line 284 of file ColumnarMETMaker.h.

{*this, "Jets"};

m_jetTrkNMuOlap

int met::ColumnarMETMaker::m_jetTrkNMuOlap {}

private

Definition at line 265 of file ColumnarMETMaker.h.

{};

m_jetTrkPtMuPt

double met::ColumnarMETMaker::m_jetTrkPtMuPt {}

private

Definition at line 269 of file ColumnarMETMaker.h.

{};

m_jetWidthMuOlap

double met::ColumnarMETMaker::m_jetWidthMuOlap {}

private

Definition at line 266 of file ColumnarMETMaker.h.

{};

m_JvtCut

double met::ColumnarMETMaker::m_JvtCut {}

private

Definition at line 236 of file ColumnarMETMaker.h.

{}, m_JvtPtMax{}; // JVT cut and pt region of jets to apply a JVT selection

m_JvtPtMax

double met::ColumnarMETMaker::m_JvtPtMax {}

private

Definition at line 236 of file ColumnarMETMaker.h.

{}, m_JvtPtMax{}; // JVT cut and pt region of jets to apply a JVT selection

m_JvtTool

ToolHandle<IAsgSelectionTool> met::ColumnarMETMaker::m_JvtTool

private

Definition at line 273 of file ColumnarMETMaker.h.

m_JvtWP

std::string met::ColumnarMETMaker::m_JvtWP

private

Definition at line 241 of file ColumnarMETMaker.h.

m_metAssocHandle

columnar::ColumnAccessor<columnar::ContainerId::metAssociation,columnar::ObjectColumn> met::ColumnarMETMaker::m_metAssocHandle {*this, "MetAssoc", {.addMTDependency=true}}

private

Definition at line 282 of file ColumnarMETMaker.h.

{*this, "MetAssoc", {.addMTDependency=true}};

m_missObjWarningPtThreshold

float met::ColumnarMETMaker::m_missObjWarningPtThreshold

private

Definition at line 226 of file ColumnarMETMaker.h.

m_muEloss

bool met::ColumnarMETMaker::m_muEloss {}

private

Definition at line 259 of file ColumnarMETMaker.h.

{};

m_muIDPTJetPtRatioMuOlap

double met::ColumnarMETMaker::m_muIDPTJetPtRatioMuOlap {}

private

Definition at line 270 of file ColumnarMETMaker.h.

{};

m_muonsHandle

columnar::MuonAccessor<columnar::ObjectColumn> met::ColumnarMETMaker::m_muonsHandle {*this, "Muons"}

private

Definition at line 287 of file ColumnarMETMaker.h.

{*this, "Muons"};

m_orCaloTaggedMuon

bool met::ColumnarMETMaker::m_orCaloTaggedMuon {}

private

Definition at line 260 of file ColumnarMETMaker.h.

{};

m_outputMetHandle

columnar::MutableMetAccessor<columnar::ObjectColumn> met::ColumnarMETMaker::m_outputMetHandle {*this, "OutputMET"}

private

Definition at line 280 of file ColumnarMETMaker.h.

{*this, "OutputMET"};

m_outputMetMapAcc

columnar::MetHelpers::MapLookupAccessor<columnar::ContainerId::mutableMet> met::ColumnarMETMaker::m_outputMetMapAcc {*this}

private

Definition at line 290 of file ColumnarMETMaker.h.

{*this};

m_outputMetMomAcc

columnar::MetHelpers::MetMomentumAccessors<columnar::ContainerId::mutableMet> met::ColumnarMETMaker::m_outputMetMomAcc {*this}

private

Definition at line 291 of file ColumnarMETMaker.h.

{*this};

m_outputMetNameAcc

columnar::MutableMetAccessor<std::string> met::ColumnarMETMaker::m_outputMetNameAcc {*this, "name"}

private

Definition at line 289 of file ColumnarMETMaker.h.

{*this, "name"};

m_outputMetWeightDecRegular

columnar::MetHelpers::ObjectWeightDecorator met::ColumnarMETMaker::m_outputMetWeightDecRegular {*this, "", true}

private

Definition at line 306 of file ColumnarMETMaker.h.

{*this, "", true};

m_particlesHandle

columnar::ParticleAccessor<columnar::ObjectColumn> met::ColumnarMETMaker::m_particlesHandle {*this, "Particles"}

private

Definition at line 283 of file ColumnarMETMaker.h.

{*this, "Particles"};

m_photonsHandle

columnar::PhotonAccessor<columnar::ObjectColumn> met::ColumnarMETMaker::m_photonsHandle {*this, "Photons"}

private

Definition at line 286 of file ColumnarMETMaker.h.

{*this, "Photons"};

m_PVkey

SG::ReadHandleKey<xAOD::VertexContainer> met::ColumnarMETMaker::m_PVkey

private

Definition at line 223 of file ColumnarMETMaker.h.

m_skipSystematicJetSelection

bool met::ColumnarMETMaker::m_skipSystematicJetSelection {}

private

Definition at line 257 of file ColumnarMETMaker.h.

{};

m_trkseltool

ToolHandle<InDet::IInDetTrackSelectionTool> met::ColumnarMETMaker::m_trkseltool

private

Definition at line 272 of file ColumnarMETMaker.h.

m_useGhostMuons

bool met::ColumnarMETMaker::m_useGhostMuons {}

private

Definition at line 252 of file ColumnarMETMaker.h.

{};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_veryGreedyPhotons

bool met::ColumnarMETMaker::m_veryGreedyPhotons {}

private

Definition at line 262 of file ColumnarMETMaker.h.

{};

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

The documentation for this class was generated from the following files:

• ColumnarMETMaker.h
• ColumnarMETMaker.cxx