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

#include <METMaker.h>

Inheritance diagram for met::METMaker:
Collaboration diagram for met::METMaker:

Public Member Functions

 METMaker (const std::string &name)
 Constructor with parameters: More...
 
virtual ~METMaker ()
 Destructor: More...
 
virtual StatusCode initialize () override final
 Dummy implementation of the initialisation function. More...
 
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) override final
 
virtual StatusCode rebuildMET (xAOD::MissingET *met, const xAOD::IParticleContainer *collection, xAOD::MissingETAssociationHelper &helper, MissingETBase::UsageHandler::Policy objScale) override final
 
virtual StatusCode rebuildMET (xAOD::MissingET *met, const xAOD::IParticleContainer *collection, xAOD::MissingETAssociationHelper &helper, MissingETBase::UsageHandler::Policy p, bool removeOverlap, MissingETBase::UsageHandler::Policy objScale) override final
 
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) override final
 
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) override final
 
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) override final
 
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) override final
 
virtual StatusCode retrieveOverlapRemovedConstituents (const xAOD::PFOContainer *cpfo, const xAOD::PFOContainer *npfo, xAOD::MissingETAssociationHelper &metHelper, xAOD::PFOContainer *OR_cpfos, xAOD::PFOContainer *OR_npfos, bool retainMuon=false, const xAOD::IParticleContainer *muonCollection=0) override final
 
virtual StatusCode retrieveOverlapRemovedConstituents (const xAOD::PFOContainer *pfo, xAOD::MissingETAssociationHelper &metHelper, const xAOD::PFOContainer **OR_pfos, bool retainMuon, const xAOD::IParticleContainer *muonCollection) override final
 
virtual const xAOD::PFOContainer * retrieveOverlapRemovedConstituents (const xAOD::PFOContainer *signals, xAOD::MissingETAssociationHelper &helper, bool retainMuon=false, const xAOD::IParticleContainer *muonCollection=0, MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::ParticleFlow) override final
 
virtual StatusCode rebuildTrackMET (xAOD::MissingET *metJet, const xAOD::JetContainer *jets, xAOD::MissingETAssociationHelper &helper, xAOD::MissingET *metSoftTrk, const xAOD::MissingET *coreSoftTrk, bool doJetJVT) override final
 
virtual StatusCode markInvisible (const xAOD::IParticleContainer *collection, xAOD::MissingETAssociationHelper &helper, xAOD::MissingETContainer *metCont) override final
 
virtual void print () const
 Print the state of the tool. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

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

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

bool acceptTrack (const xAOD::TrackParticle *trk, const xAOD::Vertex *vx) const
 
const xAOD::Vertex * getPV () const
 
 METMaker ()
 Default constructor: More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

SG::ReadHandleKey< xAOD::VertexContainer > m_PVkey
 
std::unique_ptr< SG::AuxElement::ConstAccessor< float > > m_acc_jetJvtMoment
 
std::unique_ptr< SG::AuxElement::ConstAccessor< char > > m_acc_jetRejectionDec
 
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
 
bool m_useR21JvtFallback
 
double m_JvtCutTight
 
double m_JvtTightPtMax
 
double m_JvtCutMedium
 
double m_JvtMediumPtMax
 
double m_customCenJetPtCut
 
double m_customFwdJetPtCut
 
double m_customJvtCut
 
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
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 40 of file METMaker.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

◆ METMaker() [1/2]

met::METMaker::METMaker ( const std::string &  name)

Constructor with parameters:

Definition at line 95 of file METMaker.cxx.

95  :
96  AsgTool(name),
97  m_PVkey("PrimaryVertices"),
98  m_acc_jetJvtMoment(nullptr),
99  m_acc_jetRejectionDec(nullptr),
100  m_JvtCutTight(-100.0),
101  m_JvtTightPtMax(-100.0),
102  m_JvtCutMedium(-100.0),
103  m_JvtMediumPtMax(-100.0),
104  m_trkseltool(""),
105  m_JvtTool("", this)
106  {
107  //
108  // Property declaration
109  //
110 
111  // declareProperty("VxColl", m_pvcoll = "PrimaryVertices" );
112 
113  declareProperty("JetJvtMomentName", m_jetJvtMomentName = "Jvt" );
114  declareProperty("JetRejectionDec", m_jetRejectionDec = "" );
115  declareProperty("JetMinEFrac", m_jetMinEfrac = 0.0 );
116  declareProperty("JetMinWeightedPt", m_jetMinWeightedPt = 20.0e3 );
117  //declareProperty("JetConstitScaleMom", m_jetConstitScaleMom = "JetLCScaleMomentum");
118  declareProperty("JetConstitScaleMom", m_jetConstitScaleMom = "JetConstitScaleMomentum");
119  declareProperty("CorrectJetPhi", m_jetCorrectPhi = false );
120  declareProperty("DoPFlow", m_doPFlow = false );
121  declareProperty("DoSoftTruth", m_doSoftTruth = false );
122  declareProperty("DoJetTruth", m_doConstJet = false );
123 
124  declareProperty("JetSelection", m_jetSelection = "Tight" );
125  declareProperty("JetEtaMax", m_JetEtaMax = 4.5 );
126  declareProperty("JetEtaForw", m_JetEtaForw = 2.5 );
127  declareProperty("UseR21JvtFallback", m_useR21JvtFallback = false );
128  declareProperty("CustomCentralJetPt", m_customCenJetPtCut = 20e3 );
129  declareProperty("CustomForwardJetPt", m_customFwdJetPtCut = 20e3 );
130  declareProperty("CustomJetJvtCut", m_customJvtCut = 0.59 );
131  declareProperty("CustomJetJvtPtMax", m_customJvtPtMax = 60e3 );
132 
133  declareProperty("DoMuonEloss", m_muEloss = false );
134  declareProperty("ORCaloTaggedMuons", m_orCaloTaggedMuon = true );
135  declareProperty("GreedyPhotons", m_greedyPhotons = false );
136  declareProperty("VeryGreedyPhotons", m_veryGreedyPhotons = false );
137 
138  declareProperty("UseGhostMuons", m_useGhostMuons = false );
139  declareProperty("DoRemoveMuonJets", m_doRemoveMuonJets = true );
140  declareProperty("DoSetMuonJetEMScale", m_doSetMuonJetEMScale = true );
141 
142  declareProperty("DoRemoveElecTrks", m_doRemoveElecTrks = true );
143  declareProperty("DoRemoveElecTrksEM", m_doRemoveElecTrksEM = false );
144 
145  declareProperty("skipSystematicJetSelection", m_skipSystematicJetSelection = false,
146  "EXPERIMENTAL: whether to use simplified OR based on nominal jets "
147  "and for jet-related systematics only. "
148  "WARNING: this property is strictly for doing physics studies of the feasibility "
149  "of this OR scheme, it should not be used in a regular analysis");
150 
151  // muon overlap variables (expert use only)
152  declareProperty("JetTrkNMuOlap", m_jetTrkNMuOlap = 5 );
153  declareProperty("JetWidthMuOlap", m_jetWidthMuOlap = 0.1 );
154  declareProperty("JetPsEMuOlap", m_jetPsEMuOlap = 2.5e3 );
155  declareProperty("JetEmfMuOlap", m_jetEmfMuOlap = 0.9 );
156  declareProperty("JetTrkPtMuPt", m_jetTrkPtMuPt = 0.8 );
157  declareProperty("muIDPTJetPtRatioMuOlap", m_muIDPTJetPtRatioMuOlap = 2.0 );
158 
159  declareProperty("MissingObjWarnThreshold", m_missObjWarningPtThreshold = 7.0e3 );
160 
161  declareProperty("TrackSelectorTool", m_trkseltool );
162  declareProperty("JvtSelTool", m_JvtTool );
163  }

◆ ~METMaker()

met::METMaker::~METMaker ( )
virtualdefault

Destructor:

◆ METMaker() [2/2]

met::METMaker::METMaker ( )
private

Default constructor:

Member Function Documentation

◆ acceptTrack()

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

Definition at line 1393 of file METMaker.cxx.

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

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

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

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

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

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

◆ 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::METMaker::getPV ( ) const
private

Definition at line 1398 of file METMaker.cxx.

1398  {
1399 
1400  const xAOD::Vertex *pv = nullptr;
1401 
1402  SG::ReadHandle<xAOD::VertexContainer> h_PV(m_PVkey);
1403 
1404  if (!h_PV.isValid()) {
1405 
1406  ATH_MSG_WARNING("Unable to retrieve primary vertex container PrimaryVertices");
1407 
1408  } else if(h_PV->empty()) {
1409 
1410  ATH_MSG_WARNING("Event has no primary vertices!");
1411 
1412  } else {
1413 
1414  ATH_MSG_DEBUG("Successfully retrieved primary vertex container");
1415 
1416  for(const auto *const vx : *h_PV) {
1417 
1418  if(vx->vertexType()==xAOD::VxType::PriVtx) {
1419 
1420  pv = vx; break;
1421 
1422  }
1423 
1424  }
1425 
1426  }
1427 
1428  return pv;
1429 
1430  }

◆ initialize()

StatusCode met::METMaker::initialize ( )
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 172 of file METMaker.cxx.

173  {
174  ATH_MSG_INFO ("Initializing " << name() << "...");
175 
176  //default jet selection i.e. pre-recommendation
177  ATH_MSG_INFO("Use jet selection criterion: " << m_jetSelection << " PFlow: " << m_doPFlow);
178  // note: default in R22 is to let the JvtTool apply the NNJvt cuts based on the chosen WP;
179  // only if m_useR21JvtFallback is used the Jvt requirements based on m_JvtCut are applied manually
180  if (m_jetSelection == "Loose") { m_CenJetPtCut = 20e3; m_FwdJetPtCut = 20e3; m_JvtWP = "FixedEffPt"; m_JvtCut = m_doPFlow ? 0.5 : 0.59; m_JvtPtMax = 60e3; }
181  else if (m_jetSelection == "Tight") { m_CenJetPtCut = 20e3; m_FwdJetPtCut = 30e3; m_JvtWP = "FixedEffPt"; m_JvtCut = m_doPFlow ? 0.5 : 0.59; m_JvtPtMax = 60e3; }
182  else if (m_jetSelection == "Tighter"){ m_CenJetPtCut = 20e3; m_FwdJetPtCut = 35e3; m_JvtWP = "FixedEffPt"; m_JvtCut = m_doPFlow ? 0.5 : 0.59; m_JvtPtMax = 60e3; }
183  else if (m_jetSelection == "Tenacious"){ m_CenJetPtCut = 20e3; m_FwdJetPtCut = 40e3; m_JvtWP = "FixedEffPt"; m_JvtCut = m_doPFlow ? 0.5 : 0.59; m_JvtPtMax = 60e3; }
184  else if (m_jetSelection == "Tier0") { m_CenJetPtCut = 0; m_FwdJetPtCut = 0; m_JvtCut = -1; m_JvtPtMax = 0; m_useR21JvtFallback = true;}
185  else if (m_jetSelection == "Expert") {
186  ATH_MSG_INFO("Custom jet selection configured. *** FOR EXPERT USE ONLY ***");
187  m_CenJetPtCut = m_customCenJetPtCut;
188  m_FwdJetPtCut = m_customFwdJetPtCut;
189  m_JvtCut = m_customJvtCut;
190  m_JvtPtMax = m_customJvtPtMax;
191  m_JvtWP = m_customJvtWP;
192  }
193  else if (m_jetSelection == "HRecoil") {
194  ATH_MSG_INFO("Jet selection for hadronic recoil calculation is configured.");
195  m_CenJetPtCut = 9999e3;
196  m_FwdJetPtCut = 9999e3;
197  m_JetEtaMax = 5;
198  //m_JvtCut = 0.; // currently skip
199  //m_JvtPtMax = 0.; // currently skip
200  // this WP also requires that we place the Jvt cuts manually
201  m_useR21JvtFallback = true;
202  }
203  else {
204  if (m_jetSelection == "Default") ATH_MSG_WARNING( "WARNING: Default is now deprecated" );
205  ATH_MSG_ERROR( "Error: No available jet selection found! Please update JetSelection in METMaker. Choose one: Loose, Tight (recommended), Tighter, Tenacious" );
206  return StatusCode::FAILURE;
207  }
208 
209  // if using the old R21 Jvt cuts also enforce the same forward threshold
210  if (m_useR21JvtFallback) m_JetEtaForw = 2.4;
211 
212  if (!m_trkseltool.empty()) ATH_CHECK( m_trkseltool.retrieve() );
213 
214  // do not setup Jvt tool if we use the fallback option, i.e. apply Jvt requirements manually
215  if (!m_useR21JvtFallback) {
216  if (m_JvtTool.empty()) {
217  asg::AsgToolConfig config_jvt ("CP::NNJvtSelectionTool/JvtSelTool");
218  ATH_CHECK(config_jvt.setProperty("WorkingPoint", m_JvtWP));
219  ATH_CHECK(config_jvt.setProperty("JvtMomentName", "NNJvt"));
220  ATH_CHECK(config_jvt.setProperty("MaxPtForJvt", m_JvtPtMax));
221  ATH_CHECK(config_jvt.makePrivateTool(m_JvtTool));
222  }
223  ATH_CHECK(m_JvtTool.retrieve());
224  }
225 
226  // ReadHandleKey(s)
227  ATH_CHECK( m_PVkey.initialize() );
228 
229  // configurable accessors
230  m_acc_jetJvtMoment = std::make_unique<SG::AuxElement::ConstAccessor<float>>(m_jetJvtMomentName);
231  if (!m_jetRejectionDec.empty()) {
232  m_acc_jetRejectionDec = std::make_unique<SG::AuxElement::ConstAccessor<char>>(m_jetRejectionDec);
233  ATH_MSG_INFO("Applying additional jet rejection criterium in MET calculation: " << m_jetRejectionDec);
234  }
235 
236  ATH_MSG_INFO("Suppressing warnings of objects missing in METAssociationMap for objects with pT < " << m_missObjWarningPtThreshold/1e3 << " GeV.");
237 
238  // overlap removal simplification?
239  if (m_skipSystematicJetSelection) {
240  ATH_MSG_INFO("Requesting simplified overlap removal procedure in MET calculation");
241  }
242 
243  return StatusCode::SUCCESS;
244  }

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

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

