Fix up some drawing stuff
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 3 Feb 2011 14:54:25 +0000 (14:54 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 3 Feb 2011 14:54:25 +0000 (14:54 +0000)
PWG2/FORWARD/analysis2/AliFMDCorrELossFit.cxx
PWG2/FORWARD/analysis2/AliFMDCorrELossFit.h
PWG2/FORWARD/analysis2/AnalyseAOD.C
PWG2/FORWARD/analysis2/scripts/DrawCorrELoss.C

index 774db2f..6269129 100644 (file)
@@ -1,6 +1,7 @@
-// Object holding the Energy loss fit 'correction'
+// Object holding the Energy loss fit 'correction' 
 // 
 // These are generated from Monte-Carlo or real ESDs. 
+//
 #include "AliFMDCorrELossFit.h"
 #include "AliForwardUtil.h"
 #include <TF1.h>
@@ -9,6 +10,7 @@
 #include <THStack.h>
 #include <TH1D.h>
 #include <AliLog.h>
+#include <TMath.h>
 #include <TList.h>
 #include <iostream>
 #include <iomanip>
@@ -913,6 +915,8 @@ namespace {
   }
 }
 
+#define IDX2RING(I) (i == 0 || i == 1 || i == 3 ? 'I' : 'O')
+#define IDX2DET(I)  (i == 0 ? 1 : (i == 1 || i == 2 ? 2 : 3))
 //____________________________________________________________________
 void
 AliFMDCorrELossFit::Draw(Option_t* option)
@@ -926,10 +930,10 @@ AliFMDCorrELossFit::Draw(Option_t* option)
   //
   TString opt(Form("nostack %s", option));
   opt.ToLower();
-  Bool_t  rel = (opt.Contains("rel"));
-  Bool_t  err = (opt.Contains("err"));
-  if (rel) opt.ReplaceAll("rel","");
-  if (err) opt.ReplaceAll("err","");
+  Bool_t  rel = (opt.Contains("relative"));
+  Bool_t  err = (opt.Contains("error"));
+  if (rel) opt.ReplaceAll("relative","");
+  if (err) opt.ReplaceAll("error","");
   Int_t    nRings = fRings.GetEntriesFast();
   UShort_t maxN   = 0;
   for (Int_t i = 0; i < nRings; i++) { 
@@ -944,58 +948,65 @@ AliFMDCorrELossFit::Draw(Option_t* option)
     }
   }
   // AliInfo(Form("Maximum N is %d", maxN));
-  Int_t nPad = 7+maxN-1; // 7 regular params, and maxN-1 weights
+  Int_t nPad = 6+maxN-1; // 7 regular params, and maxN-1 weights
   TVirtualPad* pad = gPad;
   pad->Divide(2, (nPad+1)/2, 0.1, 0, 0);
+
+  enum { 
+    kChi2nu = 0, 
+    kC      = 1, 
+    kDelta  = 2, 
+    kXi     = 3, 
+    kSigma  = 4, 
+    kN      = 5 
+  };
   
-  THStack* chi2nu;
-  THStack* c;
-  THStack* delta;
-  THStack* xi;
-  THStack* sigma;
-  THStack* sigman;
+  THStack* sChi2nu;
+  THStack* sC;
+  THStack* sDelta;
+  THStack* sXi;
+  THStack* sSigma;
+  // THStack* sigman;
   THStack* n;
   TList stacks;
-  stacks.AddAt(chi2nu= new THStack("chi2",   "#chi^{2}/#nu"), 0);
-  stacks.AddAt(c     = new THStack("c",       "C"),           1);
-  stacks.AddAt(delta = new THStack("delta",  "#Delta_{mp}"),  2);
-  stacks.AddAt(xi    = new THStack("xi",     "#xi"),          3);
-  stacks.AddAt(sigma = new THStack("sigma",  "#sigma"),       4);
-  stacks.AddAt(sigman= new THStack("sigman", "#sigma_{n}"),   5);
-  stacks.AddAt(n     = new THStack("n",      "N"),            6);
+  stacks.AddAt(sChi2nu= new THStack("chi2",   "#chi^{2}/#nu"), kChi2nu);
+  stacks.AddAt(sC     = new THStack("c",       "C"),           kC);
+  stacks.AddAt(sDelta = new THStack("delta",  "#Delta_{mp}"),  kDelta);
+  stacks.AddAt(sXi    = new THStack("xi",     "#xi"),          kXi);
+  stacks.AddAt(sSigma = new THStack("sigma",  "#sigma"),       kSigma);
+  //stacks.AddAt(sigman= new THStack("sigman", "#sigma_{n}"),   5);
+  stacks.AddAt(n     = new THStack("n",      "N"),            kN);
   for (Int_t i = 1; i <= maxN; i++) {
-    stacks.AddAt(new THStack(Form("a_%02d", i+1), Form("a_{%d}", i+1)), 6+i);
+    stacks.AddAt(new THStack(Form("a_%02d", i+1), Form("a_{%d}", i+1)), kN+i);
   }
 
