PFCandidate.h

Go to the documentation of this file.

 
#ifndef RECON_EVENT_PFCANDIDATE_H_
#define RECON_EVENT_PFCANDIDATE_H_
 
// ROOT
#include <Rtypes.h>  // For ClassDef
 
#include <vector>
 
namespace ldmx {
 
class PFCandidate {
 public:
  PFCandidate() = default;
  virtual ~PFCandidate() {}
 
  friend std::ostream& operator<<(std::ostream& o, const PFCandidate& d);
 
  bool operator<(const PFCandidate& rhs) const {
    return this->getEnergy() < rhs.getEnergy();
  }
 
  /*
     Setters
   */
  // detector bitmask: 1 track, 2 Ecal, 4 Hcal
  void setPID(int x_) { pid_ = x_; }
  // PF type as a signed PDG ID, as in CMS: 11 e, 13 mu, 22 gamma,
  // 211 charged hadron, 130 neutral hadron; see getMass for the hypothesis
  void setPdgId(int x_) { pdg_id_ = x_; }
  void setCharge(int x_) { charge_ = x_; }
  // tracker dE/dx estimate of the charged track
  void setDeDxMassSquared(float x_) { dedx_mass2_ = x_; }
  void setDeDxIh(float x_) { dedx_ih_ = x_; }
  void setDeDxNhits(int x_) { dedx_nhits_ = x_; }
  // mass hypothesis used for the energy [MeV]
  void setMass(float x_) { mass_ = x_; }
  void setEnergy(float x_) { energy_ = x_; }
 
  void setTargetPositionXYZ(float x_, float y_, float z_) {
    pos_targ_x_ = x_;
    pos_targ_y_ = y_;
    pos_targ_z_ = z_;
  }
  void setEcalPositionXYZ(float x_, float y_, float z_) {
    pos_ecal_x_ = x_;
    pos_ecal_y_ = y_;
    pos_ecal_z_ = z_;
  }
  void setHcalPositionXYZ(float x_, float y_, float z_) {
    pos_hcal_x_ = x_;
    pos_hcal_y_ = y_;
    pos_hcal_z_ = z_;
  }
  void setTrackPxPyPz(float x_, float y_, float z_) {
    track_px_ = x_;
    track_py_ = y_;
    track_pz_ = z_;
  }
  // associate component indices to the pf candidate
  void setTrackIndex(int x) { track_idx_ = x; }
  void setEcalIndex(int x) { ecal_idx_ = x; }
  void setHcalIndex(int x) { hcal_idx_ = x; }
 
  void setEcalEnergy(float x_) { ecal_energy_ = x_; }
  // rec hits behind the candidate with the raw energy it owns of each; a hit
  // shared by Ecal clusters is listed in each candidate with its share
  void clearEcalHits() {
    ecal_hit_ids_.clear();
    ecal_hit_energies_.clear();
  }
  void clearHcalHits() {
    hcal_hit_ids_.clear();
    hcal_hit_energies_.clear();
  }
  void addEcalHits(const std::vector<unsigned int>& ids,
                   const std::vector<float>& energies) {
    addHits(ecal_hit_ids_, ecal_hit_energies_, ids, energies);
  }
  void addHcalHits(const std::vector<unsigned int>& ids,
                   const std::vector<float>& energies) {
    addHits(hcal_hit_ids_, hcal_hit_energies_, ids, energies);
  }
  // energy-weighted mean depth behind the Ecal front [mm]
  void setEcalDepth(float x_) { ecal_depth_ = x_; }
  // energy-weighted RMS distance of the hits from the track line [mm]
  void setEcalWidth(float x_) { ecal_width_ = x_; }
  void setEcalRawEnergy(float x_) { ecal_raw_energy_ = x_; }
  void setEcalClusterXYZ(float x_, float y_, float z_) {
    ecal_cluster_x_ = x_;
    ecal_cluster_y_ = y_;
    ecal_cluster_z_ = z_;
  }
  void setEcalClusterEXYZ(float x_, float y_, float z_) {
    ecal_cluster_ex_ = x_;
    ecal_cluster_ey_ = y_;
    ecal_cluster_ez_ = z_;
  }
  void setEcalClusterDXDZ(float x_) { ecal_cluster_dxdz_ = x_; }
  void setEcalClusterDYDZ(float x_) { ecal_cluster_dydz_ = x_; }
  void setEcalClusterEDXDZ(float x_) { ecal_cluster_edxdz_ = x_; }
  void setEcalClusterEDYDZ(float x_) { ecal_cluster_edydz_ = x_; }
 
