KVDataSet.h

/*
$Id: KVDataSet.h,v 1.26 2009/01/27 08:06:56 franklan Exp $
$Revision: 1.26 $
$Date: 2009/01/27 08:06:56 $
$Author: franklan $
*/
 
#ifndef __KVDATASET_H
#define __KVDATASET_H
 
#include "KVString.h"
#include "KVBase.h"
#include "KVUniqueNameList.h"
#include "KVNumberList.h"
#include "TDatime.h"
#include "TFile.h"
#include "KVDataAnalysisTask.h"
#include "KVExpDB.h"
#include "run_index.h"
 
class KVDataSetManager;
class KVDataRepository;
class KVDBSystem;
class TObjArray;
class KVDBRun;
class KVAvailableRunsFile;
 
class KVDataSet: public KVBase {
 
   friend class KVAvailableRunsFile;
   friend class KVDataSetManager;
 
protected:
    KVDataRepository* fRepository;
    TString fDatatypes;
    KVUniqueNameList fAllTasks;
    KVUniqueNameList fTasks;
    TString fCalibDir;
    Bool_t fDBBuild;
    mutable std::unique_ptr<TFile> fDBase;
    TString fDBName;
    mutable KVExpDB* fDataBase;
    mutable KVList fAvailableRuns;
   enum {
      kAvailable = BIT(14)     //flag set if this dataset is physically present on local machine
   };
    TString fUserGroups;
 
   virtual const Char_t* GetBaseFileName(const Char_t* type, const run_index_t& run) const;
 
   virtual void OpenDataBase(Option_t* opt = "") const;
   virtual void OpenDBFile(const Char_t* full_path_to_dbfile) const;
   virtual void WriteDBFile(const Char_t* full_path_to_dbfile) const;
   TString GetDBFileName() const;
   void SetDBName(const Char_t* name)
   {
      fDBName = name;
   }
   TString GetDBName() const;
   TString GetFullPathToDB() const;
   void SetDataSetSpecificTaskParameters(KVDataAnalysisTask*) const;
   TObject* open_runfile(const KVString& type, const run_index_t& run);
 
   mutable Bool_t fDataBaseUpdateInProgress = false;
public:
   Bool_t DataBaseUpdateInProgress() const
   {
      return fDataBaseUpdateInProgress;
   }
 
   KVAvailableRunsFile* GetAvailableRunsFile(const Char_t* type) const;
 
   KVDataSet();
   virtual ~ KVDataSet() {}
 
   virtual Bool_t CheckUserCanAccess();
 
   virtual void SetDataPathSubdir(const Char_t* s)
   {
      SetLabel(s);
   }
   virtual const Char_t* GetDataPathSubdir() const
   {
      return GetLabel();
   }
   const Char_t* GetDataTypeSubdir(const Char_t* type) const
   {
      KVString snom;
      snom.Form("KVDataSet.DataType.Subdir.%s", type);
      return GetDataSetEnv(snom.Data(), type);
   }
   virtual const Char_t* GetAvailableDataTypes() const
   {
      return fDatatypes.Data();
   }
   virtual void AddAvailableDataType(const Char_t*);
   virtual void SetUserGroups(const Char_t* groups)
   {
      fUserGroups = groups;
   }
   virtual Bool_t IsAvailable() const
   {
      return TestBit(kAvailable);
   }
   virtual void SetAvailable(Bool_t yes = kTRUE)
   {
      SetBit(kAvailable, yes);
   }
   virtual void CheckAvailable();
 
   virtual Bool_t HasDataType(const Char_t* data_type) const
   {
 
      KVString _dt = data_type;
      _dt.Remove(TString::kBoth, ' ');
      return (_dt == "*" || fDatatypes.Contains(_dt));
   }
 
   void ls(Option_t* opt = "") const override;
   void Print(Option_t* opt = "") const override;
 
   virtual void SetAnalysisTasks(const KVSeqCollection*);
   KVDataAnalysisTask* GetAnalysisTask(Int_t) const;
   KVDataAnalysisTask* GetAnalysisTask(const Char_t* keywords) const;
   virtual KVDataAnalysisTask* GetAnalysisTaskAny(const Char_t* keywords) const;
   virtual Int_t GetNtasks() const;
 
   virtual std::unique_ptr<TList> GetListOfAvailableSystems(const Char_t* datatype,
         KVDBSystem* systol = 0);
   virtual std::unique_ptr<TList> GetListOfAvailableSystems(KVDataAnalysisTask* datan,
         KVDBSystem* systol = 0);
 
