KVINDRADSTConverter.h

 
#ifndef KVDSTTreeConverter_h
#define KVDSTTreeConverter_h
 
#include "KVReconstructedEvent.h"
#include <TSelector.h>
#include <TTreeReader.h>
#include <TTreeReaderValue.h>
#include <TTreeReaderArray.h>
#include "KVINDRA.h"
#include "run_index.h"
 
 
class KVINDRADSTConverter : public TSelector {
 
   KVReconstructedEvent* the_event = nullptr;
   TFile* output_file;
   TTree* output_tree;
   bool camp1 = false;
   bool camp2 = false;
   bool camp4 = false;
   int run_number;
   run_index_t run_index;
 
public :
    TTreeReader fReader;
   TTree*          fChain = 0;   
 
   TTreeReaderValue<Int_t> npart_traite = {fReader, "npart_traite"};
   TTreeReaderArray<Int_t> idcode = {fReader, "code"};
   TTreeReaderArray<Int_t> ecode = {fReader, "ecode"};
   TTreeReaderArray<Int_t> icou = {fReader, "icou"};
   TTreeReaderArray<Int_t> imod = {fReader, "imod"};
   TTreeReaderArray<Int_t> z = {fReader, "z"};
   TTreeReaderArray<Int_t> a = {fReader, "a"};
   TTreeReaderArray<Float_t> z_indra = {fReader, "z_indra"};
   TTreeReaderArray<Float_t> a_indra = {fReader, "a_indra"};
   TTreeReaderArray<Int_t> mt = {fReader, "mt"};
   TTreeReaderArray<Float_t> ener = {fReader, "ener"};
   TTreeReaderArray<Float_t> de1 = {fReader, "de1"};
   TTreeReaderArray<Float_t> de2 = {fReader, "de2"};
   TTreeReaderArray<Float_t> de3 = {fReader, "de3"};
   TTreeReaderArray<Float_t> de4 = {fReader, "de4"};
   TTreeReaderArray<Float_t> de5 = {fReader, "de5"};
   TTreeReaderArray<Float_t> de_mylar = {fReader, "de_mylar"};
   TTreeReaderArray<Float_t> ci_gg = {fReader, "ChIo_GG"};
   TTreeReaderArray<Float_t> ci_pg = {fReader, "ChIo_PG"};
   TTreeReaderArray<Float_t> ci_mt = {fReader, "ChIo_MT"};
   TTreeReaderArray<Float_t> si_gg = {fReader, "Si_GG"};
   TTreeReaderArray<Float_t> si_pg = {fReader, "Si_PG"};
   TTreeReaderArray<Float_t> si_mt = {fReader, "Si_MT"};
   TTreeReaderArray<Float_t> csi_r = {fReader, "CsI_R"};
   TTreeReaderArray<Float_t> csi_l = {fReader, "CsI_L"};
   TTreeReaderArray<Float_t> csi_mt = {fReader, "CsI_MT"};
   TTreeReaderArray<Float_t> si75_gg = {fReader, "Si75_GG"};
   TTreeReaderArray<Float_t> si75_pg = {fReader, "Si75_PG"};
   TTreeReaderArray<Float_t> si75_mt = {fReader, "Si75_MT"};
   TTreeReaderArray<Float_t> sili_gg = {fReader, "SiLi_GG"};
   TTreeReaderArray<Float_t> sili_pg = {fReader, "SiLi_PG"};
   TTreeReaderArray<Float_t> sili_mt = {fReader, "SiLi_MT"};
 
 
   KVINDRADSTConverter(TTree* /*tree*/ = 0) { }
   virtual ~KVINDRADSTConverter() { }
   Int_t   Version() const override
   {
      return 2;
   }
   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;
   }
   void    SetOption(const char* option) override
   {
      fOption = option;
   }
   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;
 
   bool with_phoswich = true;
   bool csi_fired(int i)
   {
      return std::abs(de3[i]) > 0 || csi_l[i] > 0 || csi_r[i] > 0;
   }
   bool si_fired(int i)
   {
      return std::abs(de2[i]) > 0 || si_gg[i] > 0 || si_pg[i] > 0;
   }
   bool ci_fired(int i)
   {
      return (icou[i] > 1 && std::abs(de1[i]) > 0) || ci_gg[i] > 0 || ci_pg[i] > 0;
   }
   bool phos_fired(int i)
   {
      return with_phoswich && icou[i] == 1 && (std::abs(de1[i]) > 0 || ci_gg[i] > 0 || ci_pg[i] > 0);
   }
   bool si75_fired(int i)
   {
      return icou[i] > 9 && (std::abs(de4[i]) > 0 || si75_gg[i] > 0 || si75_pg[i] > 0);
   }
   bool sili_fired(int i)
   {
      return icou[i] > 9 && (std::abs(de5[i]) > 0 || sili_gg[i] > 0 || sili_pg[i] > 0);
   }
   bool stopped_in_phos(int i)
   {
      return phos_fired(i);
   }
   bool stopped_in_csi(int i)
   {
      return csi_fired(i) && (icou[i] > 1 || !with_phoswich);
   }
   bool stopped_in_si(int i)
   {
      return si_fired(i) && !stopped_in_csi(i) && (icou[i] > 1 || !with_phoswich) && icou[i] < 10;
   }
   bool stopped_in_sili(int i)
   {
      return sili_fired(i) && !stopped_in_csi(i);
   }
   bool stopped_in_si75(int i)
   {
      return si75_fired(i) && !stopped_in_sili(i) && !stopped_in_csi(i);
   }
   bool stopped_in_ci(int i)
   {
      return ci_fired(i) && !stopped_in_csi(i) && !stopped_in_si(i) && !stopped_in_si75(i) && !stopped_in_sili(i);
   }
   KVINDRADetector* get_csi(int i)
   {
      return gIndra->GetDetectorByType(icou[i], imod[i], CsI_R);
   }
   KVINDRADetector* get_si(int i)
   {
      return gIndra->GetDetectorByType(icou[i], imod[i], Si_PG);
   }
   KVINDRADetector* get_ci(int i)
   {
      auto ci = gIndra->GetDetectorByType(icou[i], imod[i], ChIo_PG);
      if (!ci) {
         ci = get_csi(i)->GetChIo();
      }
      return ci;
   }
   KVINDRADetector* get_phos(int i)
   {
      return gIndra->GetDetectorByType(icou[i], imod[i], Phos_R);
   }
   KVINDRADetector* get_si75(int i)
   {
      return gIndra->GetDetectorByType(icou[i], imod[i], Si75_GG);
   }
   KVINDRADetector* get_sili(int i)
   {
      return gIndra->GetDetectorByType(icou[i], imod[i], SiLi_GG);
   }
 
   Long64_t total_events, events_read;
 
   ClassDefOverride(KVINDRADSTConverter, 0)
};
 
#endif
 
#ifdef KVDSTTreeConverter_cxx
void KVINDRADSTConverter::Init(TTree* tree)
{
 
   fReader.SetTree(tree);
   total_events = tree->GetEntries();
}
 
Bool_t KVINDRADSTConverter::Notify()
{
 
   return kTRUE;
}
 
 
#endif // #ifdef KVDSTTreeConverter_cxx