TTreeFormula.cxx

Go to the documentation of this file.

// @(#)root/treeplayer:$Id$
// Author: Rene Brun   19/01/96
 
/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
#include "TROOT.h"
#include "TTreeFormula.h"
#include "TList.h"
#include "TTree.h"
#include "TBuffer.h"
#include "TBranch.h"
#include "TBranchObject.h"
#include "TBranchElement.h"
#include "TClonesArray.h"
#include "TLeafB.h"
#include "TLeafC.h"
#include "TLeafElement.h"
#include "TLeafObject.h"
#include "TMethodCall.h"
#include "TCutG.h"
#include "TRandom.h"
#include "TInterpreter.h"
#include "TDataType.h"
#include "TStreamerInfo.h"
#include "TStreamerElement.h"
#include "TArrayI.h"
#include "TAxis.h"
#include "TError.h"
#include "TVirtualCollectionProxy.h"
#include "TString.h"
#include "TMath.h"
 
#include "TVirtualRefProxy.h"
#include "TTreeFormulaManager.h"
#include "TFormLeafInfo.h"
#include "TMethod.h"
#include "TFormLeafInfoReference.h"
#include "strlcpy.h"
#include "snprintf.h"
#include "TEntryList.h"
 
#include <cctype>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <typeinfo>
#include <algorithm>
#include <sstream>
 
const Int_t kMaxLen     = 2048;
 
/** \class TTreeFormula
Used to pass a selection expression to the Tree drawing routine. See TTree::Draw
 
A TreeFormula can contain any arithmetic expression including
standard operators and mathematical functions separated by operators.
Examples of valid expression:
~~~{.cpp}
     "x<y && sqrt(z)>3.2"
~~~
TTreeFormula now relies on a variety of TFormLeafInfo classes to handle the
reading of the information. Here is the list of theses classes:
  - TFormLeafInfo
  - TFormLeafInfoDirect
  - TFormLeafInfoNumerical
  - TFormLeafInfoClones
  - TFormLeafInfoCollection
  - TFormLeafInfoPointer
  - TFormLeafInfoMethod
  - TFormLeafInfoMultiVarDim
  - TFormLeafInfoMultiVarDimDirect
  - TFormLeafInfoCast
 
The following method are available from the TFormLeafInfo interface:
 
 -  AddOffset(Int_t offset, TStreamerElement* element)
 -  GetCounterValue(TLeaf* leaf) : return the size of the array pointed to.
 -  GetObjectAddress(TLeafElement* leaf) : Returns the location of the object pointed to.
 -  GetMultiplicity() : Returns info on the variability of the number of elements
 -  GetNdata(TLeaf* leaf) : Returns the number of elements
 -  GetNdata() : Used by GetNdata(TLeaf* leaf)
 -  GetValue(TLeaf *leaf, Int_t instance = 0) : Return the value
 -  GetValuePointer(TLeaf *leaf, Int_t instance = 0) : Returns the address of the value
 -  GetLocalValuePointer(TLeaf *leaf, Int_t instance = 0) : Returns the address of the value of 'this' LeafInfo
 -  IsString()
 -  ReadValue(char *where, Int_t instance = 0) : Internal function to interpret the location 'where'
 -  Update() : react to the possible loading of a shared library.
*/
 
ClassImp(TTreeFormula);
 
////////////////////////////////////////////////////////////////////////////////
 