Implements IMETMaker.

Definition at line 1242 of file METMaker.cxx.

1245  {
1246 
1247  MissingET* met = nullptr;
1248  if( fillMET(met,metCont, "Invisibles" , invisSource) != StatusCode::SUCCESS) {
1249  ATH_MSG_ERROR("failed to fill MET term \"Invisibles\"");
1250  return StatusCode::FAILURE;
1251  }
1252 
1253  return rebuildMET(met,collection,helper,MissingETBase::UsageHandler::PhysicsObject);
1254  }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

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

101  {
102 
103  return MSG::name( msg().level() );
104  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ 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 JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, top::TopObjectSelection, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

131  {
132 
133  ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
134  return;
135  }

◆ rebuildJetMET() [1/3]

StatusCode met::METMaker::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 
)
finaloverridevirtual

Implements IMETMaker.

Definition at line 479 of file METMaker.cxx.

486  {
487  ATH_MSG_VERBOSE("Rebuild jet term: " << metJetKey << " and soft term: " << softKey);
488 
489  MissingET* metJet = nullptr;
490  if( fillMET(metJet,metCont, metJetKey, MissingETBase::Source::jet()) != StatusCode::SUCCESS) {
491  ATH_MSG_ERROR("failed to fill MET term \"" << metJetKey << "\"");
492  return StatusCode::FAILURE;
493  }
494 
495  const MissingET *coreSoftClus(nullptr), *coreSoftTrk(nullptr);
496  MissingET *metSoftClus(nullptr), *metSoftTrk(nullptr);
497 
498  const MissingET* coreSoft = (*metCoreCont)[softKey+"Core"];
499  if(!coreSoft) {
500  ATH_MSG_WARNING("Invalid soft term key supplied: " << softKey);
501  return StatusCode::FAILURE;
502  }
503  if(MissingETBase::Source::isTrackTerm(coreSoft->source())) {
504  coreSoftTrk = coreSoft;
505 
506  metSoftTrk = nullptr;
507  if( fillMET(metSoftTrk,metCont, softKey , coreSoftTrk->source() ) != StatusCode::SUCCESS) {
508  ATH_MSG_ERROR("failed to fill MET term \"" << softKey << "\"");
509  return StatusCode::FAILURE;
510  }
511  } else {
512  coreSoftClus = coreSoft;
513 
514  metSoftClus = nullptr;
515  if( fillMET(metSoftClus, metCont, softKey , coreSoftClus->source() ) != StatusCode::SUCCESS) {
516  ATH_MSG_ERROR("failed to fill MET term \"" << softKey << "\"");
517  return StatusCode::FAILURE;
518  }
519  }
520 
521  return rebuildJetMET(metJet, jets, helper,
522  metSoftClus, coreSoftClus,
523  metSoftTrk, coreSoftTrk,
524  doJetJVT);
525  }

◆ rebuildJetMET() [2/3]

StatusCode met::METMaker::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 
)
finaloverridevirtual

Implements IMETMaker.

Definition at line 564 of file METMaker.cxx.

572  {
573 
574  ATH_MSG_VERBOSE("Create Jet MET " << metJetKey);
575  MissingET* metJet = nullptr;
576  if( fillMET(metJet , metCont ,metJetKey , MissingETBase::Source::jet()) != StatusCode::SUCCESS) {
577  ATH_MSG_ERROR("failed to fill MET term \"" << metJetKey << "\"");
578  return StatusCode::FAILURE;
579  }
580  ATH_MSG_VERBOSE("Create SoftClus MET " << softClusKey);
581  const MissingET* coreSoftClus = (*metCoreCont)[softClusKey+"Core"];
582  ATH_MSG_VERBOSE("Create SoftTrk MET " << softTrkKey);
583  const MissingET* coreSoftTrk = (*metCoreCont)[softTrkKey+"Core"];
584  if(!coreSoftClus) {
585  ATH_MSG_WARNING("Invalid cluster soft term key supplied: " << softClusKey);
586  return StatusCode::FAILURE;
587  }
588  if(!coreSoftTrk) {
589  ATH_MSG_WARNING("Invalid track soft term key supplied: " << softTrkKey);
590  return StatusCode::FAILURE;
591  }
592  MissingET* metSoftClus = nullptr;
593  if( fillMET(metSoftClus, metCont, softClusKey, coreSoftClus->source()) != StatusCode::SUCCESS) {
594  ATH_MSG_ERROR("failed to fill MET term \"" << softClusKey << "\"");
595  return StatusCode::FAILURE;
596  }
597 
598  MissingET* metSoftTrk = nullptr;
599  if( fillMET(metSoftTrk, metCont, softTrkKey, coreSoftTrk->source()) != StatusCode::SUCCESS) {
600  ATH_MSG_ERROR("failed to fill MET term \"" << softTrkKey << "\"");
601  return StatusCode::FAILURE;
602  }
603 
604  return rebuildJetMET(metJet, jets, helper,
605  metSoftClus, coreSoftClus,
606  metSoftTrk, coreSoftTrk,
607  doJetJVT);
608  }

◆ rebuildJetMET() [3/3]

StatusCode met::METMaker::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 
)
finaloverridevirtual

Implements IMETMaker.

Definition at line 610 of file METMaker.cxx.

