ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SvtxTrackEval.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file SvtxTrackEval.cc
1 #include "SvtxTrackEval.h"
2 
3 #include "SvtxClusterEval.h"
4 #include "SvtxTruthEval.h"
5 
6 #include <g4main/PHG4Hit.h>
7 #include <trackbase/TrkrDefs.h> // for cluskey, getLayer
8 
12 
13 #include <phool/getClass.h>
14 
15 #include <cassert>
16 #include <cfloat>
17 #include <iostream>
18 #include <set>
19 
20 using namespace std;
21 
23  : _clustereval(topNode)
24  , _trackmap(nullptr)
25  , _strict(false)
26  , _verbosity(0)
27  , _errors(0)
28  , _do_cache(true)
29  , _cache_track_from_cluster_exists(false)
30  , m_TrackNodeName("SvtxTrackMap") // typically set upstream by SvtxVertexEval
31 {
32  get_node_pointers(topNode);
33 }
34 
36 {
37  if (_verbosity > 0)
38  {
39  if ((_errors > 0) || (_verbosity > 1))
40  {
41  cout << "SvtxTrackEval::~SvtxTrackEval() - Error Count: " << _errors << endl;
42  }
43  }
44 }
45 
47 {
48  _cache_all_truth_hits.clear();
59  _clustereval.next_event(topNode);
60 
61  get_node_pointers(topNode);
62 }
63 
65 {
66  if (!has_node_pointers()) return std::set<PHG4Hit*>();
67 
68  if (_strict)
69  {
70  assert(track);
71  }
72  else if (!track)
73  {
74  ++_errors;
75  return std::set<PHG4Hit*>();
76  }
77 
78  if (_do_cache)
79  {
80  std::map<SvtxTrack*, std::set<PHG4Hit*> >::iterator iter =
81  _cache_all_truth_hits.find(track);
82  if (iter != _cache_all_truth_hits.end())
83  {
84  return iter->second;
85  }
86  }
87 
88  std::set<PHG4Hit*> truth_hits;
89 
90  // loop over all clusters...
92  iter != track->end_cluster_keys();
93  ++iter)
94  {
95  TrkrDefs::cluskey cluster_key = *iter;
96 
97  // if (_strict)
98  // {
99  // assert(cluster_key);
100  // }
101  // else if (!cluster_key)
102  // {
103  // ++_errors;
104  // continue;
105  // }
106 
107  std::set<PHG4Hit*> new_hits = _clustereval.all_truth_hits(cluster_key);
108 
109  for (std::set<PHG4Hit*>::iterator jter = new_hits.begin();
110  jter != new_hits.end();
111  ++jter)
112  {
113  truth_hits.insert(*jter);
114  }
115  }
116 
117  if (_do_cache) _cache_all_truth_hits.insert(make_pair(track, truth_hits));
118 
119  return truth_hits;
120 }
121 
123 {
124  if (!has_node_pointers()) return std::set<PHG4Particle*>();
125  if (_strict)
126  {
127  assert(track);
128  }
129 
130  else if (!track)
131  {
132  ++_errors;
133  return std::set<PHG4Particle*>();
134  }
135  if (_do_cache)
136  {
137  std::map<SvtxTrack*, std::set<PHG4Particle*> >::iterator iter =
138  _cache_all_truth_particles.find(track);
139  if (iter != _cache_all_truth_particles.end())
140  {
141  return iter->second;
142  }
143  }
144  std::set<PHG4Particle*> truth_particles;
145  SvtxTrack_FastSim * fastsim_track = dynamic_cast<SvtxTrack_FastSim * >(track);
146 
147  if (fastsim_track)
148  {
149  // exception for fast sim track
150  unsigned int track_id = fastsim_track -> get_truth_track_id();
151  truth_particles.insert(get_truth_eval()->get_particle(track_id));
152  }
153  else{
154  // loop over all clusters...
156  iter != track->end_cluster_keys();
157  ++iter)
158  {
159  TrkrDefs::cluskey cluster_key = *iter;
160 
161  // if (_strict)
162  // {
163  // assert(cluster_key);
164  // }
165  // else if (!cluster_key)
166  // {
167  // ++_errors;
168  // continue;
169  // }
170 
171  std::set<PHG4Particle*> new_particles = _clustereval.all_truth_particles(cluster_key);
172 
173  for (std::set<PHG4Particle*>::iterator jter = new_particles.begin();
174  jter != new_particles.end();
175  ++jter)
176  {
177  truth_particles.insert(*jter);
178  }
179  }
180  }
181 
182  if (_do_cache) _cache_all_truth_particles.insert(make_pair(track, truth_particles));
183 
184  return truth_particles;
185 }
186 
188 {
189  if (!has_node_pointers()) return nullptr;
190 
191  if (_strict)
192  {
193  assert(track);
194  }
195  else if (!track)
196  {
197  ++_errors;
198  return nullptr;
199  }
200 
201  if (_do_cache)
202  {
203  std::map<SvtxTrack*, PHG4Particle*>::iterator iter =
205  if (iter != _cache_max_truth_particle_by_nclusters.end())
206  {
207  return iter->second;
208  }
209  }
210 
211  std::set<PHG4Particle*> particles = all_truth_particles(track);
212  PHG4Particle* max_particle = nullptr;
213 
214  SvtxTrack_FastSim * fastsim_track = dynamic_cast<SvtxTrack_FastSim * >(track);
215  if (fastsim_track)
216  {
217  // exception for fast sim track
218  unsigned int track_id = fastsim_track -> get_truth_track_id();
219  max_particle = get_truth_eval()->get_particle(track_id);
220  }
221  else
222  {
223  unsigned int max_nclusters = 0;
224 
225  for (std::set<PHG4Particle*>::iterator iter = particles.begin();
226  iter != particles.end();
227  ++iter)
228  {
229  PHG4Particle* candidate = *iter;
230  unsigned int nclusters = get_nclusters_contribution(track, candidate);
231  if (nclusters > max_nclusters)
232  {
233  max_nclusters = nclusters;
234  max_particle = candidate;
235  }
236  }
237  }
238 
239  if (_do_cache) _cache_max_truth_particle_by_nclusters.insert(make_pair(track, max_particle));
240 
241  return max_particle;
242 }
243 
244 std::set<SvtxTrack*> SvtxTrackEval::all_tracks_from(PHG4Particle* truthparticle)
245 {
246  if (!has_node_pointers()) return std::set<SvtxTrack*>();
247 
248  if (_strict)
249  {
250  assert(truthparticle);
251  }
252  else if (!truthparticle)
253  {
254  ++_errors;
255  return std::set<SvtxTrack*>();
256  }
257 
258  if (_do_cache)
259  {
260  std::map<PHG4Particle*, std::set<SvtxTrack*> >::iterator iter =
261  _cache_all_tracks_from_particle.find(truthparticle);
262  if (iter != _cache_all_tracks_from_particle.end())
263  {
264  return iter->second;
265  }
266  }
267 
268  std::set<SvtxTrack*> tracks;
269 
270  // loop over all SvtxTracks
271  for (SvtxTrackMap::Iter iter = _trackmap->begin();
272  iter != _trackmap->end();
273  ++iter)
274  {
275  SvtxTrack* track = iter->second;
276 
278  iter != track->end_cluster_keys();
279  ++iter)
280  {
281  TrkrDefs::cluskey cluster_key = *iter;
282 
283  // remove this check as cluster key = 0 is MVTX layer 0 cluster #0.
284  // if (_strict)
285  // {
286  // assert(cluster_key);
287  // }
288  // else if (!cluster_key)
289  // {
290  // ++_errors;
291  // continue;
292  // }
293 
294  // loop over all particles
295  std::set<PHG4Particle*> particles = _clustereval.all_truth_particles(cluster_key);
296  for (std::set<PHG4Particle*>::iterator jter = particles.begin();
297  jter != particles.end();
298  ++jter)
299  {
300  PHG4Particle* candidate = *jter;
301  if (get_truth_eval()->are_same_particle(candidate, truthparticle))
302  {
303  tracks.insert(track);
304  }
305  }
306  }
307  }
308 
309  if (_do_cache) _cache_all_tracks_from_particle.insert(make_pair(truthparticle, tracks));
310 
311  return tracks;
312 }
313 
314 std::set<SvtxTrack*> SvtxTrackEval::all_tracks_from(PHG4Hit* truthhit)
315 {
316  if (!has_node_pointers())
317  {
318  ++_errors;
319  return std::set<SvtxTrack*>();
320  }
321 
322  if (_strict)
323  {
324  assert(truthhit);
325  }
326  else if (!truthhit)
327  {
328  ++_errors;
329  return std::set<SvtxTrack*>();
330  }
331 
332  if (_do_cache)
333  {
334  std::map<PHG4Hit*, std::set<SvtxTrack*> >::iterator iter =
335  _cache_all_tracks_from_g4hit.find(truthhit);
336  if (iter != _cache_all_tracks_from_g4hit.end())
337  {
338  return iter->second;
339  }
340  }
341 
342  std::set<SvtxTrack*> tracks;
343 
344  // loop over all SvtxTracks
345  for (SvtxTrackMap::Iter iter = _trackmap->begin();
346  iter != _trackmap->end();
347  ++iter)
348  {
349  SvtxTrack* track = iter->second;
350 
351  // loop over all clusters
353  iter != track->end_cluster_keys();
354  ++iter)
355  {
356  TrkrDefs::cluskey cluster_key = *iter;
357 
358  // if (_strict)
359  // {
360  // assert(cluster_key);
361  // }
362  // else if (!cluster_key)
363  // {
364  // ++_errors;
365  // continue;
366  // }
367 
368  // loop over all hits
369  std::set<PHG4Hit*> hits = _clustereval.all_truth_hits(cluster_key);
370  for (std::set<PHG4Hit*>::iterator jter = hits.begin();
371  jter != hits.end();
372  ++jter)
373  {
374  PHG4Hit* candidate = *jter;
375  // if track id matches argument add to output
376  if (candidate->get_trkid() == truthhit->get_trkid())
377  {
378  tracks.insert(track);
379  }
380  }
381  }
382  }
383 
384  if (_do_cache) _cache_all_tracks_from_g4hit.insert(make_pair(truthhit, tracks));
385 
386  return tracks;
387 }
388 
390 {
391  if (!has_node_pointers())
392  {
393  ++_errors;
394  return nullptr;
395  }
396 
397  if (_strict)
398  {
399  assert(truthparticle);
400  }
401  else if (!truthparticle)
402  {
403  ++_errors;
404  return nullptr;
405  }
406 
407  if (_do_cache)
408  {
409  std::map<PHG4Particle*, SvtxTrack*>::iterator iter =
410  _cache_best_track_from_particle.find(truthparticle);
411  if (iter != _cache_best_track_from_particle.end())
412  {
413  return iter->second;
414  }
415  }
416 
417  SvtxTrack* best_track = nullptr;
418  unsigned int best_count = 0;
419  std::set<SvtxTrack*> tracks = all_tracks_from(truthparticle);
420  for (std::set<SvtxTrack*>::iterator iter = tracks.begin();
421  iter != tracks.end();
422  ++iter)
423  {
424  SvtxTrack* track = *iter;
425  unsigned int count = get_nclusters_contribution(track, truthparticle);
426  if (count > best_count)
427  {
428  best_track = track;
429  best_count = count;
430  }
431  }
432 
433  if (_do_cache) _cache_best_track_from_particle.insert(make_pair(truthparticle, best_track));
434 
435  return best_track;
436 }
437 
439 {
440  if (!has_node_pointers())
441  {
442  ++_errors;
443  return;
444  }
445 
446  // loop over all SvtxTracks
447  for (SvtxTrackMap::Iter iter = _trackmap->begin();
448  iter != _trackmap->end();
449  ++iter)
450  {
451  SvtxTrack* track = iter->second;
452  // loop over all clusters
454  iter != track->end_cluster_keys();
455  ++iter)
456  {
457  TrkrDefs::cluskey candidate_key = *iter;
458  // unsigned int cluster_layer = TrkrDefs::getLayer(candidate_key);
459  // if (_strict)
460  // {
461  // assert(candidate_key);
462  // }
463  // else if (!candidate_key)
464  // {
465  // ++_errors;
466  // continue;
467  // }
468 
469  //check if cluster has an entry in cache
470  std::map<TrkrDefs::cluskey, std::set<SvtxTrack*> >::iterator cliter =
471  _cache_all_tracks_from_cluster.find(candidate_key);
472  if (cliter != _cache_all_tracks_from_cluster.end())
473  { //got entry
474  cliter->second.insert(track); //add track to list;
475  }
476  else
477  {
478  std::set<SvtxTrack*> tracks;
479  tracks.insert(track);
480  _cache_all_tracks_from_cluster.insert(make_pair(candidate_key, tracks));
481  }
482  }
483  }
485 
486  return;
487 }
488 
489 std::set<SvtxTrack*> SvtxTrackEval::all_tracks_from(TrkrDefs::cluskey cluster_key)
490 {
491  if (!has_node_pointers())
492  {
493  ++_errors;
494  return std::set<SvtxTrack*>();
495  }
496 
497  // if (_strict)
498  // {
499  // assert(cluster_key);
500  // }
501  // else if (!cluster_key)
502  // {
503  // ++_errors;
504  // return std::set<SvtxTrack*>();
505  // }
506 
507  std::set<SvtxTrack*> tracks;
508 
509  if (_do_cache)
510  {
512  std::map<TrkrDefs::cluskey, std::set<SvtxTrack*> >::iterator iter =
513  _cache_all_tracks_from_cluster.find(cluster_key);
514  if (iter != _cache_all_tracks_from_cluster.end())
515  {
516  return iter->second;
517  }
518  else
519  {
520  return tracks;
521  }
522  }
523 
524  // loop over all SvtxTracks
525  for (SvtxTrackMap::Iter iter = _trackmap->begin();
526  iter != _trackmap->end();
527  ++iter)
528  {
529  SvtxTrack* track = iter->second;
530 
531  // loop over all clusters
533  iter != track->end_cluster_keys();
534  ++iter)
535  {
536  TrkrDefs::cluskey candidate = *iter;
537 
538  // if (_strict)
539  // {
540  // assert(candidate);
541  // }
542  // else if (!candidate)
543  // {
544  // ++_errors;
545  // continue;
546  // }
547 
548  if (cluster_key == candidate)
549  {
550  tracks.insert(track);
551  }
552  }
553  }
554 
555  if (_do_cache) _cache_all_tracks_from_cluster.insert(make_pair(cluster_key, tracks));
556 
557  return tracks;
558 }
559 
561 {
562  if (!has_node_pointers())
563  {
564  ++_errors;
565  return nullptr;
566  }
567 
568  // if (_strict)
569  // {
570  // assert(cluster_key);
571  // }
572  // else if (!cluster_key)
573  // {
574  // ++_errors;
575  // return nullptr;
576  // }
577 
578  if (_do_cache)
579  {
580  std::map<TrkrDefs::cluskey, SvtxTrack*>::iterator iter =
581  _cache_best_track_from_cluster.find(cluster_key);
582  if (iter != _cache_best_track_from_cluster.end())
583  {
584  return iter->second;
585  }
586  }
587 
588  SvtxTrack* best_track = nullptr;
589  float best_quality = FLT_MAX;
590 
591  std::set<SvtxTrack*> tracks = all_tracks_from(cluster_key);
592  // loop over all SvtxTracks
593  for (std::set<SvtxTrack*>::iterator iter = tracks.begin();
594  iter != tracks.end();
595  ++iter)
596  {
597  SvtxTrack* candidate = *iter;
598  if (candidate->get_quality() < best_quality)
599  {
600  best_quality = candidate->get_quality();
601  best_track = candidate;
602  }
603  }
604 
605  if (_do_cache) _cache_best_track_from_cluster.insert(make_pair(cluster_key, best_track));
606  return best_track;
607 }
608 
609 // overlap calculations
611 {
612  if (!has_node_pointers())
613  {
614  ++_errors;
615  return 0;
616  }
617 
618  if (_strict)
619  {
620  assert(track);
621  assert(particle);
622  }
623  else if (!track || !particle)
624  {
625  ++_errors;
626  return 0;
627  }
628 
629  calc_cluster_contribution(track, particle);
630 
631  std::map<std::pair<SvtxTrack*, PHG4Particle*>, unsigned int>::iterator iter =
632  _cache_get_nclusters_contribution.find(make_pair(track, particle));
633  if (iter != _cache_get_nclusters_contribution.end())
634  {
635  return iter->second;
636  }
637 
638  return 0;
639 }
641 {
642  if (!has_node_pointers())
643  {
644  ++_errors;
645  return 0;
646  }
647 
648  if (_strict)
649  {
650  assert(track);
651  assert(particle);
652  }
653  else if (!track || !particle)
654  {
655  ++_errors;
656  return 0;
657  }
658 
659  calc_cluster_contribution(track, particle);
660 
661  std::map<std::pair<SvtxTrack*, PHG4Particle*>, unsigned int>::iterator iter =
662  _cache_get_nwrongclusters_contribution.find(make_pair(track, particle));
663  if (iter != _cache_get_nwrongclusters_contribution.end())
664  {
665  return iter->second;
666  }
667 
668  return 0;
669 }
670 
671 // overlap calculations
673 {
674  if (!has_node_pointers())
675  {
676  ++_errors;
677  return;
678  }
679 
680  if (_strict)
681  {
682  assert(track);
683  assert(particle);
684  }
685  else if (!track || !particle)
686  {
687  ++_errors;
688  return;
689  }
690 
691  std::map<std::pair<SvtxTrack*, PHG4Particle*>, unsigned int>::iterator iter =
692  _cache_get_nclusters_contribution.find(make_pair(track, particle));
693  std::map<std::pair<SvtxTrack*, PHG4Particle*>, unsigned int>::iterator witer =
694  _cache_get_nwrongclusters_contribution.find(make_pair(track, particle));
695 
696  if (iter != _cache_get_nclusters_contribution.end() &&
698  {
699  return;
700  }
701 
702  unsigned int nclusters = 0;
703  unsigned int nwrong = 0;
704  // loop over all clusters
706  iter != track->end_cluster_keys();
707  ++iter)
708  {
709  TrkrDefs::cluskey cluster_key = *iter;
710 
711  // if (_strict)
712  // {
713  // assert(cluster_key);
714  // }
715  // else if (!cluster_key)
716  // {
717  // ++_errors;
718  // continue;
719  // }
720  int matched = 0;
721  // loop over all particles
722  std::set<PHG4Particle*> particles = _clustereval.all_truth_particles(cluster_key);
723  for (std::set<PHG4Particle*>::iterator jter = particles.begin();
724  jter != particles.end();
725  ++jter)
726  {
727  PHG4Particle* candidate = *jter;
728  if (get_truth_eval()->are_same_particle(candidate, particle))
729  {
730  ++nclusters;
731  matched = 1;
732  }
733  }
734  if (matched == 0) nwrong++;
735  }
736 
737  _cache_get_nclusters_contribution.insert(make_pair(make_pair(track, particle), nclusters));
738  _cache_get_nwrongclusters_contribution.insert(make_pair(make_pair(track, particle), nwrong));
739 
740  return;
741 }
742 
744 {
745  if (!has_node_pointers())
746  {
747  ++_errors;
748  return 0;
749  }
750 
751  if (_strict)
752  {
753  assert(track);
754  assert(particle);
755  }
756  else if (!track || !particle)
757  {
758  ++_errors;
759  return 0;
760  }
761 
762  if (_do_cache)
763  {
764  std::map<std::pair<SvtxTrack*, PHG4Particle*>, unsigned int>::iterator iter =
765  _cache_get_nclusters_contribution_by_layer.find(make_pair(track, particle));
767  {
768  return iter->second;
769  }
770  }
771 
772  unsigned int nclusters_by_layer = 0;
773  int layer_occupied[100];
774  for (int i = 0; i < 100; i++) layer_occupied[i] = 0;
775 
776  // loop over all clusters
778  iter != track->end_cluster_keys();
779  ++iter)
780  {
781  TrkrDefs::cluskey cluster_key = *iter;
782  unsigned int cluster_layer = TrkrDefs::getLayer(cluster_key);
783 
784  // if (_strict)
785  // {
786  // assert(cluster_key);
787  // }
788  // else if (!cluster_key)
789  // {
790  // ++_errors;
791  // continue;
792  // }
793 
794  // loop over all particles
795  std::set<PHG4Particle*> particles = _clustereval.all_truth_particles(cluster_key);
796 
797  for (std::set<PHG4Particle*>::iterator jter = particles.begin();
798  jter != particles.end();
799  ++jter)
800  {
801  PHG4Particle* candidate = *jter;
802  if (get_truth_eval()->are_same_particle(candidate, particle))
803  {
804  layer_occupied[cluster_layer]++;
805  }
806  }
807  }
808  for (int i = 0; i < 100; i++)
809  {
810  if (layer_occupied[i] > 0) nclusters_by_layer++;
811  }
812  if (_do_cache) _cache_get_nclusters_contribution_by_layer.insert(make_pair(make_pair(track, particle), nclusters_by_layer));
813 
814  return nclusters_by_layer;
815 }
816 
817 unsigned int SvtxTrackEval::get_layer_range_contribution(SvtxTrack* track, PHG4Particle* particle, unsigned int start_layer, unsigned int end_layer)
818 {
819  if (!has_node_pointers())
820  {
821  ++_errors;
822  return 0;
823  }
824 
825  if (_strict)
826  {
827  assert(track);
828  assert(particle);
829  }
830  else if (!track || !particle)
831  {
832  ++_errors;
833  return 0;
834  }
835 
836  unsigned int nmatches = 0;
837  unsigned int nlayers = end_layer - start_layer;
838 
839  int layers[nlayers];
840  for (unsigned int i = 0; i < nlayers; i++)
841  {
842  layers[i] = 0;
843  }
844  // loop over all clusters
846  iter != track->end_cluster_keys();
847  ++iter)
848  {
849  TrkrDefs::cluskey cluster_key = *iter;
850  unsigned int cluster_layer = TrkrDefs::getLayer(cluster_key);
851  if (cluster_layer >= end_layer) continue;
852  if (cluster_layer < start_layer) continue;
853 
854  // if (_strict)
855  // {
856  // assert(cluster_key);
857  // }
858  // else if (!cluster_key)
859  // {
860  // ++_errors;
861  // continue;
862  // }
863 
864  // loop over all particles
865  std::set<PHG4Particle*> particles = _clustereval.all_truth_particles(cluster_key);
866  for (std::set<PHG4Particle*>::iterator jter = particles.begin();
867  jter != particles.end();
868  ++jter)
869  {
870  PHG4Particle* candidate = *jter;
871  if (get_truth_eval()->are_same_particle(candidate, particle))
872  {
873  // nmatches |= (0x3FFFFFFF & (0x1 << cluster_layer));
874  layers[cluster_layer - start_layer] = 1;
875  }
876  }
877  }
878  for (unsigned int i = 0; i < nlayers; i++)
879  {
880  if (layers[i] == 1) nmatches++;
881  }
882 
883  return nmatches;
884 }
885 
887 {
888  // need things off of the DST...
889  _trackmap = findNode::getClass<SvtxTrackMap>(topNode, m_TrackNodeName);
890  return;
891 }
892 
894 {
895  // need things off of the DST...
896  if (_strict)
897  assert(_trackmap);
898  else if (!_trackmap)
899  return false;
900  return true;
901 }