TTreeFormulaManager.cxx

Go to the documentation of this file.

// @(#)root/treeplayer:$Id$
// Author: Philippe Canal   20/03/02
 
/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers and al.        *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
#include "TTreeFormulaManager.h"
 
#include "TArrayI.h"
#include "TError.h"
#include "TLeafElement.h"
 
ClassImp(TTreeFormulaManager);
 
   /** \class TTreeFormulaManager
   Used to coordinate one or more TTreeFormula objects.
 
   In particular it makes sure that the dimensions and size of all the formulas
   is properly coordinated.
   */
 
   ////////////////////////////////////////////////////////////////////////////////
   /// Tree FormulaManger default constructor.
 
TTreeFormulaManager::TTreeFormulaManager() : TObject()
{
   fMultiplicity = 0;
   fMultiVarDim = false;
   fNeedSync = false;
   fNdata = 1;
 
   for (Int_t i = 0; i < kMAXFORMDIM + 1; i++) {
      fVarDims[i] = nullptr;
      fCumulUsedSizes[i] = 1;
      fUsedSizes[i] = 1;
      fVirtUsedSizes[i] = 1;
   }
   fCumulUsedVarDims = nullptr;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Tree FormulaManager default destructor.
 
TTreeFormulaManager::~TTreeFormulaManager()
{
   for (int l = 0; l < kMAXFORMDIM; l++) {
      if (fVarDims[l]) delete fVarDims[l];
      fVarDims[l] = nullptr;
   }
   if (fCumulUsedVarDims) delete fCumulUsedVarDims;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Remove a formula from this manager
 
void TTreeFormulaManager::Remove(TTreeFormula *adding)
{
   fFormulas.Remove(adding);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Add a new formula to the list of formulas managed
/// The manager of the formula will be changed and the old one will be deleted
/// if it is empty.
 
void TTreeFormulaManager::Add(TTreeFormula *adding)
{
   TTreeFormulaManager *old = adding->fManager;
 
   if (old) {
      if (old == this) {
         if (fFormulas.FindObject(adding)) return;
      } else {
         old->fFormulas.Remove(adding);
         if (old->fFormulas.GetLast() == -1) delete adding->fManager;
      }
   }
 
   if (adding->TestBit(TTreeFormula::kNeedEntries)) {
      SetBit(TTreeFormula::kNeedEntries);
   }
 
   fFormulas.Add(adding);
   adding->fManager = this;
   fNeedSync = true;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Add a variable dimension
 
void TTreeFormulaManager::AddVarDims(Int_t virt_dim)
{
   if (!fVarDims[virt_dim]) fVarDims[virt_dim] = new TArrayI;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Cancel a dimension.  This is usually called when an out-of-bounds index
/// is used.
 
void TTreeFormulaManager::CancelDimension(Int_t virt_dim)
{
   fCumulUsedSizes[virt_dim] = 0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set the manager as handling a formula with multiple variable dimensions
 
void TTreeFormulaManager::EnableMultiVarDims()
{
   fMultiVarDim = true;
   if (!fCumulUsedVarDims) fCumulUsedVarDims = new TArrayI;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return number of available instances in the formulas.
 
Int_t TTreeFormulaManager::GetNdata(bool forceLoadDim)
{
   Int_t k;
 
   // new version of GetNData:
   // Possible problem: we only allow one variable dimension so far.
   if (fMultiplicity == 0) return fNdata;
 
   if (fMultiplicity == 2) return fNdata; // CumulUsedSizes[0];
 
   // We have at least one leaf with a variable size:
 
   // Reset the registers.
   for (k = 0; k <= kMAXFORMDIM; k++) {
      fUsedSizes[k] = std::abs(fVirtUsedSizes[k]);
      if (fVarDims[k]) {
         for (Int_t i0 = 0; i0 < fVarDims[k]->GetSize(); i0++) {
            fVarDims[k]->AddAt(0, i0);
         }
      }
   }
   if (fCumulUsedVarDims) {
      for (Int_t i0 = 0; i0 < fCumulUsedVarDims->GetSize(); ++i0) {
         fCumulUsedVarDims->AddAt(0, i0);
      }
   }
 
   TTreeFormula *current = nullptr;
 
   Int_t size = fFormulas.GetLast() + 1;
 
   for (Int_t i = 0; i < size; i++) {
 
      current = (TTreeFormula *)fFormulas.UncheckedAt(i);
      if (current->fMultiplicity != 1 && !current->fHasCast) continue;
      if (!current->LoadCurrentDim()) {
         if (forceLoadDim) {
            for (Int_t j = i + 1; j < size; j++) {
               current = (TTreeFormula *)fFormulas.UncheckedAt(j);
               if (current->fMultiplicity != 1 && !current->fHasCast) continue;
               current->LoadCurrentDim();
            }
         }
         fNdata = 0;
         return 0;
      }
   }
 
   if (fMultiplicity == -1) {
      fNdata = 1;
      return fCumulUsedSizes[0];
   }
 
   Int_t overall = 1;
   if (!fMultiVarDim) {
      for (k = kMAXFORMDIM; (k >= 0); k--) {
         if (fUsedSizes[k] >= 0) {
            overall *= fUsedSizes[k];
            fCumulUsedSizes[k] = overall;
         } else {
            Error("GetNdata", "a dimension is still negative!");
         }
      }
   } else {
      overall = 0; // Since we work with additions in this section
      if (fCumulUsedVarDims && fUsedSizes[0] > fCumulUsedVarDims->GetSize()) fCumulUsedVarDims->Set(fUsedSizes[0]);
      for (Int_t i = 0; i < fUsedSizes[0]; i++) {
         Int_t local_overall = 1;
         for (k = kMAXFORMDIM; (k > 0); k--) {
            if (fVarDims[k]) {
               Int_t index = fVarDims[k]->At(i);
               if (fCumulUsedVarDims && fCumulUsedVarDims->At(i) == 1 && index) index = 1;
               if (fUsedSizes[k] == 1 || (index != 1 && index < fUsedSizes[k]))
                  local_overall *= index;
               else
                  local_overall *= fUsedSizes[k];
            } else {
               local_overall *= fUsedSizes[k];
            }
         }
         // a negative value indicates that this value of the primary index
         // will lead to an invalid index; So we skip it.
         if (fCumulUsedVarDims->At(i) < 0)
            fCumulUsedVarDims->AddAt(0, i);
         else {
            fCumulUsedVarDims->AddAt(local_overall, i);
            overall += local_overall;
         }
      }
   }
   fNdata = overall;
   return overall;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Synchronize all the formulae.
 
bool TTreeFormulaManager::Sync()
{
   if (!fNeedSync) return true;
 
   TTreeFormula *current = nullptr;
   bool hasCast = false;
 
   fMultiplicity = 0;
   // We do not use an intermediary variable because ResetDimensions
   // might add more formulas (TCutG).
   for (Int_t i = 0; i < fFormulas.GetLast() + 1; i++) {
      current = (TTreeFormula *)fFormulas.UncheckedAt(i);
 
      hasCast |= current->fHasCast;
 
      // We probably need to reset the formula's dimension
 
      current->ResetDimensions();
      switch (current->GetMultiplicity()) {
      case 0:
         // nothing to do
         break;
      case 1: fMultiplicity = 1; break;
      case 2:
         if (fMultiplicity != 1) fMultiplicity = 2;
         break;
      default: Error("Sync", "Unexpected case!");
      }
 
   } // end of for each formulas
 
   // For now we keep fCumulUsedSizes sign aware.
   // This will be reset properly (if needed) by GetNdata.
   fCumulUsedSizes[kMAXFORMDIM] = fUsedSizes[kMAXFORMDIM];
   for (Int_t k = kMAXFORMDIM; (k > 0); k--) {
      if (fUsedSizes[k - 1] >= 0) {
         fCumulUsedSizes[k - 1] = fUsedSizes[k - 1] * fCumulUsedSizes[k];
      } else {
         fCumulUsedSizes[k - 1] = -std::abs(fCumulUsedSizes[k]);
      }
   }
 
   // Now that we know the virtual dimension we know if a loop over EvalInstance
   // is needed or not.
   if (fCumulUsedSizes[0] == 1 && fMultiplicity > 0) {
      // Case where even though we have an array.  We know that they will always
      // only be one element.
      fMultiplicity -= 2;
   } else if (fCumulUsedSizes[0] < 0 && fMultiplicity == 2) {
      // Case of a fixed length array that have one of its indices given
      // by a variable.
      fMultiplicity = 1;
   } else if (fMultiplicity == 0 && hasCast) {
      fMultiplicity = -1;
   }
 
   switch (fMultiplicity) {
   case 0: fNdata = 1; break;
   case 2: fNdata = fCumulUsedSizes[0]; break;
   default: fNdata = 0;
   }
   fNeedSync = false;
 
   return true;
}
 
////////////////////////////////////////////////////////////////////////////////
/// This function could be called TTreePlayer::UpdateFormulaLeaves, itself
/// called by TChain::LoadTree when a new Tree is loaded.
/// Because Trees in a TChain may have a different list of leaves, one
/// must update the leaves numbers in the TTreeFormula used by the TreePlayer.
 
void TTreeFormulaManager::UpdateFormulaLeaves()
{
   // A safer alternative would be to recompile the whole thing .... However
   // currently compile HAS TO be called from the constructor!
 
   Int_t size = fFormulas.GetLast() + 1;
 
   for (Int_t i = 0; i < size; i++) {
 
      TTreeFormula *current = (TTreeFormula *)fFormulas.UncheckedAt(i);
      current->UpdateFormulaLeaves();
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Reload the array sizes
 
void TTreeFormulaManager::UpdateUsedSize(Int_t &virt_dim, Int_t vsize)
{
   if (vsize < 0)
      fVirtUsedSizes[virt_dim] = -1 * std::abs(fVirtUsedSizes[virt_dim]);
   else if (std::abs(fVirtUsedSizes[virt_dim]) == 1 || (vsize < std::abs(fVirtUsedSizes[virt_dim]))) {
      // Absolute values represent the min of all real dimensions
      // that are known.  The fact that it is negatif indicates
      // that one of the leaf has a variable size for this
      // dimensions.
      if (fVirtUsedSizes[virt_dim] < 0) {
         fVirtUsedSizes[virt_dim] = -1 * vsize;
      } else {
         fVirtUsedSizes[virt_dim] = vsize;
      }
   }
   fUsedSizes[virt_dim] = fVirtUsedSizes[virt_dim];
   virt_dim++;
}