Measurement.h

#pragma once
 
//~~ StdLib ~~//
#include <array>
 
#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& x, const float& y, const float& z) {
    x_ = x;
    y_ = y;
    z_ = z;
  };
 
  [[nodiscard]] std::array<float, 3> getGlobalPosition() const {
    return std::array<float, 3>{x_, y_, z_};
  };
 
  void setLocalPosition(const float& u, const float& v) {
    u_ = u;
    v_ = v;
  };
 
  [[nodiscard]] std::array<float, 2> getLocalPosition() const {
    return std::array<float, 2>{u_, 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& t) { t_ = t; };
 
  [[nodiscard]] float getTime() const { return t_; };
 
  void setLayerID(const int& layerid) {
    layerid_ = layerid;
    layer_ = ((layerid_ / 100) % 10 - 1) * 2 + layerid % 2;
  };
 
  [[nodiscard]] int getLayerID() const { return layerid_; };
 
  int getLayer() const { return layer_; }
 
  void addTrackId(int trkId) { trackIds_.push_back(trkId); };
  std::vector<unsigned int> getTrackIds() { return trackIds_; };
 
  friend std::ostream& operator<<(std::ostream& output,
                                  const Measurement& measurement);
 
 private:
  float x_{0.};
  float y_{0.};
  float z_{0.};
  float t_{0.};
  float u_{0.};
  float v_{0.};
  int layerid_{0};
  int layer_{0};
  float edep_{0.};
  float cov_uu_{0.};
  float cov_vv_{0.};
  int id_{0};
  std::vector<unsigned int> trackIds_{};
 
  ClassDef(Measurement, 1);
};  // Measurement
 
typedef std::vector<Measurement> Measurements;
// typedef std::vector<std::reference_wrapper<const Measurement>> Measurements;
 
}  // namespace ldmx