619  {
620  if(!metJet || !jets) {
621  ATH_MSG_WARNING("Invalid pointer supplied for "
622  << "MET (" << metJet << ") or "
623  << "jet collection (" << jets << ").");
624  return StatusCode::SUCCESS;
625  }
626  const xAOD::MissingETAssociationMap* map = helper.map();
627  if(!map){
628  ATH_MSG_WARNING("MET Association Helper isn't associated with a MissingETAssociationMap!");
629  return StatusCode::SUCCESS;
630  }
631  if(softConst && m_trkseltool.empty() && !m_doPFlow && !m_doSoftTruth) {
632  ATH_MSG_WARNING( "Requested soft track element links, but no track selection tool supplied.");
633  }
634  const xAOD::Vertex *pv = softConst?getPV():nullptr;
635 
636  if(map->empty()) {
637  ATH_MSG_WARNING("Incomplete association map received. Cannot rebuild MET.");
638  ATH_MSG_WARNING("Note: METMaker should only be run on events containing at least one PV");
639  return StatusCode::SUCCESS;
640  }
641  ATH_MSG_VERBOSE("Building MET jet term " << metJet->name());
642  if(!metSoftClus && !metSoftTrk) {
643  ATH_MSG_WARNING("Neither soft cluster nor soft track term has been supplied!");
644  return StatusCode::SUCCESS;
645  }
646  static const SG::AuxElement::ConstAccessor<std::vector<ElementLink<IParticleContainer> > > acc_softConst("softConstituents");
647  if(metSoftClus) {
648  dec_constitObjLinks(*metSoftClus) = vector<iplink_t>(0);
649  if(coreSoftClus) {
650  ATH_MSG_VERBOSE("Building MET soft cluster term " << metSoftClus->name());
651  ATH_MSG_VERBOSE("Core soft cluster mpx " << coreSoftClus->mpx()
652  << ", mpy " << coreSoftClus->mpy()
653  << " sumet " << coreSoftClus->sumet());
654  *metSoftClus += *coreSoftClus;
655  } else {
656  ATH_MSG_WARNING("Soft cluster term provided without a core term!");
657  return StatusCode::SUCCESS;
658  }
659  // Fill a vector with the soft constituents, if one was provided.
660  // For now, only setting up to work with those corresponding to the jet constituents.
661  // Can expand if needed.
662  if(softConst && acc_softConst.isAvailable(*coreSoftClus)) {
663  for(const auto& constit : acc_softConst(*coreSoftClus)) {
664  softConst->push_back(*constit);
665  }
666  ATH_MSG_DEBUG(softConst->size() << " soft constituents from core term");
667  }
668  }
669  if(metSoftTrk) {
670  dec_constitObjLinks(*metSoftTrk) = vector<iplink_t>(0);
671  if(coreSoftTrk) {
672  ATH_MSG_VERBOSE("Building MET soft track term " << metSoftTrk->name());
673  ATH_MSG_VERBOSE("Core soft track mpx " << coreSoftTrk->mpx()
674  << ", mpy " << coreSoftTrk->mpy()
675  << " sumet " << coreSoftTrk->sumet());
676  *metSoftTrk += *coreSoftTrk;
677  } else {
678  ATH_MSG_WARNING("Soft track term provided without a core term!");
679  return StatusCode::SUCCESS;
680  }
681  if(softConst && acc_softConst.isAvailable(*coreSoftTrk) && !m_doPFlow && !m_doSoftTruth) {
682  for(const auto& constit : acc_softConst(*coreSoftTrk)) {
683  softConst->push_back(*constit);
684  }
685  ATH_MSG_DEBUG(softConst->size() << " soft constituents from trk core term");
686  }
687  }
688 
689  dec_constitObjLinks(*metJet) = std::vector<iplink_t>(0);
690  dec_constitObjWeights(*metJet) = std::vector<float>(0);
691  std::vector<iplink_t>& uniqueLinks = dec_constitObjLinks(*metJet);
692  std::vector<float>& uniqueWeights = dec_constitObjWeights(*metJet);
693  uniqueLinks.reserve(jets->size());
694  uniqueWeights.reserve(jets->size());
695  std::vector<iplink_t> softJetLinks;
696  std::vector<float> softJetWeights;
697  bool originalInputs = jets->empty() ? false : !acc_originalObject.isAvailable(*jets->front());
698 
699  // Get the hashed key of this jet, if we can. Though his only works if
700  // 1. the container is an owning container, and not just a view;
701  // 2. the container is in the event store already.
702  // Since we will be creating ElementLink-s to these jets later on in the
703  // code, and it should work in AnalysisBase, only the first one of these
704  // is checked. Since the code can not work otherwise.
705  SG::sgkey_t jetsSgKey = 0;
706  if(jets->ownPolicy() == SG::OWN_ELEMENTS) {
707  jetsSgKey = getKey(jets);
708  if(jetsSgKey == 0) {
709  ATH_MSG_ERROR("Could not find the jets with pointer: " << jets);
710  return StatusCode::FAILURE;
711  }
712  }
713 
714  for(const auto *const jet : *jets) {
715  const MissingETAssociation* assoc = nullptr;
716  if(originalInputs) {
717  assoc = MissingETComposition::getAssociation(map,jet);
718  } else {
719  const IParticle* orig = *acc_originalObject(*jet);
720  assoc = MissingETComposition::getAssociation(map,static_cast<const xAOD::Jet*>(orig));
721  }
722  if(assoc && !assoc->isMisc()) {
723 
724  // init nominal_jet and either actually asign nominal jet or fall back to systematic jet
725  const xAOD::Jet * nominal_jet = nullptr;
726  if(m_skipSystematicJetSelection) {
727  // retrieve nominal calibrated jet
728  if (acc_nominalObject.isAvailable(*jet))
729  nominal_jet = static_cast<const xAOD::Jet*>(*acc_nominalObject(*jet));
730  else {
731  ATH_MSG_ERROR("No nominal calibrated jet available for jet " << jet->index() << ". Cannot simplify overlap removal!");
732  nominal_jet = jet;
733  }
734  }
735  else
736  nominal_jet = jet;
737 
738  ATH_MSG_VERBOSE( "Jet (nom. calib) pt = " << nominal_jet->pt());
739  ATH_MSG_VERBOSE( "Jet pt = " << jet->pt());
740 
741  // use nominal calibrated jets instead
742  bool selected = (std::abs(nominal_jet->eta())<m_JetEtaForw && nominal_jet->pt()>m_CenJetPtCut) || (std::abs(nominal_jet->eta())>=m_JetEtaForw && nominal_jet->pt()>m_FwdJetPtCut );
743  bool JVT_reject(false);
744  bool isMuFSRJet(false);
745 
746  // 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
747  // use nominal calibrated jets instead
748  if (m_JetEtaMax > 0.0 && std::abs(nominal_jet->eta()) > m_JetEtaMax)
749  JVT_reject = true;
750 
751  if(doJetJVT) {
752  if (!m_useR21JvtFallback) {
753  // intrinsically checks that is within range to apply Jvt requirement
754  // use nominal calibrated jets instead
755  JVT_reject = !bool(m_JvtTool->accept(nominal_jet));
756  }
757  else {
758  if(jet->pt()<m_JvtPtMax && std::abs(jet->eta())<m_JetEtaForw) {
759  float jvt;
760  bool gotJVT = m_acc_jetJvtMoment->isAvailable(*jet);
761  if(gotJVT) {
762  jvt = (*m_acc_jetJvtMoment)(*jet);
763  JVT_reject = jvt<m_JvtCut;
764  if(m_JvtMediumPtMax>0.0 && jet->pt()<m_JvtMediumPtMax) JVT_reject = (jvt<m_JvtCutMedium);
765  if(m_JvtTightPtMax>0.0 && jet->pt()<m_JvtTightPtMax) JVT_reject = (jvt<m_JvtCutTight);
766  ATH_MSG_VERBOSE("Jet " << (JVT_reject ? "fails" : "passes") <<" JVT selection");
767  } else {
768  JVT_reject = true;
769  ATH_MSG_WARNING("Tried to retrieve JVT but this was not set. Failing this jet.");
770  }
771  }
772  }
773  ATH_MSG_VERBOSE("Jet " << (JVT_reject ? "fails" : "passes") <<" JVT selection");
774  }
775 
776  // if defined apply additional jet criterium
777  // use nominal calibrated jets instead
778  if (m_acc_jetRejectionDec && (*m_acc_jetRejectionDec)(*nominal_jet)==0) JVT_reject = true;
779  bool hardJet(false);
780  MissingETBase::Types::constvec_t calvec = assoc->overlapCalVec(helper);
781  bool caloverlap = false;
782  caloverlap = calvec.ce()>0;
783  ATH_MSG_DEBUG("Jet " << jet->index() << " is " << ( caloverlap ? "" : "non-") << "overlapping");
784  if(caloverlap) {
785  for(const auto& object : assoc->objects()) {
786  if(helper.objSelected(assoc, object)) {
787  ATH_MSG_VERBOSE(" Jet overlaps with " << object->type() << " " << object->index()
788  << " with pt " << object->pt() << ", phi " << object->phi() );
789  }
790 
791  // Correctly handle this jet if we're using very greedy photons
792  if (object && object->type() == xAOD::Type::Photon && m_veryGreedyPhotons) hardJet = true;
793 
794  }
795  }
796 
797  xAOD::JetFourMom_t constjet;
798  double constSF(1);
799  if(m_jetConstitScaleMom.empty() && assoc->hasAlternateConstVec()){
800  constjet = assoc->getAlternateConstVec();
801  } else { // we use this case but I don't think I need to use nominal calibrated jets - has no effect on OR decision
802  constjet = jet->jetP4(m_jetConstitScaleMom);//grab a constituent scale added by the JetMomentTool/JetConstitFourMomTool.cxx
803  double denom = (assoc->hasAlternateConstVec() ? assoc->getAlternateConstVec() : jet->jetP4("JetConstitScaleMomentum")).E();
804  constSF = denom>1e-9 ? constjet.E()/denom : 0.;
805  ATH_MSG_VERBOSE("Scale const jet by factor " << constSF);
806  calvec *= constSF;
807  }
808  double jpx = constjet.Px();
809  double jpy = constjet.Py();
810  double jpt = constjet.Pt();
811  double opx = jpx - calvec.cpx();
812  double opy = jpy - calvec.cpy();
813 
814  MissingET* met_muonEloss(nullptr);
815  if(m_muEloss || m_doSetMuonJetEMScale) {
816  // Get a term to hold the Eloss corrections
817  MissingETContainer* metCont = static_cast<MissingETContainer*>(metJet->container());
818  met_muonEloss = (*metCont)["MuonEloss"];
819  if(!met_muonEloss) {
820  ATH_MSG_WARNING("Attempted to apply muon Eloss correction, but corresponding MET term does not exist!");
821  return StatusCode::FAILURE;
822  }
823  }
824 
825  float total_eloss(0);
826  MissingETBase::Types::bitmask_t muons_selflags(0);
827  std::vector<const xAOD::Muon*> muons_in_jet;
828  std::vector<const xAOD::Electron*> electrons_in_jet;
829  bool passJetForEl=false;
830  if(m_useGhostMuons) { // for backwards-compatibility
831  if(acc_ghostMuons.isAvailable(*jet)) {
832  for(const auto& el : acc_ghostMuons(*jet)) {
833  if(el.isValid()) {
834  muons_in_jet.push_back(static_cast<const xAOD::Muon*>(*el));
835  } else {
836  ATH_MSG_WARNING("Invalid element link to ghost muon! Quitting.");
837  return StatusCode::FAILURE;
838  }
839  }
840  } else {
841  ATH_MSG_WARNING("Ghost muons requested but not found!");
842  return StatusCode::FAILURE;
843  }
844  }
845  for(const auto& obj : assoc->objects()) {
846  if (!obj) { continue; }
847  if(obj->type()==xAOD::Type::Muon && !m_useGhostMuons) {
848  const xAOD::Muon* mu_test(static_cast<const xAOD::Muon*>(obj));
849  ATH_MSG_VERBOSE("Muon " << mu_test->index() << " found in jet " << jet->index());
850  if((m_doRemoveMuonJets || m_doSetMuonJetEMScale)) {
851  if(acc_originalObject.isAvailable(*mu_test)) mu_test = static_cast<const xAOD::Muon*>(*acc_originalObject(*mu_test));
852  if(MissingETComposition::objSelected(helper,mu_test)) { //
853  muons_in_jet.push_back(mu_test);
854  ATH_MSG_VERBOSE("Muon is selected by MET.");
855  }
856  }
857  } else if(obj->type()==xAOD::Type::Electron && m_doRemoveElecTrks) {
858  const xAOD::Electron* el_test(static_cast<const xAOD::Electron*>(obj));
859  ATH_MSG_VERBOSE("Electron " << el_test->index() << " found in jet " << jet->index());
860  if(acc_originalObject.isAvailable(*el_test)) el_test = static_cast<const xAOD::Electron*>(*acc_originalObject(*el_test));
861  if(helper.objSelected(assoc,el_test)){
862  if(el_test->pt()>90.0e3) { // only worry about high-pt electrons?
863  electrons_in_jet.push_back(el_test);
864  ATH_MSG_VERBOSE("High-pt electron is selected by MET.");
865  }
866  }
867  }
868  }
869  if(m_doRemoveElecTrks) {
870  MissingETBase::Types::constvec_t initialTrkMom = assoc->jetTrkVec();
871  float jet_ORtrk_sumpt = assoc->overlapTrkVec(helper).sumpt();
872  float jet_all_trk_pt = initialTrkMom.sumpt();
873  float jet_unique_trk_pt = jet_all_trk_pt - jet_ORtrk_sumpt;
874  MissingETBase::Types::constvec_t el_calvec;
875  MissingETBase::Types::constvec_t el_trkvec;
876  for(const auto& elec : electrons_in_jet) {
877  el_calvec += assoc->calVec(elec);
878  el_trkvec += assoc->trkVec(elec);
879  }
880  float el_cal_pt = el_calvec.cpt();
881  float el_trk_pt = el_trkvec.cpt();
882  ATH_MSG_VERBOSE("Elec trk: " << el_trk_pt
883  << " jetalltrk: " << jet_all_trk_pt
884  << " jetORtrk: " << jet_ORtrk_sumpt
885  << " electrk-jetORtrk: " << (el_trk_pt-jet_ORtrk_sumpt)
886  << " elec cal: " << el_cal_pt
887  << " jetalltrk-electrk: " << (jet_all_trk_pt-el_trk_pt)
888  << " jetalltrk-jetORtrk: " << (jet_all_trk_pt-jet_ORtrk_sumpt) );
889  // Want to use the jet calo measurement if we had at least one electron
890  // and the jet has a lot of residual track pt
891  // Is the cut appropriate?
892  if(el_trk_pt>1e-9 && jet_unique_trk_pt>10.0e3) passJetForEl=true;
893  } // end ele-track removal
894 
895  for(const xAOD::Muon* mu_in_jet : muons_in_jet) {
896  if (not mu_in_jet) continue;
897  float mu_Eloss = acc_Eloss(*mu_in_jet);
898 
899  if(!JVT_reject) {
900  if (m_doRemoveMuonJets) {
901  // need to investigate how this is affected by the recording of muon clusters in the map
902  float mu_id_pt = mu_in_jet->trackParticle(xAOD::Muon::InnerDetectorTrackParticle) ? mu_in_jet->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)->pt() : 0.;
903  float jet_trk_sumpt = acc_trksumpt.isAvailable(*jet) && this->getPV() ? acc_trksumpt(*jet)[this->getPV()->index()] : 0.;
904 
905  // missed the muon, so we should add it back
906  if(0.9999*mu_id_pt>jet_trk_sumpt)
907  jet_trk_sumpt+=mu_id_pt;
908  float jet_trk_N = acc_trkN.isAvailable(*jet) && this->getPV() ? acc_trkN(*jet)[this->getPV()->index()] : 0.;
909  ATH_MSG_VERBOSE("Muon has ID pt " << mu_id_pt);
910  ATH_MSG_VERBOSE("Jet has pt " << jet->pt() << ", trk sumpt " << jet_trk_sumpt << ", trk N " << jet_trk_N);
911  // those corrections are negligible but use nominal calibrated jets instead
912  bool jet_from_muon = mu_id_pt>1e-9 && jet_trk_sumpt>1e-9 && (nominal_jet->pt()/mu_id_pt < m_muIDPTJetPtRatioMuOlap && mu_id_pt/jet_trk_sumpt>m_jetTrkPtMuPt) && jet_trk_N<m_jetTrkNMuOlap;
913  if(jet_from_muon) {
914  ATH_MSG_VERBOSE("Jet is from muon -- remove.");
915  JVT_reject = true;
916  }
917  }
918 
919  if (m_doSetMuonJetEMScale) {
920  // need to investigate how this is affected by the recording of muon clusters in the map
921  float mu_id_pt = mu_in_jet->trackParticle(xAOD::Muon::InnerDetectorTrackParticle) ? mu_in_jet->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)->pt() : 0.;
922  float jet_trk_sumpt = acc_trksumpt.isAvailable(*jet) && this->getPV() ? acc_trksumpt(*jet)[this->getPV()->index()] : 0.;
923  // missed the muon, so we should add it back
924  if(0.9999*mu_id_pt>jet_trk_sumpt)
925  jet_trk_sumpt+=mu_id_pt;
926  float jet_trk_N = acc_trkN.isAvailable(*jet) && this->getPV() ? acc_trkN(*jet)[this->getPV()->index()] : 0.;
927 
928  float jet_psE = 0.;
929  if (acc_psf.isAvailable(*jet)){
930  jet_psE = acc_psf(*jet);
931  } else if (acc_sampleE.isAvailable(*jet)){
932  jet_psE = acc_sampleE(*jet)[0] + acc_sampleE(*jet)[4];
933  } else {
934  ATH_MSG_ERROR("Jet PS fraction or sampling energy must be available to calculate MET with doSetMuonJetEMScale");
935  return StatusCode::FAILURE;
936  }
937 
938  bool jet_from_muon = jet_trk_sumpt>1e-9 && jet_trk_N<3 && mu_id_pt / jet_trk_sumpt > m_jetTrkPtMuPt && acc_emf(*jet)>m_jetEmfMuOlap && acc_width(*jet)<m_jetWidthMuOlap && jet_psE>m_jetPsEMuOlap;
939  ATH_MSG_VERBOSE("Muon has ID pt " << mu_id_pt);
940  ATH_MSG_VERBOSE("Jet has trk sumpt " << jet_trk_sumpt << ", trk N " << jet_trk_N << ", PS E " << jet_psE << ", width " << acc_width(*jet) << ", emfrac " << acc_emf(*jet));
941 
942  if(jet_from_muon) {
943  ATH_MSG_VERBOSE("Jet is from muon -- set to EM scale and subtract Eloss.");
944  // Using constjet now because we focus on AntiKt4EMTopo.
945  // Probably not a massive difference to LC, but PF needs some consideration
946  ATH_MSG_VERBOSE("Jet e: " << constjet.E() << ", mu Eloss: " << mu_Eloss);
947  float elosscorr = mu_Eloss >= constjet.e() ? 0. : 1.-mu_Eloss/constjet.e();
948  // Effectively, take the unique fraction of the jet times the eloss-corrected fraction
949  // This might in some cases oversubtract, but should err on the side of undercounting the jet contribution
950  opx *= elosscorr;
951  opy *= elosscorr;
952  ATH_MSG_VERBOSE(" Jet eloss factor " << elosscorr << ", final pt: " << sqrt(opx*opx+opy*opy));
953  // Don't treat this jet normally. Instead, just add to the Eloss term
954  isMuFSRJet = true;
955  }
956  }
957  } // end muon-jet overlap-removal
958 
959  switch(mu_in_jet->energyLossType()) {
960  case xAOD::Muon::Parametrized:
961  case xAOD::Muon::MOP:
962  case xAOD::Muon::Tail:
963  case xAOD::Muon::FSRcandidate:
964  case xAOD::Muon::NotIsolated:
965  // For now don't differentiate the behaviour
966  // Remove the Eloss assuming the parameterised value
967  // The correction is limited to the selected clusters
968  total_eloss += mu_Eloss;
969  muons_selflags |= (1<<assoc->findIndex(mu_in_jet));
970  }
971  }
972  ATH_MSG_VERBOSE("Muon selection flags: " << muons_selflags);
973  ATH_MSG_VERBOSE("Muon total eloss: " << total_eloss);
974 
975  MissingETBase::Types::constvec_t mu_calovec;
976  // borrowed from overlapCalVec
977  for(size_t iKey = 0; iKey < assoc->sizeCal(); iKey++) {
978  bool selector = (muons_selflags & assoc->calkey()[iKey]);
979  if(selector) mu_calovec += assoc->calVec(iKey);
980  ATH_MSG_VERBOSE("This key: " << assoc->calkey()[iKey] << ", selector: " << selector);
981  }
982  ATH_MSG_VERBOSE("Mu calovec pt, no Eloss: " << mu_calovec.cpt());
983  if(m_muEloss) mu_calovec *= std::max<float>(0.,1-(total_eloss/mu_calovec.ce()));
984  ATH_MSG_VERBOSE("Mu calovec pt, with Eloss: " << mu_calovec.cpt());
985 
986  // re-add calo components of muons beyond Eloss correction
987  ATH_MSG_VERBOSE("Jet " << jet->index() << " const pT before OR " << jpt);
988  ATH_MSG_VERBOSE("Jet " << jet->index() << " const pT after OR " << sqrt(opx*opx+opy*opy));
989  opx += mu_calovec.cpx();
990  opy += mu_calovec.cpy();
991  double opt = sqrt( opx*opx+opy*opy );
992  ATH_MSG_VERBOSE("Jet " << jet->index() << " const pT diff after OR readding muon clusters " << opt-jpt);
993  double uniquefrac = 1. - (calvec.ce() - mu_calovec.ce()) / constjet.E();
994  ATH_MSG_VERBOSE( "Jet constscale px, py, pt, E = " << jpx << ", " << jpy << ", " << jpt << ", " << constjet.E() );
995  ATH_MSG_VERBOSE( "Jet overlap E = " << calvec.ce() - mu_calovec.ce() );
996  ATH_MSG_VERBOSE( "Jet OR px, py, pt, E = " << opx << ", " << opy << ", " << opt << ", " << constjet.E() - calvec.ce() );
997 
998  if(isMuFSRJet) {
999 
1000  if(met_muonEloss) {
1001  met_muonEloss->add(opx,opy,opt);
1002  } else {
1003  ATH_MSG_WARNING("Attempted to apply muon Eloss correction, but corresponding MET term does not exist!");
1004  return StatusCode::FAILURE;
1005  }
1006  } else {
1007  if(selected && !JVT_reject) {
1008  if(!caloverlap) {
1009  // add jet full four-vector
1010  hardJet = true;
1011  if (!tracksForHardJets) {
1012  if(m_doConstJet) {
1013  metJet->add(jpx,jpy,jpt);
1014  } else {*metJet += jet;}
1015  }
1016  } else {
1017  // check unique fraction
1018  if((uniquefrac>m_jetMinEfrac || passJetForEl) && opt>m_jetMinWeightedPt) {
1019  // add jet corrected for overlaps
1020  hardJet = true;
1021  if(!tracksForHardJets) {
1022  if(m_jetCorrectPhi) {
1023  if (m_doConstJet) metJet->add(opx,opy,opt);
1024  else {
1025  double jesF = jet->pt() / jpt;
1026  metJet->add(opx*jesF,opy*jesF,opt*jesF);
1027  }
1028  } else {
1029  if (m_doConstJet){
1030  metJet->add(uniquefrac*jpx,uniquefrac*jpy,uniquefrac*jpt);
1031  }
1032  else{
1033  if(passJetForEl){
1034  if(m_doRemoveElecTrksEM) metJet->add(opx,opy,opt);
1035  else metJet->add(uniquefrac*jet->px(),uniquefrac*jet->py(),uniquefrac*jet->pt());
1036  }else{
1037  metJet->add(uniquefrac*jet->px(),uniquefrac*jet->py(),uniquefrac*jet->pt());
1038  }
1039  }
1040  }
1041  }
1042  }
1043  }
1044  } // hard jet selection
1045 
1046  // Create the appropriate ElementLink for this jet just the once.
1047  iplink_t jetLink;
1048  if(jetsSgKey == 0) {
1049  const xAOD::IParticleContainer* ipc =
1050  static_cast<const xAOD::IParticleContainer*>(jet->container());
1051  jetLink = iplink_t(*ipc, jet->index());
1052  } else {
1053  jetLink = iplink_t(jetsSgKey, jet->index());
1054  }
1055 
1056  if(hardJet){
1057  ATH_MSG_VERBOSE("Jet added at full scale");
1058  uniqueLinks.push_back( jetLink );
1059  uniqueWeights.push_back( uniquefrac );
1060  } else {
1061  if(metSoftClus && !JVT_reject) {
1062  // add fractional contribution
1063  ATH_MSG_VERBOSE("Jet added at const scale");
1064  if (std::abs(jet->eta())<2.5 || !(coreSoftClus->source()&MissingETBase::Source::Region::Central)) {
1065  softJetLinks.push_back( jetLink );
1066  softJetWeights.push_back( uniquefrac );
1067  metSoftClus->add(opx,opy,opt);
1068  }
1069 
1070  // Fill a vector with the soft constituents, if one was provided.
1071  // For now, only setting up to work with those corresponding to the jet constituents.
1072  // Can expand if needed.
1073  // This ignores overlap removal.
1074  //
1075  if(softConst) {
1076  for(size_t iConst=0; iConst<jet->numConstituents(); ++iConst) {
1077  const IParticle* constit = jet->rawConstituent(iConst);
1078  softConst->push_back(constit);
1079  }
1080  }
1081  }
1082  } // hard jet or CST
1083 
1084  if(metSoftTrk && (!hardJet || tracksForHardJets)) {
1085  // use jet tracks
1086  // remove any tracks already used by other objects
1087  MissingETBase::Types::constvec_t trkvec = assoc->overlapTrkVec(helper);
1088  MissingETBase::Types::constvec_t jettrkvec = assoc->jetTrkVec();
1089  if(jettrkvec.ce()>1e-9) {
1090  jpx = jettrkvec.cpx();
1091  jpy = jettrkvec.cpy();
1092  jpt = jettrkvec.sumpt();
1093  jettrkvec -= trkvec;
1094  opx = jettrkvec.cpx();
1095  opy = jettrkvec.cpy();
1096  opt = jettrkvec.sumpt();
1097  ATH_MSG_VERBOSE( "Jet track px, py, sumpt = " << jpx << ", " << jpy << ", " << jpt );
1098  ATH_MSG_VERBOSE( "Jet OR px, py, sumpt = " << opx << ", " << opy << ", " << opt );
1099  } else {
1100  opx = opy = opt = 0;
1101  ATH_MSG_VERBOSE( "This jet has no associated tracks" );
1102  }
1103  if (hardJet) metJet->add(opx,opy,opt);
1104  // use nominal calibrated jets instead
1105  else if (std::abs(nominal_jet->eta())<2.5 || !(coreSoftTrk->source()&MissingETBase::Source::Region::Central)) {
1106  metSoftTrk->add(opx,opy,opt);
1107  // Don't need to add if already done for softclus.
1108  if(!metSoftClus) {
1109  softJetLinks.push_back( jetLink );
1110  softJetWeights.push_back( uniquefrac );
1111  }
1112 
1113  // Fill a vector with the soft constituents, if one was provided.
1114  // For now, only setting up to work with those corresponding to the jet constituents.
1115  // Can expand if needed.
1116  // This ignores overlap removal.
1117  //
1118  if(softConst && !m_doPFlow && !m_doSoftTruth) {
1119  std::vector<const IParticle*> jettracks;
1120  jet->getAssociatedObjects<IParticle>(xAOD::JetAttribute::GhostTrack,jettracks);
1121  for(size_t iConst=0; iConst<jettracks.size(); ++iConst) {
1122  const TrackParticle* pTrk = static_cast<const TrackParticle*>(jettracks[iConst]);
1123  if (acceptTrack(pTrk,pv)) softConst->push_back(pTrk);
1124  }
1125  }
1126  }
1127  } // soft track
1128 
1129  } // is not from muon FSR
1130  } // association exists
1131  else {
1132  ATH_MSG_WARNING( "Jet without association found!" );
1133  }
1134  } // jet loop
1135 
1136  ATH_MSG_DEBUG("Number of selected jets: " << dec_constitObjLinks(*metJet).size());
1137 
1138  if(metSoftTrk) {
1139  dec_constitObjLinks(*metSoftTrk) = softJetLinks;
1140  ATH_MSG_DEBUG("Number of softtrk jets: " << dec_constitObjLinks(*metSoftTrk).size());
1141  }
1142 
1143  if(metSoftClus) {
1144  dec_constitObjLinks(*metSoftClus) = softJetLinks;
1145  ATH_MSG_DEBUG("Number of softclus jets: " << dec_constitObjLinks(*metSoftClus).size());
1146  }
1147 
1148  if(softConst) ATH_MSG_DEBUG(softConst->size() << " soft constituents from core term + jets");
1149 
1150  if(metSoftTrk) {
1151  // supplement track term with any tracks associated to isolated muons
1152  // these are recorded in the misc association
1153  const MissingETAssociation* assoc = map->getMiscAssociation();
1154  if(assoc) {
1155  MissingETBase::Types::constvec_t trkvec = assoc->overlapTrkVec(helper);
1156  double opx = trkvec.cpx();
1157  double opy = trkvec.cpy();
1158  double osumpt = trkvec.sumpt();
1159  ATH_MSG_VERBOSE( "Misc track px, py, sumpt = " << opx << ", " << opy << ", " << osumpt );
1160  metSoftTrk->add(opx,opy,osumpt);
1161  ATH_MSG_VERBOSE("Final soft track mpx " << metSoftTrk->mpx()
1162  << ", mpy " << metSoftTrk->mpy()
1163  << " sumet " << metSoftTrk->sumet());
1164  }
1165  }
1166 
1167  if(metSoftClus) {
1168  // supplement cluster term with any clusters associated to isolated e/gamma
1169  // these are recorded in the misc association
1170  const MissingETAssociation* assoc = map->getMiscAssociation();
1171  if(assoc) {
1172  float total_eloss(0.);
1173  MissingETBase::Types::bitmask_t muons_selflags(0);
1174  MissingETBase::Types::constvec_t calvec = assoc->overlapCalVec(helper);
1175  double opx = calvec.cpx();
1176  double opy = calvec.cpy();
1177  double osumpt = calvec.sumpt();
1178  for(const auto& obj : assoc->objects()) {
1179  if (!obj) continue;
1180  if(obj->type()==xAOD::Type::Muon) {
1181  const xAOD::Muon* mu_test(static_cast<const xAOD::Muon*>(obj));
1182  if(acc_originalObject.isAvailable(*mu_test)) mu_test = static_cast<const xAOD::Muon*>(*acc_originalObject(*mu_test));
1183  if(MissingETComposition::objSelected(helper,mu_test)) { //
1184  float mu_Eloss = acc_Eloss(*mu_test);
1185  switch(mu_test->energyLossType()) {
1186  case xAOD::Muon::Parametrized:
1187  case xAOD::Muon::MOP:
1188  case xAOD::Muon::Tail:
1189  case xAOD::Muon::FSRcandidate:
1190  case xAOD::Muon::NotIsolated:
1191  // For now don't differentiate the behaviour
1192  // Remove the Eloss assuming the parameterised value
1193  // The correction is limited to the selected clusters
1194  total_eloss += mu_Eloss;
1195  muons_selflags |= (1<<assoc->findIndex(mu_test));
1196  }
1197  ATH_MSG_VERBOSE("Mu index " << mu_test->index());
1198  }
1199  }
1200  }
1201  ATH_MSG_VERBOSE("Mu selection flags " << muons_selflags);
1202  ATH_MSG_VERBOSE("Mu total eloss " << total_eloss);
1203 
1204  MissingETBase::Types::constvec_t mu_calovec;
1205  // borrowed from overlapCalVec
1206  for(size_t iKey = 0; iKey < assoc->sizeCal(); iKey++) {
1207  bool selector = (muons_selflags & assoc->calkey()[iKey]);
1208  ATH_MSG_VERBOSE("This key: " << assoc->calkey()[iKey] << ", selector: " << selector
1209  << " this calvec E: " << assoc->calVec(iKey).ce());
1210  if(selector) mu_calovec += assoc->calVec(iKey);
1211  }
1212  if(m_muEloss){
1213  mu_calovec *= std::max<float>(0.,1-(total_eloss/mu_calovec.ce()));
1214  opx += mu_calovec.cpx();
1215  opy += mu_calovec.cpy();
1216  osumpt += mu_calovec.sumpt();
1217  }
1218  ATH_MSG_VERBOSE("Mu cluster sumpt " << mu_calovec.sumpt());
1219 
1220  ATH_MSG_VERBOSE( "Misc cluster px, py, sumpt = " << opx << ", " << opy << ", " << osumpt );
1221  metSoftClus->add(opx,opy,osumpt);
1222  ATH_MSG_VERBOSE("Final soft cluster mpx " << metSoftClus->mpx()
1223  << ", mpy " << metSoftClus->mpy()
1224  << " sumet " << metSoftClus->sumet());
1225  }
1226  }
1227 
1228  return StatusCode::SUCCESS;
1229  }

