KVEventSelector.h

#ifndef KVEventSelector_h
#define KVEventSelector_h
 
#include <TROOT.h>
#include <TChain.h>
#include <TFile.h>
#include <TSelector.h>
#include "KVEvent.h"
#include "KVGVList.h"
#include "KVString.h"
#include "KVParticleCondition.h"
#include "KVHashList.h"
#include <TH3.h>
#include <TH2.h>
#include <TProfile2D.h>
#include "KVUserAnalysisOptionList.h"
#include "TProofOutputFile.h"
#include "KVDataAnalyser.h"
 
class KVEventSelector : public TSelector {
 
protected :
    TTree* fChain;
    TTree* fAuxChain;
 
    KVEvent* Event;
    KVEvent* AuxEvent;
 
    TBranch* b_Event;
 
    KVUniqueNameList fGlobalVariables;
    Bool_t fGlobalVariableAbortEventAnalysis;
 
    KVString fBranchName;
 
    KVParticleCondition fPartCond;
 
    Bool_t fFirstEvent;
 
    Long64_t fEventsRead;
    Long64_t fEventsReadInterval;
    Long64_t fTreeEntry;
 
    KVHashList lhisto;
    KVHashList ltree;
 
    Bool_t fNotifyCalled;
    KVString fCombinedOutputFile;
 
   KVUserAnalysisOptionList fOptionList;
 
    Bool_t fDisableCreateTreeFile;
   TFile* writeFile = nullptr;  
   TProofOutputFile* mergeFile = nullptr; 
 
   void add_histo(TH1* histo);
   void add_tree(TTree* tree);
   void FillTH1(TH1* h1, Double_t one, Double_t two);
   void FillTProfile(TProfile* h1, Double_t one, Double_t two, Double_t three);
   void FillTH2(TH2* h2, Double_t one, Double_t two, Double_t three);
   void FillTProfile2D(TProfile2D* h2, Double_t one, Double_t two, Double_t three, Double_t four);
   void FillTH3(TH3* h3, Double_t one, Double_t two, Double_t three, Double_t four);
 
   void SetUpAuxEventChain();
   void    InitFriendTree(TTree* tree, const TString& branchname);
   void SetCombinedOutputFile(const TString& filename)
   {
      fCombinedOutputFile = filename;
 
      create_output_file();
   }
   void create_output_file();
   virtual void   CheckEndOfRun();
   void SetEvent(KVEvent* e)
   {
      Event = e;
   }
   virtual void ParseOptions();
   Bool_t AtEndOfRun(void)
   {
      return (fTreeEntry + 1 == fChain->GetTree()->GetEntries());
   }
   void RecalculateGlobalVariables();
   void SetAnalysisFrame()
   {
      if (gDataAnalyser->GetKinematics())
         GetEvent()->SetFrame("CM", gDataAnalyser->GetKinematics()->GetCMVelocity());
   }
 
 
public:
   Bool_t CreateTreeFile(const Char_t* filename = "");
 
   KVEventSelector(TTree* /*tree*/ = 0) : fChain(0), fAuxChain(0), fBranchName("data"), fFirstEvent(kTRUE),
      fEventsRead(0), fEventsReadInterval(100), fNotifyCalled(kFALSE), fDisableCreateTreeFile(kFALSE)
   {
      fGlobalVariables.SetOwner();
   }
   void SetEventsReadInterval(Long64_t N)
   {
      fEventsReadInterval = N;
   }
   virtual Int_t   Version() const
   {
      return 3;
   }
   virtual void    Begin(TTree* tree);
   virtual void    SlaveBegin(TTree* tree);
   virtual void    Init(TTree* tree);
 
   virtual Bool_t  Notify();
   virtual Bool_t  Process(Long64_t entry);
   virtual Int_t   GetEntry(Long64_t entry, Int_t getall = 0)
   {
      return fChain ? fChain->GetTree()->GetEntry(entry, getall) : 0;
   }
   Int_t GetFriendTreeEntry(Long64_t entry, Int_t getall = 0)
   {
      return fAuxChain ? fAuxChain->GetTree()->GetEntry(entry, getall) : 0;
   }
   KVEvent* GetFriendEvent() const
   {
      return AuxEvent;
   }
   virtual void    SetObject(TObject* obj)
   {
      fObject = obj;
   }
   virtual void    SetInputList(TList* input)
   {
      fInput = input;
   }
   virtual TList*  GetOutputList() const
   {
      return fOutput;
   }
   virtual void    SlaveTerminate();
   virtual void    Terminate();
 
   void SetBranchName(const Char_t* n)
   {
      fBranchName = n;
   }
   const Char_t* GetBranchName() const
   {
      return fBranchName.Data();
   }
   virtual void SetCurrentRun(KVDBRun*) {}
 
