[u/mrichter/AliRoot.git] / FMD / AliFMDCalibDrawer.cxx

#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);
  TString db(ocdb);
  if (db.EqualTo("run", TString::kIgnoreCase) || db.IsNull())
    cdb->SetDefaultStorageFromRun(runNo);
  else 
    cdb->SetDefaultStorage(db);

  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
//
Commit	Line	Data
ee13fa25	1	#include <AliFMDCalibDrawer.h>
	2	#include <TH1.h>
	3	#include <TH2.h>
	4	#include <TPad.h>
	5	#include <TCanvas.h>
	6	#include <AliFMDParameters.h>
	7	#include <AliCDBManager.h>
	8	#include <AliLog.h>
	9	// #include <AliFMDCalibPedestal.h>
	10	// #include <AliFMDCalibSampleRate.h>
	11	// #include <AliFMDCalibStripRange.h>
	12
	13	//____________________________________________________________________
	14	void
	15	AliFMDCalibDrawer::Init(Int_t runNo, const char* ocdb)
	16	{
	17	AliCDBManager* cdb = AliCDBManager::Instance();
	18	cdb->SetRun(runNo);
ca20eb4a	19	TString db(ocdb);
	20	if (db.EqualTo("run", TString::kIgnoreCase) \|\| db.IsNull())
	21	cdb->SetDefaultStorageFromRun(runNo);
	22	else
	23	cdb->SetDefaultStorage(db);
ee13fa25	24
	25	AliFMDParameters* pars = AliFMDParameters::Instance();
	26	pars->Init(kTRUE);
	27	}
	28
	29	//____________________________________________________________________
	30	Double_t
	31	AliFMDCalibDrawer::GetHistMax(EWhat what) const
	32	{
	33	switch (what) {
	34	case kPedestal: return 150;
	35	case kNoise: return 5;
	36	case kGain: return 4;
	37	case kDead: return 1.5;
	38	case kRate: return 5;
	39	case kRange: return 128;
	40	case kZeroSuppression: return 10;
	41	}
	42	return 1024;
	43	}
	44	//____________________________________________________________________
	45	Double_t
	46	AliFMDCalibDrawer::GetHistMin(EWhat what) const
	47	{
	48	switch (what) {
	49	case kPedestal: return 0;
	50	case kNoise: return 0;
	51	case kGain: return 0;
	52	case kDead: return -.5;
	53	case kRate: return 0;
	54	case kRange: return -1;
	55	case kZeroSuppression: return -1;
	56	}
	57	return -1;
	58	}
	59
	60	//____________________________________________________________________
	61	const char*
	62	AliFMDCalibDrawer::GetHistName(EWhat what) const
	63	{
	64	switch (what) {
	65	case kPedestal: return "peds";
	66	case kNoise: return "noise";
	67	case kGain: return "gain";
	68	case kDead: return "dead";
	69	case kRate: return "rate";
	70	case kRange: return "range";
	71	case kZeroSuppression: return "thrs";
	72	}
	73	return "unknown";
	74	}
	75	//____________________________________________________________________
	76	const char*
	77	AliFMDCalibDrawer::GetHistTitle(EWhat what) const
	78	{
	79	switch (what) {
	80	case kPedestal: return "Pedestal & noise";
	81	case kNoise: return "Noise";
	82	case kGain: return "Gain";
	83	case kDead: return "Dead map";
	84	case kRate: return "Sample rate";
	85	case kRange: return "Strip range";
	86	case kZeroSuppression: return "ZS threshold";
	87	}
88	return "Unknown";
89	}
90
91	//____________________________________________________________________
92	Int_t
93	AliFMDCalibDrawer::GetRingColor(UShort_t d, Char_t r) const
94	{
95	return ((d == 1 ? kRed : (d == 2 ? kGreen : kBlue))
96	+ ((r == 'I' \|\| r == 'i') ? 2 : -3));
97	}
98	//____________________________________________________________________
99	void
100	AliFMDCalibDrawer::SetAttributes(TH1* ret, EWhat what,
101	UShort_t d, Char_t r) const
102	{
103	ret->SetFillColor(GetRingColor(d,r));
104	ret->SetMarkerColor(GetRingColor(d,r));
105	ret->SetLineColor(GetRingColor(d,r));
106	ret->SetFillStyle(3001);
107	ret->SetMarkerStyle(20);
108	ret->SetLineStyle(1);
109	ret->SetStats(0);
110	ret->SetDirectory(0);
111	ret->SetMinimum(GetHistMin(what));
112	ret->SetMaximum(GetHistMax(what));
113	}
114	//____________________________________________________________________
115	TH2D*
116	AliFMDCalibDrawer::Make2D(EWhat what, UShort_t d, Char_t r) const
117	{
118	UShort_t q = (r == 'I' \|\| r == 'i') ? 0 : 1;
119	UShort_t nY = q == 0 ? 20 : 40;
120	UShort_t nX = q == 0 ? 512 : 256;
121	TString n(Form("%s_FMD%d%c", GetHistName(what), d, r));
122	TString t(Form("%s for FMD%d%c", GetHistTitle(what), d, r));
123	TH2D* ret = new TH2D(n, t, nX, 0, nX, nY, 0, nY);
124	ret->SetXTitle("Strip #");
125	ret->SetYTitle("Sector #");
126	ret->SetZTitle(GetHistTitle(what));
127	ret->GetXaxis()->SetNdivisions(1600 + (q == 0 ? 4 : 2),false);
128	ret->GetYaxis()->SetNdivisions(nY, false);
129	SetAttributes(ret, what, d, r);
130	return ret;
131
132	}
133
134	//____________________________________________________________________
135	TH1D*
136	AliFMDCalibDrawer::Make1D(EWhat what, UShort_t d, Char_t r, UShort_t s) const
137	{
138	UShort_t q = (r == 'I' \|\| r == 'i') ? 0 : 1;
139	UShort_t nStr = (r == 'I' \|\| r == 'i') ? 512 : 256;
140	TString n(Form("%s_FMD%d%c_%02d", GetHistName(what), d, r, s));
141	TString t(Form("%s for FMD%d%c[%2d]", GetHistTitle(what), d, r, s));
142	TH1D* ret = new TH1D(n, t, nStr, 0, nStr);
143	ret->SetXTitle("Strip #");
144	ret->SetYTitle(GetHistTitle(what));
145	ret->GetXaxis()->SetNdivisions(1600 + (q == 0 ? 4 : 2),false);
146	SetAttributes(ret, what, d, r);
147	return ret;
148	}
149
150	//____________________________________________________________________
151	void
152	AliFMDCalibDrawer::GetNumber(EWhat what, UShort_t d, Char_t r, UShort_t s,
153	UShort_t t, Double_t& val, Double_t& err) const
154	{
155	AliFMDParameters* pars = AliFMDParameters::Instance();
156	err = 0;
157	switch (what) {
158	case kPedestal:
159	val = pars->GetPedestal(d, r, s, t);
160	err = pars->GetPedestalWidth(d, r, s, t);
161	break;
162	case kNoise: val = pars->GetPedestalWidth(d, r, s, t); break;
163	case kGain: val = pars->GetPulseGain(d, r, s, t); break;
164	case kDead: val = pars->IsDead(d, r, s, t) ? 0 : 1; break;
165	case kRate: val = pars->GetSampleRate(d, r, s, t); break;
166	case kRange:
167	val = pars->GetMaxStrip(d,r,s,t);
168	err = pars->GetMinStrip(d,r,s,t);
169	break;
170	case kZeroSuppression: val = pars->GetZeroSuppression(d,r,s,t); break;
171	default:
172	AliError(Form("Unknown quantity: %d - nothing returned", what));
173	break;
174	}
175	}
176
177	//____________________________________________________________________
178	TH1*
179	AliFMDCalibDrawer::FillRing(EWhat what, UShort_t d, Char_t r) const
180	{
181	if (what == kRate \|\| what == kRange) {
182	TH1D* ret = new TH1D(Form("%s_FMD%d%c", GetHistName(what), d, r),
183	Form("%s for FMD%d%c", GetHistTitle(what), d, r),
184	2, -.5, 1.5);
185	UShort_t nSec = (r == 'I' \|\| r == 'i') ? 20 : 40;
186	ret->GetXaxis()->SetBinLabel(1, Form("Top [%02d-%02d]", 0, nSec/2-1));
187	ret->GetXaxis()->SetBinLabel(2, Form("Bottom [%02d-%02d]",nSec/2-1,nSec-1));
188	ret->SetYTitle(GetHistTitle(what));
189	SetAttributes(ret, what, d, r);
190	if (what == kRate) {
191	ret->SetBarWidth(0.8);
192	ret->SetBarOffset(0.1);
193	}
194	else
195	ret->SetMarkerSize(0);
196	for (UShort_t s = 0; s < ret->GetNbinsX(); s++) {
197	Double_t val;
198	Double_t err;
199	GetNumber(what, d, r, s*(nSec/2), 0, val, err);
200	if (what == kRange) {
201	Double_t min = err;
202	err = (val - err) / 2;
203	val = min + err;
204	}
205	ret->SetBinContent(s+1, val);
206	ret->SetBinError(s+1, err);
207	}
208	return ret;
209	}
210	if (what == kZeroSuppression) {
211	UShort_t nY = (r == 'I' \|\| r == 'i') ? 20 : 40;
212	UShort_t nX = ((r == 'I' \|\| r == 'i') ? 512 : 256) / 128;
213	TH2D* ret = new TH2D(Form("%s_FMD%d%c", GetHistName(what), d, r),
214	Form("%s for FMD%d%c", GetHistTitle(what), d, r),
215	nX, 0, nX, nY, 0, nY);
216	ret->SetXTitle("Channel #");
217	ret->SetYTitle("Sector #");
218	ret->SetZTitle(GetHistTitle(what));
219	ret->GetXaxis()->SetNdivisions(nX, false);
220	ret->GetYaxis()->SetNdivisions(nY, false);
221	SetAttributes(ret, what, d, r);
222	for (UShort_t s = 0; s < ret->GetNbinsY(); s++) {
223	for (UShort_t t = 0; t < ret->GetNbinsX(); t++) {
224	Double_t val;
225	Double_t err;
226	GetNumber(what, d, r, s, t*128, val, err);
227	ret->SetBinContent(t+1, s+1, val);
228	ret->SetBinError(t+1, s+1, err);
229	}
230	}
231	return ret;
232	}
233
234	TH2D* ret = Make2D(what, d, r);
235	for (UShort_t s = 0; s < ret->GetNbinsY(); s++) {
236	for (UShort_t t = 0; t < ret->GetNbinsX(); t++) {
237	Double_t val;
238	Double_t err;
239	GetNumber(what, d, r, s, t, val, err);
240	ret->SetBinContent(t+1, s+1, val);
241	ret->SetBinError(t+1, s+1, err);
242	}
243	}
244	return ret;
245	}
246	//____________________________________________________________________
247	TH1*
248	AliFMDCalibDrawer::FillSector(EWhat what,UShort_t d, Char_t r, UShort_t s) const
249	{
250	if (what == kZeroSuppression) {
251	UShort_t nX = ((r == 'I' \|\| r == 'i') ? 512 : 256) / 128;
252	TH1D* ret = new TH1D(Form("%s_FMD%d%c[%02d]",
253	GetHistName(what), d, r, s),
254	Form("%s for FMD%d%c[%02d]",
255	GetHistTitle(what), d, r, s),
256	nX, 0, nX);
257	ret->SetXTitle("Channel #");
258	ret->SetYTitle(GetHistTitle(what));
259	SetAttributes(ret, what, d, r);
260	ret->GetXaxis()->SetNdivisions(nX, false);
261	for (UShort_t t = 0; t < ret->GetNbinsX(); t++) {
262	Double_t val;
263	Double_t err;
264	GetNumber(what, d, r, s, t*128, val, err);
265	ret->SetBinContent(t+1, s+1, val);
266	if (err >= 0) ret->SetBinError(t+1, s+1, err);
267	}
268	return ret;
269	}
270
271	TH1D* ret = Make1D(what, d, r, s);
272	for (UShort_t t = 0; t < ret->GetNbinsX(); t++) {
273	Double_t val;
274	Double_t err;
275	GetNumber(what, d, r, s, t, val, err);
276	ret->SetBinContent(t+1, s+1, val);
277	if (err >= 0) ret->SetBinError(t+1, s+1, err);
278	}
279	return ret;
280	}
281
282	//____________________________________________________________________
283	void
284	AliFMDCalibDrawer::DrawOne(EWhat what, Short_t d, Char_t r,
285	Short_t s, Short_t /t/) const
286	{
287	Info("DrawOne", "Will draw %s for D=%d, R=%c, S=%d",
288	GetHistTitle(what), d, (r == '\0' ? '-' : r), s);
289	TVirtualPad* tp = gPad;
290	if (!tp) tp = TCanvas::MakeDefCanvas();
291	if (d <= 0 \|\| d > 3) {
292	// All detectors - need to split current pad
293	tp->Divide(1,3,0,0);
294	for (UShort_t dd = 1; dd <= 3; dd++) {
295	tp->cd(dd);
296	// Call our selves
297	DrawOne(what, dd, '\0', -1, -1);
298	}
299	}
300	else if ((r != 'I' && r != 'i') && (r != 'O' && r != 'o')) {
301	// All rings in a detector. Split current pad in two
302	tp->SetName(Form("FMD%d", d));
303	tp->Divide(2,1,0,0);
304	for (UShort_t q = 0; q < 2; q++) {
305	tp->cd(q+1);
306	Char_t rr = q == 0 ? 'I' : 'O';
307	// Call ourselves
308	DrawOne(what, d, rr, -1, -1);
309	}
310	}
311	else if (what == kRate \|\| what == kRange \|\| s < 0 \|\| s > 39) {
312	// A single ring - and special case for sample rate and strip range
313	tp->SetName(Form("FMD%d%c", d, r));
314	tp->SetFillColor(0);
315	tp->SetFillStyle(0);
316	tp->SetRightMargin(0.10);
317	if (d == 1 && (r == 'O' \|\| r == 'o')) return;
318	TH1* h = FillRing(what, d, r);
319	switch (what) {
320	case kRate: h->Draw("bar"); break;
321	case kRange: h->Draw("e3"); break;
322	default: h->Draw("colz"); break;
323	}
324	}
325	else {
326	// Finally, we're down to a single sector. In this case, we just do
327	// a single 1D histogram
328	TH1* h = FillSector(what, d, r, s);
329	h->Draw("hist e");
330	}
331	tp->Update();
332	tp->Modified();
333	tp->cd();
334	}
335
336
337
338	//____________________________________________________________________
339	//
340	// EOF
341	//