◆ rebuildMET() [1/3]

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

Implements IMETMaker.

Definition at line 249 of file METMaker.cxx.

255  {
256  MissingETBase::Types::bitmask_t metSource;
257  switch(metType) {
258  case xAOD::Type::Electron:
259  metSource = MissingETBase::Source::electron();
260  break;
261  case xAOD::Type::Photon:
262  metSource = MissingETBase::Source::photon();
263  break;
264  case xAOD::Type::Tau:
265  metSource = MissingETBase::Source::tau();
266  break;
267  case xAOD::Type::Muon:
268  metSource = MissingETBase::Source::muon();
269  break;
270  case xAOD::Type::Jet:
271  ATH_MSG_WARNING("Incorrect use of rebuildMET -- use rebuildJetMET for RefJet term");
272  return StatusCode::FAILURE;
273  default:
274  ATH_MSG_WARNING("Invalid object type provided: " << metType);
275  return StatusCode::FAILURE;
276  }
277 
278  MissingET* met = nullptr;
279  if( fillMET(met,metCont, metKey , metSource) != StatusCode::SUCCESS) {
280  ATH_MSG_ERROR("failed to fill MET term \"" << metKey << "\"");
281  return StatusCode::FAILURE;
282  }
283 
284  // If muon eloss corrections are required, create a new term to hold these if it doesn't already exist
285  if(metType==xAOD::Type::Muon && (m_muEloss || m_doSetMuonJetEMScale) && !(*metCont)["MuonEloss"]) {
286  MissingET* met_muEloss = nullptr;
287  if( fillMET(met_muEloss,metCont,"MuonEloss",
288  MissingETBase::Source::Type::Muon | MissingETBase::Source::Category::Calo) != StatusCode::SUCCESS) {
289  ATH_MSG_ERROR("failed to create Muon Eloss MET term");
290  return StatusCode::FAILURE;
291  }
292  }
293 
294  return rebuildMET(met,collection,helper,objScale);
295  }

