ATLAS Offline Software
WriteThinnedData.cxx
Go to the documentation of this file.
1 
3 /*
4  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
5 */
6 
7 // WriteThinnedData.cxx
8 // Implementation file for class WriteThinnedData
9 // Author: S.Binet<binet@cern.ch>
11 
12 
13 // STL includes
14 #include <vector>
15 #include <sstream>
16 
17 // FrameWork includes
18 #include "Gaudi/Property.h"
19 #include "GaudiKernel/SystemOfUnits.h"
20 
21 // StoreGate
22 #include "StoreGate/StoreGateSvc.h"
23 #include "StoreGate/ReadHandle.h"
24 #include "StoreGate/ThinningHandle.h"
25 
26 // DataModel includes
27 #include "AthContainers/DataVector.h"
28 #include "AthContainers/ThinningDecision.h"
29 
30 // AthExThinning includes
31 #include "AthExThinning/AthExParticles.h"
32 #include "AthExThinning/AthExDecay.h"
33 #include "AthExThinning/AthExElephantino.h"
34 #include "AthExThinning/WriteThinnedData.h"
35 
36 
37 using namespace AthExThinning;
38 
39 // Constructors
41 WriteThinnedData::WriteThinnedData( const std::string& name,
42  ISvcLocator* pSvcLocator ) :
43  ::AthAlgorithm( name, pSvcLocator )
44 {
45  //
46  // Property declaration
47  //
48  //declareProperty( "Property", m_nProperty );
49 
50  declareProperty( "Particles",
51  m_particlesName = "Particles",
52  "Input location of particles (to be thinned)" );
53 
54  declareProperty( "Filter",
55  m_filter,
56  "Filter to apply on Particles (true == keep element)" );
57  std::vector<bool> filter( 10, false );
58  m_filter.set( filter );
59 
60 }
61 
62 // Destructor
64 WriteThinnedData::~WriteThinnedData()
65 {}
66 
67 // Athena Algorithm's Hooks
69 StatusCode WriteThinnedData::initialize()
70 {
71  ATH_MSG_INFO("Initializing " << name() << "...");
72 
73  for (int i = 0; i < 3; i++) {
74  std::ostringstream ss;
75  ss << "_test" << (i+1);
76  m_elephantinoKeys.emplace_back (m_elephantinoName.value() + ss.str());
77  m_decayKeys.emplace_back (m_decayName.value() + ss.str());
78  m_iparticlesKeys.emplace_back (m_particlesName.value() + ss.str());
79  }
80  ATH_CHECK( m_elephantinoKeys.initialize() );
81  ATH_CHECK( m_decayKeys.initialize() );
82  ATH_CHECK( m_iparticlesKeys.initialize() );
83 
84  m_particlesKey1 = m_particlesName.value() + "_test1";
85  m_particlesKey2 = m_particlesName.value() + "_test2";
86  ATH_CHECK( m_particlesKey1.initialize ("StreamUSR_0") );
87  ATH_CHECK( m_particlesKey2.initialize ("StreamUSR_0") );
88 
89  m_iparticlesKey3 = m_particlesName.value() + "_test3";
90  ATH_CHECK( m_iparticlesKey3.initialize ("StreamUSR_0") );
91 
92  return StatusCode::SUCCESS;
93 }
94 
95 StatusCode WriteThinnedData::finalize()
96 {
97  ATH_MSG_INFO("Finalizing " << name() << "...");
98  return StatusCode::SUCCESS;
99 }
100 
101 StatusCode WriteThinnedData::execute()
102 {
103  const EventContext& ctx = Gaudi::Hive::currentContext();
104  ATH_MSG_DEBUG("Executing " << name() << "...");
105 
106  bool allGood = true;
107  if ( !test( ctx, 0, "test1" ).isSuccess() ) {
108  ATH_MSG_WARNING("Could not perform 'thinning test1' !!");
109  allGood = false;
110  }
111 
112  if ( !test( ctx, 1, "test2" ).isSuccess() ) {
113  ATH_MSG_WARNING("Could not perform 'thinning test2' !!");
114  allGood = false;
115  }
116 
117  if ( !test( ctx, 2, "test3" ).isSuccess() ) {
118  ATH_MSG_WARNING("Could not perform 'thinning test3' !!");
119  allGood = false;
120  }
121 
122  return allGood ? StatusCode::SUCCESS : StatusCode::FAILURE;
123 }
124 
125 StatusCode WriteThinnedData::test( const EventContext& ctx,
126  int testNum, const std::string& testName )
127 {
128  const std::string& test = testName;
129  ATH_MSG_INFO("Performing thinning test [" << test << "]...");
130 
131  // fetch Particles
132  const std::string particlesName = m_particlesName.value() + "_" + test;
133  const AthExParticles * particles = 0;
134  if ( !evtStore()->retrieve(particles, particlesName).isSuccess() ||
135  0 == particles ) {
136  ATH_MSG_WARNING
137  ("Could not fetch particles at [" << particlesName << "] !!");
138  return StatusCode::RECOVERABLE;
139  }
140 
141  // fetch IParticles
142  SG::ReadHandle<AthExIParticles> iparticles (m_iparticlesKeys[testNum], ctx);
143 
144  if ( iparticles->size() != particles->size() ||
145  iparticles->at(0)->px() != particles->at(0)->px() ) {
146  ATH_MSG_WARNING
147  ("symlinked containers are corrupted: " << endmsg
148  << " #iparticles: " << iparticles->size() << endmsg
149  << " # particles: " << particles->size() << endmsg
150  << " ipx[0] = " << iparticles->at(0)->px() << endmsg
151  << " px[0] = " << particles->at(0)->px());
152  return StatusCode::RECOVERABLE;
153  }
154 
155  // fetch Decay
156  SG::ReadHandle<AthExDecay> decay (m_decayKeys[testNum], ctx);
157 
158  // fetch Elephantino
159  SG::ReadHandle<AthExElephantino> elephantino (m_elephantinoKeys[testNum], ctx);
160 
161  const double igev = 1. / Gaudi::Units::GeV;
162  ATH_MSG_INFO("IN particles: " << particles->size() << endmsg
163  << "IN decay: " << endmsg
164  << " p1: px= " << decay->p1()->px() * igev << endmsg
165  << " p2: px= " << decay->p2()->px() * igev << endmsg
166  << " l1: px= " << decay->l1()->px() * igev << endmsg
167  << " l2: px= " << decay->l2()->px() * igev);
168 
169  ATH_MSG_INFO("IN elephantino: " << endmsg
170  << " leg1: px= " << elephantino->leg1()->px() * igev << endmsg
171  << " leg2: px= " << elephantino->leg2()->px() * igev << endmsg
172  << " leg3: px= " << elephantino->leg3()->px() * igev << endmsg
173  << " leg4: px= " << elephantino->leg4()->px() * igev << endmsg
174  << " ear1: px= " << elephantino->ear1()->px() * igev << endmsg
175  << " ear2: px= " << elephantino->ear2()->px() * igev);
176 
179  if ( test == "test1" ) {
180  if ( !doThinningTest1(ctx, m_particlesKey1).isSuccess() ) {
181  ATH_MSG_WARNING("Could not exercise Thinning !!");
182  }
183  } else if ( test == "test2" ) {
184  if ( !doThinningTest2(ctx, m_particlesKey2).isSuccess() ) {
185  ATH_MSG_WARNING("Could not exercise Thinning !!");
186  }
187  } else if ( test == "test3" ) {
188  if ( !doThinningTest3(ctx, m_iparticlesKey3).isSuccess() ) {
189  ATH_MSG_WARNING("Could not exercise Thinning !!");
190  }
191  } else {
192  ATH_MSG_ERROR("Unknown test: [" << test << "]");
193  return StatusCode::FAILURE;
194  }
196 
197  ATH_MSG_INFO
198  ("Decay is now: " << endmsg
199  << " p1: px= " << decay->p1()->px() * igev << endmsg
200  << " p2: px= " << decay->p2()->px() * igev << endmsg
201  << " l1: px= " << decay->l1()->px() * igev << endmsg
202  << " l2: px= " << decay->l2()->px() * igev);
203 
204  ATH_MSG_INFO
205  ("Elephantino is now: " << endmsg
206  << " leg1: px= " << elephantino->leg1()->px() * igev << endmsg
207  << " leg2: px= " << elephantino->leg2()->px() * igev << endmsg
208  << " leg3: px= " << elephantino->leg3()->px() * igev << endmsg
209  << " leg4: px= " << elephantino->leg4()->px() * igev << endmsg
210  << " ear1: px= " << elephantino->ear1()->px() * igev << endmsg
211  << " ear2: px= " << elephantino->ear2()->px() * igev);
212 
213 
214  ATH_MSG_INFO("[" << test << "] has been performed.");
215  return StatusCode::SUCCESS;
216 }
217 
218 
219 StatusCode WriteThinnedData::doThinningTest1( const EventContext& ctx,
220  const SG::ThinningHandleKey<AthExParticles>& particlesKey ) const
221 {
222  SG::ThinningHandle<AthExParticles> particles (particlesKey, ctx);
223  std::vector<bool> filter = m_filter.value();
224 
225  const double igev = 1. / Gaudi::Units::GeV;
226  msg(MSG::INFO) << "Particles | filter :" << endmsg;
227  for ( unsigned int i = 0; i != particles->size(); ++i ) {
228  const std::string kr = filter[i] ? "keep" : "remove";
229  msg(MSG::INFO)
230  << std::setw(9) << (*particles)[i]->px() * igev
231  << " | " << kr
232  << endmsg;
233  }
234  msg(MSG::INFO) << "===================" << endmsg;
235 
236  std::fill( filter.begin() + (filter.size() / 2),
237  filter.end(),
238  true );
239  msg(MSG::INFO) << "Filter [" << std::boolalpha;
240  std::copy( filter.begin(), filter.end(),
241  std::ostream_iterator<bool>(msg(MSG::INFO).stream(), " ") );
242  msg(MSG::INFO) << "]" << endmsg;
243 
244  msg(MSG::INFO) << "... Processing [pre-thinning] ..." << endmsg;
245  particles.keep (filter);
246  msg(MSG::INFO) << "======== Index table =========" << endmsg;
247  {
248  SG::ThinningDecisionBase tmp = particles.decision();
249  tmp.buildIndexMap();
250  for ( std::size_t i = 0; i != particles->size(); ++i ) {
251  std::size_t newIdx = tmp.index( i );
252  std::stringstream newIdxStr;
253  newIdxStr << newIdx;
254  msg(MSG::INFO)
255  << " idx " << i
256  << " -> " << (newIdx == SG::ThinningDecision::RemovedIdx
257  ? "-"
258  : newIdxStr.str() )
259  << endmsg;
260  }
261  }
262 
263 
264  filter = m_filter.value();
265  std::fill( filter.begin(),
266  filter.begin() + (filter.size() / 2),
267  true );
268 
269  msg(MSG::INFO) << "Filter [" << std::boolalpha;
270  std::copy( filter.begin(), filter.end(),
271  std::ostream_iterator<bool>(msg(MSG::INFO).stream(), " ") );
272  msg(MSG::INFO) << "]" << endmsg;
273 
274  msg(MSG::INFO) << "... Processing [thinning] ..." << endmsg;
275  particles.keep( filter, SG::ThinningDecisionBase::Op::And );
276 
277  msg(MSG::INFO) << "======== Index table =========" << endmsg;
278  {
279  SG::ThinningDecisionBase tmp = particles.decision();
280  tmp.buildIndexMap();
281  for ( std::size_t i = 0; i != particles->size(); ++i ) {
282  std::size_t newIdx = tmp.index( i );
283  std::stringstream newIdxStr;
284  newIdxStr << newIdx;
285  msg(MSG::INFO)
286  << " idx " << i
287  << " -> " << (newIdx == SG::ThinningDecision::RemovedIdx
288  ? "-"
289  : newIdxStr.str() )
290  << endmsg;
291  }
292  }
293 
294  return StatusCode::SUCCESS;
295 }
296 
297 
298 StatusCode WriteThinnedData::doThinningTest2( const EventContext& ctx,
299  const SG::ThinningHandleKey<AthExParticles>& particlesKey ) const
300 {
301  SG::ThinningHandle<AthExParticles> particles (particlesKey, ctx);
302  std::vector<bool> filter = m_filter.value();
303 
304  const double igev = 1. / Gaudi::Units::GeV;
305  msg(MSG::INFO) << "Particles | filter :" << endmsg;
306  for ( unsigned int i = 0; i != particles->size(); ++i ) {
307  const std::string kr = filter[i] ? "keep" : "remove";
308  msg(MSG::INFO)
309  << std::setw(9) << (*particles)[i]->px() * igev
310  << " | " << kr
311  << endmsg;
312  }
313  msg(MSG::INFO) << "===================" << endmsg;
314 
315  std::fill( filter.begin() + (filter.size() / 2),
316  filter.end(),
317  false );
318  msg(MSG::INFO) << "Filter [" << std::boolalpha;
319  std::copy( filter.begin(), filter.end(),
320  std::ostream_iterator<bool>(msg(MSG::INFO).stream(), " ") );
321  msg(MSG::INFO) << "]" << endmsg;
322 
323  msg(MSG::INFO) << "... Processing [pre-thinning] ..." << endmsg;
324  particles.keep (filter);
325  msg(MSG::INFO) << "======== Index table =========" << endmsg;
326  {
327  SG::ThinningDecisionBase tmp = particles.decision();
328  tmp.buildIndexMap();
329  for ( std::size_t i = 0; i != particles->size(); ++i ) {
330  std::size_t newIdx = tmp.index( i );
331  std::stringstream newIdxStr;
332  newIdxStr << newIdx;
333  msg(MSG::INFO)
334  << " idx " << i
335  << " -> " << (newIdx == SG::ThinningDecision::RemovedIdx
336  ? "-"
337  : newIdxStr.str() )
338  << endmsg;
339  }
340  }
341 
342 
343  filter = m_filter.value();
344  std::fill( filter.begin(),
345  filter.begin() + (filter.size() / 2),
346  false );
347 
348  msg(MSG::INFO) << "Filter [" << std::boolalpha;
349  std::copy( filter.begin(), filter.end(),
350  std::ostream_iterator<bool>(msg(MSG::INFO).stream(), " ") );
351  msg(MSG::INFO) << "]" << endmsg;
352 
353  msg(MSG::INFO) << "... Processing [thinning] ..." << endmsg;
354  particles.keep (filter, SG::ThinningDecisionBase::Op::Or);
355 
356  msg(MSG::INFO) << "======== Index table =========" << endmsg;
357  {
358  SG::ThinningDecisionBase tmp = particles.decision();
359  tmp.buildIndexMap();
360  for ( std::size_t i = 0; i != particles->size(); ++i ) {
361  std::size_t newIdx = tmp.index( i );
362  std::stringstream newIdxStr;
363  newIdxStr << newIdx;
364  msg(MSG::INFO)
365  << " idx " << i
366  << " -> " << (newIdx == SG::ThinningDecision::RemovedIdx
367  ? "-"
368  : newIdxStr.str() )
369  << endmsg;
370  }
371  }
372 
373  return StatusCode::SUCCESS;
374 }
375 
376 
377 StatusCode
378 WriteThinnedData::doThinningTest3( const EventContext& ctx,
379  const SG::ThinningHandleKey<AthExIParticles>& iparticlesKey ) const
380 {
381  SG::ThinningHandle<AthExIParticles> iparticles (iparticlesKey, ctx);
382  std::vector<bool> filter = m_filter.value();
383 
384  const double igev = 1. / Gaudi::Units::GeV;
385  msg(MSG::INFO) << "IParticles | filter :" << endmsg;
386  for ( unsigned int i = 0; i != iparticles->size(); ++i ) {
387  const std::string kr = filter[i] ? "keep" : "remove";
388  msg(MSG::INFO)
389  << std::setw(9) << (*iparticles)[i]->px() * igev
390  << " | " << kr
391  << endmsg;
392  }
393  msg(MSG::INFO) << "===================" << endmsg;
394 
395  std::fill( filter.begin() + (filter.size() / 2),
396  filter.end(),
397  true );
398  msg(MSG::INFO) << "Filter [" << std::boolalpha;
399  std::copy( filter.begin(), filter.end(),
400  std::ostream_iterator<bool>(msg(MSG::INFO).stream(), " ") );
401  msg(MSG::INFO) << "]" << endmsg;
402 
403  msg(MSG::INFO) << "... Processing [pre-thinning] ..." << endmsg;
404  iparticles.keep (filter);
405  msg(MSG::INFO) << "======== Index table =========" << endmsg;
406  {
407  SG::ThinningDecisionBase tmp = iparticles.decision();
408  tmp.buildIndexMap();
409  for ( std::size_t i = 0; i != iparticles->size(); ++i ) {
410  std::size_t newIdx = tmp.index( i );
411  std::stringstream newIdxStr;
412  newIdxStr << newIdx;
413  msg(MSG::INFO)
414  << " idx " << i
415  << " -> " << (newIdx == SG::ThinningDecision::RemovedIdx
416  ? "-"
417  : newIdxStr.str() )
418  << endmsg;
419  }
420  }
421 
422 
423  filter = m_filter.value();
424  std::fill( filter.begin(),
425  filter.begin() + (filter.size() / 2),
426  true );
427 
428  msg(MSG::INFO) << "Filter [" << std::boolalpha;
429  std::copy( filter.begin(), filter.end(),
430  std::ostream_iterator<bool>(msg(MSG::INFO).stream(), " ") );
431  msg(MSG::INFO) << "]" << endmsg;
432 
433  msg(MSG::INFO) << "... Processing [thinning] ..." << endmsg;
434  iparticles.keep (filter, SG::ThinningDecisionBase::Op::And);
435 
436  msg(MSG::INFO) << "======== Index table =========" << endmsg;
437  {
438  SG::ThinningDecisionBase tmp = iparticles.decision();
439  tmp.buildIndexMap();
440  for ( std::size_t i = 0; i != iparticles->size(); ++i ) {
441  std::size_t newIdx = tmp.index( i );
442  std::stringstream newIdxStr;
443  newIdxStr << newIdx;
444  msg(MSG::INFO)
445  << " idx " << i
446  << " -> " << (newIdx == SG::ThinningDecision::RemovedIdx
447  ? "-"
448  : newIdxStr.str() )
449  << endmsg;
450  }
451  }
452 
453  return StatusCode::SUCCESS;
454 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
AthExThinning::WriteThinnedData::m_particlesKey1
SG::ThinningHandleKey< AthExParticles > m_particlesKey1
Definition: WriteThinnedData.h:114
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
SG::ThinningHandleKey< AthExParticles >
ThinningHandle.h
Handle for requesting thinning for a data object.
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
SG::ThinningDecisionBase
Hold thinning decisions for one container.
Definition: ThinningDecisionBase.h:39
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
AthExThinning::WriteThinnedData::WriteThinnedData
WriteThinnedData()
Default constructor:
AthExThinning::WriteThinnedData::m_elephantinoName
StringProperty m_elephantinoName
Elephantino input location.
Definition: WriteThinnedData.h:133
AthExThinning::WriteThinnedData::doThinningTest3
StatusCode doThinningTest3(const EventContext &ctx, const SG::ThinningHandleKey< AthExIParticles > &iparticlesKey) const
Apply the real thinning.
Definition: WriteThinnedData.cxx:378
AthExThinning::WriteThinnedData::~WriteThinnedData
virtual ~WriteThinnedData()
Destructor:
Definition: WriteThinnedData.cxx:64
AthExParticle::px
virtual double px() const
Implementation of the AthExIParticle interface.
Definition: AthExParticle.h:78
AthExThinning
Definition: CreateData.h:30
AthExElephantino::leg4
const AthExIParticle * leg4() const
Definition: AthExElephantino.cxx:77
AthExThinning::WriteThinnedData::m_iparticlesKey3
SG::ThinningHandleKey< AthExIParticles > m_iparticlesKey3
Definition: WriteThinnedData.h:122
AthenaPoolTestWrite.stream
string stream
Definition: AthenaPoolTestWrite.py:12
SG::ThinningHandle
Handle for requesting thinning for a data object.
Definition: ThinningHandle.h:84
SG::ThinningHandleKey::initialize
StatusCode initialize(const std::string &stream, const std::string &qualifier, bool used=true)
Should be called during the initialize phase.
AthExThinning::WriteThinnedData::execute
virtual StatusCode execute() override
Definition: WriteThinnedData.cxx:101
WriteThinnedData.h
AthExElephantino::ear2
const AthExIParticle * ear2() const
Definition: AthExElephantino.cxx:93
covarianceTool.filter
filter
Definition: covarianceTool.py:514
AthExDecay.h
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
SG::ThinningHandleBase::keep
void keep(size_t ndx)
Mark that index ndx in the container should be kept (not thinned away).
Definition: ThinningHandleBase.cxx:68
AthExThinning::WriteThinnedData::initialize
virtual StatusCode initialize() override
Definition: WriteThinnedData.cxx:69
AthExElephantino::ear1
const AthExIParticle * ear1() const
Definition: AthExElephantino.cxx:85
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
AthExElephantino::leg2
const AthExIParticle * leg2() const
Definition: AthExElephantino.cxx:61
lumiFormat.i
int i
Definition: lumiFormat.py:85
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
SG::ThinningDecisionBase::Op::And
@ And
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ThinningDecision.h
Hold thinning decisions for one container.
AthExParticles.h
SG::ThinningHandleBase::decision
const ThinningDecision & decision() const
Return the thinning object we're building.
Definition: ThinningHandleBase.cxx:154
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthExDecay::l1
const AthExParticle * l1() const
Definition: AthExDecay.cxx:73
SG::ThinningDecisionBase::RemovedIdx
static const std::size_t RemovedIdx
Flag used to show that an index has been thinned away.
Definition: ThinningDecisionBase.h:42
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
AthExThinning::WriteThinnedData::doThinningTest1
StatusCode doThinningTest1(const EventContext &ctx, const SG::ThinningHandleKey< AthExParticles > &particlesKey) const
Apply the real thinning.
Definition: WriteThinnedData.cxx:219
checkRpcDigits.allGood
bool allGood
Loop over the SDOs & Digits.
Definition: checkRpcDigits.py:171
AthAlgorithm
Definition: AthAlgorithm.h:47
fill
void fill(H5::Group &out_file, size_t iterations)
Definition: test-hdf5-writer.cxx:95
AthExThinning::WriteThinnedData::m_decayKeys
SG::ReadHandleKeyArray< AthExDecay > m_decayKeys
Definition: WriteThinnedData.h:129
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
AthExThinning::WriteThinnedData::m_iparticlesKeys
SG::ReadHandleKeyArray< AthExIParticles > m_iparticlesKeys
Definition: WriteThinnedData.h:119
AthExThinning::WriteThinnedData::m_particlesKey2
SG::ThinningHandleKey< AthExParticles > m_particlesKey2
Definition: WriteThinnedData.h:116
AthExThinning::WriteThinnedData::m_particlesName
StringProperty m_particlesName
Particles input location.
Definition: WriteThinnedData.h:111
DataVector.h
An STL vector of pointers that by default owns its pointed-to elements.
SG::ThinningDecisionBase::Op::Or
@ Or
AthExIParticle::px
virtual double px() const =0
AthExIParticle interface.
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
AthExThinning::WriteThinnedData::m_filter
BooleanArrayProperty m_filter
Filter to apply on the Particles.
Definition: WriteThinnedData.h:140
AthExElephantino.h
AthExDecay::p2
const AthExParticle * p2() const
Definition: AthExDecay.cxx:66
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
LArG4FSStartPointFilter.particles
list particles
Definition: LArG4FSStartPointFilter.py:84
AthExElephantino::leg1
const AthExIParticle * leg1() const
Definition: AthExElephantino.cxx:53
AthExThinning::WriteThinnedData::m_elephantinoKeys
SG::ReadHandleKeyArray< AthExElephantino > m_elephantinoKeys
Definition: WriteThinnedData.h:136
calibdata.copy
bool copy
Definition: calibdata.py:27
AthExDecay::p1
const AthExParticle * p1() const
Definition: AthExDecay.cxx:59
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
AthExThinning::WriteThinnedData::doThinningTest2
StatusCode doThinningTest2(const EventContext &ctx, const SG::ThinningHandleKey< AthExParticles > &particlesKey) const
Apply the real thinning.
Definition: WriteThinnedData.cxx:298
AthExThinning::WriteThinnedData::test
StatusCode test(const EventContext &ctx, int testNum, const std::string &testName)
Exercise the following thinning tests: [testName = "test1"] retrieve a AthExParticles container remov...
Definition: WriteThinnedData.cxx:125
ReadHandle.h
Handle class for reading from StoreGate.
AthExElephantino::leg3
const AthExIParticle * leg3() const
Definition: AthExElephantino.cxx:69
AthExThinning::WriteThinnedData::finalize
virtual StatusCode finalize() override
Definition: WriteThinnedData.cxx:95
AthExThinning::WriteThinnedData::m_decayName
StringProperty m_decayName
Decay input location.
Definition: WriteThinnedData.h:126
StoreGateSvc.h
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthExParticles
Definition: AthExParticles.h:37
AthExDecay::l2
const AthExParticle * l2() const
Definition: AthExDecay.cxx:80
Generated on Mon Dec 23 2024 21:23:05 for ATLAS Offline Software by   doxygen 1.8.18