SimCalorimeterHit.h

Go to the documentation of this file.

 
#ifndef SIMCORE_EVENT_SIMCALORIMETERHIT_H_
#define SIMCORE_EVENT_SIMCALORIMETERHIT_H_
 
// ROOT
#include "TObject.h"  //For ClassDef
 
// LDMX
#include "SimCore/Event/SimParticle.h"
 
namespace ldmx {
 
class SimCalorimeterHit {
 public:
  static const std::string ECAL_COLLECTION;
 
  static const std::string HCAL_COLLECTION;
 
  struct Contrib {
    int incident_id_{-1};
 
    int track_id_{-1};
 
    int pdg_code_{0};
 
    float edep_{0};
 
    float time_{0};
 
    int origin_id_{-1};
  };
 
  SimCalorimeterHit() = default;
 
  virtual ~SimCalorimeterHit() = default;
 
  void clear();
 
  friend std::ostream &operator<<(std::ostream &o, const SimCalorimeterHit &d);
 
  /*
   * Print out a contributor.
   */
  friend std::ostream &operator<<(std::ostream &o,
                                  const SimCalorimeterHit::Contrib &contrib);
 
  int getID() const { return id_; }
 
  void setID(const int id) { this->id_ = id; }
 
  float getEdep() const { return edep_; }
 
  void setEdep(const float edep) { this->edep_ = edep; }
 
  std::vector<float> getPosition() const { return {x_, y_, z_}; }
 
  std::vector<float> getPreStepPosition() const {
    return {pre_step_x_, pre_step_y_, pre_step_z_};
  }
  std::vector<float> getPostStepPosition() const {
    return {post_step_x_, post_step_y_, post_step_z_};
  }
  void setPosition(const float x, const float y, const float z) {
    this->x_ = x;
    this->y_ = y;
    this->z_ = z;
  }
  void setPreStepPosition(const float x, const float y, const float z) {
    pre_step_x_ = x;
    pre_step_y_ = y;
    pre_step_z_ = z;
  }
  void setPostStepPosition(const float x, const float y, const float z) {
    post_step_x_ = x;
    post_step_y_ = y;
    post_step_z_ = z;
  }
 
  void setPathLength(const float length) { path_length_ = length; }
  float getPathLength() const { return path_length_; }
  void setPreStepTime(const float time) { pre_step_time_ = time; }
  void setPostStepTime(const float time) { post_step_time_ = time; }
 
  void setVelocity(float velocity) { velocity_ = velocity; }
 
  float getTime() const { return time_; }
  float getPreStepTime() const { return pre_step_time_; }
  float getPostStepTime() const { return post_step_time_; }
 
  float getVelocity() const { return velocity_; }
 
  void setTime(const float time) { this->time_ = time; }
 
  unsigned getNumberOfContribs() const { return n_contribs_; }
 
  void addContrib(int incidentID, int trackID, int pdgCode, float edep,
                  float time, int originID = -1);
 
  Contrib getContrib(int i) const;
 
  int findContribIndex(int trackID, int pdgCode) const;
 
  void updateContrib(int i, float edep, float time);
 
  bool operator<(const SimCalorimeterHit &rhs) const {
    return this->getTime() < rhs.getTime();
  }
 
  std::vector<int> getTrackIds() const { return track_id_contribs_; }
  std::vector<int> getIncidentIds() const { return incident_id_contribs_; }
 
  std::vector<int> getPdgIds() const { return pdg_code_contribs_; }
 
  std::vector<float> getEdeps() const { return edep_contribs_; }
 
  std::vector<float> getTimes() const { return time_contribs_; }
 
 private:
  int id_{0};
 
  float edep_{0};
 
  float x_{0};
 
  float y_{0};
 
  float z_{0};
 
  float time_{0};
 
  std::vector<int> track_id_contribs_;
 
  std::vector<int> incident_id_contribs_;
 
  std::vector<int> pdg_code_contribs_;
 
  std::vector<float> edep_contribs_;
 
  std::vector<float> time_contribs_;
 
  std::vector<int> origin_contribs_;
 
  unsigned n_contribs_{0};
 
  /*
   * Parameters used only for hits corresponding to a single interactions
   * (currently Hcal and TS).
   */
 
  float path_length_{-1};
 
  float pre_step_x_{0};
  float pre_step_y_{0};
  float pre_step_z_{0};
  float pre_step_time_{0};
  float post_step_x_{0};
  float post_step_y_{0};
  float post_step_z_{0};
  float post_step_time_{0};
 
  float velocity_{-1};
 
  ClassDef(SimCalorimeterHit, 8);
};
}  // namespace ldmx
 
#endif