KVDBRun.h

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef KV_DB_RUN_H
#define KV_DB_RUN_H
 
#include "KVDBRecord.h"
#include "KVDBSystem.h"
#include "KVTarget.h"
#include "KVString.h"
#include "TDatime.h"
#include "KVNameValueList.h"
#include "KVDBRunFile.h"
#include "run_index_list.h"
#include <RQ_OBJECT.h>
 
class KVDBRun: public KVDBRecord {
 
   RQ_OBJECT("KVDBRun")
    Bool_t fBlockSignals;
 
   TObjArray fRunFiles;
   std::map<int, int> fRunIndexMap;
   mutable run_index_list fRunIndexList;
 
    KVNameValueList fParameters;
 
   KVDBRunFile* get_run_file(const run_index_t& run_index)
   {
      return static_cast<KVDBRunFile*>(fRunFiles[fRunIndexMap[run_index.index()]]);
   }
   const KVDBRunFile* get_run_file(const run_index_t& run_index) const
   {
      if (fRunIndexMap.find(run_index.index()) != fRunIndexMap.end())
         return static_cast<const KVDBRunFile*>(fRunFiles[fRunIndexMap.at(run_index.index())]);
      return nullptr;
   }
public:
 
   KVDBRun();
   KVDBRun(Int_t number, const Char_t* title);
 
   Bool_t HasRunFile(const run_index_t& run_index) const
   {
      return GetRunIndexList().Contains(run_index);
   }
   KVDBRunFile& GetRunFile(const run_index_t& run_index)
   {
      auto rf = get_run_file(run_index);
      if (!rf)
         throw std::runtime_error(Form("<KVDBRun::GetRunFile>: no file for run_index_t %s", run_index.as_string().Data()));
      return *rf;
   }
   const KVDBRunFile& GetRunFile(const run_index_t& run_index) const
   {
      auto rf = get_run_file(run_index);
      if (!rf)
         throw std::runtime_error(Form("<KVDBRun::GetRunFile>: no file for run_index_t %s", run_index.as_string().Data()));
      return *rf;
   }
   void AddRunFile(KVDBRunFile* rf)
   {
      fRunIndexMap[rf->GetRunIndex().index()] = GetNRunFiles();
      fRunIndexList.Add(rf->GetRunIndex());
      fRunFiles.Add(rf);
   }
   Int_t GetNRunFiles() const
   {
      return fRunFiles.GetEntries();
   }
   const run_index_list& GetRunIndexList() const
   {
      if (!fRunIndexList.GetEntries()) {
         TIter it(&fRunFiles);
         KVDBRunFile* rf;
         while ((rf = (KVDBRunFile*)it()))
            fRunIndexList.Add(rf->GetRunIndex());
      }
      return fRunIndexList;
   }
   Bool_t IsMultiFile() const
   {
      return GetNRunFiles() > 1;
   }
   KVDBRunFile& GetFirstFile()
   {
      return GetRunFile(GetRunIndexList().First());
   }
   const KVDBRunFile& GetFirstFile() const
   {
      return GetRunFile(GetRunIndexList().Last());
   }
   std::optional<std::reference_wrapper<const KVDBRunFile>> GetFirstGoodFile() const
   {
      for (auto& ri : GetRunIndexList()) {
         auto& rf = GetRunFile(ri);
         if (!rf.IsBad()) return rf;
      }
      return {};
   }
   KVDBRunFile& GetLastFile()
   {
      return GetRunFile(GetRunIndexList().Last());
   }
   const KVDBRunFile& GetLastFile() const
   {
      return GetRunFile(GetRunIndexList().Last());
   }
   std::optional<std::reference_wrapper<const KVDBRunFile>> GetLastGoodFile() const
   {
      for (auto it = std::rbegin(GetRunIndexList()); it != std::rend(GetRunIndexList()); ++it) {
         auto& rf = GetRunFile(*it);
         if (!rf.IsBad()) return rf;
      }
      return {};
   }
   void SetBadAllRunFiles()
   {
      TIter next(&fRunFiles);
      KVDBRunFile* rf;
      while ((rf = (KVDBRunFile*)next()))
         rf->SetBad();
   }
   Int_t GetNGoodRunFiles() const
   {
      Int_t not_bad(0);
      TIter next(&fRunFiles);
      KVDBRunFile* rf;
      while ((rf = (KVDBRunFile*)next()))
         not_bad += !rf->IsBad();
      return not_bad;
   }
 
