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

#include <JetPFlowSelectionAlg.h>

Inheritance diagram for JetPFlowSelectionAlg:
Collaboration diagram for JetPFlowSelectionAlg:

Public Member Functions

 JetPFlowSelectionAlg (const std::string &n, ISvcLocator *l)
 
StatusCode initialize () override
 Athena algorithm's Hooks. More...
 
StatusCode execute (const EventContext &ctx) const override
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &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

virtual ::StatusCode finalize ()
 finalize this algorithm More...
 
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< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

Gaudi::Property< std::string > m_electronIDToExclude {this,"electronIDToExclude","LHMedium","Select electron ID to exclude"}
 
Gaudi::Property< std::string > m_electronIDToInclude {this,"electronIDToInclude","LHLoose","Select electron ID to include"}
 
Gaudi::Property< bool > m_excludeChargedElectronFE {this,"excludeChargedElectronFE",true,"Exclude charged FE matched to electrons"}
 
Gaudi::Property< bool > m_includeChargedElectronFE {this,"includeChargedElectronFE",false,"Include charged FE matched to electrons"}
 
Gaudi::Property< bool > m_excludeNeutralElectronFE {this,"excludeNeutralElectronFE",false,"Exclude neutral FE matched to electrons"}
 
Gaudi::Property< bool > m_includeNeutralElectronFE {this,"includeNeutralElectronFE",false,"Include neutral FE matched to electrons"}
 
Gaudi::Property< std::string > m_muonIDToExclude {this,"muonIDToExclude","Medium","Select muon ID to exclude"}
 
Gaudi::Property< std::string > m_muonIDToInclude {this,"muonIDToInclude","Loose","Select muon ID to include"}
 
Gaudi::Property< bool > m_excludeChargedMuonFE {this,"excludeChargedMuonFE",true,"Exclude charged FE matched to muons"}
 
Gaudi::Property< bool > m_includeChargedMuonFE {this,"includeChargedMuonFE",false,"Include charged FE matched to muons"}
 
Gaudi::Property< bool > m_excludeNeutralMuonFE {this,"excludeNeutralMuonFE",false,"Exclude neutral FE matched to muons"}
 
Gaudi::Property< bool > m_includeNeutralMuonFE {this,"includeNeutralMuonFE",false,"Include neutral FE matched to muons"}
 
SG::ReadHandleKey< xAOD::FlowElementContainerm_ChargedPFlowContainerKey = {this, "ChargedPFlowInputContainer", "", "The input Charged PFlow Objects"}
 
SG::ReadHandleKey< xAOD::FlowElementContainerm_NeutralPFlowContainerKey = {this, "NeutralPFlowInputContainer", "", "The input Neutral PFlow Objects"}
 
SG::ReadHandleKey< xAOD::ElectronContainerm_electronContainerKey = {this, "ElectronInputContainer", "", "The input electron container"}
 
SG::WriteHandleKey< xAOD::FlowElementContainerm_outputChargedPFlowHandleKey = {this, "ChargedPFlowOutputContainer", "GlobalPFlowChargedParticleFlowObjects", "The output filtered Charged PFlow Objects"}
 
SG::WriteHandleKey< xAOD::FlowElementContainerm_outputNeutralPFlowHandleKey = {this, "NeutralPFlowOutputContainer", "GlobalPFlowNeutralParticleFlowObjects", "The output filtered Neutral PFlow Objects"}
 
SG::ReadDecorHandleKey< xAOD::FlowElementContainerm_chargedFEElectronsReadDecorKey {this, "ChargedFEElectronsReadDecorKey", "JetETMissChargedParticleFlowObjects.FE_ElectronLinks", "Key for links from charged FE to electrons"}
 
SG::ReadDecorHandleKey< xAOD::FlowElementContainerm_chargedFEMuonsReadDecorKey {this, "ChargedFEMuonsReadDecorKey", "JetETMissChargedParticleFlowObjects.FE_MuonLinks", "Key for links from charged FE to muons"}
 
SG::ReadDecorHandleKey< xAOD::FlowElementContainerm_neutralFEElectronsReadDecorKey {this, "NeutralFEElectronsReadDecorKey", "JetETMissNeutralParticleFlowObjects.FE_ElectronLinks", "Key for links from neutral FE to electrons"}
 
SG::ReadDecorHandleKey< xAOD::FlowElementContainerm_neutralFEMuonsReadDecorKey {this, "NeutralFEMuonsReadDecorKey","JetETMissNeutralParticleFlowObjects.FE_MuonLinks", "Key for links from neutral FE to muons"}
 
SG::ReadDecorHandleKey< xAOD::FlowElementContainerm_neutralFEMuons_efrac_match_DecorKey {this,"FlowElementContainer_FE_efrac_matched_muon","JetETMissNeutralParticleFlowObjects.FE_efrac_matched_muon","ReadDecorHandleKey for the fraction of neutral FlowElements cluster energy used to match to Muons"}
 