+  TArrayD min(nPad);
+  TArrayD max(nPad);
+  min.Reset(100000);
+  max.Reset(-100000);
+
   for (Int_t i = 0; i < nRings; i++) { 
     if (!fRings.At(i)) continue;
     TObjArray* a     = static_cast<TObjArray*>(fRings.At(i));
     Int_t      nFits = a->GetEntriesFast();
-    Int_t      color = 0;
-    switch (i) { 
-    case 0: color = kRed+2;   break;
-    case 1: color = kGreen+2; break;
-    case 2: color = kGreen-2; break;
-    case 3: color = kBlue+2;  break;
-    case 4: color = kBlue-2;  break;
-    }
+    Int_t      color = AliForwardUtil::RingColor(IDX2DET(i), IDX2RING(i));
 
     TH1D* hChi    = MakeHist(fEtaAxis,a->GetName(), "chi2",   color);
     TH1D* hC      = MakeHist(fEtaAxis,a->GetName(), "c",      color);
     TH1D* hDelta  = MakeHist(fEtaAxis,a->GetName(), "delta",  color);
     TH1D* hXi     = MakeHist(fEtaAxis,a->GetName(), "xi",     color);
     TH1D* hSigma  = MakeHist(fEtaAxis,a->GetName(), "sigma",  color);
-    TH1D* hSigmaN = MakeHist(fEtaAxis,a->GetName(), "sigman", color);
+    // TH1D* hSigmaN = MakeHist(fEtaAxis,a->GetName(), "sigman", color);
     TH1D* hN      = MakeHist(fEtaAxis,a->GetName(), "n",      color);
     TH1D* hA[maxN];
     const char* ho = (rel || !err ? "hist" : "e");
-    chi2nu->Add(hChi,   "hist"); // 0
-    c     ->Add(hC,     ho);     // 1
-    delta ->Add(hDelta, ho);     // 2
-    xi    ->Add(hXi,    ho);     // 3
-    sigma ->Add(hSigma, ho);     // 4
-    sigman->Add(hSigmaN,ho);     // 5
-    n     ->Add(hN,     "hist"); // 6
+    sChi2nu->Add(hChi,   "hist"); // 0
+    sC     ->Add(hC,     ho);     // 1
+    sDelta ->Add(hDelta, ho);     // 2
+    sXi    ->Add(hXi,    ho);     // 3
+    sSigma ->Add(hSigma, ho);     // 4
+    // sigman->Add(hSigmaN,ho);     // 5
+    n     ->Add(hN,     "hist"); // 5
     hChi->SetFillColor(color);
     hChi->SetFillStyle(3001);
     hN->SetFillColor(color);
@@ -1003,43 +1014,72 @@ AliFMDCorrELossFit::Draw(Option_t* option)
 
     for (Int_t k = 1; k <= maxN; k++) { 
       hA[k-1] = MakeHist(fEtaAxis,a->GetName(), Form("a%02d",k+1), color);
-      static_cast<THStack*>(stacks.At(6+k))->Add(hA[k-1], ho);
+      static_cast<THStack*>(stacks.At(kN+k))->Add(hA[k-1], ho);
     }
                          
     for (Int_t j = 0; j < nFits; j++) {
       ELossFit* f = static_cast<ELossFit*>(a->At(j));
       if (!f) continue;
 
-      Int_t     b = f->fBin;
-      Int_t     nW = f->FindMaxWeight();
-      hChi   ->SetBinContent(b, (f->fNu <= 0 ? 0 : f->fChi2 / f->fNu));
+      Int_t     b      = f->fBin;
+      Int_t     nW     = f->FindMaxWeight();
+      Double_t  vChi2nu = (f->fNu <= 0 ? 0 : f->fChi2 / f->fNu);
+      Double_t  vC      = (rel ? (f->fC     >0 ?f->fEC     /f->fC      :0) 
+                          : f->fC);
+      Double_t  vDelta  = (rel ? (f->fDelta >0 ?f->fEDelta /f->fDelta  :0) 
+                          : f->fDelta);
+      Double_t  vXi     = (rel ? (f->fXi    >0 ?f->fEXi    /f->fXi     :0) 
+                          : f->fXi);
+      Double_t  vSigma  = (rel ? (f->fSigma >0 ?f->fESigma /f->fSigma  :0) 
+                          : f->fSigma);
+      // Double_t  sigman = (rel ? (f->fSigmaN>0 ?f->fESigmaN/f->fSigmaN :0) 
+      //                     : f->SigmaN); 
+      hChi   ->SetBinContent(b, vChi2nu);
       hN     ->SetBinContent(b, nW);
-
-      if (rel) { 
-       hC     ->SetBinContent(b, f->fC     >0 ?f->fEC     /f->fC      :0);
-       hDelta ->SetBinContent(b, f->fDelta >0 ?f->fEDelta /f->fDelta  :0);
-       hXi    ->SetBinContent(b, f->fXi    >0 ?f->fEXi    /f->fXi     :0);
-       hSigma ->SetBinContent(b, f->fSigma >0 ?f->fESigma /f->fSigma  :0);
-       hSigmaN->SetBinContent(b, f->fSigmaN>0 ?f->fESigmaN/f->fSigmaN :0);
+      hC     ->SetBinContent(b, vC);
+      hDelta ->SetBinContent(b, vDelta);
+      hXi    ->SetBinContent(b, vXi);
+      hSigma ->SetBinContent(b, vSigma);
+      if (vChi2nu > 1e-12) {
+       min[kChi2nu] = TMath::Min(min[kChi2nu], vChi2nu);
+       max[kChi2nu] = TMath::Max(max[kChi2nu], vChi2nu);
+      }
+      if (vC > 1e-12) {
+       min[kC] = TMath::Min(min[kC], vC);
+       max[kC] = TMath::Max(max[kC], vC);
+      }
+      if (vDelta > 1e-12) {
+       min[kDelta] = TMath::Min(min[kDelta], vDelta);
+       max[kDelta] = TMath::Max(max[kDelta], vDelta);
+      }
+      if (vXi > 1e-12) {
+       min[kXi] = TMath::Min(min[kXi], vXi);
+       max[kXi] = TMath::Max(max[kXi], vXi);
       }
-      else {
-       hC     ->SetBinContent(b, f->fC);
-       hDelta ->SetBinContent(b, f->fDelta);
-       hXi    ->SetBinContent(b, f->fXi);
-       hSigma ->SetBinContent(b, f->fSigma);
-       hSigmaN->SetBinContent(b, f->fSigmaN);
+      if (vSigma > 1e-12) {
+       min[kSigma] = TMath::Min(min[kSigma], vSigma);
+       max[kSigma] = TMath::Max(max[kSigma], vSigma);
+      }
+      if (nW > 1e-12) { 
+       min[kN] = TMath::Min(min[kN], Double_t(nW));
+       max[kN] = TMath::Max(max[kN], Double_t(nW));
+      }
+      // hSigmaN->SetBinContent(b,  sigman);
+      if (!rel) {
        hC     ->SetBinError(b, f->fEC);
        hDelta ->SetBinError(b, f->fEDelta);
        hXi    ->SetBinError(b, f->fEXi);
        hSigma ->SetBinError(b, f->fESigma);
-       hSigmaN->SetBinError(b, f->fESigmaN);
+       // hSigmaN->SetBinError(b, f->fESigmaN);
       }
       for (Int_t k = 0; k < f->fN-1 && k < maxN; k++) { 
-       if (rel) 
-         hA[k]->SetBinContent(b, f->fA[k] > 0 ? f->fEA[k] / f->fA[k] : 0);
-       else {
-         hA[k]->SetBinContent(b, f->fA[k]);
-         hA[k]->SetBinError(b, f->fEA[k]);
+       Double_t vA = (rel ? (f->fA[k] > 0 ? f->fEA[k] / f->fA[k] : 0) 
+                      : f->fA[k]);
+       hA[k]->SetBinContent(b, vA);
+       if (!rel) hA[k]->SetBinError(b, f->fEA[k]);
+       if (vA > 1e-12) {
+         min[kN+1+k] = TMath::Min(min[kN+1+k], vA);
+         max[kN+1+k] = TMath::Max(max[kN+1+k], vA);
        }
       }
     }
@@ -1055,8 +1095,13 @@ AliFMDCorrELossFit::Draw(Option_t* option)
     p->SetGridy();
     if (rel && i != 0 && i != 6 && i != 5 && i != 4) p->SetLogy();
 
+    Double_t powMax = TMath::Log10(max[i]);
+    Double_t powMin = min[i] <= 0 ? powMax : TMath::Log10(min[i]);
+    if (powMax-powMin > 2. && min[i] != 0) p->SetLogy();
+
     THStack* stack = static_cast<THStack*>(stacks.At(i));
-    // AliInfo(Form("Drawing %s (%d) in pad %d", stack->GetName(), i, iPad));
+    // stack->SetMinimum(min[i]);
+    // stack->SetMaximum(max[i]);
     stack->Draw(opt.Data());
 
     TString tit(stack->GetTitle());
@@ -1068,32 +1113,21 @@ AliFMDCorrELossFit::Draw(Option_t* option)
     yaxis->SetTitleSize(0.15);
     yaxis->SetLabelSize(0.08);
     yaxis->SetTitleOffset(0.35);
+    yaxis->SetTitleFont(132);
+    yaxis->SetLabelFont(132);
     yaxis->SetNdivisions(5);
 
+
     TAxis* xaxis = stack->GetHistogram()->GetXaxis();
     xaxis->SetTitle("#eta");
     xaxis->SetTitleSize(0.15);
     xaxis->SetLabelSize(0.08);
     xaxis->SetTitleOffset(0.35);
+    xaxis->SetTitleFont(132);
+    xaxis->SetLabelFont(132);
     xaxis->SetNdivisions(10);
 
-
-    if (!rel) {
-      switch (i) { 
-      case 0:                         break; // chi^2/nu 
-      case 1:                         break; // C 
-      case 2: stack->SetMinimum(0.4); break; // Delta 
-      case 3: stack->SetMinimum(0.02);break; // xi
-      case 4: stack->SetMinimum(0.05);break; // sigma
-      case 5:                         break; // sigmaN
-      case 6: 
-       stack->SetMinimum(-.1); 
-       stack->SetMaximum(maxN+.5); 
-       break;                              // N
-      default:                       break; // Weights
-      }
-    }
-    stack->DrawClone(opt.Data());
+    stack->Draw(opt.Data());
   }
   pad->cd();      
 }
index 3f9ab6a..4d8fca4 100644 (file)
@@ -544,7 +544,8 @@ public:
    * Draw this object 
    *
    * @param option Options.  Possible values are 
-   *  - err Plot error bars 
+   *  - error Plot error bars 
+   *  - relative Plot relative errors
    */
   void Draw(Option_t* option=""); //*MENU*
   /** 
index 19625a0..28793ac 100644 (file)
@@ -1,3 +1,4 @@
+
 /**
  * @file 
  * 
@@ -24,6 +25,7 @@
 #include <TSystem.h>
 #include "AliAODForwardMult.h"
 #include "OtherData.C"
+#include <ctime>
 
 /** 
  * Draw the data stored in the AOD 
@@ -358,12 +360,21 @@ public:
     fNWithVertex      = 0;                    // # of ev. w/vertex
     fNAccepted        = 0;                    // # of ev. used
     Int_t nAvailable  = fTree->GetEntries();  // How many entries
+    Int_t start       = time(NULL);
  
     for (int i = 0; i < nAvailable; i++) { 
       fTree->GetEntry(i);
       if (((i+1) % 100) == 0) {
-       fprintf(stdout,"Event # %9d of %9d, %9d accepted so far\r", 
-              i+1, nAvailable, fNAccepted);
+       Int_t  now  = time(NULL);
+       double t    = difftime(now,start);
+       double full = t / (i+1) * nAvailable;
+       int    rem  = full-t;
+       Int_t  ss   = rem % 60;
+       Int_t  mm   = (rem / 60) % 60;
+       Int_t  hh   = (rem / 60 / 60);
+       fprintf(stdout,"Event # %9d of %9d, %9d accepted so far  "
+               "ETA %02d:%02d:%02d\r", i+1, nAvailable, fNAccepted,
+               hh, mm, ss);
        fflush(stdout);
       }
 
@@ -412,7 +423,15 @@ public:
       // Add contribution from this event
       if (fSumCentral) fSumCentral->Add(fCentral);      
     }
-    printf("\n");
+    Int_t  now  = time(NULL);
+    Int_t  t    = Int_t(difftime(now,start));
+    Int_t  ss   = t % 60;
+    Int_t  mm   = (t / 60) % 60;
+    Int_t  hh   = (t / 60 / 60);
+    fprintf(stdout,"%9d events processed in %02d:%02d:%02d%33s\n", 
+           nAvailable, hh, mm, ss, " ");
+    fflush(stdout);
+
     // fVtxEff = Double_t(fNWithVertex)/fNTriggered;
     Int_t nGood = (fNB-fNA-fNC+2*fNE);
     fVtxEff = (Double_t(fNMB) / fNTriggered) * 
index 1470ccf..4e18885 100644 (file)
@@ -40,7 +40,7 @@ ClearCanvas(TCanvas* c)
  * @ingroup pwg2_forward_analysis_scripts
  */
 void
-DrawCorrELoss(const char* fname, const char* option="err")
+DrawCorrELoss(const char* fname, const char* option="summary error")
 {
   //__________________________________________________________________
   // Load libraries and object 
@@ -51,7 +51,7 @@ DrawCorrELoss(const char* fname, const char* option="err")
     Error("DrawCorrELoss", "Failed to open %s", fname);
     return;
   }
-  TString pname(fname);
+  TString pname(gSystem->BaseName(fname));
   pname.ReplaceAll(".root", ".pdf");
 
   AliFMDCorrELossFit* fits = 
@@ -62,15 +62,24 @@ DrawCorrELoss(const char* fname, const char* option="err")
   }
 
   //__________________________________________________________________
+  TString opts(option);
+  opts.ToLower();
+  Bool_t summary = opts.Contains("summary");
+  if (summary) opts.ReplaceAll("summary", "");
+
+  //__________________________________________________________________
   // Create a canvas
-  TCanvas* c = new TCanvas("c", "c", 800 / TMath::Sqrt(2), 800);
+  Int_t h = 800;
+  Int_t w = h / TMath::Sqrt(2);
+  if (summary) w = h;
+  TCanvas* c = new TCanvas("c", "c", w, h);
   c->SetFillColor(0);
   c->SetBorderSize(0);
   c->SetBorderMode(0);
   c->Print(Form("%s[", pname.Data()));
   
   gStyle->SetOptStat(0);
-  gStyle->SetTitleColor(0);
+  gStyle->SetTitleFillColor(0);
   gStyle->SetTitleStyle(0);
   gStyle->SetTitleBorderSize(0);
   gStyle->SetTitleX(.7);
@@ -83,53 +92,62 @@ DrawCorrELoss(const char* fname, const char* option="err")
 
   ClearCanvas(c);
   //__________________________________________________________________
-  // Create a title page 
-  TLatex* ll = new TLatex(.5,.8, fname);
-  ll->SetTextAlign(22);
-  ll->SetTextSize(0.05);
-  ll->SetNDC();
-  ll->Draw();
-
-  TLatex* l = new TLatex(.5,.8, fname);
-  l->SetNDC();
-  l->SetTextSize(0.03);
-  l->SetTextFont(132);
-  l->SetTextAlign(12);
-  l->DrawLatex(0.2, 0.70, "1^{st} page is a summary of fit parameters");
-  l->DrawLatex(0.2, 0.67, "2^{nd} page is a summary of relative errors");
-  l->DrawLatex(0.2, 0.64, "Subsequent pages shows the fitted functions");
-  l->DrawLatex(0.3, 0.60, "Black line is the full fitted function");
-  l->DrawLatex(0.3, 0.57, "Coloured lines are the individual N-mip components");
-  l->DrawLatex(0.3, 0.54, "Full drawn lines correspond to used components");
-  l->DrawLatex(0.3, 0.51, "Dashed lines correspond to ignored components");
-  l->DrawLatex(0.2, 0.47, "Each component has the form");
-  l->DrawLatex(0.3, 0.42, "f_{n}(x; #Delta, #xi, #sigma') = "
-              "#int_{-#infty}^{+#infty}d#Delta' "
-              "landau(x; #Delta, #xi)gaus(x; #Delta', #sigma')");
-  l->DrawLatex(0.2, 0.37, "The full function is given by");
-  l->DrawLatex(0.3, 0.32, "f_{N}(x; #Delta, #xi, #sigma', #bf{a}) = "
-              "#sum_{i=1}^{N} a_{i} "
-              "f_{i}(x; #Delta_{i}, #xi_{i}, #sigma_{i}')");
-  l->DrawLatex(0.3, 0.26, "#Delta_{i} = i (#Delta_{1} + #xi_{1} log(i))");
-  l->DrawLatex(0.3, 0.23, "#xi_{i} = i #xi_{1}");
-  l->DrawLatex(0.3, 0.20, "#sigma_{i} = #sqrt{i} #sigma_{1}");
-  l->DrawLatex(0.3, 0.17, "#sigma_{n} #dot{=} 0");
-  l->DrawLatex(0.3, 0.14, "#sigma'^{2} = #sigma^{2}_{n} + #sigma^{2}");
-  l->DrawLatex(0.3, 0.11, "a_{1} = 1");
-  c->Print(pname.Data(), "Title:Title page");
-
-  ClearCanvas(c);
+  if (!summary) {
+    // Create a title page 
+    TLatex* ll = new TLatex(.5,.8, fname);
+    ll->SetTextAlign(22);
+    ll->SetTextSize(0.05);
+    ll->SetNDC();
+    ll->Draw();
+    
+    TLatex* l = new TLatex(.5,.8, fname);
+    l->SetNDC();
+    l->SetTextSize(0.03);
+    l->SetTextFont(132);
+    l->SetTextAlign(12);
+    l->DrawLatex(0.2, 0.70, "1^{st} page is a summary of fit parameters");
+    l->DrawLatex(0.2, 0.67, "2^{nd} page is a summary of relative errors");
+    l->DrawLatex(0.2, 0.64, "Subsequent pages shows the fitted functions");
+    l->DrawLatex(0.3, 0.60, "Black line is the full fitted function");
+    l->DrawLatex(0.3, 0.57, "Coloured lines are the individual N-mip comp.");
+    l->DrawLatex(0.3, 0.54, "Full drawn lines correspond to used components");
+    l->DrawLatex(0.3, 0.51, "Dashed lines correspond to ignored components");
+    l->DrawLatex(0.2, 0.47, "Each component has the form");
+    l->DrawLatex(0.3, 0.42, "f_{n}(x; #Delta, #xi, #sigma') = "
+                "#int_{-#infty}^{+#infty}d#Delta' "
+                "landau(x; #Delta, #xi)gaus(x; #Delta', #sigma')");
+    l->DrawLatex(0.2, 0.37, "The full function is given by");
+    l->DrawLatex(0.3, 0.32, "f_{N}(x; #Delta, #xi, #sigma', #bf{a}) = "
+                "#sum_{i=1}^{N} a_{i} "
+                "f_{i}(x; #Delta_{i}, #xi_{i}, #sigma_{i}')");
+    l->DrawLatex(0.3, 0.26, "#Delta_{i} = i (#Delta_{1} + #xi_{1} log(i))");
+    l->DrawLatex(0.3, 0.23, "#xi_{i} = i #xi_{1}");
+    l->DrawLatex(0.3, 0.20, "#sigma_{i} = #sqrt{i} #sigma_{1}");
+    l->DrawLatex(0.3, 0.17, "#sigma_{n} #dot{=} 0");
+    l->DrawLatex(0.3, 0.14, "#sigma'^{2} = #sigma^{2}_{n} + #sigma^{2}");
+    l->DrawLatex(0.3, 0.11, "a_{1} = 1");
+    c->Print(pname.Data(), "Title:Title page");
+    
+    ClearCanvas(c);
+  }
 
   //__________________________________________________________________
   // Draw overview page 
-  fits->Draw(option);
+  fits->Draw(opts.Data());
   c->Print(pname.Data(), "Title:Fit overview");
 
+  if (summary) {
+    c->Print(Form("%s]", pname.Data()));
+    TString pngName(pname.Data());             
+    pngName.ReplaceAll(".pdf", ".png");
+    c->Print(pngName.Data());
+    return;
+  }
   ClearCanvas(c);
-
+  
   //__________________________________________________________________
   // Draw relative parameter errors 
-  fits->Draw("rel");
+  fits->Draw("relative");
   c->Print(pname.Data(), "Title:Relative parameter errors");
 
   //__________________________________________________________________