WorkingCluster.h

Go to the documentation of this file.

 
#ifndef RECON_WORKINGCLUSTER_H_
#define RECON_WORKINGCLUSTER_H_
 
#include <vector>
 
namespace recon {
 
template <class HitType>
class WorkingCluster {
 public:
  WorkingCluster() = default;
 
  WorkingCluster(const HitType* hit) {
    if (hit) {
      add(hit);
    }
  }
 
  WorkingCluster(const HitType& hit) { add(hit); }
 
  ~WorkingCluster() = default;
 
  void add(const HitType* hit) {
    if (!hit) return;
 
    double hit_e = hit->getEnergy();
    double hit_x = hit->getXPos();
    double hit_y = hit->getYPos();
    double hit_z = hit->getZPos();
    double hit_t = hit->getTime();
 
    double new_e = hit_e + centroid_e_;
    if (new_e > 0) {
      centroid_x_ = (centroid_x_ * centroid_e_ + hit_e * hit_x) / new_e;
      centroid_y_ = (centroid_y_ * centroid_e_ + hit_e * hit_y) / new_e;
      centroid_z_ = (centroid_z_ * centroid_e_ + hit_e * hit_z) / new_e;
    }
    centroid_e_ = new_e;
 
    // Track the latest time
    if (hit_t > time_) {
      time_ = hit_t;
    }
 
    hits_.push_back(hit);
  }
 
  void add(const HitType& hit) { add(&hit); }
 
  void add(const HitType* hit, double x, double y, double z) {
    if (!hit) return;
 
    double hit_e = hit->getEnergy();
    double hit_t = hit->getTime();
 
    double new_e = hit_e + centroid_e_;
    if (new_e > 0) {
      centroid_x_ = (centroid_x_ * centroid_e_ + hit_e * x) / new_e;
      centroid_y_ = (centroid_y_ * centroid_e_ + hit_e * y) / new_e;
      centroid_z_ = (centroid_z_ * centroid_e_ + hit_e * z) / new_e;
    }
    centroid_e_ = new_e;
 
    if (hit_t > time_) {
      time_ = hit_t;
    }
 
    hits_.push_back(hit);
  }
 
  void add(const WorkingCluster<HitType>& other) {
    double new_e = other.centroid_e_ + centroid_e_;
    if (new_e > 0) {
      centroid_x_ =
          (centroid_x_ * centroid_e_ + other.centroid_x_ * other.centroid_e_) /
          new_e;
      centroid_y_ =
          (centroid_y_ * centroid_e_ + other.centroid_y_ * other.centroid_e_) /
          new_e;
      centroid_z_ =
          (centroid_z_ * centroid_e_ + other.centroid_z_ * other.centroid_e_) /
          new_e;
    }
    centroid_e_ = new_e;
 
    if (other.time_ > time_) {
      time_ = other.time_;
    }
 
    for (const auto* hit : other.hits_) {
      hits_.push_back(hit);
    }
  }
 
  double centroidX() const { return centroid_x_; }
 
  double centroidY() const { return centroid_y_; }
 
  double centroidZ() const { return centroid_z_; }
 
  double energy() const { return centroid_e_; }
 
  double time() const { return time_; }
 
  const std::vector<const HitType*>& hits() const { return hits_; }
 
  bool empty() const { return hits_.empty(); }
 
  void clear() {
    hits_.clear();
    centroid_x_ = 0;
    centroid_y_ = 0;
    centroid_z_ = 0;
    centroid_e_ = 0;
    time_ = 0;
  }
 
  void setCentroid(double x, double y, double z, double e) {
    centroid_x_ = x;
    centroid_y_ = y;
    centroid_z_ = z;
    centroid_e_ = e;
  }
 
  void setTime(double t) { time_ = t; }
 
  int layer() const { return layer_; }
 
  void setLayer(int layer) { layer_ = layer; }
 
 private:
  std::vector<const HitType*> hits_;
 
  double centroid_x_{0};
 
  double centroid_y_{0};
 
  double centroid_z_{0};
 
  double centroid_e_{0};
 
  double time_{0};
 
  int layer_{-1};
};
 
}  // namespace recon
 
#endif  // RECON_WORKINGCLUSTER_H_