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