ATLAS Offline Software
Loading...
Searching...
No Matches
WriteThinnedData.cxx
Go to the documentation of this file.
1
2
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
37using namespace AthExThinning;
38
39// Constructors
41WriteThinnedData::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
66
67// Athena Algorithm's Hooks
69StatusCode 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
95StatusCode WriteThinnedData::finalize()
96{
97 ATH_MSG_INFO("Finalizing " << name() << "...");
98 return StatusCode::SUCCESS;
99}
100
101StatusCode 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
125StatusCode 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
219StatusCode 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
298StatusCode 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
377StatusCode
378WriteThinnedData::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}
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
DataVector.h
An STL vector of pointers that by default owns its pointed-to elements.
ss
static Double_t ss
Definition LArPhysWaveHECTool.cxx:37
ReadHandle.h
Handle class for reading from StoreGate.
ThinningDecision.h
Hold thinning decisions for one container.
ThinningHandle.h
Handle for requesting thinning for a data object.
AthAlgorithm::AthAlgorithm
AthAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor with parameters:
Definition AthAlgorithm.cxx:24
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition AthCommonMsg.h:24
AthExThinning::WriteThinnedData::m_elephantinoName
StringProperty m_elephantinoName
Elephantino input location.
Definition WriteThinnedData.h:133
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
AthExThinning::WriteThinnedData::doThinningTest2
StatusCode doThinningTest2(const EventContext &ctx, const SG::ThinningHandleKey< AthExParticles > &particlesKey) const
Apply the real thinning.
Definition WriteThinnedData.cxx:298
AthExThinning::WriteThinnedData::m_particlesName
StringProperty m_particlesName
Particles input location.
Definition WriteThinnedData.h:111
AthExThinning::WriteThinnedData::initialize
virtual StatusCode initialize() override
Definition WriteThinnedData.cxx:69
AthExThinning::WriteThinnedData::m_elephantinoKeys
SG::ReadHandleKeyArray< AthExElephantino > m_elephantinoKeys
Definition WriteThinnedData.h:136
AthExThinning::WriteThinnedData::m_particlesKey1
SG::ThinningHandleKey< AthExParticles > m_particlesKey1
Definition WriteThinnedData.h:114
AthExThinning::WriteThinnedData::m_decayName
StringProperty m_decayName
Decay input location.
Definition WriteThinnedData.h:126
AthExThinning::WriteThinnedData::WriteThinnedData
WriteThinnedData(const std::string &name, ISvcLocator *pSvcLocator)
Constructor with parameters:
Definition WriteThinnedData.cxx:41
AthExThinning::WriteThinnedData::m_particlesKey2
SG::ThinningHandleKey< AthExParticles > m_particlesKey2
Definition WriteThinnedData.h:116
AthExThinning::WriteThinnedData::m_iparticlesKeys
SG::ReadHandleKeyArray< AthExIParticles > m_iparticlesKeys
Definition WriteThinnedData.h:119
AthExThinning::WriteThinnedData::m_decayKeys
SG::ReadHandleKeyArray< AthExDecay > m_decayKeys
Definition WriteThinnedData.h:129
AthExThinning::WriteThinnedData::m_iparticlesKey3
SG::ThinningHandleKey< AthExIParticles > m_iparticlesKey3
Definition WriteThinnedData.h:122
AthExThinning::WriteThinnedData::execute
virtual StatusCode execute() override
Definition WriteThinnedData.cxx:101
AthExThinning::WriteThinnedData::m_filter
BooleanArrayProperty m_filter
Filter to apply on the Particles.
Definition WriteThinnedData.h:140
AthExThinning::WriteThinnedData::doThinningTest3
StatusCode doThinningTest3(const EventContext &ctx, const SG::ThinningHandleKey< AthExIParticles > &iparticlesKey) const
Apply the real thinning.
Definition WriteThinnedData.cxx:378
AthExThinning::WriteThinnedData::doThinningTest1
StatusCode doThinningTest1(const EventContext &ctx, const SG::ThinningHandleKey< AthExParticles > &particlesKey) const
Apply the real thinning.
Definition WriteThinnedData.cxx:219
AthExThinning::WriteThinnedData::~WriteThinnedData
virtual ~WriteThinnedData()
Destructor:
Definition WriteThinnedData.cxx:64
AthExThinning::WriteThinnedData::finalize
virtual StatusCode finalize() override
Definition WriteThinnedData.cxx:95
SG::ThinningDecisionBase
Hold thinning decisions for one container.
Definition ThinningDecisionBase.h:39
SG::ThinningDecisionBase::RemovedIdx
static const std::size_t RemovedIdx
Flag used to show that an index has been thinned away.
Definition ThinningDecisionBase.h:42
SG::ThinningHandleBase::decision
const ThinningDecision & decision() const
Return the thinning object we're building.
Definition ThinningHandleBase.cxx:161
SG::ThinningHandleBase::keep
void keep(size_t ndx)
Mark that index ndx in the container should be kept (not thinned away).
Definition ThinningHandleBase.cxx:75
SG::ThinningHandleKey
HandleKey object for adding thinning to an object.
Definition ThinningHandleKey.h:39
SG::ThinningHandle
Handle for requesting thinning for a data object.
Definition ThinningHandle.h:84
Generated on for ATLAS Offline Software by doxygen 1.14.0