Root.hh

 
#ifndef __RAT_DS_Root__
#define __RAT_DS_Root__
 
#include <TObject.h>
 
#include <RAT/DS/Calib.hh>
#include <RAT/DS/EV.hh>
#include <RAT/DS/MC.hh>
#include <string>
#include <utility>
#include <vector>
 
namespace RAT {
namespace DS {
 
class Root : public TObject {
 public:
  Root() : TObject() {}
  virtual ~Root() {}
 
  virtual int GetRunID() const { return runID; }
  virtual void SetRunID(int _runID) { runID = _runID; }
 
  virtual void AppendProcResult(const std::string &procName, int resultCode) {
    procResult.push_back(std::pair<std::string, int>(procName, resultCode));
  }
 
  virtual int GetLastProcResult(const std::string &procName) const {
    for (int i = procResult.size() - 1; i >= 0; i--) {
      if (procResult[(unsigned int)i].first == procName) return procResult[(unsigned int)i].second;
    }
    return -1;  // Processor has not been run
  }
 
  virtual int GetLastProcResult() const {
    if (procResult.size() == 0) {
      return -1;
    }
    return procResult[procResult.size() - 1].second;
  }
 
  virtual std::vector<std::pair<std::string, int>> GetProcResult() const { return procResult; }
 
  virtual std::string GetRatVersion() const { return ratVersion; }
  virtual void SetRatVersion(std::string _ratVersion) { ratVersion = _ratVersion; }
 
  virtual MC *GetMC() {
    if (mc.empty()) {
      mc.resize(1);
    }
    return &mc[0];
  }
  virtual const MC *GetMC() const {
    if (mc.empty()) {
      return nullptr;
    }
    return &mc[0];
  }
  virtual bool ExistMC() const { return !mc.empty(); }
  virtual void PruneMC() { mc.resize(0); }
 
  virtual Calib *GetCalib() {
    if (calib.empty()) {
      calib.resize(1);
    }
    return &calib[0];
  }
  virtual bool ExistCalib() const { return !calib.empty(); }
  virtual void PruneCalib() { calib.resize(0); }
 
  virtual const EV *GetEV(int i) const {
    if (i < 0 || i >= (int)ev.size()) {
      return nullptr;
    }
    return &ev[i];
  }
  virtual EV *GetEV(int i) { return &ev[i]; }
  virtual int GetEVCount() const { return ev.size(); }
  virtual EV *AddNewEV() {
    ev.resize(ev.size() + 1);
    return &(ev.back());
  }
  virtual bool ExistEV() const { return !ev.empty(); }
  virtual void PruneEV() { ev.resize(0); }
  virtual void PruneEV(int i) { ev.erase(ev.begin() + i); }
 
  ClassDef(Root, 1);
 
 protected:
  int runID;
  std::string ratVersion;
  std::vector<std::pair<std::string, int>> procResult;
  std::vector<MC> mc;
  std::vector<Calib> calib;
  std::vector<EV> ev;
};
 
}  // namespace DS
}  // namespace RAT
 
#endif