KVGVList.cpp

// Author: Daniel Cussol
//
// 17/02/2004
#include "KVGVList.h"
#include "KVNucleusEvent.h"
 
#include <KVUnownedList.h>
 
ClassImp(KVGVList)
 
 
//_________________________________________________________________
 
 
 
void KVGVList::init_KVGVList(void)
{
   fNbBranch = 0;
   fNbIBranch = 0;
}
 
 
 
 
KVGVList::KVGVList(const KVString& name, const KVParticleCondition& selection): KVUniqueNameList(),
   fSelection(selection)
{
   // Create a list of global variables.
   //
   // If given, the KVParticleCondition will be used to select the particles to iterate
   // over in each event in order to calculate the global variables.
   //
   // By default, if no selection is defined, only particles which are "OK" (i.e. for which
   // KVParticle::IsOK() returns true) will be iterated over - this will change in the future!
 
   SetName(name);
   init_KVGVList();
}
 
 
 
 
 
KVGVList::KVGVList(const KVGVList& a) : KVUniqueNameList()
{
   init_KVGVList();
   a.Copy(*this);
}
 
 
 
 
void KVGVList::Init(void)
{
   // Initialisation of all global variables in list
   //
   // As this method may be called several times we ensure that variables are only initialised once
 
   this->R__FOR_EACH(KVVarGlob, ListInit)();
#ifdef KVGVLIST_OPTIMIZE_GVLIST
   optimise_variable_lists();
#endif
}
 
 
 
 
void KVGVList::Reset(void)
{
   // Reset all variables before treating an event
   this->R__FOR_EACH(KVVarGlob, Reset)();
   fAbortEventAnalysis = false;
}
 
 
 
 
void KVGVList::Fill(const KVNucleus* c)
{
   // Calls KVVarGlob::Fill(KVNucleus*) method of all one-body variables in the list
   // for all KVNucleus satisfying the KVParticleCondition given to
   // KVVarGlob::SetSelection() (if no selection given, all nuclei are used).
 
   fVG1.R__FOR_EACH(KVVarGlob, Fill)(c);
}
 
 
 
 
 