   void cd() const;
 
   const Char_t* GetDataSetDir() const;
   void SetName(const char* name) override;
 
 
   KVExpDB* GetDataBase(Option_t* opt = "") const;
   virtual void SaveDataBase() const;
 
   KVString GetDataSetEnv(const Char_t* type, const Char_t* defval = "") const;
   Double_t GetDataSetEnv(const Char_t* type, Double_t defval) const;
   Bool_t GetDataSetEnv(const Char_t* type, Bool_t defval) const;
   Int_t GetDataSetEnv(const Char_t* type, Int_t defval) const;
 
   TString GetFullPathToRunfile(const KVString& type, const run_index_t& run) const;
   KVString GetRunfileName(const KVString& type, const run_index_t& run) const;
   TDatime GetRunfileDate(const KVString& type, const run_index_t& run);
   template <typename FileType>
   FileType* OpenRunfile(const KVString& type, const run_index_t& run)
   {
      return dynamic_cast<FileType*>(open_runfile(type, run));
   }
   TObject* OpenRunfile(const KVString& type, const run_index_t& run)
   {
      return open_runfile(type, run);
   }
 
   Bool_t CheckRunfileAvailable(const KVString& type, const run_index_t& run);
   void UpdateAvailableRuns(const KVString& type);
   TFile* NewRunfile(const KVString& type, const run_index_t& run);
   void CommitRunfile(const KVString& type, const run_index_t& run, TFile* file);
 
   void CopyRunfilesFromRepository(const Char_t* type, const run_index_list& runs, const Char_t* destdir);
 
   void DeleteRunfile(const KVString& type, const run_index_t& run, Bool_t confirm = kTRUE);
   void DeleteRunfiles(const Char_t* type, const run_index_list& lrun = {}, Bool_t confirm = kTRUE);
   run_index_list GetRunList_DateSelection(const Char_t* type, TDatime* min = 0, TDatime* max = 0);
   run_index_list GetRunList_StageSelection(const Char_t* other_type, const Char_t* base_type, KVDBSystem* sys = 0, Bool_t OnlyCol = kFALSE);
   run_index_list GetRunList_VersionSelection(const Char_t* type, const Char_t* version, KVDBSystem* sys = 0);
   void SetRepository(KVDataRepository*);
   KVDataRepository* GetRepository() const;
 
   void CheckMultiRunfiles(const Char_t* data_type);
   void CleanMultiRunfiles(const Char_t* data_type, Bool_t confirm = kTRUE);
 
   Bool_t CheckRunfileUpToDate(const KVString& data_type, const run_index_t& run,
                               KVDataRepository* other_repos);
   Bool_t CheckRunfileUpToDate(const KVString& data_type, const run_index_t& run,
                               const KVString& other_repos);
   void CheckUpToDate(const Char_t* data_type,
                      const Char_t* other_repos);
   run_index_list GetUpdatableRuns(const Char_t* data_type,
                                   const Char_t* other_repos);
 
   run_index_list GetRunList(const Char_t* data_type,
                             const KVDBSystem* sys = 0) const;
 
   virtual void MakeAnalysisClass(const Char_t* task, const Char_t* classname);
 
   Bool_t OpenDataSetFile(const Char_t* filename, std::ifstream& file);
   static Bool_t OpenDataSetFile(const TString& dataset, const Char_t* filename, std::ifstream& file);
   TString GetFullPathToDataSetFile(const Char_t* filename);
   static TString GetFullPathToDataSetFile(const TString& dataset, const Char_t* filename);
   static Bool_t FindDataSetFile(const TString& dataset, const Char_t* filename);
   Bool_t FindDataSetFile(const Char_t* filename);
 
   virtual Bool_t DataBaseNeedsUpdate() const;
 
   virtual KVString GetReconstructedEventClassName() const
   {
 
      return GetDataSetEnv("ReconstructedEventClassName", "KVReconstructedEvent");
   }
 
   TString GetOutputRepository(const Char_t* taskname) const;
   void CopyRunfilesToRepository(const Char_t* type, const run_index_list& runs, const Char_t* destrepo);
 
   Bool_t HasCalibIdentInfos() const
   {
      return GetDataSetEnv("HasCalibIdentInfos", kTRUE);
   }
 
   ClassDefOverride(KVDataSet, 3)       //Describes a set of experimental data which may be analysed with KaliVeda
};
 
R__EXTERN KVDataSet* gDataSet;
 
#endif