SimParticle.h

#ifndef SIMCORE_EVENT_SIMPARTICLE_H
#define SIMCORE_EVENT_SIMPARTICLE_H
 
/*~~~~~~~~~~*/
/*   ROOT   */
/*~~~~~~~~~~*/
#include "TObject.h"
 
/*~~~~~~~~~~~~~~~~*/
/*   C++ StdLib   */
/*~~~~~~~~~~~~~~~~*/
#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();
 
  void Print() const;
 
  double getEnergy() const { return energy_; }
 
  double getKineticEnergy() const { return energy_ - mass_; }
  int getPdgID() const { return pdgID_; }
 
  int getGenStatus() const { return genStatus_; }
 
  double getTime() const { return time_; }
 
  std::vector<double> getVertex() const { return {x_, y_, z_}; }
 
  std::string getVertexVolume() const { return vertexVolume_; }
 
  std::vector<double> getEndPoint() const { return {endX_, endY_, endZ_}; }
 
  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& pdgID) { pdgID_ = pdgID; }
 
  void setGenStatus(const int& genStatus) { genStatus_ = genStatus; }
 
  void setTime(const double& time) { time_ = time; }
 
  void setVertex(const double& x, const double& y, const double& z) {
    x_ = x;
    y_ = y;
    z_ = z;
  }
 
  void setVertexVolume(const std::string& vertexVolume) {
    vertexVolume_ = vertexVolume;
  }
 
  void setEndPoint(const double& endX, const double& endY, const double& endZ) {
    endX_ = endX;
    endY_ = endY;
    endZ_ = endZ;
  }
 
  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& daughterTrackID) {
    daughters_.push_back(daughterTrackID);
  }
 
  void addParent(const int& parentTrackID) {
    parents_.push_back(parentTrackID);
  }
 
  int getProcessType() const { return processType_; }
 
  void setProcessType(const int& processType) { processType_ = processType; }
 
  void setEndPointMomentum(const double& endpx, const double& endpy,
                           const double& endpz) {
    endpx_ = endpx;
    endpy_ = endpy;
    endpz_ = endpz;
  }
 
  std::vector<double> getEndPointMomentum() const {
    return {endpx_, endpy_, endpz_};
  }
 
  static ProcessType findProcessType(std::string processName);
 
 private:
  static ProcessTypeMap createProcessTypeMap();
 
 private:
  double energy_{0};
 
  int pdgID_{0};
 
  int genStatus_{-1};
 
  double time_{0};
 
  double x_{0};
 
  double y_{0};
 
  double z_{0};
 
  double endX_{0};
 
  double endY_{0};
 
  double endZ_{0};
 
  double px_{0};
 
  double py_{0};
 
  double pz_{0};
 
  double endpx_{0};
 
  double endpy_{0};
 
  double endpz_{0};
 
  double mass_{0};
 
  double charge_{0};
 
  std::vector<int> daughters_;
 
  std::vector<int> parents_;
 
  int processType_{-1};
 
  std::string vertexVolume_{""};
 
  static ProcessTypeMap PROCESS_MAP;
 
  ClassDef(SimParticle, 7);
 
};  // SimParticle
}  // namespace ldmx
 
#endif  // SIMCORE_EVENT_SIMPARTICLE_H