KVExpDB.h

 
#ifndef __KVEXPDB_H
#define __KVEXPDB_H
 
#include "KVDataBase.h"
#include "KVDBRun.h"
#include "KVNumberList.h"
#include "run_index.h"
class KVDBSystem;
 
class KVExpDB : public KVDataBase {
 
protected:
    TString fDataSet;
    TString fDataSetDir;
    TString fDBType;
 
    KVNumberList fListOfRuns;
    KVDBTable* fRuns;
    KVDBTable* fSystems;
   int index_multiplier = 1;
   bool with_index_multiplier = false;
   bool raw_files_have_index = false;
    mutable std::map<int, run_index_t> fMapGlobRunFileNumberToRunIndex;
   bool minimal_db = false; // set to true when just a runs/systems database is built
 
   Bool_t OpenCalibFile(const Char_t* type, std::ifstream& fs) const;
   virtual void ReadSystemList();
   virtual void ReadComments();
   void init();
 
   void refill_list_of_runs()
   {
 
      TIter it(GetRuns());
      KVDBRun* r;
      while ((r = (KVDBRun*)it()))
         fListOfRuns.Add(r->GetNumber());
   }
 
   void read_beams_targets_reactions();
 
   virtual void make_minimal_database()
   {
      AbstractMethod("make_minimal_database");
   }
   virtual void extend_minimal_database()
   {
      AbstractMethod("extend_minimal_database");
   }
 
public:
   KVExpDB();
   KVExpDB(const Char_t* name);
   KVExpDB(const Char_t* name, const Char_t* title);
 
   Bool_t FindCalibFile(const Char_t* type, TString& fullpath, const TString& array_name = "") const;
   void SetDataSet(const TString& s)
   {
      fDataSet = s;
   }
   TString GetDBType() const
   {
      return fDBType;
   }
   void SetDBType(const TString& s)
   {
      fDBType = s;
   }
 
   virtual ~KVExpDB();
 
   virtual void LinkListToRunRanges(TList* list, UInt_t rr_number,
                                    UInt_t run_ranges[][2]);
   virtual void LinkRecordToRunRanges(KVDBRecord* rec, UInt_t rr_number,
                                      UInt_t run_ranges[][2]);
   virtual void LinkRecordToRunRange(KVDBRecord* rec, UInt_t first_run,
                                     UInt_t last_run);
   virtual void LinkListToRunRange(TList* list, const KVNumberList& nl);
   virtual void LinkRecordToRunRange(KVDBRecord* rec,  const KVNumberList& nl);
   virtual void LinkRecordToRun(KVDBRecord* rec,  Int_t run);
 
   void AddRun(KVDBRun* r)
   {
      fRuns->AddRecord(r);
      fListOfRuns.Add(r->GetNumber());
   }
   virtual KVSeqCollection* GetRuns() const
   {
      return fRuns->GetRecords();
   }
   KVDBRun* GetDBRun(Int_t number) const
   {
      return (KVDBRun*)fRuns->GetRecord(number);
   }
   const KVDBRunFile& GetDBRunFile(const run_index_t& r) const
   {
      return GetDBRun(r.run())->GetRunFile(r);
   }
   KVDBRunFile& GetDBRunFile(const run_index_t& r)
   {
      return GetDBRun(r.run())->GetRunFile(r);
   }
   const KVNumberList& GetRunList() const
   {
 
      if (fListOfRuns.IsEmpty())
         const_cast<KVExpDB*>(this)->refill_list_of_runs();
      return fListOfRuns;
   }
   virtual KVDBSystem* GetSystem(const Char_t* system) const
   {
      return (KVDBSystem*) fSystems->GetRecord(system);
   }
   virtual KVSeqCollection* GetSystems() const
   {
      return fSystems->GetRecords();
   }
 
   void AddSystem(KVDBSystem* r)
   {
      fSystems->AddRecord(r);
   }
   void RemoveSystem(KVDBSystem* s)
   {
      fSystems->RemoveRecord(s);
   }
 
   void WriteSystemsFile() const;
   void WriteRunListFile() const;
 
   virtual void Save(const Char_t*);
 
   virtual TString GetDBEnv(const Char_t*) const;
   TString GetCalibFileName(const Char_t* type) const
   {
      return GetDBEnv(type);
   }
 
   virtual void WriteObjects(TFile*)
   {
   }
 
   virtual void ReadObjects(TFile*)
   {
   }
 
   virtual void PrintRuns(KVNumberList&) const;
 
   virtual void cd();
 
   const Char_t* GetDataSetDir() const
   {
      return fDataSetDir;
   }
   void SetDataSetDir(const Char_t* d)
   {
      fDataSetDir = d;
   }
   void Build(bool minimal = false)
   {
 
      make_minimal_database();
      if(minimal)
      {
         minimal_db = true;
         return;
      }
      extend_minimal_database();
   }
   void CompleteDataBase()
   {
      if(minimal_db){
         extend_minimal_database();
         minimal_db = false;
      }
      else
         Warning("CompleteDataBase", "Called for a non-minimal database: ignored");
   }
 
   static KVExpDB* MakeDataBase(const Char_t* name, const Char_t* datasetdir, Bool_t minimal = false);
 
   ULong64_t GetTotalEvents(int first_run, int last_run = -1) const;
   ULong64_t GetTotalEvents(const KVString& system) const;
 
   Bool_t HasRawFilesWithIndex() const
   {
      return raw_files_have_index;
   }
   Bool_t HasIndexMultiplier() const
   {
      return with_index_multiplier;
   }
   Int_t GetIndexMultiplier() const
   {
      return index_multiplier;
   }
 
   run_index_t GetRunIndexFromGlobalRunFileNumber(int glob_runfile) const;
 
   run_index_list SetRunIndexListFromString(const TString&) const;
 
   Bool_t IsMinimal() const
   {
      return minimal_db;
   }
 
   ClassDef(KVExpDB, 6) //base class to describe database of an experiment
};
 
R__EXTERN KVExpDB* gExpDB;
 
#endif