RunHeader.h

#ifndef FIRE_RUNHEADER_H
#define FIRE_RUNHEADER_H
 
#include <map>
#include <string>
 
#include "fire/version/Version.h"
#include "fire/io/Constants.h"
#include "fire/io/Data.h"
#include "fire/io/ParameterStorage.h"
 
#ifdef fire_USE_ROOT
#include "TObject.h"
namespace ldmx {
#else
namespace fire {
#endif
 
class RunHeader {
 public:
  static const std::string NAME;
 
  int getRunNumber() const { return runNumber_; }
 
  const std::string &getDetectorName() const { return detectorName_; }
 
  void setDetectorName(const std::string &det) { detectorName_ = det; }
 
  const std::string &getSoftwareTag() const { return softwareTag_; }
 
  const std::string &getDescription() const { return description_; }
 
  void setDescription(const std::string &des) { description_ = des; }
 
  int getRunStart() const { return runStart_; }
 
  void runStart(const int run) { 
    runStart_ = std::time(nullptr);
    runNumber_ = run;
  }
 
  int getRunEnd() const { return runEnd_; }
 
  void runEnd() { 
    runEnd_ = std::time(nullptr); 
  }
 
  template <typename ParameterType>
  const ParameterType& get(const std::string& name) const {
    return parameters_.get<ParameterType>(name);
  }
 
  template <typename ParameterType>
  void set(const std::string& name, const ParameterType& val) {
    parameters_.set(name,val);
  }
 
  void stream(std::ostream &s) const;
 
  void Print() const;
 
  void clear() {
    runNumber_ = -1;
    runStart_ = 0;
    runEnd_ = 0;
    detectorName_.clear();
    description_.clear();
    softwareTag_.clear();
    parameters_.clear();
  }
 
  friend std::ostream &operator<<(std::ostream &s, const RunHeader &h) {
    h.stream(s);
    return s;
  }
 
 private:
  friend class fire::io::access;
 
  template<typename DataSet>
  void attach(DataSet& d) {
    d.attach(fire::io::constants::NUMBER_NAME,runNumber_);
    d.attach("start",runStart_);
    d.attach("end",runEnd_);
    d.attach("detectorName",detectorName_);
    d.attach("description",description_);
    d.attach("softwareTag",softwareTag_);
    d.attach("parameters",parameters_);
  }
 
 private:
  int runNumber_{0};
 
  std::string detectorName_{""};
 
  std::string description_{""};
 
  long int runStart_{0};
 
  long int runEnd_{0};
 
  std::string softwareTag_{fire::version::GIT_SHA1};
 
  fire::io::ParameterStorage parameters_;
 
#ifdef fire_USE_ROOT
  friend class fire::io::Data<ldmx::RunHeader>;
  
  std::map<std::string,int> intParameters_;
 
  std::map<std::string,float> floatParameters_;
 
  std::map<std::string,std::string> stringParameters_;
  ClassDef(RunHeader, 5);
#endif
};  // RunHeader
}  // namespace fire/ldmx
 
#ifdef fire_USE_ROOT
namespace fire {
 
using RunHeader = ldmx::RunHeader;
 
namespace io {
 
template<>
class Data<ldmx::RunHeader> : public AbstractData<ldmx::RunHeader> {
 public:
  explicit Data(const std::string& path, Reader* input_file = nullptr, ldmx::RunHeader* rh = nullptr);
 
  void load(h5::Reader& r) final override;
 
  void load(root::Reader& r) final override;
 
  void save(Writer& w) final override;
 
  void structure(Writer& w) final override;
 
  template <typename MemberType>
  void attach(const std::string& name, MemberType& m) {
    members_.push_back(
        std::make_unique<Data<MemberType>>(this->path_ + "/" + name, input_file_, &m));
  }
 
 private:
  std::vector<std::unique_ptr<BaseData>> members_;
  Reader* input_file_;
};  // Data<ldmx::RunHeader>
 
}  // namespace io
}  // namespace fire
#endif // fire_USE_ROOT
#endif // FIRE_RUNHEADER_H