void KVGVList::Fill2(const KVNucleus* c1, const KVNucleus* c2)
{
   // Calls KVVarGlob::Fill(KVNucleus*,KVNucleus*) method of all two-body variables in the list
   // for all pairs of KVNucleus (c1,c2) satisfying the KVParticleCondition given to
   // KVVarGlob::SetSelection() (if no selection given, all nuclei are used).
 
   fVG2.R__FOR_EACH(KVVarGlob, Fill2)(c1, c2);
}
 
 
 
 
void KVGVList::FillN(const KVEvent* r)
{
   // Calls KVVarGlob::FillN(KVEvent*) method of all N-body variables in the list
   fVGN.R__FOR_EACH(KVVarGlob, FillN)(r);
}
 
 
 
 
void KVGVList::Calculate()
{
   // Calculate all 1-body observables after filling
   TIter it(&fVG1);
   KVVarGlob* vg;
   while ((vg = (KVVarGlob*)it())) {
      vg->Calculate();
      if (!vg->TestEventSelection()) {
         fAbortEventAnalysis = true;
         break;
      }
   }
}
 
 
 
 
void KVGVList::Calculate2()
{
   // Calculate all 2-body observables after filling
   TIter it(&fVG2);
   KVVarGlob* vg;
   while ((vg = (KVVarGlob*)it())) {
      vg->Calculate();
      if (!vg->TestEventSelection()) {
         fAbortEventAnalysis = true;
         break;
      }
   }
}
 
 
 
 
void KVGVList::CalculateN()
{
   // Calculate all N-body observables after filling
   TIter it(&fVGN);
   KVVarGlob* vg;
   while ((vg = (KVVarGlob*)it())) {
      vg->Calculate();
      if (!vg->TestEventSelection()) {
         fAbortEventAnalysis = true;
         break;
      }
   }
}
 
 
 
 
void KVGVList::CalculateGlobalVariables(KVEvent* e)
{
   // This method will calculate all global variables defined in the list for the event 'e'.
   //
   // This will iterate over all particles in the event which correspond to the KVParticleCondition fSelection;
   // if none has been defined, only particles for which KVParticle::IsOK() returns true will be used.
   //
   // Note that for 2-body variables, the Fill2 method will be called for each distinct pair of particles
   // in the event, plus each pair made up of a particle and itself.
   //
   // For each variable for which an event selection condition was set (see KVVarGlob::SetEventSelection())
   // the condition is tested as soon as the variable is calculated. If the condition is not satisfied,
   // calculation of the other variables is abandonded and method AbortEventAnalysis() returns kTRUE.
 
   Reset();
 
#ifdef KVGVLIST_OPTIMIZE_GVLIST
   TIter nxt_list(&fOptimList);
   optigvlist* current_list;
   while (current_list = (optigvlist*)nxt_list()) {
      for (auto it = EventIterator(e, fSelection).begin(); it != KVNucleusEvent::Iterator::End(); ++it) {
         current_list->iterate_one_body([&it](KVVarGlob * vg) {
            if (vg->IsGlobalVariable())
               vg->Fill(it.get_const_pointer());
         }
                                       );
         if (current_list->has_two_body) {
            for (auto it2 = it; it2 != KVNucleusEvent::Iterator::End(); ++it2) {
               // we use every distinct pair of particles (including identical pairs) in the event
               current_list->iterate_two_body([&it, &it2](KVVarGlob * vg) {
                  vg->Fill2(it.get_const_pointer(), it2.get_const_pointer());
               }
                                             );
            }
         }
      }
      if (current_list->has_N_body) {
         current_list->iterate_N_body([e](KVVarGlob * vg) {
            vg->FillN(e);
         }
                                     );
      }
      // call calculate for global variables and for KVEventClassifier objects, test event selection
      current_list->iterate_one_body_with_test([&](KVVarGlob * vg) {
         vg->Calculate();
         if ((fAbortEventAnalysis = !vg->TestEventSelection())) {
            return false;
         }
         vg->DefineNewFrame(e);
         return true;
      });
      if (fAbortEventAnalysis) return;
      if (current_list->has_two_body) {
         current_list->iterate_two_body_with_test([&](KVVarGlob * vg) {
            vg->Calculate();
            if ((fAbortEventAnalysis = !vg->TestEventSelection())) {
               return false;
            }
            vg->DefineNewFrame(e);
            return true;
         });
         if (fAbortEventAnalysis) return;
      }
      if (current_list->has_N_body) {
         current_list->iterate_N_body_with_test([&](KVVarGlob * vg) {
            vg->Calculate();
            if ((fAbortEventAnalysis = !vg->TestEventSelection())) {
               return false;
            }
            vg->DefineNewFrame(e);
            return true;
         });
         if (fAbortEventAnalysis) return;
      }
   }
#else
   TIter it(this);
   KVVarGlob* vg;
 
   while ((vg = (KVVarGlob*)it())) {
 
      if (vg->IsGlobalVariable()) {
         // call Fill methods for global variables
         if (vg->IsNBody())
            vg->FillN(e);
         else {
            for (auto it = EventIterator(e, fSelection).begin(); it != KVNucleusEvent::Iterator::End(); ++it) {
               if (vg->IsTwoBody()) {
                  for (auto it2 = it; it2 != KVNucleusEvent::Iterator::End(); ++it2) {
                     // we use every distinct pair of particles (including identical pairs) in the event
                     vg->Fill2(it.get_const_pointer(), it2.get_const_pointer());
                  }
               }
               else
                  vg->Fill(it.get_const_pointer());
            }
         }
      }
      // call calculate for global variables and for KVEventClassifier objects
      vg->Calculate();
      if ((fAbortEventAnalysis = !vg->TestEventSelection())) {
         return;
      }
      vg->DefineNewFrame(e);
   }
#endif
}
 
 
 
 
KVVarGlob* KVGVList::GetGV(const Char_t* nom) const
{
   //Return pointer to global variable in list with name 'nom'
 
   return (KVVarGlob*) FindObject(nom);
}
 
 
 
 
void KVGVList::Add(TObject* obj)
{
   // Overrides KVUniqueNameList::Add(TObject*) so that global variable pointers are sorted
   // between the 3 lists used for 1-body, 2-body & N-body variables.
   //
   // We also print a warning in case the user tries to add a global variable with the
   // same name as one already in the list. In the case we retain only the first global variable,
   // any others with the same name are ignored
 
   KVUniqueNameList::Add(obj);   // add object to main list, check duplicates
   if (!ObjectAdded()) {
      Warning("Add", "You tried to add a global variable with the same name as one already in the list");
      Warning("Add", "Only the first variable added to the list will be used: name=%s class=%s",
              GetGV(obj->GetName())->GetName(), GetGV(obj->GetName())->ClassName());
      Warning("Add", "The following global variable (the one you tried to add) will be ignored:");
      printf("\n");
      obj->Print();
      return;
   }
   if (obj->InheritsFrom("KVVarGlob")) {
      // put global variable pointer in appropriate list
      KVVarGlob* vg = (KVVarGlob*)obj;
      if (vg->IsOneBody()) fVG1.Add(vg);
      else if (vg->IsTwoBody()) fVG2.Add(vg);
      else if (vg->IsNBody()) fVGN.Add(vg);
   }
}
 
 
 