SG::ReadDecorHandleKey< xAOD::FlowElementContainerm_chargedFE_energy_match_muonReadHandleKey {this,"FlowElementContainer_ChargedFE_energy_matched_muon","JetETMissChargedParticleFlowObjects.FE_efrac_matched_muon","ReadHandleKey for the fraction of neutral FlowElements cluster energy used to match to Muons"}
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Algorithm creates a filtered collection of PFlow Objects not matched to electrons/muons.

Definition at line 24 of file JetPFlowSelectionAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ JetPFlowSelectionAlg()

JetPFlowSelectionAlg::JetPFlowSelectionAlg ( const std::string &  n,
ISvcLocator *  l 
)
inline

Definition at line 28 of file JetPFlowSelectionAlg.h.

Member Function Documentation

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality
overridevirtualinherited

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

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

64 {
65  return 0;
66 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

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

Definition at line 41 of file JetPFlowSelectionAlg.cxx.

41  {
42  ATH_MSG_DEBUG(" execute() ... ");
43 
44  //Check for invalid combinations of flags
46  ATH_MSG_ERROR("excludeChargedElectronFE and includeChargedMuonFE are mutually exclusive!");
47  return StatusCode::FAILURE;
48  }
49 
51  ATH_MSG_ERROR("excludeChargedElectronFE and includeChargedElectronFE are mutually exclusive!");
52  return StatusCode::FAILURE;
53  }
54 
56  if (! ChargedPFlowObjects.isValid()){
57  ATH_MSG_ERROR("Can't retrieve input container "<< m_ChargedPFlowContainerKey);
58  return StatusCode::FAILURE;
59  }
60 
62  if (! NeutralPFlowObjects.isValid()){
63  ATH_MSG_ERROR("Can't retrieve input container "<< m_NeutralPFlowContainerKey);
64  return StatusCode::FAILURE;
65  }
66 
68  if (!chargedFE_ElectronLinks.isValid()){
69  ATH_MSG_ERROR("Can't retrieve input decoration " << chargedFE_ElectronLinks.key());
70  return StatusCode::FAILURE;
71  }
72 
74  if (!chargedFE_MuonLinks.isValid()){
75  ATH_MSG_ERROR("Can't retrieve input decoration "<< chargedFE_MuonLinks.key());
76  return StatusCode::FAILURE;
77  }
78 
80  if (!neutralFE_ElectronLinks.isValid()){
81  ATH_MSG_ERROR("Can't retrieve input decoration "<< neutralFE_ElectronLinks.key());
82  return StatusCode::FAILURE;
83  }
84 
86  if (!neutralFE_MuonLinks.isValid()){
87  ATH_MSG_ERROR("Can't retrieve input decoration "<< neutralFE_MuonLinks.key());
88  return StatusCode::FAILURE;
89  }
90 
91  auto selectedChargedPFlowObjects = std::make_unique<xAOD::FlowElementContainer>(); // SG::VIEW_ELEMENTS
92  auto selectedChargedPFlowObjectsAux = std::make_unique<xAOD::FlowElementAuxContainer>();
93  selectedChargedPFlowObjects->setStore(selectedChargedPFlowObjectsAux.get());
94 
95  auto selectedNeutralPFlowObjects = std::make_unique<xAOD::FlowElementContainer>();
96  auto selectedNeutralPFlowObjectsAux = std::make_unique<xAOD::FlowElementAuxContainer>();
97  selectedNeutralPFlowObjects->setStore(selectedNeutralPFlowObjectsAux.get());
98 
99  // To store the charged FE objects matched to an electron/muon
100  std::vector< const xAOD::FlowElement* > ChargedPFlowObjects_matched;
101 
102  FEMuonHelper muonHelper;
103  FEElectronHelper electronHelper;
104 
105  // Loop over Charged FE objects
106  for ( const xAOD::FlowElement* fe : *ChargedPFlowObjects ) {
107 
108  bool isMuonToExclude = muonHelper.checkMuonLinks(chargedFE_MuonLinks(*fe), m_muonIDToExclude);
109  bool isMuonToInclude = muonHelper.checkMuonLinks(chargedFE_MuonLinks(*fe), m_muonIDToInclude);
110  bool isElectronToInclude = electronHelper.checkElectronLinks(chargedFE_ElectronLinks(*fe), m_electronIDToInclude);
111  bool isElectronToExclude = electronHelper.checkElectronLinks(chargedFE_ElectronLinks(*fe), m_electronIDToExclude);
112 
113  bool excludeChargedFE = false;
114 
115  //If we have only an exclude list we only need to do:
116  if (m_excludeChargedElectronFE && isElectronToExclude) excludeChargedFE = true;
117  if (m_excludeChargedMuonFE && isMuonToExclude) excludeChargedFE = true;
118 
119  //If we have an include list and the include ID is passed, we keep the FE object
120  //Whilst if it otherwise passes excludeID we exclude it
121  //e.g if we want medium we should only include leptons that pass medium ID,
122  //whilst excluding those that pass loose and NOT medium.
123  if (m_includeChargedElectronFE && isElectronToInclude) excludeChargedFE = false;
124  else if (m_includeChargedElectronFE && isElectronToExclude) excludeChargedFE = true;
125 
126  if (m_includeChargedMuonFE && isMuonToInclude) excludeChargedFE = false;
127  else if (m_includeChargedMuonFE && isMuonToExclude) excludeChargedFE = true;
128 
129  // Select FE object if not matched to an electron or muon, to exclude, via links
130  if ( !excludeChargedFE) {
131  xAOD::FlowElement* selectedFE = new xAOD::FlowElement();
132  selectedChargedPFlowObjects->push_back(selectedFE);
133  *selectedFE = *fe; // copies auxdata
134  }
135  else { // Use the matched object to put back its energy later
136  ChargedPFlowObjects_matched.push_back(fe);
137  }
138 
139  } // End loop over Charged FE Objects
140 
141  // Loop over Neutral FE objects
142  for ( const xAOD::FlowElement* fe : *NeutralPFlowObjects ) {
143 
144  bool isMuonToExclude = muonHelper.checkMuonLinks(neutralFE_MuonLinks(*fe), m_muonIDToExclude);
145  bool isMuonToInclude = muonHelper.checkMuonLinks(neutralFE_MuonLinks(*fe), m_muonIDToInclude);
146  bool isElectronToInclude = electronHelper.checkElectronLinks(neutralFE_ElectronLinks(*fe), m_electronIDToInclude);
147  bool isElectronToExclude = electronHelper.checkElectronLinks(neutralFE_ElectronLinks(*fe), m_electronIDToExclude);
148 
149  //If we specify to exclude, then we exclude if exclude ID is passed
150  //If we specify to include, then we include if include ID is passed - in this case
151  //we might want to e.g include medium electrons, whilst excluding that poass loose ID
152  if (m_excludeNeutralElectronFE && isElectronToExclude) continue;
153  bool vetoElectron_IncludeMode = false;
154  if (m_includeNeutralElectronFE && isElectronToInclude) vetoElectron_IncludeMode = false;
155  else if (m_includeNeutralElectronFE && isElectronToExclude) vetoElectron_IncludeMode = true;
156  if (vetoElectron_IncludeMode) continue;
157 
158  xAOD::FlowElement* selectedFE = new xAOD::FlowElement();
159  selectedNeutralPFlowObjects->push_back(selectedFE);
160  *selectedFE = *fe;
161 
162  bool excludeNeutralMuon = false;
163  //Muons can have both exclude and include lists
164  //Exclude case is the same as electron exclude case
165  if (m_excludeNeutralMuonFE && isMuonToExclude) excludeNeutralMuon = true;
166  //Include case is more complex - if muon passes includeID we keep it
167  //Whilst if it otherwise passes excludeID we exclude it
168  //e.g if we want medium muons we should only include muons that pass medium ID,
169  //whilst excluding those that pass loose and NOT medium.
170  if (m_includeNeutralMuonFE && isMuonToInclude) excludeNeutralMuon = false;
171  else if (m_includeNeutralMuonFE && isMuonToExclude) excludeNeutralMuon = true;
172 
173  if (excludeNeutralMuon) {
174  // If we are excluding muons, we need to adjust the energy of the neutral FE object
175  // by subtracting the muon energy in this calorimeter cluster
177  selectedFE->setP4(muonHelper.adjustNeutralCaloEnergy(clusterMuonEnergyFracs(*fe),*fe));
178  }
179 
180  } // End loop over Neutral FE Objects
181 
182  // Add the energy from removed charged FE clusters to neutral FE object
183  // if shared clusters exist, create the new neutral FE object otherwise
184  for ( const xAOD::FlowElement* chargedFE : ChargedPFlowObjects_matched ){
185 
186  // Get charged FE topoclusters and weights
187  std::vector<std::pair<const xAOD::IParticle*,float> > theOtherPairs_charged = chargedFE->otherObjectsAndWeights();
188  std::vector<ElementLink<xAOD::IParticleContainer>> theOtherLinks_charged = chargedFE->otherObjectLinks();
189 
190  // Loop over charged FE topoclusters
191  for (unsigned int iCluster = 0; iCluster < chargedFE->nOtherObjects(); ++iCluster){
192 
193  bool thisCluster_matched = false;
194 
195  std::pair<const xAOD::IParticle*,float> theOtherPair_charged = theOtherPairs_charged[iCluster];
196  const xAOD::IParticle* theCluster_charged = theOtherPair_charged.first;
197  float theClusterWeight_charged = theOtherPair_charged.second;
198 
199  // Loop over neutral FE objects
200  for ( xAOD::FlowElement* neutralFE : *selectedNeutralPFlowObjects ) {
201  if (thisCluster_matched) continue;
202 
203  // Loop over neutral FE topoclusters
204  std::vector<std::pair<const xAOD::IParticle*,float> > theOtherPairs_neutral = neutralFE->otherObjectsAndWeights();
205  for (auto& [theCluster_neutral, theClusterWeight_neutral] : theOtherPairs_neutral){
206 
207  // If topoclusters are matched, add the energy to the neutral FE object
208  if (theCluster_charged == theCluster_neutral){
209 
210  // Add the energy to the neutral FE object
211  float newEnergy = neutralFE->e() + theClusterWeight_charged;
212  neutralFE->setP4(newEnergy/cosh(neutralFE->eta()),
213  neutralFE->eta(),
214  neutralFE->phi(),
215  neutralFE->m());
216 
217  ATH_MSG_DEBUG("Updated neutral FlowElement with E, pt, eta and phi: "
218  << neutralFE->e() << ", " << neutralFE->pt() << ", "
219  << neutralFE->eta() << " and " << neutralFE->phi());
220 
221  thisCluster_matched = true;
222  }
223 
224  } // End loop over neutral FE clusters
225  } // End loop over neutral FE objects
226 
227  // If a topocluster is left unmatched, create a neutral FE object.
228  // Ignore topoclusters with nullptr
229  if ( !thisCluster_matched && theCluster_charged ){
230 
231  //check if charged cluster belongs to an electron, before we put it back as neutral
232  bool belongsToElectron = false;
234 
235  //get container index of charged cluster and compare to indices of electron topoclusters
236  unsigned int chargedClusterIndex = theCluster_charged->index();
237 
239  if (!electronReadHandle.isValid()){
240  ATH_MSG_ERROR("Can't retrieve electron container "<< m_electronContainerKey.key());
241  return StatusCode::FAILURE;
242  }
243 
244  for (auto thisElectron : *electronReadHandle){
245  const std::vector<const xAOD::CaloCluster*> electronTopoClusters = xAOD::EgammaHelpers::getAssociatedTopoClusters(thisElectron->caloCluster());
246  for (auto thisElectronTopoCluster : electronTopoClusters){
247  if (thisElectronTopoCluster->index() == chargedClusterIndex){
248  belongsToElectron = true;
249  break;
250  }
251  }
252  }
253  }
254 
255  if (belongsToElectron) continue;
256 
257  double muonCaloEnergy = 0.0;
260  std::vector<double> muonCaloEnergies = chargedFE_energy_match_muonReadHandle(*chargedFE);
261  muonCaloEnergy = muonCaloEnergies[iCluster];
262  }
263 
264  xAOD::FlowElement* newFE = new xAOD::FlowElement();
265  selectedNeutralPFlowObjects->push_back(newFE);
266 
267  newFE->setP4((theClusterWeight_charged - muonCaloEnergy) / cosh(theCluster_charged->eta()), // using energy from charged FE weight, not cluster->e()
268  theCluster_charged->eta(),
269  theCluster_charged->phi(),
270  theCluster_charged->m());
271  newFE->setCharge(0);
272  newFE->setSignalType(xAOD::FlowElement::SignalType::NeutralPFlow);
273 
274  ATH_MSG_DEBUG("Created neutral FlowElement with E, pt, eta and phi: "
275  << newFE->e() << ", " << newFE->pt() << ", "
276  << newFE->eta() << " and " << newFE->phi());
277 
278  std::vector<ElementLink<xAOD::IParticleContainer>> theClusters;
280  theIParticleLink.resetWithKeyAndIndex(theOtherLinks_charged[iCluster].persKey(), theOtherLinks_charged[iCluster].persIndex());
281 
282  theClusters.push_back(theIParticleLink);
283  newFE->setOtherObjectLinks(theClusters);
284 
285  //Add Standard data to these new FlowElements
287  const xAOD::CaloCluster* castCluster_charged = dynamic_cast<const xAOD::CaloCluster*>(theCluster_charged);
288  FEFiller.addStandardMoments(*newFE,*castCluster_charged);
289  FEFiller.addStandardSamplingEnergies(*newFE,*castCluster_charged);
290 
291  float layerEnergy_TileBar0 = castCluster_charged->eSample(xAOD::CaloCluster::CaloSample::TileBar0);
292  float layerEnergy_TileExt0 = castCluster_charged->eSample(xAOD::CaloCluster::CaloSample::TileExt0);
293  const static SG::AuxElement::Accessor<float> accFloatTIle0E("LAYERENERGY_TILE0");
294  accFloatTIle0E(*newFE) = layerEnergy_TileBar0 + layerEnergy_TileExt0;
295 
296  const static SG::AuxElement::Accessor<float> accFloatTiming("TIMING");
297  accFloatTiming(*newFE) = castCluster_charged->time();
298  }
299 
300  } // End loop over topoclusters of removed charged FE objects
301  } // End loop over removed charged FE objects
302 
303 
304  auto handle_ChargedPFlow_out = SG::makeHandle(m_outputChargedPFlowHandleKey, ctx);
305  if (!handle_ChargedPFlow_out.record(std::move(selectedChargedPFlowObjects), std::move(selectedChargedPFlowObjectsAux)) ){
306  ATH_MSG_ERROR("Can't record output PFlow container "<< m_outputChargedPFlowHandleKey);
307  return StatusCode::FAILURE;
308  }
309 
310  auto handle_NeutralPFlow_out = SG::makeHandle(m_outputNeutralPFlowHandleKey, ctx);
311  if (!handle_NeutralPFlow_out.record(std::move(selectedNeutralPFlowObjects), std::move(selectedNeutralPFlowObjectsAux)) ){
312  ATH_MSG_ERROR("Can't record output PFlow container "<< m_outputNeutralPFlowHandleKey);
313  return StatusCode::FAILURE;
314  }
315 
316  return StatusCode::SUCCESS;
317 }

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

