KVOldINDRASelector.h

 
 
#ifndef KVOldINDRASelector_h
#define KVOldINDRASelector_h
 
#include <TROOT.h>
#include <TChain.h>
#include <TFile.h>
#include <TSelector.h>
#include "KVINDRAReconEvent.h"
#include "KVINDRA.h"
#include "KV2Body.h"
#include "KVGVList.h"
#include "TStopwatch.h"
#include "TEventList.h"
#include "KVDataSelector.h"
#include "KVParticleCondition.h"
#include "KVString.h"
#include "KVLockfile.h"
#include "KVConfig.h"
#include "KVDataAnalyser.h"
#include "KVHashList.h"
#include "KVNameValueList.h"
#include "KVINDRADBRun.h"
 
#include "TH1.h"
#include "TH2.h"
#include "TH3.h"
#include "TProfile2D.h"
#include "TProfile.h"
#include "KVDalitzPlot.h"
 
class KVOldINDRASelector: public TSelector {
 
protected:
 
   enum {
      kDeleteGVList = BIT(14),
      kChangeMasses = BIT(15)
   };
 
   Int_t callnotif;
   Int_t totentry;
   Int_t NbTreeEntry;
   KVINDRAReconEvent* data;
 
    TBranch* b_data;
 
    KVGVList* gvlist;
    KVHashList* lhisto;
    KVHashList* ltree;
 
    TStopwatch* fTimer;
 
#ifdef __WITHOUT_TSELECTOR_LONG64_T
    Int_t fTreeEntry;
#else
    Long64_t fTreeEntry;
#endif
 
    TEventList* fEvtList;
#ifdef __WITHOUT_TSELECTOR_LONG64_T
    Int_t* fTreeOffset;
#else
    Long64_t* fTreeOffset;
#endif
    Int_t fCurrentTreeNumber;
 
    TString fDataSelector;
    KVDataSelector* fKVDataSelector;
    Bool_t needToSelect;
    Bool_t* fTEVLexist;
    Bool_t needToCallEndRun;
    KVINDRADBRun* fCurrentRun;
 
    UInt_t fNewMassFormula;
 
    KVParticleCondition* fPartCond;
 
    static KVString fBranchName;
 
    TTree* fChain;
 
 
   KVNameValueList fOptionList;
   void ParseOptions();
 
   KVINDRAReconEvent** GetEventReference()
   {
      return &data;
   };
 
   virtual KVINDRADBRun* GetCurrentRun() const
   {
      return fCurrentRun;
   };
 
   void SetINDRAReconEventBranchName(const Char_t* br_name)
   {
      fBranchName = br_name;
   };
 
    KVLockfile dataselector_lock;
 
   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 FillKVDalitz(KVDalitzPlot* 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);
 
public:
   KVOldINDRASelector(TTree* tree = 0);
   virtual ~ KVOldINDRASelector();
 
   KVINDRAReconEvent* GetEvent()
   {
      return data;
   }
   Int_t GetEventNumber()
   {
      return data->GetNumber();
   }
 
   Int_t Version() const
   {
      return 2;
   }
   void SetCurrentRun(KVINDRADBRun* r)
   {
      fCurrentRun = r;
   }
 
   void Begin(TTree* tree);
   void SlaveBegin(TTree* tree);
   void Init(TTree* tree);
   Bool_t Notify();
#ifdef __WITHOUT_TSELECTOR_LONG64_T
   Bool_t Process(Int_t entry);
#else
   Bool_t Process(Long64_t entry);
#endif
   void SetOption(const char* option)
   {
      fOption = option;
   }
   void SetObject(TObject* obj)
   {
      fObject = obj;
   }
   void SetInputList(TList* input)
   {
      fInput = input;
   }
   TList* GetOutputList() const
   {
      return fOutput;
   }
   void SlaveTerminate();
   void Terminate();
 
   /* user entry points */
   virtual void InitAnalysis()
   {
   };
   virtual void InitRun()
   {
   };
   virtual Bool_t Analysis()
   {
      return kTRUE;
   };
   virtual void EndRun()
   {
   };
   virtual void EndAnalysis()
   {
   };
 
   virtual void SetGVList(KVGVList* list);
   virtual KVGVList* GetGVList(void);
   virtual void AddGV(KVVarGlob*);
   virtual KVVarGlob* AddGV(const Char_t* class_name,
                            const Char_t* name);
   virtual KVVarGlob* GetGV(const Char_t*) const;
   virtual void RecalculateGlobalVariables();
 
#ifdef __WITHOUT_TSELECTOR_LONG64_T
   virtual Int_t GetTreeEntry() const;
#else
   virtual Long64_t GetTreeEntry() const;
#endif
 
   virtual void BuildEventList(void);
   virtual Bool_t AtEndOfRun(void);
 
   virtual void SetDataSelector(const Char_t* dataSel = "")
   {
      fDataSelector = dataSel;
   }
   virtual const Char_t* GetDataSelector(void)
   {
      return fDataSelector.Data();
   }
 
   virtual void LoadDataSelector(void);
   virtual void SaveCurrentDataSelection(void);
 
   virtual const Char_t* GetDataSelectorFileName(void);
 
   virtual void ChangeFragmentMasses(UInt_t mass_formula);
 
   virtual void SetParticleConditions(const KVParticleCondition&);
 
 
 
   static void Make(const Char_t* kvsname = "MyOwnKVOldINDRASelector");
 
   virtual void CreateHistos();
   virtual void CreateTrees();
 
   void FillHisto(KVString sname, Double_t one, Double_t two = 1, Double_t three = 1, Double_t four = 1);
   void FillTree(KVString sname = "");
 
   KVHashList* GetHistoList();
   KVHashList* GetTreeList();
 
   TH1* GetHisto(const Char_t* name);
   TTree* GetTree(const Char_t* name);
 
   virtual void WriteHistoToFile(KVString filename = "FileFromKVOldINDRASelector.root", Option_t* option = "recreate");
   virtual void WriteTreeToFile(KVString filename = "FileFromKVOldINDRASelector.root", Option_t* option = "recreate");
 
   virtual void SetOpt(const Char_t* option, const Char_t* value);
   virtual Bool_t IsOptGiven(const Char_t* option);
   virtual TString GetOpt(const Char_t* option) const;
   virtual void UnsetOpt(const Char_t* opt);
 
   ClassDef(KVOldINDRASelector, 0);     //Deprecated analysis class for TChains of KVINDRAReconEvents
};
 
#endif