inline static void R__LoadBranch(TBranch* br, Long64_t entry, bool quickLoad)
{
   if (!quickLoad || (br->GetReadEntry() != entry)) {
      br->GetEntry(entry);
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// \brief Helper function checking if a string contains a literal number.
/// Whitespaces are not allowed as part of a valid number-string
/// \return true if it can be converted to a valid number (floating or integer),
/// false otherwise.
 
bool IsNumberConstant(const std::string &str)
{
   std::istringstream iss(str);
   double number;
   return iss >> std::noskipws >> number && iss.eof();
}
 
////////////////////////////////////////////////////////////////////////////////
/// \class TDimensionInfo
/// A small helper class to help in keeping track of the array
/// dimensions encountered in the analysis of the expression.
 
class TDimensionInfo : public TObject {
public:
   Int_t fCode;  // Location of the leaf in TTreeFormula::fCode
   Int_t fOper;  // Location of the Helper using the leaf in TTreeFormula::fOper
   Int_t fSize;
   TFormLeafInfoMultiVarDim* fMultiDim;
   TDimensionInfo(Int_t code, Int_t oper, Int_t size, TFormLeafInfoMultiVarDim* multiDim)
      : fCode(code), fOper(oper), fSize(size), fMultiDim(multiDim) {};
   ~TDimensionInfo() override {};
};
 
////////////////////////////////////////////////////////////////////////////////
/// TreeFormula constructor only valid for ROOT I/O purposes.
 
TTreeFormula::TTreeFormula(TRootIOCtor*): ROOT::v5::TFormula(), fQuickLoad(false), fNeedLoading(true),
   fDidBooleanOptimization(false), fDimensionSetup(nullptr)
 
{
   fTree         = nullptr;
   fLookupType   = nullptr;
   fNindex       = 0;
   fNcodes       = 0;
   fAxis         = nullptr;
   fHasCast      = false;
   fManager      = nullptr;
   fMultiplicity = 0;
   fConstLD      = nullptr;
 
   Int_t j,k;
   for (j=0; j<kMAXCODES; j++) {
      fNdimensions[j] = 0;
      fCodes[j] = 0;
      fNdata[j] = 1;
      fHasMultipleVarDim[j] = false;
      for (k = 0; k<kMAXFORMDIM; k++) {
         fIndexes[j][k] = -1;
         fCumulSizes[j][k] = 1;
         fVarIndexes[j][k] = nullptr;
      }
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Normal TTree Formula Constructor
 
TTreeFormula::TTreeFormula(const char *name,const char *expression, TTree *tree)
   :ROOT::v5::TFormula(), fTree(tree), fQuickLoad(false), fNeedLoading(true),
    fDidBooleanOptimization(false), fDimensionSetup(nullptr)
{
   Init(name,expression);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Constructor used during the expansion of an alias
 
TTreeFormula::TTreeFormula(const char *name,const char *expression, TTree *tree,
                           const std::vector<std::string>& aliases)
   :ROOT::v5::TFormula(), fTree(tree), fQuickLoad(false), fNeedLoading(true),
    fDidBooleanOptimization(false), fDimensionSetup(nullptr), fAliasesUsed(aliases)
{
   Init(name,expression);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Initialization called from the constructors.
 
void TTreeFormula::Init(const char*name, const char* expression)
{
   TDirectory *const savedir=gDirectory;
 
   fNindex       = kMAXFOUND;
   fLookupType   = new Int_t[fNindex];
   fNcodes       = 0;
   fMultiplicity = 0;
   fAxis         = nullptr;
   fHasCast      = false;
   fConstLD      = nullptr;
   Int_t i,j,k;
   fManager      = new TTreeFormulaManager;
   fManager->Add(this);
 
   for (j=0; j<kMAXCODES; j++) {
      fNdimensions[j] = 0;
      fLookupType[j] = kDirect;
      fCodes[j] = 0;
      fNdata[j] = 1;
      fHasMultipleVarDim[j] = false;
      for (k = 0; k<kMAXFORMDIM; k++) {
         fIndexes[j][k] = -1;
         fCumulSizes[j][k] = 1;
         fVarIndexes[j][k] = nullptr;
      }
   }
 
   fDimensionSetup = new TList;
 
   if (Compile(expression)) {
      fTree = nullptr; fNdim = 0;
      if(savedir) savedir->cd();
      return;
   }
 
   if (fNcodes >= kMAXFOUND) {
      Warning("TTreeFormula","Too many items in expression:%s",expression);
      fNcodes = kMAXFOUND;
   }
   SetName(name);
 
   for (i=0;i<fNoper;i++) {
 
      if (GetAction(i)==kDefinedString) {
         Int_t string_code = GetActionParam(i);
         TLeaf *leafc = (TLeaf*)fLeaves.UncheckedAt(string_code);
         if (!leafc) continue;
 
         // We have a string used as a string
 
         // This dormant portion of code would be used if (when?) we allow the histogramming
         // of the integral content (as opposed to the string content) of strings
         // held in a variable size container delimited by a null (as opposed to
         // a fixed size container or variable size container whose size is controlled
         // by a variable).  In GetNdata, we will then use strlen to grab the current length.
         //fCumulSizes[i][fNdimensions[i]-1] = 1;
         //fUsedSizes[fNdimensions[i]-1] = -TMath::Abs(fUsedSizes[fNdimensions[i]-1]);
         //fUsedSizes[0] = - TMath::Abs( fUsedSizes[0]);
 
         if (fNoper == 1) {
            // If the string is by itself, then it can safely be histogrammed as
            // in a string based axis.  To histogram the number inside the string
            // just make it part of a useless expression (for example: mystring+0)
            SetBit(kIsCharacter);
         }
         continue;
      }
      if (GetAction(i)==kJump && GetActionParam(i)==(fNoper-1)) {
         // We have cond ? string1 : string2
         if (IsString(fNoper-1)) SetBit(kIsCharacter);
      }
   }
   if (fNoper == 1 && GetAction(0)==kStringConst) {
      SetBit(kIsCharacter);
   }
   if (fNoper==1 && GetAction(0)==kAliasString) {
      TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(0));
      R__ASSERT(subform);
      if (subform->IsString()) SetBit(kIsCharacter);
   } else if (fNoper==2 && GetAction(0)==kAlternateString) {
      TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(0));
      R__ASSERT(subform);
      if (subform->IsString()) SetBit(kIsCharacter);
   }
 
   fManager->Sync();
 
   // Let's verify the indexes and dies if we need to.
   Int_t k0,k1;
   for(k0 = 0; k0 < fNcodes; k0++) {
      for(k1 = 0; k1 < fNdimensions[k0]; k1++ ) {
         // fprintf(stderr,"Saw %d dim %d and index %d\n",k1, fFixedSizes[k0][k1], fIndexes[k0][k1]);
         if ( fIndexes[k0][k1]>=0 && fFixedSizes[k0][k1]>=0
              && fIndexes[k0][k1]>=fFixedSizes[k0][k1]) {
            Error("TTreeFormula",
                  "Index %d for dimension #%d in %s is too high (max is %d)",
                  fIndexes[k0][k1],k1+1, expression,fFixedSizes[k0][k1]-1);
            fTree = nullptr; fNdim = 0;
            if(savedir) savedir->cd();
            return;
         }
      }
   }
 
   // Create a list of unique branches to load.
   for(k=0; k<fNcodes ; k++) {
      TLeaf *leaf = k <= fLeaves.GetLast() ? (TLeaf*)fLeaves.UncheckedAt(k) : nullptr;
      TBranch *branch = nullptr;
      if (leaf) {
         branch = leaf->GetBranch();
         if (fBranches.FindObject(branch)) branch = nullptr;
      }
      fBranches.AddAtAndExpand(branch,k);
   }
 
   if (IsInteger(false)) SetBit(kIsInteger);
 
   if (TestBit(TTreeFormula::kNeedEntries)) {
      // Call TTree::GetEntries() to insure that it is already calculated.
      // This will need to be done anyway at the first iteration and insure
      // that it will not mess up the branch reading (because TTree::GetEntries
      // opens all the file in the chain and 'stays' on the last file.
 
      Long64_t readentry = fTree->GetReadEntry();
      Int_t treenumber = fTree->GetTreeNumber();
      fTree->GetEntries();
      if (treenumber != fTree->GetTreeNumber()) {
         if (readentry >= 0) {
            fTree->LoadTree(readentry);
         }
         UpdateFormulaLeaves();
      } else {
         if (readentry >= 0) {
            fTree->LoadTree(readentry);
         }
      }
 
   }
 
   if(savedir) savedir->cd();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Tree Formula default destructor.
 
TTreeFormula::~TTreeFormula()
{
   if (fManager) {
      fManager->Remove(this);
      if (fManager->fFormulas.GetLast()<0) {
         delete fManager;
         fManager = nullptr;
      }
   }
   // Objects in fExternalCuts are not owned and should not be deleted
   // fExternalCuts.Clear();
   fLeafNames.Delete();
   fDataMembers.Delete();
   fMethods.Delete();
   fAliases.Delete();
   if (fLookupType) delete [] fLookupType;
   for (int j=0; j<fNcodes; j++) {
      for (int k = 0; k<fNdimensions[j]; k++) {
         if (fVarIndexes[j][k]) delete fVarIndexes[j][k];
         fVarIndexes[j][k] = nullptr;
      }
   }
   if (fDimensionSetup) {
      fDimensionSetup->Delete();
      delete fDimensionSetup;
   }
   delete[] fConstLD;
}
 
////////////////////////////////////////////////////////////////////////////////
/// This method is used internally to decode the dimensions of the variables.
 
void TTreeFormula::DefineDimensions(Int_t code, Int_t size,
                                    TFormLeafInfoMultiVarDim * info,
                                    Int_t& virt_dim) {
   if (info) {
      fManager->EnableMultiVarDims();
      //if (fIndexes[code][info->fDim]<0) { // removed because the index might be out of bounds!
         info->fVirtDim = virt_dim;
         fManager->AddVarDims(virt_dim); // if (!fVarDims[virt_dim]) fVarDims[virt_dim] = new TArrayI;
      //}
<