void KVGVList::AddFirst(TObject* obj)
{
   // Overrides KVUniqueNameList::AddFirst(TObject*) so that global variable pointers are sorted
   // between the 3 lists used for 1-body, 2-body & N-body variables.
   //
   // We also print a warning in case the user tries to add a global variable with the
   // same name as one already in the list. In the case we retain only the first global variable,
   // any others with the same name are ignored
 
   KVUniqueNameList::AddFirst(obj);   // add object to main list, check duplicates
   if (!ObjectAdded()) {
      Warning("AddFirst", "You tried to add a global variable with the same name as one already in the list");
      Warning("AddFirst", "Only the first variable added to the list will be used: name=%s class=%s",
              GetGV(obj->GetName())->GetName(), GetGV(obj->GetName())->ClassName());
      Warning("AddFirst", "The following global variable (the one you tried to add) will be ignored:");
      printf("\n");
      obj->Print();
      return;
   }
   if (obj->InheritsFrom("KVVarGlob")) {
      // put global variable pointer in appropriate list
      KVVarGlob* vg = (KVVarGlob*)obj;
      if (vg->IsOneBody()) fVG1.Add(vg);
      else if (vg->IsTwoBody()) fVG2.Add(vg);
      else if (vg->IsNBody()) fVGN.Add(vg);
   }
}
 
 
 
 
 
