KVVarGlob.h

#ifndef KVVarGlob_h
#define KVVarGlob_h
#include "Riostream.h"
#include "KVBase.h"
#include "KVNucleus.h"
#include "KVNameValueList.h"
#include "KVString.h"
#include "KVParticleCondition.h"
 
class KVEvent;
 
 
 
 
 
class KVVarGlob: public KVBase {
 
public:
   enum {
      kOneBody, // one-body variable: Fill (KVNucleus*) must be defined
      kTwoBody, // two-body variable: Fill2 (KVNucleus*, KVNucleus*) must be defined
      kNBody      // N-body variable: FillN (KVEvent*) must be defined
   };
 
protected:
    Int_t fType;
    Char_t fValueType;
private:
    KVNameValueList nameList;
    Bool_t fIsInitialized;
    KVString fFrame;
    KVNameValueList fOptions;
    KVNameValueList fParameters;
    KVParticleCondition fSelection;
    Int_t fMaxNumBranches;
    Double_t fNormalization;
 
#ifdef USING_ROOT6
   using EventSelector = std::function<bool(const KVVarGlob*)>;
    EventSelector fEventSelector;
   using FrameSetter = std::function<void(KVEvent*, const KVVarGlob*)>;
    FrameSetter fFrameSetter;
#endif
 
   Bool_t fDefineGroupFromSelection{kFALSE};// kTRUE if all selected particles are to be added to a group with the name of the variable
 
   void init();
   static void AddExtraInitMethodComment(KVClassFactory& cf, KVString& body);
 
protected:
   void SetNameIndex(const Char_t* name, Int_t index);
   void ClearNameIndex()
   {
      nameList.Clear();
   }
   int GetIndexAtListPosition(int pos) const
   {
      return nameList.GetValue<int>(pos);
   }
   TString GetNameAtListPosition(int pos) const
   {
      return nameList.GetNameAt(pos);
   }
 
   static void FillMethodBody(KVString& body, int type);
   static void AddInitMethod(KVClassFactory& cf, KVString& body);
   static void ImplementInitMethod(KVClassFactory& cf, KVString& body, int type);
   static void AddFillMethod(KVClassFactory& cf, int type);
   static void AddFillMethodBody(KVClassFactory& cf, KVString& body, int type);
 
   virtual Double_t getvalue_void() const
   {
      return getvalue_int(0);
   }
   virtual Double_t getvalue_char(const Char_t* name) const
   {
 
      return getvalue_int(GetNameIndex(name));
   }
   virtual Double_t getvalue_int(Int_t) const = 0;
   virtual void fill(const KVNucleus*)
   {
      AbstractMethod("fill(KVNucleus*)");
   }
 
   virtual void fill2(const KVNucleus*, const KVNucleus*)
   {
      AbstractMethod("fill2(KVNucleus*,KVNucleus*)");
   }
 
   KVNameValueList& GetParameters()
   {
      return fParameters;
   }
   const KVNameValueList& GetParameters() const
   {
      return fParameters;
   }
 
public:
   KVVarGlob()
      : KVBase("KVVarGlob", "KVVarGlob"), nameList("IndexList", "Correspondance variable name<->index")
   {
      init();
   }
   KVVarGlob(const Char_t* nom)
      : KVBase(nom, nom), nameList("IndexList", "Correspondance variable name<->index")
   {
      init();
   }
   ROOT_COPY_CTOR(KVVarGlob, KVBase)
   ROOT_COPY_ASSIGN_OP(KVVarGlob)
   void Copy(TObject& obj) const override
   {
      KVBase::Copy(obj);
      KVVarGlob& vgobj = dynamic_cast<KVVarGlob&>(obj);
      nameList.Copy(vgobj.nameList);
      vgobj.fIsInitialized = fIsInitialized;
      vgobj.fFrame = fFrame;
      fOptions.Copy(vgobj.fOptions);
      fParameters.Copy(vgobj.fParameters);
      fSelection.Copy(vgobj.fSelection);
      vgobj.fType = fType;
      vgobj.fValueType = fValueType;
      vgobj.fMaxNumBranches = fMaxNumBranches;
      vgobj.fNormalization = fNormalization;
#ifdef USING_ROOT6
      vgobj.fEventSelector = fEventSelector;
      vgobj.fFrameSetter = fFrameSetter;
#endif
   }
   virtual ~KVVarGlob(void)
   {}
 
   Bool_t IsOneBody() const
   {
      return fType == kOneBody;
   }
 
   Bool_t IsTwoBody() const
   {
      return fType == kTwoBody;
   }
 
   Bool_t IsNBody() const
   {
      return fType == kNBody;
   }
 
   virtual Bool_t IsGlobalVariable() const
   {
      return kTRUE;
   }
 
   void ListInit()
   {
 
      if (!fIsInitialized) {
         Init();
         fIsInitialized = kTRUE;
      }
   }
   virtual void Init() = 0;
   virtual void Reset() = 0;
   virtual void Calculate() = 0;
 
