SimParticle.h

#ifndef SIMCORE_EVENT_SIMPARTICLE_H
#define SIMCORE_EVENT_SIMPARTICLE_H
 
/*~~~~~~~~~~*/
/*   ROOT   */
/*~~~~~~~~~~*/
 
/*~~~~~~~~~~~~~~~~*/
/*   C++ StdLib   */
/*~~~~~~~~~~~~~~~~*/
#include <Rtypes.h>
 
#include <functional>
#include <map>
#include <string>
#include <vector>
 
namespace ldmx {
 
class SimParticle {
 public:
  enum ProcessType {
    unknown = 0,
    annihil = 1,
    compt = 2,
    conv = 3,
    electronNuclear = 4,
    eBrem = 5,
    eIoni = 6,
    msc = 7,
    phot = 8,
    photonNuclear = 9,
    GammaToMuPair = 10,
    eDarkBrem = 11,
    Decay = 12,
    Primary = 13,
    muonNuclear = 14,
    neutronInelastic = 15,
    neutronCapture = 16,
    kaonInelastic = 17,
    pionInelastic = 18,
    protonInelastic = 19,
    // Only add additional processes to the end of this list!
  };
 
  typedef std::map<std::string, ProcessType> ProcessTypeMap;
 
  SimParticle() = default;
 
  virtual ~SimParticle() = default;
 
  void clear();
 
  friend std::ostream& operator<<(std::ostream& o, const SimParticle& d);
 
  double getEnergy() const { return energy_; }
 
  double getKineticEnergy() const { return energy_ - mass_; }
  int getPdgID() const { return pdg_id_; }
 
  int getGenStatus() const { return gen_status_; }
 
  double getTime() const { return time_; }
 
  std::vector<double> getVertex() const { return {vtx_x_, vtx_y_, vtx_z_}; }
 
  std::string getVertexVolume() const { return vertex_volume_; }
 
  std::string getInteractionMaterial() const { return interaction_material_; }
 
  std::vector<double> getEndPoint() const { return {end_x_, end_y_, end_z_}; }
 
  std::vector<double> getMomentum() const { return {px_, py_, pz_}; }
 
  double getMass() const { return mass_; }
 
  double getCharge() const { return charge_; }
 
  std::vector<int> getDaughters() const { return daughters_; }
 
  std::vector<int> getParents() const { return parents_; }
 
  void setEnergy(const double& energy) { energy_ = energy; }
 
  void setPdgID(const int& pdg_id) { pdg_id_ = pdg_id; }
 
  void setGenStatus(const int& gen_status) { gen_status_ = gen_status; }
 
  void setTime(const double& time) { time_ = time; }
 
  void setVertex(const double& vtx_x, const double& vtx_y,
                 const double& vtx_z) {
    vtx_x_ = vtx_x;
    vtx_y_ = vtx_y;
    vtx_z_ = vtx_z;
  }
 
  void setVertexVolume(const std::string& vertexVolume) {
    vertex_volume_ = vertexVolume;
  }
 
  void setInteractionMaterial(const std::string& interaction_material) {
    interaction_material_ = interaction_material;
  }
 
  void setEndPoint(const double& end_x, const double& end_y,
                   const double& end_z) {
    end_x_ = end_x;
    end_y_ = end_y;
    end_z_ = end_z;
  }
 
  void setMomentum(const double& px, const double& py, const double& pz) {
    px_ = px;
    py_ = py;
    pz_ = pz;
  }
 
  void setMass(const double& mass) { mass_ = mass; }
 
  void setCharge(const double& charge) { charge_ = charge; }
 
  void addDaughter(const int& daughter_track_id) {
    daughters_.push_back(daughter_track_id);
  }
 
  void addParent(const int& parent_track_id) {
    parents_.push_back(parent_track_id);
  }
 
  void encodeTracks(
      std::function<int(int, unsigned int, unsigned int)> encodeFunc,
      const unsigned int encoding_version, const unsigned int event_index = 0);
 
  int getProcessType() const { return process_type_; }
 
  void setProcessType(const int& process_type) { process_type_ = process_type; }
 
  void setEndPointMomentum(const double& end_px, const double& end_py,
                           const double& end_pz) {
    end_px_ = end_px;
    end_py_ = end_py;
    end_pz_ = end_pz;
  }
 
  std::vector<double> getEndPointMomentum() const {
    return {end_px_, end_py_, end_pz_};
  }
 
  static ProcessType findProcessType(std::string processName);
 
 private:
  static ProcessTypeMap createProcessTypeMap();
 
 private:
  double energy_{0};
 
  int pdg_id_{0};
 
  int gen_status_{-1};
 
  double time_{0};
 
  double vtx_x_{0};
 
  double vtx_y_{0};
 
  double vtx_z_{0};
 
  double end_x_{0};
 
  double end_y_{0};
 
  double end_z_{0};
 
  double px_{0};
 
  double py_{0};
 
  double pz_{0};
 
  double end_px_{0};
 
  double end_py_{0};
 
  double end_pz_{0};
 
  double mass_{0};
 
  double charge_{0};
 
  std::vector<int> daughters_;
 
  std::vector<int> parents_;
 
  int process_type_{-1};
 
  std::string vertex_volume_{""};
 
  std::string interaction_material_{""};
 
  static ProcessTypeMap process_map;
 
  ClassDef(SimParticle, 8);
 
};  // SimParticle
}  // namespace ldmx
 
#endif  // SIMCORE_EVENT_SIMPARTICLE_H