Code to draw calibrations
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 27 Jun 2011 14:14:32 +0000 (14:14 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 27 Jun 2011 14:14:32 +0000 (14:14 +0000)
FMD/AliFMDCalibDrawer.cxx [new file with mode: 0644]
FMD/AliFMDCalibDrawer.h [new file with mode: 0644]
FMD/scripts/DoDrawCalib.C [new file with mode: 0644]
FMD/scripts/DrawCalib.C [new file with mode: 0644]

diff --git a/FMD/AliFMDCalibDrawer.cxx b/FMD/AliFMDCalibDrawer.cxx
new file mode 100644 (file)
index 0000000..74889bb
--- /dev/null
@@ -0,0 +1,337 @@
+#include <AliFMDCalibDrawer.h>
+#include <TH1.h>
+#include <TH2.h>
+#include <TPad.h>
+#include <TCanvas.h>
+#include <AliFMDParameters.h>
+#include <AliCDBManager.h>
+#include <AliLog.h>
+// #include <AliFMDCalibPedestal.h>
+// #include <AliFMDCalibSampleRate.h>
+// #include <AliFMDCalibStripRange.h>
+
+//____________________________________________________________________
+void
+AliFMDCalibDrawer::Init(Int_t runNo, const char* ocdb)
+{
+  AliCDBManager* cdb = AliCDBManager::Instance();
+  cdb->SetRun(runNo);
+  if (ocdb && ocdb[0] != '\0') cdb->SetDefaultStorage(ocdb);
+
+  AliFMDParameters* pars = AliFMDParameters::Instance();
+  pars->Init(kTRUE);
+}
+
+//____________________________________________________________________
+Double_t
+AliFMDCalibDrawer::GetHistMax(EWhat what) const
+{
+  switch (what) {
+  case kPedestal:  return 150;
+  case kNoise:     return 5;
+  case kGain:      return 4;
+  case kDead:      return 1.5;
+  case kRate:      return 5;
+  case kRange:     return 128;
+  case kZeroSuppression:  return 10;
+  }
+  return 1024;
+}
+//____________________________________________________________________
+Double_t
+AliFMDCalibDrawer::GetHistMin(EWhat what) const
+{
+  switch (what) {
+  case kPedestal:  return 0;
+  case kNoise:     return 0;
+  case kGain:      return 0;
+  case kDead:      return -.5;
+  case kRate:      return 0;
+  case kRange:     return -1;
+  case kZeroSuppression:  return -1;
+  }
+  return -1;
+}
+  
+//____________________________________________________________________
+const char*
+AliFMDCalibDrawer::GetHistName(EWhat what) const
+{
+  switch (what) {
+  case kPedestal:  return "peds"; 
+  case kNoise:     return "noise";
+  case kGain:      return "gain";
+  case kDead:      return "dead";
+  case kRate:      return "rate";
+  case kRange:     return "range";
+  case kZeroSuppression:  return "thrs";
+  }
+  return "unknown";
+}
+//____________________________________________________________________
+const char*
+AliFMDCalibDrawer::GetHistTitle(EWhat what) const
+{
+  switch (what) {
+  case kPedestal:  return "Pedestal & noise"; 
+  case kNoise:     return "Noise";
+  case kGain:      return "Gain";
+  case kDead:      return "Dead map";
+  case kRate:      return "Sample rate";
+  case kRange:     return "Strip range";
+  case kZeroSuppression:  return "ZS threshold";
+  }
+  return "Unknown";
+}
+  
+//____________________________________________________________________
+Int_t
+AliFMDCalibDrawer::GetRingColor(UShort_t d, Char_t r) const
+{
+  return ((d == 1 ? kRed : (d == 2 ? kGreen : kBlue))
+         + ((r == 'I' || r == 'i') ? 2 : -3));
+}
+//____________________________________________________________________
+void
+AliFMDCalibDrawer::SetAttributes(TH1* ret, EWhat what, 
+                                UShort_t d, Char_t r) const
+{
+  ret->SetFillColor(GetRingColor(d,r));
+  ret->SetMarkerColor(GetRingColor(d,r));
+  ret->SetLineColor(GetRingColor(d,r));
+  ret->SetFillStyle(3001);
+  ret->SetMarkerStyle(20);
+  ret->SetLineStyle(1);
+  ret->SetStats(0);
+  ret->SetDirectory(0);
+  ret->SetMinimum(GetHistMin(what));
+  ret->SetMaximum(GetHistMax(what));
+}
+//____________________________________________________________________
+TH2D*
+AliFMDCalibDrawer::Make2D(EWhat what, UShort_t d, Char_t r) const
+{
+  UShort_t q  = (r == 'I' || r == 'i') ? 0 : 1;
+  UShort_t nY = q == 0 ?  20 :  40;
+  UShort_t nX = q == 0 ? 512 : 256;
+  TString  n(Form("%s_FMD%d%c", GetHistName(what), d, r));
+  TString  t(Form("%s for FMD%d%c", GetHistTitle(what),  d, r));
+  TH2D*    ret = new TH2D(n, t, nX, 0, nX, nY, 0, nY);
+  ret->SetXTitle("Strip #");
+  ret->SetYTitle("Sector #");
+  ret->SetZTitle(GetHistTitle(what));
+  ret->GetXaxis()->SetNdivisions(1600 + (q == 0 ? 4 : 2),false);
+  ret->GetYaxis()->SetNdivisions(nY, false);
+  SetAttributes(ret, what, d, r);
+  return ret;
+
+}
+
+//____________________________________________________________________
+TH1D*
+AliFMDCalibDrawer::Make1D(EWhat what, UShort_t d, Char_t r, UShort_t s) const  
+{
+  UShort_t q    = (r == 'I' || r == 'i') ? 0 : 1;
+  UShort_t nStr = (r == 'I' || r == 'i') ? 512 : 256;
+  TString  n(Form("%s_FMD%d%c_%02d", GetHistName(what), d, r, s));
+  TString  t(Form("%s for FMD%d%c[%2d]", GetHistTitle(what), d, r, s));
+  TH1D* ret = new TH1D(n, t, nStr, 0, nStr);
+  ret->SetXTitle("Strip #");
+  ret->SetYTitle(GetHistTitle(what));
+  ret->GetXaxis()->SetNdivisions(1600 + (q == 0 ? 4 : 2),false);
+  SetAttributes(ret, what, d, r);
+  return ret;
+}
+
+//____________________________________________________________________
+void
+AliFMDCalibDrawer::GetNumber(EWhat what, UShort_t d, Char_t r, UShort_t s, 
+                            UShort_t t, Double_t& val, Double_t& err) const
+{
+  AliFMDParameters* pars = AliFMDParameters::Instance();
+  err = 0;
+  switch (what) {
+  case kPedestal:
+    val = pars->GetPedestal(d, r, s, t);
+    err = pars->GetPedestalWidth(d, r, s, t);
+    break;
+  case kNoise: val = pars->GetPedestalWidth(d, r, s, t); break;
+  case kGain:  val = pars->GetPulseGain(d, r, s, t); break;
+  case kDead:  val = pars->IsDead(d, r, s, t) ? 0 : 1; break;
+  case kRate:  val = pars->GetSampleRate(d, r, s, t); break;
+  case kRange:
+    val = pars->GetMaxStrip(d,r,s,t);
+    err = pars->GetMinStrip(d,r,s,t);
+    break;
+  case kZeroSuppression:  val = pars->GetZeroSuppression(d,r,s,t); break;
+  default: 
+    AliError(Form("Unknown quantity: %d - nothing returned", what));
+    break;
+  }
+}
+
+//____________________________________________________________________
+TH1*
+AliFMDCalibDrawer::FillRing(EWhat what, UShort_t d, Char_t r) const
+{
+  if (what == kRate || what == kRange) { 
+    TH1D* ret = new TH1D(Form("%s_FMD%d%c", GetHistName(what), d, r), 
+                        Form("%s for FMD%d%c", GetHistTitle(what), d, r), 
+                        2, -.5, 1.5);
+    UShort_t nSec = (r == 'I' || r == 'i') ? 20 : 40;
+    ret->GetXaxis()->SetBinLabel(1, Form("Top [%02d-%02d]", 0,      nSec/2-1));
+    ret->GetXaxis()->SetBinLabel(2, Form("Bottom [%02d-%02d]",nSec/2-1,nSec-1));
+    ret->SetYTitle(GetHistTitle(what));
+    SetAttributes(ret, what, d, r);
+    if (what == kRate) { 
+      ret->SetBarWidth(0.8);
+      ret->SetBarOffset(0.1);
+    }
+    else 
+      ret->SetMarkerSize(0);
+    for (UShort_t s = 0; s < ret->GetNbinsX(); s++) { 
+      Double_t val; 
+      Double_t err; 
+      GetNumber(what, d, r, s*(nSec/2), 0, val, err);
+      if (what == kRange) { 
+       Double_t min = err;
+       err          = (val - err) / 2;
+       val          = min + err;
+      }
+      ret->SetBinContent(s+1, val);
+      ret->SetBinError(s+1, err);
+    }
+    return ret;
+  }
+  if (what == kZeroSuppression) { 
+    UShort_t nY  = (r == 'I' || r == 'i') ?  20 :  40;
+    UShort_t nX  = ((r == 'I' || r == 'i') ? 512 : 256) / 128;
+    TH2D*    ret = new TH2D(Form("%s_FMD%d%c", GetHistName(what), d, r), 
+                           Form("%s for FMD%d%c", GetHistTitle(what), d, r),
+                           nX, 0, nX, nY, 0, nY);
+    ret->SetXTitle("Channel #");
+    ret->SetYTitle("Sector #");
+    ret->SetZTitle(GetHistTitle(what));
+    ret->GetXaxis()->SetNdivisions(nX, false);
+    ret->GetYaxis()->SetNdivisions(nY, false);
+    SetAttributes(ret, what, d, r);
+    for (UShort_t s = 0; s < ret->GetNbinsY(); s++) { 
+      for (UShort_t t = 0; t < ret->GetNbinsX(); t++) { 
+       Double_t val; 
+       Double_t err; 
+       GetNumber(what, d, r, s, t*128, val, err);
+       ret->SetBinContent(t+1, s+1, val);
+       ret->SetBinError(t+1, s+1, err);
+      }
+    }
+    return ret;
+  }
+    
+  TH2D* ret = Make2D(what, d, r);
+  for (UShort_t s = 0; s < ret->GetNbinsY(); s++) { 
+    for (UShort_t t = 0; t < ret->GetNbinsX(); t++) { 
+      Double_t val; 
+      Double_t err; 
+      GetNumber(what, d, r, s, t, val, err);
+      ret->SetBinContent(t+1, s+1, val);
+      ret->SetBinError(t+1, s+1, err);
+    }
+  }
+  return ret;
+}
+//____________________________________________________________________
+TH1*
+AliFMDCalibDrawer::FillSector(EWhat what,UShort_t d, Char_t r, UShort_t s) const
+{
+  if (what == kZeroSuppression) { 
+    UShort_t nX  = ((r == 'I' || r == 'i') ? 512 : 256) / 128;
+    TH1D*    ret = new TH1D(Form("%s_FMD%d%c[%02d]", 
+                                GetHistName(what), d, r, s), 
+                           Form("%s for FMD%d%c[%02d]", 
+                                GetHistTitle(what), d, r, s),
+                           nX, 0, nX);
+    ret->SetXTitle("Channel #");
+    ret->SetYTitle(GetHistTitle(what));
+    SetAttributes(ret, what, d, r);
+    ret->GetXaxis()->SetNdivisions(nX, false);
+    for (UShort_t t = 0; t < ret->GetNbinsX(); t++) { 
+      Double_t val; 
+      Double_t err; 
+      GetNumber(what, d, r, s, t*128, val, err);
+      ret->SetBinContent(t+1, s+1, val);
+      if (err >= 0) ret->SetBinError(t+1, s+1, err);
+    }
+    return ret;
+  }
+
+  TH1D* ret = Make1D(what, d, r, s);
+  for (UShort_t t = 0; t < ret->GetNbinsX(); t++) { 
+    Double_t val; 
+    Double_t err; 
+    GetNumber(what, d, r, s, t, val, err);
+    ret->SetBinContent(t+1, s+1, val);
+    if (err >= 0) ret->SetBinError(t+1, s+1, err);
+  }
+  return ret;
+}
+
+//____________________________________________________________________
+void
+AliFMDCalibDrawer::DrawOne(EWhat what, Short_t d, Char_t r, 
+                          Short_t s, Short_t /*t*/) const
+{
+  Info("DrawOne", "Will draw %s for D=%d, R=%c, S=%d",
+       GetHistTitle(what), d, (r == '\0' ? '-' : r), s);
+  TVirtualPad* tp = gPad;
+  if (!tp) tp = TCanvas::MakeDefCanvas();
+  if (d <= 0 || d > 3) { 
+    // All detectors - need to split current pad
+    tp->Divide(1,3,0,0);
+    for (UShort_t dd = 1; dd <= 3; dd++) { 
+      tp->cd(dd);
+      // Call our selves 
+      DrawOne(what, dd, '\0', -1, -1);
+    }
+  }
+  else if ((r != 'I' && r != 'i') && (r != 'O' && r != 'o')) { 
+    // All rings in a detector.  Split current pad in two 
+    tp->SetName(Form("FMD%d", d));
+    tp->Divide(2,1,0,0);
+    for (UShort_t q = 0; q < 2; q++) { 
+      tp->cd(q+1);
+      Char_t       rr = q == 0 ? 'I' : 'O';
+      // Call ourselves 
+      DrawOne(what, d, rr, -1, -1);
+    }
+  }
+  else if (what == kRate || what == kRange || s < 0 || s > 39) {
+    // A single ring - and special case for sample rate and strip range
+    tp->SetName(Form("FMD%d%c", d, r));
+    tp->SetFillColor(0);
+    tp->SetFillStyle(0);
+    tp->SetRightMargin(0.10);
+    if (d == 1 && (r == 'O' || r == 'o')) return;
+    TH1* h = FillRing(what, d, r);
+    switch (what) { 
+    case kRate:  h->Draw("bar"); break;
+    case kRange: h->Draw("e3"); break;
+    default: h->Draw("colz"); break;
+    }
+  }
+  else {
+    // Finally, we're down to a single sector.  In this case, we just do
+    // a single 1D histogram 
+    TH1* h = FillSector(what, d, r, s);
+    h->Draw("hist e");
+  }
+  tp->Update();
+  tp->Modified();
+  tp->cd();
+}
+
+
+
+//____________________________________________________________________
+//
+// EOF
+// 
diff --git a/FMD/AliFMDCalibDrawer.h b/FMD/AliFMDCalibDrawer.h
new file mode 100644 (file)
index 0000000..2af72ec
--- /dev/null
@@ -0,0 +1,191 @@
+#ifndef ALIFMDCALIBDRAWER_H
+#define ALIFMDCALIBDRAWER_H
+#include <TObject.h>
+class TH2D;
+class TH1D;
+class TH1;
+
+class AliFMDCalibDrawer : public TObject 
+{
+public:
+  /**
+   * Things we can draw 
+   */
+  enum EWhat { 
+    kPedestal, 
+    kNoise, 
+    kGain, 
+    kDead,
+    kRate, 
+    kRange, 
+    kZeroSuppression 
+  };
+
+  AliFMDCalibDrawer() {}
+  /** 
+   * Initialize the drawer
+   * 
+   * @param runNo  Run number
+   * @param ocdb   Source of parameters (if 0, do not set)
+   */
+  void Init(Int_t runNo, const char* ocdb=0);
+  /** 
+   * Draw pedestals for the selected region.
+   * 
+]   * @param d Detector number (if 0 or negative, draw all)
+   * @param r Ring id (if null, draw all rings)
+   * @param s Sector number (if negative, draw all sectors) 
+   * @param t Strip number (if negative, draw all strips)
+   */
+  void DrawPedestals(Short_t d=-1, Char_t r='\0', 
+                    Short_t s=-1, Short_t t=-1) const 
+  { 
+    DrawOne(kPedestal, d, r, s, t);
+  }
+  /** 
+   * Draw noise for the selected region.
+   * 
+   * @param d Detector number (if 0 or negative, draw all)
+   * @param r Ring id (if null, draw all rings)
+   * @param s Sector number (if negative, draw all sectors) 
+   * @param t Strip number (if negative, draw all strips)
+   */
+  void DrawNoise(Short_t d=-1, Char_t r='\0', 
+                Short_t s=-1, Short_t t=-1) const 
+  {
+    DrawOne(kNoise, d, r, s, t);
+  }
+  /** 
+   * Draw gains for the selected region.
+   * 
+   * @param d Detector number (if 0 or negative, draw all)
+   * @param r Ring id (if null, draw all rings)
+   * @param s Sector number (if negative, draw all sectors) 
+   * @param t Strip number (if negative, draw all strips)
+   */
+  void DrawGains(Short_t d=-1, Char_t r='\0', 
+                    Short_t s=-1, Short_t t=-1) const
+  {
+    DrawOne(kGain, d, r, s, t);
+  }
+  /** 
+   * Draw dead for the selected region.
+   * 
+   * @param d Detector number (if 0 or negative, draw all)
+   * @param r Ring id (if null, draw all rings)
+   * @param s Sector number (if negative, draw all sectors) 
+   * @param t Strip number (if negative, draw all strips)
+   */
+  void DrawDead(Short_t d=-1, Char_t r='\0', Short_t s=-1, Short_t t=-1) const
+  {
+    DrawOne(kDead, d, r, s, t);
+  }
+  
+  void DrawRates(Short_t d=-1, Char_t r='\0', Short_t s=-1, Short_t t=-1) const
+  {
+    DrawOne(kRate, d, r, s, t);
+  }
+  void DrawRanges(Short_t d=-1, Char_t r='\0', Short_t s=-1, Short_t t=-1) const
+  {
+    DrawOne(kRange, d, r, s, t);
+  }
+  void DrawThresholds(Short_t d=-1, Char_t r='\0', Short_t s=-1, 
+                    Short_t t=-1) const
+  {
+    DrawOne(kZeroSuppression, d, r, s, t);
+  }
+  /** 
+   * Draw one thing
+   * 
+   * @param what  What to draw 
+   * @param d Detector number (if 0 or negative, draw all)
+   * @param r Ring id (if null, draw all rings)
+   * @param s Sector number (if negative, draw all sectors) 
+   * @param t Strip number (if negative, draw all strips)
+   */
+  void  DrawOne(EWhat what, Short_t d=-1, Char_t r='\0', 
+               Short_t s=-1, Short_t t=-1) const;
+protected:
+  void SetAttributes(TH1* ret, EWhat what, UShort_t d, Char_t r) const;
+  Double_t GetHistMax(EWhat what) const;
+  Double_t GetHistMin(EWhat what) const;
+  /** 
+   * Get the base histogram name
+   * 
+   * @param what What is drawn
+   * 
+   * @return Histogram base name
+   */
+  const char* GetHistName(EWhat what) const;
+  /** 
+   * Get the base histogram title
+   * 
+   * @param what What is drawn
+   * 
+   * @return Histogram base title
+   */
+  const char* GetHistTitle(EWhat what) const;
+  /** 
+   * Get the numbers 
+   * 
+   * @param what What to get
+   * @param d    Detector number
+   * @param r    Ring id
+   * @param s    Sector number
+   * @param t    Strip number
+   * @param val  On return, the value 
+   * @param err  On return, the error on value (or negative if no error)
+   */
+  void GetNumber(EWhat what, UShort_t d, Char_t r, UShort_t s, UShort_t t, 
+                Double_t& val, Double_t& err) const;
+  /** 
+   * Make a 1D histogram
+   *  
+   * @param what What to make the histogram for 
+   * @param d    Detector 
+   * @param r    Ring 
+   * @param s    Sector
+   * 
+   * @return Newly allocated histogram
+   */
+  TH1D* Make1D(EWhat what, UShort_t d, Char_t r, UShort_t s) const;
+  /** 
+   * Make a 2D histogram
+   *  
+   * @param what What to make the histogram for 
+   * @param d    Detector 
+   * @param r    Ring 
+   * 
+   * @return Newly allocated histogram
+   */
+  TH2D* Make2D(EWhat what, UShort_t d, Char_t r) const;
+  /** 
+   * Fill a per-ring 2D histogram 
+   * 
+   * @param what What to fill in
+   * @param d    Detector 
+   * @param r    Ring 
+   * 
+   * @return Filled histogram 
+   */
+  TH1* FillRing(EWhat what, UShort_t d, Char_t r) const;
+  /** 
+   * Fill a per-sector 1D histogram 
+   * 
+   * @param what What to fill in
+   * @param d    Detector
+   * @param r    Ring 
+   * @param s    Sector 
+   * 
+   * @return Filled histogram 
+   */
+  TH1* FillSector(EWhat what, UShort_t d, Char_t r, UShort_t s) const;
+
+  Int_t GetRingColor(UShort_t d, Char_t r) const;
+  ClassDef(AliFMDCalibDrawer,0); // Draw calibrations 
+};
+#endif
+// Local Variables: 
+//  mode: C++
+// End:
+
diff --git a/FMD/scripts/DoDrawCalib.C b/FMD/scripts/DoDrawCalib.C
new file mode 100644 (file)
index 0000000..b647b24
--- /dev/null
@@ -0,0 +1,6 @@
+{
+  gSystem->Load("libGui");
+  gROOT->LoadMacro("$ALICE_ROOT.trunk/FMD/scripts/Compile.C");
+  Compile("$ALICE_ROOT.trunk/FMD/scripts/DrawCalib.C","g");
+  DrawCalib();
+}
diff --git a/FMD/scripts/DrawCalib.C b/FMD/scripts/DrawCalib.C
new file mode 100644 (file)
index 0000000..488c4a1
--- /dev/null
@@ -0,0 +1,245 @@
+#ifndef __CINT__
+#include <AliCDBManager.h>
+#include <AliFMDCalibDrawer.h>
+#include <TSystem.h>
+#include <TGFrame.h>
+#include <TGButton.h>
+#include <TGLayout.h>
+#include <TGButtonGroup.h>
+#include <TGNumberEntry.h>
+#include <TGTextEntry.h>
+#include <TCanvas.h>
+#include <TError.h>
+#include <TGLabel.h>
+#else
+class TGMainFrame;
+class TGNumberEntry;
+class TGTextEntry;
+class TGHButtonGroup;
+class TGCheckButton;
+class TGTextButton;
+class TGLayoutHints;
+class TCanvas;
+class TGLabel;
+class TGHorizontalFrame;
+class AliFMDCalibDrawer;
+class TGGroupFrame;
+#endif
+
+
+class Menu 
+{
+public:
+  TGMainFrame       fMain;
+  TGGroupFrame      fSetup;
+  TGLabel           fLRun;
+  TGNumberEntry     fRun;  
+  TGLabel           fLOCDB;
+  TGTextEntry       fOCDB; 
+  TGTextButton      fInit;
+  TGHorizontalFrame fFDet;
+  TGLabel           fLDet;
+  TGNumberEntry     fDet;
+  TGHorizontalFrame fFRing;
+  TGLabel           fLRing;
+  TGTextEntry       fRing;
+  TGHorizontalFrame fFSec;
+  TGLabel           fLSec;
+  TGNumberEntry     fSec;
+  TGHorizontalFrame fFStr;
+  TGLabel           fLStr;
+  TGNumberEntry     fStr;
+  TGHButtonGroup    fSelection;
+  TGCheckButton     fPedestal;
+  TGCheckButton     fNoise;
+  TGCheckButton     fGain;
+  TGCheckButton     fDead;
+  TGCheckButton     fRate;
+  TGCheckButton     fRange;
+  TGCheckButton     fThreshold;
+  TGTextButton      fDraw;
+  TGLayoutHints     fLayout;
+
+  AliFMDCalibDrawer fCD;
+  TCanvas*          fCPedestal;
+  TCanvas*          fCNoise;
+  TCanvas*          fCGain;
+  TCanvas*          fCDead;
+  TCanvas*          fCRate;
+  TCanvas*          fCRange;
+  TCanvas*          fCThreshold;
+
+  Menu(Int_t runNo)
+    : fMain(gClient->GetRoot()), 
+      fSetup(&fMain, "Setup", kHorizontalFrame), 
+      fLRun(&fSetup, "Run: "),
+      fRun(&fSetup, runNo, 8, -1, TGNumberFormat::kNESInteger,
+          TGNumberFormat::kNEAAnyNumber), 
+      fLOCDB(&fSetup, "OCDB:"),
+      fOCDB(&fSetup, ""),       
+      fInit(&fSetup, "Init"),
+      fFDet(&fMain), 
+      fLDet(&fFDet, "Detector:"),
+      fDet(&fFDet, -1, 1, -1, TGNumberFormat::kNESInteger,
+          TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax,
+          -1, 3), 
+      fFRing(&fMain),
+      fLRing(&fFRing,"Ring:"),
+      fRing(&fFRing, ""), 
+      fFSec(&fMain),
+      fLSec(&fFSec,"Sector:"),
+      fSec(&fFSec, -1, 1, -1, TGNumberFormat::kNESInteger,
+          TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax,
+          -1, 39), 
+      fFStr(&fMain),
+      fLStr(&fFStr,"Strip:"),
+      fStr(&fFStr, -1, 1, -1, TGNumberFormat::kNESInteger,
+          TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax,
+          -1, 511), 
+      fSelection(&fMain, "what"),
+      fPedestal(&fSelection, "Pedestal"), 
+      fNoise(&fSelection, "Noise"), 
+      fGain(&fSelection, "Gain"), 
+      fDead(&fSelection, "Dead"), 
+      fRate(&fSelection, "Rate"), 
+      fRange(&fSelection, "Range"), 
+      fThreshold(&fSelection, "Threshold"),
+      fDraw(&fMain, "Draw"),
+      fLayout(kLHintsExpandX, 2, 2, 2, 2)
+  {
+    fSetup.AddFrame(&fLRun,  &fLayout);
+    fSetup.AddFrame(&fRun,   &fLayout);
+    fSetup.AddFrame(&fLOCDB, &fLayout);
+    fSetup.AddFrame(&fOCDB,  &fLayout);
+    fSetup.AddFrame(&fInit,  &fLayout);
+
+    fFDet.AddFrame(&fLDet,  &fLayout);
+    fFDet.AddFrame(&fDet,   &fLayout);
+    fFRing.AddFrame(&fLRing,&fLayout);
+    fFRing.AddFrame(&fRing, &fLayout);
+    fFSec.AddFrame(&fLSec,  &fLayout);
+    fFSec.AddFrame(&fSec,   &fLayout);
+    fFStr.AddFrame(&fLStr,  &fLayout);
+    fFStr.AddFrame(&fStr,   &fLayout);
+
+    fMain.AddFrame(&fSetup,      &fLayout);
+    fMain.AddFrame(&fFDet,       &fLayout);
+    fMain.AddFrame(&fFRing,      &fLayout);
+    fMain.AddFrame(&fFSec,       &fLayout);
+    fMain.AddFrame(&fFStr,       &fLayout);
+    fMain.AddFrame(&fSelection,  &fLayout);
+    fMain.AddFrame(&fDraw,       &fLayout);
+
+    fRing.SetAlignment(kTextRight);
+    fRing.SetInsertMode(TGTextEntry::kReplace);
+    fRing.SetMaxLength(1);
+
+    fMain.MapSubwindows();
+    fMain.Resize(fMain.GetDefaultSize());
+    fMain.MapWindow();
+    
+    fDraw.Connect("Clicked()", "Menu", this, "Handle()");
+    fInit.Connect("Clicked()", "Menu", this, "Init()");
+
+    fCD.Init(runNo);
+  }
+  TCanvas* MakeCanvas(const char* name, const char* title)
+  {
+    TCanvas* ret = new TCanvas(name, title, 1200, 900);
+    ret->SetFillColor(0);
+    ret->SetFillStyle(0);
+    ret->SetBorderMode(0);
+    ret->SetBorderSize(0);
+    return ret;
+  }
+  void ClearCanvas(TCanvas* c)
+  {
+    c->Clear();
+    c->SetTopMargin(0.02);
+    c->SetRightMargin(0.02);
+    c->SetBottomMargin(0.10);
+    c->SetLeftMargin(0.10);
+    c->cd();
+  }
+  void Init()
+  {
+    const Char_t* ocdb = fOCDB.GetText();
+    Int_t         run  = fRun.GetIntNumber();
+    Info("Init", "Initialising for run %d, OCDB @ %s", run, ocdb);
+    fCD.Init(run, ocdb);
+  }
+  void Handle()
+  {
+    static Short_t oD;
+    static Char_t  oR;
+    static Short_t oS;
+    static Short_t oT;
+    Short_t d = fDet.GetIntNumber();
+    Char_t  r = fRing.GetText()[0];
+    Short_t s = fSec.GetIntNumber();
+    Short_t t = fStr.GetIntNumber();
+    Info("Handle", "D=%d, R=%c, S=%d, T=%d", d, (r == '\0' ? '-' : r), s, t);
+    if (fPedestal.IsOn()) { 
+      Info("Handle", "Will draw pedestals");
+      if (!fCPedestal) fCPedestal = MakeCanvas("peds", "Pedestals");
+      ClearCanvas(fCPedestal);
+      fCD.DrawPedestals(d, r, s, t);
+    }
+    if (fNoise.IsOn()) { 
+      Info("Handle", "Will draw noises");
+      if (!fCNoise) fCNoise = MakeCanvas("noises", "Noises");
+      ClearCanvas(fCNoise);
+      fCD.DrawNoise(d, r, s, t);
+    }
+    if (fGain.IsOn()) { 
+      Info("Handle", "Will draw gains");
+      if (!fCGain) fCGain = MakeCanvas("gains", "Gains");
+      ClearCanvas(fCGain);
+      fCD.DrawGains(d, r, s, t);
+    }
+    if (fDead.IsOn()) { 
+      Info("Handle", "Will draw deads");
+      if (!fCDead) fCDead = MakeCanvas("deads", "Deads");
+      ClearCanvas(fCDead);
+      fCD.DrawDead(d, r, s, t);
+    }
+    if (fRate.IsOn()) { 
+      Info("Handle", "Will draw rates");
+      if (!fCRate) fCRate = MakeCanvas("rates", "Rates");
+      fCRate->Clear();
+      fCRate->cd();
+      fCD.DrawRates(d, r, s, t);
+    }
+    if (fRange.IsOn()) { 
+      Info("Handle", "Will draw ranges");
+      if (!fCRange) fCRange = MakeCanvas("ranges", "Ranges");
+      fCRange->Clear();
+      fCRange->cd();
+      fCD.DrawRanges(d, r, s, t);
+    }
+    if (fThreshold.IsOn()) { 
+      Info("Handle", "Will draw thresholds");
+      if (!fCThreshold) fCThreshold = MakeCanvas("thresholds", "Thresholds");
+      fCThreshold->Clear();
+      fCThreshold->cd();
+      fCD.DrawThresholds(d, r, s, t);
+    }
+  }
+};
+
+      
+void
+DrawCalib()
+{
+#ifdef __CINT__
+  gSystem->Load("libFMDutil");
+#endif
+
+  AliCDBManager* cdb = AliCDBManager::Instance();
+  cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+  cdb->SetSpecificStorage("FMD/Calib/Pedestal", "local:///mnt/hitachi/ocdb/2011");
+  cdb->SetSpecificStorage("FMD/Calib/PulseGain", "local:///mnt/hitachi/ocdb/2011");
+
+  Menu* m = new Menu(145167);
+  // cd->DrawPedestals(d,r,s,t);
+}