90 {
91  // If we didn't find any symlinks to add, just return the collection
92  // from the base class. Otherwise, return the extended collection.
93  if (!m_extendedExtraObjects.empty()) {
95  }
96  return BaseAlg::extraOutputDeps();
97 }

◆ filterPassed()

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

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

96  {
97  return execState( ctx ).filterPassed();
98  }

◆ finalize()

StatusCode EL::AnaReentrantAlgorithm::finalize ( )
protectedinherited

finalize this algorithm

This gets called after event processing has finished. The last event may no longer be in memory, and the code should not try to access it.

Definition at line 102 of file AnaReentrantAlgorithm.cxx.

104  {
105  return StatusCode::SUCCESS;
106  }

◆ initialize()

StatusCode JetPFlowSelectionAlg::initialize ( )
override

Athena algorithm's Hooks.

Definition at line 20 of file JetPFlowSelectionAlg.cxx.

20  {
21  ATH_MSG_DEBUG("Initializing " );
22 
27  }
36 
37 
38  return StatusCode::SUCCESS;
39 }

◆ inputHandles()

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

Return this algorithm's input handles.

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

◆ isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

52 {
53  // Reentrant algorithms are clonable.
54  return true;
55 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

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

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

100  {
101  execState( ctx ).setFilterPassed( state );
102  }

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext &  ctx)
overridevirtualinherited

