KVGVList.h

#ifndef KVGVList_h
#define KVGVList_h
#include "KVVarGlob.h"
#include "KVUniqueNameList.h"
#include "KVParticleCondition.h"
#include "TTree.h"
#include "KVEventClassifier.h"
 
#include <KVUnownedList.h>
 
 
 
 
 
 
 
 
class KVGVList: public KVUniqueNameList {
 
    KVParticleCondition fSelection;
    std::vector<Double_t> fBranchVar;
    std::vector<Int_t> fIBranchVar;
   Int_t fNbBranch;
   Int_t fNbIBranch;
    bool fAbortEventAnalysis;
 
   TString NameSanitizer(const Char_t* s) const
   {
      TString _s(s);
      _s.ReplaceAll("+", "_");
      _s.ReplaceAll("*", "_");
      _s.ReplaceAll("-", "_");
      _s.ReplaceAll("/", "_");
      _s.ReplaceAll("=", "_");
      return _s;
   }
   KVVarGlob* prepareGVforAdding(const Char_t* class_name, const Char_t* name);
#ifdef KVGVLIST_OPTIMIZE_GVLIST
   KVList fOptimList;
   struct optigvlist : public TObject {
      KVUnownedList one_body;
      KVUnownedList two_body;
      KVUnownedList N_body;
      bool has_two_body = false;
      bool has_N_body = false;
      void ls(Option_t* option = "") const
      {
         one_body.ls(option);
         two_body.ls(option);
         N_body.ls(option);
      }
      template<typename call_func>
      void iterate(KVUnownedList* l, call_func F)
      {
         KVVarGlob* vg;
         TIter it(l);
         while ((vg = (KVVarGlob*)it())) {
            F(vg);
         }
      }
      template<typename call_func>
      void iterate_with_test(KVUnownedList* l, call_func F)
      {
         KVVarGlob* vg;
         TIter it(l);
         while ((vg = (KVVarGlob*)it())) {
            if (!F(vg)) break;
         }
      }
      template<typename call_func>
      void iterate_one_body(call_func F)
      {
         iterate(&one_body, F);
      }
      template<typename call_func>
      void iterate_two_body(call_func F)
      {
         iterate(&two_body, F);
      }
      template<typename call_func>
      void iterate_N_body(call_func F)
      {
         iterate(&N_body, F);
      }
      template<typename call_func>
      void iterate_one_body_with_test(call_func F)
      {
         iterate_with_test(&one_body, F);
      }
      template<typename call_func>
      void iterate_two_body_with_test(call_func F)
      {
         iterate_with_test(&two_body, F);
      }
      template<typename call_func>
      void iterate_N_body_with_test(call_func F)
      {
         iterate_with_test(&N_body, F);
      }
   };
   void optimise_variable_lists();
#endif
protected:
   void init_KVGVList(void);
    TList fVG1;
    TList fVG2;
    TList fVGN;
   void Fill(const KVNucleus* c);
   void Fill2(const KVNucleus* c1, const KVNucleus* c2);
   void FillN(const KVEvent* e);
   void Calculate();
   void Calculate2();
   void CalculateN();
 
public:
   KVGVList(const KVString& name = "default", const KVParticleCondition& selection
            = KVParticleCondition{"OK", [](const KVNucleus * n)
   {
      return n->IsOK();
   }});
   KVGVList(const KVGVList& a);
 
   KVVarGlob* AddGV(const Char_t* class_name, const Char_t* name);
   KVVarGlob* AddGVFirst(const Char_t* class_name, const Char_t* name);
 
   void Init(void);
   void Reset(void);
 
   void CalculateGlobalVariables(KVEvent* e);
 
   KVVarGlob* GetGV(const Char_t* nom) const;         //find global variable with name 'nom'
 
   KVVarGlob* GetGVType(const Char_t* class_name)
   {
      return (KVVarGlob*)FindObjectByClass(class_name);
   }
   void      Add(TObject* obj) override ;
   void      AddFirst(TObject* obj) override ;
 
   Bool_t Has1BodyVariables()
   {
      return (fVG1.GetEntries() > 0);
   }
 
   Bool_t Has2BodyVariables()
   {
      return (fVG2.GetEntries() > 0);
   }
 
   Bool_t HasNBodyVariables()
   {
      return (fVGN.GetEntries() > 0);
   }
 
   void MakeBranches(TTree*);
   void FillBranches();
 
   bool AbortEventAnalysis() const
   {
      return fAbortEventAnalysis;
   }
   KVEventClassifier* AddEventClassifier(const TString& varname, const TString& value = "");
 
   ClassDefOverride(KVGVList, 3)       // List of global variables
};
#endif