◆ rebuildMET() [2/3]

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

Implements IMETMaker.

Definition at line 297 of file METMaker.cxx.

301  {
302  MissingETBase::UsageHandler::Policy p = MissingETBase::UsageHandler::OnlyCluster;
303  bool removeOverlap = true;
304  if(!collection->empty()) {
305  const IParticle* obj = collection->front();
306  if(obj->type()==xAOD::Type::Muon) {
307  p = MissingETBase::UsageHandler::OnlyTrack;
308  removeOverlap = false;
309  }
310  }
311  if (m_doSoftTruth) p = MissingETBase::UsageHandler::TruthParticle;
312  if (m_doPFlow) p = MissingETBase::UsageHandler::ParticleFlow;
313  return rebuildMET(met,collection,helper,p,removeOverlap,objScale);
314  }

◆ rebuildMET() [3/3]

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

Implements IMETMaker.

Definition at line 316 of file METMaker.cxx.

321  {
322  if(!met || !collection) {
323  ATH_MSG_WARNING("Invalid pointer supplied for "
324  << "MET (" << met << ") or "
325  << "collection (" << collection << ").");
326  return StatusCode::SUCCESS;
327  }
328  const xAOD::MissingETAssociationMap* map = helper.map();
329  if(!map){
330  ATH_MSG_WARNING("MET Association Helper isn't associated with a MissingETAssociationMap!");
331  return StatusCode::SUCCESS;
332  }
333  if(map->empty()) {
334  ATH_MSG_WARNING("Incomplete association map received. Cannot rebuild MET.");
335  ATH_MSG_WARNING("Note: METMaker should only be run on events containing at least one PV");
336  return StatusCode::SUCCESS;
337  }
338  ATH_MSG_VERBOSE("Building MET term " << met->name());
339  dec_constitObjLinks(*met) = vector<iplink_t>(0);
340  dec_constitObjWeights(*met) = vector<float>(0);
341  std::vector<iplink_t>& uniqueLinks = dec_constitObjLinks(*met);
342  std::vector<float>& uniqueWeights = dec_constitObjWeights(*met);
343  uniqueLinks.reserve(collection->size());
344  uniqueWeights.reserve(collection->size());
345 
346  // Get the hashed key of this collection, if we can. Though his only works
347  // if
348  // 1. the container is an owning container, and not just a view;
349  // 2. the container is in the event store already.
350  // Since we will be creating ElementLink-s to these objects later on in the
351  // code, and it should work in AnalysisBase, only the first one of these
352  // is checked. Since the code can not work otherwise.
353  SG::sgkey_t collectionSgKey = 0;
354  if(collection->ownPolicy() == SG::OWN_ELEMENTS) {
355  collectionSgKey = getKey(collection);
356  if(collectionSgKey == 0) {
357  ATH_MSG_ERROR("Could not find the collection with pointer: "
358  << collection);
359  return StatusCode::FAILURE;
360  }
361  }
362 
363  if(!collection->empty()) {
364  bool originalInputs = !acc_originalObject.isAvailable(*collection->front());
365  bool isShallowCopy = dynamic_cast<const xAOD::ShallowAuxContainer*>(collection->front()->container()->getConstStore());
366  ATH_MSG_VERBOSE("const store = " << collection->front()->container()->getConstStore());
367  if(isShallowCopy && originalInputs) {
368  ATH_MSG_WARNING("Shallow copy provided without \"originalObjectLinks\" decoration! "
369  << "Overlap removal cannot be done. "
370  << "Will not compute this term.");
371  ATH_MSG_WARNING("Please apply xAOD::setOriginalObjectLinks() from xAODBase/IParticleHelpers.h");
372  return StatusCode::SUCCESS;
373  } else {
374  ATH_MSG_VERBOSE("Original inputs? " << originalInputs);
375  }
376  for(const auto *const obj : *collection) {
377  const IParticle* orig = obj;
378  bool selected = false;
379  if(!originalInputs) { orig = *acc_originalObject(*obj); }
380  std::vector<const xAOD::MissingETAssociation*> assocs = xAOD::MissingETComposition::getAssociations(map,orig);
381  if(assocs.empty()) {
382  std::string message = "Object is not in association map. Did you make a deep copy but fail to set the \"originalObjectLinks\" decoration? "
383  "If not, Please apply xAOD::setOriginalObjectLinks() from xAODBase/IParticleHelpers.h";
384  // Avoid warnings for leptons with pT below threshold for association map
385  if (orig->pt()>m_missObjWarningPtThreshold) {
386  ATH_MSG_WARNING(message);
387  } else {
388  ATH_MSG_DEBUG(message);
389  }
390  // if this is an uncalibrated electron below the threshold, then we put it into the soft term
391  if(orig->type()==xAOD::Type::Electron){
392  iplink_t objLink;
393  if(collectionSgKey == 0) {
394  const xAOD::IParticleContainer* ipc = static_cast<const xAOD::IParticleContainer*>(obj->container());
395  objLink = iplink_t(*ipc, obj->index());
396  } else {
397  objLink = iplink_t(collectionSgKey, obj->index());
398  }
399  uniqueLinks.emplace_back( objLink );
400  uniqueWeights.emplace_back( 0. );
401  message = "Missing an electron from the MET map. Included as a track in the soft term. pT: " + std::to_string(obj->pt()/1e3) + " GeV";
402  if (orig->pt()>m_missObjWarningPtThreshold) {
403  ATH_MSG_WARNING(message);
404  } else {
405  ATH_MSG_DEBUG(message);
406  }
407  continue;
408  } else {
409  ATH_MSG_ERROR("Missing an object: " << orig->type() << " pT: " << obj->pt()/1e3 << " GeV, may be duplicated in the soft term.");
410  }
411  }
412 
413  // If the object has already been selected and processed, ignore it.
414  if(MissingETComposition::objSelected(helper,orig)) continue;
415  selected = MissingETComposition::selectIfNoOverlaps(helper,orig,p) || !removeOverlap;
416  ATH_MSG_VERBOSE(obj->type() << " (" << orig <<") with pt " << obj->pt()
417  << " is " << ( selected ? "non-" : "") << "overlapping");
418 
419  // Greedy photon options: set selection flags
420  if ((m_greedyPhotons || m_veryGreedyPhotons) && selected && obj->type() == xAOD::Type::Photon){
421  for(const xAOD::MissingETAssociation* assoc : assocs){
422  std::vector<size_t> indices = assoc->overlapIndices(orig);
423  std::vector<const xAOD::IParticle*> allObjects = assoc->objects();
424  for (size_t index : indices){
425  const xAOD::IParticle* thisObj = allObjects[index];
426  if(!thisObj) continue;
427  if ((thisObj->type() == xAOD::Type::Jet && m_veryGreedyPhotons) ||
428  thisObj->type() == xAOD::Type::Electron)
429  helper.setObjSelectionFlag(assoc, thisObj, true);
430  }
431  }
432  }
433 
434  //Do special overlap removal for calo tagged muons
435  if(m_orCaloTaggedMuon && !removeOverlap && orig->type()==xAOD::Type::Muon && static_cast<const xAOD::Muon*>(orig)->muonType()==xAOD::Muon::CaloTagged) {
436  for (size_t i = 0; i < assocs.size(); i++) {
437  std::vector<size_t> ind = assocs[i]->overlapIndices(orig);
438  std::vector<const xAOD::IParticle*> allObjects = assocs[i]->objects();
439  for (size_t indi = 0; indi < ind.size(); indi++) if (allObjects[ind[indi]]) {
440  if (allObjects[ind[indi]]->type()==xAOD::Type::Electron
441  && helper.objSelected(assocs[i], ind[indi])) {
442  selected = false;
443  break;
444  }
445  }
446  }
447  }
448  // Don't overlap remove muons, but flag the non-overlapping muons to take out their tracks from jets
449  // Removed eloss from here -- clusters already flagged.
450  // To be handled in rebuildJetMET
451  if(selected) {
452  if(objScale==MissingETBase::UsageHandler::PhysicsObject) {
453  ATH_MSG_VERBOSE("Add object with pt " << obj->pt());
454  *met += obj;
455  } else {
456  MissingETBase::Types::constvec_t constvec = MissingETComposition::getConstVec(map,obj,objScale);
457  ATH_MSG_VERBOSE("Add truth object with pt " << constvec.cpt());
458  met->add(constvec.cpx(),constvec.cpy(),constvec.cpt());
459  }
460  }
461  if(selected) {
462  iplink_t objLink;
463  if(collectionSgKey == 0) {
464  const xAOD::IParticleContainer* ipc =
465  static_cast<const xAOD::IParticleContainer*>(obj->container());
466  objLink = iplink_t(*ipc, obj->index());
467  } else {
468  objLink = iplink_t(collectionSgKey, obj->index());
469  }
470  uniqueLinks.push_back( objLink );
471  uniqueWeights.push_back( 1. );
472  }
473  }
474  }
475  ATH_MSG_DEBUG("Built met term " << met->name() << ", with magnitude " << met->met());
476  return StatusCode::SUCCESS;
477  }