  void setHcalEnergy(float x_) { hcal_energy_ = x_; }
  void setHcalRawEnergy(float x_) { hcal_raw_energy_ = x_; }
  void setHcalClusterXYZ(float x_, float y_, float z_) {
    hcal_cluster_x_ = x_;
    hcal_cluster_y_ = y_;
    hcal_cluster_z_ = z_;
  }
  void setHcalClusterEXYZ(float x_, float y_, float z_) {
    hcal_cluster_ex_ = x_;
    hcal_cluster_ey_ = y_;
    hcal_cluster_ez_ = z_;
  }
  void setHcalClusterDXDZ(float x_) { hcal_cluster_dxdz_ = x_; }
  void setHcalClusterDYDZ(float x_) { hcal_cluster_dydz_ = x_; }
  void setHcalClusterEDXDZ(float x_) { hcal_cluster_edxdz_ = x_; }
  void setHcalClusterEDYDZ(float x_) { hcal_cluster_edydz_ = x_; }
 
  void setTruthEcalXYZ(double x_, double y_, double z_) {
    truth_ecal_x_ = x_;
    truth_ecal_y_ = y_;
    truth_ecal_z_ = z_;
  }
  void setTruthPxPyPz(double x_, double y_, double z_) {
    truth_px_ = x_;
    truth_py_ = y_;
    truth_pz_ = z_;
  }
  void setTruthMass(double x_) { truth_mass_ = x_; }
  void setTruthEnergy(double x_) { truth_energy_ = x_; }
  void setTruthPdgId(int x_) { truth_pdg_id_ = x_; }
  void setTruthTrackId(int x_) { truth_track_id_ = x_; }
 
  /*
     Getters
   */
  int getPID() const { return pid_; }
  int getPdgId() const { return pdg_id_; }
  int getCharge() const { return charge_; }
  float getDeDxMassSquared() const { return dedx_mass2_; }
  float getDeDxIh() const { return dedx_ih_; }
  int getDeDxNhits() const { return dedx_nhits_; }
  float getMass() const { return mass_; }
  float getEnergy() const { return energy_; }
 
  std::vector<float> getTargetPositionXYZ() const {
    return {pos_targ_x_, pos_targ_y_, pos_targ_z_};
  }
  std::vector<float> getEcalPositionXYZ() const {
    return {pos_ecal_x_, pos_ecal_y_, pos_ecal_z_};
  }
  std::vector<float> getHcalPositionXYZ() const {
    return {pos_hcal_x_, pos_hcal_y_, pos_hcal_z_};
  }
  // associate component indices to the pf candidate
  int getTrackIndex() const { return track_idx_; }
  int getEcalIndex() const { return ecal_idx_; }
  int getHcalIndex() const { return hcal_idx_; }
 
  std::vector<float> getTrackPxPyPz() const {
    return {track_px_, track_py_, track_pz_};
  }
 
  float getEcalEnergy() const { return ecal_energy_; }
  const std::vector<unsigned int>& getEcalHitIds() const {
    return ecal_hit_ids_;
  }
  const std::vector<float>& getEcalHitEnergies() const {
    return ecal_hit_energies_;
  }
  const std::vector<unsigned int>& getHcalHitIds() const {
    return hcal_hit_ids_;
  }
  const std::vector<float>& getHcalHitEnergies() const {
    return hcal_hit_energies_;
  }
  float getEcalDepth() const { return ecal_depth_; }
  float getEcalWidth() const { return ecal_width_; }
  float getEcalRawEnergy() const { return ecal_raw_energy_; }
  std::vector<float> getEcalClusterXYZ() const {
    return {ecal_cluster_x_, ecal_cluster_y_, ecal_cluster_z_};
  }
  std::vector<float> getEcalClusterEXYZ() const {
    return {ecal_cluster_ex_, ecal_cluster_ey_, ecal_cluster_ez_};
  }
  float getEcalClusterDXDZ() const { return ecal_cluster_dxdz_; }
  float getEcalClusterDYDZ() const { return ecal_cluster_dydz_; }
  float getEcalClusterEDXDZ() const { return ecal_cluster_edxdz_; }
  float getEcalClusterEDYDZ() const { return ecal_cluster_edydz_; }
 
