KVRawDataAnalyser.h

 
#ifndef __KVRAWDATAANALYSER_H
#define __KVRAWDATAANALYSER_H
 
#include "KVDataSetAnalyser.h"
#include "KVHashList.h"
#include "KVRawDataReader.h"
#include "KVDBRun.h"
#include "KVRawDataPatchList.h"
#include <KVUserAnalysisOptionList.h>
#include <TH2.h>
#include <TH3.h>
#include <TProfile.h>
#include <TProfile2D.h>
 
class KVDetectorEvent;
 
class KVRawDataAnalyser : public KVDataSetAnalyser {
protected:
 
    KVRawDataReader* fRunFile;
    run_index_t fRunNumber;
    Long64_t fEventNumber;
    KVHashList fHistoList;
    KVHashList fTreeList;
   TFile* fTreeFile;
    KVDBRun* fCurrentRun;
   Long64_t TotalEntriesToRead;
    KVString fCombinedOutputFile;
    KVUserAnalysisOptionList fOptionList;
 
   KVRawDataPatchList fRustines;
 
   void ProcessRun();
 
   void AbortDuringRunProcessing();
 
   /*** Methods copied from KVEventSelector ***/
   void add_histo(TH1* histo)
   {
      fHistoList.Add(histo);
   }
   void add_tree(TTree* tree)
   {
      if (!fTreeFile) {
         Error("AddTree", "You must call CreateTreeFile(const Char_t*) before using this method!");
         return;
      }
      tree->SetDirectory(fTreeFile);
      tree->AutoSave();
      fTreeList.Add(tree);
   }
 
   void FillTH1(TH1* h1, Double_t one, Double_t two)
   {
      h1->Fill(one, two);
   }
   void FillTProfile(TProfile* h1, Double_t one, Double_t two, Double_t three)
   {
      h1->Fill(one, two, three);
   }
   void FillTH2(TH2* h2, Double_t one, Double_t two, Double_t three)
   {
      h2->Fill(one, two, three);
   }
   void FillTProfile2D(TProfile2D* h2, Double_t one, Double_t two, Double_t three, Double_t four)
   {
      h2->Fill(one, two, three, four);
   }
   void FillTH3(TH3* h3, Double_t one, Double_t two, Double_t three, Double_t four)
   {
      h3->Fill(one, two, three, four);
   }
 
   void SetCombinedOutputFile(const KVString& filename)
   {
      fCombinedOutputFile = filename;
   }
   /*** END: Methods copied from KVEventSelector ***/
 
public:
   Long64_t GetTotalEntriesToRead() const override
   {
      return TotalEntriesToRead;
   }
 
   KVRawDataAnalyser();
   virtual ~KVRawDataAnalyser();
 
   virtual void InitAnalysis() = 0;
   virtual void InitRun() = 0;
   virtual Bool_t Analysis() = 0;
   virtual void EndRun() = 0;
   virtual void EndAnalysis() = 0;
 
   Int_t GetRunNumber() const
   {
      return fRunNumber.run();
   }
   const run_index_t& GetRunIndexNumber() const
   {
      return fRunNumber;
   }
   Long64_t GetEventNumber() const
   {
      return fEventNumber;
   }
   KVDBRun* GetCurrentRun() const
   {
      return fCurrentRun;
   }
   KVDBRunFile* GetCurrentRunFile() const
   {
      return &gExpDB->GetDBRunFile(GetRunIndexNumber());
   }
 
   void SubmitTask() override;
   static void Make(const Char_t* kvsname = "MyOwnRawDataAnalyser");
 
   void CalculateTotalEventsToRead();
 
   const KVRawDataReader& GetRunFileReader() const
   {
      return *fRunFile;
   }
 
   /*** Methods copied from KVEventSelector ***/
 
   template<typename HistoType, typename... Args>
   HistoType* AddHisto(Args&& ... args)
   {
      auto h = new HistoType(std::forward<Args>(args)...);
      add_histo(h);
      return h;
   }
   void AddHisto(TH1* histo)
   {
      Deprecate(Form("You should use e.g. 'auto h = AddHisto<%s>(\"%s\",\"%s\",%d,...);' to add histograms to your analysis.",
                     histo->ClassName(), histo->GetName(), histo->GetTitle(), histo->GetNbinsX()));
      add_histo(histo);
   }
   TTree* AddTree(const TString& name, const TString& title = "")
   {
      CreateTreeFile();
      auto t = new TTree(name, title);
      add_tree(t);
      return t;
   }
   void AddTree(TTree* tree)
   {
      Deprecate(Form("You should use e.g. 'auto t = AddTree(\"%s\", \"%s\");' to add a TTree to your analysis",
                     tree->GetName(), tree->GetTitle()));
      add_tree(tree);
   }
 
   void FillHisto(const Char_t* sname, Double_t one, Double_t two = 1, Double_t three = 1, Double_t four = 1);
   void FillHisto(const Char_t* sname, const Char_t* label, Double_t weight = 1);
   void FillTree(const Char_t* sname = "");
 
   const KVHashList* GetHistoList() const
   {
      return &fHistoList;
   }
   const KVHashList* GetTreeList() const
   {
      return &fTreeList;
   }
 
   TH1* GetHisto(const Char_t* name) const
   {
      return fHistoList.get_object<TH1>(name);
   }
   TTree* GetTree(const Char_t* name) const
   {
      return fTreeList.get_object<TTree>(name);
   }
 
   virtual void SaveHistos(const Char_t* filename = "", Option_t* option = "recreate", Bool_t onlyfilled = kFALSE);
   void SetJobOutputFileName(const TString& filename)
   {
 
      if (IsRunningBatchAnalysis())
         SetCombinedOutputFile(Form("%s.root", GetBatchSystem()->GetJobName()));
      else
         SetCombinedOutputFile(filename);
   }
   Bool_t CreateTreeFile(const Char_t* filename = "");
 
   void SetOpt(const Char_t* option, const Char_t* value)
   {
      fOptionList.SetOpt(option, value);
   }
   Bool_t IsOptGiven(const Char_t* option)
   {
      return fOptionList.IsOptGiven(option);
   }
   TString GetOpt(const Char_t* option) const
   {
      return fOptionList.GetOpt(option);
   }
   void UnsetOpt(const Char_t* opt)
   {
      fOptionList.UnsetOpt(opt);
   }
   /*** END: Methods copied from KVEventSelector ***/
 
   ClassDefOverride(KVRawDataAnalyser, 1) //Abstract base class for user analysis of raw data
};
 
#endif