◆ rebuildTrackMET() [1/2]

StatusCode met::METMaker::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 
)
finaloverridevirtual

Implements IMETMaker.

Definition at line 527 of file METMaker.cxx.

534  {
535  ATH_MSG_VERBOSE("Rebuild jet term: " << metJetKey << " and soft term: " << softKey);
536 
537  MissingET* metJet = nullptr;
538  if( fillMET(metJet , metCont, metJetKey , MissingETBase::Source::jet() | MissingETBase::Source::track() ) != StatusCode::SUCCESS) {
539  ATH_MSG_ERROR("failed to fill MET term \"" << metJetKey << "\"");
540  return StatusCode::FAILURE;
541  }
542 
543  const MissingET *coreSoftTrk(nullptr);
544  MissingET *metSoftTrk(nullptr);
545 
546  const MissingET* coreSoft = (*metCoreCont)[softKey+"Core"];
547  if(!coreSoft) {
548  ATH_MSG_WARNING("Invalid soft term key supplied: " << softKey);
549  return StatusCode::FAILURE;
550  }
551  coreSoftTrk = coreSoft;
552 
553  metSoftTrk = nullptr;
554  if( fillMET(metSoftTrk , metCont, softKey , coreSoftTrk->source()) != StatusCode::SUCCESS) {
555  ATH_MSG_ERROR("failed to fill MET term \"" << softKey << "\"");
556  return StatusCode::FAILURE;
557  }
558 
559  return rebuildTrackMET(metJet, jets, helper,
560  metSoftTrk, coreSoftTrk,
561  doJetJVT);
562  }

◆ rebuildTrackMET() [2/2]

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

Implements IMETMaker.

Definition at line 1231 of file METMaker.cxx.

1236  {
1237  return rebuildJetMET(metJet,jets,helper,nullptr,nullptr,metSoftTrk,coreSoftTrk,doJetJVT,true);
1238  }

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ retrieveOverlapRemovedConstituents() [1/3]

StatusCode met::METMaker::retrieveOverlapRemovedConstituents ( const xAOD::PFOContainer *  cpfo,
const xAOD::PFOContainer *  npfo,
xAOD::MissingETAssociationHelper &  metHelper,
xAOD::PFOContainer *  OR_cpfos,
xAOD::PFOContainer *  OR_npfos,
bool  retainMuon = false,
const xAOD::IParticleContainer *  muonCollection = 0 
)
finaloverridevirtual

Implements IMETMaker.

Definition at line 1263 of file METMaker.cxx.

1270  {
1271 
1272  const xAOD::PFOContainer *OR_cpfos_tmp = retrieveOverlapRemovedConstituents(cpfo, metHelper,retainMuon,muonCollection);
1273  const xAOD::PFOContainer *OR_npfos_tmp = retrieveOverlapRemovedConstituents(npfo, metHelper,retainMuon,muonCollection);
1274 
1275  for (auto tmp_constit : static_cast<xAOD::PFOContainer>(*cpfo)){
1276  xAOD::PFO* constit=new xAOD::PFO();
1277  OR_cpfos->push_back(constit);
1278  *constit=*tmp_constit;
1279 
1280  bool keep=false;
1281  for (const auto *const ORconstit : *OR_cpfos_tmp){
1282  if (ORconstit->index()==tmp_constit->index() && ORconstit->charge()==tmp_constit->charge()) {keep=true;}
1283  }
1284  if (!keep){constit->setP4(0., 0., 0., 0.);}
1285 
1286  ATH_MSG_VERBOSE("Constituent with index " << tmp_constit->index() << ", charge " << tmp_constit->charge()<< " pT " << tmp_constit->pt() << ((keep==true) ? "" : " not ") <<" in OverlapRemovedCHSParticleFlowObjects");
1287  } // end cPFO loop
1288 
1289  for (auto tmp_constit : static_cast<xAOD::PFOContainer>(*npfo)){
1290  xAOD::PFO* constit=new xAOD::PFO();
1291  OR_npfos->push_back(constit);
1292  *constit=*tmp_constit;
1293 
1294  bool keep=false;
1295  for (const auto *const ORconstit : *OR_npfos_tmp){
1296  if (ORconstit->index()==tmp_constit->index() && ORconstit->charge()==tmp_constit->charge()) {keep=true;}
1297  }
1298  if (!keep){ constit->setP4(0., 0., 0., 0.); }
1299 
1300  ATH_MSG_VERBOSE("Constituent with index " << tmp_constit->index() << ", charge " << tmp_constit->charge()<< " pT " << tmp_constit->pt() << ((keep==true) ? "" : " not ") <<" in OverlapRemovedCHSParticleFlowObjects");
1301  } // end nPFO loop/
1302 
1303 
1304 
1305  return StatusCode::SUCCESS;
1306  }

◆ retrieveOverlapRemovedConstituents() [2/3]

StatusCode met::METMaker::retrieveOverlapRemovedConstituents ( const xAOD::PFOContainer *  pfo,
xAOD::MissingETAssociationHelper &  metHelper,
const xAOD::PFOContainer **  OR_pfos,
bool  retainMuon,
const xAOD::IParticleContainer *  muonCollection 
)
finaloverridevirtual

Implements IMETMaker.

Definition at line 1309 of file METMaker.cxx.

1315  {
1316  *OR_pfos=retrieveOverlapRemovedConstituents(pfo,metHelper,retainMuon,muonCollection);
1317  return StatusCode::SUCCESS;
1318  }

◆ retrieveOverlapRemovedConstituents() [3/3]

const xAOD::PFOContainer * met::METMaker::retrieveOverlapRemovedConstituents ( const xAOD::PFOContainer *  signals,
xAOD::MissingETAssociationHelper &  helper,
bool  retainMuon = false,
const xAOD::IParticleContainer *  muonCollection = 0,
MissingETBase::UsageHandler::Policy  p = MissingETBase::UsageHandler::ParticleFlow 
)
finaloverridevirtual

Implements IMETMaker.

Definition at line 1321 of file METMaker.cxx.

1322  {
1323 
1324  ATH_MSG_VERBOSE("Policy " << p <<" " <<MissingETBase::UsageHandler::ParticleFlow);
1325  const xAOD::MissingETAssociationMap* map = helper.map();
1326 
1327 
1328  // If muon is selected, flag it as non selected to retain its constituents in OR jets (to recover std. muon-jet overlap)
1329  std::vector<size_t> muon_index;
1330  if (retainMuon){
1331  bool originalInputs = !acc_originalObject.isAvailable(*muonCollection->front());
1332 
1333  for(const auto *const obj : *muonCollection) {
1334  const IParticle* orig = obj;
1335  if(!originalInputs) { orig = *acc_originalObject(*obj); }
1336  std::vector<const xAOD::MissingETAssociation*> assocs = xAOD::MissingETComposition::getAssociations(map,orig);
1337  if(assocs.empty()) {
1338  ATH_MSG_WARNING("Object is not in association map. Did you make a deep copy but fail to set the \"originalObjectLinks\" decoration?");
1339  ATH_MSG_WARNING("If not, Please apply xAOD::setOriginalObjectLinks() from xAODBase/IParticleHelpers.h");
1340  }
1341  if(MissingETComposition::objSelected(helper,orig)) {
1342  ATH_MSG_DEBUG("Muon with index "<<orig->index() << " is selected. Flag it as non selected before getOverlapRemovedSignals");
1343  muon_index.push_back(orig->index());
1344  for(size_t i = 0; i < assocs.size(); i++) helper.setObjSelectionFlag(assocs[i],orig,false);
1345  }
1346  }
1347 
1348  /*ATH_MSG_VERBOSE("Check selected muons before getOverlapRemovedSignals");
1349  for(const auto& obj : *muonCollection) {
1350  const IParticle* orig = obj;
1351  if(!originalInputs) { orig = *acc_originalObject(*obj); }
1352  ATH_MSG_VERBOSE("Muon with index "<<orig->index() << " is " << (MissingETComposition::objSelected(helper,orig) ? "" : "non-") << "selected" );
1353  }*/
1354  } // end retainMuon
1355 
1356  const xAOD::PFOContainer* ORsignals =static_cast<const xAOD::PFOContainer*>(map->getOverlapRemovedSignals(helper,signals,p));
1357 
1358  /*for (const auto tmp_const : *signals){ // printout overlap removed constituents
1359  bool keep=false;
1360  for (const auto constit : *ORsignals){
1361  if (constit->index()==tmp_const->index() && constit->charge()==tmp_const->charge()){keep=true;}
1362  }
1363  if (keep==false){ANA_MSG_DEBUG("Retrieve OR constituents: DON'T keep " << tmp_const->index() << " with charge " << tmp_const->charge() << " and pt "<<tmp_const->pt());}
1364  }*/
1365 
1366  // Flag back muons as selected
1367  if (retainMuon && !muon_index.empty()){
1368  bool originalInputs = !acc_originalObject.isAvailable(*muonCollection->front());
1369  for(const auto *const obj : *muonCollection) {
1370  const IParticle* orig = obj;
1371  if(!originalInputs) { orig = *acc_originalObject(*obj); }
1372  std::vector<const xAOD::MissingETAssociation*> assocs = xAOD::MissingETComposition::getAssociations(map,orig);
1373  for (size_t ind=0; ind<muon_index.size();ind++){
1374  if(orig->index()==muon_index.at(ind)) {
1375  for(size_t i = 0; i < assocs.size(); i++) helper.setObjSelectionFlag(assocs[i],orig,true);
1376  }
1377  }
1378  }
1379  /*ATH_MSG_VERBOSE("Check selected muons after getOverlapRemovedSignals");
1380  for(const auto& obj : *muonCollection) {
1381  const IParticle* orig = obj;
1382  if(!originalInputs) { orig = *acc_originalObject(*obj); }
1383  ATH_MSG_VERBOSE("Muon with index "<<orig->index() << " is selected?" << MissingETComposition::objSelected(helper,orig));
1384  }*/
1385  }
1386 
1387  return ORsignals;
1388  }

◆ sysInitialize()

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

Perform system initialization for an algorithm.

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

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

◆ sysStart()

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

Handle START transition.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_acc_jetJvtMoment

std::unique_ptr<SG::AuxElement::ConstAccessor<float > > met::METMaker::m_acc_jetJvtMoment
private

Definition at line 176 of file METMaker.h.

◆ m_acc_jetRejectionDec

