KVTemplateParticleCondition.h

/*
$Id: KVParticleCondition.h,v 1.3 2007/03/26 10:14:56 franklan Exp $
$Revision: 1.3 $
$Date: 2007/03/26 10:14:56 $
*/
 
 
#ifndef __KVTEMPLATEPARTICLECONDITION_H
#define __KVTEMPLATEPARTICLECONDITION_H
 
#include "KVBase.h"
#include "KVString.h"
#include "KVHashList.h"
#include <vector>
#include <functional>
#include <KVClassFactory.h>
#include "TROOT.h"
 
class KVClassFactory;
 
template<typename ParticleType>
class KVTemplateParticleCondition : public KVBase {
   static KVHashList fgOptimized;// list of optimized particle conditions
   mutable Int_t fNUsing;
   using LambdaFunc = std::function<bool(const ParticleType*)>;
   mutable LambdaFunc fLambdaCondition;
   LambdaFunc fSavedLambda1, fSavedLambda2;// used by || and &&
   enum class LogOp { AND, OR } fOpType;
 
   void logical_operator_lambda_condition_test() const
   {
      if (IsLambda() && !IsSet()) {
         switch (fOpType) {
            case LogOp::AND:
               fLambdaCondition = [this](const ParticleType * nuc) {
                  return (fSavedLambda1(nuc) && fSavedLambda2(nuc));
               };
               break;
            case LogOp::OR:
               fLambdaCondition = [this](const ParticleType * nuc) {
                  return (fSavedLambda1(nuc) || fSavedLambda2(nuc));
               };
               break;
         }
      }
   }
 
protected:
 
   KVString fCondition;//string containing selection criteria with ";" at end
   KVString fCondition_raw;//'raw' condition, i.e. no ';'
   KVString fCondition_brackets;//condition with '(' and ')' around it
 
   mutable const KVTemplateParticleCondition* fOptimal;
   KVString fClassName;
   mutable KVClassFactory* cf;
   KVString fOptimizedClassName;
   mutable Bool_t fOptOK;
 
   void Optimize() const
   {
 
      fOptimal = (KVTemplateParticleCondition*)fgOptimized.FindObject(GetName());
      if (fOptimal) {  /* check that the same condition has not already been optimized */
         fOptimal->fNUsing++;
         fOptOK = kTRUE;
         return;
      }
      Info("Optimize", "Optimization of KVParticleCondition : %s", fCondition.Data());
 
      CreateClassFactory();
      KVString created_class_name = cf->GetClassName();
      cf->AddMethod("optimized_test", "Bool_t", "public", false, true);
      cf->AddMethodArgument("optimized_test", "const KVNucleus*", "nuc");
      cf->AddHeaderIncludeFile("KVNucleus.h");
 
      KVString body("   //Optimized Test method for particle condition\n");
      KVString pointer = "nuc";
      if (fClassName != "") {
         pointer.Form("((%s*)nuc)", fClassName.Data());
         cf->AddImplIncludeFile(Form("%s.h", fClassName.Data()));
      }
      KVString tmp;
      tmp = fCondition;
      tmp.ReplaceAll("_NUC_", pointer.Data());
      body += "   return ";
      body += tmp;
 
      cf->AddMethodBody("optimized_test", body);
 
      cf->GenerateCode();
 
      gROOT->GetPluginManager()->AddHandler("KVParticleCondition", cf->GetClassName(), cf->GetClassName(),
                                            Form("%s+", cf->GetImpFileName()), Form("%s()", cf->GetClassName()));
      TPluginHandler* ph;
      if (!(ph = LoadPlugin("KVParticleCondition", cf->GetClassName()))) {
         Error("Optimize", " *** Optimization failed for KVParticleCondition : %s", fCondition.Data());
         Error("Optimize", " *** Use method AddExtraInclude(const Char_t*) to give the names of all necessary header files for compilation of your condition.");
         Fatal("Optimize", " *** THIS CONDITION WILL BE EVALUATED AS kFALSE FOR ALL PARTICLES!!!");
         delete cf;
         cf = 0;
         fOptimal = this;
         fOptOK = kFALSE;
         return;
      }
      fOptOK = kTRUE;
      delete cf;
      cf = 0;
      fOptimal = (KVTemplateParticleCondition*) ph->ExecPlugin(0);
 
      Info("Optimize", "fOptimal = %p", fOptimal);
      if (!fOptimal) {
         Error("Optimize", " *** Optimization failed for KVParticleCondition : %s", fCondition.Data());
         Error("Optimize", " *** Use method AddExtraInclude(const Char_t*) to give the names of all necessary header files for compilation of your condition.");
         Fatal("Optimize", " *** THIS CONDITION WILL BE EVALUATED AS kFALSE FOR ALL PARTICLES!!!");
         fOptimal = this;
         fOptOK = kFALSE;
      }
      const_cast<KVTemplateParticleCondition*>(fOptimal)->SetName(GetName());
      const_cast<KVTemplateParticleCondition*>(fOptimal)->fOptimizedClassName = created_class_name;
      fgOptimized.Add(const_cast<KVTemplateParticleCondition*>(fOptimal));
      fOptimal->fNUsing++;
      Info("Optimize", "Success");
   }
 
