KVDataSetAnalyser.h

 
#ifndef __KVDATASETANALYSER_H
#define __KVDATASETANALYSER_H
 
#include "KVDataAnalyser.h"
#include "KVDataSet.h"
 
class KVDataSetAnalyser : public KVDataAnalyser {
private:
    KVDBSystem* fSystem;
    KVDBRun* fRun;
   KVDBRunFile* fRunFile;           //currently analysed runfile
    run_index_list fRunList;
    run_index_list fFullRunList;
    KVDataSet* fDataSet;
 
    Bool_t fChoozDataSet;
    Bool_t fChoozTask;
    Bool_t fChoozSystem;
    Bool_t fChoozRuns;
 
protected:
   void SetCurrentRun(KVDBRun* r)
   {
      fRun = r;
      fSystem = r->GetSystem();
   }
   void SetCurrentRunFile(KVDBRunFile* rf)
   {
      fRunFile = rf;
   }
   virtual run_index_list PrintAvailableRuns(KVString& datatype);
   virtual void set_dataset_pointer(KVDataSet* ds);
   virtual void set_dataset_name(const Char_t* name);
   void _set_dataset_pointer(KVDataSet* ds)
   {
      fDataSet = ds;
   }
   void PostRunReset() override;
 
   Bool_t NeedToChooseWhatToDo() const override
   {
      return fChoozDataSet || IsChooseTask();
   }
   Bool_t NeedToChooseWhatToAnalyse() const override
   {
      return fChoozSystem || fChoozRuns;
   }
   void ChooseWhatToAnalyse() override;
   void ChooseWhatToDo() override;
   Bool_t CheckWhatToAnalyseAndHow() override;
   void set_up_analyser_for_task(KVDataAnalyser* the_analyser) override;
 
public:
   TString SystemBatchName() const;
   KVDataSetAnalyser();
   virtual ~KVDataSetAnalyser();
 
   void ChooseDataSet();
   void ChooseDataType();
   virtual void ChooseAnalysisTask();
   void ChooseSystem(const Char_t* data_type = "");
   void ChooseRuns(KVDBSystem* system = nullptr, const Char_t* data_type = "");
   void Reset() override;
 
   const KVDBSystem* GetSystem() const
   {
      return fSystem;
   }
   const run_index_list& GetRunList() const
   {
      return fRunList;
   }
   Int_t GetNumberOfFilesToAnalyse() const override
   {
      return fRunList.GetNValues();
   }
   const run_index_list& GetFullRunList() const
   {
      return fFullRunList;
   }
   const KVDataSet* GetDataSet() const
   {
      return fDataSet;
   }
   void SetDataSet(KVDataSet* ds)
   {
      set_dataset_pointer(ds);
   }
   void SetDataSet(const Char_t* name)
   {
      set_dataset_name(name);
   }
   void SetSystem(KVDBSystem* syst);
   void SetRuns(const run_index_list& nl, Bool_t check = kTRUE);
   void SetFullRunList(const run_index_list& nl)
   {
      fFullRunList = nl;
   }
 
   void ClearRunList()
   {
      fRunList.Clear();
   }
   void SetChooseDataSet(Bool_t yes = kTRUE)
   {
      fChoozDataSet = yes;
   }
   Bool_t IsChooseDataSet() const
   {
      return fChoozDataSet;
   }
   void SetChooseTask(Bool_t yes = kTRUE)
   {
      fChoozTask = yes;
   }
   Bool_t IsChooseTask() const
   {
      return fChoozTask;
   }
   void SetChooseSystem(Bool_t yes = kTRUE)
   {
      fChoozSystem = yes;
   }
   Bool_t IsChooseSystem() const
   {
      return fChoozSystem;
   }
   void SetChooseRuns(Bool_t yes = kTRUE)
   {
      fChoozRuns = yes;
   }
   Bool_t IsChooseRuns() const
   {
      return fChoozRuns;
   }
   void WriteBatchEnvFile(const TString& jobname, Bool_t save = kTRUE) override;
   Bool_t ReadBatchEnvFile(const TString& filename) override;
   TString ExpandAutoBatchName(const Char_t* format) const override;
   void AddJobDescriptionList(TList*) override;
   KVString GetRootDirectoryOfDataToAnalyse() const override;
   const Char_t* GetRecognisedAutoBatchNameKeywords() const override;
 
   const KV2Body* GetKinematics() const override;
   KVDBSystem* GetAnalysedSystem() const override
   {
      return fSystem;
   }
   KVDBRun* GetAnalysedRun() const override
   {
      return fRun;
   }
   KVDBRunFile* GetAnalysedRunFile() const override
   {
      return fRunFile;
   }
   TString GetAnalyserClassNameForBatchJob() override
   {
      return "DataSetAnalyser";
   }
 
   ClassDefOverride(KVDataSetAnalyser, 1) //Analysis of data in datasets
};
 
#endif