Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
TSelectorDraw.cxx
Go to the documentation of this file.
1 // @(#)root/treeplayer:$Id$
2 // Author: Rene Brun 08/01/2003
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 TSelectorDraw
13 A specialized TSelector for TTree::Draw.
14 */
15 
16 #include "TSelectorDraw.h"
17 #include "TROOT.h"
18 #include "TH2.h"
19 #include "TH3.h"
20 #include "TView.h"
21 #include "TGraph.h"
22 #include "TPolyMarker3D.h"
23 #include "TDirectory.h"
24 #include "TVirtualPad.h"
25 #include "TProfile.h"
26 #include "TProfile2D.h"
27 #include "TTreeFormulaManager.h"
28 #include "TEnv.h"
29 #include "TTree.h"
30 #include "TCut.h"
31 #include "TEntryList.h"
32 #include "TEventList.h"
33 #include "TEntryListArray.h"
34 #include "THLimitsFinder.h"
35 #include "TStyle.h"
36 #include "TClass.h"
37 #include "TColor.h"
38 
39 ClassImp(TSelectorDraw);
40 
41 const Int_t kCustomHistogram = BIT(17);
42 
43 ////////////////////////////////////////////////////////////////////////////////
44 /// Default selector constructor.
45 
46 TSelectorDraw::TSelectorDraw()
47 {
48  fTree = 0;
49  fW = 0;
50  fValSize = 4;
51  fVal = new Double_t*[fValSize];
52  fVmin = new Double_t[fValSize];
53  fVmax = new Double_t[fValSize];
54  fNbins = new Int_t[fValSize];
55  fVarMultiple = new Bool_t[fValSize];
56  fVar = new TTreeFormula*[fValSize];
57  for (Int_t i = 0; i < fValSize; ++i) {
58  fVal[i] = 0;
59  fVar[i] = 0;
60  }
61  fManager = 0;
62  fMultiplicity = 0;
63  fSelect = 0;
64  fSelectedRows = 0;
65  fDraw = 0;
66  fObject = 0;
67  fOldHistogram = 0;
68  fObjEval = kFALSE;
69  fSelectMultiple = kFALSE;
70  fCleanElist = kFALSE;
71  fTreeElist = 0;
72  fAction = 0;
73  fNfill = 0;
74  fDimension = 0;
75  fOldEstimate = 0;
76  fForceRead = 0;
77  fWeight = 1;
78  fCurrentSubEntry = -1;
79  fTreeElistArray = 0;
80 }
81 
82 ////////////////////////////////////////////////////////////////////////////////
83 /// Selector destructor.
84 
85 TSelectorDraw::~TSelectorDraw()
86 {
87  ClearFormula();
88  delete [] fVar;
89  if (fVal) {
90  for (Int_t i = 0; i < fValSize; ++i)
91  delete [] fVal[i];
92  delete [] fVal;
93  }
94  if (fVmin) delete [] fVmin;
95  if (fVmax) delete [] fVmax;
96  if (fNbins) delete [] fNbins;
97  if (fVarMultiple) delete [] fVarMultiple;
98  if (fW) delete [] fW;
99 }
100 
101 ////////////////////////////////////////////////////////////////////////////////
102 /// Called every time a loop on the tree(s) starts.
103 
104 void TSelectorDraw::Begin(TTree *tree)
105 {
106  SetStatus(0);
107  ResetAbort();
108  ResetBit(kCustomHistogram);
109  fSelectedRows = 0;
110  fTree = tree;
111  fDimension = 0;
112  fAction = 0;
113 
114  TObject *obj = fInput->FindObject("varexp");
115  const char *varexp0 = obj ? obj->GetTitle() : "";
116  obj = fInput->FindObject("selection");
117  const char *selection = obj ? obj->GetTitle() : "";
118  const char *option = GetOption();
119 
120  TString opt, abrt;
121  char *hdefault = (char *)"htemp";
122  char *varexp = nullptr;
123  Int_t i, j, hkeep;
124  opt = option;
125  opt.ToLower();
126  fOldHistogram = 0;
127  TEntryList *enlist = 0;
128  TEventList *evlist = 0;
129  TString htitle;
130  Bool_t profile = kFALSE;
131  Bool_t optSame = kFALSE;
132  Bool_t optEnlist = kFALSE;
133  Bool_t optEnlistArray = kFALSE;
134  Bool_t optpara = kFALSE;
135  Bool_t optcandle = kFALSE;
136  Bool_t opt5d = kFALSE;
137  if (opt.Contains("same")) {
138  optSame = kTRUE;
139  opt.ReplaceAll("same", "");
140  }
141  if (opt.Contains("entrylist")) {
142  optEnlist = kTRUE;
143  if (opt.Contains("entrylistarray")) {
144  optEnlistArray = kTRUE;
145  opt.ReplaceAll("entrylistarray", "");
146  } else {
147  opt.ReplaceAll("entrylist", "");
148  }
149  }
150  if (opt.Contains("para")) {
151  optpara = kTRUE;
152  opt.ReplaceAll("para", "");
153  }
154  if (opt.Contains("candle")) {
155  optcandle = kTRUE;
156  opt.ReplaceAll("candle", "");
157  }
158  if (opt.Contains("gl5d")) {
159  opt5d = kTRUE;
160  opt.ReplaceAll("gl5d", "");
161  }
162  TCut realSelection(selection);
163  //input list - only TEntryList
164  TEntryList *inElist = fTree->GetEntryList();
165  evlist = fTree->GetEventList();
166  if (evlist && inElist) {
167  //this is needed because the input entry list was created
168  //by the fTree from the input TEventList and is owned by the fTree.
169  //Calling GetEntryList function changes ownership and here
170  //we want fTree to still delete this entry list
171 
172  inElist->SetBit(kCanDelete, kTRUE);
173  }
174  fCleanElist = kFALSE;
175  fTreeElist = inElist;
176 
177  fTreeElistArray = inElist ? dynamic_cast<TEntryListArray*>(fTreeElist) : 0;
178 
179 
180  if (inElist && inElist->GetReapplyCut()) {
181  realSelection *= inElist->GetTitle();
182  }
183 
184  // what each variable should contain:
185  // varexp0 - original expression eg "a:b>>htest"
186  // hname - name of new or old histogram
187  // hkeep - flag if to keep new histogram
188  // hnameplus - flag if to add to current histo
189  // i - length of variable expression stipped of everything after ">>"
190  // varexp - variable expression stipped of everything after ">>"
191  // fOldHistogram - pointer to hist hname
192  // elist - pointer to selection list of hname
193 
194  Bool_t canExtend = kTRUE;
195  if (optSame) canExtend = kFALSE;
196 
197  Int_t nbinsx = 0, nbinsy = 0, nbinsz = 0;
198  Double_t xmin = 0, xmax = 0, ymin = 0, ymax = 0, zmin = 0, zmax = 0;
199 
200  fObject = 0;
201  char *hname = 0;
202  char *hnamealloc = 0;
203  i = 0;
204  if (varexp0 && strlen(varexp0)) {
205  for (UInt_t k = strlen(varexp0) - 1; k > 0; k--) {
206  if (varexp0[k] == '>' && varexp0[k-1] == '>') {
207  i = (int)(&(varexp0[k-1]) - varexp0); // length of varexp0 before ">>"
208  hnamealloc = new char[strlen(&(varexp0[k+1])) + 1];
209  hname = hnamealloc;
210  strcpy(hname, &(varexp0[k+1]));
211  break;
212  }
213  }
214  }
215  // char *hname = (char*)strstr(varexp0,">>");
216  if (hname) {
217  hkeep = 1;
218  varexp = new char[i+1];
219  varexp[0] = 0; //necessary if i=0
220  Bool_t hnameplus = kFALSE;
221  while (*hname == ' ') hname++;
222  if (*hname == '+') {
223  hnameplus = kTRUE;
224  hname++;
225  while (*hname == ' ') hname++; //skip ' '
226  }
227  j = strlen(hname) - 1; // skip ' ' at the end
228  while (j) {
229  if (hname[j] != ' ') break;
230  hname[j] = 0;
231  j--;
232  }
233 
234  if (i) {
235  strlcpy(varexp,varexp0,i+1);
236 
237  Int_t mustdelete = 0;
238  SetBit(kCustomHistogram);
239 
240  // parse things that follow the name of the histo between '(' and ')'.
241  // At this point hname contains the name of the specified histogram.
242  // Now the syntax is extended to handle an hname of the following format
243  // hname(nBIN [[,[xlow]][,xhigh]],...)
244  // so enclosed in brackets is the binning information, xlow, xhigh, and
245  // the same for the other dimensions
246 
247  char *pstart; // pointer to '('
248  char *pend; // pointer to ')'
249  char *cdummy; // dummy pointer
250  int ncomma; // number of commas between '(' and ')', later number of arguments
251  int ncols; // number of columns in varexpr
252  Double_t value; // parsed value (by sscanf)
253 
254  const Int_t maxvalues = 9;
255 
256  pstart = strchr(hname, '(');
257  pend = strchr(hname, ')');
258  if (pstart != 0) { // found the bracket
259 
260  mustdelete = 1;
261 
262  // check that there is only one open and close bracket
263  if (pstart == strrchr(hname, '(') && pend == strrchr(hname, ')')) {
264 
265  // count number of ',' between '(' and ')'
266  ncomma = 0;
267  cdummy = pstart;
268  cdummy = strchr(&cdummy[1], ',');
269  while (cdummy != 0) {
270  cdummy = strchr(&cdummy[1], ',');
271  ncomma++;
272  }
273 
274  if (ncomma + 1 > maxvalues) {
275  Error("DrawSelect", "ncomma+1>maxvalues, ncomma=%d, maxvalues=%d", ncomma, maxvalues);
276  ncomma = maxvalues - 1;
277  }
278 
279  ncomma++; // number of arguments
280  cdummy = pstart;
281 
282  // number of columns
283  ncols = 1;
284  for (j = 0; j < i; j++) {
285  if (varexp[j] == ':'
286  && !((j > 0 && varexp[j-1] == ':') || varexp[j+1] == ':')
287  ) {
288  ncols++;
289  }
290  }
291  if (ncols > 3) { // max 3 columns
292  Error("DrawSelect", "ncols > 3, ncols=%d", ncols);
293  ncols = 0;
294  }
295 
296  // check dimensions before and after ">>"
297  if (ncols * 3 < ncomma) {
298  Error("DrawSelect", "ncols*3 < ncomma ncols=%d, ncomma=%d", ncols, ncomma);
299  ncomma = ncols * 3;
300  }
301 
302  // scan the values one after the other
303  for (j = 0; j < ncomma; j++) {
304  cdummy++; // skip '(' or ','
305  if (sscanf(cdummy, " %lf ", &value) == 1) {
306  cdummy = strchr(&cdummy[1], ',');
307 
308  switch (j) { // do certain settings depending on position of argument
309  case 0: // binning x-axis
310  nbinsx = (Int_t)value;
311  if (ncols < 2) {
312  gEnv->SetValue("Hist.Binning.1D.x", nbinsx);
313  } else if (ncols < 3) {
314  gEnv->SetValue("Hist.Binning.2D.x", nbinsx);
315  gEnv->SetValue("Hist.Binning.2D.Prof", nbinsx);
316  } else {
317  gEnv->SetValue("Hist.Binning.3D.x", nbinsx);
318  gEnv->SetValue("Hist.Binning.3D.Profx", nbinsx);
319  }
320 
321  break;
322  case 1: // lower limit x-axis
323  xmin = value;
324  break;
325  case 2: // upper limit x-axis
326  xmax = value;
327  break;
328  case 3: // binning y-axis
329  nbinsy = (Int_t)value;
330  if (ncols < 3) gEnv->SetValue("Hist.Binning.2D.y", nbinsy);
331  else {
332  gEnv->SetValue("Hist.Binning.3D.y", nbinsy);
333  gEnv->SetValue("Hist.Binning.3D.Profy", nbinsy);
334  }
335  break;
336  case 4: // lower limit y-axis
337  ymin = value;
338  break;
339  case 5: // upper limit y-axis
340  ymax = value;
341  break;
342  case 6: // binning z-axis
343  nbinsz = (Int_t)value;
344  gEnv->SetValue("Hist.Binning.3D.z", nbinsz);
345  break;
346  case 7: // lower limit z-axis
347  zmin = value;
348  break;
349  case 8: // upper limit z-axis
350  zmax = value;
351  break;
352  default:
353  Error("DrawSelect", "j>8");
354  break;
355  }
356  } // if sscanf == 1
357  } // for j=0;j<ncomma;j++
358  } else {
359  Error("Begin", "Two open or close brackets found, hname=%s", hname);
360  }
361 
362  // fix up hname
363  pstart[0] = '\0'; // removes things after (and including) '('
364  } // if '(' is found
365 
366  j = strlen(hname) - 1; // skip ' ' at the end
367  while (j > 0) {
368  if (hname[j] != ' ') break; // skip ' ' at the end
369  hname[j] = 0;
370  j--;
371  }
372 
373  TObject *oldObject = gDirectory->Get(hname); // if hname contains '(...)' the return values is NULL, which is what we want
374  fOldHistogram = oldObject ? dynamic_cast<TH1*>(oldObject) : 0;
375 
376  if (!fOldHistogram && oldObject && !oldObject->InheritsFrom(TH1::Class())) {
377  abrt.Form("An object of type '%s' has the same name as the requested histo (%s)", oldObject->IsA()->GetName(), hname);
378  Abort(abrt);
379  delete[] varexp;
380  return;
381  }
382  if (fOldHistogram && !hnameplus) fOldHistogram->Reset(); // reset unless adding is wanted
383 
384  if (mustdelete) {
385  if (gDebug) {
386  Warning("Begin", "Deleting old histogram, since (possibly new) limits and binnings have been given");
387  }
388  delete fOldHistogram; fOldHistogram=0;
389  }
390 
391  } else {
392  // make selection list (i.e. varexp0 starts with ">>")
393  TObject *oldObject = gDirectory->Get(hname);
394  if (optEnlist) {
395  //write into a TEntryList
396  enlist = oldObject ? dynamic_cast<TEntryList*>(oldObject) : 0;
397 
398  if (!enlist && oldObject) {
399  abrt.Form("An object of type '%s' has the same name as the requested event list (%s)",
400  oldObject->IsA()->GetName(), hname);
401  Abort(abrt);
402  delete[] varexp;
403  return;
404  }
405  if (!enlist) {
406  if (optEnlistArray) {
407  enlist = new TEntryListArray(hname, realSelection.GetTitle());
408  } else {
409  enlist = new TEntryList(hname, realSelection.GetTitle());
410  }
411  }
412  if (enlist) {
413  if (!hnameplus) {
414  if (enlist == inElist) {
415  // We have been asked to reset the input list!!
416  // Let's set it aside for now ...
417  if (optEnlistArray) {
418  inElist = new TEntryListArray(*enlist);
419  } else {
420  inElist = new TEntryList(*enlist);
421  }
422  fCleanElist = kTRUE;
423  fTree->SetEntryList(inElist);
424  }
425  enlist->Reset();
426  enlist->SetTitle(realSelection.GetTitle());
427  } else {
428  TCut old = enlist->GetTitle();
429  TCut upd = old || realSelection.GetTitle();
430  enlist->SetTitle(upd.GetTitle());
431  }
432  }
433  } else {
434  //write into a TEventList
435  evlist = oldObject ? dynamic_cast<TEventList*>(oldObject) : 0;
436 
437  if (!evlist && oldObject) {
438  abrt.Form("An object of type '%s' has the same name as the requested event list (%s)",
439  oldObject->IsA()->GetName(), hname);
440  Abort(abrt);
441  return;
442  }
443  if (!evlist) {
444  evlist = new TEventList(hname, realSelection.GetTitle(), 1000, 0);
445  }
446  if (evlist) {
447  if (!hnameplus) {
448  if (evlist == fTree->GetEventList()) {
449  // We have been asked to reset the input list!!
450  // Let's set it aside for now ...
451  Abort("Input and output lists are the same!");
452  delete[] varexp;
453  return;
454  }
455  evlist->Reset();
456  evlist->SetTitle(realSelection.GetTitle());
457  } else {
458  TCut old = evlist->GetTitle();
459  TCut upd = old || realSelection.GetTitle();
460  evlist->SetTitle(upd.GetTitle());
461  }
462  }
463  }
464 
465  } // if (i)
466  } else { // if (hname)
467  hname = hdefault;
468  hkeep = 0;
469  const size_t varexpLen = strlen(varexp0) + 1;
470  varexp = new char[varexpLen];
471  strlcpy(varexp, varexp0, varexpLen);
472  if (gDirectory) {
473  fOldHistogram = (TH1*)gDirectory->Get(hname);
474  if (fOldHistogram) { fOldHistogram->Delete(); fOldHistogram = 0;}
475  }
476  }
477 
478  // Decode varexp and selection
479  if (!CompileVariables(varexp, realSelection.GetTitle())) {
480  abrt.Form("Variable compilation failed: {%s,%s}", varexp, realSelection.GetTitle());
481  Abort(abrt);
482  delete[] varexp;
483  return;
484  }
485  if (fDimension > 4 && !(optpara || optcandle || opt5d || opt.Contains("goff"))) {
486  Abort("Too many variables. Use the option \"para\", \"gl5d\" or \"candle\" to display more than 4 variables.");
487  delete[] varexp;
488  return;
489  }
490  if (fDimension < 2 && (optpara || optcandle)) {
491  Abort("The options \"para\" and \"candle\" require at least 2 variables.");
492  delete[] varexp;
493  return;
494  }
495 
496  // In case fOldHistogram exists, check dimensionality
497  Int_t nsel = strlen(selection);
498  if (nsel > 1) {
499  htitle.Form("%s {%s}", varexp, selection);
500  } else {
501  htitle = varexp;
502  }
503  if (fOldHistogram) {
504  Int_t olddim = fOldHistogram->GetDimension();
505  Int_t mustdelete = 0;
506  if (fOldHistogram->InheritsFrom(TProfile::Class())) {
507  profile = kTRUE;
508  olddim = 2;
509  }
510  if (fOldHistogram->InheritsFrom(TProfile2D::Class())) {
511  profile = kTRUE;
512  olddim = 3;
513  }
514  if (opt.Contains("prof") && fDimension > 1) {
515  // ignore "prof" for 1D.
516  if (!profile || olddim != fDimension) mustdelete = 1;
517  } else if (opt.Contains("col") && fDimension>2) {
518  if (olddim+1 != fDimension) mustdelete = 1;
519  } else {
520  if (olddim != fDimension) mustdelete = 1;
521  }
522  if (mustdelete) {
523  Warning("Begin", "Deleting old histogram with different dimensions");
524  delete fOldHistogram;
525  fOldHistogram = 0;
526  }
527  }
528 
529  // Create a default canvas if none exists
530  fDraw = 0;
531  if (!gPad && !opt.Contains("goff") && fDimension > 0) {
532  gROOT->MakeDefCanvas();
533  if (!gPad) {
534  Abort("Creation of default canvas failed");
535  delete[] varexp;
536  return;
537  }
538  }
539 
540  // 1-D distribution
541  TH1 *hist;
542  if (fDimension == 1) {
543  fAction = 1;
544  if (!fOldHistogram) {
545  fNbins[0] = gEnv->GetValue("Hist.Binning.1D.x", 100);
546  if (gPad && optSame) {
547  TListIter np(gPad->GetListOfPrimitives());
548  TObject *op;
549  TH1 *oldhtemp = 0;
550  while ((op = np()) && !oldhtemp) {
551  if (op->InheritsFrom(TH1::Class())) oldhtemp = (TH1 *)op;
552  }
553  if (oldhtemp) {
554  fNbins[0] = oldhtemp->GetXaxis()->GetNbins();
555  fVmin[0] = oldhtemp->GetXaxis()->GetXmin();
556  fVmax[0] = oldhtemp->GetXaxis()->GetXmax();
557  } else {
558  fVmin[0] = gPad->GetUxmin();
559  fVmax[0] = gPad->GetUxmax();
560  }
561  } else {
562  fAction = -1;
563  fVmin[0] = xmin;
564  fVmax[0] = xmax;
565  if (xmin < xmax) canExtend = kFALSE;
566  }
567  }
568  if (fOldHistogram) {
569  hist = fOldHistogram;
570  fNbins[0] = hist->GetXaxis()->GetNbins();
571  } else {
572  TString precision = gEnv->GetValue("Hist.Precision.1D", "float");
573  if (precision.Contains("float")) {
574  hist = new TH1F(hname, htitle.Data(), fNbins[0], fVmin[0], fVmax[0]);
575  } else {
576  hist = new TH1D(hname, htitle.Data(), fNbins[0], fVmin[0], fVmax[0]);
577  }
578  hist->SetLineColor(fTree->GetLineColor());
579  hist->SetLineWidth(fTree->GetLineWidth());
580  hist->SetLineStyle(fTree->GetLineStyle());
581  hist->SetFillColor(fTree->GetFillColor());
582  hist->SetFillStyle(fTree->GetFillStyle());
583  hist->SetMarkerStyle(fTree->GetMarkerStyle());
584  hist->SetMarkerColor(fTree->GetMarkerColor());
585  hist->SetMarkerSize(fTree->GetMarkerSize());
586  if (canExtend) hist->SetCanExtend(TH1::kAllAxes);
587  if (!hkeep) {
588  hist->GetXaxis()->SetTitle(fVar[0]->GetTitle());
589  hist->SetBit(kCanDelete);
590  if (!opt.Contains("goff")) hist->SetDirectory(0);
591  }
592  if (opt.Length() && opt.Contains("e")) hist->Sumw2();
593  }
594  fVar[0]->SetAxis(hist->GetXaxis());
595  fObject = hist;
596 
597  // 2-D distribution
598  } else if (fDimension == 2 && !(optpara || optcandle)) {
599  fAction = 2;
600  if (!fOldHistogram || !optSame) {
601  fNbins[0] = gEnv->GetValue("Hist.Binning.2D.y", 40);
602  fNbins[1] = gEnv->GetValue("Hist.Binning.2D.x", 40);
603  if (opt.Contains("prof")) fNbins[1] = gEnv->GetValue("Hist.Binning.2D.Prof", 100);
604  if (optSame) {
605  TH1 *oldhtemp = (TH1*)gPad->FindObject(hdefault);
606  if (oldhtemp) {
607  fNbins[1] = oldhtemp->GetXaxis()->GetNbins();
608  fVmin[1] = oldhtemp->GetXaxis()->GetXmin();
609  fVmax[1] = oldhtemp->GetXaxis()->GetXmax();
610  fNbins[0] = oldhtemp->GetYaxis()->GetNbins();
611  fVmin[0] = oldhtemp->GetYaxis()->GetXmin();
612  fVmax[0] = oldhtemp->GetYaxis()->GetXmax();
613  } else {
614  fNbins[1] = gEnv->GetValue("Hist.Binning.2D.x", 40);
615  fVmin[1] = gPad->GetUxmin();
616  fVmax[1] = gPad->GetUxmax();
617  fNbins[0] = gEnv->GetValue("Hist.Binning.2D.y", 40);
618  fVmin[0] = gPad->GetUymin();
619  fVmax[0] = gPad->GetUymax();
620  }
621  } else {
622  if (!fOldHistogram) fAction = -2;
623  fVmin[1] = xmin;
624  fVmax[1] = xmax;
625  fVmin[0] = ymin;
626  fVmax[0] = ymax;
627  if (xmin < xmax && ymin < ymax) canExtend = kFALSE;
628  }
629  }
630  if (profile || opt.Contains("prof")) {
631  TProfile *hp;
632  if (fOldHistogram) {
633  fAction = 4;
634  hp = (TProfile*)fOldHistogram;
635  } else {
636  if (fAction < 0) {
637  fAction = -4;
638  fVmin[1] = xmin;
639  fVmax[1] = xmax;
640  if (xmin < xmax) canExtend = kFALSE;
641  }
642  if (fAction == 2) {
643  //we come here when option = "same prof"
644  fAction = -4;
645  TH1 *oldhtemp = (TH1*)gPad->FindObject(hdefault);
646  if (oldhtemp) {
647  fNbins[1] = oldhtemp->GetXaxis()->GetNbins();
648  fVmin[1] = oldhtemp->GetXaxis()->GetXmin();
649  fVmax[1] = oldhtemp->GetXaxis()->GetXmax();
650  }
651  }
652  if (opt.Contains("profs")) {
653  hp = new TProfile(hname, htitle.Data(), fNbins[1], fVmin[1], fVmax[1], "s");
654  } else if (opt.Contains("profi")) {
655  hp = new TProfile(hname, htitle.Data(), fNbins[1], fVmin[1], fVmax[1], "i");
656  } else if (opt.Contains("profg")) {
657  hp = new TProfile(hname, htitle.Data(), fNbins[1], fVmin[1], fVmax[1], "g");
658  } else {
659  hp = new TProfile(hname, htitle.Data(), fNbins[1], fVmin[1], fVmax[1], "");
660  }
661  if (!hkeep) {
662  hp->SetBit(kCanDelete);
663  if (!opt.Contains("goff")) hp->SetDirectory(0);
664  }
665  hp->SetLineColor(fTree->GetLineColor());
666  hp->SetLineWidth(fTree->GetLineWidth());
667  hp->SetLineStyle(fTree->GetLineStyle());
668  hp->SetFillColor(fTree->GetFillColor());
669  hp->SetFillStyle(fTree->GetFillStyle());
670  hp->SetMarkerStyle(fTree->GetMarkerStyle());
671  hp->SetMarkerColor(fTree->GetMarkerColor());
672  hp->SetMarkerSize(fTree->GetMarkerSize());
673  if (canExtend) hp->SetCanExtend(TH1::kAllAxes);
674  }
675  fVar[1]->SetAxis(hp->GetXaxis());
676  fObject = hp;
677 
678  } else {
679  TH2 *h2;
680  if (fOldHistogram) {
681  h2 = (TH2F*)fOldHistogram;
682  } else {
683  TString precision = gEnv->GetValue("Hist.Precision.2D", "float");
684  if (precision.Contains("float")) {
685  h2 = new TH2F(hname, htitle.Data(), fNbins[1], fVmin[1], fVmax[1], fNbins[0], fVmin[0], fVmax[0]);
686  } else {
687  h2 = new TH2D(hname, htitle.Data(), fNbins[1], fVmin[1], fVmax[1], fNbins[0], fVmin[0], fVmax[0]);
688  }
689  h2->SetLineColor(fTree->GetLineColor());
690  h2->SetLineWidth(fTree->GetLineWidth());
691  h2->SetLineStyle(fTree->GetLineStyle());
692  h2->SetFillColor(fTree->GetFillColor());
693  h2->SetFillStyle(fTree->GetFillStyle());
694  h2->SetMarkerStyle(fTree->GetMarkerStyle());
695  h2->SetMarkerColor(fTree->GetMarkerColor());
696  h2->SetMarkerSize(fTree->GetMarkerSize());
697  if (canExtend) h2->SetCanExtend(TH1::kAllAxes);
698  if (!hkeep) {
699  h2->GetXaxis()->SetTitle(fVar[1]->GetTitle());
700  h2->GetYaxis()->SetTitle(fVar[0]->GetTitle());
701  h2->SetBit(TH1::kNoStats);
702  h2->SetBit(kCanDelete);
703  if (!opt.Contains("goff")) h2->SetDirectory(0);
704  }
705  }
706  fVar[0]->SetAxis(h2->GetYaxis());
707  fVar[1]->SetAxis(h2->GetXaxis());
708  Bool_t graph = kFALSE;
709  Int_t l = opt.Length();
710  if (l == 0 || optSame) graph = kTRUE;
711  if (opt.Contains("p") || opt.Contains("*") || opt.Contains("l")) graph = kTRUE;
712  if (opt.Contains("surf") || opt.Contains("lego") || opt.Contains("cont")) graph = kFALSE;
713  if (opt.Contains("col") || opt.Contains("hist") || opt.Contains("scat")) graph = kFALSE;
714  if (opt.Contains("box")) graph = kFALSE;
715  fObject = h2;
716  if (graph) {
717  fAction = 12;
718  if (!fOldHistogram && !optSame) fAction = -12;
719  }
720  }
721 
722  // 3-D distribution
723  } else if ((fDimension == 3 || fDimension == 4) && !(optpara || optcandle)) {
724  fAction = 3;
725  if (fDimension == 4) fAction = 40;
726  if (!fOldHistogram || !optSame) {
727  fNbins[0] = gEnv->GetValue("Hist.Binning.3D.z", 20);
728  fNbins[1] = gEnv->GetValue("Hist.Binning.3D.y", 20);
729  fNbins[2] = gEnv->GetValue("Hist.Binning.3D.x", 20);
730  if (fDimension == 3 && opt.Contains("prof")) {
731  fNbins[1] = gEnv->GetValue("Hist.Binning.3D.Profy", 20);
732  fNbins[2] = gEnv->GetValue("Hist.Binning.3D.Profx", 20);
733  } else if (fDimension == 3 && opt.Contains("col")) {
734  fNbins[0] = gEnv->GetValue("Hist.Binning.2D.y", 40);
735  fNbins[1] = gEnv->GetValue("Hist.Binning.2D.x", 40);
736  }
737  if (optSame) {
738  TH1 *oldhtemp = (TH1*)gPad->FindObject(hdefault);
739  if (oldhtemp) {
740  fNbins[2] = oldhtemp->GetXaxis()->GetNbins();
741  fVmin[2] = oldhtemp->GetXaxis()->GetXmin();
742  fVmax[2] = oldhtemp->GetXaxis()->GetXmax();
743  fNbins[1] = oldhtemp->GetYaxis()->GetNbins();
744  fVmin[1] = oldhtemp->GetYaxis()->GetXmin();
745  fVmax[1] = oldhtemp->GetYaxis()->GetXmax();
746  fNbins[0] = oldhtemp->GetZaxis()->GetNbins();
747  fVmin[0] = oldhtemp->GetZaxis()->GetXmin();
748  fVmax[0] = oldhtemp->GetZaxis()->GetXmax();
749  } else {
750  TView *view = gPad->GetView();
751  if (!view) {
752  Error("Begin", "You cannot use option same when no 3D view exists");
753  fVmin[0] = fVmin[1] = fVmin[2] = -1;
754  fVmax[0] = fVmax[1] = fVmax[2] = 1;
755  view = TView::CreateView(1, fVmin, fVmax);
756  }
757  Double_t *rmin = view->GetRmin();
758  Double_t *rmax = view->GetRmax();
759  fNbins[2] = gEnv->GetValue("Hist.Binning.3D.z", 20);
760  fVmin[2] = rmin[0];
761  fVmax[2] = rmax[0];
762  fNbins[1] = gEnv->GetValue("Hist.Binning.3D.y", 20);
763  fVmin[1] = rmin[1];
764  fVmax[1] = rmax[1];
765  fNbins[0] = gEnv->GetValue("Hist.Binning.3D.x", 20);
766  fVmin[0] = rmin[2];
767  fVmax[0] = rmax[2];
768  }
769  } else {
770  if (!fOldHistogram && fDimension == 3) fAction = -3;
771  fVmin[2] = xmin;
772  fVmax[2] = xmax;
773  fVmin[1] = ymin;
774  fVmax[1] = ymax;
775  fVmin[0] = zmin;
776  fVmax[0] = zmax;
777  if (xmin < xmax && ymin < ymax && zmin < zmax) canExtend = kFALSE;
778  }
779  }
780  if ((fDimension == 3) && (profile || opt.Contains("prof"))) {
781  TProfile2D *hp;
782  if (fOldHistogram) {
783  fAction = 23;
784  hp = (TProfile2D*)fOldHistogram;
785  } else {
786  if (fAction < 0) {
787  fAction = -23;
788  fVmin[2] = xmin;
789  fVmax[2] = xmax;
790  fVmin[1] = ymin;
791  fVmax[1] = ymax;
792  if (xmin < xmax && ymin < ymax) canExtend = kFALSE;
793  }
794  if (opt.Contains("profs")) {
795  hp = new TProfile2D(hname, htitle.Data(), fNbins[2], fVmin[2], fVmax[2], fNbins[1], fVmin[1], fVmax[1], "s");
796  } else if (opt.Contains("profi")) {
797  hp = new TProfile2D(hname, htitle.Data(), fNbins[2], fVmin[2], fVmax[2], fNbins[1], fVmin[1], fVmax[1], "i");
798  } else if (opt.Contains("profg")) {
799  hp = new TProfile2D(hname, htitle.Data(), fNbins[2], fVmin[2], fVmax[2], fNbins[1], fVmin[1], fVmax[1], "g");
800  } else {
801  hp = new TProfile2D(hname, htitle.Data(), fNbins[2], fVmin[2], fVmax[2], fNbins[1], fVmin[1], fVmax[1], "");
802  }
803  if (!hkeep) {
804  hp->SetBit(kCanDelete);
805  if (!opt.Contains("goff")) hp->SetDirectory(0);
806  }
807  hp->SetLineColor(fTree->GetLineColor());
808  hp->SetLineWidth(fTree->GetLineWidth());
809  hp->SetLineStyle(fTree->GetLineStyle());
810  hp->SetFillColor(fTree->GetFillColor());
811  hp->SetFillStyle(fTree->GetFillStyle());
812  hp->SetMarkerStyle(fTree->GetMarkerStyle());
813  hp->SetMarkerColor(fTree->GetMarkerColor());
814  hp->SetMarkerSize(fTree->GetMarkerSize());
815  if (canExtend) hp->SetCanExtend(TH1::kAllAxes);
816  }
817  fVar[1]->SetAxis(hp->GetYaxis());
818  fVar[2]->SetAxis(hp->GetXaxis());
819  fObject = hp;
820  } else if (fDimension == 3 && opt.Contains("col")) {
821  TH2F *h2;
822  if (fOldHistogram) {
823  h2 = (TH2F*)fOldHistogram;
824  } else {
825  h2 = new TH2F(hname, htitle.Data(), fNbins[1], fVmin[1], fVmax[1], fNbins[0], fVmin[0], fVmax[0]);
826  h2->SetLineColor(fTree->GetLineColor());
827  h2->SetLineWidth(fTree->GetLineWidth());
828  h2->SetLineStyle(fTree->GetLineStyle());
829  h2->SetFillColor(fTree->GetFillColor());
830  h2->SetFillStyle(fTree->GetFillStyle());
831  h2->SetMarkerStyle(fTree->GetMarkerStyle());
832  h2->SetMarkerColor(fTree->GetMarkerColor());
833  h2->SetMarkerSize(fTree->GetMarkerSize());
834  if (canExtend) h2->SetCanExtend(TH1::kAllAxes);
835  if (!hkeep) {
836  h2->GetXaxis()->SetTitle(fVar[1]->GetTitle());
837  h2->GetYaxis()->SetTitle(fVar[0]->GetTitle());
838  h2->GetZaxis()->SetTitle(fVar[2]->GetTitle());
839  h2->SetBit(TH1::kNoStats);
840  h2->SetBit(kCanDelete);
841  if (!opt.Contains("goff")) h2->SetDirectory(0);
842  }
843  }
844  fVar[0]->SetAxis(h2->GetYaxis());
845  fVar[1]->SetAxis(h2->GetXaxis());
846  fObject = h2;
847  fAction = 33;
848  } else {
849  TH3 *h3;
850  if (fOldHistogram) {
851  h3 = (TH3F*)fOldHistogram;
852  } else {
853  TString precision = gEnv->GetValue("Hist.Precision.3D", "float");
854  if (precision.Contains("float")) {
855  h3 = new TH3F(hname, htitle.Data(), fNbins[2], fVmin[2], fVmax[2], fNbins[1], fVmin[1], fVmax[1], fNbins[0], fVmin[0], fVmax[0]);
856  } else {
857  h3 = new TH3D(hname, htitle.Data(), fNbins[2], fVmin[2], fVmax[2], fNbins[1], fVmin[1], fVmax[1], fNbins[0], fVmin[0], fVmax[0]);
858  }
859  h3->SetLineColor(fTree->GetLineColor());
860  h3->SetLineWidth(fTree->GetLineWidth());
861  h3->SetLineStyle(fTree->GetLineStyle());
862  h3->SetFillColor(fTree->GetFillColor());
863  h3->SetFillStyle(fTree->GetFillStyle());
864  h3->SetMarkerStyle(fTree->GetMarkerStyle());
865  h3->SetMarkerColor(fTree->GetMarkerColor());
866  h3->SetMarkerSize(fTree->GetMarkerSize());
867  if (canExtend) h3->SetCanExtend(TH1::kAllAxes);
868  if (!hkeep) {
869  //small correction for the title offsets in x,y to take into account the angles
870  Double_t xoffset = h3->GetXaxis()->GetTitleOffset();
871  Double_t yoffset = h3->GetYaxis()->GetTitleOffset();
872  h3->GetXaxis()->SetTitleOffset(1.2 * xoffset);
873  h3->GetYaxis()->SetTitleOffset(1.2 * yoffset);
874  h3->GetXaxis()->SetTitle(fVar[2]->GetTitle());
875  h3->GetYaxis()->SetTitle(fVar[1]->GetTitle());
876  h3->GetZaxis()->SetTitle(fVar[0]->GetTitle());
877  h3->SetBit(kCanDelete);
878  h3->SetBit(TH1::kNoStats);
879  if (!opt.Contains("goff")) h3->SetDirectory(0);
880  }
881  }
882  fVar[0]->SetAxis(h3->GetZaxis());
883  fVar[1]->SetAxis(h3->GetYaxis());
884  fVar[2]->SetAxis(h3->GetXaxis());
885  fObject = h3;
886  Int_t noscat = strlen(option);
887  if (optSame) noscat -= 4;
888  if (!noscat && fDimension == 3) {
889  fAction = 13;
890  if (!fOldHistogram && !optSame) fAction = -13;
891  }
892  }
893  // An Event List
894  } else if (enlist) {
895  fAction = 5;
896  fOldEstimate = fTree->GetEstimate();
897  fTree->SetEstimate(1);
898  fObject = enlist;
899  } else if (evlist) {
900  fAction = 5;
901  fOldEstimate = fTree->GetEstimate();
902  fTree->SetEstimate(1);
903  fObject = evlist;
904  } else if (optcandle || optpara || opt5d) {
905  if (optcandle) fAction = 7;
906  else if (opt5d) fAction = 8;
907  else fAction = 6;
908  }
909  if (varexp) delete[] varexp;
910  if (hnamealloc) delete[] hnamealloc;
911  for (i = 0; i < fValSize; ++i)
912  fVarMultiple[i] = kFALSE;
913  fSelectMultiple = kFALSE;
914  for (i = 0; i < fDimension; ++i) {
915  if (fVar[i] && fVar[i]->GetMultiplicity()) fVarMultiple[i] = kTRUE;
916  }
917 
918  if (fSelect && fSelect->GetMultiplicity()) fSelectMultiple = kTRUE;
919 
920  fForceRead = fTree->TestBit(TTree::kForceRead);
921  fWeight = fTree->GetWeight();
922  fNfill = 0;
923 
924  for (i = 0; i < fDimension; ++i) {
925  if (!fVal[i] && fVar[i]) {
926  fVal[i] = new Double_t[(Int_t)fTree->GetEstimate()];
927  }
928  }
929 
930  if (!fW) fW = new Double_t[(Int_t)fTree->GetEstimate()];
931 
932  for (i = 0; i < fValSize; ++i) {
933  fVmin[i] = DBL_MAX;
934  fVmax[i] = -DBL_MAX;
935  }
936 }
937 
938 ////////////////////////////////////////////////////////////////////////////////
939 /// Delete internal buffers.
940 
941 void TSelectorDraw::ClearFormula()
942 {
943  ResetBit(kWarn);
944  for (Int_t i = 0; i < fValSize; ++i) {
945  delete fVar[i];
946  fVar[i] = 0;
947  }
948  delete fSelect; fSelect = 0;
949  fManager = 0;
950  fMultiplicity = 0;
951 }
952 
953 ////////////////////////////////////////////////////////////////////////////////
954 /// Compile input variables and selection expression.
955 ///
956 /// varexp is an expression of the general form e1:e2:e3
957 /// where e1,etc is a formula referencing a combination of the columns
958 ///
959 /// Example:
960 ///
961 /// varexp = x simplest case: draw a 1-Dim distribution of column named x
962 /// = sqrt(x) : draw distribution of sqrt(x)
963 /// = x*y/z
964 /// = y:sqrt(x) 2-Dim distribution of y versus sqrt(x)
965 ///
966 /// selection is an expression with a combination of the columns
967 ///
968 /// Example:
969 ///
970 /// selection = "x<y && sqrt(z)>3.2"
971 ///
972 /// in a selection all the C++ operators are authorized
973 ///
974 /// Return kFALSE if any of the variable is not compilable.
975 
976 Bool_t TSelectorDraw::CompileVariables(const char *varexp, const char *selection)
977 {
978  Int_t i, nch, ncols;
979 
980  // Compile selection expression if there is one
981  fDimension = 0;
982  ClearFormula();
983  fMultiplicity = 0;
984  fObjEval = kFALSE;
985 
986  if (strlen(selection)) {
987  fSelect = new TTreeFormula("Selection", selection, fTree);
988  fSelect->SetQuickLoad(kTRUE);
989  if (!fSelect->GetNdim()) {
990  delete fSelect;
991  fSelect = 0;
992  return kFALSE;
993  }
994  }
995 
996  // if varexp is empty, take first column by default
997  nch = strlen(varexp);
998  if (nch == 0) {
999  fDimension = 0;
1000  if (fSelect) {
1001  fManager = fSelect->GetManager();
1002  }
1003  fTree->ResetBit(TTree::kForceRead);
1004 
1005  if (fManager) {
1006  fManager->Sync();
1007 
1008  if (fManager->GetMultiplicity() == -1) fTree->SetBit(TTree::kForceRead);
1009  if (fManager->GetMultiplicity() >= 1) fMultiplicity = fManager->GetMultiplicity();
1010  }
1011 
1012  return kTRUE;
1013  }
1014 
1015  // otherwise select only the specified columns
1016  std::vector<TString> varnames;
1017  ncols = SplitNames(varexp, varnames);
1018 
1019  InitArrays(ncols);
1020 
1021  fManager = new TTreeFormulaManager();
1022  if (fSelect) fManager->Add(fSelect);
1023  fTree->ResetBit(TTree::kForceRead);
1024  for (i = 0; i < ncols; ++i) {
1025  fVar[i] = new TTreeFormula(TString::Format("Var%i", i + 1), varnames[i].Data(), fTree);
1026  fVar[i]->SetQuickLoad(kTRUE);
1027  if(!fVar[i]->GetNdim()) { ClearFormula(); return kFALSE; }
1028  fManager->Add(fVar[i]);
1029  }
1030  fManager->Sync();
1031 
1032  if (fManager->GetMultiplicity() == -1) fTree->SetBit(TTree::kForceRead);
1033  if (fManager->GetMultiplicity() >= 1) fMultiplicity = fManager->GetMultiplicity();
1034 
1035  fDimension = ncols;
1036 
1037  if (ncols == 1) {
1038  TClass *cl = fVar[0]->EvalClass();
1039  if (cl) {
1040  fObjEval = kTRUE;
1041  }
1042  }
1043  return kTRUE;
1044 }
1045 
1046 ////////////////////////////////////////////////////////////////////////////////
1047 /// Return the last values corresponding to the i-th component
1048 /// of the formula being processed (where the component are ':' separated).
1049 /// The actual number of entries is:
1050 ///
1051 /// GetSelectedRows() % tree->GetEstimate()
1052 ///
1053 /// Note GetSelectedRows currently returns the actual number of values plotted
1054 /// and thus if the formula contains arrays, this number might be greater than
1055 /// the number of entries in the trees.
1056 ///
1057 /// By default TTree::Draw creates the arrays obtained
1058 /// with all GetVal and GetW with a length corresponding to the
1059 /// parameter fEstimate. By default fEstimate=10000 and can be modified
1060 /// via TTree::SetEstimate. A possible recipe is to do
1061 ///
1062 /// tree->SetEstimate(tree->GetEntries());
1063 ///
1064 /// You must call SetEstimate if the expected number of selected rows
1065 /// is greater than 10000.
1066 ///
1067 /// See TTree::Draw for additional details.
1068 
1069 Double_t* TSelectorDraw::GetVal(Int_t i) const
1070 {
1071  if (i < 0 || i >= fDimension)
1072  return 0;
1073  else
1074  return fVal[i];
1075 }
1076 
1077 ////////////////////////////////////////////////////////////////////////////////
1078 /// Return the TTreeFormula corresponding to the i-th component
1079 /// of the request formula (where the component are ':' separated).
1080 
1081 TTreeFormula* TSelectorDraw::GetVar(Int_t i) const
1082 {
1083  if (i < 0 || i >= fDimension)
1084  return 0;
1085  else
1086  return fVar[i];
1087 }
1088 
1089 ////////////////////////////////////////////////////////////////////////////////
1090 /// Initialization of the primitive type arrays if the new size is bigger than the available space.
1091 
1092 void TSelectorDraw::InitArrays(Int_t newsize)
1093 {
1094  if (newsize > fValSize) {
1095  Int_t oldsize = fValSize;
1096  while (fValSize < newsize)
1097  fValSize *= 2; // Double the available space until it matches the new size.
1098  if (fNbins) delete [] fNbins;
1099  if (fVmin) delete [] fVmin;
1100  if (fVmax) delete [] fVmax;
1101  if (fVarMultiple) delete [] fVarMultiple;
1102 
1103  fNbins = new Int_t[fValSize];
1104  fVmin = new Double_t[fValSize];
1105  fVmax = new Double_t[fValSize];
1106  fVarMultiple = new Bool_t[fValSize];
1107 
1108  for (Int_t i = 0; i < oldsize; ++i)
1109  delete [] fVal[i];
1110  delete [] fVal;
1111  delete [] fVar;
1112  fVal = new Double_t*[fValSize];
1113  fVar = new TTreeFormula*[fValSize];
1114  for (Int_t i = 0; i < fValSize; ++i) {
1115  fVal[i] = 0;
1116  fVar[i] = 0;
1117  }
1118  }
1119 }
1120 
1121 ////////////////////////////////////////////////////////////////////////////////
1122 /// Build Index array for names in varexp.
1123 /// This will allocated a C style array of TString and Ints
1124 
1125 UInt_t TSelectorDraw::SplitNames(const TString &varexp, std::vector<TString> &names)
1126 {
1127  names.clear();
1128 
1129  Bool_t ternary = kFALSE;
1130  Int_t prev = 0;
1131  for (Int_t i = 0; i < varexp.Length(); i++) {
1132  if (varexp[i] == ':'
1133  && !((i > 0 && varexp[i-1] == ':') || varexp[i+1] == ':')
1134  ) {
1135  if (ternary) {
1136  ternary = kFALSE;
1137  } else {
1138  names.push_back(varexp(prev, i - prev));
1139  prev = i + 1;
1140  }
1141  }
1142  if (varexp[i] == '?') {
1143  ternary = kTRUE;
1144  }
1145  }
1146  names.push_back(varexp(prev, varexp.Length() - prev));
1147  return names.size();
1148 }
1149 
1150 
1151 ////////////////////////////////////////////////////////////////////////////////
1152 /// This function is called at the first entry of a new tree in a chain.
1153 
1154 Bool_t TSelectorDraw::Notify()
1155 {
1156  if (fTree) fWeight = fTree->GetWeight();
1157  if (fVar) {
1158  for (Int_t i = 0; i < fDimension; ++i) {
1159  if (fVar[i]) fVar[i]->UpdateFormulaLeaves();
1160  }
1161  }
1162  if (fSelect) fSelect->UpdateFormulaLeaves();
1163  return kTRUE;
1164 }
1165 
1166 ////////////////////////////////////////////////////////////////////////////////
1167 /// Called in the entry loop for all entries accepted by Select.
1168 
1169 void TSelectorDraw::ProcessFill(Long64_t entry)
1170 {
1171  if (fObjEval) {
1172  ProcessFillObject(entry);
1173  return;
1174  }
1175 
1176  if (fMultiplicity) {
1177  ProcessFillMultiple(entry);
1178  return;
1179  }
1180 
1181  // simple case with no multiplicity
1182  if (fForceRead && fManager->GetNdata() <= 0) return;
1183 
1184  if (fSelect) {
1185  fW[fNfill] = fWeight * fSelect->EvalInstance(0);
1186  if (!fW[fNfill]) return;
1187  } else fW[fNfill] = fWeight;
1188  if (fVal) {
1189  for (Int_t i = 0; i < fDimension; ++i) {
1190  if (fVar[i]) fVal[i][fNfill] = fVar[i]->EvalInstance(0);
1191  }
1192  }
1193  fNfill++;
1194  if (fNfill >= fTree->GetEstimate()) {
1195  TakeAction();
1196  fNfill = 0;
1197  }
1198 }
1199 
1200 ////////////////////////////////////////////////////////////////////////////////
1201 /// Called in the entry loop for all entries accepted by Select.
1202 /// Complex case with multiplicity.
1203 
1204 void TSelectorDraw::ProcessFillMultiple(Long64_t entry)
1205 {
1206  // Grab the array size of the formulas for this entry
1207  Int_t ndata = fManager->GetNdata();
1208 
1209  // No data at all, let's move on to the next entry.
1210  if (!ndata) return;
1211 
1212  // If the entry list is a TEntryListArray, get the selected subentries for this entry
1213  TEntryList *subList = 0;
1214  if (fTreeElistArray) {
1215  subList = fTreeElistArray->GetSubListForEntry(entry, fTree->GetTree());
1216  }
1217 
1218  Int_t nfill0 = fNfill;
1219 
1220  // Calculate the first values
1221  if (fSelect) {
1222  // coverity[var_deref_model] fSelectMultiple==kTRUE => fSelect != 0
1223  fW[fNfill] = fWeight * fSelect->EvalInstance(0);
1224  if (!fW[fNfill] && !fSelectMultiple) return;
1225  } else fW[fNfill] = fWeight;
1226 
1227  // Always call EvalInstance(0) to insure the loading
1228  // of the branches.
1229  if (fW[fNfill] && (!subList || subList->Contains(0))) {
1230  if (fDimension == 0 && fSelectMultiple) fCurrentSubEntry = (Long64_t) 0; // to fill TEntryListArray
1231  for (Int_t i = 0; i < fDimension; ++i) {
1232  if (fVar[i]) fVal[i][fNfill] = fVar[i]->EvalInstance(0);
1233  }
1234  fNfill++;
1235  if (fNfill >= fTree->GetEstimate()) {
1236  TakeAction();
1237  fNfill = 0;
1238  }
1239  } else {
1240  for (Int_t i = 0; i < fDimension; ++i) {
1241  if (fVar[i]) fVar[i]->ResetLoading();
1242  }
1243  }
1244  Double_t ww = fW[nfill0];
1245 
1246  for (Int_t i = 1; i < ndata; i++) {
1247  if (subList && !subList->Contains(i)) continue;
1248  if (fSelectMultiple) {
1249  // coverity[var_deref_model] fSelectMultiple==kTRUE => fSelect != 0
1250  ww = fWeight * fSelect->EvalInstance(i);
1251  if (ww == 0) continue;
1252  if (fNfill == nfill0) {
1253  for (Int_t k = 0; k < fDimension; ++k) {
1254  if (!fVarMultiple[k]) fVal[k][fNfill] = fVar[k]->EvalInstance(0);
1255  }
1256  }
1257  if (fDimension == 0) fCurrentSubEntry = (Long64_t) i; // to fill TEntryListArray
1258  }
1259  for (Int_t k = 0; k < fDimension; ++k) {
1260  if (fVarMultiple[k]) fVal[k][fNfill] = fVar[k]->EvalInstance(i);
1261  else fVal[k][fNfill] = fVal[k][nfill0];
1262  }
1263  fW[fNfill] = ww;
1264 
1265  fNfill++;
1266  if (fNfill >= fTree->GetEstimate()) {
1267  TakeAction();
1268  fNfill = 0;
1269  }
1270  }
1271 }
1272 
1273 ////////////////////////////////////////////////////////////////////////////////
1274 /// Called in the entry loop for all entries accepted by Select.
1275 /// Case where the only variable returns an object (or pointer to).
1276 
1277 void TSelectorDraw::ProcessFillObject(Long64_t /*entry*/)
1278 {
1279  // Complex case with multiplicity.
1280 
1281  // Grab the array size of the formulas for this entry
1282  Int_t ndata = fManager->GetNdata();
1283 
1284  // No data at all, let's move on to the next entry.
1285  if (!ndata) return;
1286 
1287  Int_t nfill0 = fNfill;
1288  Double_t ww = 0;
1289 
1290  for (Int_t i = 0; i < ndata; i++) {
1291  if (i == 0) {
1292  if (fSelect) {
1293  fW[fNfill] = fWeight * fSelect->EvalInstance(0);
1294  if (!fW[fNfill] && !fSelectMultiple) return;
1295  } else fW[fNfill] = fWeight;
1296  ww = fW[nfill0];
1297  } else if (fSelectMultiple) {
1298  ww = fWeight * fSelect->EvalInstance(i);
1299  if (ww == 0) continue;
1300  }
1301  if (fDimension >= 1 && fVar[0]) {
1302  TClass *cl = fVar[0]->EvalClass();
1303  if (cl == TBits::Class()) {
1304 
1305  void *obj = fVar[0]->EvalObject(i);
1306 
1307  if (obj) {
1308  TBits *bits = (TBits*)obj;
1309  Int_t nbits = bits->GetNbits();
1310 
1311  Int_t nextbit = -1;
1312  while (1) {
1313  nextbit = bits->FirstSetBit(nextbit + 1);
1314  if (nextbit >= nbits) break;
1315  fVal[0][fNfill] = nextbit;
1316  fW[fNfill] = ww;
1317  fNfill++;
1318  }
1319  }
1320 
1321  } else {
1322 
1323  if (!TestBit(kWarn)) {
1324  Warning("ProcessFillObject",
1325  "Not implemented for %s",
1326  cl ? cl->GetName() : "unknown class");
1327  SetBit(kWarn);
1328  }
1329 
1330  }
1331  }
1332  if (fNfill >= fTree->GetEstimate()) {
1333  TakeAction();
1334  fNfill = 0;
1335  }
1336  }
1337 
1338 }
1339 
1340 ////////////////////////////////////////////////////////////////////////////////
1341 /// Set number of entries to estimate variable limits.
1342 
1343 void TSelectorDraw::SetEstimate(Long64_t)
1344 {
1345  if (fVal) {
1346  for (Int_t i = 0; i < fValSize; ++i) {
1347  delete [] fVal[i];
1348  fVal[i] = 0;
1349  }
1350  }
1351  delete [] fW; fW = 0;
1352 }
1353 
1354 ////////////////////////////////////////////////////////////////////////////////
1355 /// Execute action for object obj fNfill times.
1356 
1357 void TSelectorDraw::TakeAction()
1358 {
1359  Int_t i;
1360  //__________________________1-D histogram_______________________
1361  if (fAction == 1)((TH1*)fObject)->FillN(fNfill, fVal[0], fW);
1362  //__________________________2-D histogram_______________________
1363  else if (fAction == 2) {
1364  TH2 *h2 = (TH2*)fObject;
1365  for (i = 0; i < fNfill; i++) h2->Fill(fVal[1][i], fVal[0][i], fW[i]);
1366  }
1367  //__________________________Profile histogram_______________________
1368  else if (fAction == 4)((TProfile*)fObject)->FillN(fNfill, fVal[1], fVal[0], fW);
1369  //__________________________Event List______________________________
1370  else if (fAction == 5) {
1371  if (fObject->InheritsFrom(TEntryListArray::Class())) {
1372  TEntryListArray *enlistarray = (TEntryListArray*)fObject;
1373  Long64_t enumb = fTree->GetTree()->GetReadEntry();
1374  enlistarray->Enter(enumb, 0, fCurrentSubEntry);
1375  } else if (fObject->InheritsFrom(TEntryList::Class())) {
1376  TEntryList *enlist = (TEntryList*)fObject;
1377  Long64_t enumb = fTree->GetTree()->GetReadEntry();
1378  enlist->Enter(enumb);
1379  } else {
1380  TEventList *evlist = (TEventList*)fObject;
1381  Long64_t enumb = fTree->GetChainOffset() + fTree->GetTree()->GetReadEntry();
1382  if (evlist->GetIndex(enumb) < 0) evlist->Enter(enumb);
1383  }
1384  }
1385  //__________________________2D scatter plot_______________________
1386  else if (fAction == 12) {
1387  TH2 *h2 = (TH2*)fObject;
1388  if (h2->CanExtendAllAxes() && h2->TestBit(kCanDelete)) {
1389  for (i = 0; i < fNfill; i++) {
1390  if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
1391  if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
1392  if (fVmin[1] > fVal[1][i]) fVmin[1] = fVal[1][i];
1393  if (fVmax[1] < fVal[1][i]) fVmax[1] = fVal[1][i];
1394  }
1395  THLimitsFinder::GetLimitsFinder()->FindGoodLimits(h2, fVmin[1], fVmax[1], fVmin[0], fVmax[0]);
1396  }
1397  TGraph *pm = new TGraph(fNfill, fVal[1], fVal[0]);
1398  pm->SetEditable(kFALSE);
1399  pm->SetBit(kCanDelete);
1400  pm->SetMarkerStyle(fTree->GetMarkerStyle());
1401  pm->SetMarkerColor(fTree->GetMarkerColor());
1402  pm->SetMarkerSize(fTree->GetMarkerSize());
1403  pm->SetLineColor(fTree->GetLineColor());
1404  pm->SetLineWidth(fTree->GetLineWidth());
1405  pm->SetLineStyle(fTree->GetLineStyle());
1406  pm->SetFillColor(fTree->GetFillColor());
1407  pm->SetFillStyle(fTree->GetFillStyle());
1408 
1409  if (!fDraw && !strstr(fOption.Data(), "goff")) {
1410  if (fOption.Length() == 0 || strcasecmp(fOption.Data(), "same") == 0) pm->Draw("p");
1411  else pm->Draw(fOption.Data());
1412  }
1413  if (!h2->TestBit(kCanDelete)) {
1414  for (i = 0; i < fNfill; i++) h2->Fill(fVal[1][i], fVal[0][i], fW[i]);
1415  }
1416  }
1417  //__________________________3D scatter plot_______________________
1418  else if (fAction == 3) {
1419  TH3 *h3 = (TH3*)fObject;
1420  if (!h3->TestBit(kCanDelete)) {
1421  for (i = 0; i < fNfill; i++) h3->Fill(fVal[2][i], fVal[1][i], fVal[0][i], fW[i]);
1422  }
1423  } else if (fAction == 13) {
1424  TPolyMarker3D *pm3d = new TPolyMarker3D(fNfill);
1425  pm3d->SetMarkerStyle(fTree->GetMarkerStyle());
1426  pm3d->SetMarkerColor(fTree->GetMarkerColor());
1427  pm3d->SetMarkerSize(fTree->GetMarkerSize());
1428  for (i = 0; i < fNfill; i++) {
1429  pm3d->SetPoint(i, fVal[2][i], fVal[1][i], fVal[0][i]);
1430  }
1431  pm3d->Draw();
1432  TH3 *h3 = (TH3*)fObject;
1433  if (!h3->TestBit(kCanDelete)) {
1434  for (i = 0; i < fNfill; i++) h3->Fill(fVal[2][i], fVal[1][i], fVal[0][i], fW[i]);
1435  }
1436  }
1437  //__________________________3D scatter plot (3rd variable = col)__
1438  else if (fAction == 33) {
1439  TH2 *h2 = (TH2*)fObject;
1440  TakeEstimate();
1441  Int_t ncolors = gStyle->GetNumberOfColors();
1442  TObjArray *grs = (TObjArray*)h2->GetListOfFunctions()->FindObject("graphs");
1443  Int_t col;
1444  TGraph *gr;
1445  if (!grs) {
1446  grs = new TObjArray(ncolors);
1447  grs->SetOwner();
1448  grs->SetName("graphs");
1449  h2->GetListOfFunctions()->Add(grs, "P");
1450  for (col = 0; col < ncolors; col++) {
1451  gr = new TGraph();
1452  gr->SetMarkerColor(gStyle->GetColorPalette(col));
1453  gr->SetMarkerStyle(fTree->GetMarkerStyle());
1454  gr->SetMarkerSize(fTree->GetMarkerSize());
1455  grs->AddAt(gr, col);
1456  }
1457  }
1458  h2->SetEntries(fNfill);
1459  h2->SetMinimum(fVmin[2]);
1460  h2->SetMaximum(fVmax[2]);
1461  // Fill the graphs according to the color
1462  for (i = 0; i < fNfill; i++) {
1463  col = Int_t(ncolors * ((fVal[2][i] - fVmin[2]) / (fVmax[2] - fVmin[2])));
1464  if (col < 0) col = 0;
1465  if (col > ncolors - 1) col = ncolors - 1;
1466  gr = (TGraph*)grs->UncheckedAt(col);
1467  if (gr) gr->SetPoint(gr->GetN(), fVal[1][i], fVal[0][i]);
1468  }
1469  // Remove potential empty graphs
1470  for (col = 0; col < ncolors; col++) {
1471  gr = (TGraph*)grs->At(col);
1472  if (gr && gr->GetN() <= 0) grs->Remove(gr);
1473  }
1474  }
1475  //__________________________2D Profile Histogram__________________
1476  else if (fAction == 23) {
1477  TProfile2D *hp2 = (TProfile2D*)fObject;
1478  for (i = 0; i < fNfill; i++) hp2->Fill(fVal[2][i], fVal[1][i], fVal[0][i], fW[i]);
1479  }
1480  //__________________________4D scatter plot_______________________
1481  else if (fAction == 40) {
1482  TakeEstimate();
1483  TH3 *h3 = (TH3*)fObject;
1484  Int_t ncolors = gStyle->GetNumberOfColors();
1485  if (ncolors == 0) {
1486  TColor::InitializeColors();
1487  ncolors = gStyle->GetNumberOfColors();
1488  }
1489  TObjArray *pms = (TObjArray*)h3->GetListOfFunctions()->FindObject("polymarkers");
1490  Int_t col;
1491  TPolyMarker3D *pm3d;
1492  if (!pms) {
1493  pms = new TObjArray(ncolors);
1494  pms->SetOwner();
1495  pms->SetName("polymarkers");
1496  h3->GetListOfFunctions()->Add(pms);
1497  for (col = 0; col < ncolors; col++) {
1498  pm3d = new TPolyMarker3D();
1499  pm3d->SetMarkerColor(gStyle->GetColorPalette(col));
1500  pm3d->SetMarkerStyle(fTree->GetMarkerStyle());
1501  pm3d->SetMarkerSize(fTree->GetMarkerSize());
1502  pms->AddAt(pm3d, col);
1503  }
1504  }
1505  h3->SetEntries(fNfill);
1506  h3->SetMinimum(fVmin[3]);
1507  h3->SetMaximum(fVmax[3]);
1508  for (i = 0; i < fNfill; i++) {
1509  col = Int_t(ncolors * ((fVal[3][i] - fVmin[3]) / (fVmax[3] - fVmin[3])));
1510  if (col > ncolors-1) col = ncolors-1;
1511  if (col < 0) col = 0;
1512  pm3d = (TPolyMarker3D*)pms->UncheckedAt(col);
1513  pm3d->SetPoint(pm3d->GetLastPoint() + 1, fVal[2][i], fVal[1][i], fVal[0][i]);
1514  }
1515  }
1516  //__________________________Parallel coordinates / candle chart_______________________
1517  else if (fAction == 6 || fAction == 7) {
1518  TakeEstimate();
1519  Bool_t candle = (fAction == 7);
1520  // Using CINT to avoid a dependency in TParallelCoord
1521  if (!fOption.Contains("goff"))
1522  gROOT->ProcessLine(TString::Format("TParallelCoord::BuildParallelCoord((TSelectorDraw*)0x%lx,0x%lx)",
1523  (ULong_t)this, (ULong_t)candle));
1524  } else if (fAction == 8) {
1525  //gROOT->ProcessLineFast(TString::Format("(new TGL5DDataSet((TTree *)0x%1x))->Draw(\"%s\");", fTree, fOption.Data()));
1526  }
1527  //__________________________something else_______________________
1528  else if (fAction < 0) {
1529  fAction = -fAction;
1530  TakeEstimate();
1531  }
1532 
1533  // Do we need to update screen?
1534  fSelectedRows += fNfill;
1535  if (!fTree->GetUpdate()) return;
1536  if (fSelectedRows > fDraw + fTree->GetUpdate()) {
1537  if (fDraw) gPad->Modified();
1538  else fObject->Draw(fOption.Data());
1539  gPad->Update();
1540  fDraw = fSelectedRows;
1541  }
1542 }
1543 
1544 ////////////////////////////////////////////////////////////////////////////////
1545 /// Estimate limits for 1-D, 2-D or 3-D objects.
1546 
1547 void TSelectorDraw::TakeEstimate()
1548 {
1549  Int_t i;
1550  Double_t rmin[3], rmax[3];
1551  Double_t vminOld[4], vmaxOld[4];
1552  for (i = 0; i < fValSize && i < 4; i++) {
1553  vminOld[i] = fVmin[i];
1554  vmaxOld[i] = fVmax[i];
1555  }
1556  for (i = 0; i < fValSize; ++i) {
1557  fVmin[i] = DBL_MAX;
1558  fVmax[i] = - DBL_MAX;
1559  }
1560  //__________________________1-D histogram_______________________
1561  if (fAction == 1) {
1562  TH1 *h1 = (TH1*)fObject;
1563  if (h1->CanExtendAllAxes()) {
1564  for (i = 0; i < fNfill; i++) {
1565  if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
1566  if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
1567  }
1568  THLimitsFinder::GetLimitsFinder()->FindGoodLimits(h1, fVmin[0], fVmax[0]);
1569  }
1570  h1->FillN(fNfill, fVal[0], fW);
1571  //__________________________2-D histogram_______________________
1572  } else if (fAction == 2) {
1573  TH2 *h2 = (TH2*)fObject;
1574  if (h2->CanExtendAllAxes()) {
1575  for (i = 0; i < fNfill; i++) {
1576  if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
1577  if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
1578  if (fVmin[1] > fVal[1][i]) fVmin[1] = fVal[1][i];
1579  if (fVmax[1] < fVal[1][i]) fVmax[1] = fVal[1][i];
1580  }
1581  THLimitsFinder::GetLimitsFinder()->FindGoodLimits(h2, fVmin[1], fVmax[1], fVmin[0], fVmax[0]);
1582  }
1583  for (i = 0; i < fNfill; i++) h2->Fill(fVal[1][i], fVal[0][i], fW[i]);
1584  //__________________________Profile histogram_______________________
1585  } else if (fAction == 4) {
1586  TProfile *hp = (TProfile*)fObject;
1587  if (hp->CanExtendAllAxes()) {
1588  for (i = 0; i < fNfill; i++) {
1589  if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
1590  if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
1591  if (fVmin[1] > fVal[1][i]) fVmin[1] = fVal[1][i];
1592  if (fVmax[1] < fVal[1][i]) fVmax[1] = fVal[1][i];
1593  }
1594  THLimitsFinder::GetLimitsFinder()->FindGoodLimits(hp, fVmin[1], fVmax[1]);
1595  }
1596  hp->FillN(fNfill, fVal[1], fVal[0], fW);
1597  //__________________________2D scatter plot_______________________
1598  } else if (fAction == 12) {
1599  TH2 *h2 = (TH2*)fObject;
1600  if (h2->CanExtendAllAxes()) {
1601  for (i = 0; i < fNfill; i++) {
1602  if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
1603  if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
1604  if (fVmin[1] > fVal[1][i]) fVmin[1] = fVal[1][i];
1605  if (fVmax[1] < fVal[1][i]) fVmax[1] = fVal[1][i];
1606  }
1607  THLimitsFinder::GetLimitsFinder()->FindGoodLimits(h2, fVmin[1], fVmax[1], fVmin[0], fVmax[0]);
1608  // In case the new lower limits of h2 axis are 0, it is better to set them to the minimum of
1609  // the data set (which should be >0) to avoid data cut when plotting in log scale.
1610  TAxis *aX = h2->GetXaxis();
1611  TAxis *aY = h2->GetYaxis();
1612  Double_t xmin = aX->GetXmin();
1613  Double_t ymin = aY->GetXmin();
1614  if (xmin == 0 || ymin == 0) {
1615  if (aX->GetBinUpEdge(aX->FindFixBin(0.01*aX->GetBinWidth(aX->GetFirst()))) > fVmin[1]) xmin = fVmin[1];
1616  if (aY->GetBinUpEdge(aY->FindFixBin(0.01*aY->GetBinWidth(aY->GetFirst()))) > fVmin[0]) ymin = fVmin[0];
1617  h2->SetBins(aX->GetNbins(), xmin, aX->GetXmax(), aY->GetNbins(), ymin, aY->GetXmax());
1618  }
1619  }
1620 
1621  if (!strstr(fOption.Data(), "same") && !strstr(fOption.Data(), "goff")) {
1622  if (!h2->TestBit(kCanDelete)) {
1623  // case like: T.Draw("y:x>>myhist")
1624  // we must draw a copy before filling the histogram h2=myhist
1625  // because h2 will be filled below and we do not want to show
1626  // the binned scatter-plot, the TGraph being better.
1627  TH1 *h2c = h2->DrawCopy(fOption.Data(),"");
1628  if (h2c) h2c->SetStats(kFALSE);
1629  } else {
1630  // case like: T.Draw("y:x")
1631  // h2 is a temporary histogram (htemp). This histogram
1632  // will be automatically deleted by TPad::Clear
1633  h2->Draw();
1634  }
1635  gPad->Update();
1636  }
1637  TGraph *pm = new TGraph(fNfill, fVal[1], fVal[0]);
1638  pm->SetEditable(kFALSE);
1639  pm->SetBit(kCanDelete);
1640  pm->SetMarkerStyle(fTree->GetMarkerStyle());
1641  pm->SetMarkerColor(fTree->GetMarkerColor());
1642  pm->SetMarkerSize(fTree->GetMarkerSize());
1643  pm->SetLineColor(fTree->GetLineColor());
1644  pm->SetLineWidth(fTree->GetLineWidth());
1645  pm->SetLineStyle(fTree->GetLineStyle());
1646  pm->SetFillColor(fTree->GetFillColor());
1647  pm->SetFillStyle(fTree->GetFillStyle());
1648  if (!fDraw && !strstr(fOption.Data(),"goff")) {
1649  if (fOption.Length() == 0 || strcasecmp(fOption.Data(),"same")==0) {
1650  pm->Draw("p");
1651  }
1652  else {
1653  TString opt = fOption;
1654  opt.ToLower();
1655  if (opt.Contains("a")) {
1656  TString temp(opt);
1657  temp.ReplaceAll("same","");
1658  if (temp.Contains("a")) {
1659  if (h2->TestBit(kCanDelete)) {
1660  // h2 will be deleted, the axis setting is delegated to only
1661  // the TGraph.
1662  h2 = 0;
1663  }
1664  }
1665  }
1666  pm->Draw(fOption.Data());
1667  }
1668  }
1669  if (h2 && !h2->TestBit(kCanDelete)) {
1670  for (i = 0; i < fNfill; i++) h2->Fill(fVal[1][i], fVal[0][i], fW[i]);
1671  }
1672  //__________________________3D scatter plot with option col_______________________
1673  } else if (fAction == 33) {
1674  TH2 *h2 = (TH2*)fObject;
1675  Bool_t process2 = kFALSE;
1676  if (h2->CanExtendAllAxes()) {
1677  if (vminOld[2] == DBL_MAX)
1678  process2 = kTRUE;
1679  for (i = 0; i < fValSize && i < 4; i++) {
1680  fVmin[i] = vminOld[i];
1681  fVmax[i] = vmaxOld[i];
1682  }
1683  for (i = 0; i < fNfill; i++) {
1684  if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
1685  if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
1686  if (fVmin[1] > fVal[1][i]) fVmin[1] = fVal[1][i];
1687  if (fVmax[1] < fVal[1][i]) fVmax[1] = fVal[1][i];
1688  if (process2) {
1689  if (fVmin[2] > fVal[2][i]) fVmin[2] = fVal[2][i];
1690  if (fVmax[2] < fVal[2][i]) fVmax[2] = fVal[2][i];
1691  }
1692  }
1693  THLimitsFinder::GetLimitsFinder()->FindGoodLimits(h2, fVmin[1], fVmax[1], fVmin[0], fVmax[0]);
1694  // In case the new lower limits of h2 axis are 0, it is better to set them to the minimum of
1695  // the data set (which should be >0) to avoid data cut when plotting in log scale.
1696  TAxis *aX = h2->GetXaxis();
1697  TAxis *aY = h2->GetYaxis();
1698  Double_t xmin = aX->GetXmin();
1699  Double_t ymin = aY->GetXmin();
1700  if (xmin == 0 || ymin == 0) {
1701  if (aX->GetBinUpEdge(aX->FindFixBin(0.01*aX->GetBinWidth(aX->GetFirst()))) > fVmin[1]) xmin = fVmin[1];
1702  if (aY->GetBinUpEdge(aY->FindFixBin(0.01*aY->GetBinWidth(aY->GetFirst()))) > fVmin[0]) ymin = fVmin[0];
1703  h2->SetBins(aX->GetNbins(), xmin, aX->GetXmax(), aY->GetNbins(), ymin, aY->GetXmax());
1704  }
1705  } else {
1706  for (i = 0; i < fNfill; i++) {
1707  if (fVmin[2] > fVal[2][i]) fVmin[2] = fVal[2][i];
1708  if (fVmax[2] < fVal[2][i]) fVmax[2] = fVal[2][i];
1709  }
1710  }
1711  //__________________________3D scatter plot_______________________
1712  } else if (fAction == 3 || fAction == 13) {
1713  TH3 *h3 = (TH3*)fObject;
1714  if (h3->CanExtendAllAxes()) {
1715  for (i = 0; i < fNfill; i++) {
1716  if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
1717  if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
1718  if (fVmin[1] > fVal[1][i]) fVmin[1] = fVal[1][i];
1719  if (fVmax[1] < fVal[1][i]) fVmax[1] = fVal[1][i];
1720  if (fVmin[2] > fVal[2][i]) fVmin[2] = fVal[2][i];
1721  if (fVmax[2] < fVal[2][i]) fVmax[2] = fVal[2][i];
1722  }
1723  THLimitsFinder::GetLimitsFinder()->FindGoodLimits(h3, fVmin[2], fVmax[2], fVmin[1], fVmax[1], fVmin[0], fVmax[0]);
1724  }
1725  if (fAction == 3) {
1726  for (i = 0; i < fNfill; i++) h3->Fill(fVal[2][i], fVal[1][i], fVal[0][i], fW[i]);
1727  return;
1728  }
1729  if (!strstr(fOption.Data(), "same") && !strstr(fOption.Data(), "goff")) {
1730  if (!h3->TestBit(kCanDelete)) {
1731  // case like: T.Draw("y:x>>myhist")
1732  // we must draw a copy before filling the histogram h3=myhist
1733  // because h3 will be filled below and we do not want to show
1734  // the binned scatter-plot, the TGraph being better.
1735  TH1 *h3c = h3->DrawCopy(fOption.Data(),"");
1736  if (h3c) h3c->SetStats(kFALSE);
1737  } else {
1738  // case like: T.Draw("y:x")
1739  // h3 is a temporary histogram (htemp). This histogram
1740  // will be automatically deleted by TPad::Clear
1741  h3->Draw(fOption.Data());
1742  }
1743  gPad->Update();
1744  } else {
1745  rmin[0] = fVmin[2]; rmin[1] = fVmin[1]; rmin[2] = fVmin[0];
1746  rmax[0] = fVmax[2]; rmax[1] = fVmax[1]; rmax[2] = fVmax[0];
1747  gPad->Clear();
1748  gPad->Range(-1, -1, 1, 1);
1749  TView::CreateView(1, rmin, rmax);
1750  }
1751  TPolyMarker3D *pm3d = new TPolyMarker3D(fNfill);
1752  pm3d->SetMarkerStyle(fTree->GetMarkerStyle());
1753  pm3d->SetMarkerColor(fTree->GetMarkerColor());
1754  pm3d->SetMarkerSize(fTree->GetMarkerSize());
1755  for (i = 0; i < fNfill; i++) {
1756  pm3d->SetPoint(i, fVal[2][i], fVal[1][i], fVal[0][i]);
1757  }
1758  if (!fDraw && !strstr(fOption.Data(), "goff")) pm3d->Draw();
1759  if (!h3->TestBit(kCanDelete)) {
1760  for (i = 0; i < fNfill; i++) h3->Fill(fVal[2][i], fVal[1][i], fVal[0][i], fW[i]);
1761  }
1762 
1763  //__________________________2D Profile Histogram__________________
1764  } else if (fAction == 23) {
1765  TProfile2D *hp = (TProfile2D*)fObject;
1766  if (hp->CanExtendAllAxes()) {
1767  for (i = 0; i < fNfill; i++) {
1768  if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
1769  if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
1770  if (fVmin[1] > fVal[1][i]) fVmin[1] = fVal[1][i];
1771  if (fVmax[1] < fVal[1][i]) fVmax[1] = fVal[1][i];
1772  if (fVmin[2] > fVal[2][i]) fVmin[2] = fVal[2][i];
1773  if (fVmax[2] < fVal[2][i]) fVmax[2] = fVal[2][i];
1774  }
1775  THLimitsFinder::GetLimitsFinder()->FindGoodLimits(hp, fVmin[2], fVmax[2], fVmin[1], fVmax[1]);
1776  }
1777  for (i = 0; i < fNfill; i++) hp->Fill(fVal[2][i], fVal[1][i], fVal[0][i], fW[i]);
1778  //__________________________4D scatter plot_______________________
1779  } else if (fAction == 40) {
1780  TH3 *h3 = (TH3*)fObject;
1781  if (h3->CanExtendAllAxes()) {
1782  for (i = 0; i < fValSize && i < 4; i++) {
1783  fVmin[i] = vminOld[i];
1784  fVmax[i] = vmaxOld[i];
1785  }
1786  for (i = 0; i < fNfill; i++) {
1787  if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
1788  if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
1789  if (fVmin[1] > fVal[1][i]) fVmin[1] = fVal[1][i];
1790  if (fVmax[1] < fVal[1][i]) fVmax[1] = fVal[1][i];
1791  if (fVmin[2] > fVal[2][i]) fVmin[2] = fVal[2][i];
1792  if (fVmax[2] < fVal[2][i]) fVmax[2] = fVal[2][i];
1793  if (fVmin[3] > fVal[3][i]) fVmin[3] = fVal[3][i];
1794  if (fVmax[3] < fVal[3][i]) fVmax[3] = fVal[3][i];
1795  }
1796  THLimitsFinder::GetLimitsFinder()->FindGoodLimits(h3, fVmin[2], fVmax[2], fVmin[1], fVmax[1], fVmin[0], fVmax[0]);
1797  } else {
1798  for (i = 0; i < fNfill; i++) {
1799  if (fVmin[3] > fVal[3][i]) fVmin[3] = fVal[3][i];
1800  if (fVmax[3] < fVal[3][i]) fVmax[3] = fVal[3][i];
1801  }
1802  }
1803  }
1804  //__________________________Parallel coordinates plot / candle chart_______________________
1805  else if (fAction == 6 || fAction == 7) {
1806  for (i = 0; i < fDimension; ++i) {
1807  for (Long64_t entry = 0; entry < fNfill; entry++) {
1808  if (fVmin[i] > fVal[i][entry]) fVmin[i] = fVal[i][entry];
1809  if (fVmax[i] < fVal[i][entry]) fVmax[i] = fVal[i][entry];
1810  }
1811  }
1812  }
1813 }
1814 
1815 ////////////////////////////////////////////////////////////////////////////////
1816 /// Called at the end of a loop on a TTree.
1817 
1818 void TSelectorDraw::Terminate()
1819 {
1820  if (fNfill) TakeAction();
1821 
1822  if ((fSelectedRows == 0) && (TestBit(kCustomHistogram) == 0)) fDraw = 1; // do not draw
1823 
1824  SetStatus(fSelectedRows);
1825 }