Analysis Software
Documentation for sPHENIX simulation software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CaloTruthEval.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file CaloTruthEval.cc
1 #include "CaloTruthEval.h"
2 
3 #include <phool/getClass.h>
4 
6 #include <g4main/PHG4HitDefs.h>
7 #include <g4main/PHG4Shower.h>
9 
10 #include <cassert>
11 #include <cmath>
12 #include <iostream>
13 #include <map>
14 #include <set>
15 #include <utility>
16 
18  : _basetrutheval(topNode)
19  , _caloname(caloname)
20  , _caloid(PHG4HitDefs::get_volume_id(caloname))
21 {
22  get_node_pointers(topNode);
23 }
24 
26 {
27  if (_verbosity > 0)
28  {
29  if ((_errors > 0) || (_verbosity > 1))
30  {
31  std::cout << "CaloTruthEval::~CaloTruthEval() - Error Count: " << _errors << std::endl;
32  }
33  }
34 }
35 
37 {
43 
44  _basetrutheval.next_event(topNode);
45 
46  get_node_pointers(topNode);
47 }
48 
50 {
52  {
53  return false;
54  }
55 
56  if (_strict)
57  {
59  }
60  else if (!_truthinfo)
61  {
62  return false;
63  }
64 
65  return true;
66 }
67 
69 {
70  return _basetrutheval.get_primary_shower(shower);
71 }
72 
74 {
75  return _basetrutheval.get_primary_shower(particle);
76 }
77 
79 {
80  return _basetrutheval.get_primary_particle(shower);
81 }
82 
84 {
85  return _basetrutheval.get_primary_particle(particle);
86 }
87 
89 {
90  return _basetrutheval.get_embed(particle);
91 }
92 
94 {
95  return _basetrutheval.get_vertex(particle);
96 }
97 
99 {
100  return _basetrutheval.are_same_shower(s1, s2);
101 }
102 
104 {
105  return _basetrutheval.are_same_particle(p1, p2);
106 }
107 
109 {
110  return _basetrutheval.are_same_vertex(vtx1, vtx2);
111 }
112 
114 {
115  return _basetrutheval.is_primary(shower);
116 }
117 
119 {
120  return _basetrutheval.is_primary(particle);
121 }
122 
124 {
126  {
127  ++_errors;
128  return NAN;
129  }
130 
131  if (_strict)
132  {
133  assert(primary);
134  }
135  else if (!primary)
136  {
137  ++_errors;
138  return NAN;
139  }
140 
141  if (!is_primary(primary))
142  {
143  return NAN;
144  }
145 
146  primary = get_primary_particle(primary);
147 
148  if (_strict)
149  {
150  assert(primary);
151  }
152  else if (!primary)
153  {
154  ++_errors;
155  return NAN;
156  }
157 
158  if (_do_cache)
159  {
160  std::map<PHG4Particle*, float>::iterator iter =
161  _cache_get_shower_energy_deposit.find(primary);
162  if (iter != _cache_get_shower_energy_deposit.end())
163  {
164  return iter->second;
165  }
166  }
167 
168  float shower_e = 0.0;
170  if (shower)
171  {
172  shower_e = shower->get_edep(_g4hit_container_id);
173  }
174 
175  if (_do_cache)
176  {
177  _cache_get_shower_energy_deposit.insert(std::make_pair(primary, shower_e));
178  }
179 
180  return shower_e;
181 }
182 
184 {
185  if (!has_full_node_pointers())
186  {
187  ++_errors;
188  return NAN;
189  }
190 
191  if (_strict)
192  {
193  assert(primary);
194  }
195  else if (!primary)
196  {
197  ++_errors;
198  return NAN;
199  }
200 
201  if (!is_primary(primary))
202  {
203  return NAN;
204  }
205 
207  if (!shower)
208  {
209  return 0.0;
210  }
211 
212  float ratio = shower->get_eh_ratio(get_caloid());
213 
214  return ratio;
215 }
216 
218 {
220  {
221  return false;
222  }
223 
224  if (_strict)
225  {
227  }
228  else if (!_truthinfo)
229  {
230  return false;
231  }
232 
233  if (_strict)
234  {
235  assert(_g4hits);
236  }
237  if (!_g4hits)
238  {
239  return false;
240  }
241 
242  return true;
243 }
244 
246 {
247  if (!has_full_node_pointers())
248  {
249  ++_errors;
250  return std::set<PHG4Hit*>();
251  }
252 
253  if (_strict)
254  {
255  assert(shower);
256  }
257  else if (!shower)
258  {
259  ++_errors;
260  return std::set<PHG4Hit*>();
261  }
262  else if (!_g4hits)
263  {
264  ++_errors;
265  return std::set<PHG4Hit*>();
266  }
267 
268  if (_do_cache)
269  {
270  std::map<PHG4Shower*, std::set<PHG4Hit*> >::iterator iter =
271  _cache_all_truth_hits_g4shower.find(shower);
272  if (iter != _cache_all_truth_hits_g4shower.end())
273  {
274  return iter->second;
275  }
276  }
277 
278  std::set<PHG4Hit*> truth_hits;
279 
280  // loop over all g4hits on the shower
282  if (iter != shower->end_g4hit_id())
283  {
284  return truth_hits;
285  }
286 
287  for (unsigned long long jter : iter->second)
288  {
289  PHG4Hit* g4hit = _g4hits->findHit(jter);
290 
291  if (_strict)
292  {
293  assert(g4hit);
294  }
295  else if (!g4hit)
296  {
297  ++_errors;
298  }
299 
300  if (g4hit)
301  {
302  truth_hits.insert(g4hit);
303  }
304  }
305 
306  if (_do_cache)
307  {
308  _cache_all_truth_hits_g4shower.insert(std::make_pair(shower, truth_hits));
309  }
310 
311  return truth_hits;
312 }
313 
315 {
316  if (!has_full_node_pointers())
317  {
318  ++_errors;
319  return std::set<PHG4Hit*>();
320  }
321 
322  if (_strict)
323  {
324  assert(particle);
325  }
326  else if (!particle)
327  {
328  ++_errors;
329  return std::set<PHG4Hit*>();
330  }
331  if (!_g4hits)
332  {
333  ++_errors;
334  return std::set<PHG4Hit*>();
335  }
336 
337  if (_do_cache)
338  {
339  std::map<PHG4Particle*, std::set<PHG4Hit*> >::iterator iter =
340  _cache_all_truth_hits_g4particle.find(particle);
341  if (iter != _cache_all_truth_hits_g4particle.end())
342  {
343  return iter->second;
344  }
345  }
346 
347  std::set<PHG4Hit*> truth_hits;
348 
349  // loop over all the g4hits
350  for (PHG4HitContainer::ConstIterator g4iter = _g4hits->getHits().first;
351  g4iter != _g4hits->getHits().second;
352  ++g4iter)
353  {
354  PHG4Hit* g4hit = g4iter->second;
355  if (is_g4hit_from_particle(g4hit, particle))
356  {
357  continue;
358  }
359  truth_hits.insert(g4hit);
360  }
361 
362  if (_do_cache)
363  {
364  _cache_all_truth_hits_g4particle.insert(std::make_pair(particle, truth_hits));
365  }
366 
367  return truth_hits;
368 }
369 
371 {
372  return _basetrutheval.get_particle(g4hit);
373 }
374 
376 {
377  if (!has_full_node_pointers())
378  {
379  ++_errors;
380  return nullptr;
381  }
382 
383  if (_strict)
384  {
385  assert(g4hit);
386  }
387  else if (!g4hit)
388  {
389  ++_errors;
390  return nullptr;
391  }
392 
393  if (_do_cache)
394  {
395  std::map<PHG4Hit*, PHG4Particle*>::iterator iter =
397  if (iter != _cache_get_primary_particle_g4hit.end())
398  {
399  return iter->second;
400  }
401  }
402 
404 
405  if (_do_cache)
406  {
407  _cache_get_primary_particle_g4hit.insert(std::make_pair(g4hit, primary));
408  }
409 
410  if (_strict)
411  {
412  assert(primary);
413  }
414  else if (!primary)
415  {
416  ++_errors;
417  }
418 
419  return primary;
420 }
421 
423 {
424  return _basetrutheval.is_g4hit_from_particle(g4hit, particle);
425 }
426 
428 {
429  if (!has_full_node_pointers())
430  {
431  ++_errors;
432  return std::set<PHG4Hit*>();
433  }
434 
435  if (_strict)
436  {
437  assert(primary);
438  }
439  else if (!primary)
440  {
441  ++_errors;
442  return std::set<PHG4Hit*>();
443  }
444 
445  if (!is_primary(primary))
446  {
447  return std::set<PHG4Hit*>();
448  }
449 
450  primary = get_primary_particle(primary);
451 
452  if (_strict)
453  {
454  assert(primary);
455  }
456  else if (!primary)
457  {
458  ++_errors;
459  return std::set<PHG4Hit*>();
460  }
461 
462  if (_do_cache)
463  {
464  std::map<PHG4Particle*, std::set<PHG4Hit*> >::iterator iter =
466  if (iter != _cache_get_shower_hits_from_primary.end())
467  {
468  return iter->second;
469  }
470  }
471 
472  std::set<PHG4Hit*> truth_hits;
473 
475  if (shower)
476  {
477  truth_hits = all_truth_hits(shower);
478  }
479 
480  if (_do_cache)
481  {
482  _cache_get_shower_hits_from_primary.insert(std::make_pair(primary, truth_hits));
483  }
484 
485  return truth_hits;
486 }
487 
489 {
490  // need things off of the DST...
491  _truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode, "G4TruthInfo");
492 
493  std::string name = "G4HIT_" + _caloname;
494  _g4hits = findNode::getClass<PHG4HitContainer>(topNode, name.c_str());
496 
497  return;
498 }