ParamSet.hh

#pragma once
#include <CLHEP/Units/PhysicalConstants.h>
#include <TVector3.h>
 
#include <algorithm>
#include <limits>
#include <string>
#include <vector>
 
namespace Mimir {
enum class ParamStatus { INACTIVE = 0, ACTIVE = 1, FIXED = 2 };
 
struct ParamComponent {
  std::string name;
  double value;
  double lower_bound = std::numeric_limits<double>::lowest();
  double upper_bound = std::numeric_limits<double>::max();
  double step = 0.01;
  ParamStatus status = ParamStatus::INACTIVE;
  bool fit_valid = false;
 
  bool is_active() const { return status == ParamStatus::ACTIVE; }
  bool is_fixed() const { return status == ParamStatus::FIXED; }
  bool is_used() const { return status != ParamStatus::INACTIVE; }
};
 
struct ParamField {
  std::vector<ParamComponent> components;
  std::vector<double> active_values() const;
  std::vector<double> used_values() const;
  std::vector<double> active_lower_bounds() const;
  std::vector<double> active_upper_bounds() const;
  void set_all_lower_bounds(double value);
  void set_all_upper_bounds(double value);
  void set_all_status(ParamStatus status);
  void set_all_fit_valid(bool valid);
  void set_status(std::vector<ParamStatus> status_vector);
  void set_values(const double* values, size_t n);
  void set_values(std::vector<double> values);
  void set_lower_bounds(const double* lower_bounds, size_t n);
  void set_lower_bounds(std::vector<double> lower_bounds);
  void set_upper_bounds(const double* upper_bouonds, size_t n);
  void set_upper_bounds(std::vector<double> upper_bounds);
  bool are_all_used() const {
    return std::all_of(components.begin(), components.end(), [](const ParamComponent& comp) { return comp.is_used(); });
  }
  bool are_all_active() const {
    return std::all_of(components.begin(), components.end(),
                       [](const ParamComponent& comp) { return comp.is_active(); });
  }
  bool are_all_fit_valid() const {
    return std::all_of(components.begin(), components.end(), [](const ParamComponent& comp) { return comp.fit_valid; });
  }
};
 
struct ParamSet {
  ParamField position_time = {.components = {{.name = "x", .value = 0.0},
                                             {.name = "y", .value = 0.0},
                                             {.name = "z", .value = 0.0},
                                             {.name = "t", .value = 0.0}}};
  ParamField direction = {
      .components = {{.name = "u", .value = 0.0}, {.name = "v", .value = 0.0}, {.name = "w", .value = 0.0}}};
  ParamField energy = {.components = {{.name = "energy", .value = 1.0, .lower_bound = 0.0}}};
 
  std::vector<double> to_active_vector() const;
  std::vector<ParamComponent> to_active_components() const;
  void update_active(const std::vector<double>& values);
  void update_active(const double* values, size_t n);
  void set_active_fit_valid(bool valid);
  ParamSet from_active_vector(const std::vector<double>& values) const;
 
  TVector3 GetPosition() const;
  TVector3 GetDirection() const;
  double GetTime() const;
  double GetEnergy() const;
};
 
}  // namespace Mimir