Execute an algorithm.

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

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

77 {
78  return BaseAlg::sysExecute (ctx);
79 }

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

107  {
109 
110  if (sc.isFailure()) {
111  return sc;
112  }
113 
114  ServiceHandle<ICondSvc> cs("CondSvc",name());
115  for (auto h : outputHandles()) {
116  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
117  // do this inside the loop so we don't create the CondSvc until needed
118  if ( cs.retrieve().isFailure() ) {
119  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
120  return StatusCode::SUCCESS;
121  }
122  if (cs->regHandle(this,*h).isFailure()) {
123  sc = StatusCode::FAILURE;
124  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
125  << " with CondSvc");
126  }
127  }
128  }
129  return sc;
130 }

◆ sysStart()

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

Handle START transition.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_chargedFE_energy_match_muonReadHandleKey

SG::ReadDecorHandleKey<xAOD::FlowElementContainer> JetPFlowSelectionAlg::m_chargedFE_energy_match_muonReadHandleKey {this,"FlowElementContainer_ChargedFE_energy_matched_muon","JetETMissChargedParticleFlowObjects.FE_efrac_matched_muon","ReadHandleKey for the fraction of neutral FlowElements cluster energy used to match to Muons"}
private

Definition at line 69 of file JetPFlowSelectionAlg.h.