   void Modified() // *SIGNAL*
   {
      if (!fBlockSignals) Emit("Modified()");
   }
   void BlockSignals(Bool_t yes = kTRUE)
   {
      fBlockSignals = yes;
   }
 
   Bool_t Has(const Char_t* param, Bool_t check_whitespace = kTRUE) const
   {
      if (check_whitespace && fParameters.HasStringParameter(param)) {
         return !(fParameters.GetTStringValue(param).IsWhitespace());
      }
      return (fParameters.HasIntParameter(param) || fParameters.HasDoubleParameter(param) || fParameters.HasStringParameter(param));
   }
 
   void SetNumber(Int_t n) override
   {
      KVDBRecord::SetNumber(n);
      Modified();
   }
   ULong64_t GetEvents() const
   {
      ULong64_t tot = 0;
      TIter it(&fRunFiles);
      while (KVDBRunFile* dbr = (KVDBRunFile*)it()) {
         if (!dbr->IsBad()) tot += dbr->GetEvents();
      }
      return tot;
   }
   const Char_t* GetStartDate() const
   {
      return GetFirstFile().GetStartDate();
   }
   const Char_t* GetEndDate() const
   {
      return GetLastFile().GetEndDate();
   }
   Double_t GetSize() const
   {
      Double_t tot = 0;
      TIter it(&fRunFiles);
      while (KVDBRunFile* dbr = (KVDBRunFile*)it()) {
         if (!dbr->IsBad()) tot += dbr->GetSize();
      }
      return tot;
   }
   Double_t GetTime() const
   {
      Double_t tot = 0;
      TIter it(&fRunFiles);
      while (KVDBRunFile* dbr = (KVDBRunFile*)it()) {
         if (!dbr->IsBad()) tot += dbr->GetTime();
      }
      return tot;
   }
 
   void SetTrigger(Int_t trig)
   {
      SetScaler("Trigger multiplicity", trig);
   }
 
   Int_t GetTrigger() const
   {
      return GetScaler("Trigger multiplicity");
   }
   const Char_t* GetTriggerString() const
   {
      if (GetTrigger() > 0) return Form("M>=%d", GetTrigger());
      else return Form("xxx");
   }
   KVDBSystem* GetSystem() const;
   const Char_t* GetSystemName() const
   {
      return (GetSystem() ? GetSystem()->GetName() : "");
   }
   const Char_t* GetComments() const
   {
      return GetString("Comments");
   }
   KVTarget* GetTarget() const
   {
      return (GetSystem() ? GetSystem()->GetTarget() : 0);
   }
   void SetComments(const KVString& comments)
   {
      Set("Comments", comments);
   }
 
   virtual void SetSystem(KVDBSystem* system);
   virtual void UnsetSystem();
 
   void Print(Option_t* option = "") const override;
 
   virtual void WriteRunListLine(std::ostream&, Char_t delim = '|') const;
   virtual void ReadRunListLine(const KVString&);
   virtual void WriteRunListHeader(std::ostream&, Char_t delim = '|') const;
 
   virtual void SetScaler(const Char_t* name, Int_t val)
   {
      KV__SET_INT(name, val)
      Modified();
   }
   virtual Int_t GetScaler(const Char_t* name) const
   {
      KV__GET_INT(name)
   }
   virtual void SetScaler64(const Char_t* name, ULong64_t val)
   {
      KV__SET_ULONG(name, val)
      Modified();
   }
   virtual ULong64_t GetScaler64(const Char_t* name) const
   {
      KV__GET_ULONG(name)
   }
   void Set(const Char_t* param, Double_t val)
   {
      KV__SET_DBL(param, val)
      Modified();
   }
   Double_t Get(const Char_t* param) const
   {
      KV__GET_DBL(param)
   }
   void Set(const Char_t* param, const KVString& val)
   {
      KV__SET_STR(param, val)
      Modified();
   }
   const Char_t* GetString(const Char_t* param) const
   {
      KV__GET_STR(param)
   }
   const KVNameValueList& GetParameters() const
   {
      return fParameters;
   }
 
   ClassDefOverride(KVDBRun, 11)         //Base class for an experiment run
};
#endif