ATLAS Offline Software
ParticleSelectionAlg.cxx
Go to the documentation of this file.
1 
3 /*
4  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
5 */
6 
7 // ParticleSelectionAlg.cxx
8 // Implementation file for class ParticleSelectionAlg
9 // Author: Karsten Koeneke <karsten.koeneke@cern.ch>
11 
12 // EventUtils includes
13 #include "ParticleSelectionAlg.h"
14 
15 // FrameWork includes
16 #include "Gaudi/Property.h"
18 
19 // EDM includes
22 #include "xAODBase/IParticle.h"
28 #include "xAODMuon/MuonContainer.h"
32 #include "xAODJet/JetContainer.h"
34 #include "xAODPFlow/PFOContainer.h"
51 
53 // Public methods:
55 
56 // Constructors
59  ISvcLocator* pSvcLocator ) :
61 {
62  m_cutBKCName = name; // cppcheck-suppress useInitializationList; deprecated Property constructor
63 }
64 
65 
66 
67 // Destructor
70 {}
71 
72 
73 
74 // Athena Algorithm's Hooks
77 {
78  ATH_MSG_DEBUG ("Initializing " << name() << "...");
79 
80  // Print out the used configuration
81  ATH_MSG_DEBUG ( " using EventInfo = " << m_evtInfoName );
82  ATH_MSG_DEBUG ( " using InputContainer = " << m_inCollKey );
83  ATH_MSG_DEBUG ( " using OutputContainer = " << m_outCollKey );
84  ATH_MSG_DEBUG ( " using WriteSplitOutputContainer = " << m_writeSplitAux );
85  ATH_MSG_DEBUG ( " using OutputContainerOwnershipPolicy = " << m_outOwnPolicyName );
86  ATH_MSG_DEBUG ( " using SelectionToolList = " << m_selTools );
87  ATH_MSG_DEBUG ( " using Selection = " << m_selection );
88  ATH_MSG_DEBUG ( " using DoCutBookkeeping = " << m_doCutFlow );
89  ATH_MSG_DEBUG ( " using CutBookkeeperContainer = " << m_cutBKCName );
90 
91 
92  // initialize proxy loaders for expression parsing
93  if ( !(m_selection.value().empty()) ){
95  }
96 
97  // initialize the counters
99 
100  // Determine the ownership policy of the output container
101  if ( m_outOwnPolicyName.value() == "OWN_ELEMENTS" ) {
103  }
104  else if ( m_outOwnPolicyName.value() == "VIEW_ELEMENTS" ) {
106  }
107  else {
108  ATH_MSG_ERROR("Unrecognized ownership policy for the output container: " << m_outOwnPolicyName );
109  return StatusCode::FAILURE;
110  }
111 
112  // Retrieve all tools
113  ATH_CHECK( m_selTools.retrieve() );
114 
115  ATH_MSG_DEBUG ( "==> done with initialize " << name() << "..." );
116  return StatusCode::SUCCESS;
117 }
118 
119 
120 
122 {
123  ATH_MSG_DEBUG ("Finalizing " << name() << "...");
124 
125  // Release all tools and services
126  ATH_CHECK( m_selTools.release() );
127 
129 
130  return StatusCode::SUCCESS;
131 }
132 
133 
134 
136 {
137  ATH_MSG_DEBUG ("start " << name() << "...");
138 
139  // Nothing to be done here, if cut-flow bookkeeping was not requested
140  if (!m_doCutFlow){ return StatusCode::SUCCESS; }
141 
142  // Get some properties from the input meta data
143  std::string inputStreamName = "Stream";
145  std::vector<std::string> streamNameList;
146  inputMetaStore()->keys(clid, streamNameList);
147  if ( streamNameList.size() >=1 ){ inputStreamName = streamNameList[0]; }
148  // Get the processing cycle number that we need to set for us
149  int maxInputCycle = -1;
150  if ( inputMetaStore()->contains<xAOD::CutBookkeeperContainer>(m_cutBKCName.value()) ){
151  xAOD::CutBookkeeperContainer* inCutBKCont = nullptr;
152  ATH_CHECK( inputMetaStore()->retrieve(inCutBKCont, m_cutBKCName.value() ) );
153  if (inCutBKCont){
154  maxInputCycle = inCutBKCont->maxCycle();
155  }
156  }
157  if (maxInputCycle<0){ maxInputCycle = 0; }
158  else { maxInputCycle += 1; }
159 
160  // Check if we already have a container in the output meta-data store
161  xAOD::CutBookkeeperContainer* cutBKCont = nullptr;
162  if ( outputMetaStore()->contains<xAOD::CutBookkeeperContainer>(m_cutBKCName.value()) ){
163  ATH_CHECK( inputMetaStore()->retrieve(cutBKCont, m_cutBKCName.value() ) );
164  // Set the index where we will start having our CutBookkeepers in this container
165  m_cutBKStartIdx = cutBKCont->size();
166  }
167  else {
168  // Create and register the container that will hold the cut-flow information
169  cutBKCont = new xAOD::CutBookkeeperContainer();
170  // Take care of the peculiarities of the new xAOD EDM, i.e., create the needed AuxStore
172  cutBKCont->setStore( cutBKAuxCont ); //gives it a new associated aux container
173  ATH_CHECK( outputMetaStore()->record( cutBKCont, m_cutBKCName.value() ) );
174  ATH_CHECK( outputMetaStore()->record( cutBKAuxCont, m_cutBKCName.value()+"Aux." ) );
175  ATH_MSG_VERBOSE( "Recorded xAOD::CutBookkeeperContainer " << m_cutBKCName.value() << "Aux." );
176  }
177 
178  //------------- for the AsgSelectionTools --------------
179  // Now, register one CutBookkeeper per cut that will be applied.
180  // For each of the registered tools, get the TAccept and ask it for all known cuts.
181  for ( std::size_t toolIdx=0; toolIdx < m_selTools.size(); ++toolIdx ){
182  const ToolHandle<IAsgSelectionTool>& tool = m_selTools[toolIdx];
183  // Fill the index bookkeeping at what index in the CutBookkeeperContainer
184  // the CutBookkeepers for this tool start.
185  m_selToolIdxOffset.push_back( cutBKCont->size() );
186  // Get some needed quantities
187  const std::string toolName = tool->name();
188  const asg::AcceptInfo& acceptInfo = tool->getAcceptInfo();
189  const unsigned int nCuts = acceptInfo.getNCuts();
190  for ( unsigned int iCut=0; iCut<nCuts; ++iCut ){
191  // Get the name and description of this cut
192  const std::string cutName = acceptInfo.getCutName(iCut);
193  const std::string cutDescr = acceptInfo.getCutDescription(iCut);
194  // Create a new xAOD::CutBookkeeper and add it to the container
196  cutBKCont->push_back(cutBK);
197  // Now, set its properties
198  cutBK->setName(toolName+"_"+cutName);
199  cutBK->setDescription(cutDescr);
200  cutBK->setCutLogic(xAOD::CutBookkeeper::CutLogic::REQUIRE); // Each cut must be passed, thus REQUIRE, i.e, logical AND
201  cutBK->setInputStream(inputStreamName);
202  cutBK->setCycle(maxInputCycle);
203  }
204  }
205 
206  //------------- for the ExpressionParsing in this algorithm --------------
207  if ( !(m_selection.value().empty()) ){
208  // Create a new xAOD::CutBookkeeper and add it to the container
210  cutBKCont->push_back(cutBK);
211  // Now, set its properties
212  cutBK->setName(this->name());
213  cutBK->setDescription(m_selection.value());
214  cutBK->setCutLogic(xAOD::CutBookkeeper::CutLogic::REQUIRE); // Each cut must be passed, thus REQUIRE, i.e, logical AND
215  cutBK->setInputStream(inputStreamName);
216  cutBK->setCycle(maxInputCycle);
217  m_idxSelParster = cutBK->index();
218  }
219 
220  return StatusCode::SUCCESS;
221 }
222 
223 
224 
225 
227 {
228  // Increase the event counter
230  // Simple status message at the beginning of each event execute,
231  ATH_MSG_DEBUG ( "==> execute " << name() << " on " << m_nEventsProcessed << ". event..." );
232 
233 
234  // Figure out what type the input container has, if we didn't do it yet
235  if ( m_contType == UNKNOWN ){
236  if ( evtStore()->contains<xAOD::PhotonContainer>(m_inCollKey.value()) ){ m_contType = PHOTON; }
237  else if ( evtStore()->contains<xAOD::ElectronContainer>(m_inCollKey.value()) ){ m_contType = ELECTRON; }
238  else if ( evtStore()->contains<xAOD::MuonContainer>(m_inCollKey.value()) ){ m_contType = MUON; }
239  else if ( evtStore()->contains<xAOD::TauJetContainer>(m_inCollKey.value()) ){ m_contType = TAU; }
240  else if ( evtStore()->contains<xAOD::JetContainer>(m_inCollKey.value()) ){ m_contType = JET; }
241  else if ( evtStore()->contains<xAOD::TruthParticleContainer>(m_inCollKey.value()) ){ m_contType = TRUTHPARTICLE; }
242  else if ( evtStore()->contains<xAOD::CompositeParticleContainer>(m_inCollKey.value()) ){ m_contType = COMPOSITEPARTICLE; }
243  else if ( evtStore()->contains<xAOD::PFOContainer>(m_inCollKey.value()) ){ m_contType = PARITCLEFLOW; }
244  else if ( evtStore()->contains<xAOD::NeutralParticleContainer>(m_inCollKey.value()) ){ m_contType = NEUTRALPARTICLE; }
245  else if ( evtStore()->contains<xAOD::TrackParticleContainer>(m_inCollKey.value()) ){ m_contType = TRACKPARTICLE; }
246  else if ( evtStore()->contains<xAOD::ParticleContainer>(m_inCollKey.value()) ){ m_contType = PARTICLE; }
247  else if ( evtStore()->contains<xAOD::CaloClusterContainer>(m_inCollKey.value()) ){ m_contType = CALOCLUSTER; }
248  }
249  if ( m_contType == UNKNOWN ){
250  ATH_MSG_FATAL("We couldn't determine the type of the container... abort!");
251  return StatusCode::FAILURE;
252  }
253 
254  // Get the input container and create the output containers
255  const xAOD::IParticleContainer* inContainer = nullptr;
256  ATH_CHECK( evtStore()->retrieve( inContainer, m_inCollKey.value() ) );
257  ATH_MSG_DEBUG ( "Input collection = " << m_inCollKey.value()
258  << " retrieved from StoreGate which has " << inContainer->size() << " entries." );
259 
260  // --------------------------------------------------------------------------
261  // Do the expression parsing once per event already here
262  // --------------------------------------------------------------------------
263  std::vector<int> resultVec;
264  resultVec.reserve(inContainer->size());
265  if ( !(m_selection.value().empty()) ){
266  resultVec = m_parser->evaluateAsVector();
267  // Check that the lengths of the input container and the result vector are the same
268  if ( inContainer->size() != resultVec.size() ) {
269  ATH_MSG_ERROR("We got an input container, but its size (" << inContainer->size()
270  << ") doesn't match the size of the result vector: " << resultVec.size() );
271  return StatusCode::FAILURE;
272  }
273  ATH_MSG_VERBOSE("Have a container of size " << inContainer->size()
274  << " and a result vector of size " << resultVec.size() );
275  } // End: If expression parsing was requested in the first place
276 
277 
278  // --------------------------------------------------------------------------
279  // Do the heavy lifting of actually creating the new and reduced output container(s)
280  // --------------------------------------------------------------------------
281  if ( m_contType == PHOTON ){
282  ATH_CHECK( (this->selectParticles<xAOD::PhotonContainer,xAOD::PhotonAuxContainer>(inContainer,resultVec)) );
283  }
284  else if ( m_contType == ELECTRON ){
285  ATH_CHECK( (this->selectParticles<xAOD::ElectronContainer,xAOD::ElectronAuxContainer>(inContainer,resultVec)) );
286  }
287  else if ( m_contType == MUON ){
288  ATH_CHECK( (this->selectParticles<xAOD::MuonContainer,xAOD::MuonAuxContainer>(inContainer,resultVec)) );
289  }
290  else if ( m_contType == TAU ){
291  ATH_CHECK( (this->selectParticles<xAOD::TauJetContainer,xAOD::TauJetAuxContainer>(inContainer,resultVec)) );
292  }
293  else if ( m_contType == JET ){
294  ATH_CHECK( (this->selectParticles<xAOD::JetContainer,xAOD::JetAuxContainer>(inContainer,resultVec)) );
295  }
296  else if ( m_contType == TRUTHPARTICLE ){
297  ATH_CHECK( (this->selectParticles<xAOD::TruthParticleContainer,xAOD::TruthParticleAuxContainer>(inContainer,resultVec)) );
298  }
299  else if ( m_contType == COMPOSITEPARTICLE ){
300  ATH_CHECK( (this->selectParticles<xAOD::CompositeParticleContainer,xAOD::CompositeParticleAuxContainer>(inContainer,resultVec)) );
301  }
302  else if ( m_contType == PARITCLEFLOW ){
303  ATH_CHECK( (this->selectParticles<xAOD::PFOContainer,xAOD::PFOAuxContainer>(inContainer,resultVec)) );
304  }
305  else if ( m_contType == NEUTRALPARTICLE ){
306  ATH_CHECK( (this->selectParticles<xAOD::NeutralParticleContainer,xAOD::NeutralParticleAuxContainer>(inContainer,resultVec)) );
307  }
308  else if ( m_contType == TRACKPARTICLE ){
309  ATH_CHECK( (this->selectParticles<xAOD::TrackParticleContainer,xAOD::TrackParticleAuxContainer>(inContainer,resultVec)) );
310  }
311  else if ( m_contType == PARTICLE ){
312  ATH_CHECK( (this->selectParticles<xAOD::ParticleContainer,xAOD::ParticleAuxContainer>(inContainer,resultVec)) );
313  }
314  else if ( m_contType == CALOCLUSTER ){
315  ATH_CHECK( (this->selectParticles<xAOD::CaloClusterContainer,xAOD::CaloClusterAuxContainer>(inContainer,resultVec)) );
316  }
317 
318  return StatusCode::SUCCESS;
319 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
ParticleSelectionAlg::m_outOwnPolicyName
Gaudi::Property< std::string > m_outOwnPolicyName
Defines the ownership policy of the output container.
Definition: ParticleSelectionAlg.h:87
ExpressionParserUserBase< ::AthAnalysisAlgorithm, 1 >::finalizeParser
StatusCode finalizeParser()
xAOD::CutBookkeeperContainer
CutBookkeeperContainer_v1 CutBookkeeperContainer
Define the latest version of the CutBookkeeperContainer class.
Definition: CutBookkeeperContainer.h:18
ParticleSelectionAlg::TAU
@ TAU
Definition: ParticleSelectionAlg.h:118
CutBookkeeper.h
xAOD::CutBookkeeperAuxContainer_v1
Auxiliary container for CutBookkeeper containers.
Definition: CutBookkeeperAuxContainer_v1.h:34
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
ParticleSelectionAlg::JET
@ JET
Definition: ParticleSelectionAlg.h:119
AthAnalysisAlgorithm
Definition: AthAnalysisAlgorithm.h:34
AthAnalysisAlgorithm::outputMetaStore
const ServiceHandle< StoreGateSvc > & outputMetaStore() const
Const accessor for the output metadata store.
Definition: AthAnalysisAlgorithm.h:53
xAOD::CutBookkeeper_v1::setCycle
void setCycle(int cycle)
Set the skimming cycle that this CutBookkeeper is running in.
Definition: CutBookkeeper_v1.cxx:209
xAOD::CutBookkeeper_v1::setName
void setName(const std::string &name)
Set the name of this CutBookkeeper.
Definition: CutBookkeeper_v1.cxx:161
IParticle.h
ParticleSelectionAlg::m_selToolIdxOffset
std::vector< std::size_t > m_selToolIdxOffset
The list of pairs of the tool index of the AsgSelectionTools and the starting index of the correspond...
Definition: ParticleSelectionAlg.h:137
xAOD::CutBookkeeper_v1::setDescription
void setDescription(const std::string &description)
Set the description of this CutBookkeeper.
Definition: CutBookkeeper_v1.cxx:177
ParticleSelectionAlg::m_writeSplitAux
Gaudi::Property< bool > m_writeSplitAux
Decide if we want to write a fully-split AuxContainer such that we can remove any variables.
Definition: ParticleSelectionAlg.h:84
ParticleSelectionAlg::ParticleSelectionAlg
ParticleSelectionAlg(const std::string &name, ISvcLocator *pSvcLocator)
Constructor with parameters:
Definition: ParticleSelectionAlg.cxx:58
ParticleSelectionAlg::ELECTRON
@ ELECTRON
Definition: ParticleSelectionAlg.h:116
SG::VIEW_ELEMENTS
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
Definition: OwnershipPolicy.h:18
ParticleSelectionAlg::m_nEventsProcessed
unsigned long m_nEventsProcessed
Internal event counter.
Definition: ParticleSelectionAlg.h:107
IAugmentationTool.h
xAOD::CutBookkeeper_v1
Description of the class that is used to keep track of event counts.
Definition: CutBookkeeper_v1.h:29
ExpressionParserUserBase< ::AthAnalysisAlgorithm, 1 >::m_parser
std::conditional< NUM_PARSER==1, std::unique_ptr< ExpressionParsing::ExpressionParser >, std::array< std::unique_ptr< ExpressionParsing::ExpressionParser >, NUM_PARSER > >::type m_parser
Definition: ExpressionParserUser.h:100
ParticleSelectionAlg::m_contType
contType_t m_contType
The variable that holds the value that we find for the input container.
Definition: ParticleSelectionAlg.h:130
ParticleSelectionAlg::m_selection
Gaudi::Property< std::string > m_selection
The selection string that will select which xAOD::IParticles to keep from an xAOD::IParticleContainer...
Definition: ParticleSelectionAlg.h:91
TruthParticleContainer.h
ParticleSelectionAlg::m_evtInfoName
Gaudi::Property< std::string > m_evtInfoName
Name of the EventInfo object.
Definition: ParticleSelectionAlg.h:75
AuxContainerBase.h
PFOContainer.h
ParticleSelectionAlg::UNKNOWN
@ UNKNOWN
Definition: ParticleSelectionAlg.h:114
ParticleSelectionAlg::m_cutBKCName
Gaudi::Property< std::string > m_cutBKCName
The name of the resulting xAOD::CutBookkeeperContainer.
Definition: ParticleSelectionAlg.h:99
ParticleSelectionAlg::m_selTools
ToolHandleArray< IAsgSelectionTool > m_selTools
The list of IAsgSelectionTools.
Definition: ParticleSelectionAlg.h:72
CutBookkeeperAuxContainer.h
AthAnalysisAlgorithm::inputMetaStore
const ServiceHandle< StoreGateSvc > & inputMetaStore() const
Const accessor for the input metadata store.
Definition: AthAnalysisAlgorithm.h:49
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
ParticleSelectionAlg::TRACKPARTICLE
@ TRACKPARTICLE
Definition: ParticleSelectionAlg.h:122
CaloClusterAuxContainer.h
CompositeParticleContainer.h
NeutralParticleAuxContainer.h
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
ParticleSelectionAlg::execute
virtual StatusCode execute() override
Athena algorithm's execute hook.
Definition: ParticleSelectionAlg.cxx:226
EventStreamInfo.h
This file contains the class definition for the EventStreamInfo class.
asg::AcceptInfo::getCutName
const std::string & getCutName(unsigned int cutPosition) const
Get the name of a cut, based on the cut position (slow, avoid usage)
Definition: AcceptInfo.cxx:36
TauJetAuxContainer.h
ParticleAuxContainer.h
TruthParticleAuxContainer.h
MuonAuxContainer.h
ParticleSelectionAlg::CALOCLUSTER
@ CALOCLUSTER
Definition: ParticleSelectionAlg.h:126
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
ParticleSelectionAlg::TRUTHPARTICLE
@ TRUTHPARTICLE
Definition: ParticleSelectionAlg.h:123
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
PFOAuxContainer.h
asg::AcceptInfo
Definition: AcceptInfo.h:28
TrackParticleAuxContainer.h
ElectronContainer.h
ParticleSelectionAlg::PARITCLEFLOW
@ PARITCLEFLOW
Definition: ParticleSelectionAlg.h:120
SG::OWN_ELEMENTS
@ OWN_ELEMENTS
this data object owns its elements
Definition: OwnershipPolicy.h:17
ElectronAuxContainer.h
ParticleContainer.h
ParticleSelectionAlg::m_outOwnPolicy
SG::OwnershipPolicy m_outOwnPolicy
The internally used translation for the ownership policy.
Definition: ParticleSelectionAlg.h:110
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
asg::AcceptInfo::getNCuts
unsigned int getNCuts() const
Get the number of cuts defined.
Definition: AcceptInfo.h:46
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
IParticleContainer.h
xAOD::CutBookkeeperContainer_v1::maxCycle
int maxCycle() const
Get the maximum cycle number of any xAOD::CutBookkeepers in the container.
Definition: CutBookkeeperContainer_v1.cxx:200
ParticleSelectionAlg.h
ParticleSelectionAlg::m_outCollKey
Gaudi::Property< std::string > m_outCollKey
Output collection name (deep copies of the original ones)
Definition: ParticleSelectionAlg.h:81
xAOD::CutBookkeeperAuxContainer
CutBookkeeperAuxContainer_v1 CutBookkeeperAuxContainer
Define the latest version of the CutBookkeeperAuxContainer class.
Definition: CutBookkeeperAuxContainer.h:17
CutBookkeeperContainer.h
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ParticleSelectionAlg::COMPOSITEPARTICLE
@ COMPOSITEPARTICLE
Definition: ParticleSelectionAlg.h:124
ParticleSelectionAlg::m_inCollKey
Gaudi::Property< std::string > m_inCollKey
Input container name.
Definition: ParticleSelectionAlg.h:78
xAOD::CutBookkeeperContainer_v1
Container that holds the Container of all CutBookkeepers.
Definition: CutBookkeeperContainer_v1.h:27
TauJetContainer.h
SG::AuxElement::index
size_t index() const
Return the index of this element within its container.
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
ParticleSelectionAlg::m_doCutFlow
Gaudi::Property< bool > m_doCutFlow
If true (default: false), do the bookkeeping of how many particles passed which selection cuts.
Definition: ParticleSelectionAlg.h:95
ExpressionParserUser<::AthAnalysisAlgorithm >::initializeParser
StatusCode initializeParser(const ExpressionParsing::SelectionArg< 1 > &selection_string)
CompositeParticleAuxContainer.h
ExpressionParserUser
Definition: ExpressionParserUser.h:107
xAOD::CutBookkeeper_v1::setInputStream
void setInputStream(const std::string &inputstream)
Set the name of the current input-file stream object for this CutBookkeeper.
Definition: CutBookkeeper_v1.cxx:225
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ParticleSelectionAlg::NEUTRALPARTICLE
@ NEUTRALPARTICLE
Definition: ParticleSelectionAlg.h:121
xAOD::CutBookkeeper
CutBookkeeper_v1 CutBookkeeper
Define the latest version of the CutBookkeeper class.
Definition: CutBookkeeper.h:17
ParticleSelectionAlg::PHOTON
@ PHOTON
Definition: ParticleSelectionAlg.h:115
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:452
ParticleSelectionAlg::start
virtual StatusCode start() override
Athena algorithm's beginRun hook (called once before running over the events, after initialize)
Definition: ParticleSelectionAlg.cxx:135
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
xAOD::CutBookkeeper_v1::setCutLogic
void setCutLogic(CutLogic logic)
Set the cut logic of this CutBookkeeper, e.g., ACCEPT, REQUIRE, VETO.
Definition: CutBookkeeper_v1.cxx:199
MuonContainer.h
NeutralParticleContainer.h
PhotonAuxContainer.h
ParticleSelectionAlg::~ParticleSelectionAlg
virtual ~ParticleSelectionAlg()
Destructor:
Definition: ParticleSelectionAlg.cxx:69
ParticleSelectionAlg::MUON
@ MUON
Definition: ParticleSelectionAlg.h:117
JetContainer.h
ParticleSelectionAlg::initialize
virtual StatusCode initialize() override
Athena algorithm's initalize hook.
Definition: ParticleSelectionAlg.cxx:76
ParticleSelectionAlg::PARTICLE
@ PARTICLE
Definition: ParticleSelectionAlg.h:125
CaloClusterContainer.h
JetAuxContainer.h
ParticleSelectionAlg::m_idxSelParster
std::size_t m_idxSelParster
Store the index of the CutBookKeeper in the CutBookkeeperContainer for the selection using the Expres...
Definition: ParticleSelectionAlg.h:141
ClassID_traits::ID
static CLID ID()
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:44
ParticleSelectionAlg::finalize
virtual StatusCode finalize() override
Athena algorithm's finalize hook.
Definition: ParticleSelectionAlg.cxx:121
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
PhotonContainer.h
ParticleSelectionAlg::m_cutBKStartIdx
std::size_t m_cutBKStartIdx
The starting index of where in the CutBookkeeperContainer our new CutBookkeepers start.
Definition: ParticleSelectionAlg.h:133
TrackParticleContainer.h
asg::AcceptInfo::getCutDescription
const std::string & getCutDescription(const std::string &cutName) const
Get the description of a cut, based on the cut name.
Definition: AcceptInfo.cxx:119