◆ m_chargedFEElectronsReadDecorKey

SG::ReadDecorHandleKey<xAOD::FlowElementContainer> JetPFlowSelectionAlg::m_chargedFEElectronsReadDecorKey {this, "ChargedFEElectronsReadDecorKey", "JetETMissChargedParticleFlowObjects.FE_ElectronLinks", "Key for links from charged FE to electrons"}
private

Definition at line 59 of file JetPFlowSelectionAlg.h.

◆ m_chargedFEMuonsReadDecorKey

SG::ReadDecorHandleKey<xAOD::FlowElementContainer> JetPFlowSelectionAlg::m_chargedFEMuonsReadDecorKey {this, "ChargedFEMuonsReadDecorKey", "JetETMissChargedParticleFlowObjects.FE_MuonLinks", "Key for links from charged FE to muons"}
private

Definition at line 60 of file JetPFlowSelectionAlg.h.

◆ m_ChargedPFlowContainerKey

SG::ReadHandleKey<xAOD::FlowElementContainer> JetPFlowSelectionAlg::m_ChargedPFlowContainerKey = {this, "ChargedPFlowInputContainer", "", "The input Charged PFlow Objects"}
private

Definition at line 51 of file JetPFlowSelectionAlg.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_electronContainerKey

SG::ReadHandleKey<xAOD::ElectronContainer> JetPFlowSelectionAlg::m_electronContainerKey = {this, "ElectronInputContainer", "", "The input electron container"}
private

Definition at line 53 of file JetPFlowSelectionAlg.h.

◆ m_electronIDToExclude

Gaudi::Property<std::string> JetPFlowSelectionAlg::m_electronIDToExclude {this,"electronIDToExclude","LHMedium","Select electron ID to exclude"}
private

Definition at line 37 of file JetPFlowSelectionAlg.h.

◆ m_electronIDToInclude

Gaudi::Property<std::string> JetPFlowSelectionAlg::m_electronIDToInclude {this,"electronIDToInclude","LHLoose","Select electron ID to include"}
private

Definition at line 38 of file JetPFlowSelectionAlg.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_excludeChargedElectronFE

Gaudi::Property<bool> JetPFlowSelectionAlg::m_excludeChargedElectronFE {this,"excludeChargedElectronFE",true,"Exclude charged FE matched to electrons"}
private

