Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
TProofDraw.cxx
Go to the documentation of this file.
1 // @(#)root/proofplayer:$Id$
2 // Author: Maarten Ballintijn, Marek Biskup 24/09/2003
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2003, 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 TProofDraw
13 \ingroup proofkernel
14 
15 Implement Tree drawing using PROOF
16 
17 */
18 
19 
20 #include "TProofDraw.h"
21 #include "TAttFill.h"
22 #include "TAttLine.h"
23 #include "TAttMarker.h"
24 #include "TCanvas.h"
25 #include "TClass.h"
26 #include "TError.h"
27 #include "TH1F.h"
28 #include "TH2F.h"
29 #include "TH3F.h"
30 #include "TProof.h"
31 #include "TProofDebug.h"
32 #include "TStatus.h"
33 #include "TTreeDrawArgsParser.h"
34 #include "TTreeFormula.h"
35 #include "TTreeFormulaManager.h"
36 #include "TTree.h"
37 #include "TEventList.h"
38 #include "TEntryList.h"
39 #include "TProfile.h"
40 #include "TProfile2D.h"
41 #include "TEnv.h"
42 #include "TNamed.h"
43 #include "TGraph.h"
44 #include "TPolyMarker3D.h"
45 #include "TVirtualPad.h"
46 #include "THLimitsFinder.h"
47 #include "TView.h"
48 #include "TStyle.h"
49 #include "TDirectory.h"
50 #include "TROOT.h"
51 
52 #include <algorithm>
53 using namespace std;
54 
55 
56 // Simple call to draw a canvas on the fly from applications loading
57 // this plug-in dynamically
58 extern "C" {
59  Int_t DrawCanvas(TObject *obj)
60  {
61  // Draw the object if deriving from a canvas
62 
63  if (TCanvas* c = dynamic_cast<TCanvas *> (obj)) {
64  c->Draw();
65  return 0;
66  }
67  // Not a TCanvas
68  return 1;
69  }
70 }
71 
72 // Simple call to parse arguments on the fly from applications loading
73 // this plug-in dynamically
74 extern "C" {
75  Int_t GetDrawArgs(const char *var, const char *sel, Option_t *opt,
76  TString &selector, TString &objname)
77  {
78  // Parse arguments with the help of TTreeDrawArgsParser
79 
80  TTreeDrawArgsParser info;
81  info.Parse(var, sel, opt);
82  selector = info.GetProofSelectorName();
83  objname = info.GetObjectName();
84 
85  // Done
86  return 0;
87  }
88 }
89 
90 // Simple call to create destroy a 'named' canvas
91 extern "C" {
92  void FeedBackCanvas(const char *name, Bool_t create)
93  {
94  // Create or destroy canvas 'name'
95 
96  if (create) {
97  new TCanvas(name, "FeedBack", 800,30,700,500);
98  } else {
99  TCanvas *c = (gROOT->GetListOfCanvases()) ?
100  (TCanvas *) gROOT->GetListOfCanvases()->FindObject(name) : 0;
101  if (c) delete c;
102  }
103  // Done
104  return;
105  }
106 }
107 
108 ClassImp(TProofDraw);
109 
110 ////////////////////////////////////////////////////////////////////////////////
111 /// Constructor.
112 
113 TProofDraw::TProofDraw()
114  : fStatus(0), fManager(0), fTree(0)
115 {
116  fVar[0] = 0;
117  fVar[1] = 0;
118  fVar[2] = 0;
119  fVar[3] = 0;
120  fManager = 0;
121  fMultiplicity = 0;
122  fSelect = 0;
123  fObjEval = kFALSE;
124  fDimension = 0;
125  fWeight = 1.;
126 }
127 
128 
129 ////////////////////////////////////////////////////////////////////////////////
130 /// Destructor.
131 
132 TProofDraw::~TProofDraw()
133 {
134  ClearFormula();
135 }
136 
137 
138 ////////////////////////////////////////////////////////////////////////////////
139 /// Init the tree.
140 
141 void TProofDraw::Init(TTree *tree)
142 {
143  PDB(kDraw,1) Info("Init","Enter tree = %p", tree);
144  fTree = tree;
145  CompileVariables();
146 }
147 
148 
149 ////////////////////////////////////////////////////////////////////////////////
150 /// Called when a new tree is loaded.
151 
152 Bool_t TProofDraw::Notify()
153 {
154  PDB(kDraw,1) Info("Notify","Enter");
155  if (fStatus == 0) {
156  if (!fOutput || (fOutput &&
157  !(fStatus = dynamic_cast<TStatus*>(fOutput->FindObject("PROOF_Status")))))
158  return kFALSE;
159  }
160  if (!fStatus->IsOk()) return kFALSE;
161  if (!fManager) {
162  fAbort = TSelector::kAbortProcess;
163  return kFALSE;
164  }
165  fManager->UpdateFormulaLeaves();
166  return kTRUE;
167 }
168 
169 ////////////////////////////////////////////////////////////////////////////////
170 /// Executed by the client before processing.
171 
172 void TProofDraw::Begin(TTree *tree)
173 {
174  PDB(kDraw,1) Info("Begin","Enter tree = %p", tree);
175 
176  TObject *os = fInput->FindObject("selection");
177  TObject *ov = fInput->FindObject("varexp");
178 
179  if (os && ov) {
180  fSelection = os->GetTitle();
181  fInitialExp = ov->GetTitle();
182  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
183  if (fTreeDrawArgsParser.GetObjectName() == "")
184  fTreeDrawArgsParser.SetObjectName("htemp");
185  }
186 
187  PDB(kDraw,1) Info("Begin","selection: %s", fSelection.Data());
188  PDB(kDraw,1) Info("Begin","varexp: %s", fInitialExp.Data());
189  fTree = 0;
190 }
191 
192 
193 ////////////////////////////////////////////////////////////////////////////////
194 /// Executed by each slave before processing.
195 
196 void TProofDraw::SlaveBegin(TTree* /*tree*/)
197 {
198  // Get the weight
199  TProofDraw::FillWeight();
200 }
201 
202 ////////////////////////////////////////////////////////////////////////////////
203 /// Get weight from input list, if any
204 
205 void TProofDraw::FillWeight()
206 {
207  Double_t ww;
208  if (TProof::GetParameter(fInput, "PROOF_ChainWeight", ww) == 0)
209  fWeight = ww;
210  PDB(kDraw,1) Info("FillWeight","fWeight= %f", fWeight);
211 }
212 
213 
214 ////////////////////////////////////////////////////////////////////////////////
215 /// Processes a single variable from an entry.
216 
217 Bool_t TProofDraw::ProcessSingle(Long64_t entry, Int_t i)
218 {
219  Double_t w;
220  Double_t v[4]; //[TTreeDrawArgsParser::fgMaxDimension];
221 
222  if (fSelect)
223  w = fWeight * fSelect->EvalInstance(i);
224  else
225  w = fWeight;
226 
227  PDB(kDraw,3) Info("ProcessSingle","w[%d] = %f", i, w);
228 
229  if (w != 0.0) {
230  R__ASSERT(fDimension <= TTreeDrawArgsParser::GetMaxDimension());
231  for (int j = 0; j < fDimension; j++)
232  v[j] = fVar[j]->EvalInstance(i);
233  if (fDimension >= 1)
234  PDB(kDraw,4) Info("Process","v[0] = %f", v[0]);
235  DoFill(entry, w, v);
236  }
237  return kTRUE;
238 }
239 
240 
241 ////////////////////////////////////////////////////////////////////////////////
242 /// Executed for each entry.
243 
244 Bool_t TProofDraw::Process(Long64_t entry)
245 {
246  PDB(kDraw,3) Info("Process", "enter entry = %lld", entry);
247 
248  fTree->LoadTree(entry);
249  Int_t ndata = fManager->GetNdata();
250 
251  PDB(kDraw,3) Info("Process","ndata = %d", ndata);
252 
253  for (Int_t i=0;i<ndata;i++) {
254  ProcessSingle(entry, i);
255  }
256  return kTRUE;
257 }
258 
259 
260 ////////////////////////////////////////////////////////////////////////////////
261 /// Executed by each slave after the processing has finished,
262 /// before returning the results to the client.
263 
264 void TProofDraw::SlaveTerminate(void)
265 {
266  PDB(kDraw,1) Info("SlaveTerminate","Enter");
267 }
268 
269 
270 ////////////////////////////////////////////////////////////////////////////////
271 /// Executed by the client after getting the processing retults.
272 
273 void TProofDraw::Terminate(void)
274 {
275  PDB(kDraw,1) Info("Terminate","Enter");
276  if (fStatus == 0) {
277  fStatus = dynamic_cast<TStatus*>(fOutput->FindObject("PROOF_Status"));
278  if (fStatus == 0) {
279  // did not run selector, error messages were already printed
280  return;
281  }
282  }
283 
284  if (!fStatus->IsOk()) {
285  fStatus->Print();
286  return;
287  }
288 }
289 
290 
291 ////////////////////////////////////////////////////////////////////////////////
292 /// Delete internal buffers.
293 
294 void TProofDraw::ClearFormula()
295 {
296  ResetBit(kWarn);
297  for (Int_t i = 0; i < 4; i++)
298  SafeDelete(fVar[i]);
299  SafeDelete(fSelect);
300  fManager = 0; // This is intentional. The manager is deleted when the last formula it manages
301  // is deleted. This is unusual but was usefull for backward compatibility.
302  fMultiplicity = 0;
303 }
304 
305 ////////////////////////////////////////////////////////////////////////////////
306 /// Move to a canvas named <name>_canvas; create the canvas if not existing.
307 /// Used to avoid screwing up existing plots when non default names are used
308 /// for the final objects
309 
310 void TProofDraw::SetCanvas(const char *objname)
311 {
312  TString name = objname;
313  if (!gPad) {
314  gROOT->MakeDefCanvas();
315  gPad->SetName(name);
316  PDB(kDraw,2) Info("SetCanvas", "created canvas %s", name.Data());
317  } else {
318  PDB(kDraw,2)
319  Info("SetCanvas", "using canvas %s", gPad->GetName());
320  }
321 }
322 
323 ////////////////////////////////////////////////////////////////////////////////
324 /// Set the drawing attributes from the input list
325 
326 void TProofDraw::SetDrawAtt(TObject *o)
327 {
328  Int_t att = -1;
329  PDB(kDraw,2) Info("SetDrawAtt", "setting attributes for %s", o->GetName());
330 
331  // Line Attributes
332  TAttLine *al = dynamic_cast<TAttLine *> (o);
333  if (al) {
334  // Line color
335  if (TProof::GetParameter(fInput, "PROOF_LineColor", att) == 0)
336  al->SetLineColor((Color_t)att);
337  // Line style
338  if (TProof::GetParameter(fInput, "PROOF_LineStyle", att) == 0)
339  al->SetLineStyle((Style_t)att);
340  // Line color
341  if (TProof::GetParameter(fInput, "PROOF_LineWidth", att) == 0)
342  al->SetLineWidth((Width_t)att);
343  PDB(kDraw,2) Info("SetDrawAtt", "line: c:%d, s:%d, wd:%d",
344  al->GetLineColor(), al->GetLineStyle(), al->GetLineWidth());
345  }
346 
347  // Marker Attributes
348  TAttMarker *am = dynamic_cast<TAttMarker *> (o);
349  if (am) {
350  // Marker color
351  if (TProof::GetParameter(fInput, "PROOF_MarkerColor", att) == 0)
352  am->SetMarkerColor((Color_t)att);
353  // Marker size
354  if (TProof::GetParameter(fInput, "PROOF_MarkerSize", att) == 0) {
355  Info("SetDrawAtt", "att: %d", att);
356  Float_t msz = (Float_t)att / 1000.;
357  am->SetMarkerSize((Size_t)msz);
358  }
359  // Marker style
360  if (TProof::GetParameter(fInput, "PROOF_MarkerStyle", att) == 0)
361  am->SetMarkerStyle((Style_t)att);
362  PDB(kDraw,2) Info("SetDrawAtt", "marker: c:%d, s:%d, sz:%f",
363  am->GetMarkerColor(), am->GetMarkerStyle(), am->GetMarkerSize());
364  }
365 
366  // Area Fill Attributes
367  TAttFill *af = dynamic_cast<TAttFill *> (o);
368  if (af) {
369  // Area fill color
370  if (TProof::GetParameter(fInput, "PROOF_FillColor", att) == 0)
371  af->SetFillColor((Color_t)att);
372  // Area fill style
373  if (TProof::GetParameter(fInput, "PROOF_FillStyle", att) == 0)
374  af->SetFillStyle((Style_t)att);
375  PDB(kDraw,2) Info("SetDrawAtt", "area: c:%d, s:%d",
376  af->GetFillColor(), af->GetFillStyle());
377  }
378 }
379 
380 ////////////////////////////////////////////////////////////////////////////////
381 /// Sets the error status.
382 
383 void TProofDraw::SetError(const char *sub, const char *mesg)
384 {
385  if (fStatus == 0) {
386  if (!(fStatus = dynamic_cast<TStatus*>(fOutput->FindObject("PROOF_Status"))))
387  return;
388  }
389 
390  TString m;
391  if (IsA())
392  m.Form("%s::%s: %s", IsA()->GetName(), sub, mesg);
393  else
394  m.Form("TProofDraw::%s: %s", sub, mesg);
395  fStatus->Add(m);
396 }
397 
398 
399 ////////////////////////////////////////////////////////////////////////////////
400 /// Compiles each variable from fTreeDrawArgsParser for the tree fTree.
401 /// Return kFALSE if any of the variable is not compilable.
402 
403 Bool_t TProofDraw::CompileVariables()
404 {
405  // Set aliases, if any
406  TNamed *nms = (TNamed *) fInput->FindObject("PROOF_ListOfAliases");
407  if (nms) {
408  TString names = nms->GetTitle(), n, na;
409  Ssiz_t from = 0;
410  while(names.Tokenize(n, from, ",")) {
411  if (!n.IsNull()) {
412  na.Form("alias:%s", n.Data());
413  TNamed *nm = (TNamed *) fInput->FindObject(na);
414  if (na) fTree->SetAlias(n.Data(), nm->GetTitle());
415  }
416  }
417  }
418  PDB(kDraw,2)
419  if (fTree->GetListOfAliases()) fTree->GetListOfAliases()->Print();
420 
421  fDimension = fTreeDrawArgsParser.GetDimension();
422  fMultiplicity = 0;
423  fObjEval = kFALSE;
424  if (strlen(fTreeDrawArgsParser.GetSelection())) {
425  fSelect = new TTreeFormula("Selection", fTreeDrawArgsParser.GetSelection(), fTree);
426  fSelect->SetQuickLoad(kTRUE);
427  if (!fSelect->GetNdim()) {delete fSelect; fSelect = 0; return kFALSE; }
428  }
429 
430  fManager = new TTreeFormulaManager();
431  if (fSelect) fManager->Add(fSelect);
432  fTree->ResetBit(TTree::kForceRead);
433 
434  for (int i = 0; i < fDimension; i++) {
435  fVar[i] = new TTreeFormula(Form("Var%d", i),fTreeDrawArgsParser.GetVarExp(i),fTree);
436  fVar[i]->SetQuickLoad(kTRUE);
437  if (!fVar[i]->GetNdim()) {
438  ClearFormula();
439  Error("CompileVariables", "Error compiling expression");
440  SetError("CompileVariables", "Error compiling variables");
441 
442  return kFALSE;
443  }
444  fManager->Add(fVar[i]);
445  }
446 
447  fManager->Sync();
448  if (fManager->GetMultiplicity()==-1) fTree->SetBit(TTree::kForceRead);
449  if (fManager->GetMultiplicity()>=1) fMultiplicity = fManager->GetMultiplicity();
450 
451  return kTRUE;
452 #if 0
453  // Commenting out to silence Coverity:
454  // but why was this made inactive?
455  if (fDimension==1) {
456  TClass *cl = fVar[0]->EvalClass();
457  if (cl) {
458  fObjEval = kTRUE;
459  }
460  }
461  return kTRUE;
462 #endif
463 }
464 
465 
466 ClassImp(TProofDrawHist);
467 
468 
469 ////////////////////////////////////////////////////////////////////////////////
470 /// Initialization for 1D Histogram.
471 
472 void TProofDrawHist::Begin1D(TTree *)
473 {
474  R__ASSERT(fTreeDrawArgsParser.GetDimension() == 1);
475  TObject* orig = fTreeDrawArgsParser.GetOriginal();
476  TH1* hold;
477  if (fTreeDrawArgsParser.GetNoParameters() == 0 && (hold = dynamic_cast<TH1*> (orig))) {
478  hold->Reset();
479  fInput->Add(hold);
480  } else {
481  delete orig;
482  DefVar1D();
483  }
484 }
485 
486 
487 ////////////////////////////////////////////////////////////////////////////////
488 /// Initialization for 2D histogram.
489 
490 void TProofDrawHist::Begin2D(TTree *)
491 {
492  R__ASSERT(fTreeDrawArgsParser.GetDimension() == 2);
493  TObject* orig = fTreeDrawArgsParser.GetOriginal();
494  TH2* hold;
495  if (fTreeDrawArgsParser.GetNoParameters() == 0 && (hold = dynamic_cast<TH2*> (orig))) {
496  hold->Reset();
497  fInput->Add(hold);
498  } else {
499  delete orig;
500  DefVar2D();
501  }
502 }
503 
504 
505 ////////////////////////////////////////////////////////////////////////////////
506 /// Initialization for 3D histogram.
507 
508 void TProofDrawHist::Begin3D(TTree *)
509 {
510  R__ASSERT(fTreeDrawArgsParser.GetDimension() == 3);
511  TObject* orig = fTreeDrawArgsParser.GetOriginal();
512  TH3* hold;
513  if ((hold = dynamic_cast<TH3*> (orig)) && fTreeDrawArgsParser.GetNoParameters() == 0) {
514  hold->Reset();
515  fInput->Add(hold);
516  } else {
517  delete orig;
518  DefVar3D();
519  }
520 }
521 
522 ////////////////////////////////////////////////////////////////////////////////
523 /// See TProofDraw::Begin().
524 
525 void TProofDrawHist::Begin(TTree *tree)
526 {
527  PDB(kDraw,1) Info("Begin","Enter tree = %p", tree);
528 
529  TObject *os = fInput->FindObject("selection");
530  TObject *ov = fInput->FindObject("varexp");
531 
532  if (os && ov) {
533  fSelection = os->GetTitle();
534  fInitialExp = ov->GetTitle();
535 
536  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
537  if (fTreeDrawArgsParser.GetObjectName() == "")
538  fTreeDrawArgsParser.SetObjectName("htemp");
539 
540  switch (fTreeDrawArgsParser.GetDimension()) {
541  case 1:
542  Begin1D(tree);
543  break;
544  case 2:
545  Begin2D(tree);
546  break;
547  case 3:
548  Begin3D(tree);
549  break;
550  default:
551  Error("Begin", "Wrong dimension");
552  break;
553  }
554  }
555  PDB(kDraw,1) Info("Begin","selection: %s", fSelection.Data());
556  PDB(kDraw,1) Info("Begin","varexp: %s", fInitialExp.Data());
557  fTree = 0;
558 }
559 
560 ////////////////////////////////////////////////////////////////////////////////
561 /// Define vars for 1D Histogram.
562 
563 void TProofDrawHist::DefVar1D()
564 {
565  R__ASSERT(fTreeDrawArgsParser.GetDimension() == 1);
566 
567  fTreeDrawArgsParser.SetOriginal(0);
568  TString exp = fTreeDrawArgsParser.GetVarExp();
569  exp += ">>";
570  double binsx, minx, maxx;
571  if (fTreeDrawArgsParser.IsSpecified(0))
572  gEnv->SetValue("Hist.Binning.1D.x", fTreeDrawArgsParser.GetParameter(0));
573  binsx = gEnv->GetValue("Hist.Binning.1D.x",100);
574  minx = fTreeDrawArgsParser.GetIfSpecified(1, 0);
575  maxx = fTreeDrawArgsParser.GetIfSpecified(2, 0);
576  exp += fTreeDrawArgsParser.GetObjectName();
577  exp += '(';
578  exp += binsx;
579  exp += ',';
580  exp += minx;
581  exp += ',';
582  exp += maxx;
583  exp += ')';
584 
585  fInitialExp = exp;
586  TNamed *n = dynamic_cast<TNamed*> (fInput->FindObject("varexp"));
587  if (n)
588  n->SetTitle(exp);
589  else
590  Error("DefVar1D", "Cannot find varexp on the fInput");
591  if (fTreeDrawArgsParser.GetNoParameters() != 3)
592  fInput->Add(new TNamed("PROOF_OPTIONS", "rebin"));
593 }
594 
595 ////////////////////////////////////////////////////////////////////////////////
596 /// Define variables for 2D histogram.
597 
598 void TProofDrawHist::DefVar2D()
599 {
600  R__ASSERT(fTreeDrawArgsParser.GetDimension() == 2);
601 
602  fTreeDrawArgsParser.SetOriginal(0);
603  TString exp = fTreeDrawArgsParser.GetVarExp();
604  exp += ">>";
605  double binsx, minx, maxx;
606  double binsy, miny, maxy;
607  if (fTreeDrawArgsParser.IsSpecified(0))
608  gEnv->SetValue("Hist.Binning.2D.x", fTreeDrawArgsParser.GetParameter(0));
609  if (fTreeDrawArgsParser.IsSpecified(3))
610  gEnv->SetValue("Hist.Binning.2D.y", fTreeDrawArgsParser.GetParameter(3));
611  binsx = gEnv->GetValue("Hist.Binning.2D.x",100);
612  minx = fTreeDrawArgsParser.GetIfSpecified(1, 0);
613  maxx = fTreeDrawArgsParser.GetIfSpecified(2, 0);
614  binsy = gEnv->GetValue("Hist.Binning.2D.y",100);
615  miny = fTreeDrawArgsParser.GetIfSpecified(4, 0);
616  maxy = fTreeDrawArgsParser.GetIfSpecified(5, 0);
617  exp += fTreeDrawArgsParser.GetObjectName();
618  exp += '(';
619  exp += binsx;
620  exp += ',';
621  exp += minx;
622  exp += ',';
623  exp += maxx;
624  exp += ',';
625  exp += binsy;
626  exp += ',';
627  exp += miny;
628  exp += ',';
629  exp += maxy;
630  exp += ')';
631  fInitialExp = exp;
632  TNamed *n = dynamic_cast<TNamed*> (fInput->FindObject("varexp"));
633  if (n)
634  n->SetTitle(exp);
635  else
636  Error("DefVar2D", "Cannot find varexp on the fInput");
637  if (fTreeDrawArgsParser.GetNoParameters() != 6)
638  fInput->Add(new TNamed("PROOF_OPTIONS", "rebin"));
639 }
640 
641 ////////////////////////////////////////////////////////////////////////////////
642 /// Define variables for 3D histogram.
643 
644 void TProofDrawHist::DefVar3D()
645 {
646  R__ASSERT(fTreeDrawArgsParser.GetDimension() == 3);
647 
648  fTreeDrawArgsParser.SetOriginal(0);
649  TString exp = fTreeDrawArgsParser.GetVarExp();
650  exp += ">>";
651  double binsx, minx, maxx;
652  double binsy, miny, maxy;
653  double binsz, minz, maxz;
654  if (fTreeDrawArgsParser.IsSpecified(0))
655  gEnv->SetValue("Hist.Binning.3D.x", fTreeDrawArgsParser.GetParameter(0));
656  if (fTreeDrawArgsParser.IsSpecified(3))
657  gEnv->SetValue("Hist.Binning.3D.y", fTreeDrawArgsParser.GetParameter(3));
658  if (fTreeDrawArgsParser.IsSpecified(6))
659  gEnv->SetValue("Hist.Binning.3D.z", fTreeDrawArgsParser.GetParameter(6));
660  binsx = gEnv->GetValue("Hist.Binning.3D.x",100);
661  minx = fTreeDrawArgsParser.GetIfSpecified(1, 0);
662  maxx = fTreeDrawArgsParser.GetIfSpecified(2, 0);
663  binsy = gEnv->GetValue("Hist.Binning.3D.y",100);
664  miny = fTreeDrawArgsParser.GetIfSpecified(4, 0);
665  maxy = fTreeDrawArgsParser.GetIfSpecified(5, 0);
666  binsz = gEnv->GetValue("Hist.Binning.3D.z",100);
667  minz = fTreeDrawArgsParser.GetIfSpecified(7, 0);
668  maxz = fTreeDrawArgsParser.GetIfSpecified(8, 0);
669  exp += fTreeDrawArgsParser.GetObjectName();
670  exp += '(';
671  exp += binsx;
672  exp += ',';
673  exp += minx;
674  exp += ',';
675  exp += maxx;
676  exp += ',';
677  exp += binsy;
678  exp += ',';
679  exp += miny;
680  exp += ',';
681  exp += maxy;
682  exp += ',';
683  exp += binsz;
684  exp += ',';
685  exp += minz;
686  exp += ',';
687  exp += maxz;
688  exp += ')';
689  fInitialExp = exp;
690  TNamed *n = dynamic_cast<TNamed*> (fInput->FindObject("varexp"));
691  if (n)
692  n->SetTitle(exp);
693  else
694  Error("DefVar3D", "Cannot find varexp on the fInput");
695  if (fTreeDrawArgsParser.GetNoParameters() != 9)
696  fInput->Add(new TNamed("PROOF_OPTIONS", "rebin"));
697 }
698 
699 ////////////////////////////////////////////////////////////////////////////////
700 /// Define variables according to arguments.
701 
702 void TProofDrawHist::DefVar()
703 {
704  PDB(kDraw,1) Info("DefVar","Enter");
705 
706  TObject *os = fInput->FindObject("selection");
707  TObject *ov = fInput->FindObject("varexp");
708 
709  if (os && ov) {
710  fSelection = os->GetTitle();
711  fInitialExp = ov->GetTitle();
712 
713  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
714  if (fTreeDrawArgsParser.GetObjectName() == "")
715  fTreeDrawArgsParser.SetObjectName("htemp");
716 
717  switch (fTreeDrawArgsParser.GetDimension()) {
718  case 1:
719  DefVar1D();
720  break;
721  case 2:
722  DefVar2D();
723  break;
724  case 3:
725  DefVar3D();
726  break;
727  default:
728  Error("DefVar", "Wrong dimension");
729  break;
730  }
731  }
732  PDB(kDraw,1) Info("DefVar","selection: %s", fSelection.Data());
733  PDB(kDraw,1) Info("DefVar","varexp: %s", fInitialExp.Data());
734  fTree = 0;
735 }
736 
737 ////////////////////////////////////////////////////////////////////////////////
738 /// See TProofDraw::Init().
739 
740 void TProofDrawHist::Init(TTree *tree)
741 {
742  PDB(kDraw,1) Info("Init","Enter tree = %p", tree);
743  if (fTree == 0) {
744  if (!dynamic_cast<TH1*> (fTreeDrawArgsParser.GetOriginal())) {
745  fHistogram->SetLineColor(tree->GetLineColor());
746  fHistogram->SetLineWidth(tree->GetLineWidth());
747  fHistogram->SetLineStyle(tree->GetLineStyle());
748  fHistogram->SetFillColor(tree->GetFillColor());
749  fHistogram->SetFillStyle(tree->GetFillStyle());
750  fHistogram->SetMarkerStyle(tree->GetMarkerStyle());
751  fHistogram->SetMarkerColor(tree->GetMarkerColor());
752  fHistogram->SetMarkerSize(tree->GetMarkerSize());
753  }
754  }
755  fTree = tree;
756  CompileVariables();
757 }
758 
759 
760 ////////////////////////////////////////////////////////////////////////////////
761 /// See TProofDraw::SlaveBegin().
762 
763 void TProofDrawHist::SlaveBegin(TTree *tree)
764 {
765  PDB(kDraw,1) Info("SlaveBegin","Enter tree = %p", tree);
766 
767  // Get the weight
768  TProofDraw::FillWeight();
769 
770  TObject *os = fInput->FindObject("selection");
771  TObject *ov = fInput->FindObject("varexp");
772 
773  if (os && ov) {
774  fSelection = os->GetTitle();
775  fInitialExp = ov->GetTitle();
776 
777  SafeDelete(fHistogram);
778 
779  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
780  fDimension = fTreeDrawArgsParser.GetDimension();
781  TString exp = fTreeDrawArgsParser.GetExp();
782  const char *objname = fTreeDrawArgsParser.GetObjectName();
783  if (objname && strlen(objname) > 0 && strcmp(objname, "htemp")) {
784  TH1 *hist = dynamic_cast<TH1*> (fInput->FindObject(objname));
785  if (hist) {
786  fHistogram = (TH1 *) hist->Clone();
787  PDB(kDraw,1) Info("SlaveBegin","original histogram found");
788  } else {
789  PDB(kDraw,1) Info("SlaveBegin", "original object '%s' not found"
790  " or it is not a histogram", objname);
791  }
792  }
793 
794  // Create the histogram if not found in the input list
795  if (!fHistogram) {
796  Int_t countx = 100; double minx = 0, maxx = 0;
797  Int_t county = 100; double miny = 0, maxy = 0;
798  Int_t countz = 100; double minz = 0, maxz = 0;
799  if (fTreeDrawArgsParser.GetNoParameters() != 0) {
800  countx = (Int_t) fTreeDrawArgsParser.GetIfSpecified(0, countx);
801  county = (Int_t) fTreeDrawArgsParser.GetIfSpecified(3, county);
802  countz = (Int_t) fTreeDrawArgsParser.GetIfSpecified(6, countz);
803  minx = fTreeDrawArgsParser.GetIfSpecified(1, minx);
804  maxx = fTreeDrawArgsParser.GetIfSpecified(2, maxx);
805  miny = fTreeDrawArgsParser.GetIfSpecified(4, miny);
806  maxy = fTreeDrawArgsParser.GetIfSpecified(5, maxy);
807  minz = fTreeDrawArgsParser.GetIfSpecified(7, minz);
808  maxz = fTreeDrawArgsParser.GetIfSpecified(8, maxz);
809  }
810  if (fTreeDrawArgsParser.GetNoParameters() != 3*fDimension)
811  Error("SlaveBegin", "Impossible - Wrong number of parameters");
812 
813  if (fDimension == 1)
814  fHistogram = new TH1F(fTreeDrawArgsParser.GetObjectName(),
815  fTreeDrawArgsParser.GetObjectTitle(),
816  countx, minx, maxx);
817  else if (fDimension == 2){
818  fHistogram = new TH2F(fTreeDrawArgsParser.GetObjectName(),
819  fTreeDrawArgsParser.GetObjectTitle(),
820  countx, minx, maxx,
821  county, miny, maxy);
822  }
823  else if (fDimension == 3) {
824  fHistogram = new TH3F(fTreeDrawArgsParser.GetObjectName(),
825  fTreeDrawArgsParser.GetObjectTitle(),
826  countx, minx, maxx,
827  county, miny, maxy,
828  countz, minz, maxz);
829  } else {
830  Info("Begin", "Wrong dimension");
831  return; // FIXME: end the session
832  }
833  if (minx >= maxx)
834  fHistogram->SetBuffer(TH1::GetDefaultBufferSize());
835  if (TNamed *opt = dynamic_cast<TNamed*> (fInput->FindObject("PROOF_OPTIONS"))) {
836  if (strstr(opt->GetTitle(), "rebin"))
837  fHistogram->SetCanExtend(TH1::kAllAxes);
838  }
839  }
840  fHistogram->SetDirectory(0); // take ownership
841  fOutput->Add(fHistogram); // release ownership
842  }
843 
844  fTree = 0;
845  PDB(kDraw,1) Info("Begin","selection: %s", fSelection.Data());
846  PDB(kDraw,1) Info("Begin","varexp: %s", fInitialExp.Data());
847 }
848 
849 
850 ////////////////////////////////////////////////////////////////////////////////
851 /// Fills the histgram with given values.
852 
853 void TProofDrawHist::DoFill(Long64_t, Double_t w, const Double_t *v)
854 {
855  if (fDimension == 1)
856  fHistogram->Fill(v[0], w);
857  else if (fDimension == 2)
858  ((TH2F *)fHistogram)->Fill(v[1], v[0], w);
859  else if (fDimension == 3)
860  ((TH3F *)fHistogram)->Fill(v[2], v[1], v[0], w);
861 }
862 
863 
864 ////////////////////////////////////////////////////////////////////////////////
865 /// See TProofDraw::Terminate().
866 
867 void TProofDrawHist::Terminate(void)
868 {
869  PDB(kDraw,1) Info("Terminate","Enter");
870  TProofDraw::Terminate();
871  if (!fStatus)
872  return;
873 
874  fHistogram = (TH1F *) fOutput->FindObject(fTreeDrawArgsParser.GetObjectName());
875  if (fHistogram) {
876  SetStatus((Int_t) fHistogram->GetEntries());
877  TH1 *h = 0;
878  if ((h = dynamic_cast<TH1*> (fTreeDrawArgsParser.GetOriginal()))) {
879  if (!fTreeDrawArgsParser.GetAdd())
880  h->Reset();
881  TList l;
882  l.Add(fHistogram);
883  h->Merge(&l);
884  l.Remove(fHistogram);
885  fOutput->Remove(fHistogram);
886  delete fHistogram;
887  } else {
888  // Set the title
889  fHistogram->SetTitle(fTreeDrawArgsParser.GetObjectTitle());
890  h = fHistogram;
891  }
892  if (fTreeDrawArgsParser.GetShouldDraw()) {
893  // Choose the right canvas
894  SetCanvas(h->GetName());
895  // Draw
896  SetDrawAtt(h);
897  h->Draw(fOption.Data());
898  }
899  }
900  fHistogram = 0;
901 }
902 
903 ClassImp(TProofDrawEventList);
904 
905 ////////////////////////////////////////////////////////////////////////////////
906 /// See TProofDraw::Init().
907 
908 void TProofDrawEventList::Init(TTree *tree)
909 {
910  PDB(kDraw,1) Info("Init","Enter tree = %p", tree);
911 
912  if (fTree) { // new tree is being set
913  if (!fElist)
914  Error("Init", "Impossible - fElist cannot be 0");
915  fEventLists->Add(fElist);
916  }
917  fElist = new TEventList(tree->GetDirectory()->GetName(), tree->GetName());
918  fTree = tree;
919  CompileVariables();
920 }
921 
922 
923 ////////////////////////////////////////////////////////////////////////////////
924 /// See TProofDraw::SlaveBegin().
925 
926 void TProofDrawEventList::SlaveBegin(TTree *tree)
927 {
928  PDB(kDraw,1) Info("SlaveBegin","Enter tree = %p", tree);
929 
930  // Get the weight
931  TProofDraw::FillWeight();
932 
933  TObject *os = fInput->FindObject("selection");
934  TObject *ov = fInput->FindObject("varexp");
935 
936  if (os && ov) {
937  fSelection = os->GetTitle();
938  fInitialExp = ov->GetTitle();
939 
940  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
941 
942  SafeDelete(fEventLists);
943 
944  fDimension = 0;
945  fTree = 0;
946  fEventLists = new TList();
947  fEventLists->SetName("PROOF_EventListsList");
948  fOutput->Add(fEventLists);
949  }
950 
951  PDB(kDraw,1) Info("Begin","selection: %s", fSelection.Data());
952  PDB(kDraw,1) Info("Begin","varexp: %s", fInitialExp.Data());
953 }
954 
955 
956 ////////////////////////////////////////////////////////////////////////////////
957 /// Fills the eventlist with given values.
958 
959 void TProofDrawEventList::DoFill(Long64_t entry, Double_t , const Double_t *)
960 {
961  fElist->Enter(entry);
962 }
963 
964 
965 ////////////////////////////////////////////////////////////////////////////////
966 /// See TProofDraw::SlaveTerminate().
967 
968 void TProofDrawEventList::SlaveTerminate(void)
969 {
970  PDB(kDraw,1) Info("SlaveTerminate","Enter");
971  fEventLists->Add(fElist);
972 }
973 
974 
975 ////////////////////////////////////////////////////////////////////////////////
976 /// See TProofDraw::Terminate().
977 
978 void TProofDrawEventList::Terminate(void)
979 {
980  TProofDraw::Terminate(); // take care of fStatus
981  if (!fStatus)
982  return;
983 
984  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
985 
986  TEventList *el = dynamic_cast<TEventList*> (fOutput->FindObject("PROOF_EventList"));
987  if (el) {
988  el->SetName(fInitialExp.Data()+2);
989  SetStatus(el->GetN());
990  if (TEventList* old = dynamic_cast<TEventList*> (fTreeDrawArgsParser.GetOriginal())) {
991  if (!fTreeDrawArgsParser.GetAdd())
992  old->Reset();
993  old->Add(el);
994  fOutput->Remove(el);
995  delete el;
996  }
997  }
998  else
999  Error("Terminate", "Cannot find output EventList");
1000 
1001 }
1002 
1003 ClassImp(TProofDrawEntryList);
1004 
1005 ////////////////////////////////////////////////////////////////////////////////
1006 /// See TProofDraw::Init().
1007 
1008 void TProofDrawEntryList::Init(TTree *tree)
1009 {
1010  PDB(kDraw,1) Info("Init","Enter tree = %p", tree);
1011 
1012  fTree = tree;
1013  CompileVariables();
1014 }
1015 
1016 ////////////////////////////////////////////////////////////////////////////////
1017 /// See TProofDraw::SlaveBegin().
1018 
1019 void TProofDrawEntryList::SlaveBegin(TTree *tree)
1020 {
1021  PDB(kDraw,1) Info("SlaveBegin","Enter tree = %p", tree);
1022 
1023  // Get the weight
1024  TProofDraw::FillWeight();
1025 
1026  TObject *os = fInput->FindObject("selection");
1027  TObject *ov = fInput->FindObject("varexp");
1028 
1029  if (os && ov) {
1030  fSelection = os->GetTitle();
1031  fInitialExp = ov->GetTitle();
1032 
1033  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
1034 
1035  SafeDelete(fElist);
1036 
1037  fDimension = 0;
1038  fTree = 0;
1039  fElist = new TEntryList("PROOF_EntryList", "PROOF_EntryList");
1040  fOutput->Add(fElist);
1041  }
1042 
1043  PDB(kDraw,1) Info("Begin","selection: %s", fSelection.Data());
1044  PDB(kDraw,1) Info("Begin","varexp: %s", fInitialExp.Data());
1045 }
1046 
1047 ////////////////////////////////////////////////////////////////////////////////
1048 /// Fills the eventlist with given values.
1049 
1050 void TProofDrawEntryList::DoFill(Long64_t entry, Double_t , const Double_t *)
1051 {
1052  fElist->Enter(entry);
1053 }
1054 
1055 ////////////////////////////////////////////////////////////////////////////////
1056 /// See TProofDraw::SlaveTerminate().
1057 
1058 void TProofDrawEntryList::SlaveTerminate(void)
1059 {
1060  PDB(kDraw,1) Info("SlaveTerminate","Enter");
1061  fElist->OptimizeStorage();
1062 }
1063 
1064 ////////////////////////////////////////////////////////////////////////////////
1065 /// See TProofDraw::Terminate().
1066 
1067 void TProofDrawEntryList::Terminate(void)
1068 {
1069  TProofDraw::Terminate(); // take care of fStatus
1070  if (!fStatus)
1071  return;
1072 
1073  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
1074 
1075  TEntryList *el = dynamic_cast<TEntryList*> (fOutput->FindObject("PROOF_EntryList"));
1076 
1077  if (el) {
1078  el->SetName(fInitialExp.Data()+2);
1079  SetStatus(el->GetN());
1080  if (TEntryList* old = dynamic_cast<TEntryList*> (fTreeDrawArgsParser.GetOriginal())) {
1081  if (!fTreeDrawArgsParser.GetAdd())
1082  old->Reset();
1083  old->Add(el);
1084  fOutput->Remove(el);
1085  delete el;
1086  }
1087  }
1088  else
1089  Error("Terminate", "Cannot find output EventList");
1090 
1091 }
1092 
1093 ClassImp(TProofDrawProfile);
1094 
1095 ////////////////////////////////////////////////////////////////////////////////
1096 /// See TProofDraw::Init().
1097 
1098 void TProofDrawProfile::Init(TTree *tree)
1099 {
1100  PDB(kDraw,1) Info("Init","Enter tree = %p", tree);
1101 
1102  if (fTree == 0) {
1103  if (!dynamic_cast<TProfile*> (fTreeDrawArgsParser.GetOriginal())) {
1104  fProfile->SetLineColor(tree->GetLineColor());
1105  fProfile->SetLineWidth(tree->GetLineWidth());
1106  fProfile->SetLineStyle(tree->GetLineStyle());
1107  fProfile->SetFillColor(tree->GetFillColor());
1108  fProfile->SetFillStyle(tree->GetFillStyle());
1109  fProfile->SetMarkerStyle(tree->GetMarkerStyle());
1110  fProfile->SetMarkerColor(tree->GetMarkerColor());
1111  fProfile->SetMarkerSize(tree->GetMarkerSize());
1112  }
1113  }
1114  fTree = tree;
1115  CompileVariables();
1116 }
1117 
1118 ////////////////////////////////////////////////////////////////////////////////
1119 /// Define relevant variables
1120 
1121 void TProofDrawProfile::DefVar()
1122 {
1123  PDB(kDraw,1) Info("DefVar","Enter");
1124 
1125  if (fTreeDrawArgsParser.GetDimension() < 0) {
1126 
1127  // Init parser
1128  TObject *os = fInput->FindObject("selection");
1129  TObject *ov = fInput->FindObject("varexp");
1130 
1131  if (os && ov) {
1132  fSelection = ov->GetTitle();
1133  fInitialExp = ov->GetTitle();
1134 
1135  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
1136  }
1137  }
1138 
1139  R__ASSERT(fTreeDrawArgsParser.GetDimension() == 2);
1140 
1141  fTreeDrawArgsParser.SetOriginal(0);
1142  TString exp = fTreeDrawArgsParser.GetVarExp();
1143  exp += ">>";
1144  double binsx, minx, maxx;
1145  if (fTreeDrawArgsParser.IsSpecified(0))
1146  gEnv->SetValue("Hist.Binning.2D.Prof", fTreeDrawArgsParser.GetParameter(0));
1147  binsx = gEnv->GetValue("Hist.Binning.2D.Prof",100);
1148  minx = fTreeDrawArgsParser.GetIfSpecified(1, 0);
1149  maxx = fTreeDrawArgsParser.GetIfSpecified(2, 0);
1150  if (fTreeDrawArgsParser.GetObjectName() == "")
1151  fTreeDrawArgsParser.SetObjectName("htemp");
1152  exp += fTreeDrawArgsParser.GetObjectName();
1153  exp += '(';
1154  exp += binsx;
1155  exp += ',';
1156  exp += minx;
1157  exp += ',';
1158  exp += maxx;
1159  exp += ')';
1160  fInitialExp = exp;
1161  TNamed *n = dynamic_cast<TNamed*> (fInput->FindObject("varexp"));
1162  if (n)
1163  n->SetTitle(exp);
1164  else
1165  Error("DefVar", "Cannot find varexp on the fInput");
1166  if (fTreeDrawArgsParser.GetNoParameters() != 3)
1167  fInput->Add(new TNamed("PROOF_OPTIONS", "rebin"));
1168 }
1169 
1170 ////////////////////////////////////////////////////////////////////////////////
1171 /// See TProofDraw::Begin().
1172 
1173 void TProofDrawProfile::Begin(TTree *tree)
1174 {
1175  PDB(kDraw,1) Info("Begin","Enter tree = %p", tree);
1176 
1177 
1178  TObject *os = fInput->FindObject("selection");
1179  TObject *ov = fInput->FindObject("varexp");
1180 
1181  if (os && ov) {
1182  fSelection = os->GetTitle();
1183  fInitialExp = ov->GetTitle();
1184 
1185  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
1186 
1187  R__ASSERT(fTreeDrawArgsParser.GetDimension() == 2);
1188 
1189  TObject *orig = fTreeDrawArgsParser.GetOriginal();
1190  TH1* pold;
1191  if ((pold = dynamic_cast<TProfile*> (orig)) && fTreeDrawArgsParser.GetNoParameters() == 0) {
1192  TProfile* pnew = (TProfile*) pold->Clone();
1193  pnew->Reset();
1194  fInput->Add(pnew);
1195  } else {
1196  delete orig;
1197  DefVar();
1198  }
1199  }
1200  PDB(kDraw,1) Info("Begin","selection: %s", fSelection.Data());
1201  PDB(kDraw,1) Info("Begin","varexp: %s", fInitialExp.Data());
1202  fTree = 0;
1203 }
1204 
1205 
1206 ////////////////////////////////////////////////////////////////////////////////
1207 /// See TProofDraw::SlaveBegin().
1208 
1209 void TProofDrawProfile::SlaveBegin(TTree *tree)
1210 {
1211  PDB(kDraw,1) Info("SlaveBegin","Enter tree = %p", tree);
1212 
1213  // Get the weight
1214  TProofDraw::FillWeight();
1215 
1216 
1217  TObject *os = fInput->FindObject("selection");
1218  TObject *ov = fInput->FindObject("varexp");
1219 
1220  if (os && ov) {
1221  fSelection = os->GetTitle();
1222  fInitialExp = ov->GetTitle();
1223 
1224  SafeDelete(fProfile);
1225 
1226 
1227  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
1228  fDimension = 2;
1229  TString exp = fTreeDrawArgsParser.GetExp();
1230 
1231  if (fTreeDrawArgsParser.GetOriginal()) {
1232  fProfile = dynamic_cast<TProfile*> (fTreeDrawArgsParser.GetOriginal());
1233  if (fProfile) {
1234  fOutput->Add(fProfile);
1235  PDB(kDraw,1) Info("SlaveBegin","Original profile histogram found");
1236  return;
1237  }
1238  else
1239  Error("SlaveBegin","Original object found but it is not a histogram");
1240  }
1241  Int_t countx = 100; double minx = 0, maxx = 0;
1242  if (fTreeDrawArgsParser.GetNoParameters() != 0) {
1243  countx = (Int_t) fTreeDrawArgsParser.GetIfSpecified(0, countx);
1244  minx = fTreeDrawArgsParser.GetIfSpecified(1, minx);
1245  maxx = fTreeDrawArgsParser.GetIfSpecified(2, maxx);
1246  }
1247  if (fTreeDrawArgsParser.GetNoParameters() != 3)
1248  Error("SlaveBegin", "Impossible - Wrong number of parameters");
1249  TString constructorOptions = "";
1250  if (fOption.Contains("profs"))
1251  constructorOptions = "s";
1252  else if (fOption.Contains("profi"))
1253  constructorOptions = "i";
1254  else if (fOption.Contains("profg"))
1255  constructorOptions = "g";
1256 
1257  fProfile = new TProfile(fTreeDrawArgsParser.GetObjectName(),
1258  fTreeDrawArgsParser.GetObjectTitle(),
1259  countx, minx, maxx,
1260  constructorOptions);
1261  if (minx >= maxx)
1262  fProfile->SetBuffer(TH1::GetDefaultBufferSize());
1263 
1264  if (TNamed *opt = dynamic_cast<TNamed*> (fInput->FindObject("PROOF_OPTIONS"))) {
1265  if (strstr(opt->GetTitle(), "rebin"))
1266  fProfile->SetCanExtend(TH1::kAllAxes);
1267  }
1268  fProfile->SetDirectory(0); // take ownership
1269  fOutput->Add(fProfile); // release ownership
1270  }
1271  fTree = 0;
1272  PDB(kDraw,1) Info("Begin","selection: %s", fSelection.Data());
1273  PDB(kDraw,1) Info("Begin","varexp: %s", fInitialExp.Data());
1274 }
1275 
1276 
1277 ////////////////////////////////////////////////////////////////////////////////
1278 /// Fills the profile histogram with the given values.
1279 
1280 void TProofDrawProfile::DoFill(Long64_t , Double_t w, const Double_t *v)
1281 {
1282  fProfile->Fill(v[1], v[0], w);
1283 }
1284 
1285 
1286 ////////////////////////////////////////////////////////////////////////////////
1287 /// See TProofDraw::Terminate().
1288 
1289 void TProofDrawProfile::Terminate(void)
1290 {
1291  PDB(kDraw,1) Info("Terminate","Enter");
1292  TProofDraw::Terminate();
1293  if (!fStatus)
1294  return;
1295 
1296  fProfile = (TProfile *) fOutput->FindObject(fTreeDrawArgsParser.GetObjectName());
1297  if (fProfile) {
1298  SetStatus((Int_t) fProfile->GetEntries());
1299  TProfile *pf = 0;
1300  if ((pf = dynamic_cast<TProfile*> (fTreeDrawArgsParser.GetOriginal()))) {
1301  if (!fTreeDrawArgsParser.GetAdd())
1302  pf->Reset();
1303  TList l;
1304  l.Add(fProfile);
1305  pf->Merge(&l);
1306  l.Remove(fProfile);
1307  fOutput->Remove(fProfile);
1308  delete fProfile;
1309  } else {
1310  fProfile->SetTitle(fTreeDrawArgsParser.GetObjectTitle());
1311  pf = fProfile;
1312  }
1313  if (fTreeDrawArgsParser.GetShouldDraw()) {
1314  // Choose the right canvas
1315  SetCanvas(pf->GetName());
1316  // Draw
1317  SetDrawAtt(pf);
1318  pf->Draw(fOption.Data());
1319  }
1320  }
1321  fProfile = 0;
1322 }
1323 
1324 
1325 ClassImp(TProofDrawProfile2D);
1326 
1327 ////////////////////////////////////////////////////////////////////////////////
1328 /// See TProofDraw::Init().
1329 
1330 void TProofDrawProfile2D::Init(TTree *tree)
1331 {
1332  PDB(kDraw,1) Info("Init","Enter tree = %p", tree);
1333  if (fTree == 0) {
1334  if (!dynamic_cast<TProfile2D*> (fTreeDrawArgsParser.GetOriginal())) {
1335  fProfile->SetLineColor(tree->GetLineColor());
1336  fProfile->SetLineWidth(tree->GetLineWidth());
1337  fProfile->SetLineStyle(tree->GetLineStyle());
1338  fProfile->SetFillColor(tree->GetFillColor());
1339  fProfile->SetFillStyle(tree->GetFillStyle());
1340  fProfile->SetMarkerStyle(tree->GetMarkerStyle());
1341  fProfile->SetMarkerColor(tree->GetMarkerColor());
1342  fProfile->SetMarkerSize(tree->GetMarkerSize());
1343  }
1344  }
1345 
1346  fTree = tree;
1347  CompileVariables();
1348 }
1349 
1350 ////////////////////////////////////////////////////////////////////////////////
1351 /// Define relevant variables
1352 
1353 void TProofDrawProfile2D::DefVar()
1354 {
1355  PDB(kDraw,1) Info("DefVar","Enter");
1356 
1357  if (fTreeDrawArgsParser.GetDimension() < 0) {
1358 
1359  // Init parser
1360  TObject *os = fInput->FindObject("selection");
1361  TObject *ov = fInput->FindObject("varexp");
1362 
1363  if (os && ov) {
1364  fSelection = os->GetTitle();
1365  fInitialExp = ov->GetTitle();
1366 
1367  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
1368  }
1369  }
1370  R__ASSERT(fTreeDrawArgsParser.GetDimension() == 3);
1371 
1372  fTreeDrawArgsParser.SetOriginal(0);
1373  TString exp = fTreeDrawArgsParser.GetVarExp();
1374  exp += ">>";
1375  double binsx, minx, maxx;
1376  double binsy, miny, maxy;
1377  if (fTreeDrawArgsParser.IsSpecified(0))
1378  gEnv->SetValue("Hist.Binning.3D.Profx", fTreeDrawArgsParser.GetParameter(0));
1379  if (fTreeDrawArgsParser.IsSpecified(3))
1380  gEnv->SetValue("Hist.Binning.3D.Profy", fTreeDrawArgsParser.GetParameter(3));
1381  binsx = gEnv->GetValue("Hist.Binning.3D.Profx",20);
1382  minx = fTreeDrawArgsParser.GetIfSpecified(1, 0);
1383  maxx = fTreeDrawArgsParser.GetIfSpecified(2, 0);
1384  binsy = gEnv->GetValue("Hist.Binning.3D.Profy",20);
1385  miny = fTreeDrawArgsParser.GetIfSpecified(4, 0);
1386  maxy = fTreeDrawArgsParser.GetIfSpecified(5, 0);
1387  if (fTreeDrawArgsParser.GetObjectName() == "")
1388  fTreeDrawArgsParser.SetObjectName("htemp");
1389  exp += fTreeDrawArgsParser.GetObjectName();
1390  exp += '(';
1391  exp += binsx;
1392  exp += ',';
1393  exp += minx;
1394  exp += ',';
1395  exp += maxx;
1396  exp += ',';
1397  exp += binsy;
1398  exp += ',';
1399  exp += miny;
1400  exp += ',';
1401  exp += maxy;
1402  exp += ')';
1403  fInitialExp = exp;
1404  TNamed *n = dynamic_cast<TNamed*> (fInput->FindObject("varexp"));
1405  if (n)
1406  n->SetTitle(exp);
1407  else
1408  Error("DefVar", "Cannot find varexp on the fInput");
1409  if (fTreeDrawArgsParser.GetNoParameters() != 6)
1410  fInput->Add(new TNamed("PROOF_OPTIONS", "rebin"));
1411 }
1412 
1413 ////////////////////////////////////////////////////////////////////////////////
1414 /// See TProofDraw::Begin().
1415 
1416 void TProofDrawProfile2D::Begin(TTree *tree)
1417 {
1418  PDB(kDraw,1) Info("Begin","Enter tree = %p", tree);
1419 
1420  TObject *os = fInput->FindObject("selection");
1421  TObject *ov = fInput->FindObject("varexp");
1422 
1423  if (os && ov) {
1424  fSelection = os->GetTitle();
1425  fInitialExp = ov->GetTitle();
1426 
1427  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
1428 
1429  R__ASSERT(fTreeDrawArgsParser.GetDimension() == 3);
1430 
1431  TObject *orig = fTreeDrawArgsParser.GetOriginal();
1432  TProfile2D *pold;
1433  if ((pold = dynamic_cast<TProfile2D*> (orig)) && fTreeDrawArgsParser.GetNoParameters() == 0) {
1434  TProfile2D* pnew = (TProfile2D*) pold->Clone();
1435  pnew->Reset();
1436  fInput->Add(pnew);
1437  } else {
1438  delete orig;
1439  DefVar();
1440  }
1441  }
1442  PDB(kDraw,1) Info("Begin","selection: %s", fSelection.Data());
1443  PDB(kDraw,1) Info("Begin","varexp: %s", fInitialExp.Data());
1444 }
1445 
1446 ////////////////////////////////////////////////////////////////////////////////
1447 /// See TProofDraw::SlaveBegin().
1448 
1449 void TProofDrawProfile2D::SlaveBegin(TTree *tree)
1450 {
1451  PDB(kDraw,1) Info("SlaveBegin","Enter tree = %p", tree);
1452 
1453  // Get the weight
1454  TProofDraw::FillWeight();
1455 
1456  TObject *os = fInput->FindObject("selection");
1457  TObject *ov = fInput->FindObject("varexp");
1458 
1459  if (os && ov) {
1460  fSelection = os->GetTitle();
1461  fInitialExp = ov->GetTitle();
1462 
1463  SafeDelete(fProfile);
1464 
1465  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
1466  fDimension = 2;
1467  TString exp = fTreeDrawArgsParser.GetExp();
1468 
1469  if (fTreeDrawArgsParser.GetOriginal()) {
1470  fProfile = dynamic_cast<TProfile2D*> (fTreeDrawArgsParser.GetOriginal());
1471  if (fProfile) {
1472  fOutput->Add(fProfile);
1473  PDB(kDraw,1) Info("SlaveBegin","Original profile histogram found");
1474  return;
1475  } else
1476  Error("SlaveBegin","Original object found but it is not a histogram");
1477  }
1478  Int_t countx = 40; double minx = 0, maxx = 0;
1479  Int_t county = 40; double miny = 0, maxy = 0;
1480  if (fTreeDrawArgsParser.GetNoParameters() != 0) {
1481  countx = (Int_t) fTreeDrawArgsParser.GetIfSpecified(0, countx);
1482  minx = fTreeDrawArgsParser.GetIfSpecified(1, minx);
1483  maxx = fTreeDrawArgsParser.GetIfSpecified(2, maxx);
1484  county = (Int_t) fTreeDrawArgsParser.GetIfSpecified(3, countx);
1485  miny = fTreeDrawArgsParser.GetIfSpecified(4, minx);
1486  maxy = fTreeDrawArgsParser.GetIfSpecified(5, maxx);
1487  }
1488  if (fTreeDrawArgsParser.GetNoParameters() != 6)
1489  Error("SlaveBegin", "Impossible - Wrong number of parameters");
1490 
1491  TString constructorOptions = "";
1492  if (fOption.Contains("profs"))
1493  constructorOptions = "s";
1494  else if (fOption.Contains("profi"))
1495  constructorOptions = "i";
1496  else if (fOption.Contains("profg"))
1497  constructorOptions = "g";
1498 
1499  fProfile = new TProfile2D(fTreeDrawArgsParser.GetObjectName(),
1500  fTreeDrawArgsParser.GetObjectTitle(),
1501  countx, minx, maxx,
1502  county, miny, maxy,
1503  constructorOptions);
1504  if (minx >= maxx)
1505  fProfile->SetBuffer(TH1::GetDefaultBufferSize());
1506 
1507  if (TNamed *opt = dynamic_cast<TNamed*> (fInput->FindObject("PROOF_OPTIONS"))) {
1508  if (strstr(opt->GetTitle(), "rebin"))
1509  fProfile->SetCanExtend(TH1::kAllAxes);
1510  }
1511  fProfile->SetDirectory(0); // take ownership
1512  fOutput->Add(fProfile); // release ownership
1513  }
1514  fTree = 0;
1515  PDB(kDraw,1) Info("Begin","selection: %s", fSelection.Data());
1516  PDB(kDraw,1) Info("Begin","varexp: %s", fInitialExp.Data());
1517 }
1518 
1519 
1520 ////////////////////////////////////////////////////////////////////////////////
1521 /// Fills the histogram with the given values.
1522 
1523 void TProofDrawProfile2D::DoFill(Long64_t , Double_t w, const Double_t *v)
1524 {
1525  fProfile->Fill(v[2], v[1], v[0], w);
1526 }
1527 
1528 
1529 ////////////////////////////////////////////////////////////////////////////////
1530 /// See TProofDraw::Terminate().
1531 
1532 void TProofDrawProfile2D::Terminate(void)
1533 {
1534  PDB(kDraw,1) Info("Terminate","Enter");
1535  TProofDraw::Terminate();
1536  if (!fStatus)
1537  return;
1538 
1539  fProfile = (TProfile2D *) fOutput->FindObject(fTreeDrawArgsParser.GetObjectName());
1540  if (fProfile) {
1541  SetStatus((Int_t) fProfile->GetEntries());
1542  TProfile2D *pf = 0;
1543  if ((pf = dynamic_cast<TProfile2D*> (fTreeDrawArgsParser.GetOriginal()))) {
1544  if (!fTreeDrawArgsParser.GetAdd())
1545  pf->Reset();
1546  TList l;
1547  l.Add(fProfile);
1548  pf->Merge(&l);
1549  l.Remove(fProfile);
1550  fOutput->Remove(fProfile);
1551  delete fProfile;
1552  } else {
1553  fProfile->SetTitle(fTreeDrawArgsParser.GetObjectTitle());
1554  pf = fProfile;
1555  }
1556  if (fTreeDrawArgsParser.GetShouldDraw()) {
1557  // Choose the right canvas
1558  SetCanvas(pf->GetName());
1559  // Draw
1560  SetDrawAtt(pf);
1561  pf->Draw(fOption.Data());
1562  }
1563  }
1564  fProfile = 0;
1565 }
1566 
1567 
1568 ClassImp(TProofDrawGraph);
1569 
1570 ////////////////////////////////////////////////////////////////////////////////
1571 /// See TProofDraw::Init().
1572 
1573 void TProofDrawGraph::Init(TTree *tree)
1574 {
1575  PDB(kDraw,1) Info("Init","Enter tree = %p", tree);
1576 
1577  if (fTree == 0) {
1578  R__ASSERT(fGraph);
1579  fGraph->SetMarkerStyle(tree->GetMarkerStyle());
1580  fGraph->SetMarkerColor(tree->GetMarkerColor());
1581  fGraph->SetMarkerSize(tree->GetMarkerSize());
1582  fGraph->SetLineColor(tree->GetLineColor());
1583  fGraph->SetLineStyle(tree->GetLineStyle());
1584  fGraph->SetFillColor(tree->GetFillColor());
1585  fGraph->SetFillStyle(tree->GetFillStyle());
1586  }
1587  fTree = tree;
1588  CompileVariables();
1589 }
1590 
1591 
1592 ////////////////////////////////////////////////////////////////////////////////
1593 /// See TProofDraw::SlaveBegin().
1594 
1595 void TProofDrawGraph::SlaveBegin(TTree *tree)
1596 {
1597  PDB(kDraw,1) Info("SlaveBegin","Enter tree = %p", tree);
1598 
1599  // Get the weight
1600  TProofDraw::FillWeight();
1601 
1602  TObject *os = fInput->FindObject("selection");
1603  TObject *ov = fInput->FindObject("varexp");
1604 
1605  if (os && ov) {
1606  fSelection = os->GetTitle();
1607  fInitialExp = ov->GetTitle();
1608  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
1609 
1610  SafeDelete(fGraph);
1611  fDimension = 2;
1612 
1613  fGraph = new TGraph();
1614  fGraph->SetName("PROOF_GRAPH");
1615  fOutput->Add(fGraph); // release ownership
1616  }
1617  PDB(kDraw,1) Info("Begin","selection: %s", fSelection.Data());
1618  PDB(kDraw,1) Info("Begin","varexp: %s", fInitialExp.Data());
1619 }
1620 
1621 
1622 ////////////////////////////////////////////////////////////////////////////////
1623 /// Fills the graph with the given values.
1624 
1625 void TProofDrawGraph::DoFill(Long64_t , Double_t , const Double_t *v)
1626 {
1627  fGraph->SetPoint(fGraph->GetN(), v[1], v[0]);
1628 }
1629 
1630 
1631 ////////////////////////////////////////////////////////////////////////////////
1632 /// See TProofDraw::Terminate().
1633 
1634 void TProofDrawGraph::Terminate(void)
1635 {
1636  PDB(kDraw,1) Info("Terminate","Enter");
1637  TProofDraw::Terminate();
1638  if (!fStatus)
1639  return;
1640 
1641  fGraph = dynamic_cast<TGraph*> (fOutput->FindObject("PROOF_GRAPH"));
1642  if (fGraph) {
1643  SetStatus((Int_t) fGraph->GetN());
1644  TH2F* hist;
1645  TObject *orig = fTreeDrawArgsParser.GetOriginal();
1646  if ( (hist = dynamic_cast<TH2F*> (orig)) == 0 ) {
1647  delete orig;
1648  fTreeDrawArgsParser.SetOriginal(0);
1649  double binsx, minx, maxx;
1650  double binsy, miny, maxy;
1651  if (fTreeDrawArgsParser.IsSpecified(0))
1652  gEnv->SetValue("Hist.Binning.2D.x", fTreeDrawArgsParser.GetParameter(0));
1653  if (fTreeDrawArgsParser.IsSpecified(3))
1654  gEnv->SetValue("Hist.Binning.2D.y", fTreeDrawArgsParser.GetParameter(3));
1655  binsx = gEnv->GetValue("Hist.Binning.2D.x",100);
1656  minx = fTreeDrawArgsParser.GetIfSpecified(1, 0);
1657  maxx = fTreeDrawArgsParser.GetIfSpecified(2, 0);
1658  binsy = gEnv->GetValue("Hist.Binning.2D.y",100);
1659  miny = fTreeDrawArgsParser.GetIfSpecified(4, 0);
1660  maxy = fTreeDrawArgsParser.GetIfSpecified(5, 0);
1661  hist = new TH2F(fTreeDrawArgsParser.GetObjectName(), fTreeDrawArgsParser.GetObjectTitle(),
1662  (Int_t) binsx, minx, maxx, (Int_t) binsy, miny, maxy);
1663  hist->SetBit(TH1::kNoStats);
1664  hist->SetBit(kCanDelete);
1665  if (fTreeDrawArgsParser.GetNoParameters() != 6)
1666  hist->SetCanExtend(TH1::kAllAxes);
1667  else
1668  hist->SetCanExtend(TH1::kNoAxis);
1669 // if (fTreeDrawArgsParser.GetShouldDraw()) // ?? FIXME
1670 // hist->SetDirectory(0);
1671  } else {
1672  if (!fTreeDrawArgsParser.GetAdd())
1673  hist->Reset();
1674  }
1675  if (hist->CanExtendAllAxes() && hist->TestBit(kCanDelete)) {
1676  Double_t* xArray = fGraph->GetX();
1677  Double_t* yArray = fGraph->GetY();
1678  Double_t xmin = *std::min_element(xArray, xArray+fGraph->GetN());
1679  Double_t xmax = *std::max_element(xArray, xArray+fGraph->GetN());
1680  Double_t ymin = *std::min_element(yArray, yArray+fGraph->GetN());
1681  Double_t ymax = *std::max_element(yArray, yArray+fGraph->GetN());
1682  THLimitsFinder::GetLimitsFinder()->FindGoodLimits(hist,xmin,xmax,ymin,ymax);
1683  }
1684  if (!hist->TestBit(kCanDelete)) {
1685  TH1 *h2c = hist->DrawCopy(fOption.Data());
1686  h2c->SetStats(kFALSE);
1687  } else {
1688  SetDrawAtt(hist);
1689  hist->Draw();
1690  }
1691  gPad->Update();
1692 
1693  fGraph->SetEditable(kFALSE);
1694  // FIXME set color, marker size, etc.
1695 
1696  if (fTreeDrawArgsParser.GetShouldDraw()) {
1697  SetDrawAtt(fGraph);
1698  if (fOption == "" || strcmp(fOption, "same") == 0)
1699  fGraph->Draw("p");
1700  else
1701  fGraph->Draw(fOption);
1702  gPad->Update();
1703  }
1704  if (!hist->TestBit(kCanDelete)) {
1705  for (int i = 0; i < fGraph->GetN(); i++) {
1706  Double_t x = 0, y = 0;
1707  fGraph->GetPoint(i, x, y);
1708  hist->Fill(x, y, 1);
1709  }
1710  }
1711  }
1712  fGraph = 0;
1713 }
1714 
1715 
1716 ClassImp(TProofDrawPolyMarker3D);
1717 
1718 ////////////////////////////////////////////////////////////////////////////////
1719 /// See TProofDraw::Init().
1720 
1721 void TProofDrawPolyMarker3D::Init(TTree *tree)
1722 {
1723  PDB(kDraw,1) Info("Init","Enter tree = %p", tree);
1724 
1725  if (fTree == 0) {
1726  R__ASSERT(fPolyMarker3D);
1727  fPolyMarker3D->SetMarkerStyle(tree->GetMarkerStyle());
1728  fPolyMarker3D->SetMarkerColor(tree->GetMarkerColor());
1729  fPolyMarker3D->SetMarkerSize(tree->GetMarkerSize());
1730  }
1731  fTree = tree;
1732  CompileVariables();
1733 }
1734 
1735 ////////////////////////////////////////////////////////////////////////////////
1736 /// See TProofDraw::SlaveBegin().
1737 
1738 void TProofDrawPolyMarker3D::SlaveBegin(TTree *tree)
1739 {
1740  PDB(kDraw,1) Info("SlaveBegin","Enter tree = %p", tree);
1741 
1742  // Get the weight
1743  TProofDraw::FillWeight();
1744 
1745  TObject *os = fInput->FindObject("selection");
1746  TObject *ov = fInput->FindObject("varexp");
1747 
1748  if (os && ov) {
1749  fSelection = os->GetTitle();
1750  fInitialExp = ov->GetTitle();
1751  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
1752  R__ASSERT(fTreeDrawArgsParser.GetDimension() == 3);
1753 
1754  SafeDelete(fPolyMarker3D);
1755  fDimension = 3;
1756 
1757  fPolyMarker3D = new TPolyMarker3D();
1758  fOutput->Add(fPolyMarker3D); // release ownership
1759  }
1760  PDB(kDraw,1) Info("Begin","selection: %s", fSelection.Data());
1761  PDB(kDraw,1) Info("Begin","varexp: %s", fInitialExp.Data());
1762 }
1763 
1764 
1765 ////////////////////////////////////////////////////////////////////////////////
1766 /// Fills the scatter plot with the given values.
1767 
1768 void TProofDrawPolyMarker3D::DoFill(Long64_t , Double_t , const Double_t *v)
1769 {
1770  fPolyMarker3D->SetNextPoint(v[2], v[1], v[0]);
1771 }
1772 
1773 
1774 ////////////////////////////////////////////////////////////////////////////////
1775 /// See TProofDraw::Terminate().
1776 
1777 void TProofDrawPolyMarker3D::Terminate(void)
1778 {
1779  PDB(kDraw,1) Info("Terminate","Enter");
1780  TProofDraw::Terminate();
1781  if (!fStatus)
1782  return;
1783 
1784  fPolyMarker3D = 0;
1785  TIter next(fOutput);
1786  while (TObject* o = next()) {
1787  if (dynamic_cast<TPolyMarker3D*> (o)) {
1788  fPolyMarker3D = dynamic_cast<TPolyMarker3D*> (o);
1789  break;
1790  }
1791  }
1792 
1793  Bool_t checkPrevious = kFALSE;
1794  if (fPolyMarker3D) {
1795  SetStatus((Int_t) fPolyMarker3D->Size());
1796  TH3F* hist;
1797  TObject *orig = fTreeDrawArgsParser.GetOriginal();
1798  if ( (hist = dynamic_cast<TH3F*> (orig)) == 0 ) {
1799  delete orig;
1800  fTreeDrawArgsParser.SetOriginal(0);
1801  if (fOption.Contains("same")) {
1802  // Check existing histogram
1803  hist = dynamic_cast<TH3F *> (gDirectory->Get(fTreeDrawArgsParser.GetObjectName()));
1804  }
1805  if (!hist) {
1806  double binsx, minx, maxx;
1807  double binsy, miny, maxy;
1808  double binsz, minz, maxz;
1809  if (fTreeDrawArgsParser.IsSpecified(0))
1810  gEnv->SetValue("Hist.Binning.3D.x", fTreeDrawArgsParser.GetParameter(0));
1811  if (fTreeDrawArgsParser.IsSpecified(3))
1812  gEnv->SetValue("Hist.Binning.3D.y", fTreeDrawArgsParser.GetParameter(3));
1813  if (fTreeDrawArgsParser.IsSpecified(6))
1814  gEnv->SetValue("Hist.Binning.3D.z", fTreeDrawArgsParser.GetParameter(6));
1815  binsx = gEnv->GetValue("Hist.Binning.3D.x",100);
1816  minx = fTreeDrawArgsParser.GetIfSpecified(1, 0);
1817  maxx = fTreeDrawArgsParser.GetIfSpecified(2, 0);
1818  binsy = gEnv->GetValue("Hist.Binning.3D.y",100);
1819  miny = fTreeDrawArgsParser.GetIfSpecified(4, 0);
1820  maxy = fTreeDrawArgsParser.GetIfSpecified(5, 0);
1821  binsz = gEnv->GetValue("Hist.Binning.3D.z",100);
1822  minz = fTreeDrawArgsParser.GetIfSpecified(7, 0);
1823  maxz = fTreeDrawArgsParser.GetIfSpecified(8, 0);
1824  hist = new TH3F(fTreeDrawArgsParser.GetObjectName(), fTreeDrawArgsParser.GetObjectTitle(),
1825  (Int_t) binsx, minx, maxx,
1826  (Int_t) binsy, miny, maxy,
1827  (Int_t) binsz, minz, maxz);
1828  hist->SetBit(TH1::kNoStats);
1829  hist->SetBit(kCanDelete);
1830  if (fTreeDrawArgsParser.GetNoParameters() != 9)
1831  hist->SetCanExtend(TH1::kAllAxes);
1832  else
1833  hist->SetCanExtend(TH1::kNoAxis);
1834  } else {
1835  checkPrevious = kTRUE;
1836  PDB(kDraw,2)
1837  Info("Terminate", "found histo '%s' in gDirectory",
1838  fTreeDrawArgsParser.GetObjectName().Data());
1839  }
1840  } else {
1841  if (!fTreeDrawArgsParser.GetAdd())
1842  hist->Reset();
1843  }
1844 
1845  // Set the ranges; take into account previous histos for 'same' runs
1846  Double_t rmin[3], rmax[3];
1847  if (hist->CanExtendAllAxes() && hist->TestBit(kCanDelete)) {
1848  rmin[0] = rmax[0] = rmin[1] = rmax[1] = rmin[2] = rmax[2] = 0;
1849  if (fPolyMarker3D->Size() > 0) {
1850  fPolyMarker3D->GetPoint(0, rmin[0], rmin[1], rmin[2]);
1851  fPolyMarker3D->GetPoint(0, rmax[0], rmax[1], rmax[2]);
1852  }
1853  for (int i = 1; i < fPolyMarker3D->Size(); i++) {
1854  Double_t v[3] = {0};
1855  fPolyMarker3D->GetPoint(i, v[0], v[1], v[2]);
1856  for (int ii = 0; ii < 3; ii++) {
1857  if (v[ii] < rmin[ii]) rmin[ii] = v[ii];
1858  if (v[ii] > rmax[ii]) rmax[ii] = v[ii];
1859  }
1860  }
1861  // Compare with previous histo, if any
1862  if (checkPrevious) {
1863  rmin[0] = (hist->GetXaxis()->GetXmin() < rmin[0]) ? hist->GetXaxis()->GetXmin()
1864  : rmin[0];
1865  rmin[1] = (hist->GetYaxis()->GetXmin() < rmin[1]) ? hist->GetYaxis()->GetXmin()
1866  : rmin[1];
1867  rmin[2] = (hist->GetZaxis()->GetXmin() < rmin[2]) ? hist->GetZaxis()->GetXmin()
1868  : rmin[2];
1869  rmax[0] = (hist->GetXaxis()->GetXmax() > rmax[0]) ? hist->GetXaxis()->GetXmax()
1870  : rmax[0];
1871  rmax[1] = (hist->GetYaxis()->GetXmax() > rmax[1]) ? hist->GetYaxis()->GetXmax()
1872  : rmax[1];
1873  rmax[2] = (hist->GetZaxis()->GetXmax() > rmax[2]) ? hist->GetZaxis()->GetXmax()
1874  : rmax[2];
1875  }
1876 
1877  THLimitsFinder::GetLimitsFinder()->FindGoodLimits(hist,
1878  rmin[0], rmax[0], rmin[1], rmax[1], rmin[2], rmax[2]);
1879  }
1880  if (fTreeDrawArgsParser.GetShouldDraw()) {
1881  if (!hist->TestBit(kCanDelete)) {
1882  TH1 *histcopy = hist->DrawCopy(fOption.Data());
1883  histcopy->SetStats(kFALSE);
1884  } else {
1885  SetDrawAtt(hist);
1886  hist->Draw(fOption); // no draw options on purpose
1887  }
1888  gPad->Update();
1889  } else {
1890  gPad->Clear();
1891  gPad->Range(-1,-1,1,1);
1892  TView::CreateView(1,rmin,rmax);
1893  }
1894  if (fTreeDrawArgsParser.GetShouldDraw()) {
1895  SetDrawAtt(fPolyMarker3D);
1896  fPolyMarker3D->Draw(fOption);
1897  }
1898  gPad->Update();
1899  if (!hist->TestBit(kCanDelete)) {
1900  for (int i = 0; i < fPolyMarker3D->Size(); i++) {
1901  Double_t x = 0, y = 0, z = 0;
1902  fPolyMarker3D->GetPoint(i, x, y, z);
1903  hist->Fill(x, y, z, 1);
1904  }
1905  }
1906  }
1907 }
1908 
1909 
1910 ClassImp(TProofDrawListOfGraphs);
1911 
1912 ////////////////////////////////////////////////////////////////////////////////
1913 /// See TProofDraw::SlaveBegin().
1914 
1915 void TProofDrawListOfGraphs::SlaveBegin(TTree *tree)
1916 {
1917  PDB(kDraw,1) Info("SlaveBegin","Enter tree = %p", tree);
1918 
1919  // Get the weight
1920  TProofDraw::FillWeight();
1921 
1922  TObject *os = fInput->FindObject("selection");
1923  TObject *ov = fInput->FindObject("varexp");
1924 
1925  if (os && ov) {
1926  fSelection = os->GetTitle();
1927  fInitialExp = ov->GetTitle();
1928  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
1929  R__ASSERT(fTreeDrawArgsParser.GetDimension() == 3);
1930 
1931  SafeDelete(fPoints);
1932 
1933  fDimension = 3;
1934 
1935  fPoints = new TProofVectorContainer<Point3D_t>(new std::vector<Point3D_t>);
1936  fPoints->SetName("PROOF_SCATTERPLOT");
1937  fOutput->Add(fPoints); // release ownership (? FIXME)
1938  }
1939  PDB(kDraw,1) Info("Begin","selection: %s", fSelection.Data());
1940  PDB(kDraw,1) Info("Begin","varexp: %s", fInitialExp.Data());
1941 }
1942 
1943 
1944 ////////////////////////////////////////////////////////////////////////////////
1945 /// Fills the scatter plot with the given values.
1946 
1947 void TProofDrawListOfGraphs::DoFill(Long64_t , Double_t , const Double_t *v)
1948 {
1949  fPoints->GetVector()->push_back(Point3D_t(v[2], v[1], v[0]));
1950 }
1951 
1952 
1953 ////////////////////////////////////////////////////////////////////////////////
1954 /// See TProofDraw::Terminate().
1955 
1956 void TProofDrawListOfGraphs::Terminate(void)
1957 {
1958  PDB(kDraw,1) Info("Terminate","Enter");
1959  TProofDraw::Terminate();
1960  if (!fStatus)
1961  return;
1962 
1963  fPoints = dynamic_cast<TProofVectorContainer<Point3D_t>*>
1964  (fOutput->FindObject("PROOF_SCATTERPLOT"));
1965  if (fPoints) {
1966  std::vector<Point3D_t> *points = fPoints->GetVector();
1967  R__ASSERT(points);
1968  SetStatus((Int_t) points->size());
1969  TH2F* hist;
1970  TObject *orig = fTreeDrawArgsParser.GetOriginal();
1971  if ( (hist = dynamic_cast<TH2F*> (orig)) == 0 ) {
1972  delete orig;
1973  fTreeDrawArgsParser.SetOriginal(0);
1974  double binsx, minx, maxx;
1975  double binsy, miny, maxy;
1976  if (fTreeDrawArgsParser.IsSpecified(0))
1977  gEnv->SetValue("Hist.Binning.2D.x", fTreeDrawArgsParser.GetParameter(0));
1978  if (fTreeDrawArgsParser.IsSpecified(3))
1979  gEnv->SetValue("Hist.Binning.2D.y", fTreeDrawArgsParser.GetParameter(3));
1980  binsx = gEnv->GetValue("Hist.Binning.2D.x", 40);
1981  minx = fTreeDrawArgsParser.GetIfSpecified(1, 0);
1982  maxx = fTreeDrawArgsParser.GetIfSpecified(2, 0);
1983  binsy = gEnv->GetValue("Hist.Binning.2D.y", 40);
1984  miny = fTreeDrawArgsParser.GetIfSpecified(4, 0);
1985  maxy = fTreeDrawArgsParser.GetIfSpecified(5, 0);
1986  hist = new TH2F(fTreeDrawArgsParser.GetObjectName(), fTreeDrawArgsParser.GetObjectTitle(),
1987  (Int_t) binsx, minx, maxx, (Int_t) binsy, miny, maxy);
1988  hist->SetBit(TH1::kNoStats);
1989  hist->SetBit(kCanDelete);
1990  if (fTreeDrawArgsParser.GetNoParameters() != 6)
1991  hist->SetCanExtend(TH1::kAllAxes);
1992  else
1993  hist->SetCanExtend(TH1::kNoAxis);
1994 
1995 // if (fTreeDrawArgsParser.GetShouldDraw()) // ?? FIXME
1996 // hist->SetDirectory(0);
1997  }
1998  Double_t rmin[3], rmax[3];
1999 
2000  // FIXME take rmin and rmax from the old histogram
2001  rmin[0] = rmax[0] = rmin[1] = rmax[1] = rmin[2] = rmax[2] = 0;
2002  if (points->size() > 0) {
2003  rmin[0] = rmax[0] = (*points)[0].fX;
2004  rmin[1] = rmax[1] = (*points)[0].fY;
2005  rmin[2] = rmax[2] = (*points)[0].fZ;
2006 
2007  for (vector<Point3D_t>::const_iterator i = points->begin() + 1; i < points->end(); ++i) {
2008  if (rmax[0] < i->fX) rmax[0] = i->fX;
2009  if (rmax[1] < i->fY) rmax[1] = i->fY;
2010  if (rmax[2] < i->fZ) rmax[2] = i->fZ;
2011  if (rmin[0] > i->fX) rmin[0] = i->fX;
2012  if (rmin[1] > i->fY) rmin[1] = i->fY;
2013  if (rmin[2] > i->fZ) rmin[2] = i->fZ;
2014  }
2015  // in this case we don't care about user-specified limits
2016  if (hist->CanExtendAllAxes() && hist->TestBit(kCanDelete)) {
2017  THLimitsFinder::GetLimitsFinder()->FindGoodLimits(hist,
2018  rmin[1], rmax[1], rmin[2], rmax[2]);
2019  }
2020  }
2021 
2022  Int_t ncolors = gStyle->GetNumberOfColors();
2023  TObjArray *grs = (TObjArray*)hist->GetListOfFunctions()->FindObject("graphs");
2024  Int_t col;
2025  TGraph *gr;
2026  if (!grs) {
2027  grs = new TObjArray(ncolors);
2028  grs->SetOwner();
2029  grs->SetName("graphs");
2030  hist->GetListOfFunctions()->Add(grs, "P");
2031  for (col=0;col<ncolors;col++) {
2032  gr = new TGraph();
2033  gr->SetMarkerColor(col);
2034 // gr->SetMarkerStyle(fTree->GetMarkerStyle());
2035 // gr->SetMarkerSize(fTree->GetMarkerSize());
2036  grs->AddAt(gr,col);
2037  }
2038  }
2039  // Fill the graphs acording to the color
2040  for (vector<Point3D_t>::const_iterator i = points->begin();
2041  i < points->end(); ++i) {
2042  col = Int_t((ncolors-1)*((i->fX-rmin[0])/(rmax[0]-rmin[0])));
2043  if (col < 0) col = 0;
2044  if (col > ncolors-1) col = ncolors-1;
2045  gr = (TGraph*)grs->UncheckedAt(col);
2046  if (gr) gr->SetPoint(gr->GetN(), i->fY, i->fZ);
2047  }
2048  // Remove potential empty graphs
2049  for (col=0;col<ncolors;col++) {
2050  gr = (TGraph*)grs->At(col);
2051  if (gr && gr->GetN() <= 0) grs->Remove(gr);
2052  }
2053  if (fTreeDrawArgsParser.GetShouldDraw()) {
2054  SetDrawAtt(hist);
2055  hist->Draw(fOption.Data());
2056  gPad->Update();
2057  }
2058  fOutput->Remove(fPoints);
2059  SafeDelete(fPoints);
2060  }
2061 }
2062 
2063 
2064 ClassImp(TProofDrawListOfPolyMarkers3D);
2065 
2066 
2067 ////////////////////////////////////////////////////////////////////////////////
2068 /// See TProofDraw::SlaveBegin().
2069 
2070 void TProofDrawListOfPolyMarkers3D::SlaveBegin(TTree *tree)
2071 {
2072  PDB(kDraw,1) Info("SlaveBegin","Enter tree = %p", tree);
2073 
2074  // Get the weight
2075  TProofDraw::FillWeight();
2076 
2077  TObject *os = fInput->FindObject("selection");
2078  TObject *ov = fInput->FindObject("varexp");
2079 
2080  if (os && ov) {
2081  fSelection = os->GetTitle();
2082  fInitialExp = ov->GetTitle();
2083  fTreeDrawArgsParser.Parse(fInitialExp, fSelection, fOption);
2084  R__ASSERT(fTreeDrawArgsParser.GetDimension() == 4);
2085 
2086  SafeDelete(fPoints);
2087 
2088  fDimension = 4;
2089 
2090  fPoints = new TProofVectorContainer<Point4D_t>(new std::vector<Point4D_t>);
2091  fPoints->SetName("PROOF_SCATTERPLOT");
2092  fOutput->Add(fPoints); // release ownership (? FIXME)
2093  }
2094  PDB(kDraw,1) Info("Begin","selection: %s", fSelection.Data());
2095  PDB(kDraw,1) Info("Begin","varexp: %s", fInitialExp.Data());
2096 }
2097 
2098 
2099 ////////////////////////////////////////////////////////////////////////////////
2100 /// Fills the scatter plot with the given values.
2101 
2102 void TProofDrawListOfPolyMarkers3D::DoFill(Long64_t , Double_t , const Double_t *v)
2103 {
2104  fPoints->GetVector()->push_back(Point4D_t(v[3], v[2], v[1], v[0]));
2105 }
2106 
2107 
2108 
2109 ////////////////////////////////////////////////////////////////////////////////
2110 /// See TProofDraw::Terminate().
2111 
2112 void TProofDrawListOfPolyMarkers3D::Terminate(void)
2113 {
2114  PDB(kDraw,1) Info("Terminate","Enter");
2115  TProofDraw::Terminate();
2116  if (!fStatus)
2117  return;
2118 
2119  fPoints = dynamic_cast<TProofVectorContainer<Point4D_t>*>
2120  (fOutput->FindObject("PROOF_SCATTERPLOT"));
2121  if (fPoints) {
2122  std::vector<Point4D_t> *points = fPoints->GetVector();
2123  R__ASSERT(points);
2124  SetStatus((Int_t) points->size());
2125  TH3F* hist;
2126  TObject *orig = fTreeDrawArgsParser.GetOriginal();
2127  if ( (hist = dynamic_cast<TH3F*> (orig)) == 0 || fTreeDrawArgsParser.GetNoParameters() != 0) {
2128  delete orig;
2129  fTreeDrawArgsParser.SetOriginal(0);
2130  double binsx, minx, maxx;
2131  double binsy, miny, maxy;
2132  double binsz, minz, maxz;
2133  if (fTreeDrawArgsParser.IsSpecified(0))
2134  gEnv->SetValue("Hist.Binning.3D.x", fTreeDrawArgsParser.GetParameter(0));
2135  if (fTreeDrawArgsParser.IsSpecified(3))
2136  gEnv->SetValue("Hist.Binning.3D.y", fTreeDrawArgsParser.GetParameter(3));
2137  if (fTreeDrawArgsParser.IsSpecified(6))
2138  gEnv->SetValue("Hist.Binning.3D.z", fTreeDrawArgsParser.GetParameter(3));
2139  binsx = gEnv->GetValue("Hist.Binning.3D.x", 20);
2140  minx = fTreeDrawArgsParser.GetIfSpecified(1, 0);
2141  maxx = fTreeDrawArgsParser.GetIfSpecified(2, 0);
2142  binsy = gEnv->GetValue("Hist.Binning.3D.y", 20);
2143  miny = fTreeDrawArgsParser.GetIfSpecified(4, 0);
2144  maxy = fTreeDrawArgsParser.GetIfSpecified(5, 0);
2145  binsz = gEnv->GetValue("Hist.Binning.3D.z", 20);
2146  minz = fTreeDrawArgsParser.GetIfSpecified(7, 0);
2147  maxz = fTreeDrawArgsParser.GetIfSpecified(8, 0);
2148  hist = new TH3F(fTreeDrawArgsParser.GetObjectName(), fTreeDrawArgsParser.GetObjectTitle(),
2149  (Int_t) binsx, minx, maxx,
2150  (Int_t) binsy, miny, maxy,
2151  (Int_t) binsz, minz, maxz);
2152  hist->SetBit(TH1::kNoStats);
2153  hist->SetBit(kCanDelete);
2154  if (fTreeDrawArgsParser.GetNoParameters() != 9)
2155  hist->SetCanExtend(TH1::kAllAxes);
2156  else
2157  hist->SetCanExtend(TH1::kNoAxis);
2158 
2159 // if (fTreeDrawArgsParser.GetShouldDraw()) // ?? FIXME
2160 // hist->SetDirectory(0);
2161  }
2162  Double_t rmin[4], rmax[4];
2163 
2164 
2165  // FIXME take rmin and rmax from the old histogram
2166  rmin[0] = rmax[0] = rmin[1] = rmax[1] = rmin[2] = rmax[2] = 0;
2167  if (points->size() > 0) {
2168  rmin[0] = rmax[0] = (*points)[0].fX;
2169  rmin[1] = rmax[1] = (*points)[0].fY;
2170  rmin[2] = rmax[2] = (*points)[0].fZ;
2171  rmin[3] = rmax[3] = (*points)[0].fT;
2172 
2173  for (vector<Point4D_t>::const_iterator i = points->begin() + 1; i < points->end(); ++i) {
2174  if (rmax[0] < i->fX) rmax[0] = i->fX;
2175  if (rmax[1] < i->fY) rmax[1] = i->fY;
2176  if (rmax[2] < i->fZ) rmax[2] = i->fZ;
2177  if (rmax[3] < i->fT) rmax[3] = i->fT;
2178  if (rmin[0] > i->fX) rmin[0] = i->fX;
2179  if (rmin[1] > i->fY) rmin[1] = i->fY;
2180  if (rmin[2] > i->fZ) rmin[2] = i->fZ;
2181  if (rmin[3] > i->fT) rmin[3] = i->fT;
2182  }
2183  // in this case we don't care about user-specified limits
2184  if (hist->CanExtendAllAxes() && hist->TestBit(kCanDelete)) {
2185  THLimitsFinder::GetLimitsFinder()->FindGoodLimits(hist,
2186  rmin[1], rmax[1], rmin[2], rmax[2], rmin[3], rmax[3]);
2187  }
2188  }
2189  Int_t ncolors = gStyle->GetNumberOfColors();
2190  TObjArray *pms = (TObjArray*)hist->GetListOfFunctions()->FindObject("polymarkers");
2191  Int_t col;
2192  TPolyMarker3D *pm3d;
2193  if (!pms) {
2194  pms = new TObjArray(ncolors);
2195  pms->SetOwner();
2196  pms->SetName("polymarkers");
2197  hist->GetListOfFunctions()->Add(pms);
2198  for (col=0;col<ncolors;col++) {
2199  pm3d = new TPolyMarker3D();
2200  pm3d->SetMarkerColor(col);
2201 // pm3d->SetMarkerStyle(fTree->GetMarkerStyle());
2202 // pm3d->SetMarkerSize(fTree->GetMarkerSize());
2203  pms->AddAt(pm3d,col);
2204  }
2205  }
2206  for (vector<Point4D_t>::const_iterator i = points->begin();
2207  i < points->end(); ++i) {
2208  col = Int_t(i->fX);
2209  if (col < 0) col = 0;
2210  if (col > ncolors-1) col = ncolors-1;
2211  pm3d = (TPolyMarker3D*)pms->UncheckedAt(col);
2212  pm3d->SetPoint(pm3d->GetLastPoint()+1, i->fY, i->fZ, i->fT);
2213  }
2214  if (fTreeDrawArgsParser.GetShouldDraw()) {
2215  SetDrawAtt(hist);
2216  hist->Draw(fOption.Data());
2217  gPad->Update();
2218  }
2219  fOutput->Remove(fPoints);
2220  SafeDelete(fPoints);
2221  }
2222 }