Logo ROOT  

Reference Guide
 
Loading...
Searching...
No Matches
TTreeFormula.cxx
Go to the documentation of this file.
1// @(#)root/treeplayer:$Id$
2// Author: Rene Brun 19/01/96
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#include "TROOT.h"
13#include "TTreeFormula.h"
14#include "TList.h"
15#include "TTree.h"
16#include "TBuffer.h"
17#include "TBranch.h"
18#include "TBranchObject.h"
19#include "TBranchElement.h"
20#include "TClonesArray.h"
21#include "TLeafB.h"
22#include "TLeafC.h"
23#include "TLeafElement.h"
24#include "TLeafObject.h"
25#include "TMethodCall.h"
26#include "TCutG.h"
27#include "TRandom.h"
28#include "TInterpreter.h"
29#include "TDataType.h"
30#include "TStreamerInfo.h"
31#include "TStreamerElement.h"
32#include "TArrayI.h"
33#include "TAxis.h"
34#include "TError.h"
35#include "TVirtualCollectionProxy.h"
36#include "TString.h"
37#include "TMath.h"
38
39#include "TVirtualRefProxy.h"
40#include "TTreeFormulaManager.h"
41#include "TFormLeafInfo.h"
42#include "TMethod.h"
43#include "TFormLeafInfoReference.h"
44#include "strlcpy.h"
45#include "snprintf.h"
46#include "TEntryList.h"
47
48#include <cctype>
49#include <cstdio>
50#include <cmath>
51#include <cstdlib>
52#include <limits>
53#include <typeinfo>
54#include <algorithm>
55#include <sstream>
56
57const Int_t kMaxLen = 2048;
58
59/** \class TTreeFormula
60Used to pass a selection expression to the Tree drawing routine. See TTree::Draw
61
62A TreeFormula can contain any arithmetic expression including
63standard operators and mathematical functions separated by operators.
64Examples of valid expression:
65~~~{.cpp}
66 "x<y && sqrt(z)>3.2"
67~~~
68TTreeFormula now relies on a variety of TFormLeafInfo classes to handle the
69reading of the information. Here is the list of theses classes:
70 - TFormLeafInfo
71 - TFormLeafInfoDirect
72 - TFormLeafInfoNumerical
73 - TFormLeafInfoClones
74 - TFormLeafInfoCollection
75 - TFormLeafInfoPointer
76 - TFormLeafInfoMethod
77 - TFormLeafInfoMultiVarDim
78 - TFormLeafInfoMultiVarDimDirect
79 - TFormLeafInfoCast
80
81The following method are available from the TFormLeafInfo interface:
82
83 - AddOffset(Int_t offset, TStreamerElement* element)
84 - GetCounterValue(TLeaf* leaf) : return the size of the array pointed to.
85 - GetObjectAddress(TLeafElement* leaf) : Returns the location of the object pointed to.
86 - GetMultiplicity() : Returns info on the variability of the number of elements
87 - GetNdata(TLeaf* leaf) : Returns the number of elements
88 - GetNdata() : Used by GetNdata(TLeaf* leaf)
89 - GetValue(TLeaf *leaf, Int_t instance = 0) : Return the value
90 - GetValuePointer(TLeaf *leaf, Int_t instance = 0) : Returns the address of the value
91 - GetLocalValuePointer(TLeaf *leaf, Int_t instance = 0) : Returns the address of the value of 'this' LeafInfo
92 - IsString()
93 - ReadValue(char *where, Int_t instance = 0) : Internal function to interpret the location 'where'
94 - Update() : react to the possible loading of a shared library.
95*/
96
97
98////////////////////////////////////////////////////////////////////////////////
99/// The function returns the number of bytes read from the input buffer.
100/// If entry does not exist or (entry!=readEntry && quickload), the function returns 0.
101/// If an I/O error occurs, the function returns -1.
102///
103[[nodiscard]] inline static Int_t R__LoadBranch(TBranch* br, Long64_t entry, bool quickLoad)
104{
105 if (!quickLoad || (br->GetReadEntry() != entry)) {
106 auto res = br->GetEntry(entry);
107 return res;
108 }
109 return 0;
110}
111
112////////////////////////////////////////////////////////////////////////////////
113/// \brief Helper function checking if a string contains a literal number.
114/// Whitespaces are not allowed as part of a valid number-string
115/// \return true if it can be converted to a valid number (floating or integer),
116/// false otherwise.
117
118bool IsNumberConstant(const std::string &str)
119{
120 std::istringstream iss(str);
121 double number;
122 return iss >> std::noskipws >> number && iss.eof();
123}
124
125////////////////////////////////////////////////////////////////////////////////
126/// \class TDimensionInfo
127/// A small helper class to help in keeping track of the array
128/// dimensions encountered in the analysis of the expression.
129
130class TDimensionInfo : public TObject {
131public:
132 Int_t fCode; // Location of the leaf in TTreeFormula::fCode
133 Int_t fOper; // Location of the Helper using the leaf in TTreeFormula::fOper
134 Int_t fSize;
135 TFormLeafInfoMultiVarDim* fMultiDim;
138 ~TDimensionInfo() override {};
139};
140
141////////////////////////////////////////////////////////////////////////////////
142/// TreeFormula constructor only valid for ROOT I/O purposes.
143
144TTreeFormula::TTreeFormula(TRootIOCtor*): ROOT::v5::TFormula(), fQuickLoad(false), fNeedLoading(true),
145 fDidBooleanOptimization(false), fDimensionSetup(nullptr)
146
147{
148 fTree = nullptr;
149 fLookupType = nullptr;
150 fNindex = 0;
151 fNcodes = 0;
152 fAxis = nullptr;
153 fHasCast = false;
154 fManager = nullptr;
155 fMultiplicity = 0;
156 fConstLD = nullptr;
157
158 Int_t j,k;
159 for (j=0; j<kMAXCODES; j++) {
160 fNdimensions[j] = 0;
161 fCodes[j] = 0;
162 fNdata[j] = 1;
163 fHasMultipleVarDim[j] = false;
164 for (k = 0; k<kMAXFORMDIM; k++) {
165 fIndexes[j][k] = -1;
166 fCumulSizes[j][k] = 1;
167 fVarIndexes[j][k] = nullptr;
168 }
169 }
170}
171
172////////////////////////////////////////////////////////////////////////////////
173/// Normal TTree Formula Constructor
174
175TTreeFormula::TTreeFormula(const char *name,const char *expression, TTree *tree)
176 :ROOT::v5::TFormula(), fTree(tree), fQuickLoad(false), fNeedLoading(true),
177 fDidBooleanOptimization(false), fDimensionSetup(nullptr)
178{
179 Init(name,expression);
180}
181
182////////////////////////////////////////////////////////////////////////////////
183/// Constructor used during the expansion of an alias
184
185TTreeFormula::TTreeFormula(const char *name,const char *expression, TTree *tree,
186 const std::vector<std::string>& aliases)
187 :ROOT::v5::TFormula(), fTree(tree), fQuickLoad(false), fNeedLoading(true),
188 fDidBooleanOptimization(false), fDimensionSetup(nullptr), fAliasesUsed(aliases)
189{
190 Init(name,expression);
191}
192
193////////////////////////////////////////////////////////////////////////////////
194/// Initialization called from the constructors.
195
196void TTreeFormula::Init(const char*name, const char* expression)
197{
198 TDirectory *const savedir=gDirectory;
199
200 fNindex = kMAXFOUND;
201 fLookupType = new Int_t[fNindex];
202 fNcodes = 0;
203 fMultiplicity = 0;
204 fAxis = nullptr;
205 fHasCast = false;
206 fConstLD = nullptr;
207 Int_t i,j,k;
208 fManager = new TTreeFormulaManager;
209 fManager->Add(this);
210
211 for (j=0; j<kMAXCODES; j++) {
212 fNdimensions[j] = 0;
213 fLookupType[j] = kDirect;
214 fCodes[j] = 0;
215 fNdata[j] = 1;
216 fHasMultipleVarDim[j] = false;
217 for (k = 0; k<kMAXFORMDIM; k++) {
218 fIndexes[j][k] = -1;
219 fCumulSizes[j][k] = 1;
220 fVarIndexes[j][k] = nullptr;
221 }
222 }
223
224 fDimensionSetup = new TList;
225
226 if (Compile(expression)) {
227 fTree = nullptr; fNdim = 0;
228 if(savedir) savedir->cd();
229 return;
230 }
231
232 if (fNcodes >= kMAXFOUND) {
233 Warning("TTreeFormula","Too many items in expression:%s",expression);
234 fNcodes = kMAXFOUND;
235 }
236 SetName(name);
237
238 for (i=0;i<fNoper;i++) {
239
240 if (GetAction(i)==kDefinedString) {
241 Int_t string_code = GetActionParam(i);
242 TLeaf *leafc = (TLeaf*)fLeaves.UncheckedAt(string_code);
243 if (!leafc) continue;
244
245 // We have a string used as a string
246
247 // This dormant portion of code would be used if (when?) we allow the histogramming
248 // of the integral content (as opposed to the string content) of strings
249 // held in a variable size container delimited by a null (as opposed to
250 // a fixed size container or variable size container whose size is controlled
251 // by a variable). In GetNdata, we will then use strlen to grab the current length.
252 //fCumulSizes[i][fNdimensions[i]-1] = 1;
253 //fUsedSizes[fNdimensions[i]-1] = -TMath::Abs(fUsedSizes[fNdimensions[i]-1]);
254 //fUsedSizes[0] = - TMath::Abs( fUsedSizes[0]);
255
256 if (fNoper == 1) {
257 // If the string is by itself, then it can safely be histogrammed as
258 // in a string based axis. To histogram the number inside the string
259 // just make it part of a useless expression (for example: mystring+0)
260 SetBit(kIsCharacter);
261 }
262 continue;
263 }
264 if (GetAction(i)==kJump && GetActionParam(i)==(fNoper-1)) {
265 // We have cond ? string1 : string2
266 if (IsString(fNoper-1)) SetBit(kIsCharacter);
267 }
268 }
269 if (fNoper == 1 && GetAction(0)==kStringConst) {
270 SetBit(kIsCharacter);
271 }
272 if (fNoper==1 && GetAction(0)==kAliasString) {
273 TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(0));
274 R__ASSERT(subform);
275 if (subform->IsString()) SetBit(kIsCharacter);
276 } else if (fNoper==2 && GetAction(0)==kAlternateString) {
277 TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(0));
278 R__ASSERT(subform);
279 if (subform->IsString()) SetBit(kIsCharacter);
280 }
281
282 fManager->Sync();
283
284 // Let's verify the indexes and dies if we need to.
285 Int_t k0,k1;
286 for(k0 = 0; k0 < fNcodes; k0++) {
287 for(k1 = 0; k1 < fNdimensions[k0]; k1++ ) {
288 // fprintf(stderr,"Saw %d dim %d and index %d\n",k1, fFixedSizes[k0][k1], fIndexes[k0][k1]);
289 if ( fIndexes[k0][k1]>=0 && fFixedSizes[k0][k1]>=0
290 && fIndexes[k0][k1]>=fFixedSizes[k0][k1]) {
291 Error("TTreeFormula",
292 "Index %d for dimension #%d in %s is too high (max is %d)",
293 fIndexes[k0][k1],k1+1, expression,fFixedSizes[k0][k1]-1);
294 fTree = nullptr; fNdim = 0;
295 if(savedir) savedir->cd();
296 return;
297 }
298 }
299 }
300
301 // Create a list of unique branches to load.
302 for(k=0; k<fNcodes ; k++) {
303 TLeaf *leaf = k <= fLeaves.GetLast() ? (TLeaf*)fLeaves.UncheckedAt(k) : nullptr;
304 TBranch *branch = nullptr;
305 if (leaf) {
306 branch = leaf->GetBranch();
307 if (fBranches.FindObject(branch)) branch = nullptr;
308 }
309 fBranches.AddAtAndExpand(branch,k);
310 }
311
312 if (IsInteger(false)) SetBit(kIsInteger);
313
314 if (TestBit(TTreeFormula::kNeedEntries)) {
315 // Call TTree::GetEntries() to insure that it is already calculated.
316 // This will need to be done anyway at the first iteration and insure
317 // that it will not mess up the branch reading (because TTree::GetEntries
318 // opens all the file in the chain and 'stays' on the last file.
319
320 Long64_t readentry = fTree->GetReadEntry();
321 Int_t treenumber = fTree->GetTreeNumber();
322 fTree->GetEntries();
323 if (treenumber != fTree->GetTreeNumber()) {
324 if (readentry >= 0) {
325 fTree->LoadTree(readentry);
326 }
327 UpdateFormulaLeaves();
328 } else {
329 if (readentry >= 0) {
330 fTree->LoadTree(readentry);
331 }
332 }
333
334 }
335
336 if(savedir) savedir->cd();
337}
338
339////////////////////////////////////////////////////////////////////////////////
340/// Tree Formula default destructor.
341
342TTreeFormula::~TTreeFormula()
343{
344 if (fManager) {
345 fManager->Remove(this);
346 if (fManager->fFormulas.GetLast()<0) {
347 delete fManager;
348 fManager = nullptr;
349 }
350 }
351 // Objects in fExternalCuts are not owned and should not be deleted
352 // fExternalCuts.Clear();
353 fLeafNames.Delete();
354 fDataMembers.Delete();
355 fMethods.Delete();
356 fAliases.Delete();
357 if (fLookupType) delete [] fLookupType;
358 for (int j=0; j<fNcodes; j++) {
359 for (int k = 0; k<fNdimensions[j]; k++) {
360 if (fVarIndexes[j][k]) delete fVarIndexes[j][k];
361 fVarIndexes[j][k] = nullptr;
362 }
363 }
364 if (fDimensionSetup) {
365 fDimensionSetup->Delete();
366 delete fDimensionSetup;
367 }
368 delete[] fConstLD;
369}
370
371////////////////////////////////////////////////////////////////////////////////
372/// This method is used internally to decode the dimensions of the variables.
373
374void TTreeFormula::DefineDimensions(Int_t code, Int_t size,
375 TFormLeafInfoMultiVarDim * info,
376 Int_t& virt_dim) {
377 if (info) {
378 fManager->EnableMultiVarDims();
379 //if (fIndexes[code][info->fDim]<0) { // removed because the index might be out of bounds!
380 info->fVirtDim = virt_dim;
381 fManager->AddVarDims(virt_dim); // if (!fVarDims[virt_dim]) fVarDims[virt_dim] = new TArrayI;
382 //}
383 }
384
385 Int_t vsize = 0;
386 bool scalarindex = false;
387
388 if (fIndexes[code][fNdimensions[code]]==-2) {
389 TTreeFormula *indexvar = fVarIndexes[code][fNdimensions[code]];
390 // ASSERT(indexvar!=0);
391 Int_t index_multiplicity = indexvar->GetMultiplicity();
392 switch (index_multiplicity) {
393 case 0:
394 scalarindex = true;
395 vsize = 1;
396 break;
397 case -1:
398 case 2:
399 vsize = indexvar->GetNdata();
400 break;
401 case 1:
402 vsize = -1;
403 break;
404 };
405 } else vsize = size;
406
407 fCumulSizes[code][fNdimensions[code]] = size;
408
409 if ( !scalarindex && fIndexes[code][fNdimensions[code]] < 0 ) {
410 fManager->UpdateUsedSize(virt_dim, vsize);
411 }
412
413 fNdimensions[code] ++;
414
415}
416
417////////////////////////////////////////////////////////////////////////////////
418/// This method is used internally to decode the dimensions of the variables.
419
420Int_t TTreeFormula::RegisterDimensions(const char *info, Int_t code)
421{
422 // We assume that there are NO white spaces in the info string
423 const char * current;
424 Int_t size, scanindex, vardim;
425
426 current = info;
427 vardim = 0;
428 // the next value could be before the string but
429 // that's okay because the next operation is ++
430 // (this is to avoid (?) a if statement at the end of the
431 // loop)
432 if (current[0] != '[') current--;
433 while (current) {
434 current++;
435 scanindex = sscanf(current,"%d",&size);
436 // if scanindex is 0 then we have a name index thus a variable
437 // array (or TClonesArray!).
438
439 if (scanindex==0) size = -1;
440
441 vardim += RegisterDimensions(code, size);
442
443 if (fNdimensions[code] >= kMAXFORMDIM) {
444 // NOTE: test that fNdimensions[code] is NOT too big!!
445
446 break;
447 }
448 current = (char*)strstr( current, "[" );
449 }
450 return vardim;
451}
452
453
454////////////////////////////////////////////////////////////////////////////////
455/// This method stores the dimension information for later usage.
456
464
465////////////////////////////////////////////////////////////////////////////////
466/// This method is used internally to decode the dimensions of the variables.
467
468Int_t TTreeFormula::RegisterDimensions(Int_t code, TFormLeafInfo *leafinfo,
469 TFormLeafInfo * /* maininfo */,
470 bool useCollectionObject) {
471 Int_t ndim, size, current, vardim;
472 vardim = 0;
473
474 const TStreamerElement * elem = leafinfo->fElement;
475 TClass* c = elem ? elem->GetClassPointer() : nullptr;
476
477 TFormLeafInfoMultiVarDim * multi = dynamic_cast<TFormLeafInfoMultiVarDim * >(leafinfo);
478 if (multi) {
479 // We have a second variable dimensions
480 fManager->EnableMultiVarDims();
481 multi->fDim = fNdimensions[code];
482 return RegisterDimensions(code, -1, multi);
483 }
484 if (elem->IsA() == TStreamerBasicPointer::Class()) {
485
486 if (elem->GetArrayDim()>0) {
487
488 ndim = elem->GetArrayDim();
489 size = elem->GetMaxIndex(0);
490 vardim += RegisterDimensions(code, -1);
491 } else {
492 ndim = 1;
493 size = -1;
494 }
495
496 TStreamerBasicPointer *array = (TStreamerBasicPointer*)elem;
497 TClass *cl = leafinfo->fClass;
498 Int_t offset;
499 TStreamerElement* counter = ((TStreamerInfo*)cl->GetStreamerInfo())->GetStreamerElement(array->GetCountName(),offset);
500#if 1
501 leafinfo->fCounter = new TFormLeafInfo(cl,offset,counter);
502#else /* Code is not ready yet see revision 14078 */
503 if (maininfo==0 || maininfo==leafinfo || 1) {
504 leafinfo->fCounter = new TFormLeafInfo(cl,offset,counter);
505 } else {
506 leafinfo->fCounter = maininfo->DeepCopy();
507 TFormLeafInfo *currentinfo = leafinfo->fCounter;
508 while(currentinfo->fNext && currentinfo->fNext->fNext) currentinfo=currentinfo->fNext;
509 delete currentinfo->fNext;
510 currentinfo->fNext = new TFormLeafInfo(cl,offset,counter);
511 }
512#endif
513 } else if (!useCollectionObject && elem->GetClassPointer() == TClonesArray::Class() ) {
514
515 ndim = 1;
516 size = -1;
517
518 TClass * clonesClass = TClonesArray::Class();
519 Int_t c_offset;
520 TStreamerElement *counter = ((TStreamerInfo*)clonesClass->GetStreamerInfo())->GetStreamerElement("fLast",c_offset);
521 leafinfo->fCounter = new TFormLeafInfo(clonesClass,c_offset,counter);
522
523 } else if (!useCollectionObject && elem->GetClassPointer() && elem->GetClassPointer()->GetCollectionProxy() ) {
524
525 if ( typeid(*leafinfo) == typeid(TFormLeafInfoCollection) ) {
526 ndim = 1;
527 size = -1;
528 } else {
529 R__ASSERT( fHasMultipleVarDim[code] );
530 ndim = 1;
531 size = 1;
532 }
533
534 } else if ( c && c->GetReferenceProxy() && c->GetReferenceProxy()->HasCounter() ) {
535 ndim = 1;
536 size = -1;
537 } else if (elem->GetArrayDim()>0) {
538
539 ndim = elem->GetArrayDim();
540 size = elem->GetMaxIndex(0);
541
542 } else if ( elem->GetNewType()== TStreamerInfo::kCharStar) {
543
544 // When we implement being able to read the length from
545 // strlen, we will have:
546 // ndim = 1;
547 // size = -1;
548 // until then we more or so die:
549 ndim = 1;
550 size = 1; //NOTE: changed from 0
551
552 } else return 0;
553
554 current = 0;
555 do {
556 vardim += RegisterDimensions(code, size);
557
558 if (fNdimensions[code] >= kMAXFORMDIM) {
559 // NOTE: test that fNdimensions[code] is NOT too big!!
560
561 break;
562 }
563 current++;
564 size = elem->GetMaxIndex(current);
565 } while (current<ndim);
566
567 return vardim;
568}
569
570////////////////////////////////////////////////////////////////////////////////
571/// This method is used internally to decode the dimensions of the variables.
572
573Int_t TTreeFormula::RegisterDimensions(Int_t code, TBranchElement *branch) {
574 TBranchElement * leafcount2 = branch->GetBranchCount2();
575 if (leafcount2) {
576 // With have a second variable dimensions
577 TBranchElement *leafcount = dynamic_cast<TBranchElement*>(branch->GetBranchCount());
578
579 R__ASSERT(leafcount); // The function should only be called on a functional TBranchElement object
580
581 fManager->EnableMultiVarDims();
582 TFormLeafInfoMultiVarDim * info = new TFormLeafInfoMultiVarDimDirect();
583 fDataMembers.AddAtAndExpand(info, code);
584 fHasMultipleVarDim[code] = true;
585
586 info->fCounter = new TFormLeafInfoDirect(leafcount);
587 info->fCounter2 = new TFormLeafInfoDirect(leafcount2);
588 info->fDim = fNdimensions[code];
589 //if (fIndexes[code][info->fDim]<0) {
590 // info->fVirtDim = virt_dim;
591 // if (!fVarDims[virt_dim]) fVarDims[virt_dim] = new TArrayI;
592 //}
593 return RegisterDimensions(code, -1, info);
594 }
595 return 0;
596}
597
598////////////////////////////////////////////////////////////////////////////////
599/// This method is used internally to decode the dimensions of the variables.
600
601Int_t TTreeFormula::RegisterDimensions(Int_t code, TLeaf *leaf) {
602 Int_t numberOfVarDim = 0;
603
604 // Let see if we can understand the structure of this branch.
605 // Usually we have: leafname[fixed_array], leaftitle[var_array]/type, leaftitle[n]/d[0,10,32]
606 // (with fixed_array that can be a multi-dimensional array).
607 TString sname = leaf->GetTitle();
608 auto slash = sname.First("/");
609 sname = (slash == TString::kNPOS) ? sname : sname(0, slash);
610 const char *tname = sname.Data();
611 char *leaf_dim = (char*)strstr( tname, "[" );
612
613 const char *bname = leaf->GetBranch()->GetName();
614 char *branch_dim = (char*)strstr(bname,"[");
615 if (branch_dim) branch_dim++; // skip the '['
616
617 bool isString = false;
618 if (leaf->IsA() == TLeafElement::Class()) {
619 Int_t type =((TBranchElement*)leaf->GetBranch())->GetStreamerType();
620 isString = (type == TStreamerInfo::kOffsetL+TStreamerInfo::kChar)
621 || (type == TStreamerInfo::kCharStar);
622 } else {
623 isString = (leaf->IsA() == TLeafC::Class());
624 }
625 if (leaf_dim) {
626 leaf_dim++; // skip the '['
627 if (!branch_dim || strncmp(branch_dim,leaf_dim,strlen(branch_dim))) {
628 // then both are NOT the same so do the leaf title first:
629 numberOfVarDim += RegisterDimensions( leaf_dim, code);
630 } else if (branch_dim && strncmp(branch_dim,leaf_dim,strlen(branch_dim))==0
631 && strlen(leaf_dim)>strlen(branch_dim)
632 && (leaf_dim+strlen(branch_dim))[0]=='[') {
633 // we have extra info in the leaf title
634 numberOfVarDim += RegisterDimensions( leaf_dim+strlen(branch_dim)+1, code);
635 }
636 }
637 if (branch_dim) {
638 // then both are NOT same so do the branch name next:
639 if (isString) {
640 numberOfVarDim += RegisterDimensions( code, 1);
641 } else {
642 numberOfVarDim += RegisterDimensions( branch_dim, code);
643 }
644 }
645 if (leaf->IsA() == TLeafElement::Class()) {
646 TBranchElement* branch = (TBranchElement*) leaf->GetBranch();
647 if (branch->GetBranchCount2()) {
648
649 if (!branch->GetBranchCount()) {
650 Warning("RegisterDimensions",
651 "Noticed an incorrect in-memory TBranchElement object (%s).\nIt has a BranchCount2 but no BranchCount!\nThe result might be incorrect!",
652 branch->GetName());
653 return numberOfVarDim;
654 }
655
656 // Switch from old direct style to using a TLeafInfo
657 if (fLookupType[code] == kDataMember)
658 Warning("RegisterDimensions",
659 "Already in kDataMember mode when handling multiple variable dimensions");
660 fLookupType[code] = kDataMember;
661
662 // Feed the information into the Dimensions system
663 numberOfVarDim += RegisterDimensions( code, branch);
664
665 }
666 }
667 return numberOfVarDim;
668}
669
670////////////////////////////////////////////////////////////////////////////////
671/// This method check for treat the case where expression contains `Alt$(`
672/// and load up both fAliases and fExpr. It also checks for `MinIf$(` and `MaxIf$(`
673/// We return:
674/// - -1 in case of failure
675/// - 0 in case we did not find any of `Alt$(`, `MinIf$(`, or `MaxIf$(`
676/// - the action number in case of success. (kAlternate, kMinIf or kMaxIf)
677
678Int_t TTreeFormula::DefineAlternate(const char *expression)
679{
680 static const char *altfunc = "Alt$(";
681 static const char *minfunc = "MinIf$(";
682 static const char *maxfunc = "MaxIf$(";
683 Int_t action = 0;
684 Int_t start = 0;
685
686 if ( strncmp(expression,altfunc,strlen(altfunc))==0
687 && expression[strlen(expression)-1]==')' ) {
688 action = kAlternate;
689 start = strlen(altfunc);
690 }
691 if ( strncmp(expression,maxfunc,strlen(maxfunc))==0
692 && expression[strlen(expression)-1]==')' ) {
693 action = kMaxIf;
694 start = strlen(maxfunc);
695 }
696 if ( strncmp(expression,minfunc,strlen(minfunc))==0
697 && expression[strlen(expression)-1]==')' ) {
698 action = kMinIf;
699 start = strlen(minfunc);
700 }
701
702 if (action) {
703 TString full = expression;
704 TString part1;
705 TString part2;
706 int paran = 0;
707 int instr = 0;
708 int brack = 0;
709 for(unsigned int i=start;i<strlen(expression);++i) {
710 switch (expression[i]) {
711 case '(': paran++; break;
712 case ')': paran--; break;
713 case '"': instr = instr ? 0 : 1; break;
714 case '[': brack++; break;
715 case ']': brack--; break;
716 };
717 if (expression[i]==',' && paran==0 && instr==0 && brack==0) {
718 part1 = full( start, i-start );
719 part2 = full( i+1, full.Length() -1 - (i+1) );
720 break; // out of the for loop
721 }
722 }
723 if (part1.Length() && part2.Length()) {
724 TTreeFormula *primary = new TTreeFormula("primary",part1,fTree);
725 TTreeFormula *alternate = new TTreeFormula("alternate",part2,fTree);
726
727 short isstring = 0;
728
729 if (action == kAlternate) {
730 if (alternate->GetManager()->GetMultiplicity() != 0 ) {
731 Error("DefineAlternate","The 2nd arguments in %s can not be an array (%s,%d)!",
732 expression,alternate->GetTitle(),
733 alternate->GetManager()->GetMultiplicity());
734 return -1;
735 }
736
737 // Should check whether we have strings.
738 if (primary->IsString()) {
739 if (!alternate->IsString()) {
740 Error("DefineAlternate",
741 "The 2nd arguments in %s has to return the same type as the 1st argument (string)!",
742 expression);
743 return -1;
744 }
745 isstring = 1;
746 } else if (alternate->IsString()) {
747 Error("DefineAlternate",
748 "The 2nd arguments in %s has to return the same type as the 1st argument (numerical type)!",
749 expression);
750 return -1;
751 }
752 } else {
753 primary->GetManager()->Add( alternate );
754 primary->GetManager()->Sync();
755 if (primary->IsString() || alternate->IsString()) {
756 if (!alternate->IsString()) {
757 Error("DefineAlternate",
758 "The arguments of %s can not be strings!",
759 expression);
760 return -1;
761 }
762 }
763 }
764
765 fAliases.AddAtAndExpand(primary,fNoper);
766 fExpr[fNoper] = "";
767 SetAction(fNoper, (Int_t)action + isstring, 0 );
768 ++fNoper;
769
770 fAliases.AddAtAndExpand(alternate,fNoper);
771 return (Int_t)kAlias + isstring;
772 }
773 }
774 return 0;
775}
776
777////////////////////////////////////////////////////////////////////////////////
778/// Decompose 'expression' as pointing to something inside the leaf
779/// Returns:
780/// - -2 Error: some information is missing (message already printed)
781/// - -1 Error: Syntax is incorrect (message already printed)
782/// - 0
783/// - >0 the value returns is the action code.
784
785Int_t TTreeFormula::ParseWithLeaf(TLeaf* leaf, const char* subExpression, bool final, UInt_t paran_level, TObjArray& castqueue, bool useLeafCollectionObject, const char* fullExpression)
786{
787 Int_t action = 0;
788
789 Int_t numberOfVarDim = 0;
790 char *current;
791
792 char scratch[kMaxLen]; scratch[0] = '\0';
793 char work[kMaxLen]; work[0] = '\0';
794
795 const char *right = subExpression;
796 TString name = fullExpression;
797
798 TBranch *branch = leaf ? leaf->GetBranch() : nullptr;
799 Long64_t readentry = fTree->GetTree()->GetReadEntry();
800 if (readentry < 0) readentry=0;
801
802 bool useLeafReferenceObject = false;
803 Int_t code = fNcodes-1;
804
805 // Make a check to prevent problem with some corrupted files (missing TStreamerInfo).
806 if (leaf && leaf->IsA()==TLeafElement::Class()) {
807 TBranchElement *br = nullptr;
808 if( branch->IsA() == TBranchElement::Class() )
809 {
810 br = ((TBranchElement*)branch);
811
812 if ( br->GetInfo() == nullptr ) {
813 Error("ParseWithLeaf","Missing StreamerInfo for %s. We will be unable to read!",
814 name.Data());
815 return -2;
816 }
817 }
818
819 TBranch *bmom = branch->GetMother();
820 if( bmom->IsA() == TBranchElement::Class() )
821 {
822 TBranchElement *mom = (TBranchElement*)br->GetMother();
823 if (mom!=br) {
824 if (mom->GetInfo()==nullptr) {
825 Error("ParseWithLeaf","Missing StreamerInfo for %s."
826 " We will be unable to read!",
827 mom->GetName());
828 return -2;
829 }
830 if ((mom->GetType()) < -1 && !mom->GetAddress()) {
831 Error("ParseWithLeaf", "Address not set when the type of the branch is negative for for %s. We will be unable to read!", mom->GetName());
832 return -2;
833 }
834 }
835 }
836 }
837
838 // We need to record the location in the list of leaves because
839 // the tree might actually be a chain and in that case the leaf will
840 // change from tree to tree!.
841
842 // Let's reconstruct the name of the leaf, including the possible friend alias
843 TTree *realtree = fTree->GetTree();
844 const char* alias = nullptr;
845 if (leaf) {
846 if (realtree) alias = realtree->GetFriendAlias(leaf->GetBranch()->GetTree());
847 if (!alias && realtree!=fTree) {
848 // Let's try on the chain
849 alias = fTree->GetFriendAlias(leaf->GetBranch()->GetTree());
850 }
851 }
852 Int_t leafname_len = 0;
853 if (alias) {
854 leafname_len = strlen(alias) + strlen(leaf->GetName()) + 1;
855 snprintf(scratch,kMaxLen-1,"%s.%s",alias,leaf->GetName()); // does not null-terminate if truncation happens
856 }
857 else if (leaf) {
858 leafname_len = strlen(leaf->GetName());
859 strlcpy(scratch,leaf->GetName(),kMaxLen); // null-terminates if truncation happens
860 }
861 if (leafname_len > kMaxLen - 1) {
862 Error("TTreeFormula",
863 "Length of leafname (%d) exceeds maximum allowed by the buffer (%d), formula will be truncated.",
864 leafname_len, kMaxLen - 1);
865 return -1;
866 }
867
868
869 TTree *tleaf = realtree;
870 if (leaf) {
871 tleaf = leaf->GetBranch()->GetTree();
872 fCodes[code] = tleaf->GetListOfLeaves()->IndexOf(leaf);
873 const char *mother_name = leaf->GetBranch()->GetMother()->GetName();
874 TString br_extended_name; // Could do ( strlen(mother_name)+strlen( leaf->GetBranch()->GetName() ) + 2 )
875 if (leaf->GetBranch()!=leaf->GetBranch()->GetMother()) {
876 if (mother_name[strlen(mother_name)-1]!='.') {
877 br_extended_name = mother_name;
878 br_extended_name.Append('.');
879 }
880 }
881 br_extended_name.Append( leaf->GetBranch()->GetName() );
882 Ssiz_t dim = br_extended_name.First('[');
883 if (dim >= 0) br_extended_name.Remove(dim);
884
885 TNamed *named = new TNamed(scratch,br_extended_name.Data());
886 fLeafNames.AddAtAndExpand(named,code);
887 fLeaves.AddAtAndExpand(leaf,code);
888 }
889
890 // If the leaf belongs to a friend tree which has an index, we might
891 // be in the case where some entry do not exist.
892 if (tleaf != realtree && tleaf->GetTreeIndex()) {
893 // reset the multiplicity
894 if (fMultiplicity >= 0) fMultiplicity = 1;
895 }
896
897 // Analyze the content of 'right'
898
899 // Try to find out the class (if any) of the object in the leaf.
900 TClass * cl = nullptr;
901 TFormLeafInfo *maininfo = nullptr;
902 TFormLeafInfo *previnfo = nullptr;
903 bool unwindCollection = false;
904 const static TClassRef stdStringClass = TClass::GetClass("string");
905
906 if (leaf==nullptr) {
907 TNamed *names = (TNamed*)fLeafNames.UncheckedAt(code);
908 fLeafNames.AddAt(nullptr,code);
909 TTree *what = (TTree*)fLeaves.UncheckedAt(code);
910 fLeaves.AddAt(nullptr,code);
911
912 cl = what ? what->IsA() : TTree::Class();
913 maininfo = new TFormLeafInfoTTree(fTree,names->GetName(),what);
914 previnfo = maininfo;
915
916 delete names;
917 } else if (leaf->InheritsFrom(TLeafObject::Class()) ) {
918 TBranchObject *bobj = (TBranchObject*)leaf->GetBranch();
919 cl = TClass::GetClass(bobj->GetClassName());
920 } else if (leaf->InheritsFrom(TLeafElement::Class())) {
921 TBranchElement *branchEl = (TBranchElement *)leaf->GetBranch();
922 branchEl->SetupAddresses();
923 TStreamerInfo *info = branchEl->GetInfo();
924 TStreamerElement *element = nullptr;
925 Int_t type = branchEl->GetStreamerType();
926 switch(type) {
927 case TStreamerInfo::kBase:
928 case TStreamerInfo::kObject:
929 case TStreamerInfo::kTString:
930 case TStreamerInfo::kTNamed:
931 case TStreamerInfo::kTObject:
932 case TStreamerInfo::kAny:
933 case TStreamerInfo::kAnyP:
934 case TStreamerInfo::kAnyp:
935 case TStreamerInfo::kSTL:
936 case TStreamerInfo::kSTLp:
937 case TStreamerInfo::kObjectp:
938 case TStreamerInfo::kObjectP: {
939 element = info->GetElement(branchEl->GetID());
940 if (element) cl = element->GetClassPointer();
941 }
942 break;
943 case TStreamerInfo::kOffsetL + TStreamerInfo::kSTL:
944 case TStreamerInfo::kOffsetL + TStreamerInfo::kSTLp:
945 case TStreamerInfo::kOffsetL + TStreamerInfo::kAny:
946 case TStreamerInfo::kOffsetL + TStreamerInfo::kAnyp:
947 case TStreamerInfo::kOffsetL + TStreamerInfo::kAnyP:
948 case TStreamerInfo::kOffsetL + TStreamerInfo::kObjectp:
949 case TStreamerInfo::kOffsetL + TStreamerInfo::kObjectP:
950 case TStreamerInfo::kOffsetL + TStreamerInfo::kObject: {
951 element = info->GetElement(branchEl->GetID());
952 if (element){
953 cl = element->GetClassPointer();
954 }
955 }
956 break;
957 case -1: {
958 cl = info->GetClass();
959 }
960 break;
961 }
962
963 // If we got a class object, we need to verify whether it is on a
964 // split TClonesArray sub branch.
965 if (cl && branchEl->GetBranchCount()) {
966 if (branchEl->GetType()==31) {
967 // This is inside a TClonesArray.
968
969 if (!element) {
970 Warning("ParseWithLeaf",
971 "Missing TStreamerElement in object in TClonesArray section");
972 return -2;
973 }
974 TFormLeafInfo* clonesinfo = new TFormLeafInfoClones(cl, 0, element, true);
975
976 // The following code was commented out because in THIS case
977 // the dimension are actually handled by parsing the title and name of the leaf
978 // and branch (see a little further)
979 // The dimension needs to be handled!
980 // numberOfVarDim += RegisterDimensions(code,clonesinfo);
981
982 maininfo = clonesinfo;
983
984 // We skip some cases because we can assume we have an object.
985 Int_t offset=0;
986 info->GetStreamerElement(element->GetName(),offset);
987 if (type == TStreamerInfo::kObjectp ||
988 type == TStreamerInfo::kObjectP ||
989 type == TStreamerInfo::kOffsetL + TStreamerInfo::kObjectp ||
990 type == TStreamerInfo::kOffsetL + TStreamerInfo::kObjectP ||
991 type == TStreamerInfo::kSTLp ||
992 type == TStreamerInfo::kAnyp ||
993 type == TStreamerInfo::kAnyP ||
994 type == TStreamerInfo::kOffsetL + TStreamerInfo::kSTLp ||
995 type == TStreamerInfo::kOffsetL + TStreamerInfo::kAnyp ||
996 type == TStreamerInfo::kOffsetL + TStreamerInfo::kAnyP) {
997 previnfo = new TFormLeafInfoPointer(cl,offset+branchEl->GetOffset(),element);
998 } else {
999 previnfo = new TFormLeafInfo(cl,offset+branchEl->GetOffset(),element);
1000 }
1001 maininfo->fNext = previnfo;
1002 unwindCollection = true;
1003
1004 } else if (branchEl->GetType()==41) {
1005
1006 // This is inside a Collection
1007
1008 if (!element) {
1009 Warning("ParseWithLeaf","Missing TStreamerElement in object in Collection section");
1010 return -2;
1011 }
1012 // First we need to recover the collection.
1013 TBranchElement *count = branchEl->GetBranchCount();
1014 TFormLeafInfo* collectioninfo;
1015 if ( count->GetID() >= 0 ) {
1016 TStreamerElement *collectionElement =
1017 count->GetInfo()->GetElement(count->GetID());
1018 TClass *collectionCl = collectionElement->GetClassPointer();
1019
1020 collectioninfo =
1021 new TFormLeafInfoCollection(collectionCl, 0, collectionElement, true);
1022 } else {
1023 TClass *collectionCl = TClass::GetClass(count->GetClassName());
1024 collectioninfo =
1025 new TFormLeafInfoCollection(collectionCl, 0, collectionCl, true);
1026 }
1027
1028 // The following code was commented out because in THIS case
1029 // the dimension are actually handled by parsing the title and name of the leaf
1030 // and branch (see a little further)
1031 // The dimension needs to be handled!
1032 // numberOfVarDim += RegisterDimensions(code,clonesinfo);
1033
1034 maininfo = collectioninfo;
1035
1036 // We skip some cases because we can assume we have an object.
1037 Int_t offset=0;
1038 info->GetStreamerElement(element->GetName(),offset);
1039 if (type == TStreamerInfo::kObjectp ||
1040 type == TStreamerInfo::kObjectP ||
1041 type == TStreamerInfo::kOffsetL + TStreamerInfo::kObjectp ||
1042 type == TStreamerInfo::kOffsetL + TStreamerInfo::kObjectP ||
1043 type == TStreamerInfo::kSTLp ||
1044 type == TStreamerInfo::kAnyp ||
1045 type == TStreamerInfo::kAnyP ||
1046 type == TStreamerInfo::kOffsetL + TStreamerInfo::kSTLp ||
1047 type == TStreamerInfo::kOffsetL + TStreamerInfo::kAnyp ||
1048 type == TStreamerInfo::kOffsetL + TStreamerInfo::kAnyP) {
1049 previnfo = new TFormLeafInfoPointer(cl,offset+branchEl->GetOffset(),element);
1050 } else {
1051 previnfo = new TFormLeafInfo(cl,offset+branchEl->GetOffset(),element);
1052 }
1053 maininfo->fNext = previnfo;
1054 unwindCollection = true;
1055 }
1056 } else if ( branchEl->GetType()==3) {
1057 TFormLeafInfo* clonesinfo;
1058 if (useLeafCollectionObject) {
1059 clonesinfo = new TFormLeafInfoCollectionObject(cl);
1060 } else {
1061 clonesinfo = new TFormLeafInfoClones(cl, 0, true);
1062 // The dimension needs to be handled!
1063 numberOfVarDim += RegisterDimensions(code,clonesinfo,maininfo,useLeafCollectionObject);
1064
1065 }
1066 maininfo = clonesinfo;
1067 previnfo = maininfo;
1068
1069 } else if (!useLeafCollectionObject && branchEl->GetType()==4) {
1070
1071 TFormLeafInfo* collectioninfo;
1072 if (useLeafCollectionObject) {
1073 collectioninfo = new TFormLeafInfoCollectionObject(cl);
1074 } else {
1075 collectioninfo = new TFormLeafInfoCollection(cl, 0, cl, true);
1076 // The dimension needs to be handled!
1077 numberOfVarDim += RegisterDimensions(code,collectioninfo,maininfo,useLeafCollectionObject);
1078 }
1079
1080 maininfo = collectioninfo;
1081 previnfo = maininfo;
1082
1083 } else if (branchEl->GetStreamerType()==-1 && cl && cl->GetCollectionProxy()) {
1084
1085 if (useLeafCollectionObject) {
1086
1087 TFormLeafInfo *collectioninfo = new TFormLeafInfoCollectionObject(cl);
1088 maininfo = collectioninfo;
1089 previnfo = collectioninfo;
1090
1091 } else {
1092 TFormLeafInfo *collectioninfo = new TFormLeafInfoCollection(cl, 0, cl, true);
1093 // The dimension needs to be handled!
1094 numberOfVarDim += RegisterDimensions(code,collectioninfo,maininfo,false);
1095
1096 maininfo = collectioninfo;
1097 previnfo = collectioninfo;
1098
1099 if (cl->GetCollectionProxy()->GetValueClass()!=nullptr &&
1100 cl->GetCollectionProxy()->GetValueClass()->GetCollectionProxy()!=nullptr) {
1101
1102 TFormLeafInfo *multi = new TFormLeafInfoMultiVarDimCollection(cl,0,
1103 cl->GetCollectionProxy()->GetValueClass(),collectioninfo);
1104
1105 fHasMultipleVarDim[code] = true;
1106 numberOfVarDim += RegisterDimensions(code,multi,maininfo,false);
1107 previnfo->fNext = multi;
1108 cl = cl->GetCollectionProxy()->GetValueClass();
1109 multi->fNext = new TFormLeafInfoCollection(cl, 0, cl, false);
1110 previnfo = multi->fNext;
1111
1112 }
1113 if (cl->GetCollectionProxy()->GetValueClass()==nullptr &&
1114 cl->GetCollectionProxy()->GetType()>0) {
1115
1116 previnfo->fNext =
1117 new TFormLeafInfoNumerical(cl->GetCollectionProxy());
1118 previnfo = previnfo->fNext;
1119 } else {
1120 // nothing to do
1121 }
1122 }
1123
1124 } else if (strlen(right)==0 && cl && element && final) {
1125
1126 TClass *elemCl = element->GetClassPointer();
1127 if (!useLeafCollectionObject
1128 && elemCl && elemCl->GetCollectionProxy()
1129 && elemCl->GetCollectionProxy()->GetValueClass()
1130 && elemCl->GetCollectionProxy()->GetValueClass()->GetCollectionProxy()) {
1131
1132 TFormLeafInfo *collectioninfo =
1133 new TFormLeafInfoCollection(cl, 0, elemCl);
1134
1135 // The dimension needs to be handled!
1136 numberOfVarDim += RegisterDimensions(code,collectioninfo,maininfo,false);
1137
1138 maininfo = collectioninfo;
1139 previnfo = collectioninfo;
1140
1141 TFormLeafInfo *multi =
1142 new TFormLeafInfoMultiVarDimCollection(elemCl, 0,
1143 elemCl->GetCollectionProxy()->GetValueClass(),
1144 collectioninfo);
1145
1146 fHasMultipleVarDim[code] = true;
1147 numberOfVarDim += RegisterDimensions(code,multi,maininfo,false);
1148 previnfo->fNext = multi;
1149 cl = elemCl->GetCollectionProxy()->GetValueClass();
1150 multi->fNext = new TFormLeafInfoCollection(cl, 0, cl, false);
1151 previnfo = multi->fNext;
1152
1153 if (cl->GetCollectionProxy()->GetValueClass()==nullptr &&
1154 cl->GetCollectionProxy()->GetType()>0) {
1155
1156 previnfo->fNext =
1157 new TFormLeafInfoNumerical(cl->GetCollectionProxy());
1158 previnfo = previnfo->fNext;
1159 }
1160
1161 } else if (!useLeafCollectionObject
1162 && elemCl && elemCl->GetCollectionProxy()
1163 && elemCl->GetCollectionProxy()->GetValueClass()==nullptr
1164 && elemCl->GetCollectionProxy()->GetType()>0) {
1165
1166 // At this point we have an element which is inside a class (which is not
1167 // a collection) and this element of a collection of numerical type.
1168 // (Note: it is not possible to have more than one variable dimension
1169 // unless we were supporting variable size C-style array of collection).
1170
1171 TFormLeafInfo* collectioninfo =
1172 new TFormLeafInfoCollection(cl, 0, elemCl);
1173
1174 // The dimension needs to be handled!
1175 numberOfVarDim += RegisterDimensions(code,collectioninfo,maininfo,false);
1176
1177 collectioninfo->fNext =
1178 new TFormLeafInfoNumerical(elemCl->GetCollectionProxy());
1179
1180 maininfo = collectioninfo;
1181 previnfo = maininfo->fNext;
1182
1183 } else if (!useLeafCollectionObject
1184 && elemCl && elemCl->GetCollectionProxy()) {
1185 if (elemCl->GetCollectionProxy()->GetValueClass()==TString::Class()) {
1186 right = "Data()";
1187 } else if (elemCl->GetCollectionProxy()->GetValueClass()==stdStringClass) {
1188 right = "c_str()";
1189 }
1190
1191 } else if (!element->IsaPointer()) {
1192
1193 maininfo = new TFormLeafInfoDirect(branchEl);
1194 previnfo = maininfo;
1195
1196 }
1197 }
1198 else if ( cl && cl->GetReferenceProxy() ) {
1199 if ( useLeafCollectionObject || fullExpression[0] == '@' || fullExpression[strlen(scratch)] == '@' ) {
1200 useLeafReferenceObject = true;
1201 }
1202 else {
1203 if ( !maininfo ) {
1204 maininfo = previnfo = new TFormLeafInfoReference(cl, element, 0);
1205 numberOfVarDim += RegisterDimensions(code,maininfo,maininfo,false);
1206 }
1207 TVirtualRefProxy *refproxy = cl->GetReferenceProxy();
1208 for(Long64_t i=0; i<leaf->GetBranch()->GetEntries()-readentry; ++i) {
1209 auto res = R__LoadBranch(leaf->GetBranch(), readentry+i, fQuickLoad);
1210 if (res < 0) {
1211 Error("ParseWithLeaf", "Branch could not be loaded:%d", res);
1212 continue;
1213 }
1214 void *refobj = maininfo->GetValuePointer(leaf,0);
1215 if (refobj) {
1216 cl = refproxy->GetValueClass(refobj);
1217 }
1218 if ( cl ) break;
1219 }
1220 if ( !cl ) {
1221 Error("ParseWithLeaf","Failed to access class type of reference target (%s)",element->GetName());
1222 return -1;
1223 }
1224 }
1225 }
1226 } else {
1227 // Regular/old TLeaf, there should not be anything afterward ...
1228 if (subExpression && subExpression[0]) {
1229 Error("ParseWithLeaf", "Found a numerical leaf but the name has trailing characters: \"%s\"", subExpression);
1230 return -1;
1231 }
1232 }
1233
1234 // Treat the dimension information in the leaf name, title and 2nd branch count
1235 if (leaf) numberOfVarDim += RegisterDimensions(code,leaf);
1236
1237 if (cl) {
1238 if (unwindCollection) {
1239 // So far we should get here only if we encounter a split collection of a class that contains
1240 // directly a collection.
1241 R__ASSERT(numberOfVarDim==1 && maininfo);
1242
1243 if (!useLeafCollectionObject && cl && cl->GetCollectionProxy()) {
1244 TFormLeafInfo *multi =
1245 new TFormLeafInfoMultiVarDimCollection(cl, 0, cl, maininfo);
1246 fHasMultipleVarDim[code] = true;
1247 numberOfVarDim += RegisterDimensions(code,multi,maininfo,false);
1248 previnfo->fNext = multi;
1249
1250 multi->fNext = new TFormLeafInfoCollection(cl, 0, cl, false);
1251 previnfo = multi->fNext;
1252
1253 if (cl->GetCollectionProxy()->GetValueClass()==nullptr &&
1254 cl->GetCollectionProxy()->GetType()>0) {
1255
1256 previnfo->fNext =
1257 new TFormLeafInfoNumerical(cl->GetCollectionProxy());
1258 previnfo = previnfo->fNext;
1259 }
1260 } else if (!useLeafCollectionObject && cl == TClonesArray::Class()) {
1261
1262 TFormLeafInfo *multi =
1263 new TFormLeafInfoMultiVarDimClones(cl, 0, cl, maininfo);
1264 fHasMultipleVarDim[code] = true;
1265 numberOfVarDim += RegisterDimensions(code,multi,maininfo,false);
1266 previnfo->fNext = multi;
1267
1268 multi->fNext = new TFormLeafInfoClones(cl, 0, false);
1269 previnfo = multi->fNext;
1270 }
1271 }
1272 Int_t offset=0;
1273 if (cl == TString::Class() && strcmp(right,"fData")==0) {
1274 // For backward compatibility replace TString::fData which no longer exist
1275 // by a call to TString::Data()
1276 right = "Data()";
1277 }
1278 Int_t nchname = strlen(right);
1279 TFormLeafInfo *leafinfo = nullptr;
1280 TStreamerElement* element = nullptr;
1281
1282 // Let see if the leaf was attempted to be casted.
1283 // Since there would have been something like
1284 // ((cast_class*)leafname)->.... we need to use
1285 // paran_level+1
1286 // Also we disable this functionality in case of TClonesArray
1287 // because it is not yet allowed to have 'inheritance' (or virtuality)
1288 // in play in a TClonesArray.
1289 {
1290 TClass * casted = (TClass*) castqueue.At(paran_level+1);
1291 if (casted && cl != TClonesArray::Class()) {
1292 if ( ! casted->InheritsFrom(cl) ) {
1293 Error("ParseWithLeaf","%s does not inherit from %s. Casting not possible!",
1294 casted->GetName(),cl->GetName());
1295 return -2;
1296 }
1297 leafinfo = new TFormLeafInfoCast(cl,casted);
1298 fHasCast = true;
1299 if (maininfo==nullptr) {
1300 maininfo = leafinfo;
1301 }
1302 if (previnfo==nullptr) {
1303 previnfo = leafinfo;
1304 } else {
1305 previnfo->fNext = leafinfo;
1306 previnfo = leafinfo;
1307 }
1308 leafinfo = nullptr;
1309
1310 cl = casted;
1311 castqueue.AddAt(nullptr,paran_level);
1312 }
1313 }
1314 Int_t i;
1315 bool prevUseCollectionObject = useLeafCollectionObject;
1316 bool useCollectionObject = useLeafCollectionObject;
1317 bool useReferenceObject = useLeafReferenceObject;
1318 bool prevUseReferenceObject = useLeafReferenceObject;
1319 for (i=0, current = &(work[0]); i<=nchname;i++ ) {
1320 // We will treated the terminator as a token.
1321 if (right[i] == '(') {
1322 // Right now we do not allow nested parenthesis
1323 do {
1324 *current++ = right[i++];
1325 } while(right[i]!=')' && right[i]);
1326 *current++ = right[i];
1327 *current='\0';
1328 char *params = strchr(work,'(');
1329 if (params) {
1330 *params = 0; params++;
1331 } else params = (char *) ")";
1332 if (cl==nullptr) {
1333 Error("ParseWithLeaf","Can not call '%s' with a class",work);
1334 return -1;
1335 }
1336 if (!cl->HasDataMemberInfo() && !cl->GetCollectionProxy()) {
1337 Error("ParseWithLeaf","Class probably unavailable:%s",cl->GetName());
1338 return -2;
1339 }
1340 if (!useCollectionObject && cl == TClonesArray::Class()) {
1341 // We are not interested in the ClonesArray object but only
1342 // in its contents.
1343 // We need to retrieve the class of its content.
1344
1345 TBranch *clbranch = leaf->GetBranch();
1346 auto lres = R__LoadBranch(clbranch,readentry,fQuickLoad);
1347 if (lres < 0) {
1348 Error("ParseWithLeaf", "Branch could not be loaded:%d", lres);
1349 return -2;
1350 }
1351 TClonesArray * clones;
1352 if (previnfo) clones = (TClonesArray*)previnfo->GetLocalValuePointer(leaf,0);
1353 else {
1354 bool top = (clbranch==((TBranchElement*)clbranch)->GetMother()
1355 || !leaf->IsOnTerminalBranch());
1356 TClass *mother_cl;
1357 if (leaf->IsA()==TLeafObject::Class()) {
1358 // in this case mother_cl is not really used
1359 mother_cl = cl;
1360 } else {
1361 mother_cl = ((TBranchElement*)clbranch)->GetInfo()->GetClass();
1362 }
1363 TFormLeafInfo* clonesinfo = new TFormLeafInfoClones(mother_cl, 0, top);
1364
1365 // The dimension needs to be handled!
1366 numberOfVarDim += RegisterDimensions(code,clonesinfo,maininfo,false);
1367
1368 previnfo = clonesinfo;
1369 maininfo = clonesinfo;
1370
1371 clones = (TClonesArray*)clonesinfo->GetLocalValuePointer(leaf,0);
1372 }
1373 TClass * inside_cl = clones ? clones->GetClass() : nullptr;
1374 cl = inside_cl;
1375
1376 }
1377 else if (!useCollectionObject && cl && cl->GetCollectionProxy() ) {
1378
1379 // We are NEVER (for now!) interested in the ClonesArray object but only
1380 // in its contents.
1381 // We need to retrieve the class of its content.
1382
1383 if (previnfo==nullptr) {
1384
1385 bool top = (branch==((TBranchElement*)branch)->GetMother()
1386 || !leaf->IsOnTerminalBranch());
1387
1388 TClass *mother_cl;
1389 if (leaf->IsA()==TLeafObject::Class()) {
1390 // in this case mother_cl is not really used
1391 mother_cl = cl;
1392 } else {
1393 mother_cl = ((TBranchElement*)branch)->GetInfo()->GetClass();
1394 }
1395
1396 TFormLeafInfo* collectioninfo =
1397 new TFormLeafInfoCollection(mother_cl, 0,cl,top);
1398 // The dimension needs to be handled!
1399 numberOfVarDim += RegisterDimensions(code,collectioninfo,maininfo,false);
1400
1401 previnfo = collectioninfo;
1402 maininfo = collectioninfo;
1403
1404 }
1405
1406 TClass * inside_cl = cl->GetCollectionProxy()->GetValueClass();
1407 if (inside_cl) cl = inside_cl;
1408 else if (cl->GetCollectionProxy()->GetType()>0) {
1409 Warning("ParseWithLeaf","Can not call method on content of %s in %s\n",
1410 cl->GetName(),name.Data());
1411 return -2;
1412 }
1413 }
1414 TMethodCall *method = nullptr;
1415 if (cl==nullptr) {
1416 Error("ParseWithLeaf",
1417 "Could not discover the TClass corresponding to (%s)!",
1418 right);
1419 return -2;
1420 } else if (cl==TClonesArray::Class() && strcmp(work,"size")==0) {
1421 method = new TMethodCall(cl, "GetEntriesFast", "");
1422 } else if (cl->GetCollectionProxy() && strcmp(work,"size")==0) {
1423 if (maininfo==nullptr) {
1424 TFormLeafInfo* collectioninfo=nullptr;
1425 if (useLeafCollectionObject) {
1426
1427 bool top = (branch==((TBranchElement*)branch)->GetMother()
1428 || !leaf->IsOnTerminalBranch());
1429 collectioninfo = new TFormLeafInfoCollectionObject(cl,top);
1430 }
1431 maininfo=previnfo=collectioninfo;
1432 }
1433 leafinfo = new TFormLeafInfoCollectionSize(cl);
1434 cl = nullptr;
1435 } else {
1436 if (!cl->HasDataMemberInfo()) {
1437 Error("ParseWithLeaf",
1438 "Can not call method %s on class without dictionary (%s)!",
1439 right,cl->GetName());
1440 return -2;
1441 }
1442 method = new TMethodCall(cl, work, params);
1443 }
1444 if (method) {
1445 if (!method->GetMethod()) {
1446 Error("ParseWithLeaf","Unknown method:%s in %s",right,cl->GetName());
1447 return -1;
1448 }
1449 switch(method->ReturnType()) {
1450 case TMethodCall::kLong:
1451 leafinfo = new TFormLeafInfoMethod(cl,method);
1452 cl = nullptr;
1453 break;
1454 case TMethodCall::kDouble:
1455 leafinfo = new TFormLeafInfoMethod(cl,method);
1456 cl = nullptr;
1457 break;
1458 case TMethodCall::kString:
1459 leafinfo = new TFormLeafInfoMethod(cl,method);
1460 // 1 will be replaced by -1 when we know how to use strlen
1461 numberOfVarDim += RegisterDimensions(code,1); //NOTE: changed from 0
1462 cl = nullptr;
1463 break;
1464 case TMethodCall::kOther:
1465 {
1466 leafinfo = new TFormLeafInfoMethod(cl,method);
1467 cl = TFormLeafInfoMethod::ReturnTClass(method);
1468 }
1469 break;
1470 default:
1471 Error("DefineVariable","Method %s from %s has an impossible return type %d",
1472 work,cl->GetName(), (Int_t)method->ReturnType());
1473 return -2;
1474 }
1475 }
1476 if (maininfo==nullptr) {
1477 maininfo = leafinfo;
1478 }
1479 if (previnfo==nullptr) {
1480 previnfo = leafinfo;
1481 } else {
1482 previnfo->fNext = leafinfo;
1483 previnfo = leafinfo;
1484 }
1485 leafinfo = nullptr;
1486 current = &(work[0]);
1487 *current = 0;
1488 prevUseCollectionObject = false;
1489 prevUseReferenceObject = false;
1490 useCollectionObject = false;
1491
1492 if (cl && cl->GetCollectionProxy()) {
1493 if (numberOfVarDim>1) {
1494 Warning("ParseWithLeaf","TTreeFormula support only 2 level of variables size collections. Assuming '@' notation for the collection %s.",
1495 cl->GetName());
1496 leafinfo = new TFormLeafInfo(cl,0,nullptr);
1497 useCollectionObject = true;
1498 } else if (numberOfVarDim==0) {
1499 R__ASSERT(maininfo);
1500 leafinfo = new TFormLeafInfoCollection(cl,0,cl);
1501 numberOfVarDim += RegisterDimensions(code,leafinfo,maininfo,false);
1502 } else if (numberOfVarDim==1) {
1503 R__ASSERT(maininfo);
1504 leafinfo =
1505 new TFormLeafInfoMultiVarDimCollection(cl,0,
1506 (TStreamerElement*)nullptr,maininfo);
1507 previnfo->fNext = leafinfo;
1508 previnfo = leafinfo;
1509 leafinfo = new TFormLeafInfoCollection(cl,0,cl);
1510
1511 fHasMultipleVarDim[code] = true;
1512 numberOfVarDim += RegisterDimensions(code,leafinfo,maininfo,false);
1513 }
1514 previnfo->fNext = leafinfo;
1515 previnfo = leafinfo;
1516 leafinfo = nullptr;
1517 }
1518 continue;
1519 } else if (right[i] == ')') {
1520 // We should have the end of a cast operator. Let's introduce a TFormLeafCast
1521 // in the chain.
1522 TClass * casted = (TClass*) ((int(--paran_level)>=0) ? castqueue.At(paran_level) : nullptr);
1523 if (casted) {
1524 leafinfo = new TFormLeafInfoCast(cl,casted);
1525 fHasCast = true;
1526
1527 if (maininfo==nullptr) {
1528 maininfo = leafinfo;
1529 }
1530 if (previnfo==nullptr) {
1531 previnfo = leafinfo;
1532 } else {
1533 previnfo->fNext = leafinfo;
1534 previnfo = leafinfo;
1535 }
1536 leafinfo = nullptr;
1537 current = &(work[0]);
1538 *current = 0;
1539
1540 cl = casted;
1541 continue;
1542
1543 }
1544 } else if (i > 0 && (right[i] == '.' || right[i] == '[' || right[i] == '\0') ) {
1545 // A delimiter happened let's see if what we have seen
1546 // so far does point to a data member.
1547 bool needClass = true;
1548 *current = '\0';
1549
1550 // skip it all if there is nothing to look at
1551 if (strlen(work)==0) continue;
1552
1553 prevUseCollectionObject = useCollectionObject;
1554 prevUseReferenceObject = useReferenceObject;
1555 if (work[0]=='@') {
1556 useReferenceObject = true;
1557 useCollectionObject = true;
1558 Int_t l = 0;
1559 for(l=0;work[l+1]!=0;++l) work[l] = work[l+1];
1560 work[l] = '\0';
1561 } else if (work[strlen(work)-1]=='@') {
1562 useReferenceObject = true;
1563 useCollectionObject = true;
1564 work[strlen(work)-1] = '\0';
1565 } else {
1566 useReferenceObject = false;
1567 useCollectionObject = false;
1568 }
1569
1570 bool mustderef = false;
1571 if ( !prevUseReferenceObject && cl && cl->GetReferenceProxy() ) {
1572 auto res = R__LoadBranch(leaf->GetBranch(), readentry, fQuickLoad);
1573 if (res < 0) {
1574 Error("ParseWithLeaf", "Branch could not be loaded:%d", res);
1575 return -2;
1576 }
1577 if ( !maininfo ) {
1578 maininfo = previnfo = new TFormLeafInfoReference(cl, element, offset);
1579 if ( cl->GetReferenceProxy()->HasCounter() ) {
1580 numberOfVarDim += RegisterDimensions(code,-1);
1581 }
1582 prevUseReferenceObject = false;
1583 } else {
1584 previnfo->fNext = new TFormLeafInfoReference(cl, element, offset);
1585 previnfo = previnfo->fNext;
1586 }
1587 TVirtualRefProxy *refproxy = cl->GetReferenceProxy();
1588 cl = nullptr;
1589 for(Long64_t entry=0; entry<leaf->GetBranch()->GetEntries()-readentry; ++entry) {
1590 auto eres = R__LoadBranch(leaf->GetBranch(), readentry+i, fQuickLoad);
1591 if (eres < 0) {
1592 Error("ParseWithLeaf", "Branch could not be loaded:%d", eres);
1593 return -2;
1594 }
1595 void *refobj = maininfo->GetValuePointer(leaf,0);
1596 if (refobj) {
1597 cl = refproxy->GetValueClass(refobj);
1598 }
1599 if ( cl ) break;
1600 }
1601 needClass = false;
1602 mustderef = true;
1603 }
1604 else if (!prevUseCollectionObject && cl == TClonesArray::Class()) {
1605 // We are not interested in the ClonesArray object but only
1606 // in its contents.
1607 // We need to retrieve the class of its content.
1608
1609 TBranch *clbranch = leaf->GetBranch();
1610 auto res = R__LoadBranch(clbranch,readentry,fQuickLoad);
1611 if (res < 0) {
1612 Error("ParseWithLeaf", "Branch could not be loaded:%d", res);
1613 return -2;
1614 }
1615 TClonesArray * clones;
1616 if (maininfo) {
1617 clones = (TClonesArray*)maininfo->GetValuePointer(leaf,0);
1618 } else {
1619 // we have a unsplit TClonesArray leaves
1620 // or we did not yet match any of the sub-branches!
1621
1622 TClass *mother_cl;
1623 if (leaf->IsA()==TLeafObject::Class()) {
1624 // in this case mother_cl is not really used
1625 mother_cl = cl;
1626 } else {
1627 mother_cl = ((TBranchElement*)clbranch)->GetInfo()->GetClass();
1628 }
1629
1630 TFormLeafInfo* clonesinfo = new TFormLeafInfoClones(mother_cl, 0);
1631 // The dimension needs to be handled!
1632 numberOfVarDim += RegisterDimensions(code,clonesinfo,maininfo,false);
1633
1634 mustderef = true;
1635 previnfo = clonesinfo;
1636 maininfo = clonesinfo;
1637
1638 if (clbranch->GetListOfBranches()->GetLast()>=0) {
1639 if (clbranch->IsA() != TBranchElement::Class()) {
1640 Error("ParseWithLeaf","Unimplemented usage of ClonesArray");
1641 return -2;
1642 }
1643 //clbranch = ((TBranchElement*)clbranch)->GetMother();
1644 clones = (TClonesArray*)((TBranchElement*)clbranch)->GetObject();
1645 } else
1646 clones = (TClonesArray*)clonesinfo->GetLocalValuePointer(leaf,0);
1647 }
1648 // NOTE clones can be zero!
1649 if (clones==nullptr) {
1650 Warning("ParseWithLeaf",
1651 "TClonesArray object was not retrievable for %s!",
1652 name.Data());
1653 return -1;
1654 }
1655 TClass * inside_cl = clones->GetClass();
1656#if 1
1657 cl = inside_cl;
1658#else
1659/* Maybe we should make those test lead to warning messages */
1660 if (1 || inside_cl) cl = inside_cl;
1661 // if inside_cl is nul ... we have a problem of inconsistency :(
1662 if (0 && strlen(work)==0) {
1663 // However in this case we have NO content :(
1664 // so let get the number of objects
1665 //strcpy(work,"fLast");
1666 }
1667#endif
1668 } else if (!prevUseCollectionObject && cl && cl->GetCollectionProxy() ) {
1669
1670 // We are NEVER interested in the Collection object but only
1671 // in its contents.
1672 // We need to retrieve the class of its content.
1673
1674 TBranch *clbranch = leaf->GetBranch();
1675 auto res = R__LoadBranch(clbranch,readentry,fQuickLoad);
1676 if (res < 0) {
1677 Error("ParseWithLeaf", "Branch could not be loaded:%d", res);
1678 return -2;
1679 }
1680
1681 if (maininfo==nullptr) {
1682
1683 // we have a unsplit Collection leaf
1684 // or we did not yet match any of the sub-branches!
1685
1686 TClass *mother_cl;
1687 if (leaf->IsA()==TLeafObject::Class()) {
1688 // in this case mother_cl is not really used
1689 mother_cl = cl;
1690 } else {
1691 mother_cl = ((TBranchElement*)clbranch)->GetInfo()->GetClass();
1692 }
1693
1694 TFormLeafInfo* collectioninfo =
1695 new TFormLeafInfoCollection(mother_cl, 0, cl);
1696 // The dimension needs to be handled!
1697 numberOfVarDim += RegisterDimensions(code,collectioninfo,maininfo,false);
1698
1699 mustderef = true;
1700 previnfo = collectioninfo;
1701 maininfo = collectioninfo;
1702
1703 } //else if (clbranch->GetStreamerType()==0) {
1704
1705 //}
1706
1707 TClass * inside_cl = cl->GetCollectionProxy()->GetValueClass();
1708
1709 if (!inside_cl) {
1710 Error("ParseWithLeaf","Could you not find the inner class for %s with coll type = %d",
1711 cl->GetName(),cl->GetCollectionProxy()->GetType());
1712 }
1713 if (!inside_cl && cl->GetCollectionProxy()->GetType() > 0) {
1714 Warning("ParseWithLeaf","No data member in content of %s in %s\n",
1715 cl->GetName(),name.Data());
1716 }
1717 cl = inside_cl;
1718 // if inside_cl is nul ... we have a problem of inconsistency.
1719 }
1720
1721 if (!cl) {
1722 if (leaf) leaf->GetBranch()->Print();
1723 Warning("ParseWithLeaf","Missing class for %s!",name.Data());
1724 } else {
1725 element = ((TStreamerInfo*)cl->GetStreamerInfo())->GetStreamerElement(work,offset);
1726 }
1727
1728 if (!element && !prevUseCollectionObject) {
1729 // We allow for looking for a data member inside a class inside
1730 // a TClonesArray without mentioning the TClonesArrays variable name
1731 TIter next( cl->GetStreamerInfo()->GetElements() );
1732 TStreamerElement * curelem;
1733 while ((curelem = (TStreamerElement*)next())) {
1734 if (curelem->GetClassPointer() == TClonesArray::Class()) {
1735 Int_t clones_offset = 0;
1736 ((TStreamerInfo*)cl->GetStreamerInfo())->GetStreamerElement(curelem->GetName(),clones_offset);
1737 TFormLeafInfo* clonesinfo =
1738 new TFormLeafInfo(cl, clones_offset, curelem);
1739 TClonesArray * clones;
1740 auto res = R__LoadBranch(leaf->GetBranch(),readentry,fQuickLoad);
1741 if (res < 0) {
1742 Error("ParseWithLeaf", "Branch could not be loaded:%d", res);
1743 return -2;
1744 }
1745
1746 if (previnfo) {
1747 previnfo->fNext = clonesinfo;
1748 clones = (TClonesArray*)maininfo->GetValuePointer(leaf,0);
1749 previnfo->fNext = nullptr;
1750 } else {
1751 clones = (TClonesArray*)clonesinfo->GetLocalValuePointer(leaf,0);
1752 }
1753
1754 TClass *sub_cl = clones->GetClass();
1755 if (sub_cl) element = ((TStreamerInfo*)sub_cl->GetStreamerInfo())->GetStreamerElement(work,offset);
1756 delete clonesinfo;
1757
1758 if (element) {
1759 leafinfo = new TFormLeafInfoClones(cl,clones_offset,curelem);
1760 numberOfVarDim += RegisterDimensions(code,leafinfo,maininfo,false);
1761 if (maininfo==nullptr) maininfo = leafinfo;
1762 if (previnfo==nullptr) previnfo = leafinfo;
1763 else {
1764 previnfo->fNext = leafinfo;
1765 previnfo = leafinfo;
1766 }
1767 leafinfo = nullptr;
1768 cl = sub_cl;
1769 break;
1770 }
1771 } else if (curelem->GetClassPointer() && curelem->GetClassPointer()->GetCollectionProxy()) {
1772
1773 Int_t coll_offset = 0;
1774 ((TStreamerInfo*)cl->GetStreamerInfo())->GetStreamerElement(curelem->GetName(),coll_offset);
1775
1776 TClass *sub_cl =
1777 curelem->GetClassPointer()->GetCollectionProxy()->GetValueClass();
1778 if (sub_cl) {
1779 element = ((TStreamerInfo*)sub_cl->GetStreamerInfo())->GetStreamerElement(work,offset);
1780 }
1781 if (element) {
1782 if (numberOfVarDim>1) {
1783 Warning("ParseWithLeaf","TTreeFormula support only 2 level of variables size collections. Assuming '@' notation for the collection %s.",
1784 curelem->GetName());
1785 leafinfo = new TFormLeafInfo(cl,coll_offset,curelem);
1786 useCollectionObject = true;
1787 } else if (numberOfVarDim==1) {
1788 R__ASSERT(maininfo);
1789 leafinfo =
1790 new TFormLeafInfoMultiVarDimCollection(cl,coll_offset,
1791 curelem,maininfo);
1792 fHasMultipleVarDim[code] = true;
1793 leafinfo->fNext = new TFormLeafInfoCollection(cl,coll_offset,curelem);
1794 numberOfVarDim += RegisterDimensions(code,leafinfo,maininfo,false);
1795 } else {
1796 leafinfo = new TFormLeafInfoCollection(cl,coll_offset,curelem);
1797 numberOfVarDim += RegisterDimensions(code,leafinfo,maininfo,false);
1798 }
1799 if (maininfo==nullptr) maininfo = leafinfo;
1800 if (previnfo==nullptr) previnfo = leafinfo;
1801 else {
1802 previnfo->fNext = leafinfo;
1803 previnfo = leafinfo;
1804 }
1805 if (leafinfo->fNext) {
1806 previnfo = leafinfo->fNext;
1807 }
1808 leafinfo = nullptr;
1809 cl = sub_cl;
1810 break;
1811 }
1812 }
1813 }
1814
1815 }
1816
1817 if (element) {
1818 Int_t type = element->GetNewType();
1819 if (type<60 && type!=0) {
1820 // This is a basic type ...
1821 if (numberOfVarDim>=1 && type>40) {
1822 // We have a variable array within a variable array!
1823 leafinfo = new TFormLeafInfoMultiVarDim(cl,offset,element,maininfo);
1824 fHasMultipleVarDim[code] = true;
1825 } else {
1826 if (leafinfo && type<=40 ) {
1827 leafinfo->AddOffset(offset,element);
1828 } else {
1829 leafinfo = new TFormLeafInfo(cl,offset,element);
1830 }
1831 }
1832 } else {
1833 bool object = false;
1834 bool pointer = false;
1835 bool objarr = false;
1836 switch(type) {
1837 case TStreamerInfo::kObjectp:
1838 case TStreamerInfo::kObjectP:
1839 case TStreamerInfo::kSTLp:
1840 case TStreamerInfo::kAnyp:
1841 case TStreamerInfo::kAnyP:
1842 case TStreamerInfo::kOffsetL + TStreamerInfo::kObjectP:
1843 case TStreamerInfo::kOffsetL + TStreamerInfo::kSTLp:
1844 case TStreamerInfo::kOffsetL + TStreamerInfo::kAnyp:
1845 case TStreamerInfo::kOffsetL + TStreamerInfo::kObjectp:
1846 case TStreamerInfo::kOffsetL + TStreamerInfo::kAnyP:
1847 pointer = true;
1848 break;
1849 case TStreamerInfo::kBase:
1850 case TStreamerInfo::kAny :
1851 case TStreamerInfo::kSTL:
1852 case TStreamerInfo::kObject:
1853 case TStreamerInfo::kTString:
1854 case TStreamerInfo::kTNamed:
1855 case TStreamerInfo::kTObject:
1856 object = true;
1857 break;
1858 case TStreamerInfo::kOffsetL + TStreamerInfo::kAny:
1859 case TStreamerInfo::kOffsetL + TStreamerInfo::kSTL:
1860 case TStreamerInfo::kOffsetL + TStreamerInfo::kObject:
1861 objarr = true;
1862 break;
1863 case TStreamerInfo::kStreamer:
1864 case TStreamerInfo::kStreamLoop:
1865 // Unsupported case.
1866 Error("ParseWithLeaf",
1867 "%s is a datamember of %s BUT is not yet of a supported type (%d)",
1868 right,cl ? cl->GetName() : "unknown class",type);
1869 return -2;
1870 default:
1871 // Unknown and Unsupported case.
1872 Error("ParseWithLeaf",
1873 "%s is a datamember of %s BUT is not of a unknown type (%d)",
1874 right,cl ? cl->GetName() : "unknown class",type);
1875 return -2;
1876 }
1877
1878 if (object && !useCollectionObject &&
1879 ( element->GetClassPointer() == TClonesArray::Class()
1880 || element->GetClassPointer()->GetCollectionProxy() ) )
1881 {
1882 object = false;
1883 }
1884 if (object && leafinfo) {
1885 leafinfo->AddOffset(offset,element);
1886 } else if (objarr) {
1887 // This is an embedded array of objects. We can not increase the offset.
1888 leafinfo = new TFormLeafInfo(cl,offset,element);
1889 mustderef = true;
1890 } else {
1891
1892 if (!useCollectionObject && element->GetClassPointer() == TClonesArray::Class()) {
1893
1894 leafinfo = new TFormLeafInfoClones(cl,offset,element);
1895 mustderef = true;
1896
1897 } else if (!useCollectionObject && element->GetClassPointer()
1898 && element->GetClassPointer()->GetCollectionProxy()) {
1899
1900 mustderef = true;
1901 if (numberOfVarDim>1) {
1902 Warning("ParseWithLeaf","TTreeFormula support only 2 level of variables size collections. Assuming '@' notation for the collection %s.",
1903 element->GetName());
1904 leafinfo = new TFormLeafInfo(cl,offset,element);
1905 useCollectionObject = true;
1906 } else if (numberOfVarDim==1) {
1907 R__ASSERT(maininfo);
1908 leafinfo =
1909 new TFormLeafInfoMultiVarDimCollection(cl,offset,element,maininfo);
1910
1911 fHasMultipleVarDim[code] = true;
1912 //numberOfVarDim += RegisterDimensions(code,leafinfo);
1913 //cl = cl->GetCollectionProxy()->GetValueClass();
1914
1915 //if (maininfo==0) maininfo = leafinfo;
1916 //if (previnfo==0) previnfo = leafinfo;
1917 //else {
1918 // previnfo->fNext = leafinfo;
1919 // previnfo = leafinfo;
1920 //}
1921 leafinfo->fNext = new TFormLeafInfoCollection(cl, offset, element);
1922 if (element->GetClassPointer()->GetCollectionProxy()->GetValueClass()==nullptr) {
1923 TFormLeafInfo *info = new TFormLeafInfoNumerical(
1924 element->GetClassPointer()->GetCollectionProxy());
1925 if (leafinfo->fNext) leafinfo->fNext->fNext = info;
1926 else leafinfo->fNext = info;
1927 }
1928 } else {
1929 leafinfo = new TFormLeafInfoCollection(cl, offset, element);
1930
1931 TClass *elemCl = element->GetClassPointer();
1932 TClass *valueCl = elemCl->GetCollectionProxy()->GetValueClass();
1933 if (!maininfo) maininfo = leafinfo;
1934
1935 if (valueCl!=nullptr && valueCl->GetCollectionProxy()!=nullptr) {
1936
1937 numberOfVarDim += RegisterDimensions(code,leafinfo,maininfo,false);
1938 if (previnfo==nullptr) previnfo = leafinfo;
1939 else {
1940 previnfo->fNext = leafinfo;
1941 previnfo = leafinfo;
1942 }
1943 leafinfo = new TFormLeafInfoMultiVarDimCollection(elemCl,0,
1944 elemCl->GetCollectionProxy()->GetValueClass(),maininfo);
1945 //numberOfVarDim += RegisterDimensions(code,previnfo->fNext);
1946 fHasMultipleVarDim[code] = true;
1947 //previnfo = previnfo->fNext;
1948 leafinfo->fNext = new TFormLeafInfoCollection(elemCl,0,
1949 valueCl);
1950 elemCl = valueCl;
1951 }
1952 if (elemCl->GetCollectionProxy() &&
1953 elemCl->GetCollectionProxy()->GetValueClass()==nullptr) {
1954 TFormLeafInfo *info = new TFormLeafInfoNumerical(elemCl->GetCollectionProxy());
1955 if (leafinfo->fNext) leafinfo->fNext->fNext = info;
1956 else leafinfo->fNext = info;
1957 }
1958 }
1959 } else if ( (object || pointer) && !useReferenceObject && element->GetClassPointer()->GetReferenceProxy() ) {
1960 TClass* c = element->GetClassPointer();
1961 auto res = R__LoadBranch(leaf->GetBranch(),readentry,fQuickLoad);
1962 if (res < 0) {
1963 Error("ParseWithLeaf", "Branch could not be loaded:%d", res);
1964 return -2;
1965 }
1966 if ( object ) {
1967 leafinfo = new TFormLeafInfoReference(c, element, offset);
1968 }
1969 else {
1970 leafinfo = new TFormLeafInfoPointer(cl,offset,element);
1971 leafinfo->fNext = new TFormLeafInfoReference(c, element, 0);
1972 }
1973 //if ( c->GetReferenceProxy()->HasCounter() ) {
1974 // numberOfVarDim += RegisterDimensions(code,-1);
1975 //}
1976 prevUseReferenceObject = false;
1977 needClass = false;
1978 mustderef = true;
1979 } else if (pointer) {
1980 // this is a pointer to be followed.
1981 leafinfo = new TFormLeafInfoPointer(cl,offset,element);
1982 mustderef = true;
1983 } else {
1984 // this is an embedded object.
1985 R__ASSERT(object);
1986 leafinfo = new TFormLeafInfo(cl,offset,element);
1987 }
1988 }
1989 }
1990 } else {
1991 if (cl) Error("ParseWithLeaf","%s is not a datamember of %s",work,cl->GetName());
1992 // no else, we warned earlier that the class was missing.
1993 return -1;
1994 }
1995
1996 numberOfVarDim += RegisterDimensions(code,leafinfo,maininfo,useCollectionObject); // Note or useCollectionObject||prevUseColectionObject
1997 if (maininfo==nullptr) {
1998 maininfo = leafinfo;
1999 }
2000 if (previnfo==nullptr) {
2001 previnfo = leafinfo;
2002 } else if (previnfo!=leafinfo) {
2003 previnfo->fNext = leafinfo;
2004 previnfo = leafinfo;
2005 }
2006 while (previnfo->fNext) previnfo = previnfo->fNext;
2007
2008 if ( right[i] != '\0' ) {
2009 if ( !needClass && mustderef ) {
2010 maininfo->SetBranch(leaf->GetBranch());
2011 char *ptr = (char*)maininfo->GetValuePointer(leaf,0);
2012 TFormLeafInfoReference* refInfo = nullptr;
2013 if ( !maininfo->IsReference() ) {
2014 for( TFormLeafInfo* inf = maininfo->fNext; inf; inf = inf->fNext ) {
2015 if ( inf->IsReference() ) {
2016 refInfo = (TFormLeafInfoReference*)inf;
2017 }
2018 }
2019 }
2020 else {
2021 refInfo = (TFormLeafInfoReference*)maininfo;
2022 }
2023 if ( refInfo ) {
2024 cl = refInfo->GetValueClass(ptr);
2025 if ( !cl ) {
2026 Error("ParseWithLeaf","Failed to access class type of reference target (%s)",element->GetName());
2027 return -1;
2028 }
2029 element = ((TStreamerInfo*)cl->GetStreamerInfo())->GetStreamerElement(work,offset);
2030 }
2031 else {
2032 Error("ParseWithLeaf","Failed to access class type of reference target (%s)",element->GetName());
2033 return -1;
2034 }
2035 }
2036 else if ( needClass ) {
2037 cl = element->GetClassPointer();
2038 }
2039 }
2040 if (mustderef) leafinfo = nullptr;
2041 current = &(work[0]);
2042 *current = 0;
2043 R__ASSERT(right[i] != '['); // We are supposed to have removed all dimensions already!
2044
2045 if (cl == TString::Class() && strcmp(right+i+1,"fData") == 0) {
2046 // For backward compatibility replace TString::fData which no longer exist
2047 // by a call to TString::Data()
2048 right = ".Data()";
2049 i = 0;
2050 nchname = strlen(right);
2051 }
2052
2053 } else
2054 *current++ = right[i];
2055 }
2056 if (maininfo) {
2057 fDataMembers.AddAtAndExpand(maininfo,code);
2058 if (leaf) fLookupType[code] = kDataMember;
2059 else fLookupType[code] = kTreeMember;
2060 }
2061 }
2062
2063 if (strlen(work)!=0) {
2064 // We have something left to analyze. Let's make this an error case!
2065 return -1;
2066 }
2067
2068 TClass *objClass = EvalClass(code);
2069 if (objClass && !useLeafCollectionObject && objClass->GetCollectionProxy() && objClass->GetCollectionProxy()->GetValueClass()) {
2070 TFormLeafInfo *last = nullptr;
2071 if ( SwitchToFormLeafInfo(code) ) {
2072
2073 last = (TFormLeafInfo*)fDataMembers.At(code);
2074
2075 if (!last) return action;
2076 while (last->fNext) { last = last->fNext; }
2077
2078 }
2079 if (last && last->GetClass() != objClass) {
2080 TClass *mother_cl;
2081 if (leaf->IsA()==TLeafObject::Class()) {
2082 // in this case mother_cl is not really used
2083 mother_cl = cl;
2084 } else {
2085 mother_cl = ((TBranchElement*)branch)->GetInfo()->GetClass();
2086 }
2087
2088 TFormLeafInfo* collectioninfo = new TFormLeafInfoCollection(mother_cl, 0, objClass, false);
2089 // The dimension needs to be handled!
2090 numberOfVarDim += RegisterDimensions(code,collectioninfo,maininfo,false);
2091 last->fNext = collectioninfo;
2092 }
2093 numberOfVarDim += RegisterDimensions(code,1); //NOTE: changed from 0
2094 objClass = objClass->GetCollectionProxy()->GetValueClass();
2095 }
2096 if (IsLeafString(code) || objClass == TString::Class() || objClass == stdStringClass) {
2097
2098 TFormLeafInfo *last = nullptr;
2099 if ( SwitchToFormLeafInfo(code) ) {
2100
2101 last = (TFormLeafInfo*)fDataMembers.At(code);
2102
2103 if (!last) return action;
2104 while (last->fNext) { last = last->fNext; }
2105
2106 }
2107 const char *funcname = nullptr;
2108 if (objClass == TString::Class()) {
2109 funcname = "Data";
2110 //tobetested: numberOfVarDim += RegisterDimensions(code,1,0); // Register the dim of the implied char*
2111 } else if (objClass == stdStringClass) {
2112 funcname = "c_str";
2113 //tobetested: numberOfVarDim += RegisterDimensions(code,1,0); // Register the dim of the implied char*
2114 }
2115 if (funcname) {
2116 TMethodCall *method = new TMethodCall(objClass, funcname, "");
2117 if (last) {
2118 last->fNext = new TFormLeafInfoMethod(objClass,method);
2119 } else {
2120 fDataMembers.AddAtAndExpand(new TFormLeafInfoMethod(objClass,method),code);
2121 if (leaf) fLookupType[code] = kDataMember;
2122 else fLookupType[code] = kTreeMember;
2123 }
2124 }
2125 return kDefinedString;
2126 }
2127
2128 if (objClass) {
2129 TMethodCall *method = new TMethodCall(objClass, "AsDouble", "");
2130 if (method->IsValid()
2131 && (method->ReturnType() == TMethodCall::kLong || method->ReturnType() == TMethodCall::kDouble)) {
2132
2133 TFormLeafInfo *last = nullptr;
2134 if (SwitchToFormLeafInfo(code)) {
2135 last = (TFormLeafInfo*)fDataMembers.At(code);
2136 // Improbable case
2137 if (!last) {
2138 delete method;
2139 return action;
2140 }
2141 while (last->fNext) { last = last->fNext; }
2142 }
2143 if (last) {
2144 last->fNext = new TFormLeafInfoMethod(objClass,method);
2145 } else {
2146 fDataMembers.AddAtAndExpand(new TFormLeafInfoMethod(objClass,method),code);
2147 if (leaf) fLookupType[code] = kDataMember;
2148 else fLookupType[code] = kTreeMember;
2149 }
2150
2151 return kDefinedVariable;
2152 }
2153 delete method;
2154 method = new TMethodCall(objClass, "AsString", "");
2155 if (method->IsValid()
2156 && method->ReturnType() == TMethodCall::kString) {
2157
2158 TFormLeafInfo *last = nullptr;
2159 if (SwitchToFormLeafInfo(code)) {
2160 last = (TFormLeafInfo*)fDataMembers.At(code);
2161 // Improbable case
2162 if (!last) {
2163 delete method;
2164 return action;
2165 }
2166 while (last->fNext) { last = last->fNext; }
2167 }
2168 if (last) {
2169 last->fNext = new TFormLeafInfoMethod(objClass,method);
2170 } else {
2171 fDataMembers.AddAtAndExpand(new TFormLeafInfoMethod(objClass,method),code);
2172 if (leaf) fLookupType[code] = kDataMember;
2173 else fLookupType[code] = kTreeMember;
2174 }
2175
2176 //tobetested: numberOfVarDim += RegisterDimensions(code,1,0); // Register the dim of the implied char*
2177 return kDefinedString;
2178 }
2179 if (method->IsValid()
2180 && method->ReturnType() == TMethodCall::kOther) {
2181
2182 TClass *rcl = TFormLeafInfoMethod::ReturnTClass(method);
2183 if ((rcl == TString::Class() || rcl == stdStringClass) ) {
2184
2185 TFormLeafInfo *last = nullptr;
2186 if (SwitchToFormLeafInfo(code)) {
2187 last = (TFormLeafInfo*)fDataMembers.At(code);
2188 // Improbable case
2189 if (!last) {
2190 delete method;
2191 return action;
2192 }
2193 while (last->fNext) { last = last->fNext; }
2194 }
2195 if (last) {
2196 last->fNext = new TFormLeafInfoMethod(objClass,method);
2197 last = last->fNext;
2198 } else {
2199 last = new TFormLeafInfoMethod(objClass,method);
2200 fDataMembers.AddAtAndExpand(last,code);
2201 if (leaf) fLookupType[code] = kDataMember;
2202 else fLookupType[code] = kTreeMember;
2203 }
2204
2205 objClass = rcl;
2206
2207 const char *funcname = nullptr;
2208 if (objClass == TString::Class()) {
2209 funcname = "Data";
2210 } else if (objClass == stdStringClass) {
2211 funcname = "c_str";
2212 }
2213 if (funcname) {
2214 method = new TMethodCall(objClass, funcname, "");
2215 last->fNext = new TFormLeafInfoMethod(objClass,method);
2216 }
2217 return kDefinedString;
2218 }
2219 }
2220 delete method;
2221 }
2222
2223 return action;
2224}
2225
2226////////////////////////////////////////////////////////////////////////////////
2227/// Look for the leaf corresponding to the start of expression.
2228/// It returns the corresponding leaf if any.
2229/// It also modify the following arguments:
2230///
2231/// - leftover: contain from expression that was not used to determine the leaf
2232/// - final:
2233/// * paran_level: number of un-matched open parenthesis
2234/// * cast_queue: list of cast to be done
2235/// * aliases: list of aliases used
2236/// - Return <0 in case of failure
2237///
2238/// - Return 0 if a leaf has been found
2239/// - Return 2 if info about the TTree itself has been requested.
2240
2241Int_t TTreeFormula::FindLeafForExpression(const char* expression, TLeaf*& leaf, TString& leftover, bool& final, UInt_t& paran_level, TObjArray& castqueue, std::vector<std::string>& aliasUsed, bool& useLeafCollectionObject, const char* fullExpression)
2242{
2243 // Later on we will need to read one entry, let's make sure
2244 // it is a real entry.
2245 if (fTree->GetTree()==nullptr) {
2246 fTree->LoadTree(0);
2247 if (fTree->GetTree()==nullptr) return -1;
2248 }
2249 Long64_t readentry = fTree->GetTree()->GetReadEntry();
2250 if (readentry < 0) readentry=0;
2251 const char *cname = expression;
2252 char first[kMaxLen]; first[0] = '\0';
2253 char second[kMaxLen*2]; second[0] = '\0';
2254 char right[kMaxLen*2]; right[0] = '\0';
2255 char work[kMaxLen]; work[0] = '\0';
2256 char left[kMaxLen]; left[0] = '\0';
2257 char scratch[kMaxLen*5];
2258 char scratch2[kMaxLen*5];
2259 std::string currentname;
2260 Int_t previousdot = 0;
2261 char *current;
2262 TLeaf *tmp_leaf=nullptr;
2263 TBranch *branch=nullptr, *tmp_branch=nullptr;
2264 Int_t nchname = strlen(cname);
2265 Int_t i;
2266 bool foundAtSign = false;
2267 bool startWithParan = false;
2268
2269 for (i=0, current = &(work[0]); i<=nchname && !final;i++ ) {
2270 // We will treated the terminator as a token.
2271 *current++ = cname[i];
2272
2273 if (cname[i] == '(') {
2274 ++paran_level;
2275
2276 if (current==work+1) {
2277 // If the expression starts with a parenthesis, we are likely
2278 // to have a cast operator inside.
2279 startWithParan = true;
2280 current--;
2281 }
2282 continue;
2283 //i++;
2284 //while( cname[i]!=')' && cname[i] ) {
2285 // *current++ = cname[i++];
2286 //}
2287 //*current++ = cname[i];
2288 ////*current = 0;
2289 //continue;
2290 }
2291 if (cname[i] == ')') {
2292 if (paran_level==0) {
2293 Error("FindLeafForExpression","Unmatched parenthesis in %s",fullExpression);
2294 return -1;
2295 }
2296 paran_level--;
2297
2298 if (startWithParan) {
2299 startWithParan = false; // the next match wont be against the starting parenthesis.
2300
2301 // Let's see if work is a classname and thus we have a cast.
2302 *(--current) = 0;
2303 TString cast_name = gInterpreter->TypeName(work);
2304 TClass *cast_cl = TClass::GetClass(cast_name);
2305 if (cast_cl) {
2306 // We must have a cast
2307 castqueue.AddAtAndExpand(cast_cl,paran_level);
2308 current = &(work[0]);
2309 *current = 0;
2310 // Warning("FindLeafForExpression","Found cast to %s",cast_fullExpression);
2311 continue;
2312 } else if (gROOT->GetType(cast_name)) {
2313 // We reset work
2314 current = &(work[0]);
2315 *current = 0;
2316 Warning("FindLeafForExpression",
2317 "Casting to primary types like \"%s\" is not supported yet",cast_name.Data());
2318 continue;
2319 }
2320 *(current++)=')';
2321 }
2322
2323 *current='\0';
2324 char *params = strchr(work,'(');
2325 if (params) {
2326 *params = 0; params++;
2327
2328 if (branch && !leaf) {
2329 // We have a branch but not a leaf. We are likely to have found
2330 // the top of split branch.
2331 if (BranchHasMethod(nullptr, branch, work, params, readentry)) {
2332 //fprintf(stderr, "Does have a method %s for %s.\n", work, branch->GetName());
2333 }
2334 }
2335
2336 // What we have so far might be a member function of one of the
2337 // leaves that are not split (for example "GetNtrack" for the Event class).
2338 TIter next(fTree->GetIteratorOnAllLeaves());
2339 TLeaf* leafcur = nullptr;
2340 while (!leaf && (leafcur = (TLeaf*) next())) {
2341 TBranch* br = leafcur->GetBranch();
2342 bool yes = BranchHasMethod(leafcur, br, work, params, readentry);
2343 if (yes) {
2344 leaf = leafcur;
2345 //fprintf(stderr, "Does have a method %s for %s found in leafcur %s.\n", work, leafcur->GetBranch()->GetName(), leafcur->GetName());
2346 }
2347 }
2348 if (!leaf) {
2349 // Check for an alias.
2350 if (strlen(left) && left[strlen(left)-1]=='.') left[strlen(left)-1]=0;
2351 const char *aliasValue = fTree->GetAlias(left);
2352 if (aliasValue && strcspn(aliasValue, "()[]+*/-%&!=<>|") == strlen(aliasValue) &&
2353 !IsNumberConstant(aliasValue)) {
2354 // First check whether we are using this alias recursively (this would
2355 // lead to an infinite recursion).
2356 if (find(aliasUsed.begin(),
2357 aliasUsed.end(),
2358 left) != aliasUsed.end()) {
2359 Error("FindLeafForExpression",
2360 "The substitution of the branch alias \"%s\" by \"%s\" in \"%s\" failed\n"\
2361 "\tbecause \"%s\" is used [recursively] in its own definition!",
2362 left,aliasValue,fullExpression,left);
2363 return -3;
2364 }
2365 aliasUsed.push_back(left);
2366 TString newExpression = aliasValue;
2367 newExpression += (cname+strlen(left));
2368 Int_t res = FindLeafForExpression(newExpression, leaf, leftover, final, paran_level,
2369 castqueue, aliasUsed, useLeafCollectionObject, fullExpression);
2370 if (res<0) {
2371 Error("FindLeafForExpression",
2372 "The substitution of the alias \"%s\" by \"%s\" failed.",left,aliasValue);
2373 return -3;
2374 }
2375 return res;
2376 }
2377
2378 // This is actually not really any error, we probably received something
2379 // like "abs(some_val)", let ROOT::v5::TFormula decompose it first.
2380 return -1;
2381 }
2382 // if (!leaf->InheritsFrom(TLeafObject::Class()) ) {
2383 // If the leaf that we found so far is not a TLeafObject then there is
2384 // nothing we would be able to do.
2385 // Error("FindLeafForExpression","Need a TLeafObject to call a function!");
2386 // return -1;
2387 //}
2388 // We need to recover the info not used.
2389 strlcpy(right,work,2*kMaxLen);
2390 strncat(right,"(",2*kMaxLen-1-strlen(right));
2391 strncat(right,params,2*kMaxLen-1-strlen(right));
2392 final = true;
2393
2394 // Record in 'i' what we consumed
2395 i += 2; // open and close parentheses
2396
2397 // we reset work
2398 current = &(work[0]);
2399 *current = 0;
2400 break;
2401 }
2402 }
2403 if (cname[i] == '.' || cname[i] == '\0' || cname[i] == ')') {
2404 // A delimiter happened let's see if what we have seen
2405 // so far does point to a leaf.
2406 *current = '\0';
2407
2408 Int_t len = strlen(work);
2409 if (work[0]=='@') {
2410 foundAtSign = true;
2411 Int_t l = 0;
2412 for(l=0;work[l+1]!=0;++l) work[l] = work[l+1];
2413 work[l] = '\0';
2414 --current;
2415 } else if (len>=2 && work[len-2]=='@') {
2416 foundAtSign = true;
2417 work[len-2] = cname[i];
2418 work[len-1] = '\0';
2419 --current;
2420 } else {
2421 foundAtSign = false;
2422 }
2423
2424 if (left[0]==0) strlcpy(left,work,kMaxLen);
2425 if (!leaf && !branch) {
2426 // So far, we have not found a matching leaf or branch.
2427 strlcpy(first,work,kMaxLen);
2428
2429 std::string treename(first);
2430 if (!treename.empty() && treename[treename.size()-1]=='.') {
2431 treename.erase(treename.size()-1);
2432 }
2433 if (treename== "This" /* || treename == fTree->GetName() */ ) {
2434 // Request info about the TTree object itself,
2435 TNamed *named = new TNamed(fTree->GetName(),fTree->GetName());
2436 fLeafNames.AddAtAndExpand(named,fNcodes);
2437 fLeaves.AddAtAndExpand(fTree,fNcodes);
2438 if (cname[i]) leftover = &(cname[i+1]);
2439 return 2;
2440 }
2441 // The following would allow to access the friend by name
2442 // however, it would also prevent the access of the leaves
2443 // within the friend. We could use the '@' notation here
2444 // however this would not be aesthetically pleasing :(
2445 // What we need to do, is add the ability to look ahead to
2446 // the next 'token' to decide whether we to access the tree
2447 // or its leaf.
2448 //} else {
2449 // TTree *tfriend = fTree->GetFriend(treename.c_str());
2450 // TTree *realtree = fTree->GetTree();
2451 // if (!tfriend && realtree != fTree){
2452 // // If it is a chain and we did not find a friend,
2453 // // let's try with the internal tree.
2454 // tfriend = realtree->GetFriend(treename.c_str());
2455 // }
2456 // if (tfriend) {
2457 // TNamed *named = new TNamed(treename.c_str(),tfriend->GetName());
2458 // fLeafNames.AddAtAndExpand(named,fNcodes);
2459 // fLeaves.AddAtAndExpand(tfriend,fNcodes);
2460 // if (cname[i]) leftover = &(cname[i+1]);
2461 // return 2;
2462 // }
2463 //}
2464
2465 branch = fTree->FindBranch(first);
2466 leaf = fTree->FindLeaf(first);
2467
2468 // Now look with the delimiter removed (we looked with it first
2469 // because a dot is allowed at the end of some branches).
2470 if (cname[i]) first[strlen(first)-1]='\0';
2471 if (!branch) branch = fTree->FindBranch(first);
2472 if (!leaf) leaf = fTree->FindLeaf(first);
2473 TClass* cl = nullptr;
2474 if ( branch && branch->InheritsFrom(TBranchElement::Class()) ) {
2475 int offset=0;
2476 TBranchElement* bElt = (TBranchElement*)branch;
2477 TStreamerInfo* info = bElt->GetInfo();
2478 TStreamerElement* element = info ? info->GetStreamerElement(first,offset) : nullptr;
2479 if (element) cl = element->GetClassPointer();
2480 if ( cl && !cl->GetReferenceProxy() ) cl = nullptr;
2481 }
2482 if ( cl ) { // We have a reference class here....
2483 final = true;
2484 useLeafCollectionObject = foundAtSign;
2485 // we reset work
2486 current = &(work[0]);
2487 *current = 0;
2488 }
2489 else if (branch && (foundAtSign || cname[i] != 0) ) {
2490 // Since we found a branch and there is more information in the name,
2491 // we do NOT look at the 'IsOnTerminalBranch' status of the leaf
2492 // we found ... yet!
2493
2494 if (leaf==nullptr) {
2495 // Note we do not know (yet?) what (if anything) to do
2496 // for a TBranchObject branch.
2497 if (branch->InheritsFrom(TBranchElement::Class()) ) {
2498 Int_t type = ((TBranchElement*)branch)->GetType();
2499 if ( type == 3 || type ==4) {
2500 // We have a Collection branch.
2501 leaf = (TLeaf*)branch->GetListOfLeaves()->At(0);
2502 if (foundAtSign) {
2503 useLeafCollectionObject = foundAtSign;
2504 foundAtSign = false;
2505 current = &(work[0]);
2506 *current = 0;
2507 ++i;
2508 break;
2509 }
2510 }
2511 }
2512 }
2513
2514 // we reset work
2515 useLeafCollectionObject = foundAtSign;
2516 foundAtSign = false;
2517 current = &(work[0]);
2518 *current = 0;
2519 } else if (leaf || branch) {
2520 if (leaf && branch) {
2521 // We found both a leaf and branch matching the request name
2522 // let's see which one is the proper one to use! (On annoying case
2523 // is that where the same name is repeated ( varname.varname )
2524
2525 // We always give priority to the branch
2526 // leaf = 0;
2527 }
2528 if (leaf && leaf->IsOnTerminalBranch()) {
2529 // This is a non-object leaf, it should NOT be specified more except for
2530 // dimensions.
2531 final = true;
2532 }
2533 // we reset work
2534 current = &(work[0]);
2535 *current = 0;
2536 } else {
2537 // What we have so far might be a data member of one of the
2538 // leaves that are not split (for example "fNtrack" for the Event class.
2539 TLeaf *leafcur = GetLeafWithDatamember(first,work,readentry);
2540 if (leafcur) {
2541 leaf = leafcur;
2542 branch = leaf->GetBranch();
2543 if (leaf->IsOnTerminalBranch()) {
2544 final = true;
2545 strlcpy(right,first,kMaxLen);
2546 //We need to put the delimiter back!
2547 if (foundAtSign) strncat(right,"@",2*kMaxLen-1-strlen(right));
2548 if (cname[i]=='.') strncat(right,".",2*kMaxLen-1-strlen(right));
2549
2550 // We reset work
2551 current = &(work[0]);
2552 *current = 0;
2553 };
2554 } else if (cname[i] == '.') {
2555 // If we have a branch that match a name preceded by a dot
2556 // then we assume we are trying to drill down the branch
2557 // Let look if one of the top level branch has a branch with the name
2558 // we are looking for.
2559 TBranch *branchcur;
2560 TIter next( fTree->GetListOfBranches() );
2561 while(!branch && (branchcur=(TBranch*)next()) ) {
2562 branch = branchcur->FindBranch(first);
2563 }
2564 if (branch) {
2565 // We reset work
2566 current = &(work[0]);
2567 *current = 0;
2568 }
2569 }
2570 }
2571 } else { // correspond to if (leaf || branch)
2572 if (final) {
2573 Error("FindLeafForExpression", "Unexpected control flow!");
2574 return -1;
2575 }
2576
2577 // No dot is allowed in subbranches and leaves, so
2578 // we always remove it in the present case.
2579 if (cname[i]) work[strlen(work)-1] = '\0';
2580 snprintf(scratch,sizeof(scratch),"%s.%s",first,work);
2581 snprintf(scratch2,sizeof(scratch2),"%s.%s.%s",first,second,work);
2582
2583 if (previousdot) {
2584 currentname = &(work[previousdot+1]);
2585 }
2586
2587 // First look for the current 'word' in the list of
2588 // leaf of the
2589 if (branch) {
2590 tmp_leaf = branch->FindLeaf(work);
2591 if (!tmp_leaf) tmp_leaf = branch->FindLeaf(scratch);
2592 if (!tmp_leaf) tmp_leaf = branch->FindLeaf(scratch2);
2593 if (!tmp_leaf) tmp_leaf = branch->FindLeaf(currentname.c_str());
2594 }
2595 if (tmp_leaf && tmp_leaf->IsOnTerminalBranch() ) {
2596 // This is a non-object leaf, it should NOT be specified more except for
2597 // dimensions.
2598 final = true;
2599 }
2600
2601 if (branch) {
2602 tmp_branch = branch->FindBranch(work);
2603 if (!tmp_branch) tmp_branch = branch->FindBranch(scratch);
2604 if (!tmp_branch) tmp_branch = branch->FindBranch(scratch2);
2605 if (!tmp_branch) tmp_branch = branch->FindBranch(currentname.c_str());
2606 }
2607 if (tmp_branch) {
2608 branch=tmp_branch;
2609
2610 // NOTE: Should we look for a leaf within here?
2611 if (!final) {
2612 tmp_leaf = branch->FindLeaf(work);
2613 if (!tmp_leaf) tmp_leaf = branch->FindLeaf(scratch);
2614 if (!tmp_leaf) tmp_leaf = branch->FindLeaf(scratch2);
2615 if (!tmp_leaf) tmp_leaf = branch->FindLeaf(currentname.c_str());
2616 if (tmp_leaf && tmp_leaf->IsOnTerminalBranch() ) {
2617 // This is a non-object leaf, it should NOT be specified
2618 // more except for dimensions.
2619 final = true;
2620 leaf = tmp_leaf;
2621 }
2622 }
2623 }
2624 if (tmp_leaf) {
2625 // Something was found.
2626 if (second[0]) strncat(second,".",2*kMaxLen-1-strlen(second));
2627 strncat(second,work,2*kMaxLen-1-strlen(second));
2628 leaf = tmp_leaf;
2629 useLeafCollectionObject = foundAtSign;
2630 foundAtSign = false;
2631
2632 // we reset work
2633 current = &(work[0]);
2634 *current = 0;
2635 } else {
2636 //We need to put the delimiter back!
2637 if (strlen(work)) {
2638 if (foundAtSign) {
2639 Int_t where = strlen(work);
2640 work[where] = '@';
2641 work[where+1] = cname[i];
2642 ++current;
2643 previousdot = where+1;
2644 } else {
2645 previousdot = strlen(work);
2646 work[strlen(work)] = cname[i];
2647 }
2648 } else --current;
2649 }
2650 }
2651 }
2652 }
2653
2654 // Copy the left over for later use.
2655 if (strlen(work)) {
2656 strncat(right,work,2*kMaxLen-1-strlen(right));
2657 }
2658
2659 if (i<nchname) {
2660 if (strlen(right) && right[strlen(right)-1]!='.' && cname[i]!='.') {
2661 // In some cases we remove a little too fast the period, we add
2662 // it back if we need. It is assumed that 'right' and the rest of
2663 // the name was cut by a delimiter, so this should be safe.
2664 strncat(right,".",2*kMaxLen-1-strlen(right));
2665 }
2666 strncat(right,&cname[i],2*kMaxLen-1-strlen(right));
2667 }
2668
2669 if (!final && branch) {
2670 if (!leaf) {
2671 leaf = (TLeaf*)branch->GetListOfLeaves()->UncheckedAt(0);
2672 if (!leaf) return -1;
2673 }
2674 final = leaf->IsOnTerminalBranch();
2675 }
2676
2677 if (leaf && leaf->InheritsFrom(TLeafObject::Class()) ) {
2678 if (strlen(right)==0) strlcpy(right,work,2*kMaxLen);
2679 }
2680
2681 if (leaf==nullptr && left[0]!=0) {
2682 if (left[strlen(left)-1]=='.') left[strlen(left)-1]=0;
2683
2684 // Check for an alias.
2685 const char *aliasValue = fTree->GetAlias(left);
2686 if (aliasValue && strcspn(aliasValue, "()[]+*/-%&!=<>|") == strlen(aliasValue) && !IsNumberConstant(aliasValue)) {
2687 // First check whether we are using this alias recursively (this would
2688 // lead to an infinite recursion).
2689 if (find(aliasUsed.begin(),
2690 aliasUsed.end(),
2691 left) != aliasUsed.end()) {
2692 Error("FindLeafForExpression",
2693 "The substitution of the branch alias \"%s\" by \"%s\" in \"%s\" failed\n"\
2694 "\tbecause \"%s\" is used [recursively] in its own definition!",
2695 left,aliasValue,fullExpression,left);
2696 return -3;
2697 }
2698 aliasUsed.push_back(left);
2699 TString newExpression = aliasValue;
2700 newExpression += (cname+strlen(left));
2701 Int_t res = FindLeafForExpression(newExpression, leaf, leftover, final, paran_level,
2702 castqueue, aliasUsed, useLeafCollectionObject, fullExpression);
2703 if (res<0) {
2704 Error("FindLeafForExpression",
2705 "The substitution of the alias \"%s\" by \"%s\" failed.",left,aliasValue);
2706 return -3;
2707 }
2708 return res;
2709 }
2710 }
2711 leftover = right;
2712
2713 return 0;
2714}
2715
2716////////////////////////////////////////////////////////////////////////////////
2717/// Check if name is in the list of Tree/Branch leaves.
2718///
2719/// This member function redefines the function in ROOT::v5::TFormula
2720/// If a leaf has a name corresponding to the argument name, then
2721/// returns a new code.
2722///
2723/// A TTreeFormula may contain more than one variable.
2724/// For each variable referenced, the pointers to the corresponding
2725/// branch and leaf is stored in the object arrays fBranches and fLeaves.
2726///
2727/// name can be :
2728/// - Leaf_Name (simple variable or data member of a ClonesArray)
2729/// - Branch_Name.Leaf_Name
2730/// - Branch_Name.Method_Name
2731/// - Leaf_Name[index]
2732/// - Branch_Name.Leaf_Name[index]
2733/// - Branch_Name.Leaf_Name[index1]
2734/// - Branch_Name.Leaf_Name[][index2]
2735/// - Branch_Name.Leaf_Name[index1][index2]
2736///
2737/// New additions:
2738/// - Branch_Name.Leaf_Name[OtherLeaf_Name]
2739/// - Branch_Name.Datamember_Name
2740/// - '.' can be replaced by '->'
2741///
2742/// and
2743/// - Branch_Name[index1].Leaf_Name[index2]
2744/// - Leaf_name[index].Action().OtherAction(param)
2745/// - Leaf_name[index].Action()[val].OtherAction(param)
2746///
2747/// The expected returned values are
2748/// - -2 : the name has been recognized but won't be usable
2749/// - -1 : the name has not been recognized, or is too long, or tree does not exist.
2750/// - >=0 : the name has been recognized, return the internal code for this name.
2751
2752Int_t TTreeFormula::DefinedVariable(TString &name, Int_t &action)
2753{
2754
2755 action = kDefinedVariable;
2756 if (!fTree) return -1;
2757
2758 fNpar = 0;
2759 if (name.Length() > kMaxLen) {
2760 Error("TTreeFormula", "The length of the variable name (%d) exceeds the maximum allowed (%d)", name.Length(), kMaxLen);
2761 return -1;
2762 }
2763 Int_t i,k;
2764
2765 if (name == "Entry$") {
2766 Int_t code = fNcodes++;
2767 fCodes[code] = 0;
2768 fLookupType[code] = kIndexOfEntry;
2769 return code;
2770 }
2771 if (name == "LocalEntry$") {
2772 Int_t code = fNcodes++;
2773 fCodes[code] = 0;
2774 fLookupType[code] = kIndexOfLocalEntry;
2775 return code;
2776 }
2777 if (name == "Entries$") {
2778 Int_t code = fNcodes++;
2779 fCodes[code] = 0;
2780 fLookupType[code] = kEntries;
2781 SetBit(kNeedEntries);
2782 fManager->SetBit(kNeedEntries);
2783 return code;
2784 }
2785 if (name == "LocalEntries$") {
2786 Int_t code = fNcodes++;
2787 fCodes[code] = 0;
2788 fLookupType[code] = kLocalEntries;
2789 SetBit(kNeedEntries); // FIXME: necessary?
2790 fManager->SetBit(kNeedEntries); // FIXME: necessary?
2791 return code;
2792 }
2793 if (name == "Iteration$") {
2794 Int_t code = fNcodes++;
2795 fCodes[code] = 0;
2796 fLookupType[code] = kIteration;
2797 return code;
2798 }
2799 if (name == "Length$") {
2800 Int_t code = fNcodes++;
2801 fCodes[code] = 0;
2802 fLookupType[code] = kLength;
2803 return code;
2804 }
2805 static const char *lenfunc = "Length$(";
2806 if (strncmp(name.Data(),"Length$(",strlen(lenfunc))==0
2807 && name[name.Length()-1]==')') {
2808
2809 TString subform = name.Data()+strlen(lenfunc);
2810 subform.Remove( subform.Length() - 1 );
2811 TTreeFormula *lengthForm = new TTreeFormula("lengthForm",subform,fTree);
2812 fAliases.AddAtAndExpand(lengthForm,fNoper);
2813 Int_t code = fNcodes++;
2814 fCodes[code] = 0;
2815 fLookupType[code] = kLengthFunc;
2816 return code;
2817 }
2818 static const char *minfunc = "Min$(";
2819 if (strncmp(name.Data(),"Min$(",strlen(minfunc))==0
2820 && name[name.Length()-1]==')') {
2821
2822 TString subform = name.Data()+strlen(minfunc);
2823 subform.Remove( subform.Length() - 1 );
2824 TTreeFormula *minForm = new TTreeFormula("minForm",subform,fTree);
2825 fAliases.AddAtAndExpand(minForm,fNoper);
2826 Int_t code = fNcodes++;
2827 fCodes[code] = 0;
2828 fLookupType[code] = kMin;
2829 return code;
2830 }
2831 static const char *maxfunc = "Max$(";
2832 if (strncmp(name.Data(),"Max$(",strlen(maxfunc))==0
2833 && name[name.Length()-1]==')') {
2834
2835 TString subform = name.Data()+strlen(maxfunc);
2836 subform.Remove( subform.Length() - 1 );
2837 TTreeFormula *maxForm = new TTreeFormula("maxForm",subform,fTree);
2838 fAliases.AddAtAndExpand(maxForm,fNoper);
2839 Int_t code = fNcodes++;
2840 fCodes[code] = 0;
2841 fLookupType[code] = kMax;
2842 return code;
2843 }
2844 static const char *sumfunc = "Sum$(";
2845 if (strncmp(name.Data(),"Sum$(",strlen(sumfunc))==0
2846 && name[name.Length()-1]==')') {
2847
2848 TString subform = name.Data()+strlen(sumfunc);
2849 subform.Remove( subform.Length() - 1 );
2850 TTreeFormula *sumForm = new TTreeFormula("sumForm",subform,fTree);
2851 fAliases.AddAtAndExpand(sumForm,fNoper);
2852 Int_t code = fNcodes++;
2853 fCodes[code] = 0;
2854 fLookupType[code] = kSum;
2855 return code;
2856 }
2857
2858
2859
2860 // Check for $Alt(expression1,expression2)
2861 Int_t res = DefineAlternate(name.Data());
2862 if (res!=0) {
2863 // There was either a syntax error or we found $Alt
2864 if (res<0) return res;
2865 action = res;
2866 return 0;
2867 }
2868
2869 // Find the top level leaf and deal with dimensions
2870
2871 char cname[kMaxLen]; strlcpy(cname,name.Data(),kMaxLen);
2872 char dims[kMaxLen]; dims[0] = '\0';
2873
2874 bool final = false;
2875
2876 UInt_t paran_level = 0;
2877 TObjArray castqueue;
2878
2879 // First, it is easier to remove all dimensions information from 'cname'
2880 Int_t cnamelen = strlen(cname);
2881 for(i=0,k=0; i<cnamelen; ++i, ++k) {
2882 if (cname[i] == '[') {
2883 int bracket = i;
2884 int bracket_level = 1;
2885 int j;
2886 for (j=++i; j<cnamelen && (bracket_level>0 || cname[j]=='['); j++, i++) {
2887 if (cname[j]=='[') bracket_level++;
2888 else if (cname[j]==']') bracket_level--;
2889 }
2890 if (bracket_level != 0) {
2891 //Error("DefinedVariable","Bracket unbalanced");
2892 return -1;
2893 }
2894 strncat(dims,&cname[bracket],j-bracket);
2895 //k += j-bracket;
2896 }
2897 if (i!=k) cname[k] = cname[i];
2898 }
2899 cname[k]='\0';
2900
2901 bool useLeafCollectionObject = false;
2902 TString leftover;
2903 TLeaf *leaf = nullptr;
2904 {
2905 std::vector<std::string> aliasSofar = fAliasesUsed;
2906 res = FindLeafForExpression(cname, leaf, leftover, final, paran_level, castqueue, aliasSofar, useLeafCollectionObject, name);
2907 }
2908 if (res<0) return res;
2909
2910 if (!leaf && res!=2) {
2911 // Check for an alias.
2912 const char *aliasValue = fTree->GetAlias(cname);
2913 if (aliasValue) {
2914 // First check whether we are using this alias recursively (this would
2915 // lead to an infinite recursion).
2916 if (find(fAliasesUsed.begin(),
2917 fAliasesUsed.end(),
2918 cname) != fAliasesUsed.end()) {
2919 Error("DefinedVariable",
2920 "The substitution of the alias \"%s\" by \"%s\" failed\n"\
2921 "\tbecause \"%s\" is recursively used in its own definition!",
2922 cname,aliasValue,cname);
2923 return -3;
2924 }
2925
2926 if (strcspn(aliasValue, "()[]+*/-%&!=<>|") != strlen(aliasValue) || IsNumberConstant(aliasValue)) {
2927 // If the alias contains an operator, we need to use a nested formula
2928 // (since DefinedVariable must only add one entry to the operation's list).
2929
2930 // Need to check the aliases used so far
2931 std::vector<std::string> aliasSofar = fAliasesUsed;
2932 aliasSofar.push_back( cname );
2933
2934 TString subValue( aliasValue );
2935 if (dims[0]) {
2936 subValue += dims;
2937 }
2938
2939 TTreeFormula *subform = new TTreeFormula(cname,subValue,fTree,aliasSofar); // Need to pass the aliases used so far.
2940
2941 if (subform->GetNdim()==0) {
2942 delete subform;
2943 Error("DefinedVariable",
2944 "The substitution of the alias \"%s\" by \"%s\" failed.",cname,aliasValue);
2945 return -3;
2946 }
2947
2948 fManager->Add(subform);
2949 fAliases.AddAtAndExpand(subform,fNoper);
2950
2951 if (subform->IsString()) {
2952 action = kAliasString;
2953 return 0;
2954 } else {
2955 action = kAlias;
2956 return 0;
2957 }
2958 } else { /* assumes strcspn(aliasValue,"[]")!=strlen(aliasValue) */
2959 TString thisAlias( aliasValue );
2960 thisAlias += dims;
2961 Int_t aliasRes = DefinedVariable(thisAlias,action);
2962 if (aliasRes<0) {
2963 // We failed but DefinedVariable has not printed why yet.
2964 // and because we want those to be printed _before_ the notice
2965 // of the failure of the substitution, we need to print them here.
2966 if (aliasRes==-1) {
2967 Error("Compile", " Bad numerical expression : \"%s\"",thisAlias.Data());
2968 } else if (aliasRes==-2) {
2969 Error("Compile", " Part of the Variable \"%s\" exists but some of it is not accessible or useable",thisAlias.Data());
2970
2971 }
2972 Error("DefinedVariable",
2973 "The substitution of the alias \"%s\" by \"%s\" failed.",cname,aliasValue);
2974 return -3;
2975 }
2976 return aliasRes;
2977 }
2978 }
2979 }
2980
2981
2982 if (leaf || res==2) {
2983
2984 if (leaf && leaf->GetBranch() && leaf->GetBranch()->TestBit(kDoNotProcess)) {
2985 Error("DefinedVariable","the branch \"%s\" has to be enabled to be used",leaf->GetBranch()->GetName());
2986 return -2;
2987 }
2988
2989 Int_t code = fNcodes++;
2990
2991 // If needed will now parse the indexes specified for
2992 // arrays.
2993 if (dims[0]) {
2994 char *current = &( dims[0] );
2995 Int_t dim = 0;
2996 TString varindex;
2997 Int_t index;
2998 Int_t scanindex ;
2999 while (current) {
3000 current++;
3001 if (current[0] == ']') {
3002 fIndexes[code][dim] = -1; // Loop over all elements;
3003 } else {
3004 TString tempIndex(current);
3005 auto closePos = tempIndex.First(']');
3006 if (closePos != -1)
3007 tempIndex = tempIndex(0, closePos);
3008 if (tempIndex.IsDigit() && (scanindex = sscanf(current, "%d", &index)) && scanindex == 1) {
3009 fIndexes[code][dim] = index;
3010 } else {
3011 fIndexes[code][dim] = -2; // Index is calculated via a variable.
3012 varindex = current;
3013 char *end = (char*)(varindex.Data());
3014 for(char bracket_level = 0;*end!=0;end++) {
3015 if (*end=='[') bracket_level++;
3016 if (bracket_level==0 && *end==']') break;
3017 if (*end==']') bracket_level--;
3018 }
3019 *end = '\0';
3020 fVarIndexes[code][dim] = new TTreeFormula("index_var",
3021 varindex,
3022 fTree);
3023 if (fVarIndexes[code][dim]->GetNdim() == 0) {
3024 // Parsing failed for the index, let's stop here ....
3025 return -1;
3026 }
3027 current += strlen(varindex)+1; // move to the end of the index array
3028 }
3029 }
3030 dim ++;
3031 if (dim >= kMAXFORMDIM) {
3032 // NOTE: test that dim this is NOT too big!!
3033 break;
3034 }
3035 current = (char*)strstr( current, "[" );
3036 }
3037 }
3038
3039 // Now that we have cleaned-up the expression, let's compare it to the content
3040 // of the leaf!
3041
3042 res = ParseWithLeaf(leaf,leftover,final,paran_level,castqueue,useLeafCollectionObject,name);
3043 if (res<0) return res;
3044 if (res>0) action = res;
3045 return code;
3046 }
3047
3048//*-*- May be a graphical cut ?
3049 TCutG *gcut = (TCutG*)gROOT->GetListOfSpecials()->FindObject(name.Data());
3050 if (gcut) {
3051 if (gcut->GetObjectX()) {
3052 if(!gcut->GetObjectX()->InheritsFrom(TTreeFormula::Class()))
3053 gcut->SetObjectX(nullptr);
3054 }
3055 if (gcut->GetObjectY()) {
3056 if(!gcut->GetObjectY()->InheritsFrom(TTreeFormula::Class()))
3057 gcut->SetObjectY(nullptr);
3058 }
3059
3060 Int_t code = fNcodes;
3061
3062 if (strlen(gcut->GetVarX()) && strlen(gcut->GetVarY()) ) {
3063
3064 TTreeFormula *fx = new TTreeFormula("f_x",gcut->GetVarX(),fTree);
3065 gcut->SetObjectX(fx);
3066
3067 TTreeFormula *fy = new TTreeFormula("f_y",gcut->GetVarY(),fTree);
3068 gcut->SetObjectY(fy);
3069
3070 fCodes[code] = -2;
3071
3072 } else if (strlen(gcut->GetVarX())) {
3073
3074 // Let's build the equivalent formula:
3075 // min(gcut->X) <= VarX <= max(gcut->Y)
3076 Double_t min = 0;
3077 Double_t max = 0;
3078 Int_t n = gcut->GetN();
3079 Double_t *x = gcut->GetX();
3080 min = max = x[0];
3081 for(Int_t i2 = 1; i2<n; i2++) {
3082 if (x[i2] < min) min = x[i2];
3083 if (x[i2] > max) max = x[i2];
3084 }
3085 TString formula = "(";
3086 formula += min;
3087 formula += "<=";
3088 formula += gcut->GetVarX();
3089 formula += " && ";
3090 formula += gcut->GetVarX();
3091 formula += "<=";
3092 formula += max;
3093 formula += ")";
3094
3095 TTreeFormula *fx = new TTreeFormula("f_x",formula.Data(),fTree);
3096 gcut->SetObjectX(fx);
3097
3098 fCodes[code] = -1;
3099
3100 } else {
3101
3102 Error("DefinedVariable","Found a TCutG without leaf information (%s)",
3103 gcut->GetName());
3104 return -1;
3105
3106 }
3107
3108 fExternalCuts.AddAtAndExpand(gcut,code);
3109 fNcodes++;
3110 fLookupType[code] = -1;
3111 return code;
3112 }
3113
3114 //may be an entrylist
3115 TEntryList *elist = dynamic_cast<TEntryList*> (gDirectory->Get(name.Data()));
3116 if (elist) {
3117 Int_t code = fNcodes;
3118 fCodes[code] = 0;
3119 fExternalCuts.AddAtAndExpand(elist, code);
3120 fNcodes++;
3121 fLookupType[code] = kEntryList;
3122 return code;
3123
3124 }
3125
3126 return -1;
3127}
3128
3129////////////////////////////////////////////////////////////////////////////////
3130/// Return the leaf (if any) which contains an object containing
3131/// a data member which has the name provided in the arguments.
3132
3133TLeaf* TTreeFormula::GetLeafWithDatamember(const char* topchoice, const char* nextchoice, Long64_t readentry) const
3134{
3135 TClass * cl = nullptr;
3136 TIter nextleaf (fTree->GetIteratorOnAllLeaves());
3137 TFormLeafInfo* clonesinfo = nullptr;
3138 TLeaf *leafcur;
3139 while ((leafcur = (TLeaf*)nextleaf())) {
3140 // The following code is used somewhere else, we need to factor it out.
3141
3142 // Here since we are interested in data member, we want to consider only
3143 // 'terminal' branch and leaf.
3144 cl = nullptr;
3145 if (leafcur->InheritsFrom(TLeafObject::Class()) &&
3146 leafcur->GetBranch()->GetListOfBranches()->Last()==nullptr) {
3147 TLeafObject *lobj = (TLeafObject*)leafcur;
3148 cl = lobj->GetClass();
3149 } else if (leafcur->InheritsFrom(TLeafElement::Class()) && leafcur->IsOnTerminalBranch()) {
3150 TLeafElement * lElem = (TLeafElement*) leafcur;
3151 if (lElem->IsOnTerminalBranch()) {
3152 TBranchElement *branchEl = (TBranchElement *)leafcur->GetBranch();
3153 Int_t type = branchEl->GetStreamerType();
3154 if (type==-1) {
3155 cl = branchEl->GetInfo() ? branchEl->GetInfo()->GetClass() : nullptr;
3156 } else if (type>60 || type==0) {
3157 // Case of an object data member. Here we allow for the
3158 // variable name to be omitted. Eg, for Event.root with split
3159 // level 1 or above Draw("GetXaxis") is the same as Draw("fH.GetXaxis()")
3160 TStreamerElement* element = branchEl->GetInfo()->GetElement(branchEl->GetID());
3161 if (element) cl = element->GetClassPointer();
3162 else cl = nullptr;
3163 }
3164 }
3165
3166 }
3167 if (clonesinfo) { delete clonesinfo; clonesinfo = nullptr; }
3168 if (cl == TClonesArray::Class()) {
3169 // We have a unsplit TClonesArray leaves
3170 // In this case we assume that cl is the class in which the TClonesArray
3171 // belongs.
3172 auto res = R__LoadBranch(leafcur->GetBranch(),readentry,fQuickLoad);
3173 if (res < 0) {
3174 Error("GetLeafWithDatamember", "Branch could not be loaded:%d", res);
3175 continue;
3176 }
3177 TClonesArray * clones;
3178
3179 TBranch *branch = leafcur->GetBranch();
3180 if ( branch->IsA()==TBranchElement::Class()
3181 && ((TBranchElement*)branch)->GetType()==31) {
3182
3183 // We have an unsplit TClonesArray as part of a split TClonesArray!
3184
3185 // Let's not dig any further. If the user really wants a data member
3186 // inside the nested TClonesArray, it has to specify it explicitly.
3187
3188 continue;
3189
3190 } else {
3191 bool toplevel = (branch == branch->GetMother());
3192 clonesinfo = new TFormLeafInfoClones(cl, 0, toplevel);
3193 clones = (TClonesArray*)clonesinfo->GetLocalValuePointer(leafcur,0);
3194 }
3195 if (clones) cl = clones->GetClass();
3196 } else if (cl && cl->GetCollectionProxy()) {
3197
3198 // We have a unsplit Collection leaves
3199 // In this case we assume that cl is the class in which the TClonesArray
3200 // belongs.
3201
3202 TBranch *branch = leafcur->GetBranch();
3203 if ( branch->IsA()==TBranchElement::Class()
3204 && ((TBranchElement*)branch)->GetType()==41) {
3205
3206 // We have an unsplit Collection as part of a split Collection!
3207
3208 // Let's not dig any further. If the user really wants a data member
3209 // inside the nested Collection, it has to specify it explicitly.
3210
3211 continue;
3212
3213 } else {
3214 clonesinfo = new TFormLeafInfoCollection(cl, 0);
3215 }
3216 cl = cl->GetCollectionProxy()->GetValueClass();
3217 }
3218 if (cl) {
3219 // Now that we have the class, let's check if the topchoice is of its datamember
3220 // or if the nextchoice is a datamember of one of its datamember.
3221 Int_t offset;
3222 TStreamerInfo* info = (TStreamerInfo*)cl->GetStreamerInfo();
3223 TStreamerElement* element = info?info->GetStreamerElement(topchoice,offset):nullptr;
3224 if (!element) {
3225 TIter nextel( cl->GetStreamerInfo()->GetElements() );
3226 TStreamerElement * curelem;
3227 while ((curelem = (TStreamerElement*)nextel())) {
3228
3229 if (curelem->GetClassPointer() == TClonesArray::Class()) {
3230 // In case of a TClonesArray we need to load the data and read the
3231 // clonesArray object before being able to look into the class inside.
3232 // We need to do that because we are never interested in the TClonesArray
3233 // itself but only in the object inside.
3234 TBranch *branch = leafcur->GetBranch();
3235 TFormLeafInfo *leafinfo = nullptr;
3236 if (clonesinfo) {
3237 leafinfo = clonesinfo;
3238 } else if (branch->IsA()==TBranchElement::Class()
3239 && ((TBranchElement*)branch)->GetType()==31) {
3240 // Case of a sub branch of a TClonesArray
3241 TBranchElement *branchEl = (TBranchElement*)branch;
3242 TStreamerInfo *bel_info = branchEl->GetInfo();
3243 TClass * mother_cl = ((TBranchElement*)branch)->GetInfo()->GetClass();
3244 TStreamerElement *bel_element =
3245 bel_info->GetElement(branchEl->GetID());
3246 leafinfo = new TFormLeafInfoClones(mother_cl, 0, bel_element, true);
3247 }
3248
3249 Int_t clones_offset = 0;
3250 ((TStreamerInfo*)cl->GetStreamerInfo())->GetStreamerElement(curelem->GetName(),clones_offset);
3251 TFormLeafInfo* sub_clonesinfo = new TFormLeafInfo(cl, clones_offset, curelem);
3252 if (leafinfo)
3253 if (leafinfo->fNext) leafinfo->fNext->fNext = sub_clonesinfo;
3254 else leafinfo->fNext = sub_clonesinfo;
3255 else leafinfo = sub_clonesinfo;
3256
3257 auto res = R__LoadBranch(branch,readentry,fQuickLoad);
3258 if (res < 0) {
3259 Error("GetLeafWithDatamember", "Branch could not be loaded:%d", res);
3260 continue;
3261 }
3262
3263 TClonesArray * clones = (TClonesArray*)leafinfo->GetValuePointer(leafcur,0);
3264
3265 delete leafinfo; clonesinfo = nullptr;
3266 // If TClonesArray object does not exist we have no information, so let go
3267 // on. This is a weakish test since the TClonesArray object might exist in
3268 // the next entry ... In other word, we ONLY rely on the information available
3269 // in entry #0.
3270 if (!clones) continue;
3271 TClass *sub_cl = clones->GetClass();
3272
3273 // Now that we finally have the inside class, let's query it.
3274 element = ((TStreamerInfo*)sub_cl->GetStreamerInfo())->GetStreamerElement(nextchoice,offset);
3275 if (element) break;
3276 } // if clones array
3277 else if (curelem->GetClassPointer() && curelem->GetClassPointer()->GetCollectionProxy()) {
3278
3279 TClass *sub_cl = curelem->GetClassPointer()->GetCollectionProxy()->GetValueClass();
3280
3281 while(sub_cl && sub_cl->GetCollectionProxy())
3282 sub_cl = sub_cl->GetCollectionProxy()->GetValueClass();
3283
3284 // Now that we finally have the inside class, let's query it.
3285 if (sub_cl) element = ((TStreamerInfo*)sub_cl->GetStreamerInfo())->GetStreamerElement(nextchoice,offset);
3286 if (element) break;
3287
3288 }
3289 } // loop on elements
3290 }
3291 if (element) break;
3292 else cl = nullptr;
3293 }
3294 }
3295 delete clonesinfo;
3296 if (cl) {
3297 return leafcur;
3298 } else {
3299 return nullptr;
3300 }
3301}
3302
3303////////////////////////////////////////////////////////////////////////////////
3304/// Return the leaf (if any) of the tree with contains an object of a class
3305/// having a method which has the name provided in the argument.
3306
3307bool TTreeFormula::BranchHasMethod(TLeaf* leafcur, TBranch* branch, const char* method, const char* params, Long64_t readentry) const
3308{
3309 TClass *cl = nullptr;
3310 TLeafObject* lobj = nullptr;
3311
3312 // Since the user does not want this branch to be loaded anyway, we just
3313 // skip it. This prevents us from warning the user that the method might
3314 // be on a disabled branch. However, and more usefully, this allows the
3315 // user to avoid error messages from branches that cannot be currently
3316 // read without warnings/errors.
3317
3318 if (branch->TestBit(kDoNotProcess)) {
3319 return false;
3320 }
3321
3322 // FIXME: The following code is used somewhere else, we need to factor it out.
3323 if (branch->InheritsFrom(TBranchObject::Class())) {
3324 lobj = (TLeafObject*) branch->GetListOfLeaves()->At(0);
3325 cl = lobj->GetClass();
3326 } else if (branch->InheritsFrom(TBranchElement::Class())) {
3327 TBranchElement* branchEl = (TBranchElement*) branch;
3328 Int_t type = branchEl->GetStreamerType();
3329 if (type == -1) {
3330 cl = branchEl->GetInfo() ? branchEl->GetInfo()->GetClass() : nullptr;
3331 } else if (type > 60) {
3332 // Case of an object data member. Here we allow for the
3333 // variable name to be omitted. Eg, for Event.root with split
3334 // level 1 or above Draw("GetXaxis") is the same as Draw("fH.GetXaxis()")
3335 TStreamerElement* element = branchEl->GetInfo()->GetElement(branchEl->GetID());
3336 if (element) {
3337 cl = element->GetClassPointer();
3338 } else {
3339 cl = nullptr;
3340 }
3341 if ((cl == TClonesArray::Class()) && (branchEl->GetType() == 31)) {
3342 // we have a TClonesArray inside a split TClonesArray,
3343 // Let's not dig any further. If the user really wants a data member
3344 // inside the nested TClonesArray, it has to specify it explicitly.
3345 cl = nullptr;
3346 }
3347 // NOTE do we need code for Collection here?
3348 }
3349 }
3350
3351 if (cl == TClonesArray::Class()) {
3352 // We might be try to call a method of the top class inside a
3353 // TClonesArray.
3354 // Since the leaf was not terminal, we might have a split or
3355 // unsplit and/or top leaf/branch.
3356 TClonesArray* clones = nullptr;
3357 auto res = R__LoadBranch(branch, readentry, fQuickLoad);
3358 if (res < 0) {
3359 Error("BranchHasMethod", "Branch could not be loaded:%d", res);
3360 return false;
3361 }
3362 if (branch->InheritsFrom(TBranchObject::Class())) {
3363 clones = (TClonesArray*) lobj->GetObject();
3364 } else if (branch->InheritsFrom(TBranchElement::Class())) {
3365 // We do not know exactly where the leaf of the TClonesArray is
3366 // in the hierarchy but we still need to get the correct class
3367 // holder.
3368 TBranchElement* bc = (TBranchElement*) branch;
3369 if (bc == bc->GetMother()) {
3370 // Top level branch
3371 //clones = *((TClonesArray**) bc->GetAddress());
3372 clones = (TClonesArray*) bc->GetObject();
3373 } else if (!leafcur || !leafcur->IsOnTerminalBranch()) {
3374 TStreamerElement* element = bc->GetInfo()->GetElement(bc->GetID());
3375 if (element->IsaPointer()) {
3376 clones = *((TClonesArray**) bc->GetAddress());
3377 //clones = *((TClonesArray**) bc->GetObject());
3378 } else {
3379 //clones = (TClonesArray*) bc->GetAddress();
3380 clones = (TClonesArray*) bc->GetObject();
3381 }
3382 }
3383 if (!clones) {
3384 auto cres = R__LoadBranch(bc, readentry, fQuickLoad);
3385 if (cres < 0) {
3386 Error("BranchHasMethod", "Branch could not be loaded:%d", cres);
3387 return false;
3388 }
3389 TClass* mother_cl;
3390 mother_cl = bc->GetInfo()->GetClass();
3391 TFormLeafInfo* clonesinfo = new TFormLeafInfoClones(mother_cl, 0);
3392 // if (!leafcur) { leafcur = (TLeaf*) branch->GetListOfLeaves()->At(0); }
3393 clones = (TClonesArray*) clonesinfo->GetLocalValuePointer(leafcur, 0);
3394 // cl = clones->GetClass();
3395 delete clonesinfo;
3396 }
3397 } else {
3398 Error("BranchHasMethod","A TClonesArray was stored in a branch type no yet support (i.e. neither TBranchObject nor TBranchElement): %s",branch->IsA()->GetName());
3399 return false;
3400 }
3401 cl = clones ? clones->GetClass() : nullptr;
3402 } else if (cl && cl->GetCollectionProxy()) {
3403 cl = cl->GetCollectionProxy()->GetValueClass();
3404 }
3405
3406 if (cl) {
3407 if (cl->GetClassInfo()) {
3408 if (cl->GetMethodAllAny(method)) {
3409 // Let's try to see if the function we found belongs to the current
3410 // class. Note that this implementation currently can not work if
3411 // one the argument is another leaf or data member of the object.
3412 // (Anyway we do NOT support this case).
3413 TMethodCall methodcall(cl, method, params);
3414 if (methodcall.GetMethod()) {
3415 // We have a method that works.
3416 // We will use it.
3417 return true;
3418 }
3419 }
3420 }
3421 }
3422
3423 return false;
3424}
3425
3426////////////////////////////////////////////////////////////////////////////////
3427/// Now let calculate what physical instance we really need.
3428/// Some redundant code is used to speed up the cases where
3429/// they are no dimensions.
3430///
3431/// We know that instance is less that fCumulUsedSize[0] so
3432/// we can skip the modulo when virt_dim is 0.
3433
3434Int_t TTreeFormula::GetRealInstance(Int_t instance, Int_t codeindex) {
3435 Int_t real_instance = 0;
3436 Int_t virt_dim;
3437
3438 bool check = false;
3439 if (codeindex<0) {
3440 codeindex = 0;
3441 check = true;
3442 }
3443
3444 TFormLeafInfo * info = nullptr;
3445 Int_t max_dim = fNdimensions[codeindex];
3446 if ( max_dim ) {
3447 virt_dim = 0;
3448 max_dim--;
3449
3450 if (!fManager->fMultiVarDim) {
3451 if (fIndexes[codeindex][0]>=0) {
3452 real_instance = fIndexes[codeindex][0] * fCumulSizes[codeindex][1];
3453 } else {
3454 Int_t local_index;
3455 local_index = ( instance / fManager->fCumulUsedSizes[virt_dim+1]);
3456 if (fIndexes[codeindex][0]==-2) {
3457 // NOTE: Should we check that this is a valid index?
3458 if (check) {
3459 Int_t index_real_instance = fVarIndexes[codeindex][0]->GetRealInstance(local_index,-1);
3460 if (index_real_instance >= fVarIndexes[codeindex][0]->fNdata[0]) {
3461 // out of bounds
3462 return fNdata[0]+1;
3463 }
3464 }
3465 if (fDidBooleanOptimization && local_index!=0) {
3466 // Force the loading of the index.
3467 fVarIndexes[codeindex][0]->LoadBranches();
3468 }
3469 local_index = (Int_t)fVarIndexes[codeindex][0]->EvalInstance(local_index);
3470 if (local_index<0) {
3471 Error("EvalInstance","Index %s is out of bound (%d) in formula %s",
3472 fVarIndexes[codeindex][0]->GetTitle(),
3473 local_index,
3474 GetTitle());
3475 return fNdata[0]+1;
3476 }
3477 }
3478 real_instance = local_index * fCumulSizes[codeindex][1];
3479 virt_dim ++;
3480 }
3481 } else {
3482 // NOTE: We assume that ONLY the first dimension of a leaf can have a variable
3483 // size AND contain the index for the size of yet another sub-dimension.
3484 // I.e. a variable size array inside a variable size array can only have its
3485 // size vary with the VERY FIRST physical dimension of the leaf.
3486 // Thus once the index of the first dimension is found, all other dimensions
3487 // are fixed!
3488
3489 // NOTE: We could unroll some of this loops to avoid a few tests.
3490 if (fHasMultipleVarDim[codeindex]) {
3491 info = (TFormLeafInfo *)(fDataMembers.At(codeindex));
3492 // if (info && info->GetVarDim()==-1) info = 0;
3493 }
3494 Int_t local_index;
3495
3496 switch (fIndexes[codeindex][0]) {
3497 case -2:
3498 if (fDidBooleanOptimization && instance!=0) {
3499 // Force the loading of the index.
3500 fVarIndexes[codeindex][0]->LoadBranches();
3501 }
3502 local_index = (Int_t)fVarIndexes[codeindex][0]->EvalInstance(instance);
3503 if (local_index<0) {
3504 Error("EvalInstance","Index %s is out of bound (%d) in formula %s",
3505 fVarIndexes[codeindex][0]->GetTitle(),
3506 local_index,
3507 GetTitle());
3508 local_index = 0;
3509 }
3510 break;
3511 case -1: {
3512 if (instance <= fRealInstanceCache.fInstanceCache) {
3513 fRealInstanceCache.fLocalIndexCache = 0;
3514 fRealInstanceCache.fVirtAccumCache = 0;
3515 }
3516 fRealInstanceCache.fInstanceCache = instance;
3517 local_index = fRealInstanceCache.fLocalIndexCache;
3518 Int_t virt_accum = fRealInstanceCache.fVirtAccumCache;
3519
3520 Int_t maxloop = fManager->fCumulUsedVarDims->GetSize();
3521 if (maxloop == 0) {
3522 local_index--;
3523 instance = fNdata[0]+1; // out of bounds.
3524 if (check) return fNdata[0]+1;
3525 } else {
3526 do {
3527 virt_accum += fManager->fCumulUsedVarDims->GetArray()[local_index];
3528 local_index++;
3529 } while( instance >= virt_accum && local_index<maxloop);
3530 local_index--;
3531 // update the cache
3532 fRealInstanceCache.fVirtAccumCache = virt_accum - fManager->fCumulUsedVarDims->GetArray()[local_index];
3533 fRealInstanceCache.fLocalIndexCache = local_index;
3534
3535 if (local_index==(maxloop-1) && (instance >= virt_accum)) {
3536 instance = fNdata[0]+1; // out of bounds.
3537 if (check) return fNdata[0]+1;
3538 } else {
3539 if (fManager->fCumulUsedVarDims->At(local_index)) {
3540 instance -= (virt_accum - fManager->fCumulUsedVarDims->At(local_index));
3541 } else {
3542 instance = fNdata[0]+1; // out of bounds.
3543 if (check) return fNdata[0]+1;
3544 }
3545 }
3546 }
3547 virt_dim ++;
3548 }
3549 break;
3550 default:
3551 local_index = fIndexes[codeindex][0];
3552 }
3553
3554 // Inform the (appropriate) MultiVarLeafInfo that the clones array index is
3555 // local_index.
3556
3557 if (fManager->fVarDims[kMAXFORMDIM]) {
3558 fManager->fCumulUsedSizes[kMAXFORMDIM] = fManager->fVarDims[kMAXFORMDIM]->At(local_index);
3559 } else {
3560 fManager->fCumulUsedSizes[kMAXFORMDIM] = fManager->fUsedSizes[kMAXFORMDIM];
3561 }
3562 for(Int_t d = kMAXFORMDIM-1; d>0; d--) {
3563 if (fManager->fVarDims[d]) {
3564 fManager->fCumulUsedSizes[d] = fManager->fCumulUsedSizes[d+1] * fManager->fVarDims[d]->At(local_index);
3565 } else {
3566 fManager->fCumulUsedSizes[d] = fManager->fCumulUsedSizes[d+1] * fManager->fUsedSizes[d];
3567 }
3568 }
3569 if (info) {
3570 // When we have multiple variable dimensions, the LeafInfo only expect
3571 // the instance after the primary index has been set.
3572 info->SetPrimaryIndex(local_index);
3573 real_instance = 0;
3574
3575 // Let's update fCumulSizes for the rest of the code.
3576 Int_t vdim = info->GetVarDim();
3577 Int_t isize = info->GetSize(local_index);
3578 if (fIndexes[codeindex][vdim]>=0) {
3579 info->SetSecondaryIndex(fIndexes[codeindex][vdim]);
3580 }
3581 if (isize!=1 && fIndexes[codeindex][vdim]>isize) {
3582 // We are out of bounds!
3583 return fNdata[0]+1;
3584 }
3585 fCumulSizes[codeindex][vdim] = isize*fCumulSizes[codeindex][vdim+1];
3586 for(Int_t k=vdim -1; k>0; --k) {
3587 fCumulSizes[codeindex][k] = fCumulSizes[codeindex][k+1]*fFixedSizes[codeindex][k];
3588 }
3589 } else {
3590 real_instance = local_index * fCumulSizes[codeindex][1];
3591 }
3592 }
3593 if (max_dim>0) {
3594 for (Int_t dim = 1; dim < max_dim; dim++) {
3595 if (fIndexes[codeindex][dim]>=0) {
3596 real_instance += fIndexes[codeindex][dim] * fCumulSizes[codeindex][dim+1];
3597 } else {
3598 Int_t local_index;
3599 if (virt_dim && fManager->fCumulUsedSizes[virt_dim]>1) {
3600 local_index = ( ( instance % fManager->fCumulUsedSizes[virt_dim] )
3601 / fManager->fCumulUsedSizes[virt_dim+1]);
3602 } else {
3603 local_index = ( instance / fManager->fCumulUsedSizes[virt_dim+1]);
3604 }
3605 if (fIndexes[codeindex][dim]==-2) {
3606 // NOTE: Should we check that this is a valid index?
3607 if (fDidBooleanOptimization && local_index!=0) {
3608 // Force the loading of the index.
3609 fVarIndexes[codeindex][dim]->LoadBranches();
3610 }
3611 local_index = (Int_t)fVarIndexes[codeindex][dim]->EvalInstance(local_index);
3612 if (local_index<0 ||
3613 local_index>=(fCumulSizes[codeindex][dim]/fCumulSizes[codeindex][dim+1])) {
3614 Error("EvalInstance","Index %s is out of bound (%d/%d) in formula %s",
3615 fVarIndexes[codeindex][dim]->GetTitle(),
3616 local_index,
3617 (fCumulSizes[codeindex][dim]/fCumulSizes[codeindex][dim+1]),
3618 GetTitle());
3619 local_index = (fCumulSizes[codeindex][dim]/fCumulSizes[codeindex][dim+1])-1;
3620 }
3621 }
3622 real_instance += local_index * fCumulSizes[codeindex][dim+1];
3623 virt_dim ++;
3624 }
3625 }
3626 if (fIndexes[codeindex][max_dim]>=0) {
3627 if (!info) real_instance += fIndexes[codeindex][max_dim];
3628 } else {
3629 Int_t local_index;
3630 if (virt_dim && fManager->fCumulUsedSizes[virt_dim]>1) {
3631 local_index = instance % fManager->fCumulUsedSizes[virt_dim];
3632 } else {
3633 local_index = instance;
3634 }
3635 if (info && local_index>=fCumulSizes[codeindex][max_dim]) {
3636 // We are out of bounds! [Multiple var dims, See same message a few line above]
3637 return fNdata[0]+1;
3638 }
3639 if (fIndexes[codeindex][max_dim]==-2) {
3640 if (fDidBooleanOptimization && local_index!=0) {
3641 // Force the loading of the index.
3642 fVarIndexes[codeindex][max_dim]->LoadBranches();
3643 }
3644 local_index = (Int_t)fVarIndexes[codeindex][max_dim]->EvalInstance(local_index);
3645 if (local_index<0 ||
3646 local_index>=fCumulSizes[codeindex][max_dim]) {
3647 Error("EvalInstance","Index %s is of out bound (%d/%d) in formula %s",
3648 fVarIndexes[codeindex][max_dim]->GetTitle(),
3649 local_index,
3650 fCumulSizes[codeindex][max_dim],
3651 GetTitle());
3652 local_index = fCumulSizes[codeindex][max_dim]-1;
3653 }
3654 }
3655 real_instance += local_index;
3656 }
3657 } // if (max_dim-1>0)
3658 } // if (max_dim)
3659
3660 return real_instance;
3661}
3662
3663////////////////////////////////////////////////////////////////////////////////
3664/// Evaluate the class of this treeformula.
3665///
3666/// If the 'value' of this formula is a simple pointer to an object,
3667/// this function returns the TClass corresponding to its type.
3668
3669TClass* TTreeFormula::EvalClass() const
3670{
3671 if (fNoper != 1 || fNcodes <=0 ) return nullptr;
3672
3673 return EvalClass(0);
3674}
3675
3676////////////////////////////////////////////////////////////////////////////////
3677/// Evaluate the class of the operation oper.
3678///
3679/// If the 'value' in the requested operation is a simple pointer to an object,
3680/// this function returns the TClass corresponding to its type.
3681
3682TClass* TTreeFormula::EvalClass(Int_t oper) const
3683{
3684 TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(oper);
3685 switch(fLookupType[oper]) {
3686 case kDirect: {
3687 if (leaf->IsA()==TLeafObject::Class()) {
3688 return ((TLeafObject*)leaf)->GetClass();
3689 } else if ( leaf->IsA()==TLeafElement::Class()) {
3690 TBranchElement * branch = (TBranchElement*)((TLeafElement*)leaf)->GetBranch();
3691 TStreamerInfo * info = branch->GetInfo();
3692 Int_t id = branch->GetID();
3693 if (id>=0) {
3694 if (info==nullptr || !info->IsCompiled()) {
3695 // we probably do not have a way to know the class of the object.
3696 return nullptr;
3697 }
3698 TStreamerElement* elem = (TStreamerElement*)info->GetElement(id);
3699 if (elem==nullptr) {
3700 // we probably do not have a way to know the class of the object.
3701 return nullptr;
3702 } else {
3703 return elem->GetClass();
3704 }
3705 } else return TClass::GetClass( branch->GetClassName() );
3706 } else {
3707 return nullptr;
3708 }
3709 }
3710 case kMethod: return nullptr; // kMethod is deprecated so let's no waste time implementing this.
3711 case kTreeMember:
3712 case kDataMember: {
3713 TObject *obj = fDataMembers.UncheckedAt(oper);
3714 if (!obj) return nullptr;
3715 return ((TFormLeafInfo*)obj)->GetClass();
3716 }
3717
3718 default: return nullptr;
3719 }
3720
3721
3722}
3723
3724////////////////////////////////////////////////////////////////////////////////
3725/// Evaluate this treeformula.
3726///
3727/// Return the address of the object pointed to by the formula.
3728/// Return 0 if the formula is not a single object
3729/// The object type can be retrieved using by call EvalClass();
3730
3731void* TTreeFormula::EvalObject(int instance)
3732{
3733 if (fNoper != 1 || fNcodes <=0 ) return nullptr;
3734
3735
3736 switch (fLookupType[0]) {
3737 case kIndexOfEntry:
3738 case kIndexOfLocalEntry:
3739 case kEntries:
3740 case kLocalEntries:
3741 case kLength:
3742 case kLengthFunc:
3743 case kIteration:
3744 case kEntryList:
3745 return nullptr;
3746 }
3747
3748 TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(0);
3749
3750 Int_t real_instance = GetRealInstance(instance,0);
3751
3752 if (instance==0 || fNeedLoading) {
3753 fNeedLoading = false;
3754 auto res = R__LoadBranch(leaf->GetBranch(),
3755 leaf->GetBranch()->GetTree()->GetReadEntry(),
3756 fQuickLoad);
3757 if (res < 0) {
3758 Error("EvalObject", "Branch could not be loaded:%d", res);
3759 return nullptr;
3760 }
3761 }
3762 else if (real_instance>=fNdata[0]) return nullptr;
3763 if (fAxis) {
3764 return nullptr;
3765 }
3766 switch(fLookupType[0]) {
3767 case kDirect: {
3768 if (real_instance) {
3769 Warning("EvalObject","Not yet implement for kDirect and arrays (for %s).\nPlease contact the developers",GetName());
3770 }
3771 return leaf->GetValuePointer();
3772 }
3773 case kMethod: return GetValuePointerFromMethod(0,leaf);
3774 case kTreeMember:
3775 case kDataMember: return ((TFormLeafInfo*)fDataMembers.UncheckedAt(0))->GetValuePointer(leaf,real_instance);
3776 default: return nullptr;
3777 }
3778
3779
3780}
3781
3782
3783////////////////////////////////////////////////////////////////////////////////
3784/// Eval the instance as a string.
3785
3786const char* TTreeFormula::EvalStringInstance(Int_t instance)
3787{
3788 const Int_t kMAXSTRINGFOUND = 10;
3789 const char *stringStack[kMAXSTRINGFOUND];
3790
3791 if (fNoper==1 && fNcodes>0 && IsString()) {
3792 TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(0);
3793
3794 Int_t real_instance = GetRealInstance(instance,0);
3795
3796 if (instance==0 || fNeedLoading) {
3797 fNeedLoading = false;
3798 TBranch *branch = leaf->GetBranch();
3799 auto res = R__LoadBranch(branch,branch->GetTree()->GetReadEntry(),fQuickLoad);
3800 if (res < 0) {
3801 Error("EvalStringInstance", "Branch could not be loaded:%d", res);
3802 return nullptr;
3803 }
3804 } else if (real_instance>=fNdata[0]) {
3805 return nullptr;
3806 }
3807
3808 if (fLookupType[0]==kDirect) {
3809 return (char*)leaf->GetValuePointer();
3810 } else {
3811 return (char*)GetLeafInfo(0)->GetValuePointer(leaf,real_instance);
3812 }
3813 }
3814
3815 EvalInstance(instance,stringStack);
3816
3817 return stringStack[0];
3818}
3819
3820#define TT_EVAL_INIT \
3821 TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(0); \
3822 \
3823 const Int_t real_instance = GetRealInstance(instance,0); \
3824 \
3825 if (instance==0) fNeedLoading = true; \
3826 if (real_instance>=fNdata[0]) return TMath::SignalingNaN(); \
3827 \
3828 /* Since the only operation in this formula is reading this branch, \
3829 we are guaranteed that this function is first called with instance==0 and \
3830 hence we are guaranteed that the branch is always properly read */ \
3831 \
3832 if (fNeedLoading) { \
3833 fNeedLoading = false; \
3834 TBranch *br = leaf->GetBranch(); \
3835 if (br && br->GetTree()) { \
3836 Long64_t tEntry = br->GetTree()->GetReadEntry(); \
3837 auto lres = R__LoadBranch(br, tEntry, fQuickLoad); \
3838 if (lres < 0) \
3839 Error("TTreeFormula::TT_EVAL_INIT", \
3840 "Could not read entry (%lld) of leaf (%s), r=(%d).", tEntry, leaf->GetName(), lres);\
3841 } else { \
3842 Error("TTreeFormula::TT_EVAL_INIT", \
3843 "Could not init branch associated to this leaf (%s).", leaf->GetName()); \
3844 } \
3845 } \
3846 \
3847 if (fAxis) { \
3848 char * label; \
3849 /* This portion is a duplicate (for speed reason) of the code \
3850 located in the main for loop at "a tree string" (and in EvalStringInstance) */ \
3851 if (fLookupType[0]==kDirect) { \
3852 label = (char*)leaf->GetValuePointer(); \
3853 } else { \
3854 label = (char*)GetLeafInfo(0)->GetValuePointer(leaf,instance); \
3855 } \
3856 Int_t bin = fAxis->FindBin(label); \
3857 return bin-0.5; \
3858 }
3859
3860#define TREE_EVAL_INIT \
3861 const Int_t real_instance = GetRealInstance(instance,0); \
3862 \
3863 if (real_instance>=fNdata[0]) return TMath::SignalingNaN(); \
3864 \
3865 if (fAxis) { \
3866 char * label; \
3867 /* This portion is a duplicate (for speed reason) of the code \
3868 located in the main for loop at "a tree string" (and in EvalStringInstance) */ \
3869 label = (char*)GetLeafInfo(0)->GetValuePointer((TLeaf*)0x0,instance); \
3870 Int_t bin = fAxis->FindBin(label); \
3871 return bin-0.5; \
3872 }
3873
3874#define TT_EVAL_INIT_LOOP \
3875 TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(code); \
3876 \
3877 /* Now let calculate what physical instance we really need. */ \
3878 const Int_t real_instance = GetRealInstance(instance,code); \
3879 \
3880 if (willLoad) { \
3881 TBranch *branch = (TBranch*)fBranches.UncheckedAt(code); \
3882 if (branch) { \
3883 if (branch->GetTree()) { \
3884 Long64_t tEntry = branch->GetTree()->GetReadEntry(); \
3885 auto lres = R__LoadBranch(branch, tEntry, fQuickLoad); \
3886 if (lres < 0) { \
3887 Error("TTreeFormula::TT_EVAL_INIT_LOOP", \
3888 "Could not read entry (%lld) of leaf (%s), r=(%d).", tEntry, leaf->GetName(), lres);\
3889 } \
3890 } else { \
3891 Error("TTreeFormula::TT_EVAL_INIT_LOOP", \
3892 "Could not init branch associated to this leaf (%s).", leaf->GetName()); \
3893 } \
3894 } else if (fDidBooleanOptimization) { \
3895 branch = leaf->GetBranch(); \
3896 if (branch && branch->GetTree()) { \
3897 Long64_t tEntry = branch->GetTree()->GetReadEntry(); \
3898 if (branch->GetReadEntry() != tEntry) branch->GetEntry(tEntry); \
3899 } else { \
3900 Error("TTreeFormula::TT_EVAL_INIT_LOOP", \
3901 "Could not init branch associated to this leaf (%s).", leaf->GetName()); \
3902 } \
3903 } \
3904 } else { \
3905 /* In the cases where we are behind (i.e. right of) a potential boolean optimization \
3906 this tree variable reading may have not been executed with instance==0 which would \
3907 result in the branch being potentially not read in. */ \
3908 if (fDidBooleanOptimization) { \
3909 TBranch *br = leaf->GetBranch(); \
3910 if (br->GetTree()) { \
3911 Long64_t tEntry = br->GetTree()->GetReadEntry(); \
3912 if (br->GetReadEntry() != tEntry) br->GetEntry(tEntry); \
3913 } else { \
3914 Error("TTreeFormula::TT_EVAL_INIT_LOOP", \
3915 "Could not init branch associated to this leaf (%s).", leaf->GetName()); \
3916 } \
3917 } \
3918 } \
3919 if (real_instance>=fNdata[code]) return TMath::SignalingNaN();
3920
3921#define TREE_EVAL_INIT_LOOP \
3922 /* Now let calculate what physical instance we really need. */ \
3923 const Int_t real_instance = GetRealInstance(instance,code); \
3924 \
3925 if (real_instance>=fNdata[code]) return TMath::SignalingNaN();
3926
3927
3928template<typename T> T Summing(TTreeFormula *sum) {
3929 Int_t len = sum->GetNdata();
3930 T res = 0;
3931 for (int i=0; i<len; ++i) res += sum->EvalInstance<T>(i);
3932 return res;
3933}
3934
3935template<typename T> T FindMin(TTreeFormula *arr) {
3936 Int_t len = arr->GetNdata();
3937 T res = 0;
3938 if (len) {
3939 res = arr->EvalInstance<T>(0);
3940 for (int i=1; i<len; ++i) {
3941 T val = arr->EvalInstance<T>(i);
3942 if (val < res) {
3943 res = val;
3944 }
3945 }
3946 }
3947 return res;
3948}
3949
3950template<typename T> T FindMax(TTreeFormula *arr) {
3951 Int_t len = arr->GetNdata();
3952 T res = 0;
3953 if (len) {
3954 res = arr->EvalInstance<T>(0);
3955 for (int i=1; i<len; ++i) {
3956 T val = arr->EvalInstance(i);
3957 if (val > res) {
3958 res = val;
3959 }
3960 }
3961 }
3962 return res;
3963}
3964
3965template<typename T> T FindMin(TTreeFormula *arr, TTreeFormula *condition) {
3966 Int_t len = arr->GetNdata();
3967 T res = 0;
3968 if (len) {
3969 int i = 0;
3970 T condval;
3971 do {
3972 condval = condition->EvalInstance<T>(i);
3973 ++i;
3974 } while (!condval && i<len);
3975 if (!condval && i==len) {
3976 return 0;
3977 }
3978 if (i!=1) {
3979 // Insure the loading of the branch.
3980 arr->EvalInstance<T>(0);
3981 }
3982 // Now we know that i>0 && i<len and cond==true
3983 res = arr->EvalInstance<T>(i-1);
3984 for (; i<len; ++i) {
3985 condval = condition->EvalInstance<T>(i);
3986 if (condval) {
3987 T val = arr->EvalInstance<T>(i);
3988 if (val < res) {
3989 res = val;
3990 }
3991 }
3992 }
3993 }
3994 return res;
3995}
3996
3997template<typename T> T FindMax(TTreeFormula *arr, TTreeFormula *condition) {
3998 Int_t len = arr->GetNdata();
3999 T res = 0;
4000 if (len) {
4001 int i = 0;
4002 T condval;
4003 do {
4004 condval = condition->EvalInstance<T>(i);
4005 ++i;
4006 } while (!condval && i<len);
4007 if (!condval && i==len) {
4008 return 0;
4009 }
4010 if (i!=1) {
4011 // Insure the loading of the branch.
4012 arr->EvalInstance<T>(0);
4013 }
4014 // Now we know that i>0 && i<len and cond==true
4015 res = arr->EvalInstance<T>(i-1);
4016 for (; i<len; ++i) {
4017 condval = condition->EvalInstance<T>(i);
4018 if (condval) {
4019 T val = arr->EvalInstance<T>(i);
4020 if (val > res) {
4021 res = val;
4022 }
4023 }
4024 }
4025 }
4026 return res;
4027}
4028
4029namespace {
4030
4031template <typename T> T fmod_local(T x, T y) { return fmod(x,y); }
4032template <> Long64_t fmod_local(Long64_t x, Long64_t y) { return fmod((LongDouble_t)x,(LongDouble_t)y); }
4033
4034template<typename T> inline void SetMethodParam(TMethodCall *method, T p) { method->SetParam(p); }
4035template<> void SetMethodParam(TMethodCall *method, LongDouble_t p) { method->SetParam((Double_t)p); }
4036
4037// TTree::Scan prints each integer column through TTreeFormula, which evaluates it
4038// in a `long double` accumulator (for both the "l" and "ll" formats). That holds
4039// integers exactly only up to 2^digits (its mantissa size: 64 bits on x86, but
4040// just 53 where `long double` is merely a 64-bit `double`, e.g. macOS ARM), so a
4041// value beyond that range is printed rounded. This cannot be fixed without
4042// changing the (frozen) floating-point arithmetic of TTreeFormula, so it is a
4043// known limitation; flag it loudly instead. See
4044// https://github.com/root-project/root/issues/7844.
4045inline void CheckIntegerPrintPrecision(LongDouble_t evaluated, const char *expression)
4046{
4047 // Integers are represented exactly only while their magnitude stays below
4048 // 2^digits. At or above that threshold not every integer is representable, so
4049 // the printed value may be rounded -- and a rounded result can even land back
4050 // on the threshold (e.g. 2^53 + 1 -> 2^53 in a 53-bit type), so the comparison
4051 // is inclusive to avoid missing such cases.
4052 const LongDouble_t threshold = std::ldexp(1.0L, std::numeric_limits<LongDouble_t>::digits); // 2^digits
4053 // Deliberately a kError (not kWarning) emitted for every offending value with
4054 // no deduplication: silently printing a wrong integer is the trap we want to
4055 // make impossible to miss, so the diagnostic is intentionally as loud as
4056 // possible even on a many-row Scan.
4057 if (evaluated >= threshold || evaluated <= -threshold)
4058 ::Error("TTreeFormula::PrintValue",
4059 "the integer value of \"%s\" may be inexact: its magnitude reaches 2^%d, "
4060 "the point beyond which the long double used to evaluate it can no longer "
4061 "represent every integer exactly, so the printed value may be rounded. "
4062 "This is a known limitation "
4063 "(https://github.com/root-project/root/issues/7844).",
4064 expression, std::numeric_limits<LongDouble_t>::digits);
4065}
4066}
4067
4068template<typename T> inline T TTreeFormula::GetConstant(Int_t k) { return fConst[k]; }
4069template<> inline LongDouble_t TTreeFormula::GetConstant(Int_t k) {
4070 if( !fConstLD ) {
4071 // create LD version of the constants list by rescanning all literals used in the expression
4072 fConstLD = new LongDouble_t[fNconst];
4073 for (Int_t op=0; op<fNoper ; ++op) {
4074 const Int_t oper = GetOper()[op];
4075 if( (oper >> kTFOperShift) == kConstant ) {
4076 int i = (oper & kTFOperMask);
4077 if( !strncmp(fExpr[op], "0x", 2) || !strncmp(fExpr[op], "0X", 2) ) {
4078 ULong64_t val;
4079 sscanf( fExpr[op], "%llx", &val );
4080 fConstLD[i] = (LongDouble_t)val;
4081 } else {
4082 sscanf( fExpr[op], "%Lg", &fConstLD[i] );
4083 }
4084 }
4085 }
4086 }
4087 return fConstLD[k];
4088}
4089template<> inline Long64_t TTreeFormula::GetConstant(Int_t k) { return (Long64_t)GetConstant<LongDouble_t>(k); }
4090
4091////////////////////////////////////////////////////////////////////////////
4092/// \brief Evaluate this treeformula
4093/// \tparam T The type used to interpret the numbers then used for the operations
4094/// \param instance iteration instance
4095/// \param stringStackArg formula as string
4096/// \return the result of the evaluation, or a signaling NaN if out of bounds
4097///
4098/// \warning Care has to be taken before calling this function with std::vector
4099/// or dynamically sized objects, rather than plain fixed-size arrays.
4100/// For example, this works without problems:
4101/// ~~~{.cpp}
4102/// TTree t("t", "t");
4103/// Float_t x[2]{};
4104/// t.Branch("xa", &x, "x[2]/F");
4105/// x[1] = 1;
4106/// t.Fill();
4107/// x[1] = 2;
4108/// t.Fill();
4109/// t.Scan();
4110/// TTreeFormula tfx("tfx", "xa[1]", &t);
4111/// t.GetEntry(0);
4112/// tfx.EvalInstance()
4113/// t.GetEntry(1);
4114/// tfx.EvalInstance()
4115/// ~~~
4116/// But the following fails (independently on whether the size changed or not between entries):
4117/// ~~~{.cpp}
4118/// TTree t("t", "t");
4119/// vector<Short_t> v;
4120/// t.Branch("vec", &v);
4121/// v.push_back(2);
4122/// v.push_back(3);
4123/// t.Fill();
4124/// v.clear();
4125/// v.push_back(4);
4126/// v.push_back(5);
4127/// t.Fill();
4128/// t.Scan();
4129/// TTreeFormula tfv1("tfv1", "vec[1]", &t);
4130/// TTreeFormula tfv("tfv", "vec", &t);
4131/// t.GetEntry(0);
4132/// tfv1.EvalInstance()
4133/// tfv.EvalInstance(1)
4134/// t.GetEntry(1);
4135/// tfv1.EvalInstance()
4136/// tfv.EvalInstance(1)
4137/// ~~~
4138/// To prevent this, when working with objects with dynamic size for each entry, one needs
4139/// to mimick what TTree::Scan does, i.e. to check the value of
4140/// `GetNdata()` before calling `EvalInstance()`:
4141/// ~~~{.cpp}
4142/// t.GetEntry(0);
4143/// if (tfv1.GetNdata() > 0)
4144/// tfv1.EvalInstance()
4145/// if (tfv.GetNdata() > 1)
4146/// tfv.EvalInstance(1)
4147/// t.GetEntry(1);
4148/// if (tfv1.GetNdata() > 0)
4149/// tfv1.EvalInstance()
4150/// if (tfv.GetNdata() > 1)
4151/// tfv.EvalInstance(1)
4152/// ~~~
4153/// Note that for `tfv1`, even if the index is fixed in the formula and even if each entry
4154/// had the same std::vector size, since the formula contains a branch with theoretically variable size,
4155/// one must check GetNData() as there might 0 or 1 answers. Since even with fixed index,
4156/// the collection might be too small to fulfill it.
4157/// TTreeFormula::GetMultiplicity tells you (indirectly) whether you need to call GetNData or not for a given formula.
4158
4159template<typename T>
4160T TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[])
4161{
4162// Note that the redundancy and structure in this code is tailored to improve
4163// efficiencies.
4164 if (TestBit(kMissingLeaf)) return TMath::SignalingNaN();
4165 if (fNoper == 1 && fNcodes > 0) {
4166
4167 switch (fLookupType[0]) {
4168 case kDirect: {
4169 TT_EVAL_INIT;
4170 return leaf->GetTypedValue<T>(real_instance);
4171 }
4172 case kMethod: {
4173 TT_EVAL_INIT;
4174 ((TFormLeafInfo*)fDataMembers.UncheckedAt(0))->SetBranch(leaf->GetBranch());
4175 return GetValueFromMethod(0,leaf);
4176 }
4177 case kDataMember: {
4178 TT_EVAL_INIT;
4179 ((TFormLeafInfo*)fDataMembers.UncheckedAt(0))->SetBranch(leaf->GetBranch());
4180 return ((TFormLeafInfo*)fDataMembers.UncheckedAt(0))->GetTypedValue<T>(leaf,real_instance);
4181 }
4182 case kTreeMember: {
4183 TREE_EVAL_INIT;
4184 return ((TFormLeafInfo*)fDataMembers.UncheckedAt(0))->GetTypedValue<T>((TLeaf*)nullptr,real_instance);
4185 }
4186 case kIndexOfEntry: return (T)fTree->GetReadEntry();
4187 case kIndexOfLocalEntry: return (T)fTree->GetTree()->GetReadEntry();
4188 case kEntries: return (T)fTree->GetEntries();
4189 case kLocalEntries: return (T)fTree->GetTree()->GetEntries();
4190 case kLength: return fManager->fNdata;
4191 case kLengthFunc: return ((TTreeFormula*)fAliases.UncheckedAt(0))->GetNdata();
4192 case kIteration: return instance;
4193 case kSum: return Summing<T>((TTreeFormula*)fAliases.UncheckedAt(0));
4194 case kMin: return FindMin<T>((TTreeFormula*)fAliases.UncheckedAt(0));
4195 case kMax: return FindMax<T>((TTreeFormula*)fAliases.UncheckedAt(0));
4196 case kEntryList: {
4197 TEntryList *elist = (TEntryList*)fExternalCuts.At(0);
4198 return elist->Contains(fTree->GetTree()->GetReadEntry());
4199 }
4200 case -1: break;
4201 }
4202 switch (fCodes[0]) {
4203 case -2: {
4204 TCutG *gcut = (TCutG*)fExternalCuts.At(0);
4205 TTreeFormula *fx = (TTreeFormula *)gcut->GetObjectX();
4206 TTreeFormula *fy = (TTreeFormula *)gcut->GetObjectY();
4207 if (fDidBooleanOptimization) {
4208 fx->ResetLoading();
4209 fy->ResetLoading();
4210 }
4211 T xcut = fx->EvalInstance<T>(instance);
4212 T ycut = fy->EvalInstance<T>(instance);
4213 return gcut->IsInside(xcut,ycut);
4214 }
4215 case -1: {
4216 TCutG *gcut = (TCutG*)fExternalCuts.At(0);
4217 TTreeFormula *fx = (TTreeFormula *)gcut->GetObjectX();
4218 if (fDidBooleanOptimization) {
4219 fx->ResetLoading();
4220 }
4221 return fx->EvalInstance<T>(instance);
4222 }
4223 default: return TMath::SignalingNaN();
4224 }
4225 }
4226
4227 T tab[kMAXFOUND];
4228 const Int_t kMAXSTRINGFOUND = 10;
4229 const char *stringStackLocal[kMAXSTRINGFOUND];
4230 const char **stringStack = stringStackArg?stringStackArg:stringStackLocal;
4231
4232 const bool willLoad = (instance==0 || fNeedLoading); fNeedLoading = false;
4233 if (willLoad) fDidBooleanOptimization = false;
4234
4235 Int_t pos = 0;
4236 Int_t pos2 = 0;
4237 for (Int_t i=0; i<fNoper ; ++i) {
4238
4239 const Int_t oper = GetOper()[i];
4240 const Int_t newaction = oper >> kTFOperShift;
4241
4242 if (newaction<kDefinedVariable) {
4243 // ROOT::v5::TFormula operands.
4244
4245 // one of the most used cases
4246 if (newaction==kConstant) { pos++; tab[pos-1] = GetConstant<T>(oper & kTFOperMask); continue; }
4247
4248 switch(newaction) {
4249
4250 case kEnd : return tab[0];
4251 case kAdd : pos--; tab[pos-1] += tab[pos]; continue;
4252 case kSubstract : pos--; tab[pos-1] -= tab[pos]; continue;
4253 case kMultiply : pos--; tab[pos-1] *= tab[pos]; continue;
4254 case kDivide : pos--; if (tab[pos] == 0) tab[pos-1] = 0; // division by 0
4255 else tab[pos-1] /= tab[pos];
4256 continue;
4257 case kModulo : {pos--;
4258 Long64_t int1((Long64_t)tab[pos-1]);
4259 Long64_t int2((Long64_t)tab[pos]);
4260 tab[pos-1] = T(int1 % int2);
4261 continue;}
4262
4263 case kcos : tab[pos-1] = TMath::Cos(tab[pos-1]); continue;
4264 case ksin : tab[pos-1] = TMath::Sin(tab[pos-1]); continue;
4265 case ktan : if (TMath::Cos(tab[pos-1]) == 0) {tab[pos-1] = 0;} // { tangente indeterminee }
4266 else tab[pos-1] = TMath::Tan(tab[pos-1]);
4267 continue;
4268 case kacos : if (TMath::Abs(tab[pos-1]) > 1) {tab[pos-1] = 0;} // indetermination
4269 else tab[pos-1] = TMath::ACos(tab[pos-1]);
4270 continue;
4271 case kasin : if (TMath::Abs(tab[pos-1]) > 1) {tab[pos-1] = 0;} // indetermination
4272 else tab[pos-1] = TMath::ASin(tab[pos-1]);
4273 continue;
4274 case katan : tab[pos-1] = TMath::ATan(tab[pos-1]); continue;
4275 case kcosh : tab[pos-1] = TMath::CosH(tab[pos-1]); continue;
4276 case ksinh : tab[pos-1] = TMath::SinH(tab[pos-1]); continue;
4277 case ktanh : if (TMath::CosH(tab[pos-1]) == 0) {tab[pos-1] = 0;} // { tangente indeterminee }
4278 else tab[pos-1] = TMath::TanH(tab[pos-1]);
4279 continue;
4280 case kacosh: if (tab[pos-1] < 1) {tab[pos-1] = 0;} // indetermination
4281 else tab[pos-1] = TMath::ACosH(tab[pos-1]);
4282 continue;
4283 case kasinh: tab[pos-1] = TMath::ASinH(tab[pos-1]); continue;
4284 case katanh: if (TMath::Abs(tab[pos-1]) > 1) {tab[pos-1] = 0;} // indetermination
4285 else tab[pos-1] = TMath::ATanH(tab[pos-1]);
4286 continue;
4287 case katan2: pos--; tab[pos-1] = TMath::ATan2(tab[pos-1],tab[pos]); continue;
4288
4289 case kfmod : pos--; tab[pos-1] = fmod_local(tab[pos-1],tab[pos]); continue;
4290 case kpow : pos--; tab[pos-1] = TMath::Power(tab[pos-1],tab[pos]); continue;
4291 case ksq : tab[pos-1] = tab[pos-1]*tab[pos-1]; continue;
4292 case ksqrt : tab[pos-1] = TMath::Sqrt(TMath::Abs(tab[pos-1])); continue;
4293
4294 case kstrstr : pos2 -= 2; pos++;if (strstr(stringStack[pos2],stringStack[pos2+1])) tab[pos-1]=1;
4295 else tab[pos-1]=0;
4296 continue;
4297
4298 case kmin : pos--; tab[pos-1] = std::min(tab[pos-1],tab[pos]); continue;
4299 case kmax : pos--; tab[pos-1] = std::max(tab[pos-1],tab[pos]); continue;
4300
4301 case klog : if (tab[pos-1] > 0) tab[pos-1] = TMath::Log(tab[pos-1]);
4302 else {tab[pos-1] = 0;} //{indetermination }
4303 continue;
4304 case kexp : { Double_t dexp = tab[pos-1];
4305 if (dexp < -700) {tab[pos-1] = 0; continue;}
4306 if (dexp > 700) {tab[pos-1] = TMath::Exp(700); continue;}
4307 tab[pos-1] = TMath::Exp(dexp); continue;
4308 }
4309 case klog10: if (tab[pos-1] > 0) tab[pos-1] = TMath::Log10(tab[pos-1]);
4310 else {tab[pos-1] = 0;} //{indetermination }
4311 continue;
4312
4313 case kpi : pos++; tab[pos-1] = TMath::Pi(); continue;
4314
4315 case kabs : tab[pos-1] = TMath::Abs(tab[pos-1]); continue;
4316 case ksign : if (tab[pos-1] < 0) tab[pos-1] = -1; else tab[pos-1] = 1;
4317 continue;
4318 case kint : tab[pos-1] = T(Long64_t(tab[pos-1])); continue;
4319 case kSignInv: tab[pos-1] = -1 * tab[pos-1]; continue;
4320 case krndm : pos++; tab[pos-1] = gRandom->Rndm(); continue;
4321
4322 case kAnd : pos--; if (tab[pos-1]!=0 && tab[pos]!=0) tab[pos-1]=1;
4323 else tab[pos-1]=0;
4324 continue;
4325 case kOr : pos--; if (tab[pos-1]!=0 || tab[pos]!=0) tab[pos-1]=1;
4326 else tab[pos-1]=0;
4327 continue;
4328
4329 case kEqual : pos--; tab[pos-1] = (tab[pos-1] == tab[pos]) ? 1 : 0; continue;
4330 case kNotEqual : pos--; tab[pos-1] = (tab[pos-1] != tab[pos]) ? 1 : 0; continue;
4331 case kLess : pos--; tab[pos-1] = (tab[pos-1] < tab[pos]) ? 1 : 0; continue;
4332 case kGreater : pos--; tab[pos-1] = (tab[pos-1] > tab[pos]) ? 1 : 0; continue;
4333 case kLessThan : pos--; tab[pos-1] = (tab[pos-1] <= tab[pos]) ? 1 : 0; continue;
4334 case kGreaterThan: pos--; tab[pos-1] = (tab[pos-1] >= tab[pos]) ? 1 : 0; continue;
4335 case kNot : tab[pos-1] = (tab[pos-1] != 0) ? 0 : 1; continue;
4336
4337 case kStringEqual : pos2 -= 2; pos++; if (!strcmp(stringStack[pos2+1],stringStack[pos2])) tab[pos-1]=1;
4338 else tab[pos-1]=0;
4339 continue;
4340 case kStringNotEqual: pos2 -= 2; pos++;if (strcmp(stringStack[pos2+1],stringStack[pos2])) tab[pos-1]=1;
4341 else tab[pos-1]=0;
4342 continue;
4343
4344 case kBitAnd : pos--; tab[pos-1]= ((ULong64_t) tab[pos-1]) & ((ULong64_t) tab[pos]); continue;
4345 case kBitOr : pos--; tab[pos-1]= ((ULong64_t) tab[pos-1]) | ((ULong64_t) tab[pos]); continue;
4346 case kLeftShift : pos--; tab[pos-1]= ((ULong64_t) tab[pos-1]) <<((ULong64_t) tab[pos]); continue;
4347 case kRightShift: pos--; tab[pos-1]= ((ULong64_t) tab[pos-1]) >>((ULong64_t) tab[pos]); continue;
4348
4349 case kJump : i = (oper & kTFOperMask); continue;
4350 case kJumpIf : {
4351 pos--;
4352 if (!tab[pos]) {
4353 i = (oper & kTFOperMask);
4354 // If we skip the left (true) side of the if statement we may,
4355 // skip some of the branch loading (since we remove duplicate branch
4356 // request (in TTreeFormula constructor) and so we need to force the
4357 // loading here.
4358 if (willLoad) fDidBooleanOptimization = true;
4359 }
4360 continue;
4361 }
4362
4363 case kStringConst: {
4364 // String
4365 pos2++; stringStack[pos2-1] = (char*)fExpr[i].Data();
4366 if (fAxis) {
4367 // See TT_EVAL_INIT
4368 Int_t bin = fAxis->FindBin(stringStack[pos2-1]);
4369 return bin;
4370 }
4371 continue;
4372 }
4373
4374 case kBoolOptimize: {
4375 // boolean operation optimizer
4376
4377 int param = (oper & kTFOperMask);
4378 bool skip = false;
4379 int op = param % 10; // 1 is && , 2 is ||
4380
4381 if (op == 1 && (!tab[pos-1]) ) {
4382 // &&: skip the right part if the left part is already false
4383
4384 skip = true;
4385
4386 // Preserve the existing behavior (i.e. the result of a&&b is
4387 // either 0 or 1)
4388 tab[pos-1] = 0;
4389
4390 } else if (op == 2 && tab[pos-1] ) {
4391 // ||: skip the right part if the left part is already true
4392
4393 skip = true;
4394
4395 // Preserve the existing behavior (i.e. the result of a||b is
4396 // either 0 or 1)
4397 tab[pos-1] = 1;
4398 }
4399
4400 if (skip) {
4401 int toskip = param / 10;
4402 i += toskip;
4403 if (willLoad) fDidBooleanOptimization = true;
4404 }
4405 continue;
4406 }
4407
4408 case kFunctionCall: {
4409 // an external function call
4410
4411 int param = (oper & kTFOperMask);
4412 int fno = param / 1000;
4413 int nargs = param % 1000;
4414
4415 // Retrieve the function
4416 TMethodCall *method = (TMethodCall*)fFunctions.At(fno);
4417
4418 // Set the arguments
4419 method->ResetParam();
4420 if (nargs) {
4421 UInt_t argloc = pos-nargs;
4422 for(Int_t j=0;j<nargs;j++,argloc++,pos--) {
4423 SetMethodParam(method, tab[argloc]);
4424 }
4425 }
4426 pos++;
4427 Double_t ret = 0;
4428 method->Execute(ret);
4429 tab[pos-1] = ret; // check for the correct conversion!
4430
4431 continue;
4432 }
4433
4434// case kParameter: { pos++; tab[pos-1] = fParams[(oper & kTFOperMask)]; continue; }
4435 }
4436
4437 } else {
4438 // TTreeFormula operands.
4439
4440 // a tree variable (the most used case).
4441
4442 if (newaction == kDefinedVariable) {
4443
4444 const Int_t code = (oper & kTFOperMask);
4445 const Int_t lookupType = fLookupType[code];
4446 switch (lookupType) {
4447 case kIndexOfEntry: tab[pos++] = (T)fTree->GetReadEntry(); continue;
4448 case kIndexOfLocalEntry: tab[pos++] = (T)fTree->GetTree()->GetReadEntry(); continue;
4449 case kEntries: tab[pos++] = (T)fTree->GetEntries(); continue;
4450 case kLocalEntries: tab[pos++] = (T)fTree->GetTree()->GetEntries(); continue;
4451 case kLength: tab[pos++] = fManager->fNdata; continue;
4452 case kLengthFunc: tab[pos++] = ((TTreeFormula*)fAliases.UncheckedAt(i))->GetNdata(); continue;
4453 case kIteration: tab[pos++] = instance; continue;
4454 case kSum: tab[pos++] = Summing<T>((TTreeFormula*)fAliases.UncheckedAt(i)); continue;
4455 case kMin: tab[pos++] = FindMin<T>((TTreeFormula*)fAliases.UncheckedAt(i)); continue;
4456 case kMax: tab[pos++] = FindMax<T>((TTreeFormula*)fAliases.UncheckedAt(i)); continue;
4457
4458 case kDirect: { TT_EVAL_INIT_LOOP; tab[pos++] = leaf->GetTypedValue<T>(real_instance); continue; }
4459 case kMethod: { TT_EVAL_INIT_LOOP; tab[pos++] = GetValueFromMethod(code,leaf); continue; }
4460 case kDataMember: { TT_EVAL_INIT_LOOP; tab[pos++] = ((TFormLeafInfo*)fDataMembers.UncheckedAt(code))->
4461 GetTypedValue<T>(leaf,real_instance); continue; }
4462 case kTreeMember: { TREE_EVAL_INIT_LOOP; tab[pos++] = ((TFormLeafInfo*)fDataMembers.UncheckedAt(code))->
4463 GetTypedValue<T>((TLeaf*)nullptr,real_instance); continue; }
4464 case kEntryList: { TEntryList *elist = (TEntryList*)fExternalCuts.At(code);
4465 tab[pos++] = elist->Contains(fTree->GetReadEntry());
4466 continue;}
4467 case -1: break;
4468 default: tab[pos++] = 0; continue;
4469 }
4470 switch (fCodes[code]) {
4471 case -2: {
4472 TCutG *gcut = (TCutG*)fExternalCuts.At(code);
4473 TTreeFormula *fx = (TTreeFormula *)gcut->GetObjectX();
4474 TTreeFormula *fy = (TTreeFormula *)gcut->GetObjectY();
4475 if (fDidBooleanOptimization) {
4476 fx->ResetLoading();
4477 fy->ResetLoading();
4478 }
4479 T xcut = fx->EvalInstance<T>(instance);
4480 T ycut = fy->EvalInstance<T>(instance);
4481 tab[pos++] = gcut->IsInside(xcut,ycut);
4482 continue;
4483 }
4484 case -1: {
4485 TCutG *gcut = (TCutG*)fExternalCuts.At(code);
4486 TTreeFormula *fx = (TTreeFormula *)gcut->GetObjectX();
4487 if (fDidBooleanOptimization) {
4488 fx->ResetLoading();
4489 }
4490 tab[pos++] = fx->EvalInstance<T>(instance);
4491 continue;
4492 }
4493 default: {
4494 tab[pos++] = 0;
4495 continue;
4496 }
4497 }
4498 }
4499 switch(newaction) {
4500
4501 // a TTree Variable Alias (i.e. a sub-TTreeFormula)
4502 case kAlias: {
4503 int aliasN = i;
4504 TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(aliasN));
4505 R__ASSERT(subform);
4506
4507 subform->fDidBooleanOptimization = fDidBooleanOptimization;
4508 T param = subform->EvalInstance<T>(instance);
4509
4510 tab[pos] = param; pos++;
4511 continue;
4512 }
4513 // a TTree Variable Alias String (i.e. a sub-TTreeFormula)
4514 case kAliasString: {
4515 int aliasN = i;
4516 TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(aliasN));
4517 R__ASSERT(subform);
4518
4519 pos2++;
4520 subform->fDidBooleanOptimization = fDidBooleanOptimization;
4521 stringStack[pos2-1] = subform->EvalStringInstance(instance);
4522 continue;
4523 }
4524 case kMinIf: {
4525 int alternateN = i;
4526 TTreeFormula *primary = static_cast<TTreeFormula*>(fAliases.UncheckedAt(alternateN));
4527 TTreeFormula *condition = static_cast<TTreeFormula*>(fAliases.UncheckedAt(alternateN+1));
4528 T param = FindMin<T>(primary,condition);
4529 ++i; // skip the place holder for the condition
4530 tab[pos] = param; pos++;
4531 continue;
4532 }
4533 case kMaxIf: {
4534 int alternateN = i;
4535 TTreeFormula *primary = static_cast<TTreeFormula*>(fAliases.UncheckedAt(alternateN));
4536 TTreeFormula *condition = static_cast<TTreeFormula*>(fAliases.UncheckedAt(alternateN+1));
4537 T param = FindMax<T>(primary,condition);
4538 ++i; // skip the place holder for the condition
4539 tab[pos] = param; pos++;
4540 continue;
4541 }
4542
4543 // a TTree Variable Alternate (i.e. a sub-TTreeFormula)
4544 case kAlternate: {
4545 int alternateN = i;
4546 TTreeFormula *primary = static_cast<TTreeFormula*>(fAliases.UncheckedAt(alternateN));
4547
4548 // First check whether we are in range for the primary formula
4549 if (instance < primary->GetNdata()) {
4550
4551 T param = primary->EvalInstance<T>(instance);
4552
4553 ++i; // skip the alternate value.
4554
4555 tab[pos] = param; pos++;
4556 } else {
4557 // The primary is not in range, we will calculate the alternate value
4558 // via the next operation (which will be a intentional).
4559
4560 // kAlias no operations
4561 }
4562 continue;
4563 }
4564 case kAlternateString: {
4565 int alternateN = i;
4566 TTreeFormula *primary = static_cast<TTreeFormula*>(fAliases.UncheckedAt(alternateN));
4567
4568 // First check whether we are in range for the primary formula
4569 if (instance < primary->GetNdata()) {
4570
4571 pos2++;
4572 stringStack[pos2-1] = primary->EvalStringInstance(instance);
4573
4574 ++i; // skip the alternate value.
4575
4576 } else {
4577 // The primary is not in range, we will calculate the alternate value
4578 // via the next operation (which will be a kAlias).
4579
4580 // intentional no operations
4581 }
4582 continue;
4583 }
4584
4585 // a tree string
4586 case kDefinedString: {
4587 Int_t string_code = (oper & kTFOperMask);
4588 TLeaf *leafc = (TLeaf*)fLeaves.UncheckedAt(string_code);
4589
4590 // Now let calculate what physical instance we really need.
4591 const Int_t real_instance = GetRealInstance(instance,string_code);
4592
4593 if (instance==0 || fNeedLoading) {
4594 fNeedLoading = false;
4595 TBranch *branch = leafc->GetBranch();
4596 Long64_t readentry = branch->GetTree()->GetReadEntry();
4597 auto res = R__LoadBranch(branch,readentry,fQuickLoad);
4598 if (res < 0) {
4599 Error("EvalInstance", "Branch could not be loaded:%d", res);
4600 continue;
4601 }
4602 } else {
4603 // In the cases where we are behind (i.e. right of) a potential boolean optimization
4604 // this tree variable reading may have not been executed with instance==0 which would
4605 // result in the branch being potentially not read in.
4606 if (fDidBooleanOptimization) {
4607 TBranch *br = leafc->GetBranch();
4608 Long64_t treeEntry = br->GetTree()->GetReadEntry();
4609 auto res = R__LoadBranch(br, treeEntry, true);
4610 if (res < 0) {
4611 Error("EvalInstance", "Branch could not be loaded:%d", res);
4612 continue;
4613 }
4614 }
4615 if (real_instance>=fNdata[string_code]) return TMath::SignalingNaN();
4616 }
4617 pos2++;
4618 if (fLookupType[string_code]==kDirect) {
4619 stringStack[pos2-1] = (char*)leafc->GetValuePointer();
4620 } else {
4621 stringStack[pos2-1] = (char*)GetLeafInfo(string_code)->GetValuePointer(leafc,real_instance);
4622 }
4623 continue;
4624 }
4625
4626 }
4627 }
4628
4629 R__ASSERT(i<fNoper);
4630 }
4631
4632 //std::cout << __PRETTY_FUNCTION__ << " returning " << tab[0] << std::endl;
4633 return tab[0];
4634}
4635
4636// Template instantiations
4637template double TTreeFormula::EvalInstance<double> (int, char const**);
4638template long double TTreeFormula::EvalInstance<long double> (int, char const**);
4639template long long TTreeFormula::EvalInstance<long long> (int, char const**);
4640
4641////////////////////////////////////////////////////////////////////////////////
4642/// Return DataMember corresponding to code.
4643///
4644/// function called by TLeafObject::GetValue
4645/// with the value of fLookupType computed in TTreeFormula::DefinedVariable
4646
4647TFormLeafInfo *TTreeFormula::GetLeafInfo(Int_t code) const
4648{
4649 return (TFormLeafInfo *)fDataMembers.UncheckedAt(code);
4650
4651}
4652
4653////////////////////////////////////////////////////////////////////////////////
4654/// Return leaf corresponding to serial number n.
4655
4656TLeaf *TTreeFormula::GetLeaf(Int_t n) const
4657{
4658 return (TLeaf*)fLeaves.UncheckedAt(n);
4659}
4660
4661////////////////////////////////////////////////////////////////////////////////
4662/// Return methodcall corresponding to code.
4663///
4664/// function called by TLeafObject::GetValue
4665/// with the value of fLookupType computed in TTreeFormula::DefinedVariable
4666
4667TMethodCall *TTreeFormula::GetMethodCall(Int_t code) const
4668{
4669 return (TMethodCall *)fMethods.UncheckedAt(code);
4670
4671}
4672
4673////////////////////////////////////////////////////////////////////////////////
4674/// Return number of available instances in the formula.
4675
4676Int_t TTreeFormula::GetNdata()
4677{
4678 return fManager->GetNdata();
4679}
4680
4681////////////////////////////////////////////////////////////////////////////////
4682/// Return result of a leafobject method.
4683
4684Double_t TTreeFormula::GetValueFromMethod(Int_t i, TLeaf* leaf) const
4685{
4686 TMethodCall* m = GetMethodCall(i);
4687
4688 if (!m) {
4689 return 0.0;
4690 }
4691
4692 void* thisobj = nullptr;
4693 if (leaf->InheritsFrom(TLeafObject::Class())) {
4694 thisobj = ((TLeafObject*) leaf)->GetObject();
4695 } else {
4696 TBranchElement* branch = (TBranchElement*) ((TLeafElement*) leaf)->GetBranch();
4697 Int_t id = branch->GetID();
4698 // FIXME: This is wrong for a top-level branch.
4699 Int_t offset = 0;
4700 if (id > -1) {
4701 TStreamerInfo* info = branch->GetInfo();
4702 if (info) {
4703 offset = info->GetElementOffset(id);
4704 } else {
4705 Warning("GetValueFromMethod", "No streamer info for branch %s.", branch->GetName());
4706 }
4707 }
4708 if (id < 0) {
4709 char* address = branch->GetObject();
4710 thisobj = address;
4711 } else {
4712 //char* address = branch->GetAddress();
4713 char* address = branch->GetObject();
4714 if (address) {
4715 thisobj = *((char**) (address + offset));
4716 } else {
4717 // FIXME: If the address is not set, the object won't be either!
4718 thisobj = branch->GetObject();
4719 }
4720 }
4721 }
4722
4723 TMethodCall::EReturnType r = m->ReturnType();
4724
4725 if (r == TMethodCall::kLong) {
4726 Longptr_t l = 0;
4727 m->Execute(thisobj, l);
4728 return (Double_t) l;
4729 }
4730
4731 if (r == TMethodCall::kDouble) {
4732 Double_t d = 0.0;
4733 m->Execute(thisobj, d);
4734 return d;
4735 }
4736
4737 m->Execute(thisobj);
4738
4739 return 0;
4740}
4741
4742////////////////////////////////////////////////////////////////////////////////
4743/// Return result of a leafobject method.
4744
4745void* TTreeFormula::GetValuePointerFromMethod(Int_t i, TLeaf* leaf) const
4746{
4747 TMethodCall* m = GetMethodCall(i);
4748
4749 if (!m) {
4750 return nullptr;
4751 }
4752
4753 void* thisobj;
4754 if (leaf->InheritsFrom(TLeafObject::Class())) {
4755 thisobj = ((TLeafObject*) leaf)->GetObject();
4756 } else {
4757 TBranchElement* branch = (TBranchElement*) ((TLeafElement*) leaf)->GetBranch();
4758 Int_t id = branch->GetID();
4759 Int_t offset = 0;
4760 if (id > -1) {
4761 TStreamerInfo* info = branch->GetInfo();
4762 if (info) {
4763 offset = info->GetElementOffset(id);
4764 } else {
4765 Warning("GetValuePointerFromMethod", "No streamer info for branch %s.", branch->GetName());
4766 }
4767 }
4768 if (id < 0) {
4769 char* address = branch->GetObject();
4770 thisobj = address;
4771 } else {
4772 //char* address = branch->GetAddress();
4773 char* address = branch->GetObject();
4774 if (address) {
4775 thisobj = *((char**) (address + offset));
4776 } else {
4777 // FIXME: If the address is not set, the object won't be either!
4778 thisobj = branch->GetObject();
4779 }
4780 }
4781 }
4782
4783 TMethodCall::EReturnType r = m->ReturnType();
4784
4785 if (r == TMethodCall::kLong) {
4786 Longptr_t l = 0;
4787 m->Execute(thisobj, l);
4788 return nullptr;
4789 }
4790
4791 if (r == TMethodCall::kDouble) {
4792 Double_t d = 0.0;
4793 m->Execute(thisobj, d);
4794 return nullptr;
4795 }
4796
4797 if (r == TMethodCall::kOther) {
4798 char* c = nullptr;
4799 m->Execute(thisobj, &c);
4800 return c;
4801 }
4802
4803 m->Execute(thisobj);
4804
4805 return nullptr;
4806}
4807
4808////////////////////////////////////////////////////////////////////////////////
4809/// Return TRUE if the formula corresponds to one single Tree leaf
4810/// and this leaf is short, int or unsigned short, int
4811/// When a leaf is of type integer or string, the generated histogram is forced
4812/// to have an integer bin width
4813
4814bool TTreeFormula::IsInteger(bool fast) const
4815{
4816 if (fast) {
4817 if (TestBit(kIsInteger)) return true;
4818 else return false;
4819 }
4820
4821 if (fNoper==2 && GetAction(0)==kAlternate) {
4822 TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(0));
4823 R__ASSERT(subform);
4824 return subform->IsInteger(false);
4825 }
4826
4827 if (GetAction(0)==kMinIf || GetAction(0)==kMaxIf) {
4828 return false;
4829 }
4830
4831 if (fNoper > 1) return false;
4832
4833 if (GetAction(0)==kAlias) {
4834 TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(0));
4835 R__ASSERT(subform);
4836 return subform->IsInteger(false);
4837 }
4838
4839 if (fLeaves.GetEntries() != 1) {
4840 switch (fLookupType[0]) {
4841 case kIndexOfEntry:
4842 case kIndexOfLocalEntry:
4843 case kEntries:
4844 case kLocalEntries:
4845 case kLength:
4846 case kLengthFunc:
4847 case kIteration:
4848 return true;
4849 case kSum:
4850 case kMin:
4851 case kMax:
4852 case kEntryList:
4853 default:
4854 return false;
4855 }
4856 }
4857
4858 if (EvalClass()==TBits::Class()) return true;
4859
4860 if (IsLeafInteger(0) || IsLeafString(0)) return true;
4861 return false;
4862}
4863
4864////////////////////////////////////////////////////////////////////////////////
4865/// Return TRUE if the leaf corresponding to code is short, int or unsigned
4866/// short, int When a leaf is of type integer, the generated histogram is
4867/// forced to have an integer bin width
4868
4869bool TTreeFormula::IsLeafInteger(Int_t code) const
4870{
4871 TLeaf *leaf = (TLeaf*)fLeaves.At(code);
4872 if (!leaf) {
4873 switch (fLookupType[code]) {
4874 case kIndexOfEntry:
4875 case kIndexOfLocalEntry:
4876 case kEntries:
4877 case kLocalEntries:
4878 case kLength:
4879 case kLengthFunc:
4880 case kIteration:
4881 return true;
4882 case kSum:
4883 case kMin:
4884 case kMax:
4885 case kEntryList:
4886 default:
4887 return false;
4888 }
4889 }
4890 if (fAxis) return true;
4891 TFormLeafInfo * info;
4892 switch (fLookupType[code]) {
4893 case kMethod:
4894 case kTreeMember:
4895 case kDataMember:
4896 info = GetLeafInfo(code);
4897 return info->IsInteger();
4898 case kDirect:
4899 break;
4900 }
4901 if (!strcmp(leaf->GetTypeName(),"Int_t")) return true;
4902 if (!strcmp(leaf->GetTypeName(),"Short_t")) return true;
4903 if (!strcmp(leaf->GetTypeName(),"UInt_t")) return true;
4904 if (!strcmp(leaf->GetTypeName(),"UShort_t")) return true;
4905 if (!strcmp(leaf->GetTypeName(),"Bool_t")) return true;
4906 if (!strcmp(leaf->GetTypeName(),"Char_t")) return true;
4907 if (!strcmp(leaf->GetTypeName(),"UChar_t")) return true;
4908 if (!strcmp(leaf->GetTypeName(),"Long64_t")) return true;
4909 if (!strcmp(leaf->GetTypeName(),"ULong64_t")) return true;
4910 if (!strcmp(leaf->GetTypeName(),"string")) return true;
4911 return false;
4912}
4913
4914////////////////////////////////////////////////////////////////////////////////
4915/// Return TRUE if the formula is a string
4916
4917bool TTreeFormula::IsString() const
4918{
4919 // See TTreeFormula::Init for the setting of kIsCharacter.
4920 return TestBit(kIsCharacter);
4921}
4922
4923////////////////////////////////////////////////////////////////////////////////
4924/// Return true if the expression at the index 'oper' is to be treated as
4925/// as string.
4926
4927bool TTreeFormula::IsString(Int_t oper) const
4928{
4929 if (ROOT::v5::TFormula::IsString(oper)) return true;
4930 if (GetAction(oper)==kDefinedString) return true;
4931 if (GetAction(oper)==kAliasString) return true;
4932 if (GetAction(oper)==kAlternateString) return true;
4933 return false;
4934}
4935
4936////////////////////////////////////////////////////////////////////////////////
4937/// Return TRUE if the leaf or data member corresponding to code is a string
4938
4939bool TTreeFormula::IsLeafString(Int_t code) const
4940{
4941 TLeaf *leaf = (TLeaf*)fLeaves.At(code);
4942 TFormLeafInfo * info;
4943 if (fLookupType[code]==kTreeMember) {
4944 info = GetLeafInfo(code);
4945 return info->IsString();
4946 }
4947
4948 switch(fLookupType[code]) {
4949 case kDirect:
4950 if ( !leaf->IsUnsigned() && (leaf->InheritsFrom(TLeafC::Class()) || leaf->InheritsFrom(TLeafB::Class()) ) ) {
4951 // Need to find out if it is an 'array' or a pointer.
4952 if (leaf->GetLenStatic() > 1) return true;
4953
4954 // Now we need to differentiate between a variable length array and
4955 // a TClonesArray.
4956 if (leaf->GetLeafCount()) {
4957 const char* indexname = leaf->GetLeafCount()->GetName();
4958 if (indexname[strlen(indexname)-1] == '_' ) {
4959 // This in a clones array
4960 return false;
4961 } else {
4962 // this is a variable length char array
4963 return true;
4964 }
4965 }
4966 return false;
4967 } else if (leaf->InheritsFrom(TLeafElement::Class())) {
4968 TBranchElement * br = (TBranchElement*)leaf->GetBranch();
4969 Int_t bid = br->GetID();
4970 if (bid < 0) return false;
4971 if (br->GetInfo()==nullptr || !br->GetInfo()->IsCompiled()) {
4972 // Case where the file is corrupted is some ways.
4973 // We can not get to the actual type of the data
4974 // let's assume it is NOT a string.
4975 return false;
4976 }
4977 TStreamerElement * elem = (TStreamerElement*) br->GetInfo()->GetElement(bid);
4978 if (!elem) {
4979 // Case where the file is corrupted is some ways.
4980 // We can not get to the actual type of the data
4981 // let's assume it is NOT a string.
4982 return false;
4983 }
4984 if (elem->GetNewType() == TStreamerInfo::kOffsetL + TStreamerInfo::kChar) {
4985 // Check whether a specific element of the string is specified!
4986 if (fIndexes[code][fNdimensions[code]-1] != -1) return false;
4987 return true;
4988 }
4989 if ( elem->GetNewType() == TStreamerInfo::kCharStar) {
4990 // Check whether a specific element of the string is specified!
4991 if (fNdimensions[code] && fIndexes[code][fNdimensions[code]-1] != -1) return false;
4992 return true;
4993 }
4994 return false;
4995 } else {
4996 return false;
4997 }
4998 case kMethod:
4999 //TMethodCall *m = GetMethodCall(code);
5000 //TMethodCall::EReturnType r = m->ReturnType();
5001 return false;
5002 case kDataMember:
5003 info = GetLeafInfo(code);
5004 return info->IsString();
5005 default:
5006 return false;
5007 }
5008}
5009
5010////////////////////////////////////////////////////////////////////////////////
5011/// Return value of variable as a string
5012///
5013/// - mode = -2 : Print line with ***
5014/// - mode = -1 : Print column names
5015/// - mode = 0 : Print column values
5016
5017char *TTreeFormula::PrintValue(Int_t mode) const
5018{
5019 return PrintValue(mode,0);
5020}
5021
5022////////////////////////////////////////////////////////////////////////////////
5023/// Return value of variable as a string
5024///
5025/// - mode = -2 : Print line with ***
5026/// - mode = -1 : Print column names
5027/// - mode = 0 : Print column values
5028///
5029/// decform contains the requested format (with the same convention as printf).
5030
5031char *TTreeFormula::PrintValue(Int_t mode, Int_t instance, const char *decform) const
5032{
5033 const int kMAXLENGTH = kMaxLen;
5034 static char value[kMAXLENGTH];
5035
5036 if (mode == -2) {
5037 for (int i = 0; i < kMAXLENGTH-1; i++)
5038 value[i] = '*';
5039 value[kMAXLENGTH-1] = 0;
5040 } else if (mode == -1) {
5041 snprintf(value, kMAXLENGTH-1, "%s", GetTitle());
5042 } else if (mode == 0) {
5043 if ( (fNstring && fNval==0 && fNoper==1) || IsString() )
5044 {
5045 const char * val = nullptr;
5046 if (GetAction(0)==kStringConst) {
5047 val = fExpr[0].Data();
5048 } else if (instance<fNdata[0]) {
5049 if (fNoper == 1) {
5050 if (fLookupType[0]==kTreeMember) {
5051 val = (char*)GetLeafInfo(0)->GetValuePointer((TLeaf*)nullptr,instance);
5052 } else {
5053 TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(0);
5054 TBranch *branch = leaf->GetBranch();
5055 Long64_t readentry = branch->GetTree()->GetReadEntry();
5056 auto res = R__LoadBranch(branch,readentry,fQuickLoad);
5057 if (res < 0) {
5058 Error("PrintValue", "Branch could not be loaded:%d", res);
5059 } else {
5060 if (fLookupType[0]==kDirect && fNoper==1) {
5061 val = (const char*)leaf->GetValuePointer();
5062 } else {
5063 val = ((TTreeFormula*)this)->EvalStringInstance(instance);
5064 }
5065 }
5066 }
5067 } else {
5068 val = ((TTreeFormula*)this)->EvalStringInstance(instance);
5069 }
5070 }
5071 if (val) {
5072 strlcpy(value, val, kMAXLENGTH);
5073 } else {
5074 value[0] = '\0';
5075 }
5076 value[kMAXLENGTH-1] = 0;
5077 } else {
5078 //NOTE: This is terrible form ... but is forced upon us by the fact that we can not
5079 //use the mutable keyword AND we should keep PrintValue const.
5080 Int_t real_instance = ((TTreeFormula*)this)->GetRealInstance(instance,-1);
5081 if (real_instance<fNdata[0]) {
5082 Ssiz_t len = strlen(decform);
5083 Char_t outputSizeLevel = 1;
5084 char *expo = nullptr;
5085 if (len > 1) {
5086 switch (decform[len-2]) {
5087 case 'l':
5088 case 'L': {
5089 outputSizeLevel = 2;
5090 if (len > 2 && tolower(decform[len - 3]) == 'l') {
5091 outputSizeLevel = 3;
5092 }
5093 break;
5094 }
5095 case 'h': outputSizeLevel = 0; break;
5096 }
5097 }
5098 switch(decform[len-1]) {
5099 case 'c':
5100 case 'd':
5101 case 'i':
5102 {
5103 switch (outputSizeLevel) {
5104 case 0: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(Short_t)((TTreeFormula*)this)->EvalInstance(instance)); break;
5105 // Evaluate both the "long" ("l") and "long long" ("ll") formats
5106 // through `long double` so that, where it is wide enough (x86),
5107 // the full 64-bit value prints exactly; this keeps floating-point
5108 // arithmetic semantics unchanged.
5109 case 2: {
5110 LongDouble_t v = ((TTreeFormula *)this)->EvalInstance<LongDouble_t>(instance);
5111 CheckIntegerPrintPrecision(v, GetTitle());
5112 snprintf(value, kMAXLENGTH, Form("%%%s", decform), (Long_t)v);
5113 break;
5114 }
5115 case 3: {
5116 LongDouble_t v = ((TTreeFormula *)this)->EvalInstance<LongDouble_t>(instance);
5117 CheckIntegerPrintPrecision(v, GetTitle());
5118 snprintf(value, kMAXLENGTH, Form("%%%s", decform), (Long64_t)v);
5119 break;
5120 }
5121 case 1:
5122 default: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(Int_t)((TTreeFormula*)this)->EvalInstance(instance)); break;
5123 }
5124 break;
5125 }
5126 case 'o':
5127 case 'x':
5128 case 'X':
5129 case 'u':
5130 {
5131 switch (outputSizeLevel) {
5132 case 0: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(UShort_t)((TTreeFormula*)this)->EvalInstance(instance)); break;
5133 // See the signed 'd'/'i' case above: both "l" and "ll" evaluate
5134 // through `long double` to print the full value exactly where it
5135 // is wide enough, without changing arithmetic semantics.
5136 case 2: {
5137 LongDouble_t v = ((TTreeFormula *)this)->EvalInstance<LongDouble_t>(instance);
5138 CheckIntegerPrintPrecision(v, GetTitle());
5139 snprintf(value, kMAXLENGTH, Form("%%%s", decform), (ULong_t)v);
5140 break;
5141 }
5142 case 3: {
5143 LongDouble_t v = ((TTreeFormula *)this)->EvalInstance<LongDouble_t>(instance);
5144 CheckIntegerPrintPrecision(v, GetTitle());
5145 snprintf(value, kMAXLENGTH, Form("%%%s", decform), (ULong64_t)v);
5146 break;
5147 }
5148 case 1:
5149 default: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(UInt_t)((TTreeFormula*)this)->EvalInstance(instance)); break;
5150 }
5151 break;
5152 }
5153 case 'f':
5154 case 'e':
5155 case 'E':
5156 case 'g':
5157 case 'G':
5158 {
5159 switch (outputSizeLevel) {
5160 case 2: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(LongDouble_t)((TTreeFormula*)this)->EvalInstance<LongDouble_t>(instance)); break;
5161 case 1:
5162 default: snprintf(value,kMAXLENGTH,Form("%%%s",decform),((TTreeFormula*)this)->EvalInstance(instance)); break;
5163 }
5164 expo = strchr(value,'e');
5165 break;
5166 }
5167 default:
5168 snprintf(value,kMAXLENGTH,Form("%%%sg",decform),((TTreeFormula*)this)->EvalInstance(instance));
5169 expo = strchr(value,'e');
5170 }
5171 if (expo) {
5172 // If there is an exponent we may be longer than planned.
5173 // so let's trim off the excess precision!
5174 UInt_t declen = atoi(decform);
5175 if (strlen(value)>declen) {
5176 UInt_t off = strlen(value)-declen;
5177 char *start = expo - off;
5178 UInt_t vlen = strlen(expo);
5179 for(UInt_t z=0;z<=vlen;++z) {
5180 start[z] = expo[z];
5181 }
5182 //strcpy(expo-off,expo);
5183 }
5184 }
5185 } else {
5186 if (isalpha(decform[strlen(decform)-1])) {
5187 TString short_decform(decform);
5188 short_decform.Remove(short_decform.Length()-1);
5189 snprintf(value,kMAXLENGTH,Form(" %%%sc",short_decform.Data()),' ');
5190 } else {
5191 snprintf(value,kMAXLENGTH,Form(" %%%sc",decform),' ');
5192 }
5193
5194 }
5195 }
5196 }
5197 return &value[0];
5198}
5199
5200////////////////////////////////////////////////////////////////////////////////
5201/// Tell the formula that we are going to request a new entry.
5202
5203void TTreeFormula::ResetLoading()
5204{
5205 fNeedLoading = true;
5206 fDidBooleanOptimization = false;
5207
5208 for(Int_t i=0; i<fNcodes; ++i) {
5209 UInt_t max_dim = fNdimensions[i];
5210 for(UInt_t dim=0; dim<max_dim ;++dim) {
5211 if (fVarIndexes[i][dim]) {
5212 fVarIndexes[i][dim]->ResetLoading();
5213 }
5214 }
5215 }
5216 Int_t n = fAliases.GetLast();
5217 if ( fNoper < n ) {
5218 n = fNoper;
5219 }
5220 for(Int_t k=0; k <= n; ++k) {
5221 TTreeFormula *f = static_cast<TTreeFormula*>(fAliases.UncheckedAt(k));
5222 if (f) {
5223 f->ResetLoading();
5224 }
5225 }
5226 for (int i=0; i<fExternalCuts.GetSize(); i++) {
5227 auto c = dynamic_cast<TCutG*>(fExternalCuts.At(i));
5228 if (c) {
5229 ((TTreeFormula *)(c->GetObjectX()))->ResetLoading();
5230 ((TTreeFormula *)(c->GetObjectY()))->ResetLoading();
5231 }
5232 }
5233 fRealInstanceCache.fInstanceCache = 0;
5234 fRealInstanceCache.fLocalIndexCache = 0;
5235 fRealInstanceCache.fVirtAccumCache = 0;
5236}
5237
5238////////////////////////////////////////////////////////////////////////////////
5239/// Set the axis (in particular get the type).
5240
5241void TTreeFormula::SetAxis(TAxis *axis)
5242{
5243 if (!axis) {fAxis = nullptr; return;}
5244 if (IsString()) {
5245 fAxis = axis;
5246 if (fNoper==1 && GetAction(0)==kAliasString){
5247 TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(0));
5248 R__ASSERT(subform);
5249 subform->SetAxis(axis);
5250 } else if (fNoper==2 && GetAction(0)==kAlternateString){
5251 TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(0));
5252 R__ASSERT(subform);
5253 subform->SetAxis(axis);
5254 }
5255 // Since the bin are corresponding to 'string', we currently must also set
5256 // the axis to align the bins exactly on integer boundaries.
5257 axis->SetBit(TAxis::kIsInteger);
5258 } else if (IsInteger()) {
5259 axis->SetBit(TAxis::kIsInteger);
5260 }
5261}
5262
5263////////////////////////////////////////////////////////////////////////////////
5264/// Stream an object of class TTreeFormula.
5265
5266void TTreeFormula::Streamer(TBuffer &R__b)
5267{
5268 if (R__b.IsReading()) {
5269 UInt_t R__s, R__c;
5270 Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
5271 if (R__v > 2) {
5272 R__b.ReadClassBuffer(TTreeFormula::Class(), this, R__v, R__s, R__c);
5273 return;
5274 }
5275 //====process old versions before automatic schema evolution
5276 ROOT::v5::TFormula::Streamer(R__b);
5277 R__b >> fTree;
5278 R__b >> fNcodes;
5279 R__b.ReadFastArray(fCodes, fNcodes);
5280 R__b >> fMultiplicity;
5281 Int_t instance;
5282 R__b >> instance; //data member removed
5283 R__b >> fNindex;
5284 if (fNindex) {
5285 fLookupType = new Int_t[fNindex];
5286 R__b.ReadFastArray(fLookupType, fNindex);
5287 }
5288 fMethods.Streamer(R__b);
5289 //====end of old versions
5290
5291 } else {
5292 R__b.WriteClassBuffer(TTreeFormula::Class(),this);
5293 }
5294}
5295
5296////////////////////////////////////////////////////////////////////////////////
5297/// Try to 'demote' a string into an array bytes. If this is not possible,
5298/// return false.
5299
5300bool TTreeFormula::StringToNumber(Int_t oper)
5301{
5302 Int_t code = GetActionParam(oper);
5303 if (GetAction(oper)==kDefinedString && fLookupType[code]==kDirect) {
5304 if (oper>0 && GetAction(oper-1)==kJump) {
5305 // We are the second hand of a ternary operator, let's not do the fixing.
5306 return false;
5307 }
5308 TLeaf *leaf = (TLeaf*)fLeaves.At(code);
5309 if (leaf && (leaf->InheritsFrom(TLeafC::Class()) || leaf->InheritsFrom(TLeafB::Class()) ) ) {
5310 SetAction(oper, kDefinedVariable, code );
5311 fNval++;
5312 fNstring--;
5313 return true;
5314 }
5315 }
5316 return false;
5317}
5318
5319
5320////////////////////////////////////////////////////////////////////////////////
5321/// This function is called TTreePlayer::UpdateFormulaLeaves, itself
5322/// called by TChain::LoadTree when a new Tree is loaded.
5323/// Because Trees in a TChain may have a different list of leaves, one
5324/// must update the leaves numbers in the TTreeFormula used by the TreePlayer.
5325///
5326/// A safer alternative would be to recompile the whole thing .... However
5327/// currently compile HAS TO be called from the constructor!
5328
5329void TTreeFormula::UpdateFormulaLeaves()
5330{
5331 Int_t nleaves = fLeafNames.GetEntriesFast();
5332 ResetBit( kMissingLeaf );
5333 for (Int_t i=0;i<nleaves;i++) {
5334 if (!fTree) break;
5335 if (!fLeafNames[i]) continue;
5336
5337 TLeaf *leaf = fTree->GetLeaf(fLeafNames[i]->GetTitle(),fLeafNames[i]->GetName());
5338 fLeaves[i] = leaf;
5339 if (fBranches[i] && leaf) {
5340 fBranches[i] = leaf->GetBranch();
5341 // Since sometimes we might no read all the branches for all the entries, we
5342 // might sometimes only read the branch count and thus reset the collection
5343 // but might not read the data branches, to insure that a subsequent read
5344 // from TTreeFormula will properly load the data branches even if fQuickLoad is true,
5345 // we reset the entry of all branches in the TTree.
5346 ((TBranch*)fBranches[i])->ResetReadEntry();
5347 }
5348 if (leaf==nullptr) SetBit( kMissingLeaf );
5349 }
5350 for (Int_t j=0; j<kMAXCODES; j++) {
5351 for (Int_t k = 0; k<kMAXFORMDIM; k++) {
5352 if (fVarIndexes[j][k]) {
5353 fVarIndexes[j][k]->UpdateFormulaLeaves();
5354 }
5355 }
5356 if (fLookupType[j]==kDataMember || fLookupType[j]==kTreeMember) GetLeafInfo(j)->Update();
5357 if (j<fNval && fCodes[j]<0) {
5358 TCutG *gcut = (TCutG*)fExternalCuts.At(j);
5359 if (gcut) {
5360 TTreeFormula *fx = (TTreeFormula *)gcut->GetObjectX();
5361 TTreeFormula *fy = (TTreeFormula *)gcut->GetObjectY();
5362 if (fx) fx->UpdateFormulaLeaves();
5363 if (fy) fy->UpdateFormulaLeaves();
5364 }
5365 }
5366 }
5367 for(Int_t k=0;k<fNoper;k++) {
5368 const Int_t oper = GetOper()[k];
5369 switch(oper >> kTFOperShift) {
5370 case kAlias:
5371 case kAliasString:
5372 case kAlternate:
5373 case kAlternateString:
5374 case kMinIf:
5375 case kMaxIf:
5376 {
5377 TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(k));
5378 R__ASSERT(subform);
5379 subform->UpdateFormulaLeaves();
5380 break;
5381 }
5382 case kDefinedVariable:
5383 {
5384 Int_t code = GetActionParam(k);
5385 if (fCodes[code]==0) switch(fLookupType[code]) {
5386 case kLengthFunc:
5387 case kSum:
5388 case kMin:
5389 case kMax:
5390 {
5391 TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(k));
5392 R__ASSERT(subform);
5393 subform->UpdateFormulaLeaves();
5394 break;
5395 }
5396 default:
5397 break;
5398 }
5399 }
5400 default:
5401 break;
5402 }
5403 }
5404}
5405
5406////////////////////////////////////////////////////////////////////////////////
5407/// Populate the TTreeFormulaManager with the dimension information.
5408
5409void TTreeFormula::ResetDimensions() {
5410 Int_t i,k;
5411
5412 // Now that we saw all the expressions and variables AND that
5413 // we know whether arrays of chars are treated as string or
5414 // not, we can properly setup the dimensions.
5415 TIter next(fDimensionSetup);
5416 Int_t last_code = -1;
5417 Int_t virt_dim = 0;
5418 for(TDimensionInfo * info; (info = (TDimensionInfo*)next()); ) {
5419 if (last_code!=info->fCode) {
5420 // We know that the list is ordered by code number then by
5421 // dimension. Thus a different code means that we need to
5422 // restart at the lowest dimensions.
5423 virt_dim = 0;
5424 last_code = info->fCode;
5425 fNdimensions[last_code] = 0;
5426 }
5427
5428 if (GetAction(info->fOper)==kDefinedString) {
5429
5430 // We have a string used as a string (and not an array of number)
5431 // We need to determine which is the last dimension and skip it.
5432 TDimensionInfo *nextinfo = (TDimensionInfo*)next();
5433 while(nextinfo && nextinfo->fCode==info->fCode) {
5434 DefineDimensions(info->fCode,info->fSize, info->fMultiDim, virt_dim);
5435 nextinfo = (TDimensionInfo*)next();
5436 }
5437 if (!nextinfo) break;
5438
5439 info = nextinfo;
5440 virt_dim = 0;
5441 last_code = info->fCode;
5442 fNdimensions[last_code] = 0;
5443
5444 info->fSize = 1; // Maybe this should actually do nothing!
5445 }
5446
5447
5448 DefineDimensions(info->fCode,info->fSize, info->fMultiDim, virt_dim);
5449 }
5450
5451 fMultiplicity = 0;
5452 for(i=0;i<fNoper;i++) {
5453 Int_t action = GetAction(i);
5454
5455 if (action==kMinIf || action==kMaxIf) {
5456 // Skip/Ignore the 2nd args
5457 ++i;
5458 continue;
5459 }
5460 if (action==kAlias || action==kAliasString) {
5461 TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(i));
5462 R__ASSERT(subform);
5463 switch(subform->GetMultiplicity()) {
5464 case 0: break;
5465 case 1: fMultiplicity = 1; break;
5466 case 2: if (fMultiplicity!=1) fMultiplicity = 2; break;
5467 }
5468 fManager->Add(subform);
5469 // since we are addint to this manager 'subform->ResetDimensions();'
5470 // will be called a little latter
5471 continue;
5472 }
5473 if (action==kDefinedString) {
5474 //if (fOper[i] >= 105000 && fOper[i]<110000) {
5475 // We have a string used as a string
5476
5477 // This dormant portion of code would be used if (when?) we allow the histogramming
5478 // of the integral content (as opposed to the string content) of strings
5479 // held in a variable size container delimited by a null (as opposed to
5480 // a fixed size container or variable size container whose size is controlled
5481 // by a variable). In GetNdata, we will then use strlen to grab the current length.
5482 //fCumulSizes[i][fNdimensions[i]-1] = 1;
5483 //fUsedSizes[fNdimensions[i]-1] = -TMath::Abs(fUsedSizes[fNdimensions[i]-1]);
5484 //fUsedSizes[0] = - TMath::Abs( fUsedSizes[0]);
5485
5486 //continue;
5487 }
5488 }
5489
5490 for (i=0;i<fNcodes;i++) {
5491 if (fCodes[i] < 0) {
5492 TCutG *gcut = (TCutG*)fExternalCuts.At(i);
5493 if (!gcut) continue;
5494 TTreeFormula *fx = (TTreeFormula *)gcut->GetObjectX();
5495 TTreeFormula *fy = (TTreeFormula *)gcut->GetObjectY();
5496
5497 if (fx) {
5498 switch(fx->GetMultiplicity()) {
5499 case 0: break;
5500 case 1: fMultiplicity = 1; break;
5501 case 2: if (fMultiplicity!=1) fMultiplicity = 2; break;
5502 }
5503 fManager->Add(fx);
5504 }
5505 if (fy) {
5506 switch(fy->GetMultiplicity()) {
5507 case 0: break;
5508 case 1: fMultiplicity = 1; break;
5509 case 2: if (fMultiplicity!=1) fMultiplicity = 2; break;
5510 }
5511 fManager->Add(fy);
5512 }
5513
5514 continue;
5515 }
5516
5517 if (fLookupType[i]==kIteration) {
5518 fMultiplicity = 1;
5519 continue;
5520 }
5521
5522 TLeaf *leaf = i <= fLeaves.GetLast() ? (TLeaf*)fLeaves.UncheckedAt(i) : nullptr;
5523 if (!leaf) continue;
5524
5525 // Reminder of the meaning of fMultiplicity:
5526 // -1: Only one or 0 element per entry but contains variable length
5527 // -array! (Only used for TTreeFormulaManager)
5528 // 0: Only one element per entry, no variable length array
5529 // 1: loop over the elements of a variable length array
5530 // 2: loop over elements of fixed length array (nData is the same for all entry)
5531
5532 if (leaf->GetLeafCount()) {
5533 // We assume only one possible variable length dimension (the left most)
5534 fMultiplicity = 1;
5535 } else if (fLookupType[i]==kDataMember) {
5536 TFormLeafInfo * leafinfo = GetLeafInfo(i);
5537 TStreamerElement * elem = leafinfo->fElement;
5538 if (fMultiplicity!=1) {
5539 if (leafinfo->HasCounter() ) fMultiplicity = 1;
5540 else if (elem && elem->GetArrayDim()>0) fMultiplicity = 2;
5541 else if (leaf->GetLenStatic()>1) fMultiplicity = 2;
5542 }
5543 } else {
5544 if (leaf->GetLenStatic()>1 && fMultiplicity!=1) fMultiplicity = 2;
5545 }
5546 if (fMultiplicity!=1) {
5547 // If the leaf belongs to a friend tree which has an index, we might
5548 // be in the case where some entry do not exist.
5549
5550 TTree *realtree = fTree ? fTree->GetTree() : nullptr;
5551 TTree *tleaf = leaf->GetBranch()->GetTree();
5552 if (tleaf && tleaf != realtree && tleaf->GetTreeIndex()) {
5553 // Reset the multiplicity if we have a friend tree with an index.
5554 fMultiplicity = 1;
5555 }
5556 }
5557
5558 Int_t virt_dim2 = 0;
5559 for (k = 0; k < fNdimensions[i]; k++) {
5560 // At this point fCumulSizes[i][k] actually contain the physical
5561 // dimension of the k-th dimensions.
5562 if ( (fCumulSizes[i][k]>=0) && (fIndexes[i][k] >= fCumulSizes[i][k]) ) {
5563 // unreachable element requested:
5564 fManager->CancelDimension(virt_dim2); // fCumulUsedSizes[virt_dim2] = 0;
5565 }
5566 if ( fIndexes[i][k] < 0 ) virt_dim2++;
5567 fFixedSizes[i][k] = fCumulSizes[i][k];
5568 }
5569
5570 // Add up the cumulative size
5571 for (k = fNdimensions[i] - 1; (k > 0); k--) {
5572 // NOTE: When support for inside variable dimension is added this
5573 // will become inaccurate (since one of the value in the middle of the chain
5574 // is unknown until GetNdata is called.
5575 fCumulSizes[i][k-1] *= TMath::Abs(fCumulSizes[i][k]);
5576 }
5577 // NOTE: We assume that the inside variable dimensions are dictated by the
5578 // first index.
5579 if (fCumulSizes[i][0]>0) fNdata[i] = fCumulSizes[i][0];
5580
5581 //for (k = 0; k<kMAXFORMDIM; k++) {
5582 // if (fVarIndexes[i][k]) fManager->Add(fVarIndexes[i][k]);
5583 //}
5584
5585 }
5586
5587 // Handle the case of an Alt$(primary,alternate) expression that provides
5588 // the only source of multiplicity, i.e. it's used not alongside another
5589 // array that drives the iteration. Example: Scan("Alt$(x,-1)"), instead of
5590 // Scan("y-Alt$(x,-1)"). In that case the number of instances must be
5591 // dictated by the `primary` array, so we register it with the manager. We
5592 // only get here when fMultiplicity == 0, i.e. nothing else in this formula
5593 // drives an iteration.
5594 if (fMultiplicity == 0) {
5595 for (i = 0; i < fNoper; i++) {
5596 Int_t action = GetAction(i);
5597 if (action == kAlternate || action == kAlternateString) {
5598 TTreeFormula *primary = static_cast<TTreeFormula *>(fAliases.UncheckedAt(i));
5599 R__ASSERT(primary);
5600 switch (primary->GetManager()->GetMultiplicity()) {
5601 case 1: // primary is a variable length array: drive a variable length loop
5602 fMultiplicity = 1;
5603 fManager->Add(primary);
5604 break;
5605 case 2: // primary is a fixed length array: drive a fixed length loop
5606 if (fMultiplicity != 1)
5607 fMultiplicity = 2;
5608 fManager->Add(primary);
5609 break;
5610 // multiplicity 0 (scalar) or -1 (0-or-1 element): nothing to loop
5611 // over, leave fMultiplicity at 0
5612 }
5613 // An Alt$(primary,alternate) expression occupies two consecutive
5614 // operands: the `primary` action we just handled, immediately
5615 // followed by the `alternate`, which we can skip.
5616 ++i;
5617 }
5618 }
5619 }
5620}
5621
5622////////////////////////////////////////////////////////////////////////////////
5623/// Make sure that all the branches have been loaded properly.
5624
5625void TTreeFormula::LoadBranches()
5626{
5627 Int_t i;
5628 for (i=0; i<fNoper ; ++i) {
5629 TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(i);
5630 if (leaf==nullptr) continue;
5631
5632 TBranch *br = leaf->GetBranch();
5633 Long64_t treeEntry = br->GetTree()->GetReadEntry();
5634 auto res = R__LoadBranch(br, treeEntry, true);
5635 if (res < 0) {
5636 Error("LoadBranches", "Branch could not be loaded:%d", res);
5637 continue;
5638 }
5639
5640 TTreeFormula *alias = (TTreeFormula*)fAliases.UncheckedAt(i);
5641 if (alias) alias->LoadBranches();
5642
5643 Int_t max_dim = fNdimensions[i];
5644 for (Int_t dim = 0; dim < max_dim; ++dim) {
5645 if (fVarIndexes[i][dim]) fVarIndexes[i][dim]->LoadBranches();
5646 }
5647 }
5648}
5649
5650////////////////////////////////////////////////////////////////////////////////
5651/// Calculate the actual dimension for the current entry.
5652
5653bool TTreeFormula::LoadCurrentDim() {
5654 Int_t size;
5655 bool outofbounds = false;
5656
5657 for (Int_t i=0;i<fNcodes;i++) {
5658 if (fCodes[i] < 0) continue;
5659
5660 // NOTE: Currently only the leafcount can indicate a dimension that
5661 // is physically variable. So only the left-most dimension is variable.
5662 // When an API is introduced to be able to determine a variable inside dimensions
5663 // one would need to add a way to recalculate the values of fCumulSizes for this
5664 // leaf. This would probably require the addition of a new data member
5665 // fSizes[kMAXCODES][kMAXFORMDIM];
5666 // Also note that EvalInstance expect all the values (but the very first one)
5667 // of fCumulSizes to be positive. So indicating that a physical dimension is
5668 // variable (expected for the first one) can NOT be done via negative values of
5669 // fCumulSizes.
5670
5671 TLeaf *leaf = i <= fLeaves.GetLast() ? (TLeaf *)fLeaves.UncheckedAt(i) : nullptr;
5672 if (!leaf) {
5673 switch(fLookupType[i]) {
5674 case kDirect:
5675 case kMethod:
5676 case kTreeMember:
5677 case kDataMember:
5678 fNdata[i] = 0;
5679 outofbounds = true;
5680 }
5681 continue;
5682 }
5683
5684 TTree *realtree = fTree->GetTree();
5685 TTree *tleaf = leaf->GetBranch()->GetTree();
5686 if (tleaf && tleaf != realtree && tleaf->GetTreeIndex()) {
5687 if (tleaf->GetReadEntry() < 0) {
5688 fNdata[i] = 0;
5689 outofbounds = true;
5690 continue;
5691 } else {
5692 fNdata[i] = fCumulSizes[i][0];
5693 }
5694 }
5695 bool hasBranchCount2 = false;
5696 if (leaf->GetLeafCount()) {
5697 TLeaf* leafcount = leaf->GetLeafCount();
5698 TBranch *branchcount = leafcount->GetBranch();
5699 TFormLeafInfo * info = nullptr;
5700 if (leaf->IsA() == TLeafElement::Class()) {
5701 //if branchcount address not yet set, GetEntry will set the address
5702 // read branchcount value
5703 Long64_t readentry = leaf->GetBranch()->GetTree()->GetReadEntry();
5704 if (readentry < 0) readentry=0;
5705 if (!branchcount->GetAddress()) {
5706 auto res = R__LoadBranch(branchcount, readentry, fQuickLoad);
5707 if (res < 0) {
5708 Error("LoadCurrentDim", "Branch could not be loaded:%d", res);
5709 return false;
5710 }
5711 } else {
5712 // Since we do not read the full branch let's reset the read entry number
5713 // so that a subsequent read from TTreeFormula will properly load the full
5714 // object even if fQuickLoad is true.
5715 branchcount->TBranch::GetEntry(readentry);
5716 branchcount->ResetReadEntry();
5717 }
5718
5719 size = ((TBranchElement*)branchcount)->GetNdata();
5720 // Reading the size as above is correct only when the branchcount
5721 // is of streamer type kCounter which require the underlying data
5722 // member to be signed integral type.
5723
5724 TBranchElement* branch = (TBranchElement*) leaf->GetBranch();
5725 if (branch->GetAddress() == nullptr) {
5726 // Humm there is no space reserve to write the data,
5727 // the data member is likely 'removed' from the class
5728 // layout, so rather than crashing by accessing
5729 // random memory, make it clear we can't read it.
5730 size = 0;
5731 }
5732
5733 // NOTE: could be sped up
5734 if (fHasMultipleVarDim[i]) {// info && info->GetVarDim()>=0) {
5735 info = (TFormLeafInfo* )fDataMembers.At(i);
5736 auto res = R__LoadBranch(branch->GetBranchCount2() ? branch->GetBranchCount2() : branch, readentry, fQuickLoad);
5737 if (res < 0) {
5738 Error("LoadCurrentDim", "Branch could not be loaded:%d", res);
5739 return false;
5740 }
5741
5742 // Here we need to add the code to take in consideration the
5743 // double variable length
5744 // We fill up the array of sizes in the TLeafInfo:
5745 info->LoadSizes(branch);
5746 hasBranchCount2 = true;
5747 if (info->GetVirtVarDim()>=0) info->UpdateSizes(fManager->fVarDims[info->GetVirtVarDim()]);
5748
5749 // Refresh the fCumulSizes[i] to have '1' for the
5750 // double variable dimensions
5751 Int_t vdim = info->GetVarDim();
5752 fCumulSizes[i][vdim] = fCumulSizes[i][vdim+1];
5753 for(Int_t k=vdim -1; k>=0; k--) {
5754 fCumulSizes[i][k] = fCumulSizes[i][k+1]*fFixedSizes[i][k];
5755 }
5756 // Update fCumulUsedSizes
5757 // UpdateMultiVarSizes(vdim,info,i)
5758 //Int_t fixed = fCumulSizes[i][vdim+1];
5759 //for(Int_t k=vdim - 1; k>=0; k++) {
5760 // Int_t fixed *= fFixedSizes[i][k];
5761 // for(Int_t l=0;l<size; l++) {
5762 // fCumulSizes[i][k] += info->GetSize(l) * fixed;
5763 //}
5764 }
5765 } else {
5766 Long64_t readentry = leaf->GetBranch()->GetTree()->GetReadEntry();
5767 if (readentry < 0) readentry=0;
5768 auto res = R__LoadBranch(branchcount,readentry,fQuickLoad);
5769 if (res < 0) {
5770 Error("LoadCurrentDim", "Branch could not be loaded:%d", res);
5771 return false;
5772 }
5773 size = leaf->GetLen() / leaf->GetLenStatic();
5774 }
5775 if (hasBranchCount2) {
5776 // We assume that fCumulSizes[i][1] contains the product of the fixed sizes
5777 fNdata[i] = fCumulSizes[i][1] * ((TFormLeafInfo *)fDataMembers.At(i))->GetSumOfSizes();
5778 } else {
5779 fNdata[i] = size * fCumulSizes[i][1];
5780 }
5781 if (fIndexes[i][0]==-1) {
5782 // Case where the index is not specified AND the 1st dimension has a variable
5783 // size.
5784 if (fManager->fUsedSizes[0]==1 || (size<fManager->fUsedSizes[0]) ) fManager->fUsedSizes[0] = size;
5785 if (info && fIndexes[i][info->GetVarDim()]>=0) {
5786 for(Int_t j=0; j<size; j++) {
5787 if (fIndexes[i][info->GetVarDim()] >= info->GetSize(j)) {
5788 info->SetSize(j,0);
5789 if (size>fManager->fCumulUsedVarDims->GetSize()) fManager->fCumulUsedVarDims->Set(size);
5790 fManager->fCumulUsedVarDims->AddAt(-1,j);
5791 } else if (fIndexes[i][info->GetVarDim()]>=0) {
5792 // There is an index and it is not too large
5793 info->SetSize(j,1);
5794 if (size>fManager->fCumulUsedVarDims->GetSize()) fManager->fCumulUsedVarDims->Set(size);
5795 fManager->fCumulUsedVarDims->AddAt(1,j);
5796 }
5797 }
5798 }
5799 } else if (fIndexes[i][0] >= size) {
5800 // unreachable element requested:
5801 fManager->fUsedSizes[0] = 0;
5802 fNdata[i] = 0;
5803 outofbounds = true;
5804 } else if (hasBranchCount2) {
5805 TFormLeafInfo *info2;
5806 info2 = (TFormLeafInfo *)fDataMembers.At(i);
5807 if (fIndexes[i][0]<0
5808 || fIndexes[i][info2->GetVarDim()] >= info2->GetSize(fIndexes[i][0])) {
5809 // unreachable element requested:
5810 fManager->fUsedSizes[0] = 0;
5811 fNdata[i] = 0;
5812 outofbounds = true;
5813 }
5814 }
5815 } else if (fLookupType[i]==kDataMember) {
5816 TFormLeafInfo *leafinfo = (TFormLeafInfo*)fDataMembers.UncheckedAt(i);
5817 if (leafinfo->HasCounter()) {
5818 TBranch *branch = leaf->GetBranch();
5819 Long64_t readentry = branch->GetTree()->GetReadEntry();
5820 if (readentry < 0) readentry=0;
5821 auto res = R__LoadBranch(branch,readentry,fQuickLoad);
5822 if (res < 0) {
5823 Error("LoadCurrentDim", "Branch could not be loaded:%d", res);
5824 return false;
5825 }
5826 size = (Int_t) leafinfo->GetCounterValue(leaf);
5827 if (fIndexes[i][0]==-1) {
5828 // Case where the index is not specified AND the 1st dimension has a variable
5829 // size.
5830 if (fManager->fUsedSizes[0]==1 || (size<fManager->fUsedSizes[0]) ) {
5831 fManager->fUsedSizes[0] = size;
5832 }
5833 } else if (fIndexes[i][0] >= size) {
5834 // unreachable element requested:
5835 fManager->fUsedSizes[0] = 0;
5836 fNdata[i] = 0;
5837 outofbounds = true;
5838 } else {
5839 fNdata[i] = size*fCumulSizes[i][1];
5840 }
5841 Int_t vdim = leafinfo->GetVarDim();
5842 if (vdim>=0) {
5843 // Here we need to add the code to take in consideration the
5844 // double variable length
5845 // We fill up the array of sizes in the TLeafInfo:
5846 // here we can assume that branch is a TBranch element because the other style does NOT support this type
5847 // of complexity.
5848 leafinfo->LoadSizes(branch);
5849 hasBranchCount2 = true;
5850 if (fIndexes[i][0]==-1&&fIndexes[i][vdim] >= 0) {
5851 for(int z=0; z<size; ++z) {
5852 if (fIndexes[i][vdim] >= leafinfo->GetSize(z)) {
5853 leafinfo->SetSize(z,0);
5854 // --fManager->fUsedSizes[0];
5855 } else if (fIndexes[i][vdim] >= 0 ) {
5856 leafinfo->SetSize(z,1);
5857 }
5858 }
5859 }
5860 leafinfo->UpdateSizes(fManager->fVarDims[vdim]);
5861
5862 // Refresh the fCumulSizes[i] to have '1' for the
5863 // double variable dimensions
5864 fCumulSizes[i][vdim] = fCumulSizes[i][vdim+1];
5865 for(Int_t k=vdim -1; k>=0; k--) {
5866 fCumulSizes[i][k] = fCumulSizes[i][k+1]*fFixedSizes[i][k];
5867 }
5868 fNdata[i] = fCumulSizes[i][1] * leafinfo->GetSumOfSizes();
5869 } else {
5870 fNdata[i] = size * fCumulSizes[i][1];
5871 }
5872 } else if (leafinfo->GetMultiplicity()==-1) {
5873 TBranch *branch = leaf->GetBranch();
5874 Long64_t readentry = branch->GetTree()->GetReadEntry();
5875 if (readentry < 0) readentry=0;
5876 auto res = R__LoadBranch(branch,readentry,fQuickLoad);
5877 if (res < 0) {
5878 Error("LoadCurrentDim", "Branch could not be loaded:%d", res);
5879 return false;
5880 }
5881 if (leafinfo->GetNdata(leaf)==0) {
5882 outofbounds = true;
5883 }
5884 }
5885 }
5886 // However we allow several dimensions that virtually vary via the size of their
5887 // index variables. So we have code to recalculate fCumulUsedSizes.
5888 TFormLeafInfo * info = nullptr;
5889 if (fLookupType[i]!=kDirect) {
5890 info = (TFormLeafInfo *)fDataMembers.At(i);
5891 }
5892 for(Int_t k=0, virt_dim=0; k < fNdimensions[i]; k++) {
5893 if (fIndexes[i][k]<0) {
5894 if (info && fIndexes[i][k]==-2 && fVarIndexes[i][k]->GetManager()->GetMultiplicity()==0) {
5895 // Index and thus local size provided by a "index variable of size 1"
5896 Int_t index = fVarIndexes[i][k]->EvalInstance(0);
5897 Int_t index_size = info->GetSize(index);
5898 if (fManager->fUsedSizes[virt_dim]==1 || (index_size!=1 && index_size<fManager->fUsedSizes[virt_dim]) )
5899 fManager->fUsedSizes[virt_dim] = index_size;
5900 } else if (fIndexes[i][k]==-2 && fManager->fVirtUsedSizes[virt_dim]<0) {
5901
5902 // if fVirtUsedSize[virt_dim] is positive then VarIndexes[i][k]->GetNdata()
5903 // is always the same and has already been factored in fUsedSize[virt_dim]
5904 Int_t index_size = fVarIndexes[i][k]->GetNdata();
5905 if (index_size==1) {
5906 // We could either have a variable size array which is currently of size one
5907 // or a single element that might or not might not be present (and is currently present!)
5908 if (fVarIndexes[i][k]->GetManager()->GetMultiplicity()==1) {
5909 if (index_size<fManager->fUsedSizes[virt_dim]) fManager->fUsedSizes[virt_dim] = index_size;
5910 }
5911
5912 } else if (fManager->fUsedSizes[virt_dim]==-fManager->fVirtUsedSizes[virt_dim] ||
5913 index_size<fManager->fUsedSizes[virt_dim]) {
5914 fManager->fUsedSizes[virt_dim] = index_size;
5915 }
5916
5917 } else if (hasBranchCount2 && info && k==info->GetVarDim()) {
5918 // NOTE: We assume the indexing of variable sizes on the first index!
5919 if (fIndexes[i][0]>=0) {
5920 Int_t index_size = info->GetSize(fIndexes[i][0]);
5921 if (fManager->fUsedSizes[virt_dim]==1 || (index_size!=1 && index_size<fManager->fUsedSizes[virt_dim]) )
5922 fManager->fUsedSizes[virt_dim] = index_size;
5923 }
5924 }
5925 virt_dim++;
5926 } else if (hasBranchCount2 && info && k==info->GetVarDim()) {
5927
5928 // nothing to do, at some point I thought this might be useful:
5929 // if (fIndexes[i][k]>=0) {
5930 // index = info->GetSize(fIndexes[i][k]);
5931 // if (fManager->fUsedSizes[virt_dim]==1 || (index!=1 && index<fManager->fUsedSizes[virt_dim]) )
5932 // fManager->fUsedSizes[virt_dim] = index;
5933 // virt_dim++;
5934 // }
5935
5936 }
5937 }
5938 }
5939 return ! outofbounds;
5940
5941
5942
5943}
5944
5945void TTreeFormula::Convert(UInt_t oldversion)
5946{
5947 // Convert the fOper of a TTTreeFormula version fromVersion to the current in memory version
5948
5949 enum { kOldAlias = /*ROOT::v5::TFormula::kVariable*/ 100000+10000+1,
5950 kOldAliasString = kOldAlias+1,
5951 kOldAlternate = kOldAlias+2,
5952 kOldAlternateString = kOldAliasString+2
5953 };
5954
5955 for (int k=0; k<fNoper; k++) {
5956 // First hide from ROOT::v5::TFormula convertion
5957
5958 Int_t action = GetOper()[k];
5959
5960 switch (action) {
5961
5962 case kOldAlias: GetOper()[k] = -kOldAlias; break;
5963 case kOldAliasString: GetOper()[k] = -kOldAliasString; break;
5964 case kOldAlternate: GetOper()[k] = -kOldAlternate; break;
5965 case kOldAlternateString: GetOper()[k] = -kOldAlternateString; break;
5966 }
5967 }
5968
5969 ROOT::v5::TFormula::Convert(oldversion);
5970
5971 for (int i=0,offset=0; i<fNoper; i++) {
5972 Int_t action = GetOper()[i+offset];
5973
5974 switch (action) {
5975 case -kOldAlias: SetAction(i, kAlias, 0); break;
5976 case -kOldAliasString: SetAction(i, kAliasString, 0); break;
5977 case -kOldAlternate: SetAction(i, kAlternate, 0); break;
5978 case -kOldAlternateString: SetAction(i, kAlternateString, 0); break;
5979 }
5980 }
5981
5982}
5983
5984////////////////////////////////////////////////////////////////////////////////
5985/// Convert the underlying lookup method from the direct technique
5986/// (dereferencing the address held by the branch) to the method using
5987/// TFormLeafInfo. This is in particular useful in the case where we
5988/// need to append an additional TFormLeafInfo (for example to call a
5989/// method).
5990/// Return false if the switch was unsuccessful (basically in the
5991/// case of an old style split tree).
5992
5993bool TTreeFormula::SwitchToFormLeafInfo(Int_t code)
5994{
5995 TFormLeafInfo *last = nullptr;
5996 TLeaf *leaf = (TLeaf*)fLeaves.At(code);
5997 if (!leaf) return false;
5998
5999 if (fLookupType[code]==kDirect) {
6000 if (leaf->InheritsFrom(TLeafElement::Class())) {
6001 TBranchElement * br = (TBranchElement*)leaf->GetBranch();
6002 if (br->GetType()==31) {
6003 // sub branch of a TClonesArray
6004 TStreamerInfo *info = br->GetInfo();
6005 TClass* cl = info->GetClass();
6006 TStreamerElement *element = (TStreamerElement *)info->GetElement(br->GetID());
6007 TFormLeafInfo* clonesinfo = new TFormLeafInfoClones(cl, 0, element, true);
6008 Int_t offset;
6009 info->GetStreamerElement(element->GetName(),offset);
6010 clonesinfo->fNext = new TFormLeafInfo(cl,offset+br->GetOffset(),element);
6011 last = clonesinfo->fNext;
6012 fDataMembers.AddAtAndExpand(clonesinfo,code);
6013 fLookupType[code]=kDataMember;
6014
6015 } else if (br->GetType()==41) {
6016 // sub branch of a Collection
6017
6018 TBranchElement *count = br->GetBranchCount();
6019 TFormLeafInfo* collectioninfo;
6020 if ( count->GetID() >= 0 ) {
6021 TStreamerElement *collectionElement =
6022 (TStreamerElement *)count->GetInfo()->GetElement(count->GetID());
6023 TClass *collectionCl = collectionElement->GetClassPointer();
6024
6025 collectioninfo =
6026 new TFormLeafInfoCollection(collectionCl, 0, collectionElement, true);
6027 } else {
6028 TClass *collectionCl = TClass::GetClass(count->GetClassName());
6029 collectioninfo =
6030 new TFormLeafInfoCollection(collectionCl, 0, collectionCl, true);
6031 }
6032
6033 TStreamerInfo *info = br->GetInfo();
6034 TClass* cl = info->GetClass();
6035 TStreamerElement *element = (TStreamerElement *)info->GetElement(br->GetID());
6036 Int_t offset;
6037 info->GetStreamerElement(element->GetName(),offset);
6038 collectioninfo->fNext = new TFormLeafInfo(cl,offset+br->GetOffset(),element);
6039 last = collectioninfo->fNext;
6040 fDataMembers.AddAtAndExpand(collectioninfo,code);
6041 fLookupType[code]=kDataMember;
6042
6043 } else if (br->GetID()<0) {
6044 return false;
6045 } else {
6046 last = new TFormLeafInfoDirect(br);
6047 fDataMembers.AddAtAndExpand(last,code);
6048 fLookupType[code]=kDataMember;
6049 }
6050 } else {
6051 //last = new TFormLeafInfoDirect(br);
6052 //fDataMembers.AddAtAndExpand(last,code);
6053 //fLookupType[code]=kDataMember;
6054 return false;
6055 }
6056 }
6057 return true;
6058}
6059
6060Bool_t TTreeFormula::AnalyzePrimitive(TString &, TObjArray &, Int_t &, Int_t)
6061{
6062 // TTreeFormula version of AnalyzePrimitive(). Does nothing. Predefined
6063 // primitive functions are not supported by TTreeFormula since they
6064 // operate on x[] and parameters, which are unavailable here.
6065
6066 return kFALSE;
6067}
6068
6069void TTreeFormula::Optimize()
6070{
6071 // TTreeFormula version of Optimize(). Does nothing. TTreeFormula does not
6072 // support the TFormula-style optimization since it requires variables and
6073 // parameters in fixed locations, which are unavailable here.
6074
6075 return;
6076}
lenfunc
#define lenfunc
Definition CPyCppyy.h:224
d
#define d(i)
Definition RSha256.hxx:102
f
#define f(i)
Definition RSha256.hxx:104
c
#define c(i)
Definition RSha256.hxx:101
instance
static Roo_reg_AGKInteg1D instance
Definition RooAdaptiveGaussKronrodIntegrator1D.cxx:151
size
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
Bool_t
bool Bool_t
Boolean (0=false, 1=true) (bool)
Definition RtypesCore.h:78
Int_t
int Int_t
Signed integer 4 bytes (int)
Definition RtypesCore.h:60
Longptr_t
long Longptr_t
Integer large enough to hold a pointer (platform-dependent)
Definition RtypesCore.h:90
Version_t
short Version_t
Class version identifier (short)
Definition RtypesCore.h:80
Char_t
char Char_t
Character 1 byte (char)
Definition RtypesCore.h:52
ULong_t
unsigned long ULong_t
Unsigned long integer 4 bytes (unsigned long). Size depends on architecture.
Definition RtypesCore.h:70
Long_t
long Long_t
Signed long integer 4 bytes (long). Size depends on architecture.
Definition RtypesCore.h:69
UInt_t
unsigned int UInt_t
Unsigned integer 4 bytes (unsigned int)
Definition RtypesCore.h:61
Short_t
short Short_t
Signed Short integer 2 bytes (short)
Definition RtypesCore.h:54
kFALSE
constexpr Bool_t kFALSE
Definition RtypesCore.h:109
Double_t
double Double_t
Double 8 bytes.
Definition RtypesCore.h:74
LongDouble_t
long double LongDouble_t
Long Double (not portable)
Definition RtypesCore.h:76
Long64_t
long long Long64_t
Portable signed long integer 8 bytes.
Definition RtypesCore.h:84
ULong64_t
unsigned long long ULong64_t
Portable unsigned long integer 8 bytes.
Definition RtypesCore.h:85
kDoNotProcess
const Int_t kDoNotProcess
Definition TBranch.h:56
TRangeDynCast
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
Definition TCollection.h:359
kMaxLen
const Int_t kMaxLen
Definition TDirectory.cxx:35
gDirectory
#define gDirectory
Definition TDirectory.h:385
R__ASSERT
#define R__ASSERT(e)
Checks condition e and reports a fatal error if it's false.
Definition TError.h:125
Error
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition TError.cxx:208
p
winID h TVirtualViewer3D TVirtualGLPainter p
Definition TGWin32VirtualGLProxy.cxx:51
offset
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h offset
Definition TGWin32VirtualXProxy.cxx:245
r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Definition TGWin32VirtualXProxy.cxx:168
index
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t index
Definition TGWin32VirtualXProxy.cxx:168
cname
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char cname
Definition TGWin32VirtualXProxy.cxx:230
value
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Definition TGWin32VirtualXProxy.cxx:142
len
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t UChar_t len
Definition TGWin32VirtualXProxy.cxx:249
mode
Option_t Option_t TPoint TPoint const char mode
Definition TGWin32VirtualXProxy.cxx:68
type
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
Definition TGWin32VirtualXProxy.cxx:249
name
char name[80]
Definition TGX11.cxx:148
gInterpreter
#define gInterpreter
Definition TInterpreter.h:573
gROOT
#define gROOT
Definition TROOT.h:417
gRandom
R__EXTERN TRandom * gRandom
Definition TRandom.h:73
Form
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition TString.cxx:2570
TT_EVAL_INIT_LOOP
#define TT_EVAL_INIT_LOOP
Definition TTreeFormula.cxx:3870
TREE_EVAL_INIT
#define TREE_EVAL_INIT
Definition TTreeFormula.cxx:3857
TT_EVAL_INIT
#define TT_EVAL_INIT
Definition TTreeFormula.cxx:3820
R__LoadBranch
static Int_t R__LoadBranch(TBranch *br, Long64_t entry, bool quickLoad)
The function returns the number of bytes read from the input buffer.
Definition TTreeFormula.cxx:103
FindMin
T FindMin(TTreeFormula *arr)
Definition TTreeFormula.cxx:3929
FindMax
T FindMax(TTreeFormula *arr)
Definition TTreeFormula.cxx:3944
kMaxLen
const Int_t kMaxLen
Definition TTreeFormula.cxx:57
TREE_EVAL_INIT_LOOP
#define TREE_EVAL_INIT_LOOP
Definition TTreeFormula.cxx:3915
Summing
T Summing(TTreeFormula *sum)
Definition TTreeFormula.cxx:3922
IsNumberConstant
bool IsNumberConstant(const std::string &str)
Helper function checking if a string contains a literal number.
Definition TTreeFormula.cxx:118
kMAXCODES
const Int_t kMAXCODES
Definition TTreeFormula.h:42
kMAXFORMDIM
const Int_t kMAXFORMDIM
Definition TTreeFormula.h:43
snprintf
#define snprintf
Definition civetweb.c:1579
ROOT::RRangeCast::begin
const_iterator begin() const
Definition RRangeCast.hxx:103
ROOT::RRangeCast::end
const_iterator end() const
Definition RRangeCast.hxx:104
ROOT::v5::TFormula::fConst
Double_t * fConst
Definition TFormula.h:82
ROOT::v5::TFormula::fFunctions
TObjArray fFunctions
Definition TFormula.h:85
ROOT::v5::TFormula::Convert
virtual void Convert(UInt_t fromVersion)
Definition TFormula_v5.cxx:3573
ROOT::v5::TFormula::GetOper
Int_t * GetOper() const
Definition TFormula.h:104
ROOT::v5::TFormula::fExpr
TString * fExpr
Definition TFormula.h:78
ROOT::v5::TFormula::GetNdim
virtual Int_t GetNdim() const
Definition TFormula.h:238
ROOT::v5::TFormula::GetAction
Short_t GetAction(Int_t code) const
Definition TFormula.h:105
ROOT::v5::TFormula::GetActionParam
Int_t GetActionParam(Int_t code) const
Definition TFormula.h:106
ROOT::v5::TFormula::Compile
virtual Int_t Compile(const char *expression="")
Compile expression already stored in fTitle.
Definition TFormula_v5.cxx:2303
ROOT::v5::TFormula::SetAction
void SetAction(Int_t code, Int_t value, Int_t param=0)
Definition TFormula.h:108
ROOT::v5::TFormula::Streamer
void Streamer(TBuffer &b, const TClass *onfile_class)
Stream a class object.
Definition TFormula_v5.cxx:3469
ROOT::v5::TFormula::IsString
virtual Bool_t IsString(Int_t oper) const
Return true if the expression at the index 'oper' has to be treated as a string.
Definition TFormula_v5.cxx:3279
TArrayI::Set
void Set(Int_t n) override
Set size of this array to n ints.
Definition TArrayI.cxx:104
TArrayI::GetArray
const Int_t * GetArray() const
Definition TArrayI.h:43
TArrayI::At
Int_t At(Int_t i) const
Definition TArrayI.h:79
TArrayI::AddAt
void AddAt(Int_t c, Int_t i)
Add Int_t c at position i. Check for out of bounds.
Definition TArrayI.cxx:92
TArray::GetSize
Int_t GetSize() const
Definition TArray.h:47
TAxis
Class to manage histogram axis.
Definition TAxis.h:32
TAxis::kIsInteger
@ kIsInteger
Definition TAxis.h:76
TAxis::FindBin
virtual Int_t FindBin(Double_t x)
Find bin number corresponding to abscissa x.
Definition TAxis.cxx:293
TBits::Class
static TClass * Class()
TBranchElement
A Branch for the case of an object.
Definition TBranchElement.h:39
TBranchElement::Class
static TClass * Class()
TBranchElement::GetID
Int_t GetID() const
Definition TBranchElement.h:195
TBranchElement::GetClassName
const char * GetClassName() const override
Return the name of the user class whose content is stored in this branch, if any.
Definition TBranchElement.h:186
TBranchElement::GetInfo
TStreamerInfo * GetInfo() const
Get streamer info for the branch class.
Definition TBranchElement.cxx:1058
TBranchObject
A Branch for the case of an object.
Definition TBranchObject.h:26
TBranchObject::Class
static TClass * Class()
TBranch
A TTree is a list of TBranches.
Definition TBranch.h:93
TBuffer
Buffer base class used for serializing objects.
Definition TBuffer.h:43
TClassRef
TClassRef is used to implement a permanent reference to a TClass object.
Definition TClassRef.h:29
TClass
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:84
TClass::HasDataMemberInfo
Bool_t HasDataMemberInfo() const
Definition TClass.h:420
TClass::GetClassInfo
ClassInfo_t * GetClassInfo() const
Definition TClass.h:448
TClass::GetStreamerInfo
TVirtualStreamerInfo * GetStreamerInfo(Int_t version=0, Bool_t isTransient=kFALSE) const
returns a pointer to the TVirtualStreamerInfo object for version If the object does not exist,...
Definition TClass.cxx:4657
TClass::GetCollectionProxy
TVirtualCollectionProxy * GetCollectionProxy() const
Return the proxy describing the collection (if any).
Definition TClass.cxx:2918
TClass::GetMethodAllAny
TMethod * GetMethodAllAny(const char *method)
Return pointer to method without looking at parameters.
Definition TClass.cxx:4442
TClass::GetReferenceProxy
TVirtualRefProxy * GetReferenceProxy() const
Definition TClass.h:499
TClass::GetClass
static TClass * GetClass(const char *name, Bool_t load=kTRUE, Bool_t silent=kFALSE)
Static method returning pointer to TClass of the specified class name.
Definition TClass.cxx:2994
TClonesArray
An array of clone (identical) objects.
Definition TClonesArray.h:29
TClonesArray::Class
static TClass * Class()
TCollection::GetSize
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition TCollection.h:186
TCutG
Graphical cut class.
Definition TCutG.h:20
TDimensionInfo
A small helper class to help in keeping track of the array dimensions encountered in the analysis of ...
Definition TTreeFormula.cxx:130
TDimensionInfo::TDimensionInfo
TDimensionInfo(Int_t code, Int_t oper, Int_t size, TFormLeafInfoMultiVarDim *multiDim)
Definition TTreeFormula.cxx:136
TDimensionInfo::~TDimensionInfo
~TDimensionInfo() override
Definition TTreeFormula.cxx:138
TDimensionInfo::fMultiDim
TFormLeafInfoMultiVarDim * fMultiDim
Definition TTreeFormula.cxx:135
TDirectory
Describe directory structure in memory.
Definition TDirectory.h:45
TEntryList
A List of entry numbers in a TTree or TChain.
Definition TEntryList.h:26
TEntryList::Contains
virtual Int_t Contains(Long64_t entry, TTree *tree=nullptr)
Definition TEntryList.cxx:589
TFormLeafInfoCast
A small helper class to implement casting an object to a different type (equivalent to dynamic_cast)
Definition TFormLeafInfo.h:500
TFormLeafInfoClones
A small helper class to implement reading a data member on a TClonesArray object stored in a TTree.
Definition TFormLeafInfo.h:231
TFormLeafInfoCollectionObject
A small helper class to implement reading a data member on a TClonesArray object stored in a TTree.
Definition TFormLeafInfo.h:204
TFormLeafInfoCollectionSize
Used to return the size of a collection.
Definition TFormLeafInfo.h:306
TFormLeafInfoCollection
A small helper class to implement reading a data member on a generic collection object stored in a TT...
Definition TFormLeafInfo.h:261
TFormLeafInfoDirect
A small helper class to implement reading a data member on an object stored in a TTree.
Definition TFormLeafInfo.h:162
TFormLeafInfoMethod
Asmall helper class to implement executing a method of an object stored in a TTree.
Definition TFormLeafInfo.h:352
TFormLeafInfoMethod::ReturnTClass
static TClass * ReturnTClass(TMethodCall *mc)
Return the TClass corresponding to the return type of the function if it is an object type or if the ...
Definition TFormLeafInfo.cxx:2187
TFormLeafInfoMultiVarDimClones
A small helper class to implement reading a data member on a variable size array inside a TClonesArra...
Definition TFormLeafInfo.h:479
TFormLeafInfoMultiVarDimCollection
A small helper class to implement reading a data member on a variable size array inside a TClonesArra...
Definition TFormLeafInfo.h:457
TFormLeafInfoMultiVarDimDirect
A small helper class to implement reading a data member on a variable size array inside a TClonesArra...
Definition TFormLeafInfo.h:441
TFormLeafInfoMultiVarDim
A helper class to implement reading a data member on a variable size array inside a TClonesArray obje...
Definition TFormLeafInfo.h:389
TFormLeafInfoNumerical
A small helper class to implement reading a numerical value inside a collection.
Definition TFormLeafInfo.h:182
TFormLeafInfoPointer
A small helper class to implement reading a data member by following a pointer inside a branch of TTr...
Definition TFormLeafInfo.h:337
TFormLeafInfoReference
A small helper class to implement the following of reference objects stored in a TTree.
Definition TFormLeafInfoReference.h:20
TFormLeafInfoTTree
A small helper class to implement reading from the containing TTree object itself.
Definition TFormLeafInfo.h:525
TFormLeafInfo
This class is a small helper class to implement reading a data member on an object stored in a TTree.
Definition TFormLeafInfo.h:47
TFormLeafInfo::GetValuePointer
virtual void * GetValuePointer(TLeaf *leaf, Int_t instance=0)
returns the address of the value pointed to by the serie of TFormLeafInfo.
Definition TFormLeafInfo.cxx:619
TFormLeafInfo::Update
virtual bool Update()
We reloading all cached information in case the underlying class information has changed (for example...
Definition TFormLeafInfo.cxx:509
TFormLeafInfo::GetClass
virtual TClass * GetClass() const
Get the class of the underlying data.
Definition TFormLeafInfo.cxx:173
TFormLeafInfo::fNext
TFormLeafInfo * fNext
follow this to grab the inside information
Definition TFormLeafInfo.h:67
TFormula
The Formula class.
Definition TFormula.h:89
TLeafB::Class
static TClass * Class()
TLeafC::Class
static TClass * Class()
TLeafElement
A TLeaf for the general case when using the branches created via a TStreamerInfo (i....
Definition TLeafElement.h:32
TLeafElement::Class
static TClass * Class()
TLeafObject
A TLeaf for a general object derived from TObject.
Definition TLeafObject.h:31
TLeafObject::Class
static TClass * Class()
TLeaf
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
Definition TLeaf.h:57
TList
A doubly linked list.
Definition TList.h:38
TList::Add
void Add(TObject *obj) override
Definition TList.h:81
TList::Delete
void Delete(Option_t *option="") override
Remove all objects from the list AND delete all heap based objects.
Definition TList.cxx:600
TMethodCall
Method or function calling interface.
Definition TMethodCall.h:37
TMethodCall::kLong
static const EReturnType kLong
Definition TMethodCall.h:43
TMethodCall::kString
static const EReturnType kString
Definition TMethodCall.h:45
TMethodCall::kOther
static const EReturnType kOther
Definition TMethodCall.h:46
TMethodCall::kDouble
static const EReturnType kDouble
Definition TMethodCall.h:44
TNamed
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
TNamed::GetName
const char * GetName() const override
Returns name of object.
Definition TNamed.h:49
TNamed::GetTitle
const char * GetTitle() const override
Returns title of object.
Definition TNamed.h:50
TNamed::TNamed
TNamed()
Definition TNamed.h:38
TNamed::SetName
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition TNamed.cxx:149
TObjArray
An array of TObjects.
Definition TObjArray.h:31
TObjArray::GetEntriesFast
Int_t GetEntriesFast() const
Definition TObjArray.h:58
TObjArray::AddAt
void AddAt(TObject *obj, Int_t idx) override
Add object at position ids.
Definition TObjArray.cxx:253
TObjArray::AddAtAndExpand
virtual void AddAtAndExpand(TObject *obj, Int_t idx)
Add object at position idx.
Definition TObjArray.cxx:234
TObjArray::Streamer
void Streamer(TBuffer &) override
Stream all objects in the array to or from the I/O buffer.
Definition TObjArray.cxx:448
TObjArray::GetEntries
Int_t GetEntries() const override
Return the number of objects in array (i.e.
Definition TObjArray.cxx:522
TObjArray::Delete
void Delete(Option_t *option="") override
Remove all objects from the array AND delete all heap based objects.
Definition TObjArray.cxx:355
TObjArray::At
TObject * At(Int_t idx) const override
Definition TObjArray.h:170
TObjArray::UncheckedAt
TObject * UncheckedAt(Int_t i) const
Definition TObjArray.h:90
TObjArray::FindObject
TObject * FindObject(const char *name) const override
Find an object in this collection using its name.
Definition TObjArray.cxx:414
TObjArray::GetLast
Int_t GetLast() const override
Return index of last object in array.
Definition TObjArray.cxx:576
TObject
Mother of all ROOT objects.
Definition TObject.h:42
TObject::TestBit
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition TObject.h:204
TObject::Warning
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition TObject.cxx:1084
TObject::Execute
virtual void Execute(const char *method, const char *params, Int_t *error=nullptr)
Execute method on this object with the given parameter string, e.g.
Definition TObject.cxx:378
TObject::SetBit
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:888
TObject::Error
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:1098
TObject::ResetBit
void ResetBit(UInt_t f)
Definition TObject.h:203
TRandom::Rndm
Double_t Rndm() override
Machine independent random number generator.
Definition TRandom.cxx:558
TStreamerBasicPointer::Class
static TClass * Class()
TStreamerBasicPointer::GetCountName
const char * GetCountName() const
Definition TStreamerElement.h:215
TStreamerElement
Describe one element (data member) to be Streamed.
Definition TStreamerElement.h:25
TStreamerInfo
Describes a persistent version of a class.
Definition TStreamerInfo.h:39
TStreamerInfo::GetElement
TStreamerElement * GetElement(Int_t id) const override
Definition TStreamerInfo.h:167
TString
Basic string class.
Definition TString.h:138
TString::kNPOS
static constexpr Ssiz_t kNPOS
Definition TString.h:286
TString::Data
const char * Data() const
Definition TString.h:386
TString::Class
static TClass * Class()
TTreeFormulaManager::fMultiVarDim
bool fMultiVarDim
True if one of the variable has 2 variable size dimensions.
Definition TTreeFormulaManager.h:34
TTreeFormulaManager::UpdateUsedSize
virtual void UpdateUsedSize(Int_t &virt_dim, Int_t vsize)
Reload the array sizes.
Definition TTreeFormulaManager.cxx:307
TTreeFormulaManager::fVirtUsedSizes
Int_t fVirtUsedSizes[kMAXFORMDIM+1]
Virtual size of lower dimensions as seen for this formula.
Definition TTreeFormulaManager.h:43
TTreeFormulaManager::fNdata
Int_t fNdata
! Last value calculated by GetNdata
Definition TTreeFormulaManager.h:35
TTreeFormulaManager::fCumulUsedVarDims
TArrayI * fCumulUsedVarDims
fCumulUsedSizes(1) for multi variable dimensions case
Definition TTreeFormulaManager.h:39
TTreeFormulaManager::fVarDims
TArrayI * fVarDims[kMAXFORMDIM+1]
List of variable sizes dimensions.
Definition TTreeFormulaManager.h:42
TTreeFormulaManager::EnableMultiVarDims
virtual void EnableMultiVarDims()
Set the manager as handling a formula with multiple variable dimensions.
Definition TTreeFormulaManager.cxx:112
TTreeFormulaManager::CancelDimension
virtual void CancelDimension(Int_t virt_dim)
Cancel a dimension.
Definition TTreeFormulaManager.cxx:104
TTreeFormulaManager::fCumulUsedSizes
Int_t fCumulUsedSizes[kMAXFORMDIM+1]
Accumulated size of lower dimensions as seen for this entry.
Definition TTreeFormulaManager.h:38
TTreeFormulaManager::fUsedSizes
Int_t fUsedSizes[kMAXFORMDIM+1]
Actual size of the dimensions as seen for this entry.
Definition TTreeFormulaManager.h:41
TTreeFormulaManager::GetNdata
virtual Int_t GetNdata(bool forceLoadDim=false)
Return number of available instances in the formulas.
Definition TTreeFormulaManager.cxx:121
TTreeFormulaManager::Add
virtual void Add(TTreeFormula *)
Add a new formula to the list of formulas managed The manager of the formula will be changed and the ...
Definition TTreeFormulaManager.cxx:70
TTreeFormulaManager::Sync
virtual bool Sync()
Synchronize all the formulae.
Definition TTreeFormulaManager.cxx:218
TTreeFormulaManager::AddVarDims
virtual void AddVarDims(Int_t virt_dim)
Add a variable dimension.
Definition TTreeFormulaManager.cxx:95
TTreeFormulaManager::Remove
virtual void Remove(TTreeFormula *)
Remove a formula from this manager.
Definition TTreeFormulaManager.cxx:60
TTreeFormulaManager::GetMultiplicity
virtual Int_t GetMultiplicity() const
Definition TTreeFormulaManager.h:66
TTreeFormula
Used to pass a selection expression to the Tree drawing routine.
Definition TTreeFormula.h:58
TTreeFormula::LoadCurrentDim
bool LoadCurrentDim()
Calculate the actual dimension for the current entry.
Definition TTreeFormula.cxx:5647
TTreeFormula::ResetLoading
virtual void ResetLoading()
Tell the formula that we are going to request a new entry.
Definition TTreeFormula.cxx:5197
TTreeFormula::IsInteger
virtual bool IsInteger(bool fast=true) const
Return TRUE if the formula corresponds to one single Tree leaf and this leaf is short,...
Definition TTreeFormula.cxx:4808
TTreeFormula::fHasCast
bool fHasCast
Record whether the formula contain a cast operation or not.
Definition TTreeFormula.h:99
TTreeFormula::fHasMultipleVarDim
UChar_t fHasMultipleVarDim[kMAXCODES]
True if the corresponding variable is an array with more than one variable dimension.
Definition TTreeFormula.h:115
TTreeFormula::fMultiplicity
Int_t fMultiplicity
Indicator of the variability of the formula.
Definition TTreeFormula.h:100
TTreeFormula::FindLeafForExpression
Int_t FindLeafForExpression(const char *expression, TLeaf *&leaf, TString &leftover, bool &final, UInt_t &paran_level, TObjArray &castqueue, std::vector< std::string > &aliasUsed, bool &useLeafCollectionObject, const char *fullExpression)
Look for the leaf corresponding to the start of expression.
Definition TTreeFormula.cxx:2241
TTreeFormula::TTreeFormula
TTreeFormula()=delete
TTreeFormula::DefineAlternate
Int_t DefineAlternate(const char *expression)
This method check for treat the case where expression contains Alt$( and load up both fAliases and fE...
Definition TTreeFormula.cxx:678
TTreeFormula::GetManager
TTreeFormulaManager * GetManager() const
Definition TTreeFormula.h:195
TTreeFormula::GetLeaf
virtual TLeaf * GetLeaf(Int_t n) const
Return leaf corresponding to serial number n.
Definition TTreeFormula.cxx:4650
TTreeFormula::fAxis
TAxis * fAxis
! pointer to histogram axis if this is a string
Definition TTreeFormula.h:122
TTreeFormula::AnalyzePrimitive
Bool_t AnalyzePrimitive(TString &chain, TObjArray &args, Int_t &err, Int_t offset) override
Check if the given string matches a defined function primitive.
Definition TTreeFormula.cxx:6054
TTreeFormula::fNindex
Int_t fNindex
Size of fIndex.
Definition TTreeFormula.h:101
TTreeFormula::fNcodes
Int_t fNcodes
Number of leaves referenced in formula.
Definition TTreeFormula.h:98
TTreeFormula::RegisterDimensions
Int_t RegisterDimensions(Int_t code, Int_t size, TFormLeafInfoMultiVarDim *multidim=nullptr)
This method stores the dimension information for later usage.
Definition TTreeFormula.cxx:457
TTreeFormula::fExternalCuts
TObjArray fExternalCuts
! List of TCutG and TEntryList used in the formula
Definition TTreeFormula.h:106
TTreeFormula::DefinedVariable
Int_t DefinedVariable(TString &variable, Int_t &action) override
Check if name is in the list of Tree/Branch leaves.
Definition TTreeFormula.cxx:2752
TTreeFormula::GetValueFromMethod
virtual Double_t GetValueFromMethod(Int_t i, TLeaf *leaf) const
Return result of a leafobject method.
Definition TTreeFormula.cxx:4678
TTreeFormula::EvalStringInstance
virtual const char * EvalStringInstance(Int_t i=0)
Eval the instance as a string.
Definition TTreeFormula.cxx:3786
TTreeFormula::Init
void Init(const char *name, const char *formula)
Initialization called from the constructors.
Definition TTreeFormula.cxx:196
TTreeFormula::fLookupType
Int_t * fLookupType
[fNindex] Array indicating how each leaf should be looked-up
Definition TTreeFormula.h:102
TTreeFormula::fQuickLoad
bool fQuickLoad
! If true, branch GetEntry is only called when the entry number changes.
Definition TTreeFormula.h:110
TTreeFormula::ParseWithLeaf
Int_t ParseWithLeaf(TLeaf *leaf, const char *expression, bool final, UInt_t paran_level, TObjArray &castqueue, bool useLeafCollectionObject, const char *fullExpression)
Decompose 'expression' as pointing to something inside the leaf Returns:
Definition TTreeFormula.cxx:785
TTreeFormula::SwitchToFormLeafInfo
virtual bool SwitchToFormLeafInfo(Int_t code)
Convert the underlying lookup method from the direct technique (dereferencing the address held by the...
Definition TTreeFormula.cxx:5987
TTreeFormula::fAliasesUsed
std::vector< std::string > fAliasesUsed
! List of aliases used during the parsing of the expression.
Definition TTreeFormula.h:128
TTreeFormula::fCodes
Int_t fCodes[kMAXCODES]
List of leaf numbers referenced in formula.
Definition TTreeFormula.h:96
TTreeFormula::PrintValue
virtual char * PrintValue(Int_t mode=0) const
Return value of variable as a string.
Definition TTreeFormula.cxx:5011
TTreeFormula::fNeedLoading
bool fNeedLoading
! If true, the current entry has not been loaded yet.
Definition TTreeFormula.h:111
TTreeFormula::fIndexes
Int_t fIndexes[kMAXCODES][kMAXFORMDIM]
Index of array selected by user for each leaf.
Definition TTreeFormula.h:119
TTreeFormula::GetMultiplicity
virtual Int_t GetMultiplicity() const
Definition TTreeFormula.h:197
TTreeFormula::Streamer
void Streamer(TBuffer &) override
Stream an object of class TTreeFormula.
Definition TTreeFormula.cxx:5260
TTreeFormula::fCumulSizes
Int_t fCumulSizes[kMAXCODES][kMAXFORMDIM]
Accumulated sizes of lower dimensions for each leaf after variable dimensions has been calculated.
Definition TTreeFormula.h:118
TTreeFormula::IsString
virtual bool IsString() const
Return TRUE if the formula is a string.
Definition TTreeFormula.cxx:4911
TTreeFormula::fDimensionSetup
TList * fDimensionSetup
! list of dimension setups, for delayed creation of the dimension information.
Definition TTreeFormula.h:127
TTreeFormula::EvalInstance
T EvalInstance(Int_t i=0, const char *stringStack[]=nullptr)
Evaluate this treeformula.
Definition TTreeFormula.cxx:4154
TTreeFormula::ResetDimensions
void ResetDimensions()
Populate the TTreeFormulaManager with the dimension information.
Definition TTreeFormula.cxx:5403
TTreeFormula::fNdimensions
Int_t fNdimensions[kMAXCODES]
Number of array dimensions in each leaf.
Definition TTreeFormula.h:113
TTreeFormula::fTree
TTree * fTree
! Pointer to Tree
Definition TTreeFormula.h:95
TTreeFormula::GetLeafWithDatamember
TLeaf * GetLeafWithDatamember(const char *topchoice, const char *nextchice, Long64_t readentry) const
Return the leaf (if any) which contains an object containing a data member which has the name provide...
Definition TTreeFormula.cxx:3133
TTreeFormula::GetMethodCall
TMethodCall * GetMethodCall(Int_t code) const
Return methodcall corresponding to code.
Definition TTreeFormula.cxx:4661
TTreeFormula::UpdateFormulaLeaves
virtual void UpdateFormulaLeaves()
This function is called TTreePlayer::UpdateFormulaLeaves, itself called by TChain::LoadTree when a ne...
Definition TTreeFormula.cxx:5323
TTreeFormula::~TTreeFormula
~TTreeFormula() override
Tree Formula default destructor.
Definition TTreeFormula.cxx:342
TTreeFormula::fAliases
TObjArray fAliases
! List of TTreeFormula for each alias used.
Definition TTreeFormula.h:107
TTreeFormula::GetConstant
T GetConstant(Int_t k)
Definition TTreeFormula.cxx:4062
TTreeFormula::EvalObject
virtual void * EvalObject(Int_t i=0)
Evaluate this treeformula.
Definition TTreeFormula.cxx:3731
TTreeFormula::fLeafNames
TObjArray fLeafNames
List of TNamed describing leaves.
Definition TTreeFormula.h:108
TTreeFormula::StringToNumber
bool StringToNumber(Int_t code) override
Try to 'demote' a string into an array bytes.
Definition TTreeFormula.cxx:5294
TTreeFormula::Class
static TClass * Class()
TTreeFormula::IsLeafInteger
virtual bool IsLeafInteger(Int_t code) const
Return TRUE if the leaf corresponding to code is short, int or unsigned short, int When a leaf is of ...
Definition TTreeFormula.cxx:4863
TTreeFormula::DefineDimensions
void DefineDimensions(Int_t code, Int_t size, TFormLeafInfoMultiVarDim *info, Int_t &virt_dim)
This method is used internally to decode the dimensions of the variables.
Definition TTreeFormula.cxx:374
TTreeFormula::IsLeafString
virtual bool IsLeafString(Int_t code) const
Return TRUE if the leaf or data member corresponding to code is a string.
Definition TTreeFormula.cxx:4933
TTreeFormula::LoadBranches
void LoadBranches()
Make sure that all the branches have been loaded properly.
Definition TTreeFormula.cxx:5619
TTreeFormula::EvalClass
virtual TClass * EvalClass() const
Evaluate the class of this treeformula.
Definition TTreeFormula.cxx:3669
TTreeFormula::GetRealInstance
Int_t GetRealInstance(Int_t instance, Int_t codeindex)
Now let calculate what physical instance we really need.
Definition TTreeFormula.cxx:3434
TTreeFormula::SetAxis
virtual void SetAxis(TAxis *axis=nullptr)
Set the axis (in particular get the type).
Definition TTreeFormula.cxx:5235
TTreeFormula::GetLeafInfo
TFormLeafInfo * GetLeafInfo(Int_t code) const
Return DataMember corresponding to code.
Definition TTreeFormula.cxx:4641
TTreeFormula::fDataMembers
TObjArray fDataMembers
! List of leaf data members
Definition TTreeFormula.h:104
TTreeFormula::BranchHasMethod
bool BranchHasMethod(TLeaf *leaf, TBranch *branch, const char *method, const char *params, Long64_t readentry) const
Return the leaf (if any) of the tree with contains an object of a class having a method which has the...
Definition TTreeFormula.cxx:3307
TTreeFormula::fVarIndexes
TTreeFormula * fVarIndexes[kMAXCODES][kMAXFORMDIM]
Pointer to a variable index.
Definition TTreeFormula.h:120
TTreeFormula::fConstLD
LongDouble_t * fConstLD
! local version of fConsts able to store bigger numbers
Definition TTreeFormula.h:130
TTreeFormula::fFixedSizes
Int_t fFixedSizes[kMAXCODES][kMAXFORMDIM]
Physical sizes of lower dimensions for each leaf.
Definition TTreeFormula.h:114
TTreeFormula::GetNdata
virtual Int_t GetNdata()
Return number of available instances in the formula.
Definition TTreeFormula.cxx:4670
TTreeFormula::fRealInstanceCache
RealInstanceCache fRealInstanceCache
! Cache accelerating the GetRealInstance function
Definition TTreeFormula.h:132
TTreeFormula::fMethods
TObjArray fMethods
! List of leaf method calls
Definition TTreeFormula.h:105
TTreeFormula::fNdata
Int_t fNdata[kMAXCODES]
! This caches the physical number of element in the leaf or data member.
Definition TTreeFormula.h:97
TTreeFormula::Optimize
void Optimize() override
MI include.
Definition TTreeFormula.cxx:6063
TTreeFormula::fLeaves
TObjArray fLeaves
! List of leaf used in this formula.
Definition TTreeFormula.h:103
TTreeFormula::fDidBooleanOptimization
bool fDidBooleanOptimization
! True if we executed one boolean optimization since the last time instance number 0 was evaluated
Definition TTreeFormula.h:123
TTreeFormula::TTreeFormulaManager
friend class TTreeFormulaManager
Definition TTreeFormula.h:60
TTreeFormula::GetValuePointerFromMethod
virtual void * GetValuePointerFromMethod(Int_t i, TLeaf *leaf) const
Return result of a leafobject method.
Definition TTreeFormula.cxx:4739
TTreeFormula::fBranches
TObjArray fBranches
! List of branches to read. Similar to fLeaves but duplicates are zeroed out.
Definition TTreeFormula.h:109
TTreeFormula::fManager
TTreeFormulaManager * fManager
! The dimension coordinator.
Definition TTreeFormula.h:124
TTreeFormula::Convert
void Convert(UInt_t fromVersion) override
Definition TTreeFormula.cxx:5939
TTree
A TTree represents a columnar dataset.
Definition TTree.h:89
TTree::FindBranch
virtual TBranch * FindBranch(const char *name)
Return the branch that correspond to the path 'branchname', which can include the name of the tree or...
Definition TTree.cxx:4890
TTree::GetIteratorOnAllLeaves
virtual TIterator * GetIteratorOnAllLeaves(bool dir=kIterForward)
Creates a new iterator that will go through all the leaves on the tree itself and its friend.
Definition TTree.cxx:6193
TTree::GetEntries
virtual Long64_t GetEntries() const
Definition TTree.h:510
TTree::GetLeaf
virtual TLeaf * GetLeaf(const char *branchname, const char *leafname)
Return pointer to the 1st Leaf named name in any Branch of this Tree or any branch in the list of fri...
Definition TTree.cxx:6306
TTree::GetReadEntry
virtual Long64_t GetReadEntry() const
Definition TTree.h:596
TTree::GetListOfBranches
virtual TObjArray * GetListOfBranches()
Definition TTree.h:575
TTree::GetTree
virtual TTree * GetTree() const
Definition TTree.h:604
TTree::LoadTree
virtual Long64_t LoadTree(Long64_t entry)
Set current entry.
Definition TTree.cxx:6584
TTree::GetAlias
virtual const char * GetAlias(const char *aliasName) const
Returns the expanded value of the alias. Search in the friends if any.
Definition TTree.cxx:5275
TTree::GetTreeNumber
virtual Int_t GetTreeNumber() const
Definition TTree.h:606
TTree::Class
static TClass * Class()
TTree::FindLeaf
virtual TLeaf * FindLeaf(const char *name)
Find first leaf containing searchname.
Definition TTree.cxx:4965
TTree::GetFriendAlias
virtual const char * GetFriendAlias(TTree *) const
If the 'tree' is a friend, this method returns its alias name.
Definition TTree.cxx:6113
TVirtualCollectionProxy::GetType
virtual EDataType GetType() const =0
If the value type is a fundamental data type, return its type (see enumeration EDataType).
TVirtualCollectionProxy::GetValueClass
virtual TClass * GetValueClass() const =0
If the value type is a user-defined class, return a pointer to the TClass representing the value type...
TVirtualRefProxy::HasCounter
virtual Bool_t HasCounter() const =0
TVirtualStreamerInfo::GetElements
virtual TObjArray * GetElements() const =0
ROOT::VecOps::fmod
RVec< PromoteTypes< T0, T1 > > fmod(const T0 &x, const RVec< T1 > &v)
Definition RVec.hxx:1838
y
Double_t y[n]
Definition legend1.C:17
x
Double_t x[n]
Definition legend1.C:17
n
const Int_t n
Definition legend1.C:16
TMath::CosH
Double_t CosH(Double_t)
Returns the hyperbolic cosine of x.
Definition TMath.h:623
TMath::ACos
Double_t ACos(Double_t)
Returns the principal value of the arc cosine of x, expressed in radians.
Definition TMath.h:643
TMath::ASin
Double_t ASin(Double_t)
Returns the principal value of the arc sine of x, expressed in radians.
Definition TMath.h:635
TMath::Exp
Double_t Exp(Double_t x)
Returns the base-e exponential function of x, which is e raised to the power x.
Definition TMath.h:720
TMath::ATan
Double_t ATan(Double_t)
Returns the principal value of the arc tangent of x, expressed in radians.
Definition TMath.h:651
TMath::ASinH
Double_t ASinH(Double_t)
Returns the area hyperbolic sine of x.
Definition TMath.cxx:67
TMath::TanH
Double_t TanH(Double_t)
Returns the hyperbolic tangent of x.
Definition TMath.h:629
TMath::ACosH
Double_t ACosH(Double_t)
Returns the nonnegative area hyperbolic cosine of x.
Definition TMath.cxx:81
TMath::ATan2
Double_t ATan2(Double_t y, Double_t x)
Returns the principal value of the arc tangent of y/x, expressed in radians.
Definition TMath.h:657
TMath::Log
Double_t Log(Double_t x)
Returns the natural logarithm of x.
Definition TMath.h:767
TMath::Sqrt
Double_t Sqrt(Double_t x)
Returns the square root of x.
Definition TMath.h:673
TMath::Power
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Returns x raised to the power y.
Definition TMath.h:732
TMath::Cos
Double_t Cos(Double_t)
Returns the cosine of an angle of x radians.
Definition TMath.h:605
TMath::Pi
constexpr Double_t Pi()
Definition TMath.h:40
TMath::Sin
Double_t Sin(Double_t)
Returns the sine of an angle of x radians.
Definition TMath.h:599
TMath::SignalingNaN
Double_t SignalingNaN()
Returns a signaling NaN as defined by IEEE 754](http://en.wikipedia.org/wiki/NaN#Signaling_NaN).
Definition TMath.h:921
TMath::Tan
Double_t Tan(Double_t)
Returns the tangent of an angle of x radians.
Definition TMath.h:611
TMath::ATanH
Double_t ATanH(Double_t)
Returns the area hyperbolic tangent of x.
Definition TMath.cxx:95
TMath::Log10
Double_t Log10(Double_t x)
Returns the common (base-10) logarithm of x.
Definition TMath.h:773
TMath::Abs
Short_t Abs(Short_t d)
Returns the absolute value of parameter Short_t d.
Definition TMathBase.h:122
TMath::SinH
Double_t SinH(Double_t)
Returns the hyperbolic sine of `x.
Definition TMath.h:617
df101_h1Analysis.condition
str condition
Definition df101_h1Analysis.py:52
v
@ v
Definition rootcling_impl.cxx:3554
slash
TCanvas * slash()
Definition slash.C:1
what
static const char * what
Definition stlLoader.cc:5
m
TMarker m
Definition textangle.C:8
l
TLine l
Definition textangle.C:4
sum
static uint64_t sum(uint64_t i)
Definition Factory.cxx:2338
kTFOperShift
const UChar_t kTFOperShift
Definition TFormula.h:33
kTFOperMask
const Int_t kTFOperMask
Definition TFormula.h:32
kMAXFOUND
const Int_t kMAXFOUND
Definition TFormula.h:31