AliPhysics  6cf2591 (6cf2591)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SummaryAODDrawer.C
Go to the documentation of this file.
1 #include "SummaryDrawer.C"
2 #ifndef __CINT__
3 # include <TGraph.h>
4 # include <TGraphErrors.h>
5 # include <TF1.h>
6 # include <TArrow.h>
7 #else
8 class TGraph;
9 class TFile;
10 #endif
11 
25 {
26 public:
27  enum EFlags {
28  kEventInspector = 0x001,
29  kSharingFilter = 0x002,
31  kCorrector = 0x008,
32  kHistCollector = 0x010,
33  kSteps = 0x020,
34  kResults = 0x040,
35  kCentral = 0x080,
36  kESDFixer = 0x100,
37  kNormal = 0x1FF
38  };
40  : SummaryDrawer(),
41  fSums(0),
42  fResults(0)
43  {}
44  //__________________________________________________________________
45  TFile* Init(const char* fname)
46  {
47  // --- Open the file ---------------------------------------------
48  TString filename(fname);
49  TFile* file = TFile::Open(filename, "READ");
50  if (!file) {
51  Error("Run", "Failed to open \"%s\"", filename.Data());
52  return 0;
53  }
54 
55  // --- Get top-level collection ----------------------------------
56  fSums = GetCollection(file, "ForwardSums");
57  if (!fSums) {
58  Info("Run", "Trying old name Forward");
59  fSums = GetCollection(file, "Forward");
60  if (!fSums) return 0;
61  }
62 
63  // --- Do the results ----------------------------------------------
64  fResults = GetCollection(file, "ForwardResults");
65  if (!fResults) fResults = fSums; // Old-style
66 
67  return file;
68  }
69  void SummarizeSharing(const char* fname, UShort_t what=0)
70  {
71  // --- Initialize ------------------------------------------------
72  TFile* file = 0;
73  if (!(file = Init(fname))) return;
74 
75  // --- Make our canvas -------------------------------------------
76  TString pdfName("sharing.pdf");
77  pdfName.ReplaceAll(".root", ".pdf");
78  CreateCanvas(pdfName, what & kLandscape, true, false);
79 
80  TCollection* c = GetCollection(fSums, "fmdSharingFilter");
81  if (!c) return;
82  TCollection* rc = GetCollection(fResults, "fmdSharingFilter");
83  if (!rc) rc = c;
84 
85  Int_t nFiles = 0;
86  TParameter<int>* pnFiles =
87  static_cast<TParameter<int>*>(GetObject(c, "nFiles"));
88  if (pnFiles) {
89  nFiles = pnFiles->GetVal();
90  }
91 
92  TCollection* lc = GetCollection(c, "lCuts");
93  TCollection* hc = GetCollection(c, "hCuts");
94  Int_t lm = 0;
95  Int_t hm = 0;
96  TH2* hLow = GetH2(c, "lowCuts");
97  TH2* hHigh = GetH2(c, "highCuts");
98  GetParameter(lc, "method", lm);
99  GetParameter(hc, "method", hm);
100  if (hLow && nFiles > 0 && !hLow->TestBit(BIT(20)))
101  hLow->Scale(1. / nFiles);
102  if (hHigh && nFiles > 0 && !hHigh->TestBit(BIT(20)))
103  hHigh->Scale(1. / nFiles);
104 
105  DivideForRings(true,true);
106  const char** ptr = GetRingNames(false);
107  UShort_t iq = 1;
108  while (*ptr) {
109  TCollection* sc = GetCollection(c, *ptr);
110  if (!sc) { ptr++; iq++; continue; }
111  UShort_t d = Int_t((*ptr)[3])-48;
112  Char_t r = (*ptr)[4];
113 
114  TH1* esdELoss = GetH1(sc, "esdEloss");
115  TH1* anaELoss = GetH1(sc, "anaEloss");
116  TGraph* lowCut = CreateCutGraph(lm, iq, hLow, esdELoss, kYellow+1);
117  TGraph* highCut = CreateCutGraph(hm, iq, hHigh, esdELoss, kCyan+1);
118  // Double_t ignCut = TMath::Max(lowCut->GetX()[3],0.);
119  // Int_t esdLow = esdELoss->FindBin(ignCut);
120  // Int_t anaLow = anaELoss->FindBin(ignCut);
121  // Double_t esdInt = esdELoss->Integral(esdLow,esdELoss->GetNbinsX()+1);
122  // Double_t anaInt = anaELoss->Integral(anaLow,anaELoss->GetNbinsX()+1);
123  // Double_t frac = esdInt > 0 ? (esdInt-anaInt)/esdInt : 1;
124  esdELoss->GetXaxis()->SetRangeUser(-.1, 2);
125 
126  DrawInRingPad(d,r, esdELoss, "", kLogy, *ptr);
127  // "#Delta/#Delta_{mip} reconstructed and merged");
128  DrawInRingPad(d, r, anaELoss, "same");
129  DrawInRingPad(d, r, lowCut, "lf same");
130  DrawInRingPad(d, r, highCut, "lf same");
131  ptr++;
132  iq++;
133  }
134  TVirtualPad* p = RingPad(0,0);
135  p->cd();
136  TLegend* l = new TLegend(0.1, 0.1, 0.98, 0.98, "");
137  l->SetFillStyle(0);
138  l->SetFillColor(0);
139  l->SetBorderSize(0);
140  TLegendEntry* e = 0;
141  e = l->AddEntry("dummy", "ESD signal", "f");
142  e->SetFillStyle(3002);
143  e->SetFillColor(kBlack);
144  e = l->AddEntry("dummy", "Merged signal", "f");
145  e->SetFillStyle(3001);
146  e->SetFillColor(kBlack);
147  e = l->AddEntry("dummy", "Low cut", "f");
148  e->SetFillStyle(3002);
149  e->SetFillColor(kYellow+1);
150  e->SetLineWidth(0);
151  e->SetLineColor(kWhite);
152  e = l->AddEntry("dummy", "High cut", "f");
153  e->SetFillStyle(3002);
154  e->SetFillColor(kCyan+1);
155  e->SetLineWidth(0);
156  e->SetLineColor(kWhite);
157  l->Draw();
158 
159  PrintCanvas("Summary of sharing filter");
160  CloseCanvas();
161 
162  }
163  void SummarizeSteps(const char* fname, UShort_t what=0)
164  {
165  // --- Initialize ------------------------------------------------
166  TFile* file = 0;
167  if (!(file = Init(fname))) return;
168 
169  // --- Make our canvas -------------------------------------------
170  TString pdfName("steps.pdf");
171  pdfName.ReplaceAll(".root", ".pdf");
172  CreateCanvas(pdfName, what & kLandscape, true, false);
173  DrawSteps();
174  CloseCanvas();
175  }
176 
177  //__________________________________________________________________
184  void Run(const char* fname, UShort_t what=kNormal)
185  {
186  // --- Initialize ------------------------------------------------
187  TFile* file = 0;
188  if (!(file = Init(fname))) return;
189 
190  // --- Make our canvas -------------------------------------------
191  TString pdfName(fname);
192  pdfName.ReplaceAll(".root", ".pdf");
193  CreateCanvas(pdfName, what & kLandscape);
194  DrawTitlePage(file);
195 
196  // --- Possibly make a chapter here ------------------------------
197  TCollection* centralSums = GetCollection(file, "CentralSums", false);
198  if (!centralSums) {
199  Info("Run", "Trying old name \"Central\"");
200  centralSums = GetCollection(file, "Central", false);
201  }
202  if (what & kCentral && centralSums)
203  MakeChapter("Forward");
204 
205  // --- Set pause flag --------------------------------------------
206  fPause = what & kPause;
207 
208  // Plot status if found
209  TH1* hStatus = GetH1(fSums, "status", false);
210  if (hStatus) {
211  hStatus->SetMaximum(hStatus->GetMaximum()*1.2);
212  fBody->SetRightMargin(0.10);
213  DrawInPad(fBody,0,hStatus, "hist text30");
214  PrintCanvas("Status");
215  }
216 
217  // --- Do each sub-algorithm -------------------------------------
219  if (what & kESDFixer) DrawESDFixer(fSums);
220  if (what & kSharingFilter) DrawSharingFilter();
222  if (what & kCorrector) DrawCorrector();
223  if (what & kHistCollector) DrawHistCollector();
224 
225 
226  if (what & kSteps) DrawSteps();
227  if (what & kResults) DrawResults();
228 
229  // --- SPD clusters ----------------------------------------------
230  if (what & kCentral) {
231  // --- Get top-level collection --------------------------------
232  fSums = GetCollection(file, "CentralSums");
233  if (!fSums)
234  fSums = GetCollection(file, "Central");
235  if (fSums) {
236  MakeChapter("Central");
237  DrawCentral();
238  if (what & kEventInspector) DrawEventInspector(fSums);
239  }
240  fResults = GetCollection(file, "CentralResults");
241  if (fResults && (what & kResults)) {
243  }
244 
245  if (what & kResults) DrawBoth(file);
246  }
247 
248 
249  CloseCanvas();
250  }
251 protected:
252  //____________________________________________________________________
253  void DrawTitlePage(TFile* f)
254  {
255  fBody->cd();
256 
257  TLatex* ltx = new TLatex(.5, .7, "ESD #rightarrow AOD filtering");
258  ltx->SetNDC();
259  ltx->SetTextSize(0.07);
260  ltx->SetTextAlign(22);
261  ltx->Draw();
262 
263  TCollection* fwd = fSums; // GetCollection(f, "ForwardSums");
264  TCollection* cen = GetCollection(f, "CentralSums");
265  Double_t y = .6;
266 
267  Double_t save = fParName->GetTextSize();
268  fParName->SetTextSize(0.03);
269  fParVal->SetTextSize(0.03);
270 
271  DrawParameter(y, "Tasks", (fwd ? "Forward" : ""));
272  DrawParameter(y, "", (cen ? "Central" : ""));
273 
274  if (fwd) {
275  TCollection* ei = GetCollection(fwd, "fmdEventInspector");
276  if (ei) {
277 
278  UShort_t sys=0, sNN=0;
279  Int_t field=0;
280  ULong_t runNo=0;
281  Bool_t mc=false;
282  GetParameter(ei, "sys", sys);
283  GetParameter(ei, "sNN", sNN);
284  GetParameter(ei, "field", field);
285  GetParameter(ei, "runNo", runNo);
286  if (!GetParameter(ei, "mc", mc, false)) mc = false;
287 
288  TString sysString; SysString(sys, sysString);
289  TString sNNString; SNNString(sNN, sNNString);
290 
291  DrawParameter(y, "System", sysString);
292  DrawParameter(y, "#sqrt{s_{NN}}", sNNString);
293  DrawParameter(y, "L3 B field", Form("%+2dkG", field));
294  DrawParameter(y, "Run #", Form("%6lu", runNo));
295  DrawParameter(y, "Simulation", (mc ? "yes" : "no"));
296  }
297  }
298  PrintCanvas("Title page");
299  fParName->SetTextSize(save);
300  fParVal->SetTextSize(save);
301  }
303  Int_t color)
304  {
305  TGraph* ret = new TGraph(4);
306  Double_t y0 = TMath::Max(eloss->GetMinimum(),1.);
307  Double_t y1 = eloss->GetMaximum();
308  Double_t min = 1000;
309  Double_t max = 0;
310  Int_t iiy = (iy == 4 ? 5 : iy == 5 ? 4 : iy);
311  if (method == 0) { // Fixed value
312  max = cuts->GetBinContent(1, iiy);
313  min = eloss->GetXaxis()->GetXmin();
314  }
315  else {
316  for (Int_t ix=1; ix <= cuts->GetNbinsX(); ix++) {
317  Double_t c = cuts->GetBinContent(ix, iiy);
318  if (c <= 0.0001) continue;
319  min = TMath::Min(c, min);
320  max = TMath::Max(c, max);
321  }
322  }
323  // Printf("Cuts between %f,%f @%f, %f", min, max, y0,y1);
324  ret->SetPoint(0, min, y0);
325  ret->SetPoint(1, min, y1);
326  ret->SetPoint(2, max, y1);
327  ret->SetPoint(3, max, y0);
328  ret->SetFillColor(color);
329  ret->SetFillStyle(3002);
330  ret->SetLineColor(kBlack);
331  ret->SetLineStyle(2);
332  ret->SetName(Form("g%s", cuts->GetName()));
333  ret->SetTitle(cuts->GetTitle());
334 
335  return ret;
336  }
337  //____________________________________________________________________
338  const Char_t* CutMethodName(Int_t lm) const
339  {
340  switch (lm) {
341  case 0: return "c=X";
342  case 1: return "c=X#times#Delta_{p}";
343  case 2: return "c:Lower bound of fit range";
344  case 3: return "c=#Delta_{p}-X#times#xi";
345  case 4: return "c=#Delta_{p}-X#times(#xi+#sigma)";
346  case 5: return "c:P(#Delta<c)<X";
347  }
348  return "unknown";
349  }
350  //____________________________________________________________________
351  Int_t PrintCut(const TCollection* c, Double_t& y, const Char_t* name,
352  Double_t size=0)
353  {
354  if (!c) return -1;
355 
356  Int_t method = 0;
357  if (!GetParameter(c, "method", method)) return -1;
358  DrawParameter(y, name, CutMethodName(method), size);
359 
360  TString params;
361  const char* cuts[] = { "fmd1i", "fmd2i", "fmd2o", "fmd3i", "fmd3o", 0 };
362  const char** pcut = cuts;
363  while (*pcut) {
364  Double_t cut;
365  GetParameter(c, *pcut, cut, false);
366  if (pcut != cuts) params.Append(", ");
367  params.Append(Form("%5.2f", cut));
368  pcut++;
369  }
370  if (params.IsNull()) {
371  Double_t frac = 0;
372  GetParameter(c, "frac", frac);
373  params = Form("%f", frac);
374  }
375  DrawParameter(y, "Parameters", params, size);
376  return method;
377  }
378  //____________________________________________________________________
379  void DrawCut(TVirtualPad* parent, Int_t sub, TH2* cuts)
380  {
381  if (!cuts) return;
382  THStack* stack = new THStack(cuts,"x");
383  stack->SetTitle(cuts->GetTitle());
384  for (Int_t i = 1; i <= cuts->GetNbinsY(); i++) {
385  TH1* hist = static_cast<TH1*>(stack->GetHists()->At(i-1));
386  TString name(cuts->GetYaxis()->GetBinLabel(i));
387  UShort_t det = UShort_t(name[3]-48);
388  Char_t rng = name[4];
389  Color_t col = RingColor(det, rng);
390  hist->SetDirectory(0);
391  hist->SetTitle(name);
392  hist->SetMarkerStyle(20);
393  hist->SetMarkerColor(col);
394  hist->SetLineColor(col);
395  hist->SetFillColor(col);
396  hist->SetLineWidth(0);
397  hist->SetFillStyle(0);
398  hist->SetXTitle("#eta");
399  hist->SetYTitle(cuts->GetZaxis()->GetTitle());
400  }
401  DrawInPad(parent, sub, stack, "nostack p", kLegend|kCenter|kSouth);
402  }
403  //____________________________________________________________________
405  {
406  Info("DrawSharingFilter", "Drawing sharing filter");
407  TCollection* c = GetCollection(fSums, "fmdSharingFilter");
408  if (!c) return;
409  TCollection* rc = GetCollection(fResults, "fmdSharingFilter");
410  if (!rc) rc = c;
411 
412  // --- Draw summary information ----------------------------------
413  fBody->Divide(1, 3, 0, 0);
414  fBody->cd(1);
415 
416  Double_t y = .95;
417  Bool_t angle=false, lowSignal=false, disabled=false;
418  Int_t nFiles = 0;
419  if (GetParameter(c, "angle", angle))
420  DrawParameter(y, "Angle correct", (angle ? "yes" : "no"));
421  if (GetParameter(c, "lowSignal", lowSignal))
422  DrawParameter(y, "Lower signal", (lowSignal ? "yes" : "no"));
423  TParameter<int>* pnFiles =
424  static_cast<TParameter<int>*>(GetObject(c, "nFiles"));
425  if (pnFiles) {
426  nFiles = pnFiles->GetVal();
427  DrawParameter(y, "# files merged", Form("%d", nFiles));
428  }
429  if (GetParameter(c, "disabled", disabled, false))
430  DrawParameter(y, "Merging disabled", (disabled ? "yes" : "no"));
431 
432  Int_t lm = 0;
433  Int_t hm = 0;
434  TH2* hLow = 0;
435  TH2* hHigh = 0;
436  if (!disabled) {
437  Bool_t simple=false, three=false;
438  if (GetParameter(c, "simple", simple))
439  DrawParameter(y, "Simple method", (simple ? "yes" : "no"));
440  if (GetParameter(c, "sumThree", three))
441  DrawParameter(y, "3-strip merging", (three ? "yes" : "no"));
442 
443  TCollection* lc = GetCollection(c, "lCuts");
444  TCollection* hc = GetCollection(c, "hCuts");
445  lm = PrintCut(lc, y, "Low cut");
446  hm = PrintCut(hc, y, "High cut");
447  hLow = GetH2(c, "lowCuts");
448  hHigh = GetH2(c, "highCuts");
449  if (hLow && nFiles > 0 && !hLow->TestBit(BIT(20)))
450  hLow->Scale(1. / nFiles);
451  if (hHigh && nFiles > 0 && !hHigh->TestBit(BIT(20)))
452  hHigh->Scale(1. / nFiles);
453  DrawCut(fBody, 2, hLow);
454  DrawCut(fBody, 3, hHigh);
455  }
456  PrintCanvas("Sharing filter");
457 
458  if (!disabled) {
459  // --- Draw rings individually -----------------------------------
460  Double_t savX = fParVal->GetX();
461  Double_t savY = fParVal->GetY();
462  fParVal->SetX(0.6);
463  fParVal->SetY(0.6);
464  const char** ptr = GetRingNames(false);
465  UShort_t iq = 1;
466  while (*ptr) {
467  TCollection* sc = GetCollection(c, *ptr);
468  if (!sc) { ptr++; iq++; continue; }
469 
470  if (fLandscape) fBody->Divide(3, 2);
471  else fBody->Divide(2,3);
472 
473  TH1* esdELoss = GetH1(sc, "esdEloss");
474  TH1* anaELoss = GetH1(sc, "anaEloss");
475  TGraph* lowCut = CreateCutGraph(lm, iq, hLow, esdELoss, kYellow+1);
476  TGraph* highCut = CreateCutGraph(hm, iq, hHigh, esdELoss, kCyan+1);
477  Double_t ignCut = TMath::Max(lowCut->GetX()[3],0.);
478  Int_t esdLow = esdELoss->FindBin(ignCut);
479  Int_t anaLow = anaELoss->FindBin(ignCut);
480  Double_t esdInt = esdELoss->Integral(esdLow,esdELoss->GetNbinsX()+1);
481  Double_t anaInt = anaELoss->Integral(anaLow,anaELoss->GetNbinsX()+1);
482  Double_t frac = esdInt > 0 ? (esdInt-anaInt)/esdInt : 1;
483  esdELoss->GetXaxis()->SetRangeUser(-.1, 2);
484 
485  DrawInPad(fBody, 1, esdELoss, "", kLogy,
486  "#Delta/#Delta_{mip} reconstructed and merged");
487  DrawInPad(fBody, 1, anaELoss, "same");
488  DrawInPad(fBody, 1, lowCut, "lf same");
489  DrawInPad(fBody, 1, highCut, "lf same", kLogy|kLegend|kNorth|kWest);
490  TVirtualPad* p = fBody->GetPad(1);
491  p->cd();
492  TLatex* l = new TLatex(1-p->GetRightMargin(),
493  0.5, Form("Loss: %5.1f%%", frac*100));
494  l->SetNDC();
495  l->SetTextAlign(32);
496  l->Draw();
497  l->DrawLatex(1-p->GetRightMargin(), 0.45,
498  Form("%f #rightarrow #infty", ignCut));
499 
500  TH1* singles = GetH1(sc, "singleEloss");
501  TH1* doubles = GetH1(sc, "doubleEloss");
502  TH1* tripples = GetH1(sc, "tripleEloss");
503  Double_t int1 = singles->Integral(0,singles->GetNbinsX()+1);
504  Double_t int2 = doubles->Integral(0,doubles->GetNbinsX()+1);
505  Double_t int3 = tripples->Integral(0,tripples->GetNbinsX()+1);
506  Double_t intT = int1 + int2 + int3;
507  Double_t f1 = intT > 0 ? int1 / intT : 0;
508  Double_t f2 = intT > 0 ? int2 / intT : 0;
509  Double_t f3 = intT > 0 ? int3 / intT : 0;
510 
511  singles->GetXaxis()->SetRangeUser(-.1, 2);
512  DrawInPad(fBody, 2, singles, "", kLogy,
513  "#Delta/#Delta_{mip} for single, double, and tripple hits");
514  DrawInPad(fBody, 2, doubles, "same", kLogy);
515  DrawInPad(fBody, 2, tripples, "same", kLogy);
516  DrawInPad(fBody, 2, lowCut, "lf same", kLogy);
517  DrawInPad(fBody, 2, highCut, "lf same", kLogy|kLegend|kNorth|kWest);
518 
519  fBody->cd(2);
520  Double_t nameX = fParName->GetX();
521  Double_t valX = fParVal->GetX();
522  Double_t intY = 0.4;
523  fParName->SetX(0.5);
524  fParVal->SetX(0.7);
525  DrawParameter(intY, "Singles", Form("%5.1f%%", 100*f1), 0.05);
526  DrawParameter(intY, "Doubles", Form("%5.1f%%", 100*f2), 0.05);
527  DrawParameter(intY, "Tripples", Form("%5.1f%%", 100*f3), 0.05);
528  fParName->SetX(nameX);
529  fParVal->SetX(valX);
530 
531  DrawInPad(fBody, 3, GetH2(sc, "singlePerStrip"), "colz",kLogz);
532  // DrawInPad(fBody, 4, GetH1(sc, "distanceBefore"), "", 0x2);
533  // DrawInPad(fBody, 4, GetH1(sc, "distanceAfter"), "same", 0x12);
534  DrawInPad(fBody, 4, GetH2(sc, "summed"), "colz",0x0);
535 
536  TH2* nB = GetH2(sc, "neighborsBefore");
537  if (nB) {
538  nB->GetXaxis()->SetRangeUser(0,2);
539  nB->GetYaxis()->SetRangeUser(0,2);
540  }
541  DrawInPad(fBody, 5, nB, "colz cont3", kLogz,
542  "Correlation of neighbors before merging");
543 
544  TH2* nA = GetH2(sc, "neighborsAfter");
545  if (nA) {
546  nA->GetXaxis()->SetRangeUser(0,2);
547  nA->GetYaxis()->SetRangeUser(0,2);
548  }
549  DrawInPad(fBody, 6, nA, "colz cont3", kLogz,
550  "Correlation of neighbors after merging");
551 
552  // DrawInPad(fBody, 6, GetH2(sc, "beforeAfter"), "colz", kLogz);
553 
554  PrintCanvas(Form("Sharing filter - %s", *ptr));
555  ptr++;
556  iq++;
557  }
558  fParVal->SetX(savX);
559  fParVal->SetY(savY);
560  }
561 
562  // --- MC --------------------------------------------------------
563  TCollection* cc = GetCollection(c, "esd_mc_comparion", false); // Spelling!
564  if (!cc) {
565  cc = GetCollection(c, "esd_mc_comparison", false); // Spelling!
566  if (!cc) return; // Not MC
567  }
568 
569  DivideForRings(false, false);
570  const char** ptr = GetRingNames(false);
571  while (*ptr) {
572  TString nam(Form("%s_corr", *ptr));
573  TH2* hc = GetH2(cc, nam, false);
574  if (!hc) {
575  nam[4] = (nam[4] == 'I' ? 'i' : 'o');
576  hc = GetH2(cc, nam, false);
577  if (!hc) {
578  ptr++;
579  continue;
580  }
581  }
582  DrawInRingPad(hc, "colz", kLogz);
583  ptr++;
584  }
585 
586  PrintCanvas("Sharing filter - MC vs Reco");
587 
588  // --- MC --------------------------------------------------------
589  DrawTrackDensity(c);
590  }
591  //__________________________________________________________________
604  TVirtualPad* p, Int_t sub, UShort_t flags=0,
605  Double_t cut=-1)
606  {
607  if (!h) return;
608  TAxis* indep = (inY ? h->GetXaxis() : h->GetYaxis());
609  TAxis* dep = (inY ? h->GetYaxis() : h->GetXaxis());
610 
611 
612  TObjArray* fits = new TObjArray;
613  fits->SetOwner();
614  // FitSlicesX sets onX to true. If onX is true, then it calls
615  // ProjectionX for each Y bin. That is, we fit each X slice.
616  Int_t minB = dep->FindBin(0.)+1;
617  Int_t maxB = dep->GetNbins();
618  Info("", "Bin range: %d - %d", minB, maxB);
619  if (inY) h->FitSlicesY(0, minB, maxB, 10, "QN", fits);
620  else h->FitSlicesX(0, minB, maxB, 10, "QN", fits);
621  if (!fits) {
622  Warning("ShowSliceFit", "No fits returned");
623  return;
624  }
625 
626  // If inY is true then this is the mean,variance as a function of X
627  TH1* mean = static_cast<TH1*>(fits->At(1));
628  TH1* var = static_cast<TH1*>(fits->At(2));
629  if (!mean || !var) {
630  Warning("ShowSliceFit", "Didn't get histograms");
631  fits->Delete();
632  return;
633  }
634 #if 0
635  TH1* hh[] = { mean, var, 0 };
636  for (Int_t ib=1; ib<=mean->GetNbinsX();ib++) {
637  TH1** hp = hh;
638  while (*hp) {
639  if ((*hp)->GetBinContent(ib) <= 0) {
640  (*hp)->SetBinContent(ib,0);
641  (*hp)->SetBinError(ib,0);
642  }
643  hp++;
644  }
645  }
646 #endif
647 
648  // If inY is true then this is the mean,variance as a function of X
649  TF1* fmean = new TF1("mean", "pol1");
650  TF1* fvar = new TF1("var", "pol1");
651  mean->Fit(fmean, "Q0+");
652  var->Fit(fvar, "Q0+");
653  if (!fmean || !fvar) {
654  Warning("ShowSliceFit", "No functions returned");
655  fits->Delete();
656  return;
657  }
658 
659  TGraphErrors* g = new TGraphErrors(h->GetNbinsX());
660  g->SetName(Form("g%s", h->GetName()));
661  TString xTit = indep->GetTitle();
662  TString yTit = dep->GetTitle();
663  g->SetTitle(Form("Correlation of %s and %s",xTit.Data(),yTit.Data()));
664  g->SetFillColor(kBlue-10);
665  g->SetFillStyle(3001);
666  TGraph* up = (cut > 0 ? new TGraph(indep->GetNbins()) : 0);
667  TGraph* low = (cut > 0 ? new TGraph(indep->GetNbins()) : 0);
668  if (up) {
669  up ->SetLineColor(kBlack);
670  up ->SetLineWidth(2);
671  up ->SetLineStyle(2);
672  }
673  if (low) {
674  low->SetLineColor(kBlack);
675  low->SetLineWidth(2);
676  low->SetLineStyle(2);
677  }
678  for (Int_t i = 1; i <= h->GetNbinsX(); i++) {
679  Double_t x = indep->GetBinCenter(i);
680  Double_t y = fmean->Eval(x);
681  Double_t e = fvar->Eval(x);
682  // Double_t y = mean->GetBinContent(i);
683  // Double_t e = var->GetBinContent(i);
684  Double_t ee = nVar * e;
685  if (flags & 0x8000) ee *= e > 0 ? TMath::Log10(e) : 1;
686  if (inY) {
687  g->SetPoint(i-1, x, y);
688  g->SetPointError(i-1, 0, ee);
689  }
690  else {
691  g->SetPoint(i-1, y, x);
692  g->SetPointError(i-1, ee, 0);
693  }
694  if (up) {
695  if (inY) up->SetPoint(i-1,x,x+cut*x);
696  else up->SetPoint(i-1,y+cut*y,y);
697  }
698  if (low) {
699  if (inY) low->SetPoint(i-1,x,x-cut*x);
700  else low->SetPoint(i-1,y-cut*y,y);
701  }
702  }
703  DrawInPad(p, sub, g, "3", flags);
704  if (up) DrawInPad(p, sub, up, "l", flags);
705  if (low) DrawInPad(p, sub, low, "l", flags);
706  fmean->SetRange(indep->GetXmin(), indep->GetXmax());
707  fmean->SetLineWidth(2);
708  DrawInPad(p, sub, fmean, "same", flags);
709 
710  TVirtualPad* pp = p->GetPad(sub);
711  Double_t y = 1-pp->GetTopMargin()-.01;
712  TLatex* l = new TLatex(.15, y,
713  Form("#LT%s#GT(%s) = "
714  "%f + %f %s",
715  yTit.Data(), xTit.Data(),
716  fmean->GetParameter(0),
717  fmean->GetParameter(1), xTit.Data()));
718  l->SetNDC();
719  l->SetTextAlign(13);
720  l->SetTextSize(fParVal->GetTextSize());
721  l->SetTextFont(42);
722  l->Draw();
723  l->DrawLatex(0.15, y-0.07,
724  Form("#sigma_{%s}(%s) = "
725  "%f + %f %s",
726  yTit.Data(), xTit.Data(),
727  fvar->GetParameter(0),
728  fvar->GetParameter(1), xTit.Data()));
729  l->DrawLatex(0.15, y-0.14, Form("#delta = %3.1f %s #sigma",
730  nVar,
731  flags & 0x8000 ? "log_{10}(#sigma)" : ""));
732  fits->Delete();
733  }
734 
735  //____________________________________________________________________
737  {
738  Info("DrawDensityCalculator", "Drawing density calculator");
739  TCollection* c = GetCollection(fSums, "fmdDensityCalculator");
740  if (!c) return;
741 
742  fBody->Divide(2, 2);
743  fBody->cd(1);
744 
745  Double_t y = .9;
746  Int_t maxParticles=0, phiAcceptance=0, etaLumping=0, phiLumping=0;
747  Bool_t method=false, recalcPhi=false;
748  Double_t maxOutliers=0, outlierCut=-1;
749  Double_t size = fLandscape ? 0.05 : 0.03;
750 
751  GetParameter(c, "maxParticle", maxParticles);
752 
753  if (GetParameter(c, "phiAcceptance", phiAcceptance))
754  DrawParameter(y, "#phi acceptance method",
755  (phiAcceptance == 1 ? "N_{ch}" :
756  phiAcceptance == 2 ? "#DeltaE" : "none"), size);
757  if (GetParameter(c, "etaLumping", etaLumping) &&
758  GetParameter(c, "phiLumping", phiLumping))
759  DrawParameter(y, "Region size (sector#timesstrip)",
760  Form("%2d #times %2d", phiLumping, etaLumping), size);
761  if (GetParameter(c, "method", method))
762  DrawParameter(y, "Method", (method ? "Poisson" : "#DeltaE"), size);
763  if (GetParameter(c, "recalcPhi", recalcPhi))
764  DrawParameter(y, "Recalculate #phi",(recalcPhi ? "yes" : "no"),size);
765  if (GetParameter(c, "maxOutliers", maxOutliers, false))
766  DrawParameter(y, "Max relative N_{outlier}",
767  Form("%5.3f",maxOutliers),size);
768  Bool_t hasOutCut = false;
769  if ((hasOutCut = GetParameter(c, "outlierCut", outlierCut, false)))
770  DrawParameter(y, "Max relative deviation",Form("%5.3f",outlierCut),size);
771 
772 
773  TParameter<int>* nFiles =
774  static_cast<TParameter<int>*>(GetObject(c, "nFiles"));
775  if (nFiles)
776  DrawParameter(y, "# files merged", Form("%d", nFiles->GetVal()), size);
777 
778  TCollection* lc = GetCollection(c, "lCuts");
779  Int_t tm = PrintCut(lc, y, "Threshold", size);
780 
781  TVirtualPad* p = fBody; // fBody->cd(2);
782  // p->Divide(3,1);
783 
784  TH1* accI = GetH1(c, "accI");
785  TH1* accO = GetH1(c, "accO");
786  if (accI) {
787  Double_t scale = 1./accI->GetMaximum();
788  accI->Scale(scale);
789  accO->Scale(scale);
790  accI->SetMinimum(0);
791  accI->SetMaximum(1.3);
792  }
793  TH2* lCuts = GetH2(c, "lowCuts");
794  TH2* maxW = GetH2(c, "maxWeights");
795  if (lCuts) lCuts->SetTitle("Thresholds");
796  if (nFiles && lCuts) lCuts->Scale(1. / nFiles->GetVal());
797  if (nFiles && maxW) maxW->Scale(1. / nFiles->GetVal());
798  DrawInPad(p, 2, accI);
799  DrawInPad(p, 2, accO, "same", kLegend|kNorth|kCenter);
800  DrawCut(p, 3, lCuts);
801  DrawCut(p, 4, maxW);
802 
803  PrintCanvas("Density calculator");
804  Float_t save = fParVal->GetTextSize();
805  fParVal->SetTextSize(0.03);
806 
807  UShort_t iq = 1;
808  const char** ptr = GetRingNames(false);
809  while (*ptr) {
810  TCollection* sc = GetCollection(c, *ptr);
811  if (!sc) { ptr++; continue; }
812 
813  if (fLandscape) fBody->Divide(3,2);
814  else fBody->Divide(2,3);
815 
816  TH2* corr = GetH2(sc, "elossVsPoisson");
817  TH2* corrOut = GetH2(sc, "elossVsPoissonOutlier", false);
818  TH1* diff = GetH1(sc, "diffElossPoisson");
819  TH1* diffOut = GetH1(sc, "diffElossPoissonOutlier", false);
820  TH1* eloss = GetH1(sc, "eloss");
821  TH1* elossUsed = GetH1(sc, "elossUsed");
822  TH1* occ = GetH1(sc, "occupancy");
823  if (eloss) eloss ->SetLineWidth(1);
824  if (elossUsed) elossUsed->SetLineWidth(1);
825  if (eloss) eloss->GetXaxis()->SetRangeUser(0.05, 2);
826 
827  corr->SetXTitle("N_{ch,#Delta}");
828  corr->SetYTitle("N_{ch,Poisson}");
829  DrawInPad(fBody, 1, corr, "colz", kLogz);
830  if (corrOut)
831  DrawInPad(fBody,1, corrOut, "same", kLogz);
832  ShowSliceFit(true, corr, 10, fBody, 1, kLogz, outlierCut);
833 
834  DrawInPad(fBody, 2, diff, "HIST E", kLogy);
835  if (diffOut)
836  DrawInPad(fBody,2, diffOut, "HIST E SAME", kLogy|kLegend|kNorth|kWest);
837  DrawInPad(fBody, 3, occ, "", kLogy);
838  DrawInPad(fBody, 4, eloss, "", kLogy,
839  "#Delta/#Delta_{mip} before and after cuts");
840  DrawInPad(fBody, 4, elossUsed, "same", kLogy);
841  TGraph* thres = CreateCutGraph(tm, iq, lCuts, eloss, kYellow+1);
842  DrawInPad(fBody, 4, thres, "lf same", kLogy|kLegend|kNorth|kWest);
843 
844  if (eloss && elossUsed) {
845  Int_t lowBin = eloss->GetXaxis()->FindBin(0.)+1;
846  Int_t upBin = eloss->GetNbinsX()+1;
847  Double_t beforeInt = eloss->Integral(lowBin,upBin);
848  Double_t afterInt = elossUsed->Integral(lowBin,upBin);
849  Double_t frac = beforeInt > 0 ? (beforeInt-afterInt)/beforeInt : 1;
850  TVirtualPad* pp = fBody->GetPad(4);
851  pp->cd();
852  TLatex* l = new TLatex(1-pp->GetRightMargin(),
853  0.5, Form("Loss: %5.1f%%", frac*100));
854  l->SetNDC();
855  l->SetTextAlign(32);
856  l->Draw();
857  }
858 
859 
860  TH1* phiB = GetH1(sc, "phiBefore");
861  TH1* phiA = GetH1(sc, "phiAfter");
862  TH1* outliers = GetH1(sc, "outliers", false);
863  if (outliers)
864  DrawInPad(fBody, 5, outliers, "hist", kLogy);
865  else if (phiB && phiA) {
866  phiA->Add(phiB, -1);
867  phiA->Divide(phiB);
868  phiA->SetTitle("#Delta#phi from Ip (x,y) correction");
869  phiA->SetYTitle("(#phi_{after}-#phi_{before})/#phi_{before}");
870  DrawInPad(fBody, 5, phiA);
871  }
872  else {
873  fBody->cd(5);
874  TLatex* ltx = new TLatex(0.5, 0.5, "No outliers or #phi corrections");
875  ltx->SetTextAlign(22);
876  ltx->SetTextSize(0.07);
877  ltx->SetNDC();
878  ltx->Draw();
879  }
880  DrawInPad(fBody, 6, GetH2(sc, "phiAcc"), "colz", kLogz);
881 
882 
883  if (diff && diffOut) {
884  fBody->cd(2);
885  Double_t in = diff->GetEntries();
886  Double_t out = diffOut->GetEntries();
887  if ((in+out) > 0) {
888  TLatex* ltx = new TLatex(0.11, 0.89,
889  Form("Fraction: %7.3f%%",
890  100*out/(in+out)));
891  ltx->SetNDC();
892  ltx->SetTextAlign(13);
893  ltx->SetTextSize(0.06);
894  ltx->Draw();
895  }
896  }
897  PrintCanvas(Form("Density calculator - %s", *ptr));
898  ptr++;
899  iq++;
900  }
901 
902  TCollection* cc = GetCollection(c, "esd_mc_comparison", false);
903  if (!cc) {
904  fParVal->SetTextSize(save);
905  return; // Not MC
906  }
907 
908  ptr = GetRingNames(false);
909  THStack* profiles = new THStack("profiles", "MC-ESD");
910  // Int_t cnt = 0;
911  while (*ptr) {
912  fBody->Divide(2,1);
913 
914  TH2* corr = GetH2(cc, Form("%s_corr_mc_esd", *ptr));
915  if (corr) {
916  // corr->GetXaxis()->SetRangeUser(-1,51);
917  // corr->GetYaxis()->SetRangeUser(-1,51);
918  corr->SetXTitle("MC");
919  corr->SetYTitle("ANA");
920  TH1* h = new TH1F("",Form("Correlation of N_{ch,incl} for %s", *ptr),
921  corr->GetNbinsX(),
922  corr->GetXaxis()->GetXmin(),
923  corr->GetXaxis()->GetXmax());
924  h->SetMinimum(corr->GetYaxis()->GetXmin());
925  h->SetMaximum(1.2*corr->GetYaxis()->GetXmax());
926  h->SetXTitle("MC"); // corr->GetXaxis()->GetTitle());
927  h->SetYTitle(corr->GetYaxis()->GetTitle());
928  DrawInPad(fBody, 1, h, "", kLogz);
929  DrawInPad(fBody, 1, corr, "colz same", kLogz);
930  ShowSliceFit(true, corr, 1, fBody, 1, 0, -1);
931  }
932  TH1* diff = GetH1(cc, Form("%s_diff_mc_esd", *ptr));
933  if (diff && diff->GetEntries() > 0) {
934  // diff->Rebin(2);
935  diff->Smooth(3);
936  diff->Scale(1./diff->GetEntries(), "width");
937  TF1* f = new TF1(Form("%s_tri", *ptr),
938  "[0]*TMath::Exp(-TMath::Abs(x-[1])/[2])",-20,20);
939  f->SetParNames("A", "x_{0}", "w");
940  f->SetParameters(1, diff->GetMean(), diff->GetRMS());
941  diff->Fit(f,"RQ0+");
942  DrawInPad(fBody, 2, diff, "", kLogy);
943  DrawInPad(fBody, 2, f, "same", kLogy);
944  Double_t py = .88;
945  TLatex* l = new TLatex(.89, py, "Ae^{-|x-x_{0}|/w}");
946  l->SetTextAlign(33);
947  l->SetTextSize(fParVal->GetTextSize());
948  l->SetTextFont(42);
949  l->SetNDC();
950  l->Draw();
951  py -= fParVal->GetTextSize();
952  l->DrawLatex(.89, py, Form("#chi^{2}/#nu=%f", f->GetNDF()>0 ?
953  f->GetChisquare()/f->GetNDF() : 0));
954  for (Int_t i = 0; i < 3; i++) {
955  py -= fParVal->GetTextSize();
956  l->DrawLatex(.89, py, Form("%s: %f #pm %f", f->GetParName(i),
957  f->GetParameter(i), f->GetParError(i)));
958  }
959  }
960  TH2* vs = GetH2(cc, Form("%s_esd_vs_mc", *ptr));
961  if (vs) {
962  const Double_t lVs = -0.3;
963  const Double_t hVs = +0.4;
964  Int_t nX = vs->GetNbinsX();
965  Int_t nY = vs->GetNbinsY();
966  TProfile* vsp = new TProfile(Form("%s_esd_vs_mc_px", *ptr), *ptr,
967  nX, vs->GetXaxis()->GetXmin(),
968  vs->GetXaxis()->GetXmax());
969  vsp->SetXTitle(vs->GetXaxis()->GetTitle());
970  vsp->SetYTitle("#LT#deltaN_{ch}#GT");
971  vsp->SetLineColor(diff->GetLineColor());
972  vsp->SetMarkerColor(diff->GetLineColor());
973  vsp->SetFillColor(diff->GetLineColor());
974  vsp->SetDirectory(0);
975  Bool_t hasSome = false;
976  for (Int_t ix = 1; ix <= nX; ix++) {
977  Double_t vsx = vs->GetXaxis()->GetBinCenter(ix);
978  for (Int_t iy = 1; iy <= nY; iy++) {
979  Double_t vsc = vs->GetBinContent(ix, iy);
980  Double_t vse = vs->GetBinError(ix, iy);
981  if (vsc < lVs || vsc > hVs) continue;
982  hasSome = true;
983  vsp->Fill(vsx, vsc, vse);
984  }
985  }
986  if (hasSome) profiles->Add(vsp);
987  else delete vsp;
988  }
989  PrintCanvas(Form("Density calculator - MC vs Reco - %s", *ptr));
990  ptr++;
991  // cnt++;
992  }
993  if (profiles->GetHists() && profiles->GetHists()->GetEntries() > 0) {
994  Double_t pmax = profiles->GetMaximum("nostack")*1.3;
995  profiles->SetMaximum(+pmax);
996  profiles->SetMinimum(-pmax);
997  DrawInPad(fBody, 0, profiles, "nostack");
998  PrintCanvas("Density calculator - MC vs Reco - All");
999  }
1000 
1001  fParVal->SetTextSize(save);
1002  }
1003 
1004  //____________________________________________________________________
1006  {
1007  Info("DrawCorrector", "Drawing corrector");
1008  TCollection* c = GetCollection(fSums, "fmdCorrector");
1009  if (!c) return;
1010 
1011  fBody->cd();
1012 
1013  Double_t y = .8;
1014  Bool_t secondary=false, vertexBias=false, acceptance=false, merging=false;
1015  if (GetParameter(c, "secondary", secondary))
1016  DrawParameter(y, "Secondary corr.", secondary ? "yes" : "no");
1017  if (GetParameter(c, "acceptance", acceptance))
1018  DrawParameter(y, "Acceptance corr.", acceptance ? "yes" : "no");
1019  if (GetParameter(c, "vertexBias", vertexBias))
1020  DrawParameter(y, "Vertex bias corr.", vertexBias ? "yes" : "no");
1021  if (GetParameter(c, "merging", merging))
1022  DrawParameter(y, "Merging eff.", merging ? "yes" : "no");
1023 
1024  PrintCanvas("Corrector");
1025 
1026  TCollection* cc = GetCollection(c, "esd_mc_comparison", false);
1027  if (!cc) return; // Not MC
1028 
1029  DivideForRings(false, false);
1030  const char** ptr = GetRingNames(false);
1031  while (*ptr) {
1032  DrawInRingPad(GetH2(cc, Form("%s_esd_vs_mc", *ptr)), "colz", 0x0);
1033  ptr++;
1034  }
1035 
1036  PrintCanvas("Corrector - MC vs Reco");
1037  }
1038 
1039  //____________________________________________________________________
1041  {
1042  Info("DrawHistCollector", "Drawing histogram collector");
1043  TCollection* c = GetCollection(fSums, "fmdHistCollector");
1044  if (!c) return;
1045 
1046  fBody->Divide(2, 1);
1047  TVirtualPad* p = fBody->cd(1);
1048  p->Divide(1,2);
1049  p->cd(1);
1050 
1051  Double_t y = .8;
1052  Int_t nCutBins=0, fiducial=0, merge=0, skipRings=0;
1053  Double_t fiducialCut=0.;
1054  Bool_t bgAndHits=false;
1055  Double_t size = fLandscape ? 0.06 : 0.04;
1056  if (GetParameter(c, "nCutBins", nCutBins))
1057  DrawParameter(y, "# of bins to cut", Form("%d", nCutBins),size);
1058 
1059  if (GetParameter(c, "skipRings", skipRings)) {
1060  TString skipped;
1061  if (skipRings & 0x05) skipped.Append("FMD1i ");
1062  if (skipRings & 0x09) skipped.Append("FMD2i ");
1063  if (skipRings & 0x0a) skipped.Append("FMD2o ");
1064  if (skipRings & 0x11) skipped.Append("FMD3i ");
1065  if (skipRings & 0x12) skipped.Append("FMD3o ");
1066  if (skipped.IsNull()) skipped = "none";
1067  DrawParameter(y, "Skipped rings", skipped, size);
1068  }
1069  if (GetParameter(c, "bgAndHits", bgAndHits))
1070  DrawParameter(y, "Bg & hit maps stored.", bgAndHits?"yes":"no",size);
1071  if (GetParameter(c, "merge", merge))
1072  DrawParameter(y, "Merge method",
1073  (merge == 0 ? "straight mean" :
1074  merge == 1 ? "straight mean, no zeroes" :
1075  merge == 2 ? "weighted mean" :
1076  merge == 3 ? "least error" :
1077  merge == 4 ? "sum" : "unknown"),size);
1078  if (GetParameter(c, "fiducial", fiducial))
1079  DrawParameter(y, "Fiducial method.",
1080  fiducial == 0 ? "cut" : "distance", size);
1081  if (GetParameter(c, "fiducialCut", fiducialCut))
1082  DrawParameter(y, "Fiducial cut.", Form("%f", fiducialCut), size);
1083 
1084  // p->cd(2);
1085  // Printf("Drawing skipped");
1086  TH1* skipped = GetH1(c, "skipped", false);
1087  if (skipped) {
1088  skipped->SetFillColor(kRed+1);
1089  skipped->SetFillStyle(3001);
1090  }
1091  DrawInPad(p, 2, skipped, "hist");
1092 
1093  p = fBody->cd(2);
1094  p->Divide(1,2,0,0);
1095 
1096  // Printf("Drawing sumRings");
1097  DrawInPad(p, 1, GetH2(c, "sumRings"), "colz");
1098  // Printf("Drawing coverage");
1099  DrawInPad(p, 2, GetH2(c, "coverage"), "colz");
1100  // Printf("Done drawing for now");
1101  PrintCanvas("Histogram collector");
1102 
1103 
1104  TIter next(c);
1105  TObject* o = 0;
1106  TRegexp regexp("[pm][0-9]+_[pm][0-9]+");
1107  while ((o = next())) {
1108  TString name(o->GetName());
1109  if (name.Index(regexp) == kNPOS) continue;
1110 
1111  TList* vl = static_cast<TList*>(o);
1112  if (!vl) continue;
1113 
1114  DivideForRings(false, false);
1115  const char** ptr = GetRingNames(false);
1116  while (*ptr) {
1117  DrawInRingPad(GetH2(vl, Form("secMap%s", *ptr)), "colz", 0x0);
1118  DrawInRingPad(GetH2(vl, Form("hitMap%s", *ptr)), "box same", 0x0);
1119  ptr++;
1120  }
1121  PrintCanvas(Form("Histogram Collector - Vertex bin %s", vl->GetName()));
1122  }
1123 
1124  o = c->FindObject("byCentrality");
1125  if (!o) return;
1126  TList* bc = static_cast<TList*>(o);
1127 
1128  DrawInPad(fBody, GetH3(bc, "FMD1I"), "box", 0);
1129  DrawInPad(fBody, GetH3(bc, "FMD2I"), "box same", 0);
1130  DrawInPad(fBody, GetH3(bc, "FMD2O"), "box same", 0);
1131  DrawInPad(fBody, GetH3(bc, "FMD3O"), "box same", 0);
1132  DrawInPad(fBody, GetH3(bc, "FMD3I"), "box same", kLegend);
1133  }
1134 
1135  //____________________________________________________________________
1137  {
1138  Info("DrawCentral", "Drawing central (SPD)");
1139  TCollection* c = fSums;
1140  if (!c) return;
1141 
1142  fBody->Divide(2, 2);
1143  fBody->cd(1);
1144  Double_t y = .7;
1145  Bool_t secondary=false, acceptance=false;
1146  if (GetParameter(c, "secondary", secondary))
1147  DrawParameter(y, "Secondary corr.", secondary ? "yes" : "no");
1148  if (GetParameter(c, "acceptance", acceptance))
1149  DrawParameter(y, "Acceptance corr.", acceptance ? "yes" : "no");
1150 
1151 
1152  DrawInPad(fBody, 2, GetH2(c, "coverage"), "col", 0,
1153  "#eta coverage per v_{z}");
1154  TH2* cvst = GetH2(c, "nClusterVsnTracklet");
1155  if (cvst) {
1156  // cvst->Scale(1, "width");
1157  cvst->GetXaxis()->SetTitle("N_{free cluster}");
1158  cvst->GetYaxis()->SetTitle("N_{tracklet}");
1159  cvst->GetXaxis()->SetRangeUser(1,10000);
1160  cvst->GetYaxis()->SetRangeUser(1,10000);
1161  }
1162  DrawInPad(fBody, 3, cvst, "colz", kLogx|kLogy|kLogz,
1163  "Correlation of # of tracklets and clusters");
1164  DrawInPad(fBody, 4, GetH2(c, "clusterPerTracklet"), "colz", 0x0,
1165  "# clusters per tracklet vs #eta");
1166  ShowSliceFit(true, cvst, 3, fBody, 3, 0x8000|kLogz);
1167 
1168  fBody->cd(1)->Modified();
1169  fBody->cd(2)->Modified();
1170  fBody->cd(3)->Modified();
1171  fBody->cd(4)->Modified();
1172  fBody->cd(1)->Update();
1173  fBody->cd(2)->Update();
1174  fBody->cd(3)->Update();
1175  fBody->cd(4)->Update();
1176  PrintCanvas("Central - overview");
1177 
1178 
1179  TIter next(c);
1180  TObject* o = 0;
1181  TRegexp regexp("[pm][0-9]+_[pm][0-9]+");
1182  while ((o = next())) {
1183  TString name(o->GetName());
1184  if (name.Index(regexp) == kNPOS) continue;
1185 
1186  TList* vl = static_cast<TList*>(o);
1187 
1188  fBody->Divide(1, 3);
1189 
1190  DrawInPad(fBody, 1, GetH1(vl, "acceptance"), "", 0);
1191 
1192  TH1* sec = GetH1(vl, "secondary");
1193  sec->SetMarkerStyle(21);
1194  sec->SetMarkerSize(1.2);
1195  DrawInPad(fBody, 2, sec, "", 0);
1196  DrawInPad(fBody, 2, GetH1(vl, "secondaryFiducial"), "same", 0x0);
1197  DrawInPad(fBody, 3, GetH2(vl, "secondaryMapFiducial"), "colz", 0);
1198  DrawInPad(fBody, 3, GetH2(vl, "hitMap"), "box same", 0x0);
1199 
1200  fBody->cd(1)->Modified();
1201  fBody->cd(2)->Modified();
1202  fBody->cd(3)->Modified();
1203  fBody->cd(1)->Update();
1204  fBody->cd(2)->Update();
1205  fBody->cd(3)->Update();
1206  PrintCanvas(Form("Central - Vertex bin %s", vl->GetName()));
1207  }
1208  }
1209 
1210 
1211  //____________________________________________________________________
1212  void AddToAll(THStack* all, const THStack* stack, Int_t curr, Int_t step)
1213  {
1214  if (!stack) return;
1215 
1216  TIter next(stack->GetHists());
1217  TH1* h = 0;
1218  while ((h = static_cast<TH1*>(next()))) {
1219  TH1* copy = static_cast<TH1*>(h->Clone(Form("%s_copy", h->GetName())));
1220  copy->SetDirectory(0);
1221  if (curr != step) {
1222  copy->SetMarkerColor(kGray);
1223  copy->SetLineColor(kGray);
1224  }
1225  all->Add(copy);
1226  }
1227  }
1228  //____________________________________________________________________
1229  void AddToAll(THStack* all, const THStack* stack)
1230  {
1231  if (!stack) return;
1232 
1233  TIter next(stack->GetHists());
1234  TH1* h = 0;
1235  while ((h = static_cast<TH1*>(next()))) {
1236  TH1* copy = static_cast<TH1*>(h->Clone(Form("%s_copy", h->GetName())));
1237  copy->SetDirectory(0);
1238  copy->SetMarkerColor(kGray);
1239  copy->SetLineColor(kGray);
1240  all->Add(copy);
1241  }
1242  }
1243 
1244  //____________________________________________________________________
1245  void DrawStep(Int_t step,
1246  THStack* all,
1247  TObject* cur,
1248  TLegend* leg,
1249  const char* title,
1250  TVirtualPad* can,
1251  Int_t sub,
1252  Int_t nCol)
1253  {
1254  if (all->GetHists()->GetEntries() <= 0 || !cur) return;
1255 
1256  // Info("", "Drawing step # %d", step);
1257  Bool_t left = sub % nCol == 1;
1258  Bool_t right= sub % nCol == 0;
1259  Bool_t top = (sub-1) / nCol == 0;
1260  TVirtualPad* p = can->cd(sub);
1261  gStyle->SetOptTitle(0);
1262  p->SetTitle(Form("Step # %d", step));
1263  p->SetFillColor(kWhite);
1264  p->SetRightMargin(right ? 0.02 : 0);
1265  p->SetTopMargin(top ? 0.02 : 0); // 0.02);
1266  // Info("", "Drawing step %d in sub-pad %d (%s)",
1267  // step, sub, (left?"left":"right"));
1268 
1269  p->cd();
1270  all->Draw("nostack");
1271  all->GetHistogram()->SetXTitle("#eta");
1272  all->GetHistogram()->SetYTitle("signal");
1273 
1274  TLegendEntry* e =
1275  static_cast<TLegendEntry*>(leg->GetListOfPrimitives()->At(step-1));
1276  if (e) {
1277  e->SetMarkerColor(kBlack);
1278  e->SetLineColor(kBlack);
1279  e->SetTextColor(kBlack);
1280  }
1281 
1282  // p->cd();
1283  gROOT->SetSelectedPad(p);
1284  cur->DrawClone("same nostack");
1285  leg->DrawClone("");
1286 
1287  TLatex* ltx = new TLatex(.97, .97, title);
1288  ltx->SetNDC();
1289  ltx->SetTextSize(.06);
1290  ltx->SetTextAlign(33);
1291  ltx->Draw();
1292 
1293  ltx = new TLatex((left ? .12 : .02), .97, p->GetTitle());
1294  ltx->SetNDC();
1295  ltx->SetTextSize(.06);
1296  ltx->SetTextAlign(13);
1297  ltx->Draw();
1298 
1299  if (step > 1) {
1300  Double_t x1 = 0.5*(p->GetUxmax()+p->GetUxmin());
1301  Double_t x2 = x1;
1302  Double_t y1 = p->GetUymax();
1303  Double_t y2 = 0.92*y1;
1304  Double_t sz = 0.05;
1305  if (fLandscape) {
1306  x1 = 0.99*p->GetUxmin();
1307  x2 = 0.80*x1;
1308  y1 = .5*(p->GetUymax()+p->GetUymin());
1309  y2 = y1;
1310  sz = 0.034;
1311  }
1312  // Info("", "Arrow at (x1,y1)=%f,%f (x2,y2)=%f,%f", x1, y1, x2, y2);
1313  TArrow* a = new TArrow(x1, y1, x2, y2, sz, "|>");
1314  // (fLandscape ? "<|" : "|>"));
1315  a->SetFillColor(kGray+1);
1316  a->SetLineColor(kGray+1);
1317  a->Draw();
1318  }
1319  p->Modified();
1320  p->Update();
1321  p->cd();
1322 
1323  if (e) {
1324  e->SetMarkerColor(kGray);
1325  e->SetLineColor(kGray);
1326  e->SetTextColor(kGray);
1327  }
1328  gStyle->SetOptTitle(1);
1329  }
1330 
1331  //____________________________________________________________________
1332  void FixStack(THStack* stack, const TString& title,
1333  const TString& extra, Int_t marker)
1334  {
1335  if (!stack) return;
1336  stack->SetTitle(title);
1337  TIter next(stack->GetHists());
1338  TH1* h = 0;
1339  while ((h = static_cast<TH1*>(next()))) {
1340  h->SetMarkerStyle(marker);
1341  TString tit(h->GetTitle());
1342  tit.ReplaceAll("cache", "");
1343  tit.Append(extra);
1344  h->SetTitle(tit);
1345  }
1346  }
1347  void AddLegendEntry(TLegend* l,
1348  const TH1* h,
1349  const TString& title)
1350  {
1351  if (!h) return;
1352 
1353  TLegendEntry* e = l->AddEntry("dummy", title.Data(), "pl");
1354  e->SetMarkerStyle(h->GetMarkerStyle());
1355  e->SetMarkerColor(kGray);
1356  e->SetLineColor(kGray);
1357  e->SetTextColor(kGray);
1358  }
1359 
1360 
1361  //____________________________________________________________________
1362  void DrawSteps()
1363  {
1364  // MakeChapter(can, "Steps");
1365 
1366  THStack* esds = GetStack(GetCollection(fResults, "fmdSharingFilter"),
1367  "sumsESD", "summedESD",false);
1368  THStack* deltas = GetStack(GetCollection(fResults, "fmdSharingFilter"),
1369  "sums", "summed",false);
1370  THStack* nchs = GetStack(GetCollection(fResults,
1371  "fmdDensityCalculator"),
1372  "sums", "inclDensity",false);
1373  THStack* prims = GetStack(GetCollection(fResults, "fmdCorrector"),
1374  "sums", "primaryDensity",false);
1375  THStack* rings = GetStack(GetCollection(fResults, "ringResults"),
1376  "all",0, false);
1377  THStack* mcRings = GetStack(GetCollection(fResults, "mcRingResults", false),
1378  "all","dndeta_eta", false);
1379  TH1* dndeta = GetH1(fResults, "dNdeta", false);
1380  if (dndeta) dndeta->SetMarkerColor(kBlack);
1381  if (!(esds || deltas || nchs || prims || rings)) return;
1382 
1383  FixStack(esds, "#sum_{s} #Delta/#Delta_{mip}", "", 20);
1384  FixStack(deltas, "#sum_{c} #Delta/#Delta_{mip}", "", 21);
1385  FixStack(nchs, "#sum_{b} N_{ch,incl}", "", 22);
1386  FixStack(prims, "#sum_{b} N_{ch,primary}", "", 23);
1387  FixStack(rings, "dN/d#eta per ring", "", 33);
1388  FixStack(mcRings,"dN/d#eta per ring (MC)", "(MC)", 34);
1389 
1390  THStack* all = new THStack;
1391  AddToAll(all, mcRings);
1392  AddToAll(all, esds);
1393  AddToAll(all, deltas);
1394  AddToAll(all, nchs);
1395  AddToAll(all, prims);
1396  AddToAll(all, rings);
1397 
1398  TH1* res = 0;
1399  if (dndeta) {
1400  res = static_cast<TH1*>(dndeta->Clone("dNdeta"));
1401  res->SetTitle("dN/d#eta");
1402  res->SetMarkerColor(kGray);
1403  res->SetLineColor(kGray);
1404  res->SetDirectory(0);
1405  all->Add(res);
1406  }
1407 
1408  TLegend* l = new TLegend(.35, .2, .55, .9);
1409  l->SetFillColor(kWhite);
1410  l->SetFillStyle(0);
1411  l->SetBorderSize(0);
1412  TLegendEntry* e = 0;
1413 
1414  THStack* stacks[] = { mcRings,
1415  esds,
1416  deltas,
1417  nchs,
1418  prims,
1419  rings };
1420 
1421  Int_t nHist = 0;
1422  for (Int_t i = 0; i < 6; i++) {
1423  if (!stacks[i]) continue;
1424  TH1* h = static_cast<TH1*>(stacks[i]->GetHists()->At(0));
1425  AddLegendEntry(l, h, stacks[i]->GetTitle());
1426  nHist++;
1427  }
1428  if (res) {
1429  AddLegendEntry(l, res, res->GetTitle());
1430  nHist++;
1431  }
1432 
1433  TObject* objs[] = { stacks[0],
1434  stacks[1],
1435  stacks[2],
1436  stacks[3],
1437  stacks[4],
1438  stacks[5],
1439  dndeta };
1440  const char* titles[] = { /* 1 */ "MC",
1441  /* 2 */ "ESD input",
1442  /* 3 */ "After merging",
1443  /* 4 */ "After particle counting",
1444  /* 5 */ "After corrections",
1445  /* 6 */ "After normalization",
1446  /* 7 */ "After combining" };
1447  Int_t nY = nHist > 6 ? 4 : 3;
1448  Int_t nX = 2;
1449  if (fLandscape) {
1450  Int_t tmp = nX;
1451  nX = nY;
1452  nY = tmp;
1453  }
1454  fBody->Divide(nX, nY, 0, 0);
1455 
1456  Int_t step = 0;
1457  for (Int_t i = 0; i < 7; i++) {
1458  TObject* obj = objs[i];
1459  if (!obj) continue;
1460 
1461  step++;
1462  Int_t padNo = step;
1463  if (!fLandscape) {
1464  switch (step) {
1465  case 1: padNo = 1; break;
1466  case 2: padNo = 3; break;
1467  case 3: padNo = 5; break;
1468  case 4: padNo = (mcRings ? 7 : 2); break;
1469  case 5: padNo = (mcRings ? 2 : 4); break;
1470  case 6: padNo = (mcRings ? 4 : 6); break;
1471  case 7: padNo = (mcRings ? 6 : 8); break;
1472  }
1473  }
1474  //Printf("Drawing step %d in sub-pad %d (%s)",step,padNo,obj->GetTitle());
1475  DrawStep(step, all, obj, l, titles[i], fBody, padNo, nX);
1476  }
1477 
1478  if (!esds && !mcRings && deltas) {
1479  fBody->cd(6);
1480  TLegend* ll = new TLegend(0.01, 0.11, 0.99, 0.99);
1481  // ll->SetNDC();
1482  ll->SetFillColor(kWhite);
1483  ll->SetFillStyle(0);
1484  ll->SetBorderSize(0);
1485 
1486  TIter next(deltas->GetHists());
1487  TH1* hh = 0;
1488  while ((hh = static_cast<TH1*>(next()))) {
1489  e = ll->AddEntry("dummy", hh->GetTitle(), "pl");
1490  e->SetMarkerColor(hh->GetMarkerColor());
1491  e->SetMarkerStyle(hh->GetMarkerStyle());
1492  e->SetLineColor(kBlack);
1493  }
1494  ll->Draw();
1495  }
1496  // Printf("Done drawing steps");
1497  PrintCanvas("Steps");
1498  }
1499 
1500 
1501  //____________________________________________________________________
1503  {
1504  // MakeChapter(can, "Results");
1505 
1506  fBody->Divide(2,1);
1507 
1508  TCollection* c = GetCollection(fResults, "ringResults");
1509  if (!c) return;
1510 
1511  THStack* mcRings = GetStack(GetCollection(fResults, "mcRingResults", false),
1512  "all", "dndeta_eta", false);
1513 
1514  TH1* dndeta_phi = GetH1(fResults, "dNdeta");
1515  TH1* dndeta_eta = GetH1(fResults, "dNdeta_");
1516  dndeta_phi->SetTitle("1/N_{ev}dN_{ch}/d#eta (#varphi norm)");
1517  dndeta_eta->SetTitle("1/N_{ev}dN_{ch}/d#eta (#eta norm)");
1518  dndeta_eta->SetMarkerSize(0.7);
1519 
1520  THStack* allPhi = new THStack("phiAcc", "#varphi Acceptance");
1521  THStack* allEta = new THStack("etaCov", "#eta Coverage");
1522  const char** pring = GetRingNames(false);
1523 
1524  while ((*pring)) {
1525  TCollection* cc = GetCollection(c, *pring);
1526  TH1* etaCov = GetH1(cc, "etaCov");
1527  TH1* phiAcc = GetH1(cc, "phiAcc");
1528  TH1* dndeta = GetH1(cc, "dndeta_phi");
1529  Int_t color = kBlack;
1530  if (dndeta) color = dndeta->GetMarkerColor();
1531  if (etaCov) {
1532  etaCov->SetTitle(*pring);
1533  etaCov->SetFillColor(color);
1534  etaCov->SetLineColor(color);
1535  allEta->Add(etaCov);
1536  }
1537  if (phiAcc) {
1538  phiAcc->SetFillColor(color);
1539  phiAcc->SetLineColor(color);
1540  allPhi->Add(phiAcc);
1541  }
1542  pring++;
1543  }
1544  Double_t savX = fParVal->GetX();
1545  Double_t savY = fParVal->GetY();
1546  fParVal->SetX(.3);
1547  fParVal->SetY(.2);
1548  TVirtualPad* p = fBody->cd(1);
1549  p->Divide(1,2,0,0);
1550  DrawInPad(p, 1, GetStack(c, "all"), "nostack", mcRings ? 0 : kLegend,
1551  "Individual ring results");
1552  DrawInPad(p, 1, mcRings, "nostack same", kLegend|kSilent);
1553  DrawInPad(p, 2, allEta, "nostack hist", kLegend,
1554  "#phi acceptance and #eta coverage per ring");
1555  DrawInPad(p, 2, allPhi, "nostack hist same", 0x0);
1556 
1557  p = fBody->cd(2);
1558  p->Divide(1,2,0,0);
1559  DrawInPad(p, 1, dndeta_phi, "", 0x0,
1560  "1/#it{N}_{ev} d#it{N}_{ch}/d#it{#eta}");
1561  DrawInPad(p, 1, dndeta_eta, "Same", kLegend);
1562  DrawInPad(p, 2, GetH1(fResults, "norm"), "", 0x0,
1563  "Total #phi acceptance and #eta coverage");
1564  DrawInPad(p, 2, GetH1(fResults, "phi"), "same", kLegend);
1565  // DrawInPad(fBody, 4, GetH1(fSums, "d2Ndetadphi"), "colz");
1566 
1567  // fBody->cd(1);
1568  // TLatex* l = new TLatex(.5, .2, "Ring results");
1569  // l->SetNDC();
1570  // l->SetTextAlign(21);
1571  // l->Draw();
1572 
1573  // fBody->cd(2);
1574  // l->DrawLatex(.5, .2, "1/N_{ev}dN_{ch}/d#eta");
1575 
1576  // fBody->cd(3);
1577  // l->DrawLatex(.5, .2, "1/N_{ev}dN_{ch}/d#eta (#vta norm.)");
1578 
1579  fParVal->SetX(savX);
1580  fParVal->SetY(savY);
1581  PrintCanvas("Results");
1582  }
1583 
1584  //____________________________________________________________________
1586  {
1587  // MakeChapter(can, "Results");
1588  Info("DrawCentralResults", "Drawing central results");
1589 
1590  fBody->Divide(1,2,0,0);
1591 
1592  TH1* dndeta_ = GetH1(fResults, "dNdeta_");
1593  TH1* dndeta = GetH1(fResults, "dNdeta");
1594  THStack* stack = new THStack("dndetas",
1595  "d#it{N}_{ch}/d#it{#eta} - central");
1596  stack->Add(dndeta_);
1597  stack->Add(dndeta);
1598 
1599  DrawInPad(fBody, 1, stack, "nostack");
1600  TH1* h = stack->GetHistogram();
1601  if (h) {
1602  h->SetXTitle("#it{#eta}");
1603  h->SetYTitle("#frac{d#it{N}_{ch}}{d#it{#eta}}");
1604  }
1605  fBody->cd(1);
1606  TLegend* l = new TLegend(.3, .05, .7, .4);
1607  l->SetFillColor(0);
1608  l->SetFillStyle(0);
1609  l->SetBorderSize(0);
1610  l->AddEntry(dndeta_, "Normalized to coverage", "lp");
1611  l->AddEntry(dndeta, "Normalized to #phi acceptance", "lp");
1612  l->Draw();
1613 
1614  DrawInPad(fBody, 2, GetH1(fResults, "norm"));
1615  DrawInPad(fBody, 2, GetH1(fResults, "phi"), "same", kLegend);
1616 
1617  PrintCanvas("Central Results");
1618 
1619  }
1620  void DrawBoth(TFile* file)
1621  {
1622  Info("DrawBoth", "Drawing central & forward results");
1623  TCollection* central = GetCollection(file, "CentralResults");
1624  TCollection* forward = GetCollection(file, "ForwardResults");
1625 
1626  if (!central || !forward) {
1627  Warning("DrawBoth", "central %p or forward %p results not found",
1628  central, forward);
1629  return;
1630  }
1631 
1632  TH1* f1 = GetH1(forward, "dNdeta_");
1633  TH1* c1 = GetH1(central, "dNdeta_");
1634  TH1* f2 = GetH1(forward, "dNdeta");
1635  TH1* c2 = GetH1(central, "dNdeta");
1636  if (!f1 || !c1 || !f2 || !c2) return;
1637  f1->SetLineColor(kBlack);
1638  f2->SetLineColor(kBlack);
1639  c1->SetLineColor(kBlack);
1640  c2->SetLineColor(kBlack);
1641  f1->SetMarkerColor(f2->GetMarkerColor());
1642  f1->SetMarkerStyle(24);
1643  c1->SetMarkerStyle(24);
1644  c2->SetMarkerStyle(20);
1645  c2->SetMarkerColor(c1->GetMarkerColor());
1646  THStack* s = new THStack("dndetas", "d#it{N}_{ch}/d#it{#eta}");
1647  s->Add(f1);
1648  s->Add(c1);
1649  s->Add(f2);
1650  s->Add(c2);
1651 
1652  fBody->Divide(1, 2, 0, 0);
1653  DrawInPad(fBody, 1, s, "nostack");
1654  s->GetHistogram()->SetXTitle("#it{#eta}");
1655  s->GetHistogram()->SetYTitle("#frac{d#it{N}_{ch}}{d#it{#eta}}");
1656 
1657  fBody->cd(1);
1658  TLegend* l = new TLegend(.4, .05, .8, .4);
1659  l->SetFillColor(0);
1660  l->SetFillStyle(0);
1661  l->SetBorderSize(0);
1662  TLegendEntry* entry = l->AddEntry("dummy", "Forward", "f");
1663  entry->SetFillColor(f1->GetMarkerColor());
1664  entry->SetLineColor(f1->GetMarkerColor());
1665  entry->SetFillStyle(1001);
1666  entry->SetLineWidth(0);
1667  entry = l->AddEntry("dummy", "Central", "f");
1668  entry->SetFillColor(c1->GetMarkerColor());
1669  entry->SetLineColor(c1->GetMarkerColor());
1670  entry->SetLineWidth(0);
1671  entry->SetFillStyle(1001);
1672  entry = l->AddEntry("dummy", "Normalized to coverage", "lp");
1673  entry->SetMarkerStyle(f1->GetMarkerStyle());
1674  entry = l->AddEntry("dummy", "Normalized to #phi acceptance", "lp");
1675  entry->SetMarkerStyle(f2->GetMarkerStyle());
1676  l->Draw();
1677 
1678  TH1* f3 = GetH1(forward, "norm");
1679  TH1* c3 = GetH1(central, "norm");
1680  TH1* f4 = GetH1(forward, "phi");
1681  TH1* c4 = GetH1(central, "phi");
1682  f3->SetFillColor(f1->GetMarkerColor());
1683  f4->SetFillColor(f1->GetMarkerColor());
1684  c3->SetFillColor(c1->GetMarkerColor());
1685  c4->SetFillColor(c1->GetMarkerColor());
1686  f3->SetLineColor(f1->GetMarkerColor());
1687  f4->SetLineColor(f1->GetMarkerColor());
1688  c3->SetLineColor(c1->GetMarkerColor());
1689  c4->SetLineColor(c1->GetMarkerColor());
1690 
1691  THStack* a = new THStack("norms", "Normalizations");
1692  a->Add(f3);
1693  a->Add(c3);
1694  a->Add(f4);
1695  a->Add(c4);
1696 
1697  a->SetMaximum(a->GetMaximum("nostack")*1.2);
1698  DrawInPad(fBody, 2, a, "nostack");
1699  a->GetHistogram()->SetXTitle("#it{#eta}");
1700  a->GetHistogram()->SetYTitle("Normalization (coverage or acceptance)");
1701 
1702  fBody->cd(2);
1703  l = new TLegend(.2, .94, .9, .99);
1704  l->SetFillColor(0);
1705  l->SetFillStyle(0);
1706  l->SetBorderSize(0);
1707  l->SetNColumns(2);
1708  // entry = l->AddEntry("dummy", "Forward", "f");
1709  // entry->SetFillColor(f1->GetMarkerColor());
1710  // entry->SetLineColor(f1->GetMarkerColor());
1711  // entry->SetFillStyle(1001);
1712  // entry->SetLineWidth(0);
1713  // entry = l->AddEntry("dummy", "Central", "f");
1714  // entry->SetFillColor(c1->GetMarkerColor());
1715  // entry->SetLineColor(c1->GetMarkerColor());
1716  // entry->SetLineWidth(0);
1717  // entry->SetFillStyle(1001);
1718  entry = l->AddEntry("dummy", "#eta Coverage", "f");
1719  entry->SetFillStyle(f3->GetFillStyle());
1720  entry->SetFillColor(kBlack);
1721  entry = l->AddEntry("dummy", "#phi Acceptance", "f");
1722  entry->SetFillStyle(f4->GetFillStyle());
1723  entry->SetFillColor(kBlack);
1724  l->Draw();
1725 
1726  PrintCanvas("Both results");
1727  }
1730 };
1731 
1732 // #endif
Int_t color[]
const Char_t * CutMethodName(Int_t lm) const
void SummarizeSharing(const char *fname, UShort_t what=0)
const char * filename
Definition: TestFCM.C:1
TLatex * fParName
const Color_t cc[]
Definition: DrawKs.C:1
double Double_t
Definition: External.C:58
Base class for classes to draw summaries.
const char * title
Definition: MakeQAPdf.C:26
TGraph * CreateCutGraph(Int_t method, Int_t iy, TH2 *cuts, TH1 *eloss, Int_t color)
static TH1 * GetH1(const TObject *parent, const TString &name, Bool_t verb=true)
static TH2 * GetH2(const TObject *parent, const TString &name, Bool_t verb=true)
void DrawCut(TVirtualPad *parent, Int_t sub, TH2 *cuts)
void DrawInRingPad(UShort_t d, Char_t r, TObject *h, Option_t *opts="", UShort_t flags=0x0, const char *title="")
void DrawBoth(TFile *file)
void Run(const char *fname, UShort_t what=kNormal)
void DrawTrackDensity(TCollection *parent, const char *folderName="mcTrackDensity")
char Char_t
Definition: External.C:18
TFile * Init(const char *fname)
TCanvas * c
Definition: TestFitELoss.C:172
void ShowSliceFit(Bool_t inY, TH2 *h, Double_t nVar, TVirtualPad *p, Int_t sub, UShort_t flags=0, Double_t cut=-1)
Int_t PrintCut(const TCollection *c, Double_t &y, const Char_t *name, Double_t size=0)
void DrawTitlePage(TFile *f)
void AddToAll(THStack *all, const THStack *stack, Int_t curr, Int_t step)
void MakeChapter(const TString &title)
static void SysString(UShort_t sys, TString &str)
static TH3 * GetH3(const TCollection *parent, const TString &name, Bool_t verb=true)
int Int_t
Definition: External.C:63
float Float_t
Definition: External.C:68
Int_t method
TCollection * fResults
static Bool_t GetParameter(const TObject *c, const TString &name, Short_t &value, Bool_t verb=true)
void DrawStep(Int_t step, THStack *all, TObject *cur, TLegend *leg, const char *title, TVirtualPad *can, Int_t sub, Int_t nCol)
static TObject * GetObject(const TObject *parent, const TString &name, Bool_t verb=true)
unsigned long ULong_t
Definition: External.C:38
const char * pdfName
Definition: DrawAnaELoss.C:30
void CreateCanvas(const TString &pname, Bool_t landscape=false, Bool_t pdf=true, Bool_t useTop=true)
void SummarizeSteps(const char *fname, UShort_t what=0)
void DrawParameter(Double_t &y, const TString &name, const TString &value, Double_t size=0)
static const Char_t ** GetRingNames(Bool_t lower=false)
void PrintCanvas(const TString &title, Float_t size=.7)
const char * fwd
TCollection * fSums
static void SNNString(UShort_t sNN, TString &str)
void CloseCanvas()
virtual void DrawEventInspector(TCollection *parent)
void DivideForRings(Bool_t commonX, Bool_t commonY)
TLatex * fParVal
Definition: External.C:220
const Int_t nVar
TFile * file
unsigned short UShort_t
Definition: External.C:28
void AddLegendEntry(TLegend *l, const TH1 *h, const TString &title)
TObject * DrawInPad(TVirtualPad *c, Int_t padNo, TObject *h, Option_t *opts="", UInt_t flags=0x0, const char *title="")
bool Bool_t
Definition: External.C:53
virtual void DrawESDFixer(TCollection *parent)
TVirtualPad * RingPad(UShort_t d, Char_t r) const
static TCollection * GetCollection(const TObject *parent, const TString &name, Bool_t verb=true)
void FixStack(THStack *stack, const TString &title, const TString &extra, Int_t marker)
Definition: External.C:196
static Color_t RingColor(UShort_t d, Char_t r)
static THStack * GetStack(const TObject *parent, const TString &name, const char *sub=0, Bool_t verb=true)
void AddToAll(THStack *all, const THStack *stack)