void KVGVList::MakeBranches(TTree* tree)
{
   // Create a branch in the TTree for each global variable in the list.
   // A leaf with the name of each global variable will be created to hold the
   // value of the variable (result of KVVarGlob::GetValue() method).
   // For multi-valued global variables we add a branch for each value with name
   //
   //    `GVname.ValueName`
   //
   // To avoid problems with TTree::Draw, 'GVName' will be sanitized i.e. any
   // mathematical symbols will be replaced by '_'.
   //
   // Any variable for which KVVarGlob::SetMaxNumBranches() was called with argument `0`
   // will not be added to the TTree.
 
   if (!tree) return;
 
   // Make sure all variables are initialised before proceeding
   Init();
 
   fNbBranch = 0;
   fNbIBranch = 0;
   fBranchVar.clear();
   fIBranchVar.clear();
 
   // calculate the number of variables which will be stored in each vector
   // the space has to be pre-reserved not added by successive "push_back"s, otherwise references to vector elements
   // are invalidated every time the vector reallocates space
 
   TIter next(this);
   KVVarGlob* ob;
   while ((ob = (KVVarGlob*)next())) {
      if (ob->GetNumberOfBranches()) { //skip variables for which KVVarGlob::SetMaxNumBranches(0) was called
         if (ob->GetNumberOfValues() > 1) {
            // multi-valued variable
            for (int i = 0; i < ob->GetNumberOfBranches(); i++) {
               if (ob->GetValueType(i) == 'I') ++fNbIBranch;
               else ++fNbBranch;
            }
         }
         else {
            if (ob->GetValueType(0) == 'I') ++fNbIBranch;
            else ++fNbBranch;
         }
      }
   }
 
   fBranchVar.reserve(fNbBranch);
   fIBranchVar.reserve(fNbIBranch);
   fNbBranch = 0;
   fNbIBranch = 0;
 
   next.Reset();
 
   while ((ob = (KVVarGlob*)next())) {
      if (ob->GetNumberOfBranches()) { //skip variables for which KVVarGlob::SetMaxNumBranches(0) was called
         TString sane_varname = NameSanitizer(ob->GetName());
         if (ob->GetNumberOfValues() > 1) {
            // multi-valued variable
            for (int i = 0; i < ob->GetNumberOfBranches(); i++) {
               // replace any nasty mathematical symbols which could pose problems
               // in names of TTree leaves/branches
               TString sane_name(ob->GetValueName(i));
               sane_name.ReplaceAll("*", "star");
               if (ob->GetValueType(i) == 'I') {
                  tree->Branch(Form("%s.%s", sane_varname.Data(), sane_name.Data()), &fIBranchVar[ fNbIBranch ], Form("%s.%s/I", sane_varname.Data(), sane_name.Data()));
                  ++fNbIBranch;
               }
               else {
                  tree->Branch(Form("%s.%s", sane_varname.Data(), sane_name.Data()), &fBranchVar[ fNbBranch ], Form("%s.%s/D", sane_varname.Data(), sane_name.Data()));
                  ++fNbBranch;
               }
            }
         }
         else {
            if (ob->GetValueType(0) == 'I') {
               tree->Branch(sane_varname, &fIBranchVar[ fNbIBranch ], Form("%s/I", sane_varname.Data()));
               ++fNbIBranch;
            }
            else {
               tree->Branch(sane_varname, &fBranchVar[ fNbBranch ], Form("%s/D", sane_varname.Data()));
               ++fNbBranch;
            }
         }
      }
   }
}
 
 
 
 
 