   KVEvent* GetEvent() const
   {
      return Event;
   }
   Int_t GetEventNumber() const
   {
      if (!GetEvent()) {
         Error("GetEventNumber", "No event defined!!!");
         return -1;
      }
      return GetEvent()->GetNumber();
   }
 
   virtual void InitAnalysis()
   {
      AbstractMethod("InitAnalysis");
   }
   virtual void InitRun()
   {
      AbstractMethod("InitRun");
   }
   virtual Bool_t Analysis()
   {
      return kTRUE;
   }
   virtual void EndRun()
   {
      AbstractMethod("EndRun");
   }
   virtual void EndAnalysis()
   {
      AbstractMethod("EndAnalysis");
   }
 
   KVGVList* AddGVList(const KVString& list_name, const KVParticleCondition& selection = KVParticleCondition())
   {
      if (list_name != "" && GetGVList(list_name)) {
         Error("AddGVList", "You tried to add a list with the same name '%s' as an existing list: no list created",
               list_name.Data());
         return nullptr;
      }
      auto gvl = new KVGVList(list_name, selection);
      fGlobalVariables.Add(gvl);
      return gvl;
   }
   KVGVList* GetGVList(const KVString& list_name = "default")
   {
      auto l = (KVGVList*)fGlobalVariables.FindObject(list_name);
      if (!l) {
         if (list_name == "default") {
            l = new KVGVList("default");
            fGlobalVariables.Add(l);
         }
         else if (list_name == "__internal__") {
            l = new KVGVList("__internal__", KVParticleCondition());
            fGlobalVariables.AddFirst(l);
         }
      }
      return l;
   }
 
   const KVGVList* GetGVList(const KVString& list_name = "default") const
   {
      return (KVGVList*)fGlobalVariables.FindObject(list_name);
   }
   void AddGV(KVVarGlob* vg)
   {
      if (!vg)
         Error("AddGV(KVVarGlob*)", "KVVarGlob pointer is null");
      else
         GetGVList()->Add(vg);
   }
   KVVarGlob* AddGV(const Char_t* class_name, const Char_t* name)
   {
      return GetGVList()->AddGV(class_name, name);
   }
 
   KVVarGlob* GetGV(const Char_t* name) const
   {
      auto gv = GetGVList()->GetGV(name);
      if (!gv) {
         Error("GetGV(const Char_t* name)", "Request for undefined global variable name=%s", name);
      }
      return gv;
   }
 
   void SetParticleConditions(const KVParticleCondition& cond)
   {
      fPartCond = cond;
   }
 
   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);
   }
 
   template<typename HistoType, typename... Args>
   HistoType* AddHisto(Args&& ... args)
   {
      auto h = new HistoType(std::forward<Args>(args)...);
      add_histo(h);
      return h;
   }
 
   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);
   }
 
   TTree* AddTree(const TString& name, const TString& title = "");
 
   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* tree_name = "");
 
   const KVHashList* GetHistoList() const
   {
      return &lhisto;
   }
 
   const KVHashList* GetTreeList() const
   {
      return &ltree;
   }
 
   TH1* GetHisto(const Char_t* name) const
   {
      return lhisto.get_object<TH1>(name);
   }
 
   TTree* GetTree(const Char_t* name) const
   {
      TTree* t = ltree.get_object<TTree>(name);
      if (!t) Fatal("GetTree", "Tree %s not found: is this the right name?", name);
      return t;
   }
 
   virtual void SaveHistos(const Char_t* = "", Option_t* = "recreate", Bool_t = kFALSE)
   {
      Error("SaveHistos", "Method no longer implemented. Does nothing.");
   }
 
   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);
   }
 
   virtual void SetAdditionalBranchAddress()
   {
   }
 
   void SetJobOutputFileName(const TString& filename)
   {
      if (KVDataAnalyser::IsRunningBatchAnalysis() && (gDataAnalyser->GetProofMode() == KVDataAnalyser::EProofMode::None))
         SetCombinedOutputFile(Form("%s.root", gDataAnalyser->GetBatchSystem()->GetJobName()));
      else
         SetCombinedOutputFile(filename);
   }
 
   void SetTriggerConditionsForRun(int run)
   {
      gDataAnalyser->SetTriggerConditionsForRun(run);
   }
   ClassDef(KVEventSelector, 0)//General purpose analysis class for TTrees containing KVEvent objects
};
 
#define AddVar(var,type) Branch(dadastr(var), &var, didixstr(duduvartype(var,type)))
#define AddVarBranch(var,branch,type) Branch(dadastr(branch), &var, didixstr(duduvartype(branch,type)))
#define duduvartype(var,type) var/type
#define didixstr(s) dadastr(s)
#define dadastr(s) #s
 
#endif