Logo ROOT  
Reference Guide
TTreePlayer.cxx
Go to the documentation of this file.
1 // @(#)root/treeplayer:$Id$
2 // Author: Rene Brun 12/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 /** \class TTreePlayer
13 
14 Implement some of the functionality of the class TTree requiring access to
15 extra libraries (Histogram, display, etc).
16 */
17 
18 #include "TTreePlayer.h"
19 
20 #include <cstring>
21 #include <cstdio>
22 #include <cstdlib>
23 #include <iostream>
24 #include <fstream>
25 
26 #include "TROOT.h"
27 #include "TSystem.h"
28 #include "TFile.h"
29 #include "TEventList.h"
30 #include "TEntryList.h"
31 #include "TBranchObject.h"
32 #include "TBranchElement.h"
33 #include "TStreamerInfo.h"
34 #include "TStreamerElement.h"
35 #include "TLeafObject.h"
36 #include "TLeafF.h"
37 #include "TLeafD.h"
38 #include "TLeafC.h"
39 #include "TLeafB.h"
40 #include "TLeafI.h"
41 #include "TLeafS.h"
42 #include "TMath.h"
43 #include "TH1.h"
44 #include "TPolyMarker.h"
45 #include "TPolyMarker3D.h"
46 #include "TText.h"
47 #include "TDirectory.h"
48 #include "TClonesArray.h"
49 #include "TClass.h"
50 #include "TVirtualPad.h"
51 #include "TProfile.h"
52 #include "TProfile2D.h"
53 #include "TTreeFormula.h"
54 #include "TTreeFormulaManager.h"
55 #include "TStyle.h"
56 #include "Foption.h"
57 #include "TTreeResult.h"
58 #include "TTreeRow.h"
59 #include "TPrincipal.h"
60 #include "TChain.h"
61 #include "TChainElement.h"
62 #include "TF1.h"
63 #include "TVirtualFitter.h"
64 #include "THLimitsFinder.h"
65 #include "TSelectorDraw.h"
66 #include "TSelectorEntries.h"
67 #include "TPluginManager.h"
68 #include "TObjString.h"
69 #include "TTreeProxyGenerator.h"
70 #include "TTreeReaderGenerator.h"
71 #include "TTreeIndex.h"
72 #include "TChainIndex.h"
73 #include "TRefProxy.h"
74 #include "TRefArrayProxy.h"
75 #include "TVirtualMonitoring.h"
76 #include "TTreeCache.h"
77 #include "TVirtualMutex.h"
78 #include "ThreadLocalStorage.h"
79 #include "strlcpy.h"
80 #include "snprintf.h"
81 
82 #include "HFitInterface.h"
83 #include "Fit/BinData.h"
84 #include "Fit/UnBinData.h"
85 #include "Math/MinimizerOptions.h"
86 
87 
89 
91 
93 
94 ////////////////////////////////////////////////////////////////////////////////
95 /// Default Tree constructor.
96 
98 {
99  fTree = 0;
100  fScanFileName = 0;
102  fSelectedRows = 0;
103  fDimension = 0;
104  fHistogram = 0;
105  fFormulaList = new TList();
107  fSelector = new TSelectorDraw();
108  fSelectorFromFile = 0;
109  fSelectorClass = 0;
110  fSelectorUpdate = 0;
111  fInput = new TList();
112  fInput->Add(new TNamed("varexp",""));
113  fInput->Add(new TNamed("selection",""));
115  {
117  gROOT->GetListOfCleanups()->Add(this);
118  }
121 }
122 
123 ////////////////////////////////////////////////////////////////////////////////
124 /// Tree destructor.
125 
127 {
128  delete fFormulaList;
129  delete fSelector;
131  fInput->Delete();
132  delete fInput;
134  gROOT->GetListOfCleanups()->Remove(this);
135 }
136 
137 ////////////////////////////////////////////////////////////////////////////////
138 /// Build the index for the tree (see TTree::BuildIndex)
139 
140 TVirtualIndex *TTreePlayer::BuildIndex(const TTree *T, const char *majorname, const char *minorname)
141 {
142  TVirtualIndex *index;
143  if (dynamic_cast<const TChain*>(T)) {
144  index = new TChainIndex(T, majorname, minorname);
145  if (index->IsZombie()) {
146  delete index;
147  Error("BuildIndex", "Creating a TChainIndex unsuccessful - switching to TTreeIndex");
148  }
149  else
150  return index;
151  }
152  return new TTreeIndex(T,majorname,minorname);
153 }
154 
155 ////////////////////////////////////////////////////////////////////////////////
156 /// Copy a Tree with selection, make a clone of this Tree header, then copy the
157 /// selected entries.
158 ///
159 /// - selection is a standard selection expression (see TTreePlayer::Draw)
160 /// - option is reserved for possible future use
161 /// - nentries is the number of entries to process (default is all)
162 /// - first is the first entry to process (default is 0)
163 ///
164 /// IMPORTANT: The copied tree stays connected with this tree until this tree
165 /// is deleted. In particular, any changes in branch addresses
166 /// in this tree are forwarded to the clone trees. Any changes
167 /// made to the branch addresses of the copied trees are over-ridden
168 /// anytime this tree changes its branch addresses.
169 /// Once this tree is deleted, all the addresses of the copied tree
170 /// are reset to their default values.
171 ///
172 /// The following example illustrates how to copy some events from the Tree
173 /// generated in $ROOTSYS/test/Event
174 /// ~~~{.cpp}
175 /// gSystem->Load("libEvent");
176 /// TFile f("Event.root");
177 /// TTree *T = (TTree*)f.Get("T");
178 /// Event *event = new Event();
179 /// T->SetBranchAddress("event",&event);
180 /// TFile f2("Event2.root","recreate");
181 /// TTree *T2 = T->CopyTree("fNtrack<595");
182 /// T2->Write();
183 /// ~~~
184 
186  Long64_t firstentry)
187 {
188 
189  // we make a copy of the tree header
190  TTree *tree = fTree->CloneTree(0);
191  if (tree == 0) return 0;
192 
193  // The clone should not delete any shared i/o buffers.
194  TObjArray* branches = tree->GetListOfBranches();
195  Int_t nb = branches->GetEntriesFast();
196  for (Int_t i = 0; i < nb; ++i) {
197  TBranch* br = (TBranch*) branches->UncheckedAt(i);
198  if (br->InheritsFrom(TBranchElement::Class())) {
199  ((TBranchElement*) br)->ResetDeleteObject();
200  }
201  }
202 
203  Long64_t entry,entryNumber;
204  nentries = GetEntriesToProcess(firstentry, nentries);
205 
206  // Compile selection expression if there is one
207  TTreeFormula *select = 0; // no need to interfere with fSelect since we
208  // handle the loop explicitly below and can call
209  // UpdateFormulaLeaves ourselves.
210  if (strlen(selection)) {
211  select = new TTreeFormula("Selection",selection,fTree);
212  if (!select || !select->GetNdim()) {
213  delete select;
214  delete tree;
215  return 0;
216  }
217  fFormulaList->Add(select);
218  }
219 
220  //loop on the specified entries
221  Int_t tnumber = -1;
222  for (entry=firstentry;entry<firstentry+nentries;entry++) {
223  entryNumber = fTree->GetEntryNumber(entry);
224  if (entryNumber < 0) break;
225  Long64_t localEntry = fTree->LoadTree(entryNumber);
226  if (localEntry < 0) break;
227  if (tnumber != fTree->GetTreeNumber()) {
228  tnumber = fTree->GetTreeNumber();
229  if (select) select->UpdateFormulaLeaves();
230  }
231  if (select) {
232  Int_t ndata = select->GetNdata();
233  Bool_t keep = kFALSE;
234  for(Int_t current = 0; current<ndata && !keep; current++) {
235  keep |= (select->EvalInstance(current) != 0);
236  }
237  if (!keep) continue;
238  }
239  fTree->GetEntry(entryNumber);
240  tree->Fill();
241  }
242  fFormulaList->Clear();
243  return tree;
244 }
245 
246 ////////////////////////////////////////////////////////////////////////////////
247 /// Delete any selector created by this object.
248 /// The selector has been created using TSelector::GetSelector(file)
249 
251 {
253  if (fSelectorClass->IsLoaded()) {
254  delete fSelectorFromFile;
255  }
256  }
257  fSelectorFromFile = 0;
258  fSelectorClass = 0;
259 }
260 
261 ////////////////////////////////////////////////////////////////////////////////
262 /// Draw the result of a C++ script.
263 ///
264 /// The macrofilename and optionally cutfilename are assumed to contain
265 /// at least a method with the same name as the file. The method
266 /// should return a value that can be automatically cast to
267 /// respectively a double and a boolean.
268 ///
269 /// Both methods will be executed in a context such that the
270 /// branch names can be used as C++ variables. This is
271 /// accomplished by generating a TTreeProxy (see MakeProxy)
272 /// and including the files in the proper location.
273 ///
274 /// If the branch name can not be used a proper C++ symbol name,
275 /// it will be modified as follow:
276 /// - white spaces are removed
277 /// - if the leading character is not a letter, an underscore is inserted
278 /// - < and > are replace by underscores
279 /// - * is replaced by st
280 /// - & is replaced by rf
281 ///
282 /// If a cutfilename is specified, for each entry, we execute
283 /// ~~~{.cpp}
284 /// if (cutfilename()) htemp->Fill(macrofilename());
285 /// ~~~
286 /// If no cutfilename is specified, for each entry we execute
287 /// ~~~{.cpp}
288 /// htemp(macrofilename());
289 /// ~~~
290 /// The default for the histogram are the same as for
291 /// TTreePlayer::DrawSelect
292 
293 Long64_t TTreePlayer::DrawScript(const char* wrapperPrefix,
294  const char *macrofilename, const char *cutfilename,
295  Option_t *option, Long64_t nentries, Long64_t firstentry)
296 {
297  if (!macrofilename || strlen(macrofilename)==0) return 0;
298 
299  TString aclicMode;
300  TString arguments;
301  TString io;
302  TString realcutname;
303  if (cutfilename && strlen(cutfilename))
304  realcutname = gSystem->SplitAclicMode(cutfilename, aclicMode, arguments, io);
305 
306  // we ignore the aclicMode for the cutfilename!
307  TString realname = gSystem->SplitAclicMode(macrofilename, aclicMode, arguments, io);
308 
309  TString selname = wrapperPrefix;
310 
311  ROOT::Internal::TTreeProxyGenerator gp(fTree,realname,realcutname,selname,option,3);
312 
313  selname = gp.GetFileName();
314  if (aclicMode.Length()==0) {
315  Warning("DrawScript","TTreeProxy does not work in interpreted mode yet. The script will be compiled.");
316  aclicMode = "+";
317  }
318  selname.Append(aclicMode);
319 
320  Info("DrawScript","%s",Form("Will process tree/chain using %s",selname.Data()));
321  Long64_t result = fTree->Process(selname,option,nentries,firstentry);
322  fTree->SetNotify(0);
323 
324  // could delete the file selname+".h"
325  // However this would remove the optimization of avoiding a useless
326  // recompilation if the user ask for the same thing twice!
327 
328  return result;
329 }
330 
331 ////////////////////////////////////////////////////////////////////////////////
332 /// Draw expression varexp for specified entries that matches the selection.
333 /// Returns -1 in case of error or number of selected events in case of success.
334 ///
335 /// See the documentation of TTree::Draw for the complete details.
336 
337 Long64_t TTreePlayer::DrawSelect(const char *varexp0, const char *selection, Option_t *option,Long64_t nentries, Long64_t firstentry)
338 {
339  if (fTree->GetEntriesFriend() == 0) return 0;
340 
341  // Let's see if we have a filename as arguments instead of
342  // a TTreeFormula expression.
343 
344  TString possibleFilename = varexp0;
345  Ssiz_t dot_pos = possibleFilename.Last('.');
346  if ( dot_pos != kNPOS
347  && possibleFilename.Index("Alt$")<0 && possibleFilename.Index("Entries$")<0
348  && possibleFilename.Index("LocalEntries$")<0
349  && possibleFilename.Index("Length$")<0 && possibleFilename.Index("Entry$")<0
350  && possibleFilename.Index("LocalEntry$")<0
351  && possibleFilename.Index("Min$")<0 && possibleFilename.Index("Max$")<0
352  && possibleFilename.Index("MinIf$")<0 && possibleFilename.Index("MaxIf$")<0
353  && possibleFilename.Index("Iteration$")<0 && possibleFilename.Index("Sum$")<0
354  && possibleFilename.Index(">")<0 && possibleFilename.Index("<")<0
355  && gSystem->IsFileInIncludePath(possibleFilename.Data())) {
356 
357  if (selection && strlen(selection) && !gSystem->IsFileInIncludePath(selection)) {
358  Error("DrawSelect",
359  "Drawing using a C++ file currently requires that both the expression and the selection are files\n\t\"%s\" is not a file",
360  selection);
361  return 0;
362  }
363  return DrawScript("generatedSel",varexp0,selection,option,nentries,firstentry);
364 
365  } else {
366  possibleFilename = selection;
367  if (possibleFilename.Index("Alt$")<0 && possibleFilename.Index("Entries$")<0
368  && possibleFilename.Index("LocalEntries$")<0
369  && possibleFilename.Index("Length$")<0 && possibleFilename.Index("Entry$")<0
370  && possibleFilename.Index("LocalEntry$")<0
371  && possibleFilename.Index("Min$")<0 && possibleFilename.Index("Max$")<0
372  && possibleFilename.Index("MinIf$")<0 && possibleFilename.Index("MaxIf$")<0
373  && possibleFilename.Index("Iteration$")<0 && possibleFilename.Index("Sum$")<0
374  && possibleFilename.Index(">")<0 && possibleFilename.Index("<")<0
375  && gSystem->IsFileInIncludePath(possibleFilename.Data())) {
376 
377  Error("DrawSelect",
378  "Drawing using a C++ file currently requires that both the expression and the selection are files\n\t\"%s\" is not a file",
379  varexp0);
380  return 0;
381  }
382  }
383 
384  Long64_t oldEstimate = fTree->GetEstimate();
385  TEventList *evlist = fTree->GetEventList();
386  TEntryList *elist = fTree->GetEntryList();
387  if (evlist && elist){
388  elist->SetBit(kCanDelete, kTRUE);
389  }
390  TNamed *cvarexp = (TNamed*)fInput->FindObject("varexp");
391  TNamed *cselection = (TNamed*)fInput->FindObject("selection");
392  if (cvarexp) cvarexp->SetTitle(varexp0);
393  if (cselection) cselection->SetTitle(selection);
394 
395  TString opt = option;
396  opt.ToLower();
397  Bool_t optpara = kFALSE;
398  Bool_t optcandle = kFALSE;
399  Bool_t optgl5d = kFALSE;
400  Bool_t optnorm = kFALSE;
401  if (opt.Contains("norm")) {optnorm = kTRUE; opt.ReplaceAll("norm",""); opt.ReplaceAll(" ","");}
402  if (opt.Contains("para")) optpara = kTRUE;
403  if (opt.Contains("candle")) optcandle = kTRUE;
404  if (opt.Contains("gl5d")) optgl5d = kTRUE;
406  if (optgl5d) {
408  if (!gPad) {
409  if (pgl == kFALSE) gStyle->SetCanvasPreferGL(kTRUE);
410  gROOT->ProcessLineFast("new TCanvas();");
411  }
412  }
413 
414  // Do not process more than fMaxEntryLoop entries
416 
417  // invoke the selector
418  Long64_t nrows = Process(fSelector,option,nentries,firstentry);
419  fSelectedRows = nrows;
421 
422  //*-* an Event List
423  if (fDimension <= 0) {
424  fTree->SetEstimate(oldEstimate);
425  if (fSelector->GetCleanElist()) {
426  // We are in the case where the input list was reset!
427  fTree->SetEntryList(elist);
428  delete fSelector->GetObject();
429  }
430  return nrows;
431  }
432 
433  // Draw generated histogram
434  Long64_t drawflag = fSelector->GetDrawFlag();
435  Int_t action = fSelector->GetAction();
436  Bool_t draw = kFALSE;
437  if (!drawflag && !opt.Contains("goff")) draw = kTRUE;
438  if (!optcandle && !optpara) fHistogram = (TH1*)fSelector->GetObject();
439  if (optnorm) {
441  if (sumh != 0) fHistogram->Scale(1./sumh);
442  }
443 
444  if (drawflag) {
445  if (gPad) {
446  if (!opt.Contains("same") && !opt.Contains("goff")) {
447  gPad->DrawFrame(-1.,-1.,1.,1.);
448  TText *text_empty = new TText(0.,0.,"Empty");
449  text_empty->SetTextAlign(22);
450  text_empty->SetTextFont(42);
451  text_empty->SetTextSize(0.1);
452  text_empty->SetTextColor(1);
453  text_empty->Draw();
454  }
455  } else {
456  Warning("DrawSelect", "The selected TTree subset is empty.");
457  }
458  }
459 
460  //*-*- 1-D distribution
461  if (fDimension == 1 && !(optpara||optcandle)) {
463  if (draw) fHistogram->Draw(opt.Data());
464 
465  //*-*- 2-D distribution
466  } else if (fDimension == 2 && !(optpara||optcandle)) {
469  if (action == 4) {
470  if (draw) fHistogram->Draw(opt.Data());
471  } else {
472  Bool_t graph = kFALSE;
473  Int_t l = opt.Length();
474  if (l == 0 || opt == "same") graph = kTRUE;
475  if (opt.Contains("p") || opt.Contains("*") || opt.Contains("l")) graph = kTRUE;
476  if (opt.Contains("surf") || opt.Contains("lego") || opt.Contains("cont")) graph = kFALSE;
477  if (opt.Contains("col") || opt.Contains("hist") || opt.Contains("scat")) graph = kFALSE;
478  if (!graph) {
479  if (draw) fHistogram->Draw(opt.Data());
480  } else {
481  if (fSelector->GetOldHistogram() && draw) fHistogram->Draw(opt.Data());
482  }
483  }
484  //*-*- 3-D distribution
485  } else if (fDimension == 3 && !(optpara||optcandle)) {
489  if (action == 23) {
490  if (draw) fHistogram->Draw(opt.Data());
491  } else if (action == 33) {
492  if (draw) {
493  if (opt.Contains("z")) fHistogram->Draw("func z");
494  else fHistogram->Draw("func");
495  }
496  } else {
497  Int_t noscat = opt.Length();
498  if (opt.Contains("same")) noscat -= 4;
499  if (noscat) {
500  if (draw) fHistogram->Draw(opt.Data());
501  } else {
502  if (fSelector->GetOldHistogram() && draw) fHistogram->Draw(opt.Data());
503  }
504  }
505  //*-*- 4-D distribution
506  } else if (fDimension == 4 && !(optpara||optcandle)) {
510  if (draw) fHistogram->Draw(opt.Data());
511  Int_t ncolors = gStyle->GetNumberOfColors();
512  TObjArray *pms = (TObjArray*)fHistogram->GetListOfFunctions()->FindObject("polymarkers");
513  for (Int_t col=0;col<ncolors;col++) {
514  if (!pms) continue;
515  TPolyMarker3D *pm3d = (TPolyMarker3D*)pms->UncheckedAt(col);
516  if (draw) pm3d->Draw();
517  }
518  //*-*- Parallel Coordinates or Candle chart.
519  } else if (fDimension > 1 && (optpara || optcandle)) {
520  if (draw) {
521  TObject* para = fSelector->GetObject();
522  fTree->Draw(">>enlist",selection,"entrylist",nentries,firstentry);
523  TObject *enlist = gDirectory->FindObject("enlist");
524  gROOT->ProcessLine(Form("TParallelCoord::SetEntryList((TParallelCoord*)0x%lx,(TEntryList*)0x%lx)",
525  (ULong_t)para, (ULong_t)enlist));
526  }
527  //*-*- 5d with gl
528  } else if (fDimension == 5 && optgl5d) {
529  gROOT->ProcessLineFast(Form("(new TGL5DDataSet((TTree *)0x%lx))->Draw(\"%s\");", (ULong_t)fTree, opt.Data()));
531  }
532 
534  return fSelectedRows;
535 }
536 
537 ////////////////////////////////////////////////////////////////////////////////
538 /// Fit a projected item(s) from a Tree.
539 /// Returns -1 in case of error or number of selected events in case of success.
540 ///
541 /// The formula is a TF1 expression.
542 ///
543 /// See TTree::Draw for explanations of the other parameters.
544 ///
545 /// By default the temporary histogram created is called htemp.
546 /// If varexp contains >>hnew , the new histogram created is called hnew
547 /// and it is kept in the current directory.
548 /// Example:
549 /// ~~~{.cpp}
550 /// tree.Fit("pol4","sqrt(x)>>hsqrt","y>0")
551 /// will fit sqrt(x) and save the histogram as "hsqrt" in the current
552 /// directory.
553 /// ~~~
554 ///
555 /// The function returns the status of the histogram fit (see TH1::Fit)
556 /// If no entries were selected, the function returns -1;
557 /// (i.e. fitResult is null if the fit is OK)
558 
559 Int_t TTreePlayer::Fit(const char *formula ,const char *varexp, const char *selection,Option_t *option ,Option_t *goption,Long64_t nentries, Long64_t firstentry)
560 {
561  Int_t nch = option ? strlen(option) + 10 : 10;
562  char *opt = new char[nch];
563  if (option) strlcpy(opt,option,nch-1);
564  else strlcpy(opt,"goff",5);
565 
566  Long64_t nsel = DrawSelect(varexp,selection,opt,nentries,firstentry);
567 
568  delete [] opt;
569  Int_t fitResult = -1;
570 
571  if (fHistogram && nsel > 0) {
572  fitResult = fHistogram->Fit(formula,option,goption);
573  }
574  return fitResult;
575 }
576 
577 ////////////////////////////////////////////////////////////////////////////////
578 /// Return the number of entries matching the selection.
579 /// Return -1 in case of errors.
580 ///
581 /// If the selection uses any arrays or containers, we return the number
582 /// of entries where at least one element match the selection.
583 /// GetEntries is implemented using the selector class TSelectorEntries,
584 /// which can be used directly (see code in TTreePlayer::GetEntries) for
585 /// additional option.
586 /// If SetEventList was used on the TTree or TChain, only that subset
587 /// of entries will be considered.
588 
589 Long64_t TTreePlayer::GetEntries(const char *selection)
590 {
591  TSelectorEntries s(selection);
592  fTree->Process(&s);
593  fTree->SetNotify(0);
594  return s.GetSelectedRows();
595 }
596 
597 ////////////////////////////////////////////////////////////////////////////////
598 /// return the number of entries to be processed
599 /// this function checks that nentries is not bigger than the number
600 /// of entries in the Tree or in the associated TEventlist
601 
603 {
604  Long64_t lastentry = firstentry + nentries - 1;
605  if (lastentry > fTree->GetEntriesFriend()-1) {
606  lastentry = fTree->GetEntriesFriend() - 1;
607  nentries = lastentry - firstentry + 1;
608  }
609  //TEventList *elist = fTree->GetEventList();
610  //if (elist && elist->GetN() < nentries) nentries = elist->GetN();
611  TEntryList *elist = fTree->GetEntryList();
612  if (elist && elist->GetN() < nentries) nentries = elist->GetN();
613  return nentries;
614 }
615 
616 ////////////////////////////////////////////////////////////////////////////////
617 /// Return name corresponding to colindex in varexp.
618 ///
619 /// - varexp is a string of names separated by :
620 /// - index is an array with pointers to the start of name[i] in varexp
621 
622 const char *TTreePlayer::GetNameByIndex(TString &varexp, Int_t *index,Int_t colindex)
623 {
624  TTHREAD_TLS_DECL(std::string,column);
625  if (colindex<0 ) return "";
626  Int_t i1,n;
627  i1 = index[colindex] + 1;
628  n = index[colindex+1] - i1;
629  column = varexp(i1,n).Data();
630  // return (const char*)Form((const char*)column);
631  return column.c_str();
632 }
633 
634 ////////////////////////////////////////////////////////////////////////////////
635 /// Return the name of the branch pointer needed by MakeClass/MakeSelector
636 
638 {
639  TLeaf *leafcount = leaf->GetLeafCount();
640  TBranch *branch = leaf->GetBranch();
641 
642  TString branchname( branch->GetName() );
643 
644  if ( branch->GetNleaves() <= 1 ) {
645  if (branch->IsA() != TBranchObject::Class()) {
646  if (!leafcount) {
647  TBranch *mother = branch->GetMother();
648  const char* ltitle = leaf->GetTitle();
649  if (mother && mother!=branch) {
650  branchname = mother->GetName();
651  if (branchname[branchname.Length()-1]!='.') {
652  branchname += ".";
653  }
654  if (strncmp(branchname.Data(),ltitle,branchname.Length())==0) {
655  branchname = "";
656  }
657  } else {
658  branchname = "";
659  }
660  branchname += ltitle;
661  }
662  }
663  }
664  if (replace) {
665  char *bname = (char*)branchname.Data();
666  char *twodim = (char*)strstr(bname,"[");
667  if (twodim) *twodim = 0;
668  while (*bname) {
669  if (*bname == '.') *bname='_';
670  if (*bname == ',') *bname='_';
671  if (*bname == ':') *bname='_';
672  if (*bname == '<') *bname='_';
673  if (*bname == '>') *bname='_';
674  bname++;
675  }
676  }
677  return branchname;
678 }
679 
680 ////////////////////////////////////////////////////////////////////////////////
681 /// Generate skeleton analysis class for this Tree.
682 ///
683 /// The following files are produced: classname.h and classname.C
684 /// If classname is 0, classname will be called "nameoftree.
685 ///
686 /// The generated code in classname.h includes the following:
687 /// - Identification of the original Tree and Input file name
688 /// - Definition of analysis class (data and functions)
689 /// - the following class functions:
690 /// - constructor (connecting by default the Tree file)
691 /// - GetEntry(Long64_t entry)
692 /// - Init(TTree *tree) to initialize a new TTree
693 /// - Show(Long64_t entry) to read and Dump entry
694 ///
695 /// The generated code in classname.C includes only the main
696 /// analysis function Loop.
697 ///
698 /// To use this function:
699 /// - connect your Tree file (eg: TFile f("myfile.root");)
700 /// - T->MakeClass("MyClass");
701 ///
702 /// where T is the name of the Tree in file myfile.root
703 /// and MyClass.h, MyClass.C the name of the files created by this function.
704 /// In a ROOT session, you can do:
705 /// ~~~{.cpp}
706 /// root> .L MyClass.C
707 /// root> MyClass t
708 /// root> t.GetEntry(12); // Fill t data members with entry number 12
709 /// root> t.Show(); // Show values of entry 12
710 /// root> t.Show(16); // Read and show values of entry 16
711 /// root> t.Loop(); // Loop on all entries
712 /// ~~~
713 /// NOTE: Do not use the code generated for one Tree in case of a TChain.
714 /// Maximum dimensions calculated on the basis of one TTree only
715 /// might be too small when processing all the TTrees in one TChain.
716 /// Instead of myTree.MakeClass(.., use myChain.MakeClass(..
717 
718 Int_t TTreePlayer::MakeClass(const char *classname, const char *option)
719 {
720  TString opt = option;
721  opt.ToLower();
722 
723  // Connect output files
724  if (!classname) classname = fTree->GetName();
725 
726  TString thead;
727  thead.Form("%s.h", classname);
728  FILE *fp = fopen(thead, "w");
729  if (!fp) {
730  Error("MakeClass","cannot open output file %s", thead.Data());
731  return 3;
732  }
733  TString tcimp;
734  tcimp.Form("%s.C", classname);
735  FILE *fpc = fopen(tcimp, "w");
736  if (!fpc) {
737  Error("MakeClass","cannot open output file %s", tcimp.Data());
738  fclose(fp);
739  return 3;
740  }
741  TString treefile;
742  if (fTree->GetDirectory() && fTree->GetDirectory()->GetFile()) {
743  treefile = fTree->GetDirectory()->GetFile()->GetName();
744  } else {
745  treefile = "Memory Directory";
746  }
747  // In the case of a chain, the GetDirectory information usually does
748  // pertain to the Chain itself but to the currently loaded tree.
749  // So we can not rely on it.
750  Bool_t ischain = fTree->InheritsFrom(TChain::Class());
751  Bool_t isHbook = fTree->InheritsFrom("THbookTree");
752  if (isHbook)
753  treefile = fTree->GetTitle();
754 
755 //======================Generate classname.h=====================
756  // Print header
757  TObjArray *leaves = fTree->GetListOfLeaves();
758  Int_t nleaves = leaves ? leaves->GetEntriesFast() : 0;
759  TDatime td;
760  fprintf(fp,"//////////////////////////////////////////////////////////\n");
761  fprintf(fp,"// This class has been automatically generated on\n");
762  fprintf(fp,"// %s by ROOT version %s\n",td.AsString(),gROOT->GetVersion());
763  if (!ischain) {
764  fprintf(fp,"// from TTree %s/%s\n",fTree->GetName(),fTree->GetTitle());
765  fprintf(fp,"// found on file: %s\n",treefile.Data());
766  } else {
767  fprintf(fp,"// from TChain %s/%s\n",fTree->GetName(),fTree->GetTitle());
768  }
769  fprintf(fp,"//////////////////////////////////////////////////////////\n");
770  fprintf(fp,"\n");
771  fprintf(fp,"#ifndef %s_h\n",classname);
772  fprintf(fp,"#define %s_h\n",classname);
773  fprintf(fp,"\n");
774  fprintf(fp,"#include <TROOT.h>\n");
775  fprintf(fp,"#include <TChain.h>\n");
776  fprintf(fp,"#include <TFile.h>\n");
777  if (isHbook) fprintf(fp,"#include <THbookFile.h>\n");
778  if (opt.Contains("selector")) fprintf(fp,"#include <TSelector.h>\n");
779 
780  // See if we can add any #include about the user data.
781  Int_t l;
782  fprintf(fp,"\n// Header file for the classes stored in the TTree if any.\n");
783  TList listOfHeaders;
784  listOfHeaders.SetOwner();
785  for (l=0;l<nleaves;l++) {
786  TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
787  TBranch *branch = leaf->GetBranch();
788  TClass *cl = TClass::GetClass(branch->GetClassName());
789  if (cl && cl->IsLoaded() && !listOfHeaders.FindObject(cl->GetName())) {
790  const char *declfile = cl->GetDeclFileName();
791  if (declfile && declfile[0]) {
792  static const char *precstl = "prec_stl/";
793  static const unsigned int precstl_len = strlen(precstl);
794  static const char *rootinclude = "include/";
795  static const unsigned int rootinclude_len = strlen(rootinclude);
796  if (strncmp(declfile,precstl,precstl_len) == 0) {
797  fprintf(fp,"#include <%s>\n",declfile+precstl_len);
798  listOfHeaders.Add(new TNamed(cl->GetName(),declfile+precstl_len));
799  } else if (strncmp(declfile,"/usr/include/",13) == 0) {
800  fprintf(fp,"#include <%s>\n",declfile+strlen("/include/c++/"));
801  listOfHeaders.Add(new TNamed(cl->GetName(),declfile+strlen("/include/c++/")));
802  } else if (strstr(declfile,"/include/c++/") != 0) {
803  fprintf(fp,"#include <%s>\n",declfile+strlen("/include/c++/"));
804  listOfHeaders.Add(new TNamed(cl->GetName(),declfile+strlen("/include/c++/")));
805  } else if (strncmp(declfile,rootinclude,rootinclude_len) == 0) {
806  fprintf(fp,"#include <%s>\n",declfile+rootinclude_len);
807  listOfHeaders.Add(new TNamed(cl->GetName(),declfile+rootinclude_len));
808  } else {
809  fprintf(fp,"#include \"%s\"\n",declfile);
810  listOfHeaders.Add(new TNamed(cl->GetName(),declfile));
811  }
812  }
813  }
814  }
815 
816  // First loop on all leaves to generate dimension declarations
817  Int_t len, lenb;
818  char blen[1024];
819  char *bname;
820  Int_t *leaflen = new Int_t[nleaves];
821  TObjArray *leafs = new TObjArray(nleaves);
822  for (l=0;l<nleaves;l++) {
823  TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
824  leafs->AddAt(new TObjString(leaf->GetName()),l);
825  leaflen[l] = leaf->GetMaximum();
826  }
827  if (ischain) {
828  // In case of a chain, one must find the maximum dimension of each leaf
829  // One must be careful and not assume that all Trees in the chain
830  // have the same leaves and in the same order!
831  TChain *chain = (TChain*)fTree;
832  Int_t ntrees = chain->GetNtrees();
833  for (Int_t file=0;file<ntrees;file++) {
834  Long64_t first = chain->GetTreeOffset()[file];
835  chain->LoadTree(first);
836  for (l=0;l<nleaves;l++) {
837  TObjString *obj = (TObjString*)leafs->At(l);
838  TLeaf *leaf = chain->GetLeaf(obj->GetName());
839  if (leaf) {
840  leaflen[l] = TMath::Max(leaflen[l],leaf->GetMaximum());
841  }
842  }
843  }
844  chain->LoadTree(0);
845  }
846 
847  fprintf(fp,"\n");
848  if (opt.Contains("selector")) {
849  fprintf(fp,"class %s : public TSelector {\n",classname);
850  fprintf(fp,"public :\n");
851  fprintf(fp," TTree *fChain; //!pointer to the analyzed TTree or TChain\n");
852  } else {
853  fprintf(fp,"class %s {\n",classname);
854  fprintf(fp,"public :\n");
855  fprintf(fp," TTree *fChain; //!pointer to the analyzed TTree or TChain\n");
856  fprintf(fp," Int_t fCurrent; //!current Tree number in a TChain\n");
857  }
858 
859  fprintf(fp,"\n// Fixed size dimensions of array or collections stored in the TTree if any.\n");
860  leaves = fTree->GetListOfLeaves();
861  for (l=0;l<nleaves;l++) {
862  TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
863  strlcpy(blen,leaf->GetName(),sizeof(blen));
864  bname = &blen[0];
865  while (*bname) {
866  if (*bname == '.') *bname='_';
867  if (*bname == ',') *bname='_';
868  if (*bname == ':') *bname='_';
869  if (*bname == '<') *bname='_';
870  if (*bname == '>') *bname='_';
871  bname++;
872  }
873  lenb = strlen(blen);
874  if (blen[lenb-1] == '_') {
875  blen[lenb-1] = 0;
876  len = leaflen[l];
877  if (len <= 0) len = 1;
878  fprintf(fp," static constexpr Int_t kMax%s = %d;\n",blen,len);
879  }
880  }
881  delete [] leaflen;
882  leafs->Delete();
883  delete leafs;
884 
885 // second loop on all leaves to generate type declarations
886  fprintf(fp,"\n // Declaration of leaf types\n");
887  TLeaf *leafcount;
888  TLeafObject *leafobj;
889  TBranchElement *bre=0;
890  const char *headOK = " ";
891  const char *headcom = " //";
892  const char *head;
893  char branchname[1024];
894  char aprefix[1024];
895  TObjArray branches(100);
896  TObjArray mustInit(100);
897  TObjArray mustInitArr(100);
898  mustInitArr.SetOwner(kFALSE);
899  Int_t *leafStatus = new Int_t[nleaves];
900  for (l=0;l<nleaves;l++) {
901  Int_t kmax = 0;
902  head = headOK;
903  leafStatus[l] = 0;
904  TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
905  len = leaf->GetLen(); if (len<=0) len = 1;
906  leafcount =leaf->GetLeafCount();
907  TBranch *branch = leaf->GetBranch();
908  branchname[0] = 0;
909  strlcpy(branchname,branch->GetName(),sizeof(branchname));
910  strlcpy(aprefix,branch->GetName(),sizeof(aprefix));
911  if (!branches.FindObject(branch)) branches.Add(branch);
912  else leafStatus[l] = 1;
913  if ( branch->GetNleaves() > 1) {
914  // More than one leaf for the branch we need to distinguish them
915  strlcat(branchname,".",sizeof(branchname));
916  strlcat(branchname,leaf->GetTitle(),sizeof(branchname));
917  if (leafcount) {
918  // remove any dimension in title
919  char *dim = (char*)strstr(branchname,"["); if (dim) dim[0] = 0;
920  }
921  } else {
922  strlcpy(branchname,branch->GetName(),sizeof(branchname));
923  }
924  char *twodim = (char*)strstr(leaf->GetTitle(),"][");
925  bname = branchname;
926  while (*bname) {
927  if (*bname == '.') *bname='_';
928  if (*bname == ',') *bname='_';
929  if (*bname == ':') *bname='_';
930  if (*bname == '<') *bname='_';
931  if (*bname == '>') *bname='_';
932  bname++;
933  }
934  if (branch->IsA() == TBranchObject::Class()) {
935  if (branch->GetListOfBranches()->GetEntriesFast()) {leafStatus[l] = 1; continue;}
936  leafobj = (TLeafObject*)leaf;
937  if (!leafobj->GetClass()) {leafStatus[l] = 1; head = headcom;}
938  fprintf(fp,"%s%-15s *%s;\n",head,leafobj->GetTypeName(), leafobj->GetName());
939  if (leafStatus[l] == 0) mustInit.Add(leafobj);
940  continue;
941  }
942  if (leafcount) {
943  len = leafcount->GetMaximum();
944  if (len<=0) len = 1;
945  strlcpy(blen,leafcount->GetName(),sizeof(blen));
946  bname = &blen[0];
947  while (*bname) {
948  if (*bname == '.') *bname='_';
949  if (*bname == ',') *bname='_';
950  if (*bname == ':') *bname='_';
951  if (*bname == '<') *bname='_';
952  if (*bname == '>') *bname='_';
953  bname++;
954  }
955  lenb = strlen(blen);
956  if (blen[lenb-1] == '_') {blen[lenb-1] = 0; kmax = 1;}
957  else snprintf(blen,sizeof(blen),"%d",len);
958  }
959  if (branch->IsA() == TBranchElement::Class()) {
960  bre = (TBranchElement*)branch;
961  if (bre->GetType() != 3 && bre->GetType() != 4
962  && bre->GetStreamerType() <= 0 && bre->GetListOfBranches()->GetEntriesFast()) {
963  leafStatus[l] = 0;
964  }
965  if (bre->GetType() == 3 || bre->GetType() == 4) {
966  fprintf(fp," %-15s %s_;\n","Int_t", branchname);
967  continue;
968  }
969  if (bre->IsBranchFolder()) {
970  fprintf(fp," %-15s *%s;\n",bre->GetClassName(), branchname);
971  mustInit.Add(bre);
972  continue;
973  } else {
974  if (branch->GetListOfBranches()->GetEntriesFast()) {leafStatus[l] = 1;}
975  }
976  if (bre->GetStreamerType() < 0) {
977  if (branch->GetListOfBranches()->GetEntriesFast()) {
978  fprintf(fp,"%s%-15s *%s;\n",headcom,bre->GetClassName(), branchname);
979  } else {
980  fprintf(fp,"%s%-15s *%s;\n",head,bre->GetClassName(), branchname);
981  mustInit.Add(bre);
982  }
983  continue;
984  }
985  if (bre->GetStreamerType() == 0) {
986  if (!TClass::GetClass(bre->GetClassName())->HasInterpreterInfo()) {leafStatus[l] = 1; head = headcom;}
987  fprintf(fp,"%s%-15s *%s;\n",head,bre->GetClassName(), branchname);
988  if (leafStatus[l] == 0) mustInit.Add(bre);
989  continue;
990  }
991  if (bre->GetStreamerType() > 60) {
992  TClass *cle = TClass::GetClass(bre->GetClassName());
993  if (!cle) {leafStatus[l] = 1; continue;}
994  if (bre->GetStreamerType() == 66) leafStatus[l] = 0;
995  char brename[256];
996  strlcpy(brename,bre->GetName(),255);
997  char *bren = brename;
998  char *adot = strrchr(bren,'.');
999  if (adot) bren = adot+1;
1000  char *brack = strchr(bren,'[');
1001  if (brack) *brack = 0;
1003  if (elem) {
1004  if (elem->IsA() == TStreamerBase::Class()) {leafStatus[l] = 1; continue;}
1005  if (!TClass::GetClass(elem->GetTypeName())) {leafStatus[l] = 1; continue;}
1006  if (!TClass::GetClass(elem->GetTypeName())->HasInterpreterInfo()) {leafStatus[l] = 1; head = headcom;}
1007  if (leafcount) fprintf(fp,"%s%-15s %s[kMax%s];\n",head,elem->GetTypeName(), branchname,blen);
1008  else fprintf(fp,"%s%-15s %s;\n",head,elem->GetTypeName(), branchname);
1009  } else {
1010  if (!TClass::GetClass(bre->GetClassName())->HasInterpreterInfo()) {leafStatus[l] = 1; head = headcom;}
1011  fprintf(fp,"%s%-15s %s;\n",head,bre->GetClassName(), branchname);
1012  }
1013  continue;
1014  }
1015  }
1016  if (strlen(leaf->GetTypeName()) == 0) {leafStatus[l] = 1; continue;}
1017  if (leafcount) {
1018  //len = leafcount->GetMaximum();
1019  //strlcpy(blen,leafcount->GetName(),sizeof(blen));
1020  //bname = &blen[0];
1021  //while (*bname) {if (*bname == '.') *bname='_'; bname++;}
1022  //lenb = strlen(blen);
1023  //Int_t kmax = 0;
1024  //if (blen[lenb-1] == '_') {blen[lenb-1] = 0; kmax = 1;}
1025  //else sprintf(blen,"%d",len);
1026 
1027  const char *stars = " ";
1028  if (bre && bre->GetBranchCount2()) {
1029  stars = "*";
1030  }
1031  // Dimensions can be in the branchname for a split Object with a fix length C array.
1032  // Theses dimensions HAVE TO be placed after the dimension explicited by leafcount
1033  TString dimensions;
1034  char *dimInName = (char*) strstr(branchname,"[");
1035  if ( twodim || dimInName ) {
1036  if (dimInName) {
1037  dimensions = dimInName;
1038  dimInName[0] = 0; // terminate branchname before the array dimensions.
1039  }
1040  if (twodim) dimensions += (char*)(twodim+1);
1041  }
1042  const char* leafcountName = leafcount->GetName();
1043  char b2len[1024];
1044  if (bre && bre->GetBranchCount2()) {
1045  TLeaf * l2 = (TLeaf*)bre->GetBranchCount2()->GetListOfLeaves()->At(0);
1046  strlcpy(b2len,l2->GetName(),sizeof(b2len));
1047  bname = &b2len[0];
1048  while (*bname) {
1049  if (*bname == '.') *bname='_';
1050  if (*bname == ',') *bname='_';
1051  if (*bname == ':') *bname='_';
1052  if (*bname == '<') *bname='_';
1053  if (*bname == '>') *bname='_';
1054  bname++;
1055  }
1056  leafcountName = b2len;
1057  }
1058  if (dimensions.Length()) {
1059  if (kmax) fprintf(fp," %-14s %s%s[kMax%s]%s; //[%s]\n",leaf->GetTypeName(), stars,
1060  branchname,blen,dimensions.Data(),leafcountName);
1061  else fprintf(fp," %-14s %s%s[%d]%s; //[%s]\n",leaf->GetTypeName(), stars,
1062  branchname,len,dimensions.Data(),leafcountName);
1063  } else {
1064  if (kmax) fprintf(fp," %-14s %s%s[kMax%s]; //[%s]\n",leaf->GetTypeName(), stars, branchname,blen,leafcountName);
1065  else fprintf(fp," %-14s %s%s[%d]; //[%s]\n",leaf->GetTypeName(), stars, branchname,len,leafcountName);
1066  }
1067  if (stars[0]=='*') {
1068  TNamed *n;
1069  if (kmax) n = new TNamed(branchname, Form("kMax%s",blen));
1070  else n = new TNamed(branchname, Form("%d",len));
1071  mustInitArr.Add(n);
1072  }
1073  } else {
1074  if (strstr(branchname,"[")) len = 1;
1075  if (len < 2) fprintf(fp," %-15s %s;\n",leaf->GetTypeName(), branchname);
1076  else {
1077  if (twodim) fprintf(fp," %-15s %s%s;\n",leaf->GetTypeName(), branchname,(char*)strstr(leaf->GetTitle(),"["));
1078  else fprintf(fp," %-15s %s[%d];\n",leaf->GetTypeName(), branchname,len);
1079  }
1080  }
1081  }
1082 
1083 // generate list of branches
1084  fprintf(fp,"\n");
1085  fprintf(fp," // List of branches\n");
1086  for (l=0;l<nleaves;l++) {
1087  if (leafStatus[l]) continue;
1088  TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
1089  fprintf(fp," TBranch *b_%s; //!\n",R__GetBranchPointerName(leaf).Data());
1090  }
1091 
1092 // generate class member functions prototypes
1093  if (opt.Contains("selector")) {
1094  fprintf(fp,"\n");
1095  fprintf(fp," %s(TTree * /*tree*/ =0) : fChain(0) { }\n",classname) ;
1096  fprintf(fp," virtual ~%s() { }\n",classname);
1097  fprintf(fp," virtual Int_t Version() const { return 2; }\n");
1098  fprintf(fp," virtual void Begin(TTree *tree);\n");
1099  fprintf(fp," virtual void SlaveBegin(TTree *tree);\n");
1100  fprintf(fp," virtual void Init(TTree *tree);\n");
1101  fprintf(fp," virtual Bool_t Notify();\n");
1102  fprintf(fp," virtual Bool_t Process(Long64_t entry);\n");
1103  fprintf(fp," virtual Int_t GetEntry(Long64_t entry, Int_t getall = 0) { return fChain ? fChain->GetTree()->GetEntry(entry, getall) : 0; }\n");
1104  fprintf(fp," virtual void SetOption(const char *option) { fOption = option; }\n");
1105  fprintf(fp," virtual void SetObject(TObject *obj) { fObject = obj; }\n");
1106  fprintf(fp," virtual void SetInputList(TList *input) { fInput = input; }\n");
1107  fprintf(fp," virtual TList *GetOutputList() const { return fOutput; }\n");
1108  fprintf(fp," virtual void SlaveTerminate();\n");
1109  fprintf(fp," virtual void Terminate();\n\n");
1110  fprintf(fp," ClassDef(%s,0);\n",classname);
1111  fprintf(fp,"};\n");
1112  fprintf(fp,"\n");
1113  fprintf(fp,"#endif\n");
1114  fprintf(fp,"\n");
1115  } else {
1116  fprintf(fp,"\n");
1117  fprintf(fp," %s(TTree *tree=0);\n",classname);
1118  fprintf(fp," virtual ~%s();\n",classname);
1119  fprintf(fp," virtual Int_t Cut(Long64_t entry);\n");
1120  fprintf(fp," virtual Int_t GetEntry(Long64_t entry);\n");
1121  fprintf(fp," virtual Long64_t LoadTree(Long64_t entry);\n");
1122  fprintf(fp," virtual void Init(TTree *tree);\n");
1123  fprintf(fp," virtual void Loop();\n");
1124  fprintf(fp," virtual Bool_t Notify();\n");
1125  fprintf(fp," virtual void Show(Long64_t entry = -1);\n");
1126  fprintf(fp,"};\n");
1127  fprintf(fp,"\n");
1128  fprintf(fp,"#endif\n");
1129  fprintf(fp,"\n");
1130  }
1131 // generate code for class constructor
1132  fprintf(fp,"#ifdef %s_cxx\n",classname);
1133  if (!opt.Contains("selector")) {
1134  fprintf(fp,"%s::%s(TTree *tree) : fChain(0) \n",classname,classname);
1135  fprintf(fp,"{\n");
1136  fprintf(fp,"// if parameter tree is not specified (or zero), connect the file\n");
1137  fprintf(fp,"// used to generate this class and read the Tree.\n");
1138  fprintf(fp," if (tree == 0) {\n");
1139  if (ischain) {
1140  fprintf(fp,"\n#ifdef SINGLE_TREE\n");
1141  fprintf(fp," // The following code should be used if you want this class to access\n");
1142  fprintf(fp," // a single tree instead of a chain\n");
1143  }
1144  if (isHbook) {
1145  fprintf(fp," THbookFile *f = (THbookFile*)gROOT->GetListOfBrowsables()->FindObject(\"%s\");\n",
1146  treefile.Data());
1147  fprintf(fp," if (!f) {\n");
1148  fprintf(fp," f = new THbookFile(\"%s\");\n",treefile.Data());
1149  fprintf(fp," }\n");
1150  Int_t hid;
1151  sscanf(fTree->GetName(),"h%d",&hid);
1152  fprintf(fp," tree = (TTree*)f->Get(%d);\n\n",hid);
1153  } else {
1154  fprintf(fp," TFile *f = (TFile*)gROOT->GetListOfFiles()->FindObject(\"%s\");\n",treefile.Data());
1155  fprintf(fp," if (!f || !f->IsOpen()) {\n");
1156  fprintf(fp," f = new TFile(\"%s\");\n",treefile.Data());
1157  fprintf(fp," }\n");
1158  if (fTree->GetDirectory() != fTree->GetCurrentFile()) {
1159  fprintf(fp," TDirectory * dir = (TDirectory*)f->Get(\"%s\");\n",fTree->GetDirectory()->GetPath());
1160  fprintf(fp," dir->GetObject(\"%s\",tree);\n\n",fTree->GetName());
1161  } else {
1162  fprintf(fp," f->GetObject(\"%s\",tree);\n\n",fTree->GetName());
1163  }
1164  }
1165  if (ischain) {
1166  fprintf(fp,"#else // SINGLE_TREE\n\n");
1167  fprintf(fp," // The following code should be used if you want this class to access a chain\n");
1168  fprintf(fp," // of trees.\n");
1169  fprintf(fp," TChain * chain = new TChain(\"%s\",\"%s\");\n",
1170  fTree->GetName(),fTree->GetTitle());
1171  {
1173  TIter next(((TChain*)fTree)->GetListOfFiles());
1174  TChainElement *element;
1175  while ((element = (TChainElement*)next())) {
1176  fprintf(fp," chain->Add(\"%s/%s\");\n",element->GetTitle(),element->GetName());
1177  }
1178  }
1179  fprintf(fp," tree = chain;\n");
1180  fprintf(fp,"#endif // SINGLE_TREE\n\n");
1181  }
1182  fprintf(fp," }\n");
1183  fprintf(fp," Init(tree);\n");
1184  fprintf(fp,"}\n");
1185  fprintf(fp,"\n");
1186  }
1187 
1188 // generate code for class destructor()
1189  if (!opt.Contains("selector")) {
1190  fprintf(fp,"%s::~%s()\n",classname,classname);
1191  fprintf(fp,"{\n");
1192  fprintf(fp," if (!fChain) return;\n");
1193  if (isHbook) {
1194  //fprintf(fp," delete fChain->GetCurrentFile();\n");
1195  } else {
1196  fprintf(fp," delete fChain->GetCurrentFile();\n");
1197  }
1198  fprintf(fp,"}\n");
1199  fprintf(fp,"\n");
1200  }
1201 // generate code for class member function GetEntry()
1202  if (!opt.Contains("selector")) {
1203  fprintf(fp,"Int_t %s::GetEntry(Long64_t entry)\n",classname);
1204  fprintf(fp,"{\n");
1205  fprintf(fp,"// Read contents of entry.\n");
1206 
1207  fprintf(fp," if (!fChain) return 0;\n");
1208  fprintf(fp," return fChain->GetEntry(entry);\n");
1209  fprintf(fp,"}\n");
1210  }
1211 // generate code for class member function LoadTree()
1212  if (!opt.Contains("selector")) {
1213  fprintf(fp,"Long64_t %s::LoadTree(Long64_t entry)\n",classname);
1214  fprintf(fp,"{\n");
1215  fprintf(fp,"// Set the environment to read one entry\n");
1216  fprintf(fp," if (!fChain) return -5;\n");
1217  fprintf(fp," Long64_t centry = fChain->LoadTree(entry);\n");
1218  fprintf(fp," if (centry < 0) return centry;\n");
1219  fprintf(fp," if (fChain->GetTreeNumber() != fCurrent) {\n");
1220  fprintf(fp," fCurrent = fChain->GetTreeNumber();\n");
1221  fprintf(fp," Notify();\n");
1222  fprintf(fp," }\n");
1223  fprintf(fp," return centry;\n");
1224  fprintf(fp,"}\n");
1225  fprintf(fp,"\n");
1226  }
1227 
1228 // generate code for class member function Init(), first pass = get branch pointer
1229  fprintf(fp,"void %s::Init(TTree *tree)\n",classname);
1230  fprintf(fp,"{\n");
1231  fprintf(fp," // The Init() function is called when the selector needs to initialize\n"
1232  " // a new tree or chain. Typically here the branch addresses and branch\n"
1233  " // pointers of the tree will be set.\n"
1234  " // It is normally not necessary to make changes to the generated\n"
1235  " // code, but the routine can be extended by the user if needed.\n"
1236  " // Init() will be called many times when running on PROOF\n"
1237  " // (once per file to be processed).\n\n");
1238  if (mustInit.Last()) {
1239  TIter next(&mustInit);
1240  TObject *obj;
1241  fprintf(fp," // Set object pointer\n");
1242  while( (obj = next()) ) {
1243  if (obj->InheritsFrom(TBranch::Class())) {
1244  strlcpy(branchname,((TBranch*)obj)->GetName(),sizeof(branchname));
1245  } else if (obj->InheritsFrom(TLeaf::Class())) {
1246  strlcpy(branchname,((TLeaf*)obj)->GetName(),sizeof(branchname));
1247  }
1248  branchname[1023]=0;
1249  bname = branchname;
1250  while (*bname) {
1251  if (*bname == '.') *bname='_';
1252  if (*bname == ',') *bname='_';
1253  if (*bname == ':') *bname='_';
1254  if (*bname == '<') *bname='_';
1255  if (*bname == '>') *bname='_';
1256  bname++;
1257  }
1258  fprintf(fp," %s = 0;\n",branchname );
1259  }
1260  }
1261  if (mustInitArr.Last()) {
1262  TIter next(&mustInitArr);
1263  TNamed *info;
1264  fprintf(fp," // Set array pointer\n");
1265  while( (info = (TNamed*)next()) ) {
1266  fprintf(fp," for(int i=0; i<%s; ++i) %s[i] = 0;\n",info->GetTitle(),info->GetName());
1267  }
1268  fprintf(fp,"\n");
1269  }
1270  fprintf(fp," // Set branch addresses and branch pointers\n");
1271  fprintf(fp," if (!tree) return;\n");
1272  fprintf(fp," fChain = tree;\n");
1273  if (!opt.Contains("selector")) fprintf(fp," fCurrent = -1;\n");
1274  fprintf(fp," fChain->SetMakeClass(1);\n");
1275  fprintf(fp,"\n");
1276  for (l=0;l<nleaves;l++) {
1277  if (leafStatus[l]) continue;
1278  TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
1279  len = leaf->GetLen();
1280  leafcount =leaf->GetLeafCount();
1281  TBranch *branch = leaf->GetBranch();
1282  strlcpy(aprefix,branch->GetName(),sizeof(aprefix));
1283 
1284  if ( branch->GetNleaves() > 1) {
1285  // More than one leaf for the branch we need to distinguish them
1286  strlcpy(branchname,branch->GetName(),sizeof(branchname));
1287  strlcat(branchname,".",sizeof(branchname));
1288  strlcat(branchname,leaf->GetTitle(),sizeof(branchname));
1289  if (leafcount) {
1290  // remove any dimension in title
1291  char *dim = (char*)strstr(branchname,"["); if (dim) dim[0] = 0;
1292  }
1293  } else {
1294  strlcpy(branchname,branch->GetName(),sizeof(branchname));
1295  if (branch->IsA() == TBranchElement::Class()) {
1296  bre = (TBranchElement*)branch;
1297  if (bre->GetType() == 3 || bre->GetType()==4) strlcat(branchname,"_",sizeof(branchname));
1298  }
1299  }
1300  bname = branchname;
1301  char *brak = strstr(branchname,"["); if (brak) *brak = 0;
1302  char *twodim = (char*)strstr(bname,"["); if (twodim) *twodim = 0;
1303  while (*bname) {
1304  if (*bname == '.') *bname='_';
1305  if (*bname == ',') *bname='_';
1306  if (*bname == ':') *bname='_';
1307  if (*bname == '<') *bname='_';
1308  if (*bname == '>') *bname='_';
1309  bname++;
1310  }
1311  const char *maybedisable = "";
1312  if (branch != fTree->GetBranch(branch->GetName())) {
1313  Error("MakeClass","The branch named %s (full path name: %s) is hidden by another branch of the same name and its data will not be loaded.",branch->GetName(),R__GetBranchPointerName(leaf,kFALSE).Data());
1314  maybedisable = "// ";
1315  }
1316  if (branch->IsA() == TBranchObject::Class()) {
1317  if (branch->GetListOfBranches()->GetEntriesFast()) {
1318  fprintf(fp,"%s fChain->SetBranchAddress(\"%s\",(void*)-1,&b_%s);\n",maybedisable,branch->GetName(),R__GetBranchPointerName(leaf).Data());
1319  continue;
1320  }
1321  strlcpy(branchname,branch->GetName(),sizeof(branchname));
1322  }
1323  if (branch->IsA() == TBranchElement::Class()) {
1324  if (((TBranchElement*)branch)->GetType() == 3) len =1;
1325  if (((TBranchElement*)branch)->GetType() == 4) len =1;
1326  }
1327  if (leafcount) len = leafcount->GetMaximum()+1;
1328  if (len > 1) fprintf(fp,"%s fChain->SetBranchAddress(\"%s\", %s, &b_%s);\n",
1329  maybedisable,branch->GetName(), branchname, R__GetBranchPointerName(leaf).Data());
1330  else fprintf(fp,"%s fChain->SetBranchAddress(\"%s\", &%s, &b_%s);\n",
1331  maybedisable,branch->GetName(), branchname, R__GetBranchPointerName(leaf).Data());
1332  }
1333  //must call Notify in case of MakeClass
1334  if (!opt.Contains("selector")) {
1335  fprintf(fp," Notify();\n");
1336  }
1337 
1338  fprintf(fp,"}\n");
1339  fprintf(fp,"\n");
1340 
1341 // generate code for class member function Notify()
1342  fprintf(fp,"Bool_t %s::Notify()\n",classname);
1343  fprintf(fp,"{\n");
1344  fprintf(fp," // The Notify() function is called when a new file is opened. This\n"
1345  " // can be either for a new TTree in a TChain or when when a new TTree\n"
1346  " // is started when using PROOF. It is normally not necessary to make changes\n"
1347  " // to the generated code, but the routine can be extended by the\n"
1348  " // user if needed. The return value is currently not used.\n\n");
1349  fprintf(fp," return kTRUE;\n");
1350  fprintf(fp,"}\n");
1351  fprintf(fp,"\n");
1352 
1353 // generate code for class member function Show()
1354  if (!opt.Contains("selector")) {
1355  fprintf(fp,"void %s::Show(Long64_t entry)\n",classname);
1356  fprintf(fp,"{\n");
1357  fprintf(fp,"// Print contents of entry.\n");
1358  fprintf(fp,"// If entry is not specified, print current entry\n");
1359 
1360  fprintf(fp," if (!fChain) return;\n");
1361  fprintf(fp," fChain->Show(entry);\n");
1362  fprintf(fp,"}\n");
1363  }
1364 // generate code for class member function Cut()
1365  if (!opt.Contains("selector")) {
1366  fprintf(fp,"Int_t %s::Cut(Long64_t entry)\n",classname);
1367  fprintf(fp,"{\n");
1368  fprintf(fp,"// This function may be called from Loop.\n");
1369  fprintf(fp,"// returns 1 if entry is accepted.\n");
1370  fprintf(fp,"// returns -1 otherwise.\n");
1371 
1372  fprintf(fp," return 1;\n");
1373  fprintf(fp,"}\n");
1374  }
1375  fprintf(fp,"#endif // #ifdef %s_cxx\n",classname);
1376 
1377 //======================Generate classname.C=====================
1378  if (!opt.Contains("selector")) {
1379  // generate code for class member function Loop()
1380  fprintf(fpc,"#define %s_cxx\n",classname);
1381  fprintf(fpc,"#include \"%s\"\n",thead.Data());
1382  fprintf(fpc,"#include <TH2.h>\n");
1383  fprintf(fpc,"#include <TStyle.h>\n");
1384  fprintf(fpc,"#include <TCanvas.h>\n");
1385  fprintf(fpc,"\n");
1386  fprintf(fpc,"void %s::Loop()\n",classname);
1387  fprintf(fpc,"{\n");
1388  fprintf(fpc,"// In a ROOT session, you can do:\n");
1389  fprintf(fpc,"// root> .L %s.C\n",classname);
1390  fprintf(fpc,"// root> %s t\n",classname);
1391  fprintf(fpc,"// root> t.GetEntry(12); // Fill t data members with entry number 12\n");
1392  fprintf(fpc,"// root> t.Show(); // Show values of entry 12\n");
1393  fprintf(fpc,"// root> t.Show(16); // Read and show values of entry 16\n");
1394  fprintf(fpc,"// root> t.Loop(); // Loop on all entries\n");
1395  fprintf(fpc,"//\n");
1396  fprintf(fpc,"\n// This is the loop skeleton where:\n");
1397  fprintf(fpc,"// jentry is the global entry number in the chain\n");
1398  fprintf(fpc,"// ientry is the entry number in the current Tree\n");
1399  fprintf(fpc,"// Note that the argument to GetEntry must be:\n");
1400  fprintf(fpc,"// jentry for TChain::GetEntry\n");
1401  fprintf(fpc,"// ientry for TTree::GetEntry and TBranch::GetEntry\n");
1402  fprintf(fpc,"//\n");
1403  fprintf(fpc,"// To read only selected branches, Insert statements like:\n");
1404  fprintf(fpc,"// METHOD1:\n");
1405  fprintf(fpc,"// fChain->SetBranchStatus(\"*\",0); // disable all branches\n");
1406  fprintf(fpc,"// fChain->SetBranchStatus(\"branchname\",1); // activate branchname\n");
1407  fprintf(fpc,"// METHOD2: replace line\n");
1408  fprintf(fpc,"// fChain->GetEntry(jentry); //read all branches\n");
1409  fprintf(fpc,"//by b_branchname->GetEntry(ientry); //read only this branch\n");
1410  fprintf(fpc," if (fChain == 0) return;\n");
1411  fprintf(fpc,"\n Long64_t nentries = fChain->GetEntriesFast();\n");
1412  fprintf(fpc,"\n Long64_t nbytes = 0, nb = 0;\n");
1413  fprintf(fpc," for (Long64_t jentry=0; jentry<nentries;jentry++) {\n");
1414  fprintf(fpc," Long64_t ientry = LoadTree(jentry);\n");
1415  fprintf(fpc," if (ientry < 0) break;\n");
1416  fprintf(fpc," nb = fChain->GetEntry(jentry); nbytes += nb;\n");
1417  fprintf(fpc," // if (Cut(ientry) < 0) continue;\n");
1418  fprintf(fpc," }\n");
1419  fprintf(fpc,"}\n");
1420  }
1421  if (opt.Contains("selector")) {
1422  // generate usage comments and list of includes
1423  fprintf(fpc,"#define %s_cxx\n",classname);
1424  fprintf(fpc,"// The class definition in %s.h has been generated automatically\n",classname);
1425  fprintf(fpc,"// by the ROOT utility TTree::MakeSelector(). This class is derived\n");
1426  fprintf(fpc,"// from the ROOT class TSelector. For more information on the TSelector\n"
1427  "// framework see $ROOTSYS/README/README.SELECTOR or the ROOT User Manual.\n\n");
1428  fprintf(fpc,"// The following methods are defined in this file:\n");
1429  fprintf(fpc,"// Begin(): called every time a loop on the tree starts,\n");
1430  fprintf(fpc,"// a convenient place to create your histograms.\n");
1431  fprintf(fpc,"// SlaveBegin(): called after Begin(), when on PROOF called only on the\n"
1432  "// slave servers.\n");
1433  fprintf(fpc,"// Process(): called for each event, in this function you decide what\n");
1434  fprintf(fpc,"// to read and fill your histograms.\n");
1435  fprintf(fpc,"// SlaveTerminate: called at the end of the loop on the tree, when on PROOF\n"
1436  "// called only on the slave servers.\n");
1437  fprintf(fpc,"// Terminate(): called at the end of the loop on the tree,\n");
1438  fprintf(fpc,"// a convenient place to draw/fit your histograms.\n");
1439  fprintf(fpc,"//\n");
1440  fprintf(fpc,"// To use this file, try the following session on your Tree T:\n");
1441  fprintf(fpc,"//\n");
1442  fprintf(fpc,"// root> T->Process(\"%s.C\")\n",classname);
1443  fprintf(fpc,"// root> T->Process(\"%s.C\",\"some options\")\n",classname);
1444  fprintf(fpc,"// root> T->Process(\"%s.C+\")\n",classname);
1445  fprintf(fpc,"//\n\n");
1446  fprintf(fpc,"#include \"%s\"\n",thead.Data());
1447  fprintf(fpc,"#include <TH2.h>\n");
1448  fprintf(fpc,"#include <TStyle.h>\n");
1449  fprintf(fpc,"\n");
1450  // generate code for class member function Begin
1451  fprintf(fpc,"\n");
1452  fprintf(fpc,"void %s::Begin(TTree * /*tree*/)\n",classname);
1453  fprintf(fpc,"{\n");
1454  fprintf(fpc," // The Begin() function is called at the start of the query.\n");
1455  fprintf(fpc," // When running with PROOF Begin() is only called on the client.\n");
1456  fprintf(fpc," // The tree argument is deprecated (on PROOF 0 is passed).\n");
1457  fprintf(fpc,"\n");
1458  fprintf(fpc," TString option = GetOption();\n");
1459  fprintf(fpc,"\n");
1460  fprintf(fpc,"}\n");
1461  // generate code for class member function SlaveBegin
1462  fprintf(fpc,"\n");
1463  fprintf(fpc,"void %s::SlaveBegin(TTree * /*tree*/)\n",classname);
1464  fprintf(fpc,"{\n");
1465  fprintf(fpc," // The SlaveBegin() function is called after the Begin() function.\n");
1466  fprintf(fpc," // When running with PROOF SlaveBegin() is called on each slave server.\n");
1467  fprintf(fpc," // The tree argument is deprecated (on PROOF 0 is passed).\n");
1468  fprintf(fpc,"\n");
1469  fprintf(fpc," TString option = GetOption();\n");
1470  fprintf(fpc,"\n");
1471  fprintf(fpc,"}\n");
1472  // generate code for class member function Process
1473  fprintf(fpc,"\n");
1474  fprintf(fpc,"Bool_t %s::Process(Long64_t entry)\n",classname);
1475  fprintf(fpc,"{\n");
1476  fprintf(fpc," // The Process() function is called for each entry in the tree (or possibly\n"
1477  " // keyed object in the case of PROOF) to be processed. The entry argument\n"
1478  " // specifies which entry in the currently loaded tree is to be processed.\n"
1479  " // It can be passed to either %s::GetEntry() or TBranch::GetEntry()\n"
1480  " // to read either all or the required parts of the data. When processing\n"
1481  " // keyed objects with PROOF, the object is already loaded and is available\n"
1482  " // via the fObject pointer.\n"
1483  " //\n"
1484  " // This function should contain the \"body\" of the analysis. It can contain\n"
1485  " // simple or elaborate selection criteria, run algorithms on the data\n"
1486  " // of the event and typically fill histograms.\n"
1487  " //\n"
1488  " // The processing can be stopped by calling Abort().\n"
1489  " //\n"
1490  " // Use fStatus to set the return value of TTree::Process().\n"
1491  " //\n"
1492  " // The return value is currently not used.\n\n", classname);
1493  fprintf(fpc,"\n");
1494  fprintf(fpc," return kTRUE;\n");
1495  fprintf(fpc,"}\n");
1496  // generate code for class member function SlaveTerminate
1497  fprintf(fpc,"\n");
1498  fprintf(fpc,"void %s::SlaveTerminate()\n",classname);
1499  fprintf(fpc,"{\n");
1500  fprintf(fpc," // The SlaveTerminate() function is called after all entries or objects\n"
1501  " // have been processed. When running with PROOF SlaveTerminate() is called\n"
1502  " // on each slave server.");
1503  fprintf(fpc,"\n");
1504  fprintf(fpc,"\n");
1505  fprintf(fpc,"}\n");
1506  // generate code for class member function Terminate
1507  fprintf(fpc,"\n");
1508  fprintf(fpc,"void %s::Terminate()\n",classname);
1509  fprintf(fpc,"{\n");
1510  fprintf(fpc," // The Terminate() function is the last function to be called during\n"
1511  " // a query. It always runs on the client, it can be used to present\n"
1512  " // the results graphically or save the results to file.");
1513  fprintf(fpc,"\n");
1514  fprintf(fpc,"\n");
1515  fprintf(fpc,"}\n");
1516  }
1517  Info("MakeClass","Files: %s and %s generated from TTree: %s",thead.Data(),tcimp.Data(),fTree->GetName());
1518  delete [] leafStatus;
1519  fclose(fp);
1520  fclose(fpc);
1521 
1522  return 0;
1523 }
1524 
1525 
1526 ////////////////////////////////////////////////////////////////////////////////
1527 /// Generate skeleton function for this Tree
1528 ///
1529 /// The function code is written on filename.
1530 /// If filename is 0, filename will be called nameoftree.C
1531 ///
1532 /// The generated code includes the following:
1533 /// - Identification of the original Tree and Input file name
1534 /// - Connection of the Tree file
1535 /// - Declaration of Tree variables
1536 /// - Setting of branches addresses
1537 /// - A skeleton for the entry loop
1538 ///
1539 /// To use this function:
1540 /// - connect your Tree file (eg: TFile f("myfile.root");)
1541 /// - T->MakeCode("anal.C");
1542 /// where T is the name of the Tree in file myfile.root
1543 /// and anal.C the name of the file created by this function.
1544 ///
1545 /// NOTE: Since the implementation of this function, a new and better
1546 /// function TTree::MakeClass() has been developed.
1547 
1548 Int_t TTreePlayer::MakeCode(const char *filename)
1549 {
1550 // Connect output file
1551  TString tfile;
1552  if (filename)
1553  tfile = filename;
1554  else
1555  tfile.Form("%s.C", fTree->GetName());
1556  FILE *fp = fopen(tfile, "w");
1557  if (!fp) {
1558  Error("MakeCode","cannot open output file %s", tfile.Data());
1559  return 3;
1560  }
1561  TString treefile;
1562  if (fTree->GetDirectory() && fTree->GetDirectory()->GetFile()) {
1563  treefile = fTree->GetDirectory()->GetFile()->GetName();
1564  } else {
1565  treefile = "Memory Directory";
1566  }
1567  // In the case of a chain, the GetDirectory information usually does
1568  // pertain to the Chain itself but to the currently loaded tree.
1569  // So we can not rely on it.
1570  Bool_t ischain = fTree->InheritsFrom(TChain::Class());
1571 
1572 // Print header
1573  TObjArray *leaves = fTree->GetListOfLeaves();
1574  Int_t nleaves = leaves ? leaves->GetEntriesFast() : 0;
1575  TDatime td;
1576  fprintf(fp,"{\n");
1577  fprintf(fp,"//////////////////////////////////////////////////////////\n");
1578  fprintf(fp,"// This file has been automatically generated \n");
1579  fprintf(fp,"// (%s by ROOT version%s)\n",td.AsString(),gROOT->GetVersion());
1580  if (!ischain) {
1581  fprintf(fp,"// from TTree %s/%s\n",fTree->GetName(),fTree->GetTitle());
1582  fprintf(fp,"// found on file: %s\n",treefile.Data());
1583  } else {
1584  fprintf(fp,"// from TChain %s/%s\n",fTree->GetName(),fTree->GetTitle());
1585  }
1586  fprintf(fp,"//////////////////////////////////////////////////////////\n");
1587  fprintf(fp,"\n");
1588  fprintf(fp,"\n");
1589 
1590 
1591 // Reset and file connect
1592  fprintf(fp,"//Reset ROOT and connect tree file\n");
1593  fprintf(fp," gROOT->Reset();\n");
1594  if (ischain) {
1595  fprintf(fp,"\n#ifdef SINGLE_TREE\n");
1596  fprintf(fp," // The following code should be used if you want this code to access\n");
1597  fprintf(fp," // a single tree instead of a chain\n");
1598  }
1599  fprintf(fp," TFile *f = (TFile*)gROOT->GetListOfFiles()->FindObject(\"%s\");\n",treefile.Data());
1600  fprintf(fp," if (!f) {\n");
1601  fprintf(fp," f = new TFile(\"%s\");\n",treefile.Data());
1602  fprintf(fp," }\n");
1603  if (fTree->GetDirectory() != fTree->GetCurrentFile()) {
1604  fprintf(fp," TDirectory * dir = (TDirectory*)f->Get(\"%s\");\n",fTree->GetDirectory()->GetPath());
1605  fprintf(fp," dir->GetObject(\"%s\",tree);\n\n",fTree->GetName());
1606  } else {
1607  fprintf(fp," f->GetObject(\"%s\",tree);\n\n",fTree->GetName());
1608  }
1609  if (ischain) {
1610  fprintf(fp,"#else // SINGLE_TREE\n\n");
1611  fprintf(fp," // The following code should be used if you want this code to access a chain\n");
1612  fprintf(fp," // of trees.\n");
1613  fprintf(fp," TChain *%s = new TChain(\"%s\",\"%s\");\n",
1615  {
1617  TIter next(((TChain*)fTree)->GetListOfFiles());
1618  TChainElement *element;
1619  while ((element = (TChainElement*)next())) {
1620  fprintf(fp," %s->Add(\"%s/%s\");\n",fTree->GetName(),element->GetTitle(),element->GetName());
1621  }
1622  }
1623  fprintf(fp,"#endif // SINGLE_TREE\n\n");
1624  }
1625 
1626 // First loop on all leaves to generate type declarations
1627  fprintf(fp,"//Declaration of leaves types\n");
1628  Int_t len, l;
1629  TLeaf *leafcount;
1630  TLeafObject *leafobj;
1631  char *bname;
1632  const char *headOK = " ";
1633  const char *headcom = " //";
1634  const char *head;
1635  char branchname[1024];
1636  for (l=0;l<nleaves;l++) {
1637  TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
1638  len = leaf->GetLen();
1639  leafcount =leaf->GetLeafCount();
1640  TBranch *branch = leaf->GetBranch();
1641  if (branch->GetListOfBranches()->GetEntriesFast() > 0) continue;
1642 
1643  if ( branch->GetNleaves() > 1) {
1644  // More than one leaf for the branch we need to distinguish them
1645  strlcpy(branchname,branch->GetName(),sizeof(branchname));
1646  strlcat(branchname,".",sizeof(branchname));
1647  strlcat(branchname,leaf->GetTitle(),sizeof(branchname));
1648  if (leafcount) {
1649  // remove any dimension in title
1650  char *dim = (char*)strstr(branchname,"[");
1651  if (dim) dim[0] = 0;
1652  }
1653  } else {
1654  if (leafcount) strlcpy(branchname,branch->GetName(),sizeof(branchname));
1655  else strlcpy(branchname,leaf->GetTitle(),sizeof(branchname));
1656  }
1657  char *twodim = (char*)strstr(leaf->GetTitle(),"][");
1658  bname = branchname;
1659  while (*bname) {
1660  if (*bname == '.') *bname='_';
1661  if (*bname == ',') *bname='_';
1662  if (*bname == ':') *bname='_';
1663  if (*bname == '<') *bname='_';
1664  if (*bname == '>') *bname='_';
1665  bname++;
1666  }
1667  if (branch->IsA() == TBranchObject::Class()) {
1668  leafobj = (TLeafObject*)leaf;
1669  if (leafobj->GetClass()) head = headOK;
1670  else head = headcom;
1671  fprintf(fp,"%s%-15s *%s = 0;\n",head,leafobj->GetTypeName(), leafobj->GetName());
1672  continue;
1673  }
1674  if (leafcount) {
1675  len = leafcount->GetMaximum();
1676  // Dimensions can be in the branchname for a split Object with a fix length C array.
1677  // Theses dimensions HAVE TO be placed after the dimension explicited by leafcount
1678  char *dimInName = (char*) strstr(branchname,"[");
1679  TString dimensions;
1680  if ( twodim || dimInName ) {
1681  if (dimInName) {
1682  dimensions = dimInName;
1683  dimInName[0] = 0; // terminate branchname before the array dimensions.
1684  }
1685  if (twodim) dimensions += (char*)(twodim+1);
1686  }
1687  if (dimensions.Length()) {
1688  fprintf(fp," %-15s %s[%d]%s;\n",leaf->GetTypeName(), branchname,len,dimensions.Data());
1689  } else {
1690  fprintf(fp," %-15s %s[%d];\n",leaf->GetTypeName(), branchname,len);
1691  }
1692  } else {
1693  if (strstr(branchname,"[")) len = 1;
1694  if (len < 2) fprintf(fp," %-15s %s;\n",leaf->GetTypeName(), branchname);
1695  else fprintf(fp," %-15s %s[%d];\n",leaf->GetTypeName(), branchname,len);
1696  }
1697  }
1698 
1699 // Second loop on all leaves to set the corresponding branch address
1700  fprintf(fp,"\n // Set branch addresses.\n");
1701  for (l=0;l<nleaves;l++) {
1702  TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
1703  len = leaf->GetLen();
1704  leafcount =leaf->GetLeafCount();
1705  TBranch *branch = leaf->GetBranch();
1706 
1707  if ( branch->GetNleaves() > 1) {
1708  // More than one leaf for the branch we need to distinguish them
1709  strlcpy(branchname,branch->GetName(),sizeof(branchname));
1710  strlcat(branchname,".",sizeof(branchname));
1711  strlcat(branchname,leaf->GetTitle(),sizeof(branchname));
1712  if (leafcount) {
1713  // remove any dimension in title
1714  char *dim = (char*)strstr(branchname,"[");
1715  if (dim) dim[0] = 0;
1716  }
1717  } else {
1718  if (leafcount) strlcpy(branchname,branch->GetName(),sizeof(branchname));
1719  else strlcpy(branchname,leaf->GetTitle(),sizeof(branchname));
1720  }
1721  bname = branchname;
1722  while (*bname) {
1723  if (*bname == '.') *bname='_';
1724  if (*bname == ',') *bname='_';
1725  if (*bname == ':') *bname='_';
1726  if (*bname == '<') *bname='_';
1727  if (*bname == '>') *bname='_';
1728  bname++;
1729  }
1730  char *brak = strstr(branchname,"[");
1731  if (brak) *brak = 0;
1732  head = headOK;
1733  if (branch->IsA() == TBranchObject::Class()) {
1734  strlcpy(branchname,branch->GetName(),sizeof(branchname));
1735  leafobj = (TLeafObject*)leaf;
1736  if (!leafobj->GetClass()) head = headcom;
1737  }
1738  if (leafcount) len = leafcount->GetMaximum()+1;
1739  if (len > 1 || brak) fprintf(fp,"%s%s->SetBranchAddress(\"%s\",%s);\n",head,fTree->GetName(),branch->GetName(),branchname);
1740  else fprintf(fp,"%s%s->SetBranchAddress(\"%s\",&%s);\n",head,fTree->GetName(),branch->GetName(),branchname);
1741  }
1742 
1743 //Generate instructions to make the loop on entries
1744  fprintf(fp,"\n// This is the loop skeleton\n");
1745  fprintf(fp,"// To read only selected branches, Insert statements like:\n");
1746  fprintf(fp,"// %s->SetBranchStatus(\"*\",0); // disable all branches\n",fTree->GetName());
1747  fprintf(fp,"// %s->SetBranchStatus(\"branchname\",1); // activate branchname\n",GetName());
1748  fprintf(fp,"\n Long64_t nentries = %s->GetEntries();\n",fTree->GetName());
1749  fprintf(fp,"\n Long64_t nbytes = 0;\n");
1750  fprintf(fp,"// for (Long64_t i=0; i<nentries;i++) {\n");
1751  fprintf(fp,"// nbytes += %s->GetEntry(i);\n",fTree->GetName());
1752  fprintf(fp,"// }\n");
1753  fprintf(fp,"}\n");
1754 
1755  printf("Macro: %s generated from Tree: %s\n",tfile.Data(), fTree->GetName());
1756  fclose(fp);
1757 
1758  return 0;
1759 }
1760 
1761 ////////////////////////////////////////////////////////////////////////////////
1762 /// Generate a skeleton analysis class for this Tree using TBranchProxy.
1763 /// TBranchProxy is the base of a class hierarchy implementing an
1764 /// indirect access to the content of the branches of a TTree.
1765 ///
1766 /// "proxyClassname" is expected to be of the form:
1767 /// ~~~{.cpp}
1768 /// [path/]fileprefix
1769 /// ~~~
1770 /// The skeleton will then be generated in the file:
1771 /// ~~~{.cpp}
1772 /// fileprefix.h
1773 /// ~~~
1774 /// located in the current directory or in 'path/' if it is specified.
1775 /// The class generated will be named 'fileprefix'.
1776 /// If the fileprefix contains a period, the right side of the period
1777 /// will be used as the extension (instead of 'h') and the left side
1778 /// will be used as the classname.
1779 ///
1780 /// "macrofilename" and optionally "cutfilename" are expected to point
1781 /// to source file which will be included in by the generated skeletong.
1782 /// Method of the same name as the file(minus the extension and path)
1783 /// will be called by the generated skeleton's Process method as follow:
1784 /// ~~~{.cpp}
1785 /// [if (cutfilename())] htemp->Fill(macrofilename());
1786 /// ~~~
1787 /// "option" can be used select some of the optional features during
1788 /// the code generation. The possible options are:
1789 /// - nohist : indicates that the generated ProcessFill should not
1790 /// fill the histogram.
1791 ///
1792 /// 'maxUnrolling' controls how deep in the class hierarchy does the
1793 /// system 'unroll' class that are not split. 'unrolling' a class
1794 /// will allow direct access to its data members a class (this
1795 /// emulates the behavior of TTreeFormula).
1796 ///
1797 /// The main features of this skeleton are:
1798 ///
1799 /// * on-demand loading of branches
1800 /// * ability to use the 'branchname' as if it was a data member
1801 /// * protection against array out-of-bound
1802 /// * ability to use the branch data as object (when the user code is available)
1803 ///
1804 /// For example with Event.root, if
1805 /// ~~~{.cpp}
1806 /// Double_t somepx = fTracks.fPx[2];
1807 /// ~~~
1808 /// is executed by one of the method of the skeleton,
1809 /// somepx will be updated with the current value of fPx of the 3rd track.
1810 ///
1811 /// Both macrofilename and the optional cutfilename are expected to be
1812 /// the name of source files which contain at least a free standing
1813 /// function with the signature:
1814 /// ~~~{.cpp}
1815 /// x_t macrofilename(); // i.e function with the same name as the file
1816 /// ~~~
1817 /// and
1818 /// ~~~{.cpp}
1819 /// y_t cutfilename(); // i.e function with the same name as the file
1820 /// ~~~
1821 /// x_t and y_t needs to be types that can convert respectively to a double
1822 /// and a bool (because the skeleton uses:
1823 /// ~~~{.cpp}
1824 /// if (cutfilename()) htemp->Fill(macrofilename());
1825 /// ~~~
1826 /// This 2 functions are run in a context such that the branch names are
1827 /// available as local variables of the correct (read-only) type.
1828 ///
1829 /// Note that if you use the same 'variable' twice, it is more efficient
1830 /// to 'cache' the value. For example
1831 /// ~~~{.cpp}
1832 /// Int_t n = fEventNumber; // Read fEventNumber
1833 /// if (n<10 || n>10) { ... }
1834 /// ~~~
1835 /// is more efficient than
1836 /// ~~~{.cpp}
1837 /// if (fEventNumber<10 || fEventNumber>10)
1838 /// ~~~
1839 /// Access to TClonesArray.
1840 ///
1841 /// If a branch (or member) is a TClonesArray (let's say fTracks), you
1842 /// can access the TClonesArray itself by using ->:
1843 /// ~~~{.cpp}
1844 /// fTracks->GetLast();
1845 /// ~~~
1846 /// However this will load the full TClonesArray object and its content.
1847 /// To quickly read the size of the TClonesArray use (note the dot):
1848 /// ~~~{.cpp}
1849 /// fTracks.GetEntries();
1850 /// ~~~
1851 /// This will read only the size from disk if the TClonesArray has been
1852 /// split.
1853 /// To access the content of the TClonesArray, use the [] operator:
1854 /// ~~~
1855 /// float px = fTracks[i].fPx; // fPx of the i-th track
1856 /// ~~~
1857 /// Warning:
1858 ///
1859 /// The variable actually use for access are 'wrapper' around the
1860 /// real data type (to add autoload for example) and hence getting to
1861 /// the data involves the implicit call to a C++ conversion operator.
1862 /// This conversion is automatic in most case. However it is not invoked
1863 /// in a few cases, in particular in variadic function (like printf).
1864 /// So when using printf you should either explicitly cast the value or
1865 /// use any intermediary variable:
1866 /// ~~~{.cpp}
1867 /// fprintf(stdout,"trs[%d].a = %d\n",i,(int)trs.a[i]);
1868 /// ~~~
1869 /// Also, optionally, the generated selector will also call methods named
1870 /// macrofilename_methodname in each of 6 main selector methods if the method
1871 /// macrofilename_methodname exist (Where macrofilename is stripped of its
1872 /// extension).
1873 ///
1874 /// Concretely, with the script named h1analysisProxy.C,
1875 ///
1876 /// - The method calls the method (if it exist)
1877 /// - Begin -> void h1analysisProxy_Begin(TTree*);
1878 /// - SlaveBegin -> void h1analysisProxy_SlaveBegin(TTree*);
1879 /// - Notify -> Bool_t h1analysisProxy_Notify();
1880 /// - Process -> Bool_t h1analysisProxy_Process(Long64_t);
1881 /// - SlaveTerminate -> void h1analysisProxy_SlaveTerminate();
1882 /// - Terminate -> void h1analysisProxy_Terminate();
1883 ///
1884 /// If a file name macrofilename.h (or .hh, .hpp, .hxx, .hPP, .hXX) exist
1885 /// it is included before the declaration of the proxy class. This can
1886 /// be used in particular to insure that the include files needed by
1887 /// the macro file are properly loaded.
1888 ///
1889 /// The default histogram is accessible via the variable named 'htemp'.
1890 ///
1891 /// If the library of the classes describing the data in the branch is
1892 /// loaded, the skeleton will add the needed `include` statements and
1893 /// give the ability to access the object stored in the branches.
1894 ///
1895 /// To draw px using the file `hsimple.root (generated by the
1896 /// hsimple.C tutorial), we need a file named hsimple.cxx:
1897 ///
1898 /// ~~~{.cpp}
1899 /// double hsimple() {
1900 /// return px;
1901 /// }
1902 /// ~~~
1903 /// MakeProxy can then be used indirectly via the TTree::Draw interface
1904 /// as follow:
1905 /// ~~~{.cpp}
1906 /// new TFile("hsimple.root")
1907 /// ntuple->Draw("hsimple.cxx");
1908 /// ~~~
1909 /// A more complete example is available in the tutorials directory:
1910 /// h1analysisProxy.cxx , h1analysProxy.h and h1analysisProxyCut.C
1911 /// which reimplement the selector found in h1analysis.C
1912 
1913 Int_t TTreePlayer::MakeProxy(const char *proxyClassname,
1914  const char *macrofilename, const char *cutfilename,
1915  const char *option, Int_t maxUnrolling)
1916 {
1917  if (macrofilename==0 || strlen(macrofilename)==0 ) {
1918  // We currently require a file name for the script
1919  Error("MakeProxy","A file name for the user script is required");
1920  return 0;
1921  }
1922 
1923  ROOT::Internal::TTreeProxyGenerator gp(fTree,macrofilename,cutfilename,proxyClassname,option,maxUnrolling);
1924 
1925  return 0;
1926 }
1927 
1928 
1929 ////////////////////////////////////////////////////////////////////////////////
1930 /// Generate skeleton selector class for this tree.
1931 ///
1932 /// The following files are produced: classname.h and classname.C.
1933 /// If classname is 0, the selector will be called "nameoftree".
1934 /// The option can be used to specify the branches that will have a data member.
1935 /// - If option is empty, readers will be generated for each leaf.
1936 /// - If option is "@", readers will be generated for the topmost branches.
1937 /// - Individual branches can also be picked by their name:
1938 /// - "X" generates readers for leaves of X.
1939 /// - "@X" generates a reader for X as a whole.
1940 /// - "@X;Y" generates a reader for X as a whole and also readers for the
1941 /// leaves of Y.
1942 /// - For further examples see the figure below.
1943 ///
1944 /// \image html ttree_makeselector_option_examples.png
1945 ///
1946 /// The generated code in classname.h includes the following:
1947 /// - Identification of the original Tree and Input file name
1948 /// - Definition of selector class (data and functions)
1949 /// - The following class functions:
1950 /// - constructor and destructor
1951 /// - void Begin(TTree *tree)
1952 /// - void SlaveBegin(TTree *tree)
1953 /// - void Init(TTree *tree)
1954 /// - Bool_t Notify()
1955 /// - Bool_t Process(Long64_t entry)
1956 /// - void Terminate()
1957 /// - void SlaveTerminate()
1958 ///
1959 /// The selector derives from TSelector.
1960 /// The generated code in classname.C includes empty functions defined above.
1961 ///
1962 /// To use this function:
1963 /// - connect your Tree file (eg: `TFile f("myfile.root");`)
1964 /// - `T->MakeSelector("myselect");`
1965 /// where `T` is the name of the Tree in file `myfile.root`
1966 /// and `myselect.h`, `myselect.C` the name of the files created by this
1967 /// function.
1968 ///
1969 /// In a ROOT session, you can do:
1970 /// ~~~ {.cpp}
1971 /// root > T->Process("myselect.C")
1972 /// ~~~
1973 Int_t TTreePlayer::MakeReader(const char *classname, Option_t *option)
1974 {
1975  if (!classname) classname = fTree->GetName();
1976 
1977  ROOT::Internal::TTreeReaderGenerator gsr(fTree, classname, option);
1978 
1979  return 0;
1980 }
1981 
1982 
1983 ////////////////////////////////////////////////////////////////////////////////
1984 /// Interface to the Principal Components Analysis class.
1985 ///
1986 /// Create an instance of TPrincipal
1987 /// Fill it with the selected variables
1988 ///
1989 /// - if option "n" is specified, the TPrincipal object is filled with
1990 /// normalized variables.
1991 /// - If option "p" is specified, compute the principal components
1992 /// - If option "p" and "d" print results of analysis
1993 /// - If option "p" and "h" generate standard histograms
1994 /// - If option "p" and "c" generate code of conversion functions
1995 ///
1996 /// return a pointer to the TPrincipal object. It is the user responsibility
1997 /// to delete this object.
1998 ///
1999 /// The option default value is "np"
2000 ///
2001 /// See TTreePlayer::DrawSelect for explanation of the other parameters.
2002 
2003 TPrincipal *TTreePlayer::Principal(const char *varexp, const char *selection, Option_t *option, Long64_t nentries, Long64_t firstentry)
2004 {
2005  TTreeFormula **var;
2006  std::vector<TString> cnames;
2007  TString opt = option;
2008  opt.ToLower();
2009  TPrincipal *principal = 0;
2010  Long64_t entry,entryNumber;
2011  Int_t i,nch;
2012  Int_t ncols = 8; // by default first 8 columns are printed only
2013  TObjArray *leaves = fTree->GetListOfLeaves();
2014  Int_t nleaves = leaves->GetEntriesFast();
2015  if (nleaves < ncols) ncols = nleaves;
2016  nch = varexp ? strlen(varexp) : 0;
2017 
2018  nentries = GetEntriesToProcess(firstentry, nentries);
2019 
2020 //*-*- Compile selection expression if there is one
2021  TTreeFormula *select = 0;
2022  if (strlen(selection)) {
2023  select = new TTreeFormula("Selection",selection,fTree);
2024  if (!select) return principal;
2025  if (!select->GetNdim()) { delete select; return principal; }
2026  fFormulaList->Add(select);
2027  }
2028 //*-*- if varexp is empty, take first 8 columns by default
2029  int allvar = 0;
2030  if (varexp && !strcmp(varexp, "*")) { ncols = nleaves; allvar = 1; }
2031  if (nch == 0 || allvar) {
2032  for (i=0;i<ncols;i++) {
2033  cnames.push_back( ((TLeaf*)leaves->At(i))->GetName() );
2034  }
2035 //*-*- otherwise select only the specified columns
2036  } else {
2037  ncols = fSelector->SplitNames(varexp,cnames);
2038  }
2039  var = new TTreeFormula* [ncols];
2040  Double_t *xvars = new Double_t[ncols];
2041 
2042 //*-*- Create the TreeFormula objects corresponding to each column
2043  for (i=0;i<ncols;i++) {
2044  var[i] = new TTreeFormula("Var1",cnames[i].Data(),fTree);
2045  fFormulaList->Add(var[i]);
2046  }
2047 
2048 //*-*- Create a TreeFormulaManager to coordinate the formulas
2049  TTreeFormulaManager *manager=0;
2050  if (fFormulaList->LastIndex()>=0) {
2051  manager = new TTreeFormulaManager;
2052  for(i=0;i<=fFormulaList->LastIndex();i++) {
2053  manager->Add((TTreeFormula*)fFormulaList->At(i));
2054  }
2055  manager->Sync();
2056  }
2057 
2058 //*-* Build the TPrincipal object
2059  if (opt.Contains("n")) principal = new TPrincipal(ncols, "n");
2060  else principal = new TPrincipal(ncols);
2061 
2062 //*-*- loop on all selected entries
2063  fSelectedRows = 0;
2064  Int_t tnumber = -1;
2065  for (entry=firstentry;entry<firstentry+nentries;entry++) {
2066  entryNumber = fTree->GetEntryNumber(entry);
2067  if (entryNumber < 0) break;
2068  Long64_t localEntry = fTree->LoadTree(entryNumber);
2069  if (localEntry < 0) break;
2070  if (tnumber != fTree->GetTreeNumber()) {
2071  tnumber = fTree->GetTreeNumber();
2072  if (manager) manager->UpdateFormulaLeaves();
2073  }
2074  int ndata = 1;
2075  if (manager && manager->GetMultiplicity()) {
2076  ndata = manager->GetNdata();
2077  }
2078 
2079  for(int inst=0;inst<ndata;inst++) {
2080  Bool_t loaded = kFALSE;
2081  if (select) {
2082  if (select->EvalInstance(inst) == 0) {
2083  continue;
2084  }
2085  }
2086 
2087  if (inst==0) loaded = kTRUE;
2088  else if (!loaded) {
2089  // EvalInstance(0) always needs to be called so that
2090  // the proper branches are loaded.
2091  for (i=0;i<ncols;i++) {
2092  var[i]->EvalInstance(0);
2093  }
2094  loaded = kTRUE;
2095  }
2096 
2097  for (i=0;i<ncols;i++) {
2098  xvars[i] = var[i]->EvalInstance(inst);
2099  }
2100  principal->AddRow(xvars);
2101  }
2102  }
2103 
2104  //*-* some actions with principal ?
2105  if (opt.Contains("p")) {
2106  principal->MakePrincipals(); // Do the actual analysis
2107  if (opt.Contains("d")) principal->Print();
2108  if (opt.Contains("h")) principal->MakeHistograms();
2109  if (opt.Contains("c")) principal->MakeCode();
2110  }
2111 
2112 //*-*- delete temporary objects
2113  fFormulaList->Clear();
2114  delete [] var;
2115  delete [] xvars;
2116 
2117  return principal;
2118 }
2119 
2120 ////////////////////////////////////////////////////////////////////////////////
2121 /// Process this tree executing the TSelector code in the specified filename.
2122 /// The return value is -1 in case of error and TSelector::GetStatus() in
2123 /// in case of success.
2124 ///
2125 /// The code in filename is loaded (interpreted or compiled, see below),
2126 /// filename must contain a valid class implementation derived from TSelector,
2127 /// where TSelector has the following member functions:
2128 ///
2129 /// - Begin(): called every time a loop on the tree starts,
2130 /// a convenient place to create your histograms.
2131 /// - SlaveBegin(): called after Begin(), when on PROOF called only on the
2132 /// slave servers.
2133 /// - Process(): called for each event, in this function you decide what
2134 /// to read and fill your histograms.
2135 /// - SlaveTerminate: called at the end of the loop on the tree, when on PROOF
2136 /// called only on the slave servers.
2137 /// - Terminate(): called at the end of the loop on the tree,
2138 /// a convenient place to draw/fit your histograms.
2139 ///
2140 /// If filename is of the form file.C, the file will be interpreted.
2141 /// If filename is of the form file.C++, the file file.C will be compiled
2142 /// and dynamically loaded.
2143 ///
2144 /// If filename is of the form file.C+, the file file.C will be compiled
2145 /// and dynamically loaded. At next call, if file.C is older than file.o
2146 /// and file.so, the file.C is not compiled, only file.so is loaded.
2147 ///
2148 /// ### NOTE 1
2149 /// It may be more interesting to invoke directly the other Process function
2150 /// accepting a TSelector* as argument.eg
2151 /// ~~~{.cpp}
2152 /// MySelector *selector = (MySelector*)TSelector::GetSelector(filename);
2153 /// selector->CallSomeFunction(..);
2154 /// mytree.Process(selector,..);
2155 /// ~~~
2156 /// ### NOTE 2
2157 /// One should not call this function twice with the same selector file
2158 /// in the same script. If this is required, proceed as indicated in NOTE1,
2159 /// by getting a pointer to the corresponding TSelector,eg
2160 ///#### workaround 1
2161 /// ~~~{.cpp}
2162 ///void stubs1() {
2163 /// TSelector *selector = TSelector::GetSelector("h1test.C");
2164 /// TFile *f1 = new TFile("stubs_nood_le1.root");
2165 /// TTree *h1 = (TTree*)f1->Get("h1");
2166 /// h1->Process(selector);
2167 /// TFile *f2 = new TFile("stubs_nood_le1_coarse.root");
2168 /// TTree *h2 = (TTree*)f2->Get("h1");
2169 /// h2->Process(selector);
2170 ///}
2171 /// ~~~
2172 /// or use ACLIC to compile the selector
2173 ///#### workaround 2
2174 /// ~~~{.cpp}
2175 ///void stubs2() {
2176 /// TFile *f1 = new TFile("stubs_nood_le1.root");
2177 /// TTree *h1 = (TTree*)f1->Get("h1");
2178 /// h1->Process("h1test.C+");
2179 /// TFile *f2 = new TFile("stubs_nood_le1_coarse.root");
2180 /// TTree *h2 = (TTree*)f2->Get("h1");
2181 /// h2->Process("h1test.C+");
2182 ///}
2183 /// ~~~
2184 
2185 Long64_t TTreePlayer::Process(const char *filename,Option_t *option, Long64_t nentries, Long64_t firstentry)
2186 {
2187  DeleteSelectorFromFile(); //delete previous selector if any
2188 
2189  // This might reloads the script and delete your option
2190  // string! so let copy it first:
2191  TString opt(option);
2192  TString file(filename);
2193  TSelector *selector = TSelector::GetSelector(file);
2194  if (!selector) return -1;
2195 
2196  fSelectorFromFile = selector;
2197  fSelectorClass = selector->IsA();
2198 
2199  Long64_t nsel = Process(selector,opt,nentries,firstentry);
2200  return nsel;
2201 }
2202 
2203 ////////////////////////////////////////////////////////////////////////////////
2204 /// Process this tree executing the code in the specified selector.
2205 /// The return value is -1 in case of error and TSelector::GetStatus() in
2206 /// in case of success.
2207 ///
2208 /// The TSelector class has the following member functions:
2209 ///
2210 /// - Begin(): called every time a loop on the tree starts,
2211 /// a convenient place to create your histograms.
2212 /// - SlaveBegin(): called after Begin(), when on PROOF called only on the
2213 /// slave servers.
2214 /// - Process(): called for each event, in this function you decide what
2215 /// to read and fill your histograms.
2216 /// - SlaveTerminate: called at the end of the loop on the tree, when on PROOF
2217 /// called only on the slave servers.
2218 /// - Terminate(): called at the end of the loop on the tree,
2219 /// a convenient place to draw/fit your histograms.
2220 ///
2221 /// If the Tree (Chain) has an associated EventList, the loop is on the nentries
2222 /// of the EventList, starting at firstentry, otherwise the loop is on the
2223 /// specified Tree entries.
2224 
2226 {
2227  nentries = GetEntriesToProcess(firstentry, nentries);
2228 
2229  TDirectory::TContext ctxt;
2230 
2231  fTree->SetNotify(selector);
2232 
2233  selector->SetOption(option);
2234 
2235  selector->Begin(fTree); //<===call user initialization function
2236  selector->SlaveBegin(fTree); //<===call user initialization function
2237  if (selector->Version() >= 2)
2238  selector->Init(fTree);
2239  selector->Notify();
2240 
2241  if (gMonitoringWriter)
2243 
2244  Bool_t process = (selector->GetAbort() != TSelector::kAbortProcess &&
2245  (selector->Version() != 0 || selector->GetStatus() != -1)) ? kTRUE : kFALSE;
2246  if (process) {
2247 
2248  Long64_t readbytesatstart = 0;
2249  readbytesatstart = TFile::GetFileBytesRead();
2250 
2251  //set the file cache
2252  TTreeCache *tpf = 0;
2253  TFile *curfile = fTree->GetCurrentFile();
2254  if (curfile && fTree->GetCacheSize() > 0) {
2255  tpf = (TTreeCache*)curfile->GetCacheRead(fTree);
2256  if (tpf)
2257  tpf->SetEntryRange(firstentry,firstentry+nentries);
2258  else {
2260  tpf = (TTreeCache*)curfile->GetCacheRead(fTree);
2261  if (tpf) tpf->SetEntryRange(firstentry,firstentry+nentries);
2262  }
2263  }
2264 
2265  //Create a timer to get control in the entry loop(s)
2266  TProcessEventTimer *timer = 0;
2267  Int_t interval = fTree->GetTimerInterval();
2268  if (!gROOT->IsBatch() && interval)
2269  timer = new TProcessEventTimer(interval);
2270 
2271  //loop on entries (elist or all entries)
2272  Long64_t entry, entryNumber, localEntry;
2273 
2274  Bool_t useCutFill = selector->Version() == 0;
2275 
2276  // force the first monitoring info
2277  if (gMonitoringWriter)
2279 
2280  //trying to set the first tree, because in the Draw function
2281  //the tree corresponding to firstentry has already been loaded,
2282  //so it is not set in the entry list
2283  fSelectorUpdate = selector;
2285 
2286  for (entry=firstentry;entry<firstentry+nentries;entry++) {
2287  entryNumber = fTree->GetEntryNumber(entry);
2288  if (entryNumber < 0) break;
2289  if (timer && timer->ProcessEvents()) break;
2290  if (gROOT->IsInterrupted()) break;
2291  localEntry = fTree->LoadTree(entryNumber);
2292  if (localEntry < 0) break;
2293  if(useCutFill) {
2294  if (selector->ProcessCut(localEntry))
2295  selector->ProcessFill(localEntry); //<==call user analysis function
2296  } else {
2297  selector->Process(localEntry); //<==call user analysis function
2298  }
2299  if (gMonitoringWriter)
2300  gMonitoringWriter->SendProcessingProgress((entry-firstentry),TFile::GetFileBytesRead()-readbytesatstart,kTRUE);
2301  if (selector->GetAbort() == TSelector::kAbortProcess) break;
2302  if (selector->GetAbort() == TSelector::kAbortFile) {
2303  // Skip to the next file.
2304  entry += fTree->GetTree()->GetEntries() - localEntry;
2305  // Reset the abort status.
2306  selector->ResetAbort();
2307  }
2308  }
2309  delete timer;
2310  //we must reset the cache
2311  {
2312  TFile *curfile2 = fTree->GetCurrentFile();
2313  if (curfile2 && fTree->GetCacheSize() > 0) {
2314  tpf = (TTreeCache*)curfile2->GetCacheRead(fTree);
2315  if (tpf) tpf->SetEntryRange(0,0);
2316  }
2317  }
2318  }
2319 
2320  process = (selector->GetAbort() != TSelector::kAbortProcess &&
2321  (selector->Version() != 0 || selector->GetStatus() != -1)) ? kTRUE : kFALSE;
2322  Long64_t res = (process) ? 0 : -1;
2323  if (process) {
2324  selector->SlaveTerminate(); //<==call user termination function
2325  selector->Terminate(); //<==call user termination function
2326  res = selector->GetStatus();
2327  }
2328  fTree->SetNotify(0); // Detach the selector from the tree.
2329  fSelectorUpdate = 0;
2330  if (gMonitoringWriter)
2332 
2333  return res;
2334 }
2335 
2336 ////////////////////////////////////////////////////////////////////////////////
2337 /// cleanup pointers in the player pointing to obj
2338 
2340 {
2341  if (fHistogram == obj) fHistogram = 0;
2342 }
2343 
2344 ////////////////////////////////////////////////////////////////////////////////
2345 /// Loop on Tree and print entries passing selection. If varexp is 0 (or "")
2346 /// then print only first 8 columns. If varexp = "*" print all columns.
2347 /// Otherwise a columns selection can be made using "var1:var2:var3".
2348 /// The function returns the number of entries passing the selection.
2349 ///
2350 /// By default 50 rows are shown and you are asked for `<CR>`
2351 /// to see the next 50 rows.
2352 ///
2353 /// You can change the default number of rows to be shown before `<CR>`
2354 /// via mytree->SetScanField(maxrows) where maxrows is 50 by default.
2355 /// if maxrows is set to 0 all rows of the Tree are shown.
2356 ///
2357 /// This option is interesting when dumping the contents of a Tree to
2358 /// an ascii file, eg from the command line.
2359 /// ### with ROOT 5
2360 /// ~~~{.cpp}
2361 /// root [0] tree->SetScanField(0);
2362 /// root [1] tree->Scan("*"); >tree.log
2363 /// ~~~
2364 /// ### with ROOT 6
2365 /// ~~~{.cpp}
2366 /// root [0] tree->SetScanField(0);
2367 /// root [1] .> tree.log
2368 /// tree->Scan("*");
2369 /// .>
2370 /// ~~~
2371 /// will create a file tree.log
2372 ///
2373 /// Arrays (within an entry) are printed in their linear forms.
2374 /// If several arrays with multiple dimensions are printed together,
2375 /// they will NOT be synchronized. For example print
2376 /// arr1[4][2] and arr2[2][3] will results in a printing similar to:
2377 /// ~~~{.cpp}
2378 /// ***********************************************
2379 /// * Row * Instance * arr1 * arr2 *
2380 /// ***********************************************
2381 /// * x * 0 * arr1[0][0]* arr2[0][0]*
2382 /// * x * 1 * arr1[0][1]* arr2[0][1]*
2383 /// * x * 2 * arr1[1][0]* arr2[0][2]*
2384 /// * x * 3 * arr1[1][1]* arr2[1][0]*
2385 /// * x * 4 * arr1[2][0]* arr2[1][1]*
2386 /// * x * 5 * arr1[2][1]* arr2[1][2]*
2387 /// * x * 6 * arr1[3][0]* *
2388 /// * x * 7 * arr1[3][1]* *
2389 /// ~~~
2390 /// However, if there is a selection criterion which is an array, then
2391 /// all the formulas will be synchronized with the selection criterion
2392 /// (see TTreePlayer::DrawSelect for more information).
2393 ///
2394 /// The options string can contains the following parameters:
2395 ///
2396 /// - lenmax=dd
2397 /// Where 'dd' is the maximum number of elements per array that should
2398 /// be printed. If 'dd' is 0, all elements are printed (this is the
2399 /// default)
2400 /// - colsize=ss
2401 /// Where 'ss' will be used as the default size for all the column
2402 /// If this options is not specified, the default column size is 9
2403 /// - precision=pp
2404 /// Where 'pp' will be used as the default 'precision' for the
2405 /// printing format.
2406 /// - col=xxx
2407 /// Where 'xxx' is colon (:) delimited list of printing format for
2408 /// each column. The format string should follow the printf format
2409 /// specification. The value given will be prefixed by % and, if no
2410 /// conversion specifier is given, will be suffixed by the letter g.
2411 /// before being passed to fprintf. If no format is specified for a
2412 /// column, the default is used (aka ${colsize}.${precision}g )
2413 ///
2414 /// For example:
2415 /// ~~~{.cpp}
2416 /// tree->Scan("a:b:c","","colsize=30 precision=3 col=::20.10:#x:5ld");
2417 /// ~~~
2418 /// Will print 3 columns, the first 2 columns will be 30 characters long,
2419 /// the third columns will be 20 characters long. The printing format used
2420 /// for the columns (assuming they are numbers) will be respectively:
2421 /// ~~~ {.cpp}
2422 /// %30.3g %30.3g %20.10g %#x %5ld
2423 /// ~~~
2424 
2425 Long64_t TTreePlayer::Scan(const char *varexp, const char *selection,
2426  Option_t * option,
2427  Long64_t nentries, Long64_t firstentry)
2428 {
2429 
2430  TString opt = option;
2431  opt.ToLower();
2432  UInt_t ui;
2433  UInt_t lenmax = 0;
2434  UInt_t colDefaultSize = 9;
2435  UInt_t colPrecision = 9;
2436  std::vector<TString> colFormats;
2437  std::vector<Int_t> colSizes;
2438 
2439  if (opt.Contains("lenmax=")) {
2440  int start = opt.Index("lenmax=");
2441  int numpos = start + strlen("lenmax=");
2442  int numlen = 0;
2443  int len = opt.Length();
2444  while( (numpos+numlen<len) && isdigit(opt[numpos+numlen]) ) numlen++;
2445  TString num = opt(numpos,numlen);
2446  opt.Remove(start,strlen("lenmax")+numlen);
2447 
2448  lenmax = atoi(num.Data());
2449  }
2450  if (opt.Contains("colsize=")) {
2451  int start = opt.Index("colsize=");
2452  int numpos = start + strlen("colsize=");
2453  int numlen = 0;
2454  int len = opt.Length();
2455  while( (numpos+numlen<len) && isdigit(opt[numpos+numlen]) ) numlen++;
2456  TString num = opt(numpos,numlen);
2457  opt.Remove(start,strlen("size")+numlen);
2458 
2459  colDefaultSize = atoi(num.Data());
2460  colPrecision = colDefaultSize;
2461  if (colPrecision>18) colPrecision = 18;
2462  }
2463  if (opt.Contains("precision=")) {
2464  int start = opt.Index("precision=");
2465  int numpos = start + strlen("precision=");
2466  int numlen = 0;
2467  int len = opt.Length();
2468  while( (numpos+numlen<len) && isdigit(opt[numpos+numlen]) ) numlen++;
2469  TString num = opt(numpos,numlen);
2470  opt.Remove(start,strlen("precision")+numlen);
2471 
2472  colPrecision = atoi(num.Data());
2473  }
2474  TString defFormat = Form("%d.%d",colDefaultSize,colPrecision);
2475  if (opt.Contains("col=")) {
2476  int start = opt.Index("col=");
2477  int numpos = start + strlen("col=");
2478  int numlen = 0;
2479  int len = opt.Length();
2480  while( (numpos+numlen<len) &&
2481  (isdigit(opt[numpos+numlen])
2482  || opt[numpos+numlen] == 'c'
2483  || opt[numpos+numlen] == 'd'
2484  || opt[numpos+numlen] == 'i'
2485  || opt[numpos+numlen] == 'o'
2486  || opt[numpos+numlen] == 'x'
2487  || opt[numpos+numlen] == 'X'
2488  || opt[numpos+numlen] == 'u'
2489  || opt[numpos+numlen] == 'f'
2490  || opt[numpos+numlen] == 'e'
2491  || opt[numpos+numlen] == 'E'
2492  || opt[numpos+numlen] == 'g'
2493  || opt[numpos+numlen] == 'G'
2494  || opt[numpos+numlen] == 'l'
2495  || opt[numpos+numlen] == 'L'
2496  || opt[numpos+numlen] == 'h'
2497  || opt[numpos+numlen] == 's'
2498  || opt[numpos+numlen] == '#'
2499  || opt[numpos+numlen]=='.'
2500  || opt[numpos+numlen]==':')) numlen++;
2501  TString flist = opt(numpos,numlen);
2502  opt.Remove(start,strlen("col")+numlen);
2503 
2504  int i = 0;
2505  while(i<flist.Length() && flist[i]==':') {
2506  colFormats.push_back(defFormat);
2507  colSizes.push_back(colDefaultSize);
2508  ++i;
2509  }
2510  for(; i<flist.Length(); ++i) {
2511  int next = flist.Index(":",i);
2512  if (next==i) {
2513  colFormats.push_back(defFormat);
2514  } else if (next==kNPOS) {
2515  colFormats.push_back(flist(i,flist.Length()-i));
2516  i = flist.Length();
2517  } else {
2518  colFormats.push_back(flist(i,next-i));
2519  i = next;
2520  }
2521  UInt_t siz = atoi(colFormats[colFormats.size()-1].Data());
2522  colSizes.push_back( siz ? siz : colDefaultSize );
2523  }
2524  }
2525 
2526  TTreeFormula **var;
2527  std::vector<TString> cnames;
2528  TString onerow;
2529  Long64_t entry,entryNumber;
2530  Int_t i,nch;
2531  UInt_t ncols = 8; // by default first 8 columns are printed only
2532  std::ofstream out;
2533  const char *fname = nullptr;
2534  TString fownname;
2535  if (fScanRedirect) {
2536  fTree->SetScanField(0); // no page break if Scan is redirected
2537  fname = fScanFileName;
2538  if (!fname) fname = "";
2539  Int_t lenfile = strlen(fname);
2540  if (!lenfile) {
2541  fownname = fTree->GetName();
2542  fownname.Append("-scan.dat");
2543  fname = fownname.Data();
2544  }
2545  out.open(fname, std::ios::out);
2546  if (!out.good ()) {
2547  Error("Scan","Can not open file for redirection");
2548  return 0;
2549  }
2550  }
2551  TObjArray *leaves = fTree->GetListOfLeaves();
2552  if (leaves==0) return 0;
2553  UInt_t nleaves = leaves->GetEntriesFast();
2554  if (nleaves < ncols) ncols = nleaves;
2555  nch = varexp ? strlen(varexp) : 0;
2556 
2557  nentries = GetEntriesToProcess(firstentry, nentries);
2558 
2559 //*-*- Compile selection expression if there is one
2560  TTreeFormula *select = 0;
2561  if (selection && strlen(selection)) {
2562  select = new TTreeFormula("Selection",selection,fTree);
2563  if (!select) return -1;
2564  if (!select->GetNdim()) { delete select; return -1; }
2565  fFormulaList->Add(select);
2566  }
2567 //*-*- if varexp is empty, take first 8 columns by default
2568  int allvar = 0;
2569  if (varexp && !strcmp(varexp, "*")) { ncols = nleaves; allvar = 1; }
2570  if (nch == 0 || allvar) {
2571  UInt_t ncs = ncols;
2572  ncols = 0;
2573  for (ui=0;ui<ncs;++ui) {
2574  TLeaf *lf = (TLeaf*)leaves->At(ui);
2575  if (lf->GetBranch()->GetListOfBranches()->GetEntries() > 0) continue;
2576  cnames.push_back( lf->GetBranch()->GetMother()->GetName() );
2577  if (cnames[ncols] == lf->GetName() ) {
2578  // Already complete, let move on.
2579  } else if (cnames[ncols][cnames[ncols].Length()-1]=='.') {
2580  cnames[ncols] = lf->GetBranch()->GetName(); // name of branch already include mother's name
2581  } else {
2582  if (lf->GetBranch()->GetMother()->IsA()->InheritsFrom(TBranchElement::Class())) {
2583  TBranchElement *mother = (TBranchElement*)lf->GetBranch()->GetMother();
2584  if (mother->GetType() == 3 || mother->GetType() == 4) {
2585  // The name of the mother branch is embedded in the sub-branch names.
2586  cnames[ncols] = lf->GetBranch()->GetName();
2587  ++ncols;
2588  continue;
2589  }
2590  }
2591  if (!strchr(lf->GetBranch()->GetName() ,'[') ) {
2592  cnames[ncols].Append('.');
2593  cnames[ncols].Append( lf->GetBranch()->GetName() );
2594  }
2595  }
2596  if (lf->GetBranch()->IsA() == TBranch::Class() ||
2597  strcmp( lf->GetBranch()->GetName(), lf->GetName() ) != 0 ) {
2598  cnames[ncols].Append('.');
2599  cnames[ncols].Append( lf->GetName() );
2600  }
2601  ++ncols;
2602  }
2603 //*-*- otherwise select only the specified columns
2604  } else {
2605 
2606  ncols = fSelector->SplitNames(varexp, cnames);
2607 
2608  }
2609  var = new TTreeFormula* [ncols];
2610 
2611  for(ui=colFormats.size();ui<ncols;++ui) {
2612  colFormats.push_back(defFormat);
2613  colSizes.push_back(colDefaultSize);
2614  }
2615 
2616 //*-*- Create the TreeFormula objects corresponding to each column
2617  for (ui=0;ui<ncols;ui++) {
2618  var[ui] = new TTreeFormula("Var1",cnames[ui].Data(),fTree);
2619  fFormulaList->Add(var[ui]);
2620  }
2621 
2622 //*-*- Create a TreeFormulaManager to coordinate the formulas
2623  TTreeFormulaManager *manager=0;
2624  Bool_t hasArray = kFALSE;
2625  Bool_t forceDim = kFALSE;
2626  if (fFormulaList->LastIndex()>=0) {
2627  if (select) {
2628  if (select->GetManager()->GetMultiplicity() > 0 ) {
2629  manager = new TTreeFormulaManager;
2630  for(i=0;i<=fFormulaList->LastIndex();i++) {
2631  manager->Add((TTreeFormula*)fFormulaList->At(i));
2632  }
2633  manager->Sync();
2634  }
2635  }
2636  for(i=0;i<=fFormulaList->LastIndex();i++) {
2637  TTreeFormula *form = ((TTreeFormula*)fFormulaList->At(i));
2638  switch( form->GetManager()->GetMultiplicity() ) {
2639  case 1:
2640  case 2:
2641  hasArray = kTRUE;
2642  forceDim = kTRUE;
2643  break;
2644  case -1:
2645  forceDim = kTRUE;
2646  break;
2647  case 0:
2648  break;
2649  }
2650 
2651  }
2652  }
2653 
2654 //*-*- Print header
2655  onerow = "***********";
2656  if (hasArray) onerow += "***********";
2657 
2658  for (ui=0;ui<ncols;ui++) {
2659  TString starFormat = Form("*%%%d.%ds",colSizes[ui]+2,colSizes[ui]+2);
2660  onerow += Form(starFormat.Data(),var[ui]->PrintValue(-2));
2661  }
2662  if (fScanRedirect)
2663  out<<onerow.Data()<<"*"<<std::endl;
2664  else
2665  printf("%s*\n",onerow.Data());
2666  onerow = "* Row ";
2667  if (hasArray) onerow += "* Instance ";
2668  for (ui=0;ui<ncols;ui++) {
2669  TString numbFormat = Form("* %%%d.%ds ",colSizes[ui],colSizes[ui]);
2670  onerow += Form(numbFormat.Data(),var[ui]->PrintValue(-1));
2671  }
2672  if (fScanRedirect)
2673  out<<onerow.Data()<<"*"<<std::endl;
2674  else
2675  printf("%s*\n",onerow.Data());
2676  onerow = "***********";
2677  if (hasArray) onerow += "***********";
2678  for (ui=0;ui<ncols;ui++) {
2679  TString starFormat = Form("*%%%d.%ds",colSizes[ui]+2,colSizes[ui]+2);
2680  onerow += Form(starFormat.Data(),var[ui]->PrintValue(-2));
2681  }
2682  if (fScanRedirect)
2683  out<<onerow.Data()<<"*"<<std::endl;
2684  else
2685  printf("%s*\n",onerow.Data());
2686 //*-*- loop on all selected entries
2687  fSelectedRows = 0;
2688  Int_t tnumber = -1;
2689  Bool_t exitloop = kFALSE;
2690  for (entry=firstentry;
2691  entry<(firstentry+nentries) && !exitloop;
2692  entry++) {
2693  entryNumber = fTree->GetEntryNumber(entry);
2694  if (entryNumber < 0) break;
2695  Long64_t localEntry = fTree->LoadTree(entryNumber);
2696  if (localEntry < 0) break;
2697  if (tnumber != fTree->GetTreeNumber()) {
2698  tnumber = fTree->GetTreeNumber();
2699  if (manager) manager->UpdateFormulaLeaves();
2700  else {
2701  for(i=0;i<=fFormulaList->LastIndex();i++) {
2703  }
2704  }
2705  }
2706 
2707  int ndata = 1;
2708  if (forceDim) {
2709 
2710  if (manager) {
2711 
2712  ndata = manager->GetNdata(kTRUE);
2713 
2714  } else {
2715 
2716  // let's print the max number of column
2717  for (ui=0;ui<ncols;ui++) {
2718  if (ndata < var[ui]->GetNdata() ) {
2719  ndata = var[ui]->GetNdata();
2720  }
2721  }
2722  if (select && select->GetNdata()==0) ndata = 0;
2723  }
2724 
2725  }
2726 
2727  if (lenmax && ndata>(int)lenmax) ndata = lenmax;
2728  Bool_t loaded = kFALSE;
2729  for(int inst=0;inst<ndata;inst++) {
2730  if (select) {
2731  if (select->EvalInstance(inst) == 0) {
2732  continue;
2733  }
2734  }
2735  if (inst==0) loaded = kTRUE;
2736  else if (!loaded) {
2737  // EvalInstance(0) always needs to be called so that
2738  // the proper branches are loaded.
2739  for (ui=0;ui<ncols;ui++) {
2740  var[ui]->EvalInstance(0);
2741  }
2742  loaded = kTRUE;
2743  }
2744  onerow = Form("* %8lld ",entryNumber);
2745  if (hasArray) {
2746  onerow += Form("* %8d ",inst);
2747  }
2748  for (ui=0;ui<ncols;++ui) {
2749  TString numbFormat = Form("* %%%d.%ds ",colSizes[ui],colSizes[ui]);
2750  if (var[ui]->GetNdim()) onerow += Form(numbFormat.Data(),var[ui]->PrintValue(0,inst,colFormats[ui].Data()));
2751  else {
2752  TString emptyForm = Form("* %%%dc ",colSizes[ui]);
2753  onerow += Form(emptyForm.Data(),' ');
2754  }
2755  }
2756  fSelectedRows++;
2757  if (fScanRedirect)
2758  out<<onerow.Data()<<"*"<<std::endl;
2759  else
2760  printf("%s*\n",onerow.Data());
2761  if (fTree->GetScanField() > 0 && fSelectedRows > 0) {
2762  if (fSelectedRows%fTree->GetScanField() == 0) {
2763  fprintf(stderr,"Type <CR> to continue or q to quit ==> ");
2764  int answer, readch;
2765  readch = getchar();
2766  answer = readch;
2767  while (readch != '\n' && readch != EOF) readch = getchar();
2768  if (answer == 'q' || answer == 'Q') {
2769  exitloop = kTRUE;
2770  break;
2771  }
2772  }
2773  }
2774  }
2775  }
2776  onerow = "***********";
2777  if (hasArray) onerow += "***********";
2778  for (ui=0;ui<ncols;ui++) {
2779  TString starFormat = Form("*%%%d.%ds",colSizes[ui]+2,colSizes[ui]+2);
2780  onerow += Form(starFormat.Data(),var[ui]->PrintValue(-2));
2781  }
2782  if (fScanRedirect)
2783  out<<onerow.Data()<<"*"<<std::endl;
2784  else
2785  printf("%s*\n",onerow.Data());
2786  if (select) Printf("==> %lld selected %s", fSelectedRows,
2787  fSelectedRows == 1 ? "entry" : "entries");
2788  if (fScanRedirect) printf("File <%s> created\n", fname);
2789 
2790 //*-*- delete temporary objects
2791  fFormulaList->Clear();
2792  // The TTreeFormulaManager is deleted by the last TTreeFormula.
2793  delete [] var;
2794  return fSelectedRows;
2795 }
2796 
2797 ////////////////////////////////////////////////////////////////////////////////
2798 /// Loop on Tree and return TSQLResult object containing entries passing
2799 /// selection. If varexp is 0 (or "") then print only first 8 columns.
2800 /// If varexp = "*" print all columns. Otherwise a columns selection can
2801 /// be made using "var1:var2:var3". In case of error 0 is returned otherwise
2802 /// a TSQLResult object which must be deleted by the user.
2803 
2804 TSQLResult *TTreePlayer::Query(const char *varexp, const char *selection,
2805  Option_t *, Long64_t nentries, Long64_t firstentry)
2806 {
2807  TTreeFormula **var;
2808  std::vector<TString> cnames;
2809  TString onerow;
2810  Long64_t entry,entryNumber;
2811  Int_t i,nch;
2812  Int_t ncols = 8; // by default first 8 columns are printed only
2813  TObjArray *leaves = fTree->GetListOfLeaves();
2814  Int_t nleaves = leaves->GetEntriesFast();
2815  if (nleaves < ncols) ncols = nleaves;
2816  nch = varexp ? strlen(varexp) : 0;
2817 
2818  nentries = GetEntriesToProcess(firstentry, nentries);
2819 
2820  // compile selection expression if there is one
2821  TTreeFormula *select = 0;
2822  if (strlen(selection)) {
2823  select = new TTreeFormula("Selection",selection,fTree);
2824  if (!select) return 0;
2825  if (!select->GetNdim()) { delete select; return 0; }
2826  fFormulaList->Add(select);
2827  }
2828 
2829  // if varexp is empty, take first 8 columns by default
2830  int allvar = 0;
2831  if (varexp && !strcmp(varexp, "*")) { ncols = nleaves; allvar = 1; }
2832  if (nch == 0 || allvar) {
2833  for (i=0;i<ncols;i++) {
2834  cnames.push_back( ((TLeaf*)leaves->At(i))->GetName() );
2835  }
2836  } else {
2837  // otherwise select only the specified columns
2838  ncols = fSelector->SplitNames(varexp,cnames);
2839  }
2840  var = new TTreeFormula* [ncols];
2841 
2842  // create the TreeFormula objects corresponding to each column
2843  for (i=0;i<ncols;i++) {
2844  var[i] = new TTreeFormula("Var1",cnames[i].Data(),fTree);
2845  fFormulaList->Add(var[i]);
2846  }
2847 
2848  // fill header info into result object
2849  TTreeResult *res = new TTreeResult(ncols);
2850  for (i = 0; i < ncols; i++) {
2851  res->AddField(i, var[i]->PrintValue(-1));
2852  }
2853 
2854  //*-*- Create a TreeFormulaManager to coordinate the formulas
2855  TTreeFormulaManager *manager=0;
2856  if (fFormulaList->LastIndex()>=0) {
2857  manager = new TTreeFormulaManager;
2858  for(i=0;i<=fFormulaList->LastIndex();i++) {
2859  manager->Add((TTreeFormula*)fFormulaList->At(i));
2860  }
2861  manager->Sync();
2862  }
2863 
2864  // loop on all selected entries
2865  const char *aresult;
2866  Int_t len;
2867  char *arow = new char[ncols*50];
2868  fSelectedRows = 0;
2869  Int_t tnumber = -1;
2870  Int_t *fields = new Int_t[ncols];
2871  for (entry=firstentry;entry<firstentry+nentries;entry++) {
2872  entryNumber = fTree->GetEntryNumber(entry);
2873  if (entryNumber < 0) break;
2874  Long64_t localEntry = fTree->LoadTree(entryNumber);
2875  if (localEntry < 0) break;
2876  if (tnumber != fTree->GetTreeNumber()) {
2877  tnumber = fTree->GetTreeNumber();
2878  for (i=0;i<ncols;i++) var[i]->UpdateFormulaLeaves();
2879  }
2880 
2881  Int_t ndata = 1;
2882  if (manager && manager->GetMultiplicity()) {
2883  ndata = manager->GetNdata();
2884  }
2885 
2886  if (select) {
2887  select->GetNdata();
2888  if (select->EvalInstance(0) == 0) continue;
2889  }
2890 
2891  Bool_t loaded = kFALSE;
2892  for(int inst=0;inst<ndata;inst++) {
2893  if (select) {
2894  if (select->EvalInstance(inst) == 0) {
2895  continue;
2896  }
2897  }
2898 
2899  if (inst==0) loaded = kTRUE;
2900  else if (!loaded) {
2901  // EvalInstance(0) always needs to be called so that
2902  // the proper branches are loaded.
2903  for (i=0;i<ncols;i++) {
2904  var[i]->EvalInstance(0);
2905  }
2906  loaded = kTRUE;
2907  }
2908  for (i=0;i<ncols;i++) {
2909  aresult = var[i]->PrintValue(0,inst);
2910  len = strlen(aresult)+1;
2911  if (i == 0) {
2912  memcpy(arow,aresult,len);
2913  fields[i] = len;
2914  } else {
2915  memcpy(arow+fields[i-1],aresult,len);
2916  fields[i] = fields[i-1] + len;
2917  }
2918  }
2919  res->AddRow(new TTreeRow(ncols,fields,arow));
2920  fSelectedRows++;
2921  }
2922  }
2923 
2924  // delete temporary objects
2925  fFormulaList->Clear();
2926  // The TTreeFormulaManager is deleted by the last TTreeFormula.
2927  delete [] fields;
2928  delete [] arow;
2929  delete [] var;
2930 
2931  return res;
2932 }
2933 
2934 ////////////////////////////////////////////////////////////////////////////////
2935 /// Set number of entries to estimate variable limits.
2936 
2938 {
2940 }
2941 
2942 ////////////////////////////////////////////////////////////////////////////////
2943 /// Start the TTreeViewer on this TTree.
2944 ///
2945 /// - ww is the width of the canvas in pixels
2946 /// - wh is the height of the canvas in pixels
2947 
2949 {
2950  if (gROOT->IsBatch()) {
2951  Warning("StartViewer", "viewer cannot run in batch mode");
2952  return;
2953  }
2954 
2955  if (ww || wh) { } // use unused variables
2956  TPluginHandler *h;
2957  if ((h = gROOT->GetPluginManager()->FindHandler("TVirtualTreeViewer"))) {
2958  if (h->LoadPlugin() == -1)
2959  return;
2960  h->ExecPlugin(1,fTree);
2961  }
2962 }
2963 
2964 ////////////////////////////////////////////////////////////////////////////////
2965 /// Unbinned fit of one or more variable(s) from a Tree.
2966 ///
2967 /// funcname is a TF1 function.
2968 ///
2969 /// See TTree::Draw for explanations of the other parameters.
2970 ///
2971 /// Fit the variable varexp using the function funcname using the
2972 /// selection cuts given by selection.
2973 ///
2974 /// The list of fit options is given in parameter option.
2975 ///
2976 /// - option = "Q" Quiet mode (minimum printing)
2977 /// - option = "V" Verbose mode (default is between Q and V)
2978 /// - option = "E" Perform better Errors estimation using Minos technique
2979 /// - option = "M" More. Improve fit results
2980 /// - option = "D" Draw the projected histogram with the fitted function
2981 /// normalized to the number of selected rows
2982 /// and multiplied by the bin width
2983 ///
2984 /// You can specify boundary limits for some or all parameters via
2985 /// ~~~{.cpp}
2986 /// func->SetParLimits(p_number, parmin, parmax);
2987 /// ~~~
2988 /// if parmin>=parmax, the parameter is fixed
2989 ///
2990 /// Note that you are not forced to fix the limits for all parameters.
2991 /// For example, if you fit a function with 6 parameters, you can do:
2992 /// ~~~{.cpp}
2993 /// func->SetParameters(0,3.1,1.e-6,0.1,-8,100);
2994 /// func->SetParLimits(4,-10,-4);
2995 /// func->SetParLimits(5, 1,1);
2996 /// ~~~
2997 /// With this setup, parameters 0->3 can vary freely
2998 /// - Parameter 4 has boundaries [-10,-4] with initial value -8
2999 /// - Parameter 5 is fixed to 100.
3000 ///
3001 /// For the fit to be meaningful, the function must be self-normalized.
3002 ///
3003 /// i.e. It must have the same integral regardless of the parameter
3004 /// settings. Otherwise the fit will effectively just maximize the
3005 /// area.
3006 ///
3007 /// It is mandatory to have a normalization variable
3008 /// which is fixed for the fit. e.g.
3009 /// ~~~{.cpp}
3010 /// TF1* f1 = new TF1("f1", "gaus(0)/sqrt(2*3.14159)/[2]", 0, 5);
3011 /// f1->SetParameters(1, 3.1, 0.01);
3012 /// f1->SetParLimits(0, 1, 1); // fix the normalization parameter to 1
3013 /// data->UnbinnedFit("f1", "jpsimass", "jpsipt>3.0");
3014 /// ~~~
3015 ///
3016 /// 1, 2 and 3 Dimensional fits are supported.
3017 /// See also TTree::Fit
3018 ///
3019 /// ### Return status
3020 ///
3021 /// The function return the status of the fit in the following form
3022 /// ~~~{.cpp}
3023 /// fitResult = migradResult + 10*minosResult + 100*hesseResult + 1000*improveResult
3024 /// ~~~
3025 /// - The fitResult is 0 is the fit is OK.
3026 /// - The fitResult is negative in case of an error not connected with the fit.
3027 /// - The number of entries used in the fit can be obtained via
3028 /// ~~~{.cpp}
3029 /// mytree.GetSelectedRows();
3030 /// ~~~
3031 /// - If the number of selected entries is null the function returns -1
3032 ///
3033 /// new implementation using new Fitter classes
3034 
3035 Int_t TTreePlayer::UnbinnedFit(const char *funcname ,const char *varexp, const char *selection,Option_t *option ,Long64_t nentries, Long64_t firstentry)
3036 {
3037  // function is given by name, find it in gROOT
3038  TF1* fitfunc = (TF1*)gROOT->GetFunction(funcname);
3039  if (!fitfunc) { Error("UnbinnedFit", "Unknown function: %s",funcname); return 0; }
3040 
3041  Int_t npar = fitfunc->GetNpar();
3042  if (npar <=0) { Error("UnbinnedFit", "Illegal number of parameters = %d",npar); return 0; }
3043 
3044  // Spin through the data to select out the events of interest
3045  // Make sure that the arrays V1,etc are created large enough to accommodate
3046  // all entries
3047  Long64_t oldEstimate = fTree->GetEstimate();
3048  Long64_t nent = fTree->GetEntriesFriend();
3050 
3051  // build FitOptions
3052  TString opt = option;
3053  opt.ToUpper();
3054  Foption_t fitOption;
3055  if (opt.Contains("Q")) fitOption.Quiet = 1;
3056  if (opt.Contains("V")){fitOption.Verbose = 1; fitOption.Quiet = 0;}
3057  if (opt.Contains("E")) fitOption.Errors = 1;
3058  if (opt.Contains("M")) fitOption.More = 1;
3059  if (!opt.Contains("D")) fitOption.Nograph = 1; // what about 0
3060  // could add range and automatic normalization of functions and gradient
3061 
3062  TString drawOpt = "goff";
3063  if (!fitOption.Nograph) drawOpt = "";
3064  Long64_t nsel = DrawSelect(varexp, selection,drawOpt, nentries, firstentry);
3065 
3066  if (!fitOption.Nograph && GetSelectedRows() <= 0 && GetDimension() > 4) {
3067  Info("UnbinnedFit","Ignore option D with more than 4 variables");
3068  nsel = DrawSelect(varexp, selection,"goff", nentries, firstentry);
3069  }
3070 
3071  //if no selected entries return
3072  Long64_t nrows = GetSelectedRows();
3073 
3074  if (nrows <= 0) {
3075  Error("UnbinnedFit", "Cannot fit: no entries selected");
3076  return -1;
3077  }
3078 
3079  // Check that function has same dimension as number of variables
3080  Int_t ndim = GetDimension();
3081  // do not check with TF1::GetNdim() since it returns 1 for TF1 classes created with
3082  // a C function with larger dimension
3083 
3084 
3085  // use pointer stored in the tree (not copy the data in)
3086  std::vector<double *> vlist(ndim);
3087  for (int i = 0; i < ndim; ++i)
3088  vlist[i] = fSelector->GetVal(i);
3089 
3090  // fill the fit data object
3091  // the object will be then managed by the fitted classes - however it will be invalid when the
3092  // data pointers (given by fSelector->GetVal() ) wil be invalidated
3093  ROOT::Fit::UnBinData * fitdata = new ROOT::Fit::UnBinData(nrows, ndim, vlist.begin());
3094 
3095 
3096 
3097  ROOT::Math::MinimizerOptions minOption;
3098  TFitResultPtr ret = ROOT::Fit::UnBinFit(fitdata,fitfunc, fitOption, minOption);
3099 
3100  //reset estimate
3101  fTree->SetEstimate(oldEstimate);
3102 
3103  //if option "D" is specified, draw the projected histogram
3104  //with the fitted function normalized to the number of selected rows
3105  //and multiplied by the bin width
3106  if (!fitOption.Nograph && fHistogram) {
3107  if (fHistogram->GetDimension() < 2) {
3108  TH1 *hf = (TH1*)fHistogram->Clone("unbinnedFit");
3109  hf->SetLineWidth(3);
3110  hf->Reset();
3111  Int_t nbins = fHistogram->GetXaxis()->GetNbins();
3112  Double_t norm = ((Double_t)nsel)*fHistogram->GetXaxis()->GetBinWidth(1);
3113  for (Int_t bin=1;bin<=nbins;bin++) {
3114  Double_t func = norm*fitfunc->Eval(hf->GetBinCenter(bin));
3115  hf->SetBinContent(bin,func);
3116  }
3117  fHistogram->GetListOfFunctions()->Add(hf,"lsame");
3118  }
3119  fHistogram->Draw();
3120  }
3121 
3122 
3123  return int(ret);
3124 
3125 }
3126 
3127 ////////////////////////////////////////////////////////////////////////////////
3128 /// this function is called by TChain::LoadTree when a new Tree is loaded.
3129 /// Because Trees in a TChain may have a different list of leaves, one
3130 /// must update the leaves numbers in the TTreeFormula used by the TreePlayer.
3131 
3133 {
3134  if (fSelector) fSelector->Notify();
3135  if (fSelectorUpdate){
3136  //If the selector is writing into a TEntryList, the entry list's
3137  //sublists need to be changed according to the loaded tree
3138  if (fSelector==fSelectorUpdate) {
3139  //FIXME: should be more consistent with selector from file
3140  TObject *obj = fSelector->GetObject();
3141  if (obj){
3144  }
3145  }
3146  }
3149  TEntryList *elist=0;
3150  while ((elist=(TEntryList*)next())){
3151  if (elist->InheritsFrom(TEntryList::Class())){
3152  elist->SetTree(fTree->GetTree());
3153  }
3154  }
3155  }
3156  }
3157 
3158  if (fFormulaList->GetSize()) {
3159  TObjLink *lnk = fFormulaList->FirstLink();
3160  while (lnk) {
3161  lnk->GetObject()->Notify();
3162  lnk = lnk->Next();
3163  }
3164  }
3165 }
TClass::GetStreamerInfo
TVirtualStreamerInfo * GetStreamerInfo(Int_t version=0) const
returns a pointer to the TVirtualStreamerInfo object for version If the object does not exist,...
Definition: TClass.cxx:4504
TStyle::SetCanvasPreferGL
void SetCanvasPreferGL(Bool_t prefer=kTRUE)
Definition: TStyle.h:325
TTreeResult::AddRow
void AddRow(TSQLRow *row)
Adopt a row to result set.
Definition: TTreeResult.cxx:154
l
auto * l
Definition: textangle.C:4
TSelectorDraw::Notify
virtual Bool_t Notify()
This function is called at the first entry of a new tree in a chain.
Definition: TSelectorDraw.cxx:1154
TPrincipal.h
n
const Int_t n
Definition: legend1.C:16
TTree::GetScanField
virtual Int_t GetScanField() const
Definition: TTree.h:506
TTree::GetEntriesFriend
virtual Long64_t GetEntriesFriend() const
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:5411
TBranch::GetNleaves
Int_t GetNleaves() const
Definition: TBranch.h:245
TBranchElement::GetType
Int_t GetType() const
Definition: TBranchElement.h:202
first
Definition: first.py:1
TH1::kNoAxis
@ kNoAxis
NOTE: Must always be 0 !!!
Definition: TH1.h:70
TTreeFormulaManager::Sync
virtual Bool_t Sync()
Synchronize all the formulae.
Definition: TTreeFormulaManager.cxx:219
TSelector::GetStatus
virtual Long64_t GetStatus() const
Definition: TSelector.h:58
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
TTreeIndex.h
TTreePlayer.h
principal
Definition: principal.py:1
TObjArray::Delete
virtual void Delete(Option_t *option="")
Remove all objects from the array AND delete all heap based objects.
Definition: TObjArray.cxx:356
TTreeFormula::IsInteger
virtual Bool_t IsInteger(Bool_t fast=kTRUE) const
Return TRUE if the formula corresponds to one single Tree leaf and this leaf is short,...
Definition: TTreeFormula.cxx:4576
TEventList
Definition: TEventList.h:31
snprintf
#define snprintf
Definition: civetweb.c:1540
TObjArray
Definition: TObjArray.h:37
TSelector
Definition: TSelector.h:31
R__GetBranchPointerName
static TString R__GetBranchPointerName(TLeaf *leaf, Bool_t replace=kTRUE)
Return the name of the branch pointer needed by MakeClass/MakeSelector.
Definition: TTreePlayer.cxx:637
TTreePlayer::Scan
virtual Long64_t Scan(const char *varexp, const char *selection, Option_t *option, Long64_t nentries, Long64_t firstentry)
Loop on Tree and print entries passing selection.
Definition: TTreePlayer.cxx:2425
TDirectory.h
TTreePlayer::Fit
virtual Int_t Fit(const char *formula, const char *varexp, const char *selection, Option_t *option, Option_t *goption, Long64_t nentries, Long64_t firstentry)
Fit a projected item(s) from a Tree.
Definition: TTreePlayer.cxx:559
Foption_t::Errors
int Errors
Definition: Foption.h:43
TChainIndex
Definition: TChainIndex.h:40
Foption
R__EXTERN Foption_t Foption
Definition: TTreePlayer.cxx:88
TRefArrayProxy
Definition: TRefArrayProxy.h:22
Foption_t
Definition: Foption.h:24
TStreamerElement::GetTypeName
const char * GetTypeName() const
Definition: TStreamerElement.h:123
TLeafObject.h
TMath::Max
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:212
TStreamerInfo.h
TTree::SetScanField
virtual void SetScanField(Int_t n=50)
Definition: TTree.h:637
TSelector::Init
virtual void Init(TTree *)
Definition: TSelector.h:53
TSelectorDraw::GetDrawFlag
virtual Long64_t GetDrawFlag() const
Definition: TSelectorDraw.h:83
kNPOS
const Ssiz_t kNPOS
Definition: RtypesCore.h:115
TBranchElement
Definition: TBranchElement.h:39
tFitter
TVirtualFitter * tFitter
Definition: TTreePlayer.cxx:90
TChain::GetTreeOffset
Long64_t * GetTreeOffset() const
Definition: TChain.h:117
TTreePlayer::fTree
TTree * fTree
Definition: TTreePlayer.h:44
TList::FindObject
virtual TObject * FindObject(const char *name) const
Find an object in this list using its name.
Definition: TList.cxx:577
ROOT::Fit::UnBinData
Class describing the unbinned data sets (just x coordinates values) of any dimensions.
Definition: UnBinData.h:52
TList::Delete
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: TList.cxx:469
TVirtualIndex
Definition: TVirtualIndex.h:30
TString::Data
const char * Data() const
Definition: TString.h:369
tree
Definition: tree.py:1
TLeafS.h
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
Form
char * Form(const char *fmt,...)
TTreePlayer::fSelector
TSelectorDraw * fSelector
Pointer to histogram used for the projection.
Definition: TTreePlayer.h:50
TTreePlayer::Query
virtual TSQLResult * Query(const char *varexp, const char *selection, Option_t *option, Long64_t nentries, Long64_t firstentry)
Loop on Tree and return TSQLResult object containing entries passing selection.
Definition: TTreePlayer.cxx:2804
TNamed::GetTitle
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:54
TTreePlayer::GetNameByIndex
const char * GetNameByIndex(TString &varexp, Int_t *index, Int_t colindex)
Set to the selector address when it's entry list needs to be updated by the UpdateFormulaLeaves funct...
Definition: TTreePlayer.cxx:622
TSelector::Terminate
virtual void Terminate()
Definition: TSelector.h:71
TObjString.h
TProcessEventTimer
Definition: TSystem.h:257
TSelector::SlaveTerminate
virtual void SlaveTerminate()
Definition: TSelector.h:70
TTreePlayer::DrawSelect
virtual Long64_t DrawSelect(const char *varexp, const char *selection, Option_t *option, Long64_t nentries, Long64_t firstentry)
Draw expression varexp for specified entries that matches the selection.
Definition: TTreePlayer.cxx:337
TStreamerElement.h
TBranch::GetListOfBranches
TObjArray * GetListOfBranches()
Definition: TBranch.h:242
TF1::GetNpar
virtual Int_t GetNpar() const
Definition: TF1.h:477
Foption_t::Verbose
int Verbose
Definition: Foption.h:36
TSelector::GetSelector
static TSelector * GetSelector(const char *filename)
The code in filename is loaded (interpreted or compiled, see below), filename must contain a valid cl...
Definition: TSelector.cxx:142
HFitInterface.h
TObject::Info
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:864
Long64_t
long long Long64_t
Definition: RtypesCore.h:73
TObject::Error
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:890
TTree::CloneTree
virtual TTree * CloneTree(Long64_t nentries=-1, Option_t *option="")
Create a clone of this tree and copy nentries.
Definition: TTree.cxx:3089
TTree::GetEntryList
virtual TEntryList * GetEntryList()
Returns the entry list assigned to this tree.
Definition: TTree.cxx:5754
TTree
Definition: TTree.h:79
TSelectorEntries.h
TCollection::SetOwner
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
Definition: TCollection.cxx:746
TTreeFormula::GetManager
TTreeFormulaManager * GetManager() const
Definition: TTreeFormula.h:189
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:71
TLeaf::GetTypeName
virtual const char * GetTypeName() const
Definition: TLeaf.h:138
Foption_t::Nograph
int Nograph
Definition: Foption.h:48
TStyle::GetNumberOfColors
Int_t GetNumberOfColors() const
Return number of colors in the color palette.
Definition: TStyle.cxx:1124
TTreeFormula.h
TFile::GetFileBytesRead
static Long64_t GetFileBytesRead()
Static function returning the total number of bytes read from all files.
Definition: TFile.cxx:4413
TClass::IsLoaded
Bool_t IsLoaded() const
Return true if the shared library of this class is currently in the a process's memory.
Definition: TClass.cxx:5726
TStyle.h
TGeant4Unit::s
static constexpr double s
Definition: TGeant4SystemOfUnits.h:168
TDatime::AsString
const char * AsString() const
Return the date & time as a string (ctime() format).
Definition: TDatime.cxx:102
TH1::SetCanExtend
virtual UInt_t SetCanExtend(UInt_t extendBitMask)
Make the histogram axes extendable / not extendable according to the bit mask returns the previous bi...
Definition: TH1.cxx:6290
TSelectorDraw::GetVar3
TTreeFormula * GetVar3() const
Definition: TSelectorDraw.h:97
TString::Contains
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
TH1::SetBinContent
virtual void SetBinContent(Int_t bin, Double_t content)
Set bin content see convention for numbering bins in TH1::GetBin In case the bin number is greater th...
Definition: TH1.cxx:8677
TSeqCollection::LastIndex
Int_t LastIndex() const
Definition: TSeqCollection.h:61
TObjArray::GetEntries
Int_t GetEntries() const
Return the number of objects in array (i.e.
Definition: TObjArray.cxx:523
TString::Length
Ssiz_t Length() const
Definition: TString.h:410
TDirectory::TContext
Definition: TDirectory.h:47
TClass.h
TTree::GetMaxEntryLoop
virtual Long64_t GetMaxEntryLoop() const
Definition: TTree.h:492
TLeafD.h
nentries
int nentries
Definition: THbookFile.cxx:91
TH1::GetListOfFunctions
TList * GetListOfFunctions() const
Definition: TH1.h:240
TObjArray::UncheckedAt
TObject * UncheckedAt(Int_t i) const
Definition: TObjArray.h:90
TTreePlayer::Process
virtual Long64_t Process(const char *filename, Option_t *option, Long64_t nentries, Long64_t firstentry)
Process this tree executing the TSelector code in the specified filename.
Definition: TTreePlayer.cxx:2185
TObjArray::At
TObject * At(Int_t idx) const
Definition: TObjArray.h:166
TBranch::GetClassName
virtual const char * GetClassName() const
Return the name of the user class whose content is stored in this branch, if any.
Definition: TBranch.cxx:1303
TEntryList::SetTree
virtual void SetTree(const TTree *tree)
If a list for a tree with such name and filename exists, sets it as the current sublist If not,...
Definition: TEntryList.cxx:1194
TProfile.h
TString
Definition: TString.h:136
ROOT::Fit::UnBinFit
TFitResultPtr UnBinFit(ROOT::Fit::UnBinData *data, TF1 *f1, Foption_t &option, const ROOT::Math::MinimizerOptions &moption)
fit an unbin data set (from tree or from histogram buffer) using a TF1 pointer and fit options.
Definition: HFitImpl.cxx:816
TVirtualFitter.h
MinimizerOptions.h
TClass::HasInterpreterInfo
Bool_t HasInterpreterInfo() const
Definition: TClass.h:367
Bool_t
bool Bool_t
Definition: RtypesCore.h:63
Foption.h
UnBinData.h
TVirtualFitter
Definition: TVirtualFitter.h:29
TChainIndex.h
TTreePlayer::SetEstimate
virtual void SetEstimate(Long64_t n)
Set number of entries to estimate variable limits.
Definition: TTreePlayer.cxx:2937
TSelector::Begin
virtual void Begin(TTree *)
Definition: TSelector.h:54
TObject::InheritsFrom
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:445
TTree::GetEntry
virtual Int_t GetEntry(Long64_t entry=0, Int_t getall=0)
Read all branches of entry and return total number of bytes read.
Definition: TTree.cxx:5537
TTree::GetEntryNumber
virtual Long64_t GetEntryNumber(Long64_t entry) const
Return entry number corresponding to entry.
Definition: TTree.cxx:5765
TFile.h
TObjString::GetName
const char * GetName() const
Returns name of object.
Definition: TObjString.h:44
TTreePlayer::GetDimension
virtual Int_t GetDimension() const
Definition: TTreePlayer.h:74
TTreePlayer::MakeReader
virtual Int_t MakeReader(const char *classname, Option_t *option)
Generate skeleton selector class for this tree.
Definition: TTreePlayer.cxx:1973
TTreePlayer::Principal
TPrincipal * Principal(const char *varexp, const char *selection, Option_t *option, Long64_t nentries, Long64_t firstentry)
Interface to the Principal Components Analysis class.
Definition: TTreePlayer.cxx:2003
TSelectorDraw::GetAction
virtual Int_t GetAction() const
Definition: TSelectorDraw.h:80
bool
TObjArray::Last
TObject * Last() const
Return the object in the last filled slot. Returns 0 if no entries.
Definition: TObjArray.cxx:506
TString::ReplaceAll
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition: TString.h:692
THLimitsFinder.h
TClonesArray.h
TTree::SetEstimate
virtual void SetEstimate(Long64_t nentries=1000000)
Set number of entries to estimate variable limits.
Definition: TTree.cxx:8925
TTreeFormula::PrintValue
virtual char * PrintValue(Int_t mode=0) const
Return value of variable as a string.
Definition: TTreeFormula.cxx:4779
TObjArray::Add
void Add(TObject *obj)
Definition: TObjArray.h:74
TSQLResult
Definition: TSQLResult.h:32
TPolyMarker3D.h
TSelectorDraw::GetOldHistogram
TH1 * GetOldHistogram() const
Definition: TSelectorDraw.h:87
TTree::GetCacheSize
virtual Long64_t GetCacheSize() const
Definition: TTree.h:448
TSystem::SplitAclicMode
virtual TString SplitAclicMode(const char *filename, TString &mode, TString &args, TString &io) const
This method split a filename of the form:
Definition: TSystem.cxx:4267
TTreePlayer::GetSelectedRows
virtual Long64_t GetSelectedRows() const
Definition: TTreePlayer.h:81
TTreePlayer::fSelectorClass
TClass * fSelectorClass
Pointer to a user defined selector created by this TTreePlayer object.
Definition: TTreePlayer.h:52
TTreeFormula::UpdateFormulaLeaves
virtual void UpdateFormulaLeaves()
This function is called TTreePlayer::UpdateFormulaLeaves, itself called by TChain::LoadTree when a ne...
Definition: TTreeFormula.cxx:5060
TChainElement
Definition: TChainElement.h:28
TString::Last
Ssiz_t Last(char c) const
Find last occurrence of a character c.
Definition: TString.cxx:892
TTreePlayer::DrawScript
virtual Long64_t DrawScript(const char *wrapperPrefix, const char *macrofilename, const char *cutfilename, Option_t *option, Long64_t nentries, Long64_t firstentry)
Draw the result of a C++ script.
Definition: TTreePlayer.cxx:293
TTreePlayer::fScanFileName
const char * fScanFileName
Definition: TTreePlayer.h:46
TProfile2D.h
TSelectorEntries
Definition: TSelectorEntries.h:34
TH1::GetDimension
virtual Int_t GetDimension() const
Definition: TH1.h:279
TStyle::GetCanvasPreferGL
Bool_t GetCanvasPreferGL() const
Definition: TStyle.h:179
TSelector::ResetAbort
virtual void ResetAbort()
Definition: TSelector.h:74
TROOT.h
TTreePlayer::MakeProxy
virtual Int_t MakeProxy(const char *classname, const char *macrofilename=0, const char *cutfilename=0, const char *option=0, Int_t maxUnrolling=3)
Generate a skeleton analysis class for this Tree using TBranchProxy.
Definition: TTreePlayer.cxx:1913
TH1::Clone
TObject * Clone(const char *newname=0) const
Make a complete copy of the underlying object.
Definition: TH1.cxx:2664
TString::ToUpper
void ToUpper()
Change string to upper case.
Definition: TString.cxx:1138
TObjString
Definition: TObjString.h:28
TTree::GetTree
virtual TTree * GetTree() const
Definition: TTree.h:512
TObject::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:359
TTreePlayer::UpdateFormulaLeaves
virtual void UpdateFormulaLeaves()
this function is called by TChain::LoadTree when a new Tree is loaded.
Definition: TTreePlayer.cxx:3132
TTreePlayer
Definition: TTreePlayer.h:37
TBranch
Definition: TBranch.h:89
TTree::GetBranch
virtual TBranch * GetBranch(const char *name)
Return pointer to the branch with the given name in this tree or its friends.
Definition: TTree.cxx:5210
TPluginHandler
Definition: TPluginManager.h:101
TRefArrayProxy.h
TTree::GetCurrentFile
TFile * GetCurrentFile() const
Return pointer to the current file.
Definition: TTree.cxx:5378
TList::At
virtual TObject * At(Int_t idx) const
Returns the object at position idx. Returns 0 if idx is out of range.
Definition: TList.cxx:356
TTreePlayer::SetTree
virtual void SetTree(TTree *t)
Definition: TTreePlayer.h:124
TString::Form
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2289
TSelector::kAbortProcess
@ kAbortProcess
Definition: TSelector.h:34
TSelector::Process
virtual Bool_t Process(Long64_t)
Definition: TSelector.cxx:330
TSelector::kAbortFile
@ kAbortFile
Definition: TSelector.h:34
TTreeReaderGenerator.h
TTreeFormulaManager
Definition: TTreeFormulaManager.h:30
TSelector::GetAbort
virtual EAbort GetAbort() const
Definition: TSelector.h:73
TTreePlayer::MakeCode
virtual Int_t MakeCode(const char *filename)
Generate skeleton function for this Tree.
Definition: TTreePlayer.cxx:1548
Option_t
const typedef char Option_t
Definition: RtypesCore.h:66
TTreeCache.h
TChain.h
TTreePlayer::fSelectorFromFile
TSelector * fSelectorFromFile
Pointer to current selector.
Definition: TTreePlayer.h:51
TTreeFormula::GetNdata
virtual Int_t GetNdata()
Return number of available instances in the formula.
Definition: TTreeFormula.cxx:4438
TBranchElement.h
TList::FirstLink
virtual TObjLink * FirstLink() const
Definition: TList.h:108
gStyle
R__EXTERN TStyle * gStyle
Definition: TStyle.h:412
TSystem.h
TObject::Notify
virtual Bool_t Notify()
This method must be overridden to handle object notification.
Definition: TObject.cxx:508
TFitResultPtr
Definition: TFitResultPtr.h:32
TTreePlayer::CopyTree
virtual TTree * CopyTree(const char *selection, Option_t *option, Long64_t nentries, Long64_t firstentry)
Copy a Tree with selection, make a clone of this Tree header, then copy the selected entries.
Definition: TTreePlayer.cxx:185
TBranchElement::IsBranchFolder
Bool_t IsBranchFolder() const
Definition: TBranchElement.h:210
TPolyMarker3D::Draw
virtual void Draw(Option_t *option="")
Draws 3-D polymarker with its current attributes.
Definition: TPolyMarker3D.cxx:265
gROOTMutex
R__EXTERN TVirtualMutex * gROOTMutex
Definition: TROOT.h:61
TLeafI.h
h
#define h(i)
Definition: RSha256.hxx:124
TLeaf
Definition: TLeaf.h:57
TPolyMarker3D
Definition: TPolyMarker3D.h:32
TObject::SetBit
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:696
TTree::Process
virtual Long64_t Process(const char *filename, Option_t *option="", Long64_t nentries=kMaxEntries, Long64_t firstentry=0)
Process this tree executing the TSelector code in the specified filename.
Definition: TTree.cxx:7321
TTree::LoadTree
virtual Long64_t LoadTree(Long64_t entry)
Set current entry.
Definition: TTree.cxx:6366
TTreePlayer::fInput
TList * fInput
Pointer to the actual class of the TSelectorFromFile.
Definition: TTreePlayer.h:53
TLeaf::GetLeafCount
virtual TLeaf * GetLeafCount() const
If this leaf stores a variable-sized array or a multi-dimensional array whose last dimension has vari...
Definition: TLeaf.h:120
TObjArray::GetEntriesFast
Int_t GetEntriesFast() const
Definition: TObjArray.h:64
TTreePlayer::StartViewer
virtual void StartViewer(Int_t ww, Int_t wh)
Start the TTreeViewer on this TTree.
Definition: TTreePlayer.cxx:2948
TTree::GetTimerInterval
virtual Int_t GetTimerInterval() const
Definition: TTree.h:509
TTree::SetNotify
virtual void SetNotify(TObject *obj)
Sets the address of the object to be notified when the tree is loaded.
Definition: TTree.h:632
TLeafF.h
TString::Remove
TString & Remove(Ssiz_t pos)
Definition: TString.h:673
TNamed
Definition: TNamed.h:29
TTreeFormulaManager.h
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
TTreePlayer::UnbinnedFit
virtual Int_t UnbinnedFit(const char *formula, const char *varexp, const char *selection, Option_t *option, Long64_t nentries, Long64_t firstentry)
Unbinned fit of one or more variable(s) from a Tree.
Definition: TTreePlayer.cxx:3035
TString::Append
TString & Append(const char *cs)
Definition: TString.h:564
TH1::GetBinCenter
virtual Double_t GetBinCenter(Int_t bin) const
Return bin center for 1D histogram.
Definition: TH1.cxx:8596
TTreeFormula::EvalInstance
T EvalInstance(Int_t i=0, const char *stringStack[]=0)
Evaluate this treeformula.
Definition: TTreeFormula.cxx:3930
TTree::SetEntryList
virtual void SetEntryList(TEntryList *list, Option_t *opt="")
Set an EntryList.
Definition: TTree.cxx:8861
TLeafC.h
TTreeFormulaManager::UpdateFormulaLeaves
virtual void UpdateFormulaLeaves()
This function could be called TTreePlayer::UpdateFormulaLeaves, itself called by TChain::LoadTree whe...
Definition: TTreeFormulaManager.cxx:291
TTree::GetEstimate
virtual Long64_t GetEstimate() const
Definition: TTree.h:462
TPrincipal
Definition: TPrincipal.h:21
ROOT::Internal::TTreeReaderGenerator
Definition: TTreeReaderGenerator.h:85
TSelectorDraw::SplitNames
virtual UInt_t SplitNames(const TString &varexp, std::vector< TString > &names)
Build Index array for names in varexp.
Definition: TSelectorDraw.cxx:1125
TLeafObject
Definition: TLeafObject.h:31
TBranchElement::GetClassName
virtual const char * GetClassName() const
Return the name of the user class whose content is stored in this branch, if any.
Definition: TBranchElement.h:186
TClass::GetDeclFileName
const char * GetDeclFileName() const
Return name of the file containing the declaration of this class.
Definition: TClass.cxx:3342
gDirectory
#define gDirectory
Definition: TDirectory.h:236
TChain::GetNtrees
Int_t GetNtrees() const
Definition: TChain.h:95
TChain::LoadTree
virtual Long64_t LoadTree(Long64_t entry)
Find the tree which contains entry, and set it as the current tree.
Definition: TChain.cxx:1284
TSelector::Notify
virtual Bool_t Notify()
This method must be overridden to handle object notification.
Definition: TSelector.h:56
TTreePlayer::fHistogram
TH1 * fHistogram
Definition: TTreePlayer.h:49
TTreeFormula
Definition: TTreeFormula.h:58
TProcessEventTimer::ProcessEvents
Bool_t ProcessEvents()
Process events if timer did time out.
Definition: TSystem.cxx:90
TTree::Draw
virtual void Draw(Option_t *opt)
Default Draw method for all objects.
Definition: TTree.h:427
TSelector::SetInputList
virtual void SetInputList(TList *input)
Definition: TSelector.h:66
ROOT::Math::MinimizerOptions
Minimizer options.
Definition: MinimizerOptions.h:42
R__LOCKGUARD
#define R__LOCKGUARD(mutex)
Definition: TVirtualMutex.h:104
TVirtualPad.h
TTreeFormulaManager::GetNdata
virtual Int_t GetNdata(Bool_t forceLoadDim=kFALSE)
Return number of available instances in the formulas.
Definition: TTreeFormulaManager.cxx:122
TSelectorDraw::GetCleanElist
virtual Bool_t GetCleanElist() const
Definition: TSelectorDraw.h:81
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:2925
TClass::AdoptReferenceProxy
void AdoptReferenceProxy(TVirtualRefProxy *proxy)
Adopt the Reference proxy pointer to indicate that this class represents a reference.
Definition: TClass.cxx:6448
TTreePlayer::fDimension
Int_t fDimension
Definition: TTreePlayer.h:47
ULong_t
unsigned long ULong_t
Definition: RtypesCore.h:55
TTreePlayer::~TTreePlayer
virtual ~TTreePlayer()
Tree destructor.
Definition: TTreePlayer.cxx:126
TSelectorDraw::SetEstimate
virtual void SetEstimate(Long64_t n)
Set number of entries to estimate variable limits.
Definition: TSelectorDraw.cxx:1343
TTree::GetTreeNumber
virtual Int_t GetTreeNumber() const
Definition: TTree.h:514
TSelector::ProcessCut
virtual Bool_t ProcessCut(Long64_t)
Definition: TSelector.cxx:300
TLeafB.h
TTreeFormulaManager::GetMultiplicity
virtual Int_t GetMultiplicity() const
Definition: TTreeFormulaManager.h:66
TTreePlayer::TTreePlayer
TTreePlayer()
Default Tree constructor.
Definition: TTreePlayer.cxx:97
TNamed::SetTitle
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:164
TVirtualMutex.h
TObject::Warning
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:876
ROOT::Internal::TTreeProxyGenerator
Definition: TTreeProxyGenerator.h:28
TObject::kCanDelete
@ kCanDelete
if object in a list can be deleted
Definition: TObject.h:58
TVirtualMonitoringWriter::SendProcessingStatus
virtual Bool_t SendProcessingStatus(const char *, Bool_t=kFALSE)
Definition: TVirtualMonitoring.h:77
TFile
Definition: TFile.h:54
TSelector::GetOutputList
virtual TList * GetOutputList() const
Definition: TSelector.h:69
TSelectorDraw::GetVar1
TTreeFormula * GetVar1() const
Definition: TSelectorDraw.h:93
Foption_t::More
int More
Definition: Foption.h:44
TDirectory::GetPath
virtual const char * GetPath() const
Returns the full path of the directory.
Definition: TDirectory.cxx:988
TMath::Min
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:180
unsigned int
TTreeCache::SetEntryRange
virtual void SetEntryRange(Long64_t emin, Long64_t emax)
Set the minimum and maximum entry number to be processed this information helps to optimize the numbe...
Definition: TTreeCache.cxx:2086
TTreeProxyGenerator.h
TTree::GetDirectory
TDirectory * GetDirectory() const
Definition: TTree.h:457
TTreePlayer::fSelectorUpdate
TSelector * fSelectorUpdate
Pointer to a list of coordinated list TTreeFormula (used by Scan and Query)
Definition: TTreePlayer.h:55
TEntryList
Definition: TEntryList.h:25
TString::Index
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition: TString.h:639
TSelector::SlaveBegin
virtual void SlaveBegin(TTree *)
Definition: TSelector.h:55
Printf
void Printf(const char *fmt,...)
TRefProxy.h
TObject::IsZombie
R__ALWAYS_INLINE Bool_t IsZombie() const
Definition: TObject.h:134
gSystem
R__EXTERN TSystem * gSystem
Definition: TSystem.h:559
TLeaf::GetLen
virtual Int_t GetLen() const
Return the number of effective elements of this leaf, for the current entry.
Definition: TLeaf.cxx:381
TObjArray::AddAt
virtual void AddAt(TObject *obj, Int_t idx)
Add object at position ids.
Definition: TObjArray.cxx:254
TTreeIndex
Definition: TTreeIndex.h:29
TH1::LabelsDeflate
virtual void LabelsDeflate(Option_t *axis="X")
Reduce the number of bins for the axis passed in the option to the number of bins having a label.
Definition: TH1.cxx:5090
TTreePlayer::BuildIndex
virtual TVirtualIndex * BuildIndex(const TTree *T, const char *majorname, const char *minorname)
Build the index for the tree (see TTree::BuildIndex)
Definition: TTreePlayer.cxx:140
TSelector::SetOption
virtual void SetOption(const char *option)
Definition: TSelector.h:64
TBranch::GetMother
TBranch * GetMother() const
Get our top-level parent branch in the tree.
Definition: TBranch.cxx:1982
TTree::SetCacheSize
virtual Int_t SetCacheSize(Long64_t cachesize=-1)
Set maximum size of the file cache .
Definition: TTree.cxx:8501
TLeaf::GetBranch
TBranch * GetBranch() const
Definition: TLeaf.h:115
TTreePlayer::RecursiveRemove
virtual void RecursiveRemove(TObject *obj)
cleanup pointers in the player pointing to obj
Definition: TTreePlayer.cxx:2339
TObject::Draw
virtual void Draw(Option_t *option="")
Default Draw method for all objects.
Definition: TObject.cxx:197
TTreeCache
A cache to speed-up the reading of ROOT datasets.
Definition: TTreeCache.h:32
TText
Definition: TText.h:22
TLeaf::GetMaximum
virtual Int_t GetMaximum() const
Definition: TLeaf.h:133
Double_t
double Double_t
Definition: RtypesCore.h:59
TSelectorDraw.h
TPluginManager.h
TF1.h
TBranchElement::GetBranchCount2
TBranchElement * GetBranchCount2() const
Definition: TBranchElement.h:183
TObjArray::FindObject
virtual TObject * FindObject(const char *name) const
Find an object in this collection using its name.
Definition: TObjArray.cxx:415
TF1::Eval
virtual Double_t Eval(Double_t x, Double_t y=0, Double_t z=0, Double_t t=0) const
Evaluate this function.
Definition: TF1.cxx:1450
TSelectorDraw::GetVal
virtual Double_t * GetVal(Int_t i) const
Return the last values corresponding to the i-th component of the formula being processed (where the ...
Definition: TSelectorDraw.cxx:1069
BinData.h
TCollection::GetSize
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:182
TTreePlayer::GetEntries
virtual Long64_t GetEntries(const char *selection)
Return the number of entries matching the selection.
Definition: TTreePlayer.cxx:589
TClass
Definition: TClass.h:80
file
Definition: file.py:1
graph
Definition: graph.py:1
gMonitoringWriter
R__EXTERN TVirtualMonitoringWriter * gMonitoringWriter
Definition: TVirtualMonitoring.h:116
TList::Add
virtual void Add(TObject *obj)
Definition: TList.h:87
TObject
Definition: TObject.h:37
TH1::Reset
virtual void Reset(Option_t *option="")
Reset this histogram: contents, errors, etc.
Definition: TH1.cxx:6735
TTreeRow
Definition: TTreeRow.h:29
TTreePlayer::fSelectedRows
Long64_t fSelectedRows
Definition: TTreePlayer.h:48
TH1
Definition: TH1.h:57
TVirtualMonitoring.h
TEntryList.h
TDirectory::GetFile
virtual TFile * GetFile() const
Definition: TDirectory.h:165
TList::Clear
virtual void Clear(Option_t *option="")
Remove all objects from the list.
Definition: TList.cxx:401
TSelector::ProcessFill
virtual void ProcessFill(Long64_t)
Definition: TSelector.cxx:317
TSelector::Version
virtual int Version() const
Definition: TSelector.h:52
ROOT::Math::Chebyshev::T
double T(double x)
Definition: ChebyshevPol.h:52
TBranchObject.h
TPolyMarker.h
gPad
#define gPad
Definition: TVirtualPad.h:287
TIter
Definition: TCollection.h:233
TTree::GetEventList
TEventList * GetEventList() const
Definition: TTree.h:468
ROOT::v5::TFormula::GetNdim
virtual Int_t GetNdim() const
Definition: TFormula.h:237
TTreePlayer::fFormulaList
TList * fFormulaList
input list to the selector
Definition: TTreePlayer.h:54
R__EXTERN
#define R__EXTERN
Definition: DllImport.h:27
TTreePlayer::DeleteSelectorFromFile
void DeleteSelectorFromFile()
Delete any selector created by this object.
Definition: TTreePlayer.cxx:250
TDatime
Definition: TDatime.h:37
TTreeResult
Definition: TTreeResult.h:34
TSelectorDraw::GetObject
TObject * GetObject() const
Definition: TSelectorDraw.h:84
TChain
Definition: TChain.h:33
TSelectorDraw::GetVar2
TTreeFormula * GetVar2() const
Definition: TSelectorDraw.h:95
TH1::Fit
virtual TFitResultPtr Fit(const char *formula, Option_t *option="", Option_t *goption="", Double_t xmin=0, Double_t xmax=0)
Fit histogram with function fname.
Definition: TH1.cxx:3807
TChain::GetLeaf
virtual TLeaf * GetLeaf(const char *branchname, const char *leafname)
Return a pointer to the leaf name in the current tree.
Definition: TChain.cxx:1047
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:53
TRefProxy
Definition: TRefProxy.h:28
TTreePlayer::fScanRedirect
Bool_t fScanRedirect
Pointer to current Tree.
Definition: TTreePlayer.h:45
TTreeRow.h
TF1
1-Dim function class
Definition: TF1.h:212
TTreePlayer::MakeClass
virtual Int_t MakeClass(const char *classname, Option_t *option)
Generate skeleton analysis class for this Tree.
Definition: TTreePlayer.cxx:718
Class
void Class()
Definition: Class.C:29
TH1::GetSumOfWeights
virtual Double_t GetSumOfWeights() const
Return the sum of weights excluding under/overflows.
Definition: TH1.cxx:7425
TTreeResult::AddField
void AddField(Int_t field, const char *fieldname)
Add field name to result set.
Definition: TTreeResult.cxx:142
TString::ToLower
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1125
TBranch::GetListOfLeaves
TObjArray * GetListOfLeaves()
Definition: TBranch.h:243
TH1::GetXaxis
TAxis * GetXaxis()
Get the behaviour adopted by the object about the statoverflows. See EStatOverflows for more informat...
Definition: TH1.h:317
TTreePlayer::GetEntriesToProcess
virtual Long64_t GetEntriesToProcess(Long64_t firstentry, Long64_t nentries) const
return the number of entries to be processed this function checks that nentries is not bigger than th...
Definition: TTreePlayer.cxx:602
TBranchElement::GetStreamerType
Int_t GetStreamerType() const
Definition: TBranchElement.h:203
RooStats::HistFactory::Constraint::GetType
Type GetType(const std::string &Name)
Definition: Systematics.cxx:34
TH1.h
TTree::GetListOfLeaves
virtual TObjArray * GetListOfLeaves()
Definition: TTree.h:484
TTree::GetEntries
virtual Long64_t GetEntries() const
Definition: TTree.h:458
TText.h
TLeafObject::GetClass
TClass * GetClass() const
Definition: TLeafObject.h:59
TEntryList::GetN
virtual Long64_t GetN() const
Definition: TEntryList.h:75
TChainElement.h
TStreamerElement
Definition: TStreamerElement.h:33
ThreadLocalStorage.h
TH1::Scale
virtual void Scale(Double_t c1=1, Option_t *option="")
Multiply this histogram by a constant c1.
Definition: TH1.cxx:6245
TAxis::GetNbins
Int_t GetNbins() const
Definition: TAxis.h:121
ROOT::Internal::TTreeProxyGenerator::GetFileName
const char * GetFileName()
Definition: TTreeProxyGenerator.h:72
TSelectorDraw::GetDimension
virtual Int_t GetDimension() const
Definition: TSelectorDraw.h:82
TFile::GetCacheRead
TFileCacheRead * GetCacheRead(const TObject *tree=nullptr) const
Return a pointer to the current read cache.
Definition: TFile.cxx:1179
TList
Definition: TList.h:44
TLeafObject::GetTypeName
const char * GetTypeName() const
Returns name of leaf type.
Definition: TLeafObject.cxx:111
TSelectorDraw
Definition: TSelectorDraw.h:33
TAxis::GetBinWidth
virtual Double_t GetBinWidth(Int_t bin) const
Return bin width.
Definition: TAxis.cxx:540
TVirtualStreamerInfo::GetElements
virtual TObjArray * GetElements() const =0
Foption_t::Quiet
int Quiet
Definition: Foption.h:35
TMath.h
gROOT
#define gROOT
Definition: TROOT.h:406
int
TH1::Draw
virtual void Draw(Option_t *option="")
Draw this histogram with options.
Definition: TH1.cxx:2997
TVirtualMonitoringWriter::SendProcessingProgress
virtual Bool_t SendProcessingProgress(Double_t, Double_t, Bool_t=kFALSE)
Definition: TVirtualMonitoring.h:79
TSystem::IsFileInIncludePath
virtual Bool_t IsFileInIncludePath(const char *name, char **fullpath=nullptr)
Return true if 'name' is a file that can be found in the ROOT include path or the current directory.
Definition: TSystem.cxx:965
TTreeResult.h
TEventList.h