   void Fill(const KVNucleus* c)
   {
      const KVNucleus* c_in_frame = dynamic_cast<const KVNucleus*>(c->GetFrame(fFrame, false));
      if (fSelection.Test(c_in_frame)) {
         fill(c_in_frame);
         if (fDefineGroupFromSelection) c->AddGroup(GetOptionString("GROUP_NAME"));
      }
   }
   void Fill2(const KVNucleus* n1, const KVNucleus* n2)
   {
      const KVNucleus* n1_in_frame = dynamic_cast<const KVNucleus*>(n1->GetFrame(fFrame, false));
      const KVNucleus* n2_in_frame = dynamic_cast<const KVNucleus*>(n2->GetFrame(fFrame, false));
      if (fSelection.Test(n1_in_frame) && fSelection.Test(n2_in_frame))
         fill2(n1_in_frame, n2_in_frame);
   }
   virtual void FillN(const KVEvent*)
   {
      AbstractMethod("FillN(KVEvent*)");
   }
   Bool_t HasValue(const Char_t* name) const
   {
 
      return nameList.HasParameter(name);
   }
   Double_t GetValue(void) const
   {
 
      return getvalue_void() / fNormalization;
   }
   Double_t GetValue(const Char_t* name) const
   {
 
      return getvalue_char(name) / fNormalization;
   }
   Double_t GetValue(Int_t i) const
   {
 
      return getvalue_int(i) / fNormalization;
   }
   virtual std::vector<Double_t> GetValueVector(void) const
   {
 
      std::vector<Double_t> tmp;
      for (int i = 0; i < GetNumberOfValues(); ++i) tmp.push_back(GetValue(i) / fNormalization);
      return tmp;
   }
 
   Double_t operator()(void) const
   {
      return GetValue();
   }
 
   Double_t operator()(const Char_t* name) const
   {
      return GetValue(name);
   }
 
   Double_t operator()(Int_t i) const
   {
      return GetValue(i);
   }
 
   Int_t GetNameIndex(const Char_t* name) const;
 
   static void MakeClass(const Char_t* classname, const Char_t* classdesc, int type = kOneBody);
 
   void SetFrame(const Char_t* ref)
   {
      fFrame = ref;
   }
   const TString& GetFrame() const
   {
      return fFrame;
   }
 
   void SetOption(const Char_t* option, const Char_t* value)
   {
      KVString tmp(value);
      fOptions.SetValue(option, tmp);
      fIsInitialized = kFALSE; //allow re-initialisation
   }
 
   Bool_t IsOptionGiven(const Char_t* opt)
   {
 
      return fOptions.HasParameter(opt);
   }
 
   TString GetOptionString(const Char_t* opt) const
   {
 
      return fOptions.GetTStringValue(opt);
   }
   void UnsetOption(const Char_t* opt)
   {
 
      fOptions.RemoveParameter(opt);
   }
 
   void SetParameter(const Char_t* par, Double_t value)
   {
 
      TString Par(par);
      if (Par == "Zmin" || Par == "Zmax" || Par == "Vmin" || Par == "Vmax")
         Fatal("SetParameter", "Particle selection for global variables must be defined using SetSelection(const KVParticleCondition&).\nUpdate the use of variable \"%s\" in your analysis.",
               GetName());
      if (Par == "Normalization") SetNormalization(value);
      else fParameters.SetValue(par, value);
      fIsInitialized = kFALSE; //allow re-initialisation
   }
 
   virtual void SetNormalization(Double_t norm)
   {
      fNormalization = norm;
      fValueType = 'D';
   }
 
   Bool_t IsParameterSet(const Char_t* par)
   {
      if (TString(par) == "Normalization") return (fNormalization != 1.0);
      return fParameters.HasParameter(par);
   }
 
   Double_t GetParameter(const Char_t* par) const
   {
      if (TString(par) == "Normalization") return fNormalization;
      return fParameters.GetDoubleValue(par);
   }
 
   Double_t GetNormalization() const
   {
      return fNormalization;
   }
 
   void UnsetParameter(const Char_t* par)
   {
 
      if (TString(par) == "Normalization") fNormalization = 1.0;
      fParameters.RemoveParameter(par);
   }
 
   void SetSelection(const KVParticleCondition& sel)
   {
 
      fSelection = sel;
   }
 
   void AddSelection(const KVParticleCondition& sel)
   {
 
      fSelection &= sel;
   }
 
   Double_t AsDouble() const
   {
      return GetValue();
   }
   operator double() const
   {
      return AsDouble();
   }
 
   virtual Int_t GetNumberOfValues() const
   {
      return nameList.GetNpar();
   }
   Int_t GetNumberOfBranches() const
   {
      return (fMaxNumBranches > -1 ? fMaxNumBranches : GetNumberOfValues());
   }
   virtual TString GetValueName(Int_t i) const
   {
      for (int j = 0; j < GetNumberOfValues(); j++) {
         if (nameList.GetIntValue(j) == i) return nameList.GetParameter(j)->GetName();
      }
      return TString("unknown");
   }
   const KVNameValueList& GetValueNameList() const
   {
      return nameList;
   }
   virtual Char_t GetValueType(Int_t) const
   {
 
      return fValueType;
   }
   void SetMaxNumBranches(Int_t n)
   {
      fMaxNumBranches = (n <= GetNumberOfValues() ? n : -1);
   }
   void Print(Option_t* = "") const override;
 
#ifdef USING_ROOT6
   void SetEventSelection(const EventSelector& f)
   {
      fEventSelector = f;
   }
   bool TestEventSelection() const
   {
 
      if (!fEventSelector) return true;
      bool result = fEventSelector(this);
      return result;
   }
   bool IsSelectingEvents() const
   {
      return (bool)fEventSelector;
   }
   void SetNewFrameDefinition(const FrameSetter& f)
   {
      fFrameSetter = f;
   }
   void DefineNewFrame(KVEvent* e) const
   {
      if (fFrameSetter) fFrameSetter(e, this);
   }
   bool IsDefiningNewFrame() const
   {
      return (bool)fFrameSetter;
   }
#endif
   void SetDefineGroup(const KVString& groupname = "");
 
   ClassDefOverride(KVVarGlob, 7)      // Base class for global variables
};
#endif