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

File indexing completed on 2025-12-16 09:22:02

 #include "PHG4TruthInfoContainer.h"
 
 #include "PHG4Particle.h"
 #include "PHG4Shower.h"
 #include "PHG4VtxPoint.h"
 
 #include <algorithm>
 #include <boost/tuple/tuple.hpp>
 
 #include <limits>
 #include <string>
 
 PHG4TruthInfoContainer::~PHG4TruthInfoContainer() { Reset(); }
 
 void PHG4TruthInfoContainer::Reset()
 {
   for (auto& iter : particlemap)
   {
     delete iter.second;
   }
   particlemap.clear();
 
   for (auto& iter : sPHENIXprimaryparticlemap)
   {
     delete iter.second;
   }
   sPHENIXprimaryparticlemap.clear();
 
   for (auto& iter : vtxmap)
   {
     delete iter.second;
   }
   vtxmap.clear();
 
   for (auto& iter : showermap)
   {
     delete iter.second;
   }
   showermap.clear();
 
   particle_embed_flags.clear();
   vertex_embed_flags.clear();
 
   return;
 }
 
 void PHG4TruthInfoContainer::identify(std::ostream& os) const
 {
   os << "---particlemap--------------------------" << std::endl;
   for (auto iter : particlemap)
   {
     os << "particle id " << iter.first << std::endl;
     (iter.second)->identify();
   }
 
   os << "---vtxmap-------------------------------" << std::endl;
   for (auto vter : vtxmap)
   {
     os << "vtx id: " << vter.first << std::endl;
     (vter.second)->identify();
   }
 
   os << "---showermap-------------------------------" << std::endl;
   for (auto ster : showermap)
   {
     os << "shower id: " << ster.first << std::endl;
     (ster.second)->identify();
   }
 
   os << "---list of embeded track flags-------------------" << std::endl;
   for (auto particle_embed_flag : particle_embed_flags)
   {
     os << "embeded track id: " << particle_embed_flag.first
        << " flag: " << particle_embed_flag.second << std::endl;
   }
 
   os << "---list of embeded vtx flags-------------------" << std::endl;
   for (auto vertex_embed_flag : vertex_embed_flags)
   {
     os << "embeded vertex id: " << vertex_embed_flag.first
        << " flag: " << vertex_embed_flag.second << std::endl;
   }
 
   os << "---primary vertex-------------------" << std::endl;
   os << "Vertex " << GetPrimaryVertexIndex() << " is identified as the primary vertex" << std::endl;
 
   return;
 }
 
 PHG4TruthInfoContainer::ConstIterator
 PHG4TruthInfoContainer::AddParticle(const int trackid, PHG4Particle* newparticle)
 {
   int key = trackid;
   ConstIterator it;
   bool added = false;
   boost::tie(it, added) = particlemap.insert(std::make_pair(key, newparticle));
   if (added)
   {
     return it;
   }
 
   std::cout << "PHG4TruthInfoContainer::AddParticle"
             << " - Attempt to add particle with existing trackid "
             << trackid << ": " << newparticle->get_name() << " id "
             << newparticle->get_track_id()
             << ", p = [" << newparticle->get_px()
             << ", " << newparticle->get_py()
             << ", " << newparticle->get_pz() << "], "
             << " parent ID " << newparticle->get_parent_id()
             << std::endl;
   return particlemap.end();
 }
 
 PHG4TruthInfoContainer::ConstIterator
 PHG4TruthInfoContainer::AddsPHENIXPrimaryParticle(const int trackid, PHG4Particle* newparticle)
 {
   int key = trackid;
   ConstIterator it;
   bool added = false;
 
   boost::tie(it, added) = sPHENIXprimaryparticlemap.insert(std::make_pair(key, newparticle));
   if (added)
   {
     return it;
   }
 
   std::cout << "PHG4TruthInfoContainer::AddsPHENIXPrimaryParticle"
             << " - Attempt to add sPHENIX primary particle with existing trackid "
             << trackid << ": " << newparticle->get_name() << " id "
             << newparticle->get_track_id()
             << ", p = [" << newparticle->get_px()
             << ", " << newparticle->get_py()
             << ", " << newparticle->get_pz() << "], "
             << " parent ID " << newparticle->get_parent_id()
             << std::endl;
   return sPHENIXprimaryparticlemap.end();
 }
 
 PHG4Particle* PHG4TruthInfoContainer::GetParticle(const int trackid)
 {
   int key = trackid;
   Iterator it = particlemap.find(key);
   if (it != particlemap.end())
   {
     return it->second;
   }
   return nullptr;
 }
 
 PHG4Particle* PHG4TruthInfoContainer::GetParticle(const int trackid) const
 {
   int key = trackid;
   ConstIterator it = particlemap.find(key);
   if (it != particlemap.end())
   {
     return it->second;
   }
   return nullptr;
 }
 
 PHG4Particle* PHG4TruthInfoContainer::GetPrimaryParticle(const int trackid)
 {
   if (trackid <= 0)
   {
     return nullptr;
   }
   Iterator it = particlemap.find(trackid);
   if (it != particlemap.end())
   {
     return it->second;
   }
   return nullptr;
 }
 
 PHG4Particle* PHG4TruthInfoContainer::GetsPHENIXPrimaryParticle(const int trackid)
 {
   Iterator it = sPHENIXprimaryparticlemap.find(trackid);
   if (it != sPHENIXprimaryparticlemap.end())
   {
     return it->second;
   }
   return nullptr;
 }
 
 PHG4VtxPoint* PHG4TruthInfoContainer::GetVtx(const int vtxid)
 {
   int key = vtxid;
   VtxIterator it = vtxmap.find(key);
   if (it != vtxmap.end())
   {
     return it->second;
   }
   return nullptr;
 }
 
 PHG4VtxPoint* PHG4TruthInfoContainer::GetPrimaryVtx(const int vtxid)
 {
   if (vtxid <= 0)
   {
     return nullptr;
   }
   VtxIterator it = vtxmap.find(vtxid);
   if (it != vtxmap.end())
   {
     return it->second;
   }
   return nullptr;
 }
 
 PHG4Shower* PHG4TruthInfoContainer::GetShower(const int showerid)
 {
   int key = showerid;
   ShowerIterator it = showermap.find(key);
   if (it != showermap.end())
   {
     return it->second;
   }
   return nullptr;
 }
 
 PHG4Shower* PHG4TruthInfoContainer::GetPrimaryShower(const int showerid)
 {
   if (showerid <= 0)
   {
     return nullptr;
   }
   ShowerIterator it = showermap.find(showerid);
   if (it != showermap.end())
   {
     return it->second;
   }
   return nullptr;
 }
 
 PHG4TruthInfoContainer::ConstVtxIterator
 PHG4TruthInfoContainer::AddVertex(const int id, PHG4VtxPoint* newvtx)
 {
   int key = id;
   ConstVtxIterator it;
   bool added = false;
 
   if (vtxmap.contains(id))
   {
     std::cout << "trying to add existing vtx " << id
               << " vtx pos: " << std::endl;
     (vtxmap.find(id)->second)->identify();
     identify();
   }
 
   boost::tie(it, added) = vtxmap.insert(std::make_pair(key, newvtx));
   if (added)
   {
     newvtx->set_id(key);
     return it;
   }
 
   std::cout << "PHG4TruthInfoContainer::AddVertex"
             << " - Attempt to add vertex with existing id " << id << std::endl;
   return vtxmap.end();
 }
 
 PHG4TruthInfoContainer::ConstShowerIterator
 PHG4TruthInfoContainer::AddShower(const int id, PHG4Shower* newshower)
 {
   int key = id;
   ConstShowerIterator it;
   bool added = false;
 
   if (showermap.contains(id))
   {
     std::cout << "trying to add existing shower " << id
               << " shower pos: " << std::endl;
     (showermap.find(id)->second)->identify();
     identify();
   }
 
   boost::tie(it, added) = showermap.insert(std::make_pair(key, newshower));
   if (added)
   {
     newshower->set_id(key);
     return it;
   }
 
   std::cout << "PHG4TruthInfoContainer::AddShower"
             << " - Attempt to add shower with existing id " << id << std::endl;
   return showermap.end();
 }
 
 int PHG4TruthInfoContainer::maxtrkindex() const
 {
   int key = 0;
   if (!particlemap.empty())
   {
     key = particlemap.rbegin()->first;
   }
   key = std::max(key, 0);
   return key;
 }
 
 int PHG4TruthInfoContainer::mintrkindex() const
 {
   int key = 0;
   if (!particlemap.empty())
   {
     key = particlemap.begin()->first;
   }
   key = std::min(key, 0);
   return key;
 }
 
 int PHG4TruthInfoContainer::maxvtxindex() const
 {
   int key = 0;
   if (!vtxmap.empty())
   {
     key = vtxmap.rbegin()->first;
   }
   key = std::max(key, 0);
   return key;
 }
 
 int PHG4TruthInfoContainer::minvtxindex() const
 {
   int key = 0;
   if (!vtxmap.empty())
   {
     key = vtxmap.begin()->first;
   }
   key = std::min(key, 0);
   return key;
 }
 
 int PHG4TruthInfoContainer::maxshowerindex() const
 {
   int key = 0;
   if (!showermap.empty())
   {
     key = showermap.rbegin()->first;
   }
   key = std::max(key, 0);
   return key;
 }
 
 int PHG4TruthInfoContainer::minshowerindex() const
 {
   int key = 0;
   if (!showermap.empty())
   {
     key = showermap.begin()->first;
   }
   key = std::min(key, 0);
   return key;
 }
 
 void PHG4TruthInfoContainer::delete_particle(Iterator piter)
 {
   delete piter->second;
   particlemap.erase(piter);
   return;
 }
 
 void PHG4TruthInfoContainer::delete_particle(int trackid)
 {
   Iterator it = particlemap.find(trackid);
   if (it != particlemap.end())
   {
     delete_particle(it);
   }
 }
 
 void PHG4TruthInfoContainer::delete_vtx(VtxIterator viter)
 {
   delete viter->second;
   vtxmap.erase(viter);
   return;
 }
 
 void PHG4TruthInfoContainer::delete_vtx(int vtxid)
 {
   VtxIterator it = vtxmap.find(vtxid);
   if (it != vtxmap.end())
   {
     delete_vtx(it);
   }
 }
 
 void PHG4TruthInfoContainer::delete_shower(ShowerIterator siter)
 {
   delete siter->second;
   showermap.erase(siter);
   return;
 }
 
 int PHG4TruthInfoContainer::isEmbeded(const int trackid) const
 {
   // I think here for G4 secondarys we just check their primary's embedding ID
   int trackid_embed = trackid;
   if (trackid_embed <= 0)
   {
     const PHG4Particle* p = GetParticle(trackid_embed);
     if (p)
     {
       trackid_embed = p->get_primary_id();
     }
   }
   std::map<int, int>::const_iterator iter = particle_embed_flags.find(trackid_embed);
   if (iter == particle_embed_flags.end())
   {
     return 0;
   }
 
   return iter->second;
 }
 
 int PHG4TruthInfoContainer::isEmbededVtx(const int vtxid) const
 {
   std::map<int, int>::const_iterator iter = vertex_embed_flags.find(vtxid);
   if (iter == vertex_embed_flags.end())
   {
     return 0;
   }
 
   return iter->second;
 }
 
 bool PHG4TruthInfoContainer::is_primary_vtx(const PHG4VtxPoint* v) const
 {
   return (v->get_id() > 0);
 }
 
 bool PHG4TruthInfoContainer::is_primary(const PHG4Particle* p) const
 {
   return (p->get_track_id() > 0);
 }
 
 // this is O(log N)...
 bool PHG4TruthInfoContainer::is_sPHENIX_primary(const PHG4Particle* p) const
 {
   // sPHENIX primary particles are in the sPHENIXprimaryparticlemap
   return (sPHENIXprimaryparticlemap.contains(p->get_track_id()));
 }
 
 int PHG4TruthInfoContainer::GetPrimaryVertexIndex() const
 {
   ConstVtxRange vrange = GetPrimaryVtxRange();
 
   int highest_embedding_ID = std::numeric_limits<int>::min();
   int vtx_id_for_highest_embedding_ID = 0;
   for (auto iter = vrange.first; iter != vrange.second; ++iter)
   {
     //        std::cout <<"PHG4TruthInfoContainer::GetPrimaryVertexIndex - vertex ID "<<iter->first<<" embedding ID "<< isEmbededVtx(iter->first) <<": ";
     // iter->second->identify();
     const int embedding_ID = isEmbededVtx(iter->first);
 
     if (embedding_ID >= highest_embedding_ID)
     {
       highest_embedding_ID = embedding_ID;
       vtx_id_for_highest_embedding_ID = iter->first;
     }
   }
 
   if (highest_embedding_ID == std::numeric_limits<int>::min())
   {
     std::cout << "PHG4TruthInfoContainer::GetPrimaryVertexIndex - "
               << "WARNING: no valid primary vertex. Return an invalid ID of 0"
               << std::endl;
     return 0;
   }
 
   return vtx_id_for_highest_embedding_ID;
 }
 
 bool operator==(const PHG4TruthInfoContainer::Map::value_type& lhs, const PHG4TruthInfoContainer::Map::value_type& rhs)
 {
   return *lhs.second == *rhs.second;
 }
 
 bool operator==(const PHG4TruthInfoContainer::VtxMap::value_type& lhs, const PHG4TruthInfoContainer::VtxMap::value_type& rhs)
 {
   return *lhs.second == *rhs.second;
 }
 
 bool operator==(const PHG4TruthInfoContainer::ShowerMap::value_type& lhs, const PHG4TruthInfoContainer::ShowerMap::value_type& rhs)
 {
   return *lhs.second == *rhs.second;
 }

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