EventHeader.h

#ifndef FIRE_EVENTHEADER_H
#define FIRE_EVENTHEADER_H
 
// STL
#include <ctime>
#include <iostream>
#include <map>
#include <string>
#include <variant>
 
#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"
#include "TTimeStamp.h"
namespace ldmx {
#else
namespace fire {
#endif
 
class EventHeader {
 public:
  static const std::string NAME;
 
  friend std::ostream& operator<<(std::ostream& s, const EventHeader& eh) {
    std::string_view label{eh.isRealData_ ? "DATA" : "MC"};
    std::time_t t = eh.time_;
    return s << "EventHeader {"
      << " number: " << eh.eventNumber_
      << ", run: " << eh.run_
      << ", weight: " << eh.weight_
      << ", " <<  label
      << ", timestamp: " << std::asctime(std::localtime(&t))
      << " }";
  }
 
  int getEventNumber() const { return eventNumber_; }
 
  int number() const { return eventNumber_; }
 
  int getRun() const { return run_; }
 
  int run() const { return run_; }
 
  double getWeight() const { return weight_; }
 
  double weight() const { return weight_; }
 
  bool isRealData() const { return isRealData_; }
 
  void setEventNumber(int number) { this->eventNumber_ = number; }
 
  void setRun(int run) { this->run_ = run; }
 
  void setTimestamp() {
    this->time_ = std::time(nullptr);
  }
 
  void setWeight(double weight) { this->weight_ = weight; }
 
  void clear() {
    weight_ = 1.;
    isRealData_ = false;
    time_ = 0.;
    run_ = -1;
    eventNumber_ = -1;
    parameters_.clear();
  }
 
  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);
  }
 
 private:
  friend class fire::io::access;
 
  template<typename DataSet>
  void attach(DataSet& d) {
    // make sure we use the name for this variable that the reader expects
    d.attach(fire::io::constants::NUMBER_NAME,eventNumber_);
    d.attach("run",run_);
    d.attach("timestamp",time_);
    d.attach("weight",weight_);
    d.attach("isRealData",isRealData_);
    d.attach("parameters",parameters_);
  }
 
  int eventNumber_{-1};
 
  int run_{-1};
 
  long int time_;
 
  double weight_{1.0};
 
  bool isRealData_{false};
 
  fire::io::ParameterStorage parameters_;
 
#ifdef fire_USE_ROOT
  friend class fire::io::Data<ldmx::EventHeader>;
 
  TTimeStamp timestamp_;
 
  std::map<std::string,int> intParameters_;
 
  std::map<std::string,float> floatParameters_;
 
  std::map<std::string,std::string> stringParameters_;
 
  ClassDef(EventHeader, 4);
#endif
};
 
}  // namespace fire
 
#ifdef fire_USE_ROOT
namespace fire {
 
using EventHeader = ldmx::EventHeader;
 
namespace io {
 
template<>
class Data<ldmx::EventHeader> : public AbstractData<ldmx::EventHeader> {
 public:
  explicit Data(const std::string& path, Reader* input_file, ldmx::EventHeader* eh);
 
  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::EventHeader>
 
} // namespace fire
} // namespace io
#endif // fire_USE_ROOT
#endif // FIRE_EVENTHEADER_H