   virtual bool optimized_test(const ParticleType*) const
   {
      return kFALSE;
   }
   void CreateClassFactory() const
   {
 
      if (cf) return;
 
      TUUID unique;
      KVString new_class = unique.AsString();
      new_class.Remove(8);
      new_class.Prepend("KVParticleCondition_");
 
      cf = new KVClassFactory(new_class.Data(), "Particle condition to test", "KVParticleCondition");
      cf->SetInheritAllConstructors(kFALSE); // avoid generating ctor with LambdaFunc argument!!!
   }
 
   void SetClassFactory(KVClassFactory* CF)
   {
      CreateClassFactory();
      CF->Copy(*cf);
   }
 
public:
   KVTemplateParticleCondition()
      : KVBase("KVParticleCondition", "Particle selection criteria")
   {
      fOptimal = nullptr;
      cf = nullptr;
      fOptOK = kFALSE;
      fNUsing = 0;
   }
 
   KVTemplateParticleCondition(const KVString& cond)
      : KVBase(cond, "KVParticleCondition")
   {
      fOptimal = nullptr;
      Set(cond);
      cf = nullptr;
      fOptOK = kFALSE;
      fNUsing = 0;
   }
 
   KVTemplateParticleCondition(const Char_t* cond)
      : KVBase(cond, "KVParticleCondition")
   {
      fOptimal = nullptr;
      Set(cond);
      cf = nullptr;
      fOptOK = kFALSE;
      fNUsing = 0;
   }
 
   KVTemplateParticleCondition(const KVTemplateParticleCondition& obj)
      : KVBase("KVParticleCondition", "Particle selection criteria")
   {
      fOptimal = nullptr;
      cf = nullptr;
      fOptOK = kFALSE;
      fNUsing = 0;
      obj.Copy(*this);
   }
 
   KVTemplateParticleCondition(const KVString& name, const LambdaFunc& F)
      : KVBase(name, "KVParticleCondition"), fLambdaCondition(F)
   {
      fOptimal = nullptr;
      cf = nullptr;
      fOptOK = kFALSE;
      fNUsing = 0;
   }
   bool IsLambda() const
   {
      return (bool)fLambdaCondition || ((bool)fSavedLambda1 && (bool)fSavedLambda2);
   }
 
   ~KVTemplateParticleCondition()
   {
      if (fOptimal) {
         --(fOptimal->fNUsing);
         if (!(fOptimal->fNUsing)) {
            fgOptimized.Remove(const_cast<KVTemplateParticleCondition*>(fOptimal));
            delete fOptimal;
            fOptimal = nullptr;
         }
      }
      SafeDelete(cf);
   }
 
   void Set(const KVString& name, const LambdaFunc& F)
   {
      fLambdaCondition = F;
      SetName(name);
   }
 
   void Set(const KVString& cond)
   {
 
 
      fCondition = cond;
      Ssiz_t ind = fCondition.Index(";");
      if (ind < 0) {
         fCondition_raw = fCondition;
         fCondition += ";";    //we add a ";" if there isn't already
      }
      else {
         fCondition_raw = fCondition.Strip(TString::kTrailing, ';');
      }
      fCondition_brackets = "(" + fCondition_raw + ")";
   }
 
   Bool_t Test(const ParticleType* nuc) const
   {
 
      logical_operator_lambda_condition_test();
      if (!IsSet()) return kTRUE;
      if (IsLambda()) return fLambdaCondition(nuc);
      if (!fOptimal) Optimize();
 
      return (fOptOK ? fOptimal->optimized_test(nuc) : kFALSE);
   }
 
   Bool_t Test(const ParticleType& nuc) const
   {
 
      return Test(&nuc);
   }
 
   void SetParticleClassName(const Char_t* cl)
   {
      fClassName = cl;
   }
   void AddExtraInclude(const Char_t* inc_file)
   {
 
      CreateClassFactory();
      cf->AddImplIncludeFile(inc_file);
   }
 
   void Copy(TObject& obj) const
   {
      KVBase::Copy(obj);
      ((KVTemplateParticleCondition&) obj).fCondition = fCondition;
      ((KVTemplateParticleCondition&) obj).fCondition_raw = fCondition_raw;
      ((KVTemplateParticleCondition&) obj).fCondition_brackets = fCondition_brackets;
      ((KVTemplateParticleCondition&) obj).fLambdaCondition = fLambdaCondition;
      ((KVTemplateParticleCondition&) obj).fSavedLambda1 = fSavedLambda1;
      ((KVTemplateParticleCondition&) obj).fSavedLambda2 = fSavedLambda2;
      ((KVTemplateParticleCondition&) obj).fOpType = fOpType;
      ((KVTemplateParticleCondition&) obj).fOptOK = fOptOK;
      ((KVTemplateParticleCondition&) obj).fOptimal = nullptr;
      if (fClassName != "")((KVTemplateParticleCondition&) obj).SetParticleClassName(fClassName.Data());
      if (cf) {
         ((KVTemplateParticleCondition&) obj).SetClassFactory(cf);
      }
   }
 
