KVEventClassifier.h

#ifndef __KVEVENTCLASSIFIER_H
#define __KVEVENTCLASSIFIER_H
 
#include "KVVarGlob1.h"
 
class KVEventClassifier : public KVVarGlob1 {
    KVVarGlob* fVar;
    TString fVal;
    std::vector<double> fCuts;
    bool fBcuts;
    bool fBins;
    bool fWithVal;
    bool fWithExpression;
    bool fIntegerVariable;
    std::unique_ptr<TFormula> fFormula;
    std::vector<std::string> fValues;
 
   int calc_where() const;
 
public:
   KVEventClassifier() : KVVarGlob1("KVEventClassifier"), fVar(nullptr), fVal(""), fBcuts(false),
      fBins(false), fWithVal(false), fWithExpression(false), fIntegerVariable(false), fFormula(nullptr)
   {}
   KVEventClassifier(KVVarGlob* b, const TString& value = "")
      : KVVarGlob1((value == "") ? Form("%s_EC", b->GetName()) : Form("%s_%s_EC", b->GetName(), value.Data())),
        fVar(b), fVal(value), fBcuts(false), fBins(false), fWithVal(value != ""), fWithExpression(false), fIntegerVariable(false), fFormula(nullptr)
   {
   }
   virtual ~KVEventClassifier() {}
   ROOT_COPY_CTOR(KVEventClassifier, KVVarGlob1)
   ROOT_COPY_ASSIGN_OP(KVEventClassifier)
 
   void Copy(TObject& other) const override
   {
      KVVarGlob1::Copy(other);
      ((KVEventClassifier&)other).fVar = fVar;
      ((KVEventClassifier&)other).fVal = fVal;
      ((KVEventClassifier&)other).fCuts = fCuts;
      ((KVEventClassifier&)other).fBcuts = fBcuts;
      ((KVEventClassifier&)other).fBins = fBins;
      ((KVEventClassifier&)other).fWithVal = fWithVal;
      ((KVEventClassifier&)other).fWithExpression = fWithExpression;
      ((KVEventClassifier&)other).fIntegerVariable = fIntegerVariable;
      ((KVEventClassifier&)other).fFormula.reset(new TFormula(*(fFormula.get())));
      ((KVEventClassifier&)other).fValues = fValues;
   }
   Bool_t IsGlobalVariable() const override
   {
      return kFALSE;
   }
   int GetEventClassification() const
   {
 
      int where = calc_where();
      if (fBins) {
         if (where % 2) {
            return where / 2;
         }
         return -1;
      }
      return where;
   }
   int GetMaxEventClassNumber() const
   {
 
      if (fBins) return fCuts.size() / 2;
      return fCuts.size();
   }
 
   void AddCut(double x)
   {
 
      if (fBins) {
         Error("AddCut", "You cannot mix cuts & bins (and you already defined some bins)");
         return;
      }
      fBcuts = true;
      fCuts.push_back(x);
   }
   void AddBin(double xmin, double xmax)
   {
 
      if (fBcuts) {
         Error("AddBin", "You cannot mix cuts & bins (and you already defined some cuts)");
         return;
      }
      fBins = true;
      fCuts.push_back(xmin);
      fCuts.push_back(xmax);
   }
 
   void Init() override;
   void Reset() override {}
   void Calculate() override
   {
      SetValue(GetEventClassification());
   }
 
   ClassDefOverride(KVEventClassifier, 1) //Simple class for sorting events according to global variables
};
 
#endif