void KVGVList::FillBranches()
{
   // Use this method ONLY if you first use MakeBranches(TTree*) in order to
   // automatically create branches for your global variables.
   // Call this method for each event in order to put the values of the variables
   // in the branches ready for TTree::Fill to be called (note that TTree::Fill is not
   // called in this method: you should do it after this).
 
   if (!fNbBranch && !fNbIBranch) return;  // MakeBranches has not been called
 
   int INT_index = 0;
   int FLT_index = 0;
   TIter next(this);
   KVVarGlob* ob;
   while ((ob = (KVVarGlob*)next())) {
      if (ob->GetNumberOfBranches()) { //skip variables for which KVVarGlob::SetMaxNumBranches(0) was called
 
         if (ob->GetNumberOfValues() > 1) {
            // multi-valued variable
            for (int j = 0; j < ob->GetNumberOfBranches(); j++) {
               if (ob->GetValueType(j) == 'I') {
                  fIBranchVar[ INT_index ] = (Int_t)ob->GetValue(j);
                  ++INT_index;
               }
               else {
                  fBranchVar[ FLT_index ] = ob->GetValue(j);
                  ++FLT_index;
               }
            }
         }
         else {
            if (ob->GetValueType(0) == 'I') {
               fIBranchVar[ INT_index ] = (Int_t)ob->GetValue();
               ++INT_index;
            }
            else {
               fBranchVar[ FLT_index ] = ob->GetValue();
               ++FLT_index;
            }
         }
 
      }
   }
}
 
 
 
 
KVEventClassifier* KVGVList::AddEventClassifier(const TString& varname, const TString& value)
{
   // Add an event classification object to the list, based on the named global variable
   // (which must already be in the list).
   //
   // \param[in] varname name of global variable previously added to list
   // \param[in] value [optional] for multi-valued variables, you can specify which value to use by name, or a mathematical expression
   //                involving one or more of the available values
   //
   // Returns a pointer to the object, in order to add either cuts or bins like so:
   //
   // #### Using cuts
   //~~~~{.cpp}
   //        mtot_cuts->AddCut(5);
   //        mtot_cuts->AddCut(10);
   //        mtot_cuts->AddCut(15);
   //        mtot_cuts->AddCut(20);
   //        mtot_cuts->AddCut(25);
   //        mtot_cuts->AddCut(30);
   //~~~~
   //   This will class events according to:
   //   | mtot       | mtot_EC |
   //   |------------|---------|
   //   |         <5 |    0    |
   //   |  [5, 9]    |    1    |
   //   |  [10, 14]  |    2    |
   //   |  [15, 19]  |    3    |
   //   |  [20, 24]  |    4    |
   //   |  [25, 29]  |    5    |
   //   |  >=30      |    6    |
   //
   // `mtot_EC` is the default name for an event classification based on `mtot` and will be
   // used for the branch added to the user's analysis TTree by method MakeBranches().
   //
   // #### Using bins
   // ~~~~{.cpp}
   //              mtot_cuts->AddBin(5,10);
   //              mtot_cuts->AddBin(15,20);
   //              mtot_cuts->AddBin(25,30);
   //~~~~
   //This will class events according to the 2 bins with the following numbers:
   // | mtot     |   mtot_EC   |
   // |----------|-------------|
   // |  [5, 9]  |    0        |
   // | [15, 19] |    1        |
   // | [25, 29] |    2        |
   // | other    |    -1       |
   //
   // Note that in this case, any value outside of a defined bin is unclassified.
 
   KVVarGlob* gv = GetGV(varname);
   if (!gv) {
      Warning("AddEventClassifier", "Variable %s not found in list. No classification possible.", varname.Data());
   }
   KVEventClassifier* ec = new KVEventClassifier(gv, value);
   Add(ec);
   return ec;
}
 
 
 
 
KVVarGlob* KVGVList::AddGV(const Char_t* class_name, const Char_t* name)
{
   //Add a global variable to the list.
   //
   //`"class_name"` must be the name of a valid class inheriting from KVVarGlob, e.g. any of the default global
   //variable classes defined as part of the standard KaliVeda package (see the [Global Variables module](group__GlobalVariables.html)),
   //or the name of a user-defined class (see below).
   //
   //`"name"` is a unique name for the new global variable object which will be created and added to the
   //list of global variables. This name can later be used to retrieve the object (see GetGV()).
   //
   //Returns pointer to new global variable object in case more than the usual default initialisation is necessary.
   //
   //### User-defined global variables
   //The user may use her own global variables, without having to add them to the main libraries.
   //If the given class name is not known, it is assumed to be a user-defined class and we attempt to compile and load
   //the class from the user's source code. For this to work, the user must:
   //
   //  1. add to the ROOT macro path the directory where her class's source code is kept, e.g. in `$HOME/.rootrc` add the following line:
   //
   //~~~~~~~~~~~~~~~
   //              +Unix.*.Root.MacroPath:      $(HOME)/myVarGlobs
   //~~~~~~~~~~~~~~~
   //
   //  2. for each user-defined class, add a line to $HOME/.kvrootrc to define a "plugin". E.g. for a class called MyNewVarGlob,
   //
   //~~~~~~~~~~~~~~~
   //              +Plugin.KVVarGlob:    MyNewVarGlob    MyNewVarGlob     MyNewVarGlob.cpp+   "MyNewVarGlob(const char*)"
   //~~~~~~~~~~~~~~~
   //
   //  It is assumed that `MyNewVarGlob.h` and `MyNewVarGlob.cpp` will be found in `$HOME/myVarGlobs` (in this example).
   // The constructor taking a single character string argument (name of the variable) must be defined in the class.
 
   KVVarGlob* vg = prepareGVforAdding(class_name, name);
   if (vg) Add(vg);
   return vg;
}
 
 
 
 
KVVarGlob* KVGVList::prepareGVforAdding(const Char_t* class_name, const Char_t* name)
{
   KVVarGlob* vg = nullptr;
   TClass* clas = TClass::GetClass(class_name);
   if (!clas) {
      //class not in dictionary - user-defined class ? Look for plugin.
      TPluginHandler* ph = KVBase::LoadPlugin("KVVarGlob", class_name);
      if (!ph) {
         //not found
         Error("AddGV(const Char_t*,const Char_t*)",
               "Called with class_name=%s.\nClass is unknown: not in standard libraries, and plugin (user-defined class) not found",
               class_name);
         return 0;
      }
      else {
         vg = (KVVarGlob*) ph->ExecPlugin(1, name);
      }
   }
   else if (!clas->InheritsFrom("KVVarGlob")) {
      Error("AddGV(const Char_t*,const Char_t*)",
            "%s is not a valid class deriving from KVVarGlob.",
            class_name);
      return nullptr;
   }
   else {
      // need to use plugins to create even known classes, in order to call ctor with name
      TPluginHandler* ph = KVBase::LoadPlugin("KVVarGlob", class_name);
      if (!ph) {
         // define plugin handler for known class
         gPluginMgr->AddHandler("KVVarGlob", class_name, class_name, "KVMultiDetglobvars", Form("%s(const char*)", class_name));
         ph = KVBase::LoadPlugin("KVVarGlob", class_name);
      }
      vg = (KVVarGlob*) ph->ExecPlugin(1, name);
   }
   return vg;
}
 
 
#ifdef KVGVLIST_OPTIMIZE_GVLIST
 
 
void KVGVList::optimise_variable_lists()
{
   // Called when list is initialised (after all variables have been added)
   //
   // Variables are sorted into sublists so that:
   //   - event-selecting variables are treated together
   //   - any variable defining a new frame is calculated before all following variables
 
   if (fOptimList.GetEntries()) return; //already done - don't repeate
 
   optigvlist* current_list = new optigvlist;
   fOptimList.Add(current_list);
 
   TIter next_var(this);
   KVVarGlob* vg, *last_vg(nullptr);
   while ((vg = (KVVarGlob*)next_var())) {
      if (last_vg) {
         if ((last_vg->IsSelectingEvents() && !vg->IsSelectingEvents()) || (last_vg->IsDefiningNewFrame())) {
            // 1. we have come to the end of a series of event selectors: start a new list
            // 2. vg's which define new frames have to be calculated before any others
            current_list = new optigvlist;
            fOptimList.Add(current_list);
         }
      }
      if (vg->IsNBody()) {
         current_list->N_body.Add(vg);
         current_list->has_N_body = true;
      }
      else if (vg->IsTwoBody()) {
         current_list->two_body.Add(vg);
         current_list->has_two_body = true;
      }
      else
         current_list->one_body.Add(vg);
      last_vg = vg;
   }
 
   Info("optimise_variable_lists", "After optimization, global variables have been separated into %d lists as follows:", fOptimList.GetEntries());
   fOptimList.ls();
}
 
#endif
 
 
 
KVVarGlob* KVGVList::AddGVFirst(const Char_t* class_name, const Char_t* name)
{
   // Add a global variable at the beginning of the list.
   //
   // See AddGV() for details.
 
   KVVarGlob* vg = prepareGVforAdding(class_name, name);
   if (vg) AddFirst(vg);
   return vg;
}