PHG4TruthInfoContainer.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file PHG4TruthInfoContainer.h

// Tell emacs that this is a C++ source
//  -*- C++ -*-.
#ifndef G4MAIN_PHG4TRUTHINFOCONTAINER_H
#define G4MAIN_PHG4TRUTHINFOCONTAINER_H

#include <phool/PHObject.h>

#include <iostream>
#include <iterator>  // for distance
#include <map>
#include <utility>

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();
  ~PHG4TruthInfoContainer() override;

// from PHObject
  void Reset() override;
  void identify(std::ostream& os = std::cout) const override;

  // --- particle storage ------------------------------------------------------

  ConstIterator AddParticle(const int particleid, PHG4Particle* newparticle);
  void delete_particle(Iterator piter);
  void delete_particle(int trackid);

  PHG4Particle* GetParticle(const int trackid);
  PHG4Particle* GetPrimaryParticle(const int trackid);

  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);
  void delete_vtx(int vtxid);

  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

  ClassDefOverride(PHG4TruthInfoContainer, 1)
};



bool operator==(const PHG4TruthInfoContainer::Map::value_type& lhs, const PHG4TruthInfoContainer::Map::value_type& rhs);
bool operator==(const PHG4TruthInfoContainer::VtxMap::value_type& lhs, const PHG4TruthInfoContainer::VtxMap::value_type& rhs);
bool operator==(const PHG4TruthInfoContainer::ShowerMap::value_type& lhs, const PHG4TruthInfoContainer::ShowerMap::value_type& rhs);


inline bool operator==(const PHG4TruthInfoContainer& lhs, const PHG4TruthInfoContainer& rhs)
{
  return lhs.GetMap() == rhs.GetMap() && lhs.GetVtxMap() == rhs.GetVtxMap() && lhs.GetShowerMap() == rhs.GetShowerMap();
}

inline bool operator!=(const PHG4TruthInfoContainer& lhs, const PHG4TruthInfoContainer& rhs) { return !(lhs == rhs); }

#endif