   KVTemplateParticleCondition& operator=(const KVTemplateParticleCondition& obj)
   {
      if (&obj != this) obj.Copy(*this);
      return (*this);
   }
 
   KVTemplateParticleCondition& operator=(const KVString& sel)
   {
      Set(sel);
      return (*this);
   }
 
   KVTemplateParticleCondition& operator=(const LambdaFunc& f)
   {
      fLambdaCondition = f;
      return (*this);
   }
 
   friend KVTemplateParticleCondition operator&&(const KVTemplateParticleCondition& A, const KVTemplateParticleCondition& B)
   {
 
      A.logical_operator_lambda_condition_test();
      B.logical_operator_lambda_condition_test();
 
      if (!(A.IsSet() && B.IsSet())) {
         if (!(A.IsSet() || B.IsSet())) {
            return KVTemplateParticleCondition();
         }
         else if (A.IsSet()) return KVTemplateParticleCondition(A);
         else return KVTemplateParticleCondition(B);
      }
      if (A.IsLambda() || B.IsLambda()) {
         if (A.IsLambda() && B.IsLambda()) {
            KVTemplateParticleCondition tmp;
            tmp.fSavedLambda1 = A.fLambdaCondition;
            tmp.fSavedLambda2 = B.fLambdaCondition;
            tmp.fOpType = KVTemplateParticleCondition::LogOp::AND;
            tmp.SetName(Form("(%s) && (%s)", A.GetName(), B.GetName()));
            return tmp;
         }
         else {
            ::Error("KVTemplateParticleCondition::operator&&", "Both KVParticleCondition objects must use lambda captures in order to do this");
            return KVTemplateParticleCondition();
         }
      }
      KVTemplateParticleCondition tmp;
      tmp.Set(A.fCondition_brackets + " && " + B.fCondition_brackets);
      if (A.fClassName != "") tmp.SetParticleClassName(A.fClassName);
      else if (B.fClassName != "") tmp.SetParticleClassName(B.fClassName);
      return tmp;
   }
 
   friend KVTemplateParticleCondition operator||(const KVTemplateParticleCondition& A, const KVTemplateParticleCondition& B)
   {
 
      A.logical_operator_lambda_condition_test();
      B.logical_operator_lambda_condition_test();
 
      if (!(A.IsSet() && B.IsSet())) {
         if (!(A.IsSet() || B.IsSet())) {
            return KVTemplateParticleCondition();
         }
         else if (A.IsSet()) return KVTemplateParticleCondition(A);
         else return KVTemplateParticleCondition(B);
      }
      if (A.IsLambda() || B.IsLambda()) {
         if (A.IsLambda() && B.IsLambda()) {
            KVTemplateParticleCondition tmp;
            tmp.fSavedLambda1 = A.fLambdaCondition;
            tmp.fSavedLambda2 = B.fLambdaCondition;
            tmp.fOpType = KVTemplateParticleCondition::LogOp::OR;
            tmp.SetName(Form("(%s) || (%s)", A.GetName(), B.GetName()));
            return tmp;
         }
         else {
            ::Error("operator&&", "Both KVParticleCondition objects must use lambda captures in order to do this");
            return KVTemplateParticleCondition();
         }
      }
      KVTemplateParticleCondition tmp;
      tmp.Set(A.fCondition_brackets + " || " + B.fCondition_brackets);
      if (A.fClassName != "") tmp.SetParticleClassName(A.fClassName);
      else if (B.fClassName != "") tmp.SetParticleClassName(B.fClassName);
      return tmp;
   }
 
   KVTemplateParticleCondition& operator|=(const KVTemplateParticleCondition& other)
   {
 
      KVTemplateParticleCondition tmp = *this || other;
      tmp.Copy(*this);
      return *this;
   }
 
   KVTemplateParticleCondition& operator&=(const KVTemplateParticleCondition& other)
   {
 
      KVTemplateParticleCondition tmp = *this && other;
      tmp.Copy(*this);
      return *this;
   }
   void Print(Option_t* opt = "") const
   {
      if (fCondition != "") {
         Info("Print", "object name = %s, address = %p", GetName(), this);
         std::cout << " * condition = " << fCondition.Data() << std::endl;
         std::cout << " * classname = " << fClassName.Data() << std::endl;
         std::cout << " * fOptimal = " << fOptimal << std::endl;
         std::cout << " * fNUsing = " << fNUsing << std::endl;
         if (cf) {
            std::cout << " * classfactory :" << std::endl;
            cf->Print();
         }
      }
      else {
         std::cout << GetName() << std::endl;
      }
   }
 
   static void PrintOptimizedList()
   {
      fgOptimized.Print();
   }
   Bool_t IsSet() const
   {
 
      return (fLambdaCondition || fCondition != "");
   }
 
   ClassDef(KVTemplateParticleCondition, 1) //Implements parser of particle selection criteria
};
 
template<typename ParticleClass>
KVHashList KVTemplateParticleCondition<ParticleClass>::fgOptimized;
#endif