std::unique_ptr<SG::AuxElement::ConstAccessor<char > > met::METMaker::m_acc_jetRejectionDec
private

Definition at line 177 of file METMaker.h.

◆ m_CenJetPtCut

double met::METMaker::m_CenJetPtCut
private

Definition at line 189 of file METMaker.h.

◆ m_customCenJetPtCut

double met::METMaker::m_customCenJetPtCut
private

Definition at line 203 of file METMaker.h.

◆ m_customFwdJetPtCut

double met::METMaker::m_customFwdJetPtCut
private

Definition at line 203 of file METMaker.h.

◆ m_customJvtCut

double met::METMaker::m_customJvtCut
private

Definition at line 204 of file METMaker.h.

◆ m_customJvtPtMax

double met::METMaker::m_customJvtPtMax
private

Definition at line 204 of file METMaker.h.

◆ m_customJvtWP

std::string met::METMaker::m_customJvtWP
private

Definition at line 205 of file METMaker.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::METMaker::m_doConstJet
private

Definition at line 209 of file METMaker.h.

◆ m_doPFlow

bool met::METMaker::m_doPFlow
private

Definition at line 207 of file METMaker.h.

◆ m_doRemoveElecTrks

bool met::METMaker::m_doRemoveElecTrks
private

Definition at line 213 of file METMaker.h.

◆ m_doRemoveElecTrksEM

bool met::METMaker::m_doRemoveElecTrksEM
private

Definition at line 214 of file METMaker.h.

◆ m_doRemoveMuonJets

bool met::METMaker::m_doRemoveMuonJets
private

Definition at line 212 of file METMaker.h.

◆ m_doSetMuonJetEMScale

bool met::METMaker::m_doSetMuonJetEMScale
private

Definition at line 215 of file METMaker.h.

◆ m_doSoftTruth

bool met::METMaker::m_doSoftTruth
private

Definition at line 208 of file METMaker.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_FwdJetPtCut

double met::METMaker::m_FwdJetPtCut
private

Definition at line 189 of file METMaker.h.

◆ m_greedyPhotons

bool met::METMaker::m_greedyPhotons
private

Definition at line 220 of file METMaker.h.

◆ m_jetConstitScaleMom

std::string met::METMaker::m_jetConstitScaleMom
private

Definition at line 185 of file METMaker.h.

◆ m_jetCorrectPhi

bool met::METMaker::m_jetCorrectPhi
private

Definition at line 182 of file METMaker.h.

◆ m_jetEmfMuOlap

double met::METMaker::m_jetEmfMuOlap
private

Definition at line 227 of file METMaker.h.

◆ m_JetEtaForw

double met::METMaker::m_JetEtaForw
private

Definition at line 192 of file METMaker.h.

◆ m_JetEtaMax

double met::METMaker::m_JetEtaMax
private

Definition at line 191 of file METMaker.h.

◆ m_jetJvtMomentName

std::string met::METMaker::m_jetJvtMomentName
private

Definition at line 186 of file METMaker.h.

◆ m_jetMinEfrac

double met::METMaker::m_jetMinEfrac
private

Definition at line 183 of file METMaker.h.

◆ m_jetMinWeightedPt

double met::METMaker::m_jetMinWeightedPt
private

Definition at line 184 of file METMaker.h.

◆ m_jetPsEMuOlap

double met::METMaker::m_jetPsEMuOlap
private

Definition at line 226 of file METMaker.h.

◆ m_jetRejectionDec

std::string met::METMaker::m_jetRejectionDec
private

Definition at line 187 of file METMaker.h.

◆ m_jetSelection

std::string met::METMaker::m_jetSelection
private

Definition at line 194 of file METMaker.h.

◆ m_jetTrkNMuOlap

int met::METMaker::m_jetTrkNMuOlap
private

Definition at line 224 of file METMaker.h.

◆ m_jetTrkPtMuPt

double met::METMaker::m_jetTrkPtMuPt
private

Definition at line 228 of file METMaker.h.

◆ m_jetWidthMuOlap

double met::METMaker::m_jetWidthMuOlap
private

Definition at line 225 of file METMaker.h.

◆ m_JvtCut

double met::METMaker::m_JvtCut
private

Definition at line 190 of file METMaker.h.

◆ m_JvtCutMedium

double met::METMaker::m_JvtCutMedium
private

Definition at line 200 of file METMaker.h.

◆ m_JvtCutTight

double met::METMaker::m_JvtCutTight
private

Definition at line 199 of file METMaker.h.

◆ m_JvtMediumPtMax

double met::METMaker::m_JvtMediumPtMax
private

Definition at line 200 of file METMaker.h.

◆ m_JvtPtMax

double met::METMaker::m_JvtPtMax
private

Definition at line 190 of file METMaker.h.

◆ m_JvtTightPtMax

double met::METMaker::m_JvtTightPtMax
private

Definition at line 199 of file METMaker.h.

◆ m_JvtTool

ToolHandle<IAsgSelectionTool> met::METMaker::m_JvtTool
private

Definition at line 232 of file METMaker.h.

◆ m_JvtWP

std::string met::METMaker::m_JvtWP
private

Definition at line 195 of file METMaker.h.

◆ m_missObjWarningPtThreshold

float met::METMaker::m_missObjWarningPtThreshold
private

Definition at line 180 of file METMaker.h.

◆ m_muEloss

bool met::METMaker::m_muEloss
private

Definition at line 218 of file METMaker.h.

◆ m_muIDPTJetPtRatioMuOlap

double met::METMaker::m_muIDPTJetPtRatioMuOlap
private

Definition at line 229 of file METMaker.h.

◆ m_orCaloTaggedMuon

bool met::METMaker::m_orCaloTaggedMuon
private

Definition at line 219 of file METMaker.h.

◆ m_PVkey

SG::ReadHandleKey<xAOD::VertexContainer> met::METMaker::m_PVkey
private

Definition at line 172 of file METMaker.h.

◆ m_skipSystematicJetSelection

bool met::METMaker::m_skipSystematicJetSelection
private

Definition at line 216 of file METMaker.h.

◆ m_trkseltool

ToolHandle<InDet::IInDetTrackSelectionTool> met::METMaker::m_trkseltool
private

Definition at line 231 of file METMaker.h.

◆ m_useGhostMuons

bool met::METMaker::m_useGhostMuons
private

Definition at line 211 of file METMaker.h.

◆ m_useR21JvtFallback

bool met::METMaker::m_useR21JvtFallback
private

Definition at line 196 of file METMaker.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_veryGreedyPhotons

bool met::METMaker::m_veryGreedyPhotons
private

