sPhenix code displayed by LXR master/​coresoftware/​simulation/​g4simulation/​g4eval/​SvtxHitEval.cc	Source navigation Diff markup Identifier search General search
	Version: master Revert   Change

File indexing completed on 2025-08-05 08:18:00

 #include "SvtxHitEval.h"
 
 #include <trackbase/TrkrClusterContainer.h>
 #include <trackbase/TrkrDefs.h>
 #include <trackbase/TrkrHitSet.h>
 #include <trackbase/TrkrHitSetContainer.h>
 #include <trackbase/TrkrHitTruthAssoc.h>
 
 #include <g4main/PHG4Hit.h>
 #include <g4main/PHG4HitContainer.h>
 #include <g4main/PHG4HitDefs.h>
 #include <g4main/PHG4Particle.h>
 #include <g4main/PHG4TruthInfoContainer.h>
 
 #include <phool/getClass.h>
 #include <phool/phool.h>
 
 #include <cassert>
 #include <cfloat>
 #include <cmath>
 #include <iostream>  // for operator<<, endl, basic_...
 #include <map>
 #include <set>
 
 class TrkrHit;
 
 SvtxHitEval::SvtxHitEval(PHCompositeNode* topNode)
   : _trutheval(topNode)
 {
   get_node_pointers(topNode);
 }
 
 SvtxHitEval::~SvtxHitEval()
 {
   if (_verbosity > 0)
   {
     if ((_errors > 0) || (_verbosity > 1))
     {
       std::cout << "SvtxHitEval::~SvtxHitEval() - Error Count: " << _errors << std::endl;
     }
   }
 }
 
 void SvtxHitEval::next_event(PHCompositeNode* topNode)
 {
   _cache_all_truth_hits.clear();
   _cache_max_truth_hit_by_energy.clear();
   _cache_all_truth_particles.clear();
   _cache_max_truth_particle_by_energy.clear();
   _cache_all_hits_from_particle.clear();
   _cache_all_hits_from_g4hit.clear();
   _cache_best_hit_from_g4hit.clear();
   _cache_get_energy_contribution_g4particle.clear();
   _cache_get_energy_contribution_g4hit.clear();
 
   _trutheval.next_event(topNode);
 
   get_node_pointers(topNode);
 }
 
 /*
 PHG4Cell* SvtxHitEval::get_cell(SvtxHit* hit)
 {
   if (!has_node_pointers())
   {
     ++_errors;
     std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     return nullptr;
   }
 
   if (_strict)
   {
     assert(hit);
   }
   else if (!hit)
   {
     ++_errors;
     std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     return nullptr;
   }
 
   // hop from reco hit to g4cell
   PHG4Cell* cell = nullptr;
   if (_g4cells_svtx) cell = _g4cells_svtx->findCell(hit->get_cellid());
   if (!cell && _g4cells_tracker) cell = _g4cells_tracker->findCell(hit->get_cellid());
   if (!cell && _g4cells_maps) cell = _g4cells_maps->findCell(hit->get_cellid());
 
   // only noise hits (cellid left at default value) should not trace
   if ((_strict) && (hit->get_cellid() != 0xFFFFFFFF))
   {
     assert(cell);
   }
   else if (!cell)
   {
     ++_errors;
     std::cout << PHWHERE << " nerr: " << _errors << std::endl;
   }
 
   return cell;
 }
 */
 
 std::set<PHG4Hit*> SvtxHitEval::all_truth_hits(TrkrDefs::hitkey hit_key)
 {
   if (!has_node_pointers())
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return std::set<PHG4Hit*>();
   }
 
   if (_strict)
   {
     assert(hit_key);
   }
   else if (!hit_key)
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return std::set<PHG4Hit*>();
   }
 
   if (_do_cache)
   {
     std::map<TrkrDefs::hitkey, std::set<PHG4Hit*> >::iterator iter =
         _cache_all_truth_hits.find(hit_key);
     if (iter != _cache_all_truth_hits.end())
     {
       return iter->second;
     }
   }
 
   std::set<PHG4Hit*> truth_hits;
 
   /*
   // hop from reco hit to g4cell
   PHG4Cell* cell = nullptr;
   if (_g4cells_svtx) cell = _g4cells_svtx->findCell(hit->get_cellid());
   if (!cell && _g4cells_tracker) cell = _g4cells_tracker->findCell(hit->get_cellid());
   if (!cell && _g4cells_maps) cell = _g4cells_maps->findCell(hit->get_cellid());
 
   // only noise hits (cellid left at default value) should not trace
   if ((_strict) && (hit->get_cellid() != 0xFFFFFFFF))
     assert(cell);
   else if (!cell)
   {
     ++_errors;
     std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     return truth_hits;
   }
 
   //std::cout << "Eval: hitid " << hit->get_id() << " cellid " << cell->get_cellid() << std::endl;
   // loop over all the g4hits in this cell
   for (PHG4Cell::EdepConstIterator g4iter = cell->get_g4hits().first;
        g4iter != cell->get_g4hits().second;
        ++g4iter)
   {
     //std::cout << "    Looking for hit " << g4iter->first << " in layer " << cell->get_layer() << " with edep " << g4iter->second << std::endl;
     PHG4Hit* g4hit = nullptr;
     if (_g4hits_svtx) g4hit = _g4hits_svtx->findHit(g4iter->first);
     if (!g4hit && _g4hits_tracker) g4hit = _g4hits_tracker->findHit(g4iter->first);
     if (!g4hit && _g4hits_maps) g4hit = _g4hits_maps->findHit(g4iter->first);
     if (!g4hit) std::cout << "    Failed to find  g4hit " << g4iter->first << " with edep " << g4iter->second << std::endl;
     if (_strict)
       assert(g4hit);
     else if (!g4hit)
     {
       ++_errors;
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
       continue;
     }
   */
 
   // get all of the g4hits for this hit_key
   // have to start with all hitsets, unfortunately
   TrkrHitSetContainer::ConstRange all_hitsets = _hitmap->getHitSets();
   for (TrkrHitSetContainer::ConstIterator iter = all_hitsets.first; iter != all_hitsets.second; ++iter)
   {
     TrkrDefs::hitsetkey hitset_key = iter->first;
     unsigned int trkrid = TrkrDefs::getTrkrId(hitset_key);
     TrkrHitSet* hitset = iter->second;
 
     // does this hitset contain our hitkey?
     TrkrHit* hit = nullptr;
     hit = hitset->getHit(hit_key);
     if (hit)
     {
       // get g4hits for this hit
 
       std::multimap<TrkrDefs::hitsetkey, std::pair<TrkrDefs::hitkey, PHG4HitDefs::keytype> > temp_map;
       _hit_truth_map->getG4Hits(hitset_key, hit_key, temp_map);  // returns pairs (hitsetkey, std::pair(hitkey, g4hitkey)) for this hitkey only
       for (auto& htiter : temp_map)
       {
         // extract the g4 hit key here and add the g4hit to the set
         PHG4HitDefs::keytype g4hitkey = htiter.second.second;
         // std::cout << "           hitkey " << hitkey <<  " g4hitkey " << g4hitkey << std::endl;
         PHG4Hit* g4hit = nullptr;
         switch (trkrid)
         {
         case TrkrDefs::tpcId:
           g4hit = _g4hits_tpc->findHit(g4hitkey);
           break;
         case TrkrDefs::inttId:
           g4hit = _g4hits_intt->findHit(g4hitkey);
           break;
         case TrkrDefs::mvtxId:
           g4hit = _g4hits_mvtx->findHit(g4hitkey);
           break;
         case TrkrDefs::micromegasId:
           g4hit = _g4hits_mms->findHit(g4hitkey);
           break;
         default:
           break;
         }
         // fill output set
         if (g4hit)
         {
           truth_hits.insert(g4hit);
         }
       }
     }
   }
 
   if (_do_cache)
   {
     _cache_all_truth_hits.insert(std::make_pair(hit_key, truth_hits));
   }
 
   return truth_hits;
 }
 
 std::set<PHG4Hit*> SvtxHitEval::all_truth_hits(TrkrDefs::hitkey hit_key, const TrkrDefs::TrkrId trkrid)
 {
   if (!has_node_pointers())
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return std::set<PHG4Hit*>();
   }
 
   if (_strict)
   {
     assert(hit_key);
   }
   else if (!hit_key)
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return std::set<PHG4Hit*>();
   }
 
   if (_do_cache)
   {
     std::map<TrkrDefs::hitkey, std::set<PHG4Hit*> >::iterator iter =
         _cache_all_truth_hits.find(hit_key);
     if (iter != _cache_all_truth_hits.end())
     {
       return iter->second;
     }
   }
 
   std::set<PHG4Hit*> truth_hits;
   TrkrHitSetContainer::ConstRange all_hitsets = _hitmap->getHitSets(trkrid);
 
   for (TrkrHitSetContainer::ConstIterator iter = all_hitsets.first; iter != all_hitsets.second; ++iter)
   {
     TrkrDefs::hitsetkey hitset_key = iter->first;
     TrkrHitSet* hitset = iter->second;
 
     // does this hitset contain our hitkey?
     TrkrHit* hit = nullptr;
     hit = hitset->getHit(hit_key);
     if (hit)
     {
       // get g4hits for this hit
 
       std::multimap<TrkrDefs::hitsetkey, std::pair<TrkrDefs::hitkey, PHG4HitDefs::keytype> > temp_map;
       _hit_truth_map->getG4Hits(hitset_key, hit_key, temp_map);  // returns pairs (hitsetkey, std::pair(hitkey, g4hitkey)) for this hitkey only
       for (auto& htiter : temp_map)
       {
         // extract the g4 hit key here and add the g4hit to the set
         PHG4HitDefs::keytype g4hitkey = htiter.second.second;
         // std::cout << "           hitkey " << hitkey <<  " g4hitkey " << g4hitkey << std::endl;
         PHG4Hit* g4hit = nullptr;
         switch (trkrid)
         {
         case TrkrDefs::tpcId:
           g4hit = _g4hits_tpc->findHit(g4hitkey);
           break;
         case TrkrDefs::inttId:
           g4hit = _g4hits_intt->findHit(g4hitkey);
           break;
         case TrkrDefs::mvtxId:
           g4hit = _g4hits_mvtx->findHit(g4hitkey);
           break;
         case TrkrDefs::micromegasId:
           g4hit = _g4hits_mms->findHit(g4hitkey);
           break;
         default:
           break;
         }
         // fill output set
         if (g4hit)
         {
           truth_hits.insert(g4hit);
         }
       }
     }
   }
 
   if (_do_cache)
   {
     _cache_all_truth_hits.insert(std::make_pair(hit_key, truth_hits));
   }
 
   return truth_hits;
 }
 
 PHG4Hit* SvtxHitEval::max_truth_hit_by_energy(TrkrDefs::hitkey hit_key)
 {
   if (!has_node_pointers())
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return nullptr;
   }
 
   if (_strict)
   {
     assert(hit_key);
   }
   else if (!hit_key)
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return nullptr;
   }
 
   if (_do_cache)
   {
     std::map<TrkrDefs::hitkey, PHG4Hit*>::iterator iter =
         _cache_max_truth_hit_by_energy.find(hit_key);
     if (iter != _cache_max_truth_hit_by_energy.end())
     {
       return iter->second;
     }
   }
 
   std::set<PHG4Hit*> hits = all_truth_hits(hit_key);
   PHG4Hit* max_hit = nullptr;
   float max_e = FLT_MAX * -1.0;
   for (auto hit : hits)
   {
     if (hit->get_edep() > max_e)
     {
       max_e = hit->get_edep();
       max_hit = hit;
     }
   }
 
   if (_do_cache)
   {
     _cache_max_truth_hit_by_energy.insert(std::make_pair(hit_key, max_hit));
   }
 
   return max_hit;
 }
 
 PHG4Hit* SvtxHitEval::max_truth_hit_by_energy(TrkrDefs::hitkey hit_key, const TrkrDefs::TrkrId trkrid)
 {
   if (!has_node_pointers())
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return nullptr;
   }
 
   if (_strict)
   {
     assert(hit_key);
   }
   else if (!hit_key)
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return nullptr;
   }
 
   if (_do_cache)
   {
     std::map<TrkrDefs::hitkey, PHG4Hit*>::iterator iter =
         _cache_max_truth_hit_by_energy.find(hit_key);
     if (iter != _cache_max_truth_hit_by_energy.end())
     {
       return iter->second;
     }
   }
 
   std::set<PHG4Hit*> hits = all_truth_hits(hit_key, trkrid);
   PHG4Hit* max_hit = nullptr;
   float max_e = FLT_MAX * -1.0;
   for (auto hit : hits)
   {
     if (hit->get_edep() > max_e)
     {
       max_e = hit->get_edep();
       max_hit = hit;
     }
   }
 
   if (_do_cache)
   {
     _cache_max_truth_hit_by_energy.insert(std::make_pair(hit_key, max_hit));
   }
 
   return max_hit;
 }
 
 std::set<PHG4Particle*> SvtxHitEval::all_truth_particles(TrkrDefs::hitkey hit_key)
 {
   if (!has_node_pointers())
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return std::set<PHG4Particle*>();
   }
 
   if (_strict)
   {
     assert(hit_key);
   }
   else if (!hit_key)
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return std::set<PHG4Particle*>();
   }
 
   if (_do_cache)
   {
     std::map<TrkrDefs::hitkey, std::set<PHG4Particle*> >::iterator iter =
         _cache_all_truth_particles.find(hit_key);
     if (iter != _cache_all_truth_particles.end())
     {
       return iter->second;
     }
   }
 
   std::set<PHG4Particle*> truth_particles;
 
   std::set<PHG4Hit*> g4hits = all_truth_hits(hit_key);
 
   for (auto g4hit : g4hits)
   {
     PHG4Particle* particle = get_truth_eval()->get_particle(g4hit);
 
     if (_strict)
     {
       assert(particle);
     }
     else if (!particle)
     {
       ++_errors;
       if (_verbosity > 0)
       {
         std::cout << PHWHERE << " nerr: " << _errors << std::endl;
       }
       continue;
     }
 
     truth_particles.insert(particle);
   }
 
   if (_do_cache)
   {
     _cache_all_truth_particles.insert(std::make_pair(hit_key, truth_particles));
   }
 
   return truth_particles;
 }
 
 std::set<PHG4Particle*> SvtxHitEval::all_truth_particles(TrkrDefs::hitkey hit_key, const TrkrDefs::TrkrId trkrid)
 {
   if (!has_node_pointers())
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return std::set<PHG4Particle*>();
   }
 
   if (_strict)
   {
     assert(hit_key);
   }
   else if (!hit_key)
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return std::set<PHG4Particle*>();
   }
 
   if (_do_cache)
   {
     std::map<TrkrDefs::hitkey, std::set<PHG4Particle*> >::iterator iter =
         _cache_all_truth_particles.find(hit_key);
     if (iter != _cache_all_truth_particles.end())
     {
       return iter->second;
     }
   }
 
   std::set<PHG4Particle*> truth_particles;
 
   std::set<PHG4Hit*> g4hits = all_truth_hits(hit_key, trkrid);
 
   for (auto g4hit : g4hits)
   {
     PHG4Particle* particle = get_truth_eval()->get_particle(g4hit);
 
     if (_strict)
     {
       assert(particle);
     }
     else if (!particle)
     {
       ++_errors;
       if (_verbosity > 0)
       {
         std::cout << PHWHERE << " nerr: " << _errors << std::endl;
       }
       continue;
     }
 
     truth_particles.insert(particle);
   }
 
   if (_do_cache)
   {
     _cache_all_truth_particles.insert(std::make_pair(hit_key, truth_particles));
   }
 
   return truth_particles;
 }
 
 PHG4Particle* SvtxHitEval::max_truth_particle_by_energy(TrkrDefs::hitkey hit_key)
 {
   if (!has_node_pointers())
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return nullptr;
   }
 
   if (_strict)
   {
     assert(hit_key);
   }
   else if (!hit_key)
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return nullptr;
   }
 
   if (_do_cache)
   {
     std::map<TrkrDefs::hitkey, PHG4Particle*>::iterator iter =
         _cache_max_truth_particle_by_energy.find(hit_key);
     if (iter != _cache_max_truth_particle_by_energy.end())
     {
       return iter->second;
     }
   }
 
   // loop over all particles associated with this hit and
   // get the energy contribution for each one, record the max
   PHG4Particle* max_particle = nullptr;
   float max_e = FLT_MAX * -1.0;
   std::set<PHG4Particle*> particles = all_truth_particles(hit_key);
   for (auto particle : particles)
   {
     float e = get_energy_contribution(hit_key, particle);
     if (e > max_e)
     {
       max_e = e;
       max_particle = particle;
     }
   }
 
   if (_do_cache)
   {
     _cache_max_truth_particle_by_energy.insert(std::make_pair(hit_key, max_particle));
   }
 
   return max_particle;
 }
 
 PHG4Particle* SvtxHitEval::max_truth_particle_by_energy(TrkrDefs::hitkey hit_key, const TrkrDefs::TrkrId trkrid)
 {
   if (!has_node_pointers())
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return nullptr;
   }
 
   if (_strict)
   {
     assert(hit_key);
   }
   else if (!hit_key)
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return nullptr;
   }
 
   if (_do_cache)
   {
     std::map<TrkrDefs::hitkey, PHG4Particle*>::iterator iter =
         _cache_max_truth_particle_by_energy.find(hit_key);
     if (iter != _cache_max_truth_particle_by_energy.end())
     {
       return iter->second;
     }
   }
 
   // loop over all particles associated with this hit and
   // get the energy contribution for each one, record the max
   PHG4Particle* max_particle = nullptr;
   float max_e = FLT_MAX * -1.0;
   std::set<PHG4Particle*> particles = all_truth_particles(hit_key, trkrid);
   for (auto particle : particles)
   {
     float e = get_energy_contribution(hit_key, particle);
     if (e > max_e)
     {
       max_e = e;
       max_particle = particle;
     }
   }
 
   if (_do_cache)
   {
     _cache_max_truth_particle_by_energy.insert(std::make_pair(hit_key, max_particle));
   }
 
   return max_particle;
 }
 
 std::set<TrkrDefs::hitkey> SvtxHitEval::all_hits_from(PHG4Particle* g4particle)
 {
   if (!has_node_pointers())
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return std::set<TrkrDefs::hitkey>();
   }
 
   if (_strict)
   {
     assert(g4particle);
   }
   else if (!g4particle)
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return std::set<TrkrDefs::hitkey>();
   }
 
   if (_do_cache)
   {
     std::map<PHG4Particle*, std::set<TrkrDefs::hitkey> >::iterator iter =
         _cache_all_hits_from_particle.find(g4particle);
     if (iter != _cache_all_hits_from_particle.end())
     {
       return iter->second;
     }
   }
 
   std::set<TrkrDefs::hitkey> hits;
 
   // loop over all the hits
   TrkrHitSetContainer::ConstRange all_hitsets = _hitmap->getHitSets();
   for (TrkrHitSetContainer::ConstIterator iter = all_hitsets.first;
        iter != all_hitsets.second;
        ++iter)
   {
     TrkrHitSet::ConstRange range = iter->second->getHits();
     for (TrkrHitSet::ConstIterator hitr = range.first; hitr != range.second; ++hitr)
     {
       TrkrDefs::hitkey hit_key = hitr->first;
 
       // loop over all truth hits connected to this hit
       std::set<PHG4Hit*> g4hits = all_truth_hits(hit_key);
       for (auto candidate : g4hits)
       {
         PHG4Particle* particle = _truthinfo->GetParticle(candidate->get_trkid());
         if (g4particle->get_track_id() == particle->get_track_id())
         {
           hits.insert(hit_key);
         }
       }
     }
   }
 
   if (_do_cache)
   {
     _cache_all_hits_from_particle.insert(std::make_pair(g4particle, hits));
   }
 
   return hits;
 }
 
 std::set<TrkrDefs::hitkey> SvtxHitEval::all_hits_from(PHG4Hit* g4hit)
 {
   if (!has_node_pointers())
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return std::set<TrkrDefs::hitkey>();
   }
 
   if (_strict)
   {
     assert(g4hit);
   }
   else if (!g4hit)
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return std::set<TrkrDefs::hitkey>();
   }
 
   if (_do_cache)
   {
     std::map<PHG4Hit*, std::set<TrkrDefs::hitkey> >::iterator iter =
         _cache_all_hits_from_g4hit.find(g4hit);
     if (iter != _cache_all_hits_from_g4hit.end())
     {
       return iter->second;
     }
   }
 
   std::set<TrkrDefs::hitkey> hits;
 
   unsigned int hit_layer = g4hit->get_layer();
 
   // loop over all the hits
   TrkrHitSetContainer::ConstRange all_hitsets = _hitmap->getHitSets();
   for (TrkrHitSetContainer::ConstIterator iter = all_hitsets.first;
        iter != all_hitsets.second;
        ++iter)
   {
     TrkrHitSet::ConstRange range = iter->second->getHits();
     for (TrkrHitSet::ConstIterator hitr = range.first; hitr != range.second; ++hitr)
     {
       TrkrDefs::hitkey hit_key = hitr->first;
 
       if (TrkrDefs::getLayer(hit_key) != hit_layer)
       {
         continue;
       }
 
       // loop over all truth hits connected to this hit
       std::set<PHG4Hit*> g4hits = all_truth_hits(hit_key);
       for (auto candidate : g4hits)
       {
         if (candidate->get_hit_id() == g4hit->get_hit_id())
         {
           hits.insert(hit_key);
         }
       }
     }
   }
 
   if (_do_cache)
   {
     _cache_all_hits_from_g4hit.insert(std::make_pair(g4hit, hits));
   }
 
   return hits;
 }
 
 TrkrDefs::hitkey SvtxHitEval::best_hit_from(PHG4Hit* g4hit)
 {
   if (!has_node_pointers())
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return 0;
   }
 
   if (_strict)
   {
     assert(g4hit);
   }
   else if (!g4hit)
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return 0;
   }
 
   if (_do_cache)
   {
     std::map<PHG4Hit*, TrkrDefs::hitkey>::iterator iter =
         _cache_best_hit_from_g4hit.find(g4hit);
     if (iter != _cache_best_hit_from_g4hit.end())
     {
       return iter->second;
     }
   }
 
   TrkrDefs::hitkey best_hit = 0;
   float best_energy = 0.0;
   std::set<TrkrDefs::hitkey> hits = all_hits_from(g4hit);
   for (unsigned int hit_key : hits)
   {
     float energy = get_energy_contribution(hit_key, g4hit);
     if (energy > best_energy)
     {
       best_hit = hit_key;
       best_energy = energy;
     }
   }
 
   if (_do_cache)
   {
     _cache_best_hit_from_g4hit.insert(std::make_pair(g4hit, best_hit));
   }
 
   return best_hit;
 }
 
 // overlap calculations
 float SvtxHitEval::get_energy_contribution(TrkrDefs::hitkey hit_key, PHG4Particle* particle)
 {
   if (!has_node_pointers())
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return NAN;
   }
 
   if (_strict)
   {
     assert(hit_key);
     assert(particle);
   }
   else if (!hit_key || !particle)
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return NAN;
   }
 
   if (_do_cache)
   {
     std::map<std::pair<TrkrDefs::hitkey, PHG4Particle*>, float>::iterator iter =
         _cache_get_energy_contribution_g4particle.find(std::make_pair(hit_key, particle));
     if (iter != _cache_get_energy_contribution_g4particle.end())
     {
       return iter->second;
     }
   }
 
   float energy = 0.0;
   std::set<PHG4Hit*> g4hits = all_truth_hits(hit_key);
   for (auto g4hit : g4hits)
   {
     if (get_truth_eval()->is_g4hit_from_particle(g4hit, particle))
     {
       energy += g4hit->get_edep();
     }
   }
 
   if (_do_cache)
   {
     _cache_get_energy_contribution_g4particle.insert(std::make_pair(std::make_pair(hit_key, particle), energy));
   }
 
   return energy;
 }
 
 float SvtxHitEval::get_energy_contribution(TrkrDefs::hitkey hit_key, PHG4Hit* g4hit)
 {
   if (!has_node_pointers())
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return NAN;
   }
 
   if (_strict)
   {
     assert(hit_key);
     assert(g4hit);
   }
   else if (!hit_key || !g4hit)
   {
     ++_errors;
     if (_verbosity > 0)
     {
       std::cout << PHWHERE << " nerr: " << _errors << std::endl;
     }
     return NAN;
   }
 
   if (_do_cache)
   {
     std::map<std::pair<TrkrDefs::hitkey, PHG4Hit*>, float>::iterator iter =
         _cache_get_energy_contribution_g4hit.find(std::make_pair(hit_key, g4hit));
     if (iter != _cache_get_energy_contribution_g4hit.end())
     {
       return iter->second;
     }
   }
 
   // this is a fairly simple existance check right now, but might be more
   // complex in the future, so this is here mostly as future-proofing.
 
   float energy = 0.0;
   std::set<PHG4Hit*> g4hits = all_truth_hits(hit_key);
   for (auto candidate : g4hits)
   {
     if (candidate->get_hit_id() != g4hit->get_hit_id())
     {
       continue;
     }
     energy += candidate->get_edep();
   }
 
   if (_do_cache)
   {
     _cache_get_energy_contribution_g4hit.insert(std::make_pair(std::make_pair(hit_key, g4hit), energy));
   }
 
   return energy;
 }
 
 void SvtxHitEval::get_node_pointers(PHCompositeNode* topNode)
 {
   // need things off of the DST...
   _hitmap = findNode::getClass<TrkrHitSetContainer>(topNode, "TRKR_HITSET");
 
   _clustermap = findNode::getClass<TrkrClusterContainer>(topNode, "CORRECTED_TRKR_CLUSTER");
   if (!_clustermap)
   {
     _clustermap = findNode::getClass<TrkrClusterContainer>(topNode, "TRKR_CLUSTER");
   }
 
   _hit_truth_map = findNode::getClass<TrkrHitTruthAssoc>(topNode, "TRKR_HITTRUTHASSOC");
 
   // need things off of the DST...
   _g4hits_tpc = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_TPC");
   _g4hits_intt = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_INTT");
   _g4hits_mvtx = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_MVTX");
   _g4hits_mms = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_MICROMEGAS");
 
   _truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode, "G4TruthInfo");
 
   return;
 }
 
 bool SvtxHitEval::has_node_pointers()
 {
   if (_strict)
   {
     assert(_hitmap);
   }
   else if (!_hitmap)
   {
     return false;
   }
 
   if (_strict)
   {
     assert(_g4hits_mms || _g4hits_tpc || _g4hits_intt || _g4hits_mvtx);
   }
   else if (!_g4hits_mms && !_g4hits_tpc && !_g4hits_intt && !_g4hits_mvtx)
   {
     std::cout << "no hits" << std::endl;
     return false;
   }
   if (_strict)
   {
     assert(_truthinfo);
   }
   else if (!_truthinfo)
   {
     std::cout << " no truth" << std::endl;
     return false;
   }
 
   return true;
 }

This page was automatically generated by the 2.3.7 LXR engine. The LXR team