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"
#ifdef WITH_PROOF
#include "TProofOutputFile.h"
#endif
#include "KVDataAnalyser.h"
#include "KVTreeVectorBranchHandler.h"
#include "KVDataAnalysisTreeHistoHandler.h"
 
class KVEventSelector : public TSelector,
                        protected KVTreeVectorBranchHandler,
                        public KVDataAnalysisTreeHistoHandler<KVEventSelector>
{
 
   friend class KVDataAnalysisTreeHistoHandler<KVEventSelector>;
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;
 
    Bool_t fNotifyCalled;
    KVString fCombinedOutputFile;
 
   KVUserAnalysisOptionList fOptionList;
 
    Bool_t fDisableCreateTreeFile;
   TFile* writeFile = nullptr;  
#ifdef WITH_PROOF
   TProofOutputFile* mergeFile = nullptr; 
#endif
   void add_histo(TH1* histo);
   void add_tree(TTree* tree);
 
   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:
   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;
   }
   Int_t   Version() const override
   {
      return 3;
   }
   void    Begin(TTree* tree) override;
   void    SlaveBegin(TTree* tree) override;
   void    Init(TTree* tree) override;
 
   Bool_t  Notify() override;
   Bool_t  Process(Long64_t entry) override;
   Int_t   GetEntry(Long64_t entry, Int_t getall = 0) override
   {
      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;
   }
   void    SetObject(TObject* obj) override
   {
      fObject = obj;
   }
   void    SetInputList(TList* input) override
   {
      fInput = input;
   }
   TList*  GetOutputList() const override
   {
      return fOutput;
   }
   void    SlaveTerminate() override;
   void    Terminate() override;
 
   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()) {
         KVError::Error(this, "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)) {
         KVError::Error(this, "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)
         KVError::Error(this, "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) {
         KVError::Error(this, "GetGV(const Char_t* name)", "Request for undefined global variable name=%s", name);
      }
      return gv;
   }
 
   void SetParticleConditions(const KVParticleCondition& cond)
   {
      fPartCond = cond;
   }
 
   virtual void SaveHistos(const Char_t* = "", Option_t* = "recreate", Bool_t = kFALSE)
   {
      KVError::Info(this, "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);
   }
   ClassDefOverride(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