  float getHcalEnergy() const { return hcal_energy_; }
  float getHcalRawEnergy() const { return hcal_raw_energy_; }
  std::vector<float> getHcalClusterXYZ() const {
    return {hcal_cluster_x_, hcal_cluster_y_, hcal_cluster_z_};
  }
  std::vector<float> getHcalClusterEXYZ() const {
    return {hcal_cluster_ex_, hcal_cluster_ey_, hcal_cluster_ez_};
  }
  float getHcalClusterDXDZ() const { return hcal_cluster_dxdz_; }
  float getHcalClusterDYDZ() const { return hcal_cluster_dydz_; }
  float getHcalClusterEDXDZ() const { return hcal_cluster_edxdz_; }
  float getHcalClusterEDYDZ() const { return hcal_cluster_edydz_; }
 
  std::vector<double> const getTruthEcalXYZ() {
    return {truth_ecal_x_, truth_ecal_y_, truth_ecal_z_};
  }
  std::vector<double> const getTruthPxPyPz() {
    return {truth_px_, truth_py_, truth_pz_};
  }
  double getTruthMass() { return truth_mass_; }
  double getTruthEnergy() { return truth_energy_; }
  int getTruthPdgId() { return truth_pdg_id_; }
  int getTruthTrackId() const { return truth_track_id_; }
 
 private:
  /* Particle ID enum */
  int pid_{0};
  /* Reconstructed particle type and charge */
  int pdg_id_{0};
  int charge_{0};
  /* Tracker dE/dx, nhits 0 when not available */
  float dedx_mass2_{0};
  float dedx_ih_{0};
  int dedx_nhits_{0};
  float mass_{0};
  float energy_{0};
 
  /* Position at the Target */
  float pos_targ_x_{0};
  float pos_targ_y_{0};
  float pos_targ_z_{0};
  /* Position at the ECal face */
  float pos_ecal_x_{0};
  float pos_ecal_y_{0};
  float pos_ecal_z_{0};
  /* Position at the HCal face */
  float pos_hcal_x_{0};
  float pos_hcal_y_{0};
  float pos_hcal_z_{0};
 
  /* track momenta */
  float track_px_{0};
  float track_py_{0};
  float track_pz_{0};
 
  /* Ecal energy, cluster info */
  float ecal_energy_{0};
  float ecal_depth_{0};
  /* Rec hits used and the raw energy owned of each [MeV] */
  std::vector<unsigned int> ecal_hit_ids_;
  std::vector<float> ecal_hit_energies_;
  std::vector<unsigned int> hcal_hit_ids_;
  std::vector<float> hcal_hit_energies_;
 
  /* append hits, summing the energy of ids already listed */
  static void addHits(std::vector<unsigned int>& ids, std::vector<float>& es,
                      const std::vector<unsigned int>& new_ids,
                      const std::vector<float>& new_es);
  float ecal_width_{0};
  float ecal_raw_energy_{0};
  float ecal_cluster_x_{0};
  float ecal_cluster_y_{0};
  float ecal_cluster_z_{0};
  float ecal_cluster_ex_{0};
  float ecal_cluster_ey_{0};
  float ecal_cluster_ez_{0};
  float ecal_cluster_dxdz_{0};
  float ecal_cluster_dydz_{0};
  float ecal_cluster_edxdz_{0};
  float ecal_cluster_edydz_{0};
 
  /* Hcal energy, cluster info */
  float hcal_energy_{0};
  float hcal_raw_energy_{0};
  float hcal_cluster_x_{0};
  float hcal_cluster_y_{0};
  float hcal_cluster_z_{0};
  float hcal_cluster_ex_{0};
  float hcal_cluster_ey_{0};
  float hcal_cluster_ez_{0};
  float hcal_cluster_dxdz_{0};
  float hcal_cluster_dydz_{0};
  float hcal_cluster_edxdz_{0};
  float hcal_cluster_edydz_{0};
 
  /* Information for truth matched particles */
  double truth_ecal_x_{0};
  double truth_ecal_y_{0};
  double truth_ecal_z_{0};
  double truth_px_{0};
  double truth_py_{0};
  double truth_pz_{0};
  double truth_mass_{0};
  double truth_energy_{0};
  int truth_pdg_id_{0};
  int truth_track_id_{-1};
 
  /* Indices of the components making up the PFlow object */
  int track_idx_{-1};
  int ecal_idx_{-1};
  int hcal_idx_{-1};
 
  /* The ROOT class definition. */
  ClassDef(PFCandidate, 4);
};
}  // namespace ldmx
 
#endif /* RECON_EVENT_PFCANDIDATE_H_ */