Definition at line 39 of file JetPFlowSelectionAlg.h.

◆ m_excludeChargedMuonFE

Gaudi::Property<bool> JetPFlowSelectionAlg::m_excludeChargedMuonFE {this,"excludeChargedMuonFE",true,"Exclude charged FE matched to muons"}
private

Definition at line 46 of file JetPFlowSelectionAlg.h.

◆ m_excludeNeutralElectronFE

Gaudi::Property<bool> JetPFlowSelectionAlg::m_excludeNeutralElectronFE {this,"excludeNeutralElectronFE",false,"Exclude neutral FE matched to electrons"}
private

Definition at line 41 of file JetPFlowSelectionAlg.h.

◆ m_excludeNeutralMuonFE

Gaudi::Property<bool> JetPFlowSelectionAlg::m_excludeNeutralMuonFE {this,"excludeNeutralMuonFE",false,"Exclude neutral FE matched to muons"}
private

Definition at line 48 of file JetPFlowSelectionAlg.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_includeChargedElectronFE

Gaudi::Property<bool> JetPFlowSelectionAlg::m_includeChargedElectronFE {this,"includeChargedElectronFE",false,"Include charged FE matched to electrons"}
private

Definition at line 40 of file JetPFlowSelectionAlg.h.

◆ m_includeChargedMuonFE

Gaudi::Property<bool> JetPFlowSelectionAlg::m_includeChargedMuonFE {this,"includeChargedMuonFE",false,"Include charged FE matched to muons"}
private

Definition at line 47 of file JetPFlowSelectionAlg.h.

◆ m_includeNeutralElectronFE

Gaudi::Property<bool> JetPFlowSelectionAlg::m_includeNeutralElectronFE {this,"includeNeutralElectronFE",false,"Include neutral FE matched to electrons"}
private

Definition at line 42 of file JetPFlowSelectionAlg.h.

◆ m_includeNeutralMuonFE

Gaudi::Property<bool> JetPFlowSelectionAlg::m_includeNeutralMuonFE {this,"includeNeutralMuonFE",false,"Include neutral FE matched to muons"}
private

Definition at line 49 of file JetPFlowSelectionAlg.h.

◆ m_muonIDToExclude

Gaudi::Property<std::string> JetPFlowSelectionAlg::m_muonIDToExclude {this,"muonIDToExclude","Medium","Select muon ID to exclude"}
private

Definition at line 44 of file JetPFlowSelectionAlg.h.

◆ m_muonIDToInclude

Gaudi::Property<std::string> JetPFlowSelectionAlg::m_muonIDToInclude {this,"muonIDToInclude","Loose","Select muon ID to include"}
private

Definition at line 45 of file JetPFlowSelectionAlg.h.

◆ m_neutralFEElectronsReadDecorKey

SG::ReadDecorHandleKey<xAOD::FlowElementContainer> JetPFlowSelectionAlg::m_neutralFEElectronsReadDecorKey {this, "NeutralFEElectronsReadDecorKey", "JetETMissNeutralParticleFlowObjects.FE_ElectronLinks", "Key for links from neutral FE to electrons"}
private

Definition at line 62 of file JetPFlowSelectionAlg.h.

◆ m_neutralFEMuons_efrac_match_DecorKey

SG::ReadDecorHandleKey<xAOD::FlowElementContainer> JetPFlowSelectionAlg::m_neutralFEMuons_efrac_match_DecorKey {this,"FlowElementContainer_FE_efrac_matched_muon","JetETMissNeutralParticleFlowObjects.FE_efrac_matched_muon","ReadDecorHandleKey for the fraction of neutral FlowElements cluster energy used to match to Muons"}
private

Definition at line 67 of file JetPFlowSelectionAlg.h.

◆ m_neutralFEMuonsReadDecorKey

SG::ReadDecorHandleKey<xAOD::FlowElementContainer> JetPFlowSelectionAlg::m_neutralFEMuonsReadDecorKey {this, "NeutralFEMuonsReadDecorKey","JetETMissNeutralParticleFlowObjects.FE_MuonLinks", "Key for links from neutral FE to muons"}
private

Definition at line 64 of file JetPFlowSelectionAlg.h.

◆ m_NeutralPFlowContainerKey

SG::ReadHandleKey<xAOD::FlowElementContainer> JetPFlowSelectionAlg::m_NeutralPFlowContainerKey = {this, "NeutralPFlowInputContainer", "", "The input Neutral PFlow Objects"}
private

Definition at line 52 of file JetPFlowSelectionAlg.h.

◆ m_outputChargedPFlowHandleKey

SG::WriteHandleKey<xAOD::FlowElementContainer> JetPFlowSelectionAlg::m_outputChargedPFlowHandleKey = {this, "ChargedPFlowOutputContainer", "GlobalPFlowChargedParticleFlowObjects", "The output filtered Charged PFlow Objects"}
private

Definition at line 56 of file JetPFlowSelectionAlg.h.

◆ m_outputNeutralPFlowHandleKey

