Measurement.h

#pragma once
 
//~~ StdLib ~~//
#include <array>
#include <limits>
 
#include "SimCore/Event/SimTrackerHit.h"
 
//~~ ROOT ~~//
#include "TObject.h"  // Needed for ClassDef, ClassImp
 
namespace ldmx {
class Measurement {
 public:
  Measurement() = default;
 
  Measurement(const ldmx::SimTrackerHit& hit, const float& cov_uu = 0.05,
              const float& cov_vv = 1.0);
 
  virtual ~Measurement() = default;
 
  void setGlobalPosition(const float& meas_x, const float& meas_y,
                         const float& meas_z) {
    meas_x_ = meas_x;
    meas_y_ = meas_y;
    meas_z_ = meas_z;
  };
 
  [[nodiscard]] std::array<float, 3> getGlobalPosition() const {
    return std::array<float, 3>{meas_x_, meas_y_, meas_z_};
  };
 
  void setLocalPosition(const float& meas_u, const float& meas_v) {
    meas_u_ = meas_u;
    meas_v_ = meas_v;
  };
 
  [[nodiscard]] std::array<float, 2> getLocalPosition() const {
    return std::array<float, 2>{meas_u_, meas_v_};
  };
 
  void setLocalCovariance(const float& cov_uu, const float& cov_vv) {
    cov_uu_ = cov_uu;
    cov_vv_ = cov_vv;
  }
 
  [[nodiscard]] std::array<float, 2> getLocalCovariance() const {
    return std::array<float, 2>{cov_uu_, cov_vv_};
  };
 
  void setTime(const float& meas_t) { meas_t_ = meas_t; };
 
  [[nodiscard]] float getTime() const { return meas_t_; };
 
  void setLayerID(const int& layer_id) {
    layer_id_ = layer_id;
    layer_ = ((layer_id_ / 100) % 10 - 1) * 2 + layer_id % 2;
  };
 
  [[nodiscard]] int getLayerID() const { return layer_id_; };
 
  int getLayer() const { return layer_; }
 
  void addTrackId(int trk_id) { track_ids_.push_back(trk_id); };
  std::vector<unsigned int> getTrackIds() const { return track_ids_; };
 
  float getEdep() const { return edep_; };
 
  void setEdep(float e) { edep_ = e; };
 
  // --- Truth local position (set by DigitizationProcessor before digitization)
  // ---
 
  void setTruthU(float u) { truth_u_ = u; }
  float getTruthU() const { return truth_u_; }
 
  // --- Cluster metadata (set by StripClusterProcessor; default -1/0 otherwise)
  // ---
 
  void setNStrips(int n) { n_strips_ = n; }
  int getNStrips() const { return n_strips_; }
 
  void setClusterAmplitude(float amp) { cluster_amplitude_ = amp; }
  float getClusterAmplitude() const { return cluster_amplitude_; }
 
  friend std::ostream& operator<<(std::ostream& output,
                                  const Measurement& measurement);
 
 private:
  float meas_x_{0.};
  float meas_y_{0.};
  float meas_z_{0.};
  float meas_t_{0.};
  float meas_u_{0.};
  float meas_v_{0.};
  int layer_id_{0};
  int layer_{0};
  float edep_{0.};
  float cov_uu_{0.};
  float cov_vv_{0.};
  int id_{0};
  std::vector<unsigned int> track_ids_{};
 
  float truth_u_{std::numeric_limits<float>::quiet_NaN()};
 
  int n_strips_{-1};
  float cluster_amplitude_{0};
 
  ClassDef(Measurement, 3);
};  // Measurement
 
typedef std::vector<Measurement> Measurements;
// typedef std::vector<std::reference_wrapper<const Measurement>> Measurements;
 
}  // namespace ldmx