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 <RQ_OBJECT.h>
 
class KVDBRun: public KVDBRecord {
 
   RQ_OBJECT("KVDBRun")
    Bool_t fBlockSignals;
 
   TObjArray fRunFiles;
    KVNameValueList fParameters;
 
   KVDBRunFile* GetRunFile(int index)
   {
      return static_cast<KVDBRunFile*>(fRunFiles[index]);
   }
   const KVDBRunFile* GetRunFile(int index) const
   {
      return static_cast<const KVDBRunFile*>(fRunFiles[index]);
   }
 
public:
 
   KVDBRun();
   KVDBRun(Int_t number, const Char_t* title);
 
   Bool_t HasRunFile(const run_index_t& run_index) const
   {
     return GetRunFile(run_index.index(0))!=nullptr;
   }
   KVDBRunFile& GetRunFile(const run_index_t& run_index)
   {
      auto rf = GetRunFile(run_index.index(0));
      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 = GetRunFile(run_index.index(0));
      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)
   {
      fRunFiles.Add(rf);
   }
   Int_t GetNRunFiles() const
   {
      return fRunFiles.GetEntries();
   }
   run_index_list GetRunIndexList() const
   {
       run_index_list l;
       TIter next(&fRunFiles);
       KVDBRunFile* rf;
       while((rf = (KVDBRunFile*)next()))
          l.Add(rf->GetRunIndex());
       return l;
   }
   Bool_t IsMultiFile() const
   {
      return GetNRunFiles() > 1;
   }
   KVDBRunFile& GetFirstFile()
   {
      return *GetRunFile(0);
   }
   const KVDBRunFile& GetFirstFile() const
   {
      return *GetRunFile(0);
   }
   KVDBRunFile& GetLastFile()
   {
      return *static_cast<KVDBRunFile*>(fRunFiles.Last());
   }
   const KVDBRunFile& GetLastFile() const
   {
      return *static_cast<const KVDBRunFile*>(fRunFiles.Last());
   }
   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)
   };
 
 
   ClassDefOverride(KVDBRun, 11)         //Base class for an experiment run
};
#endif