SG::WriteHandleKey<xAOD::FlowElementContainer> JetPFlowSelectionAlg::m_outputNeutralPFlowHandleKey = {this, "NeutralPFlowOutputContainer", "GlobalPFlowNeutralParticleFlowObjects", "The output filtered Neutral PFlow Objects"}
private

Definition at line 57 of file JetPFlowSelectionAlg.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.


The documentation for this class was generated from the following files:
JetPFlowSelectionAlg::m_includeNeutralElectronFE
Gaudi::Property< bool > m_includeNeutralElectronFE
Definition: JetPFlowSelectionAlg.h:42
FEMuonHelper::adjustNeutralCaloEnergy
TLorentzVector adjustNeutralCaloEnergy(const std::vector< double > &clusterMuonEnergyFracs, const xAOD::FlowElement &theFE) const
Definition: FEMuonHelper.cxx:30
JetPFlowSelectionAlg::m_electronIDToInclude
Gaudi::Property< std::string > m_electronIDToInclude
Definition: JetPFlowSelectionAlg.h:38
xAOD::CaloCluster_v1::time
flt_t time() const
Access cluster time.
FEHelpers::FillNeutralFlowElements::addStandardSamplingEnergies
void addStandardSamplingEnergies(xAOD::FlowElement &theFE, const xAOD::CaloCluster &theCluster)
Definition: FEHelpers.cxx:246
JetPFlowSelectionAlg::m_chargedFE_energy_match_muonReadHandleKey
SG::ReadDecorHandleKey< xAOD::FlowElementContainer > m_chargedFE_energy_match_muonReadHandleKey
Definition: JetPFlowSelectionAlg.h:69
xAOD::EgammaHelpers::getAssociatedTopoClusters
std::vector< const xAOD::CaloCluster * > getAssociatedTopoClusters(const xAOD::CaloCluster *cluster)
Return a vector of all the topo clusters associated with the egamma cluster.
Definition: EgammaxAODHelpers.cxx:65
JetPFlowSelectionAlg::m_excludeNeutralElectronFE
Gaudi::Property< bool > m_excludeNeutralElectronFE
Definition: JetPFlowSelectionAlg.h:41
FEHelpers::FillNeutralFlowElements::addStandardMoments
void addStandardMoments(xAOD::FlowElement &theFE, const xAOD::CaloCluster &theCluster)
Definition: FEHelpers.cxx:213
JetPFlowSelectionAlg::m_chargedFEElectronsReadDecorKey
SG::ReadDecorHandleKey< xAOD::FlowElementContainer > m_chargedFEElectronsReadDecorKey
Definition: JetPFlowSelectionAlg.h:59
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:68
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
CaloCell_ID_FCS::TileExt0
@ TileExt0
Definition: FastCaloSim_CaloCell_ID.h:37
xAOD::FlowElement_v1::setSignalType
void setSignalType(signal_t t)
AthCommonDataStore::renounce
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)
Definition: AthCommonDataStore.h:380
JetPFlowSelectionAlg::m_electronContainerKey
SG::ReadHandleKey< xAOD::ElectronContainer > m_electronContainerKey
Definition: JetPFlowSelectionAlg.h:53
JetPFlowSelectionAlg::m_outputNeutralPFlowHandleKey
SG::WriteHandleKey< xAOD::FlowElementContainer > m_outputNeutralPFlowHandleKey
Definition: JetPFlowSelectionAlg.h:57
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:157
JetPFlowSelectionAlg::m_ChargedPFlowContainerKey
SG::ReadHandleKey< xAOD::FlowElementContainer > m_ChargedPFlowContainerKey
Definition: JetPFlowSelectionAlg.h:51
xAOD::FlowElement_v1::phi
virtual double phi() const override
The azimuthal angle ( ) of the particle.
xAOD::FlowElement_v1::pt
virtual double pt() const override
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
xAOD::FlowElement_v1::setOtherObjectLinks
void setOtherObjectLinks(const std::vector< ElementLink< IParticleContainer >> &elV)
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
JetPFlowSelectionAlg::m_chargedFEMuonsReadDecorKey
SG::ReadDecorHandleKey< xAOD::FlowElementContainer > m_chargedFEMuonsReadDecorKey
Definition: JetPFlowSelectionAlg.h:60
JetPFlowSelectionAlg::m_outputChargedPFlowHandleKey
SG::WriteHandleKey< xAOD::FlowElementContainer > m_outputChargedPFlowHandleKey
Definition: JetPFlowSelectionAlg.h:56
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
xAOD::FlowElement_v1::setCharge
void setCharge(float c)
JetPFlowSelectionAlg::m_NeutralPFlowContainerKey
SG::ReadHandleKey< xAOD::FlowElementContainer > m_NeutralPFlowContainerKey
Definition: JetPFlowSelectionAlg.h:52
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
FEHelpers::FillNeutralFlowElements
Definition: Event/xAOD/xAODPFlow/xAODPFlow/FEHelpers.h:27
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:274
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
AthCommonReentrantAlgorithm::extraOutputDeps
virtual const DataObjIDColl & extraOutputDeps() const override
Return the list of extra output dependencies.
Definition: AthCommonReentrantAlgorithm.cxx:89
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:62
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
JetPFlowSelectionAlg::m_excludeChargedElectronFE
Gaudi::Property< bool > m_excludeChargedElectronFE
Definition: JetPFlowSelectionAlg.h:39
SG::ReadDecorHandle
Handle class for reading a decoration on an object.
Definition: StoreGate/StoreGate/ReadDecorHandle.h:94
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
JetPFlowSelectionAlg::m_excludeNeutralMuonFE
Gaudi::Property< bool > m_excludeNeutralMuonFE
Definition: JetPFlowSelectionAlg.h:48
JetPFlowSelectionAlg::m_electronIDToExclude
Gaudi::Property< std::string > m_electronIDToExclude
Definition: JetPFlowSelectionAlg.h:37
CaloCell_ID_FCS::TileBar0
@ TileBar0
Definition: FastCaloSim_CaloCell_ID.h:31
beamspotman.n
n
Definition: beamspotman.py:729
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
xAOD::FlowElement
FlowElement_v1 FlowElement
Definition of the current "pfo version".
Definition: FlowElement.h:16
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
SG::AuxElement::index
size_t index() const
Return the index of this element within its container.
FEMuonHelper
Definition: Reconstruction/PFlow/PFlowUtils/PFlowUtils/FEMuonHelper.h:8
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
JetPFlowSelectionAlg::m_neutralFEMuonsReadDecorKey
SG::ReadDecorHandleKey< xAOD::FlowElementContainer > m_neutralFEMuonsReadDecorKey
Definition: JetPFlowSelectionAlg.h:64
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
JetPFlowSelectionAlg::m_excludeChargedMuonFE
Gaudi::Property< bool > m_excludeChargedMuonFE
Definition: JetPFlowSelectionAlg.h:46
FEElectronHelper::checkElectronLinks
bool checkElectronLinks(const std::vector< ElementLink< xAOD::ElectronContainer > > &FE_ElectronLinks, const std::string &qualityString) const
Definition: FEElectronHelper.cxx:5
JetPFlowSelectionAlg::m_neutralFEMuons_efrac_match_DecorKey
SG::ReadDecorHandleKey< xAOD::FlowElementContainer > m_neutralFEMuons_efrac_match_DecorKey
Definition: JetPFlowSelectionAlg.h:67
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
JetPFlowSelectionAlg::m_includeNeutralMuonFE
Gaudi::Property< bool > m_includeNeutralMuonFE
Definition: JetPFlowSelectionAlg.h:49
xAOD::FlowElement_v1::e
virtual double e() const override
The total energy of the particle.
Definition: FlowElement_v1.cxx:25
JetPFlowSelectionAlg::m_neutralFEElectronsReadDecorKey
SG::ReadDecorHandleKey< xAOD::FlowElementContainer > m_neutralFEElectronsReadDecorKey
Definition: JetPFlowSelectionAlg.h:62
JetPFlowSelectionAlg::m_muonIDToInclude
Gaudi::Property< std::string > m_muonIDToInclude
Definition: JetPFlowSelectionAlg.h:45
EL::AnaReentrantAlgorithm
the base class for EventLoop reentrant algorithms
Definition: AnaReentrantAlgorithm.h:51
JetPFlowSelectionAlg::m_includeChargedElectronFE
Gaudi::Property< bool > m_includeChargedElectronFE
Definition: JetPFlowSelectionAlg.h:40
xAOD::FlowElement_v1::eta
virtual double eta() const override
The pseudorapidity ( ) of the particle.
xAOD::CaloCluster_v1::eSample
float eSample(const CaloSample sampling) const
Definition: CaloCluster_v1.cxx:514
a
TList * a
Definition: liststreamerinfos.cxx:10
FEElectronHelper
Definition: FEElectronHelper.h:7
h
FEMuonHelper::checkMuonLinks
bool checkMuonLinks(const std::vector< ElementLink< xAOD::MuonContainer > > &FE_MuonLinks, const std::string &qualityString) const
Verify if at least one combined muon in a list passes the relevant quality criteria Details of muon w...
Definition: FEMuonHelper.cxx:5
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
xAOD::IParticle::eta
virtual double eta() const =0
The pseudorapidity ( ) of the particle.
JetPFlowSelectionAlg::m_muonIDToExclude
Gaudi::Property< std::string > m_muonIDToExclude
Definition: JetPFlowSelectionAlg.h:44
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
xAOD::FlowElement_v1::setP4
void setP4(float pt, float eta, float phi, float m)
Definition: FlowElement_v1.cxx:39
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
xAOD::IParticle::phi
virtual double phi() const =0
The azimuthal angle ( ) of the particle.
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
JetPFlowSelectionAlg::m_includeChargedMuonFE
Gaudi::Property< bool > m_includeChargedMuonFE
Definition: JetPFlowSelectionAlg.h:47
xAOD::IParticle::e
virtual double e() const =0
The total energy of the particle.
fitman.k
k
Definition: fitman.py:528
xAOD::IParticle::m
virtual double m() const =0
The invariant mass of the particle.
ServiceHandle< ICondSvc >
xAOD::FlowElement_v1
A detector object made of other lower level object(s)
Definition: FlowElement_v1.h:25