Definition at line 221 of file METMaker.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:
MissingETContainer
Definition: Reconstruction/MissingETEvent/MissingETEvent/MissingETContainer.h:22
met::METMaker::m_muEloss
bool m_muEloss
Definition: METMaker.h:218
met::METMaker::m_jetTrkNMuOlap
int m_jetTrkNMuOlap
Definition: METMaker.h:224
xAOD::Electron
Electron_v1 Electron
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Electron.h:17
met::METMaker::m_skipSystematicJetSelection
bool m_skipSystematicJetSelection
Definition: METMaker.h:216
MissingETBase::Source::muon
static Types::bitmask_t muon(Region reg=Region::FullAcceptance)
Standard MET term from reconstructed muons.
Definition: MissingETBase.h:250
met::METMaker::rebuildJetMET
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) override final
Definition: METMaker.cxx:564
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
MissingETBase::UsageHandler::PhysicsObject
@ PhysicsObject
Physics object based.
Definition: MissingETCompositionBase.h:187
met::METMaker::m_customFwdJetPtCut
double m_customFwdJetPtCut
Definition: METMaker.h:203
MissingETBase::UsageHandler::TruthParticle
@ TruthParticle
Truth particle based.
Definition: MissingETCompositionBase.h:189
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
met::METMaker::rebuildTrackMET
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) override final
Definition: METMaker.cxx:527
met::METMaker::m_jetPsEMuOlap
double m_jetPsEMuOlap
Definition: METMaker.h:226
met::METMaker::m_JvtPtMax
double m_JvtPtMax
Definition: METMaker.h:190
met::METMaker::m_missObjWarningPtThreshold
float m_missObjWarningPtThreshold
Definition: METMaker.h:180
xAOD::MissingETAssociation_v1
MET association descriptor contains object links and corresponding parameters.
Definition: MissingETAssociation_v1.h:29
met::METMaker::m_acc_jetJvtMoment
std::unique_ptr< SG::AuxElement::ConstAccessor< float > > m_acc_jetJvtMoment
Definition: METMaker.h:176
xAOD::MissingET_v1::sumet
float sumet() const
Returns.
met::METMaker::m_doSetMuonJetEMScale
bool m_doSetMuonJetEMScale
Definition: METMaker.h:215
xAOD::MissingETAssociationMap_v1::getOverlapRemovedSignals
const IParticleContainer * getOverlapRemovedSignals(const MissingETAssociationHelper &helper, const IParticleContainer *signals, MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::TrackCluster) const
Extract a container of constituents that do not overlap physics objects.
Definition: MissingETAssociationMap_v1.cxx:269
met::METMaker::m_doPFlow
bool m_doPFlow
Definition: METMaker.h:207
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
met::METMaker::m_jetConstitScaleMom
std::string m_jetConstitScaleMom
Definition: METMaker.h:185
Trk::indices
std::pair< long int, long int > indices
Definition: AlSymMatBase.h:24
MissingETBase::Source::electron
static Types::bitmask_t electron(Region reg=Region::FullAcceptance)
Standard MET term from reconstructed electrons.
Definition: MissingETBase.h:229
met::METMaker::m_jetCorrectPhi
bool m_jetCorrectPhi
Definition: METMaker.h:182
met::METMaker::m_jetSelection
std::string m_jetSelection
Definition: METMaker.h:194
xAOD::MissingETComposition::objSelected
static bool objSelected(const MissingETAssociationHelper &helper, const IParticle *obj)
Definition: Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx:375
xAOD::ShallowAuxContainer
Class creating a shallow copy of an existing auxiliary container.
Definition: ShallowAuxContainer.h:54
MissingETBase::Source::track
static Types::bitmask_t track(Region reg=Region::FullAcceptance)
Bit mask for MET term from Track signal objects.
Definition: MissingETBase.h:291
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
met::METMaker::m_CenJetPtCut
double m_CenJetPtCut
Definition: METMaker.h:189
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
xAOD::IParticle::type
virtual Type::ObjectType type() const =0
The type of the object as a simple enumeration.
met::METMaker::m_JetEtaForw
double m_JetEtaForw
Definition: METMaker.h:192
MissingETBase::Source::Region::Central
@ Central
Indicator for MET contribution from the central region.
met::METMaker::m_jetEmfMuOlap
double m_jetEmfMuOlap
Definition: METMaker.h:227
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:54
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
met::METMaker::m_FwdJetPtCut
double m_FwdJetPtCut
Definition: METMaker.h:189
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
MissingETBase::Types::bitmask_t
uint64_t bitmask_t
Type for status word bit mask.
Definition: MissingETBase.h:39
xAOD::MissingETAssociation
MissingETAssociation_v1 MissingETAssociation
Version control by type definition.
Definition: MissingETAssociation.h:15
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:40
MissingETBase::UsageHandler::OnlyCluster
@ OnlyCluster
CaloCluster based only.
Definition: MissingETCompositionBase.h:184
MissingETBase::Source::isTrackTerm
static bool isTrackTerm(Types::bitmask_t bits, Region reg=Region::FullAcceptance)
Definition: MissingETBase.h:404
met::METMaker::m_muIDPTJetPtRatioMuOlap
double m_muIDPTJetPtRatioMuOlap
Definition: METMaker.h:229
I4Momentum::pt
virtual double pt() const =0
transverse momentum
ReweightUtils.message
message
Definition: ReweightUtils.py:15
met::METMaker::m_customJvtCut
double m_customJvtCut
Definition: METMaker.h:204
met::METMaker::m_customCenJetPtCut
double m_customCenJetPtCut
Definition: METMaker.h:203
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
xAOD::MissingETAssociation_v1::ConstVec
Vector sum of constituents for subtractive overlap removal.
Definition: MissingETAssociation_v1.h:36
MissingETBase::Source::Type::Muon
@ Muon
Indicator for the MET term from reconstructed or MC truth muons.
xAOD::MissingETAssociationMap_v1
Definition: MissingETAssociationMap_v1.h:29
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
met::METMaker::m_doRemoveMuonJets
bool m_doRemoveMuonJets
Definition: METMaker.h:212
runBeamSpotCalibration.helper
helper
Definition: runBeamSpotCalibration.py:112
xAOD::TrackParticle
TrackParticle_v1 TrackParticle
Reference the current persistent version:
Definition: Event/xAOD/xAODTracking/xAODTracking/TrackParticle.h:13
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
met::METMaker::m_JetEtaMax
double m_JetEtaMax
Definition: METMaker.h:191
asg::AsgTool::AsgTool
AsgTool(const std::string &name)
Constructor specifying the tool instance's name.
Definition: AsgTool.cxx:58
met
Definition: IMETSignificance.h:24
xAOD::MissingETComposition::getConstVec
static MissingETBase::Types::constvec_t getConstVec(const MissingETAssociationMap *pMap, const IParticle *pPart, MissingETBase::UsageHandler::Policy p)
Definition: Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx:361
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
AthCommonDataStore
Definition: AthCommonDataStore.h:52
asg::AsgTool::getKey
SG::sgkey_t getKey(const void *ptr) const
Get the (hashed) key of an object that is in the event store.
Definition: AsgTool.cxx:119
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
asg::AsgToolConfig
an object that can create a AsgTool
Definition: AsgToolConfig.h:22
lumiFormat.i
int i
Definition: lumiFormat.py:92
SG::OWN_ELEMENTS
@ OWN_ELEMENTS
this data object owns its elements
Definition: OwnershipPolicy.h:17
met::METMaker::m_JvtWP
std::string m_JvtWP
Definition: METMaker.h:195
xAOD::PFO
PFO_v1 PFO
Definition of the current "pfo version".
Definition: PFO.h:17
ReadCalibFromCool.keep
keep
Definition: ReadCalibFromCool.py:85
met::METMaker::m_doSoftTruth
bool m_doSoftTruth
Definition: METMaker.h:208
MissingETBase::Source::jet
static Types::bitmask_t jet(Region reg=Region::FullAcceptance)
Standard MET term from reconstructed jets.
Definition: MissingETBase.h:257
met::METMaker::m_jetTrkPtMuPt
double m_jetTrkPtMuPt
Definition: METMaker.h:228
met::METMaker::m_customJvtPtMax
double m_customJvtPtMax
Definition: METMaker.h:204
vector
Definition: MultiHisto.h:13
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
met::METMaker::m_jetMinEfrac
double m_jetMinEfrac
Definition: METMaker.h:183
xAOD::MissingETAssociation_v1::ConstVec::cpy
float cpy() const
Returns .
xAOD::MissingETAssociation_v1::ConstVec::sumpt
float sumpt() const
Returns sum of component pt.
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:571
met::METMaker::m_useGhostMuons
bool m_useGhostMuons
Definition: METMaker.h:211
DataVector::front
const T * front() const
Access the first element in the collection as an rvalue.
MissingETBase::Source::Category::Calo
@ Calo
Indicator for MET terms reconstructed from calorimeter signals alone.
met::METMaker::m_JvtMediumPtMax
double m_JvtMediumPtMax
Definition: METMaker.h:200
met::METMaker::m_PVkey
SG::ReadHandleKey< xAOD::VertexContainer > m_PVkey
Definition: METMaker.h:172
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
xAOD::MissingET_v1::mpx
float mpx() const
Returns .
met::METMaker::m_customJvtWP
std::string m_customJvtWP
Definition: METMaker.h:205
python.xAODType.dummy
dummy
Definition: xAODType.py:4
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
met::METMaker::m_useR21JvtFallback
bool m_useR21JvtFallback
Definition: METMaker.h:196
xAOD::MissingETAssociationMap_v1::getMiscAssociation
const MissingETAssociation_v1 * getMiscAssociation() const
Get an association for miscellaneous objects not associated to jets.
Definition: MissingETAssociationMap_v1.cxx:186
met::METMaker::m_doConstJet
bool m_doConstJet
Definition: METMaker.h:209
SG::AuxElement::index
size_t index() const
Return the index of this element within its container.
xAOD::MissingET_v1::name
const std::string & name() const
Identifier getters.
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
python.L1.Config.LegacyTopoMergerMap.signals
signals
Definition: LegacyTopoMergerMap.py:13
met::METMaker::m_doRemoveElecTrksEM
bool m_doRemoveElecTrksEM
Definition: METMaker.h:214
compute_lumi.denom
denom
Definition: compute_lumi.py:76
xAOD::Jet_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: Jet_v1.cxx:49
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
MissingETBase::UsageHandler::Policy
Policy
Policies on usage checks.
Definition: MissingETCompositionBase.h:182
xAOD::MissingET_v1::add
void add(const IParticle *particle)
Add particle kinematics to MET.
Definition: MissingET_v1.cxx:77
xAOD::JetFourMom_t
ROOT::Math::LorentzVector< ROOT::Math::PtEtaPhiM4D< double > > JetFourMom_t
Base 4 Momentum type for Jet.
Definition: JetTypes.h:17
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
xAOD::PFO_v1
Class describing a particle flow object.
Definition: PFO_v1.h:35
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
MissingETBase::Source::tau
static Types::bitmask_t tau(Region reg=Region::FullAcceptance)
Standard MET term from reconstructed tau leptons.
Definition: MissingETBase.h:243
pmontree.opt
opt
Definition: pmontree.py:16
VP1PartSpect::E
@ E
Definition: VP1PartSpectFlags.h:21
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
MissingETBase::UsageHandler::OnlyTrack
@ OnlyTrack
Track based only.
Definition: MissingETCompositionBase.h:185
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
xAOD::MissingET_v1::source
MissingETBase::Types::bitmask_t source() const
MET object source tag.
xAOD::MissingETComposition::getAssociation
static const MissingETAssociation * getAssociation(const MissingETAssociationMap *pMap, const Jet *pJet)
Definition: Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx:415
SG::sgkey_t
uint32_t sgkey_t
Type used for hashed StoreGate key+CLID pairs.
Definition: CxxUtils/CxxUtils/sgkey_t.h:32
met::METMaker::m_acc_jetRejectionDec
std::unique_ptr< SG::AuxElement::ConstAccessor< char > > m_acc_jetRejectionDec
Definition: METMaker.h:177
met::METMaker::m_JvtTightPtMax
double m_JvtTightPtMax
Definition: METMaker.h:199
xAOD::Electron_v1
Definition: Electron_v1.h:34
met::METMaker::m_jetMinWeightedPt
double m_jetMinWeightedPt
Definition: METMaker.h:184
met::METMaker::rebuildMET
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) override final
Definition: METMaker.cxx:249
MissingETBase::UsageHandler::ParticleFlow
@ ParticleFlow
Particle Flow Object based.
Definition: MissingETCompositionBase.h:188
xAOD::Photon
Photon_v1 Photon
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Photon.h:17
met::METMaker::m_doRemoveElecTrks
bool m_doRemoveElecTrks
Definition: METMaker.h:213
Muon
struct TBPatternUnitContext Muon
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
met::METMaker::m_JvtCutMedium
double m_JvtCutMedium
Definition: METMaker.h:200
xAOD::PFO_v1::setP4
void setP4(const FourMom_t &vec)
set the 4-vec
Definition: PFO_v1.cxx:107
met::METMaker::m_jetWidthMuOlap
double m_jetWidthMuOlap
Definition: METMaker.h:225
DeMoScan.index
string index
Definition: DeMoScan.py:362
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
a
TList * a
Definition: liststreamerinfos.cxx:10
python.selector.AtlRunQuerySelectorLhcOlc.selector
selector
Definition: AtlRunQuerySelectorLhcOlc.py:611
h
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
met::METMaker::getPV
const xAOD::Vertex * getPV() const
Definition: METMaker.cxx:1398
xAOD::MissingETAssociation_v1::ConstVec::cpt
float cpt() const
Returns .
Definition: MissingETAssociation_v1.cxx:87
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
met::METMaker::acceptTrack
bool acceptTrack(const xAOD::TrackParticle *trk, const xAOD::Vertex *vx) const
Definition: METMaker.cxx:1393
MissingET
Definition: Reconstruction/MissingETEvent/MissingETEvent/MissingET.h:23
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
python.changerun.pv
pv
Definition: changerun.py:81
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
DataVector::ownPolicy
SG::OwnershipPolicy ownPolicy() const
Return the ownership policy setting for this container.
met::METMaker::m_JvtCutTight
double m_JvtCutTight
Definition: METMaker.h:199
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
met::METMaker::m_jetJvtMomentName
std::string m_jetJvtMomentName
Definition: METMaker.h:186
xAODType::Tau
@ Tau
The object is a tau (jet)
Definition: ObjectType.h:49
MissingETBase::Source::photon
static Types::bitmask_t photon(Region reg=Region::FullAcceptance)
Standard MET term from reconstructed photons.
Definition: MissingETBase.h:236
pickleTool.object
object
Definition: pickleTool.py:30
met::METMaker::m_veryGreedyPhotons
bool m_veryGreedyPhotons
Definition: METMaker.h:221
defineDB.jets
list jets
Definition: JetTagCalibration/share/defineDB.py:24
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
met::fillMET
StatusCode fillMET(xAOD::MissingET *&met, xAOD::MissingETContainer *metCont, const std::string &metKey, const MissingETBase::Types::bitmask_t metSource)
Definition: METHelpers.cxx:123
SG::AuxElement::container
const SG::AuxVectorData * container() const
Return the container holding this element.
xAOD::MissingETAssociation_v1::ConstVec::cpx
float cpx() const
Returns .
met::METMaker::m_greedyPhotons
bool m_greedyPhotons
Definition: METMaker.h:220
xAOD::MissingET_v1::mpy
float mpy() const
Returns .
xAOD::JetAttribute::GhostTrack
@ GhostTrack
Definition: JetAttributes.h:252
python.PyAthena.obj
obj
Definition: PyAthena.py:135
SG::DataProxy
Definition: DataProxy.h:44
met::METMaker::retrieveOverlapRemovedConstituents
virtual StatusCode retrieveOverlapRemovedConstituents(const xAOD::PFOContainer *cpfo, const xAOD::PFOContainer *npfo, xAOD::MissingETAssociationHelper &metHelper, xAOD::PFOContainer *OR_cpfos, xAOD::PFOContainer *OR_npfos, bool retainMuon=false, const xAOD::IParticleContainer *muonCollection=0) override final
Definition: METMaker.cxx:1263
xAOD::bool
setBGCode setTAP setLVL2ErrorBits bool
Definition: TrigDecision_v1.cxx:60
xAOD::Jet_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
Definition: Jet_v1.cxx:44
IParticle
Definition: Event/EventKernel/EventKernel/IParticle.h:43
xAOD::MissingETComposition::selectIfNoOverlaps
static bool selectIfNoOverlaps(MissingETAssociationHelper &helper, const IParticle *obj, MissingETBase::UsageHandler::Policy p)
Definition: Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx:382
met::METMaker::m_JvtTool
ToolHandle< IAsgSelectionTool > m_JvtTool
Definition: METMaker.h:232
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
xAOD::MissingETAssociation_v1::ConstVec::ce
float ce() const
Returns .
met::METMaker::m_orCaloTaggedMuon
bool m_orCaloTaggedMuon
Definition: METMaker.h:219
xAOD::Jet
Jet_v1 Jet
Definition of the current "jet version".
Definition: Event/xAOD/xAODJet/xAODJet/Jet.h:17
met::METMaker::m_jetRejectionDec
std::string m_jetRejectionDec
Definition: METMaker.h:187
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
checkFileSG.ind
list ind
Definition: checkFileSG.py:118
fitman.k
k
Definition: fitman.py:528
xAOD::MissingETComposition::getAssociations
static std::vector< const MissingETAssociation * > getAssociations(const MissingETAssociationMap *pMap, const IParticle *pPart)
Access non-modifiable contribution object.
Definition: Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx:391
xAOD::Muon_v1::muonType
MuonType muonType() const
met::METMaker::m_trkseltool
ToolHandle< InDet::IInDetTrackSelectionTool > m_trkseltool
Definition: METMaker.h:231
met::METMaker::m_JvtCut
double m_JvtCut
Definition: METMaker.h:190
met::iplink_t
ElementLink< xAOD::IParticleContainer > iplink_t
Definition: METMaker.cxx:70
Generated on Fri Jun 28 2024 22:21:29 for ATLAS Offline Software by   doxygen 1.8.18