PHG4TruthInfoContainer.h

Go to the documentation of this file.

#ifndef PHG4TRUTHINFOCONTAINER_H__
#define PHG4TRUTHINFOCONTAINER_H__

#include <phool/PHObject.h>

#include <map>
#include <set>

class PHG4Shower;
class PHG4Particle;
class PHG4VtxPoint;

class PHG4TruthInfoContainer: public PHObject {
  
public:

  typedef std::map<int,PHG4Particle *> Map;
  typedef Map::iterator Iterator;
  typedef Map::const_iterator ConstIterator;
  typedef std::pair<Iterator, Iterator> Range;
  typedef std::pair<ConstIterator, ConstIterator> ConstRange;

  typedef std::map<int,PHG4VtxPoint *> VtxMap;
  typedef VtxMap::iterator VtxIterator;
  typedef VtxMap::const_iterator ConstVtxIterator;
  typedef std::pair<VtxIterator, VtxIterator> VtxRange;
  typedef std::pair<ConstVtxIterator, ConstVtxIterator> ConstVtxRange;

  typedef std::map<int,PHG4Shower *> ShowerMap;
  typedef ShowerMap::iterator ShowerIterator;
  typedef ShowerMap::const_iterator ConstShowerIterator;
  typedef std::pair<ShowerIterator, ShowerIterator> ShowerRange;
  typedef std::pair<ConstShowerIterator, ConstShowerIterator> ConstShowerRange;

  PHG4TruthInfoContainer();
  virtual ~PHG4TruthInfoContainer();

  void Reset();
  void identify(std::ostream& os = std::cout) const;

  // --- particle storage ------------------------------------------------------
 
  ConstIterator AddParticle(const int particleid, PHG4Particle* newparticle);
  void delete_particle(Iterator piter); 
  
  PHG4Particle* GetParticle(const int particleid);
  PHG4Particle* GetPrimaryParticle(const int particleid);

  bool is_primary(const PHG4Particle* p) const;
  
  Range GetParticleRange() {return Range(particlemap.begin(),particlemap.end());}
  ConstRange GetParticleRange() const {return ConstRange(particlemap.begin(),particlemap.end());}

  Range GetPrimaryParticleRange() {return Range(particlemap.upper_bound(0),particlemap.end());}
  ConstRange GetPrimaryParticleRange() const {return ConstRange(particlemap.upper_bound(0),particlemap.end());}

  Range GetSecondaryParticleRange() {return Range(particlemap.begin(),particlemap.upper_bound(0));}
  ConstRange GetSecondaryParticleRange() const {return ConstRange(particlemap.begin(),particlemap.upper_bound(0));}

  unsigned int size( void ) const {return particlemap.size();}
  int GetNumPrimaryVertexParticles() {
    return std::distance(particlemap.upper_bound(0),particlemap.end());
  }
  
  const Map& GetMap() const {return particlemap;}
  
  int maxtrkindex() const;
  int mintrkindex() const;

  std::pair< std::map<int,int>::const_iterator,
             std::map<int,int>::const_iterator > GetEmbeddedTrkIds() const {
    return std::make_pair(particle_embed_flags.begin(), particle_embed_flags.end());
  }

  void AddEmbededTrkId(const int id, const int flag) {
    particle_embed_flags.insert(std::make_pair(id,flag));
  }

  int isEmbeded(const int trackid) const;
   
  // --- vertex storage --------------------------------------------------------
  
  ConstVtxIterator AddVertex(const int vtxid, PHG4VtxPoint* vertex);
  void delete_vtx(VtxIterator viter);
  
  PHG4VtxPoint* GetVtx(const int vtxid);
  PHG4VtxPoint* GetPrimaryVtx(const int vtxid);

  bool is_primary_vtx(const PHG4VtxPoint* v) const;
  
  VtxRange GetVtxRange() {return VtxRange(vtxmap.begin(),vtxmap.end());}
  ConstVtxRange GetVtxRange() const {return ConstVtxRange(vtxmap.begin(),vtxmap.end());}

  VtxRange GetPrimaryVtxRange() {return VtxRange(vtxmap.upper_bound(0),vtxmap.end());}
  ConstVtxRange GetPrimaryVtxRange() const {return ConstVtxRange(vtxmap.upper_bound(0),vtxmap.end());}

  VtxRange GetSecondaryVtxRange() {return VtxRange(vtxmap.begin(),vtxmap.upper_bound(0));}
  ConstVtxRange GetSecondaryVtxRange() const {return ConstVtxRange(vtxmap.begin(),vtxmap.upper_bound(0));}
  
  unsigned int GetNumVertices() const {return vtxmap.size();}

  const VtxMap& GetVtxMap() const {return vtxmap;}

  int maxvtxindex() const;
  int minvtxindex() const;

  int GetPrimaryVertexIndex() const;

  std::pair< std::map<int,int>::const_iterator,
             std::map<int,int>::const_iterator > GetEmbeddedVtxIds() const {
    return std::make_pair(vertex_embed_flags.begin(), vertex_embed_flags.end());
  }

  void AddEmbededVtxId(const int id, const int flag) {
    vertex_embed_flags.insert(std::make_pair(id,flag));
  }

  int isEmbededVtx(const int vtxid) const;

  // --- shower storage ------------------------------------------------------
 
  ConstShowerIterator AddShower(const int showerid, PHG4Shower* newshower);
  void delete_shower(ShowerIterator piter); 
  
  PHG4Shower* GetShower(const int showerid);
  PHG4Shower* GetPrimaryShower(const int showerid);

  ShowerRange GetShowerRange() {return ShowerRange(showermap.begin(),showermap.end());}
  ConstShowerRange GetShowerRange() const {return ConstShowerRange(showermap.begin(),showermap.end());}

  ShowerRange GetPrimaryShowerRange() {return ShowerRange(showermap.upper_bound(0),showermap.end());}
  ConstShowerRange GetPrimaryShowerRange() const {return ConstShowerRange(showermap.upper_bound(0),showermap.end());}

  ShowerRange GetSecondaryShowerRange() {return ShowerRange(showermap.begin(),showermap.upper_bound(0));}
  ConstShowerRange GetSecondaryShowerRange() const {return ConstShowerRange(showermap.begin(),showermap.upper_bound(0));}
  
  unsigned int shower_size( void ) const {return showermap.size();}
  
  const ShowerMap& GetShowerMap() const {return showermap;}
  
  int maxshowerindex() const;
  int minshowerindex() const;

 private:

  Map particlemap;

  VtxMap vtxmap;

  ShowerMap showermap;

  // embed flag storage, will typically be set for only a few entries or none at all
  std::map< int, int> particle_embed_flags; //< trackid => embed flag
  std::map< int, int> vertex_embed_flags;   //< vtxid => embed flag

  ClassDef(PHG4TruthInfoContainer,1)
};

#endif