During simulation: fill STU region w/ non null time sums
[u/mrichter/AliRoot.git] / FMD / AliFMDParameters.cxx
1 /*************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  *************************************************************************
15  * $Id$ */
16 /**
17  * @file    AliFMDParameters.cxx
18  * @author  Christian Holm Christensen <cholm@nbi.dk>
19  * @date    Mon Mar 27 12:44:26 2006
20  * @brief   Manager of FMD parameters     
21  */
22 //____________________________________________________________________
23 //                                                                          
24 // Forward Multiplicity Detector based on Silicon wafers. 
25 //
26 // This class is a singleton that handles various parameters of
27 // the FMD detectors.  
28 // The manager normally serves the parameters from the Conditions
29 // Database (CDB).  These are retrivied by the member function
30 // `Init'.  Optionally, the class can serve hard-coded constants, if
31 // no CDB is available. 
32 //                                                       
33 #include "AliFMDDebug.h"                   // ALILOG_H
34 #include "AliFMDParameters.h"      // ALIFMDPARAMETERS_H
35 #include "AliFMDGeometry.h"        // ALIFMDGEOMETRY_H
36 #include "AliFMDRing.h"            // ALIFMDRING_H
37 #include "AliFMDCalibGain.h"       // ALIFMDCALIBGAIN_H
38 #include "AliFMDCalibPedestal.h"   // ALIFMDCALIBPEDESTAL_H
39 #include "AliFMDCalibSampleRate.h" // ALIFMDCALIBSAMPLERATE_H
40 #include "AliFMDCalibStripRange.h" // ALIFMDCALIBSTRIPRANGE_H
41 #include "AliFMDAltroMapping.h"    // ALIFMDALTROMAPPING_H
42 #include <AliCDBManager.h>         // ALICDBMANAGER_H
43 #include <AliCDBEntry.h>           // ALICDBMANAGER_H
44 #include <AliFMDPreprocessor.h>
45 #include <AliLog.h>
46 #include <Riostream.h>
47 #include <sstream>
48 #include <TSystem.h>
49 #include <TArrayF.h>
50 #include <TH2D.h>
51
52 //====================================================================
53 ClassImp(AliFMDParameters)
54 #if 0
55   ; // This is here to keep Emacs for indenting the next line
56 #endif
57
58 //____________________________________________________________________
59 AliFMDParameters* AliFMDParameters::fgInstance = 0;
60
61 //____________________________________________________________________
62 const char* AliFMDParameters::fgkPulseGain          = "FMD/Calib/PulseGain";
63 const char* AliFMDParameters::fgkPedestal           = "FMD/Calib/Pedestal";
64 const char* AliFMDParameters::fgkDead               = "FMD/Calib/Dead";
65 const char* AliFMDParameters::fgkSampleRate         = "FMD/Calib/SampleRate";
66 const char* AliFMDParameters::fgkAltroMap           = "FMD/Calib/AltroMap";
67 const char* AliFMDParameters::fgkZeroSuppression    = "FMD/Calib/ZeroSuppression";
68 const char* AliFMDParameters::fgkStripRange         = "FMD/Calib/StripRange";
69 const char* AliFMDParameters::fkPedestalShuttleID   = "pedestals";
70 const char* AliFMDParameters::fkGainShuttleID       = "gains";
71 const char* AliFMDParameters::fkConditionsShuttleID = "conditions";
72
73 //____________________________________________________________________
74 AliFMDParameters* 
75 AliFMDParameters::Instance() 
76 {
77   // 
78   // Get static instance 
79   //
80   if (!fgInstance) fgInstance = new AliFMDParameters;
81   return fgInstance;
82 }
83
84 //____________________________________________________________________
85 AliFMDParameters::AliFMDParameters() 
86   : fIsInit(kFALSE),
87     fkSiDeDxMip(1.664), 
88     fVA1MipRange(0),
89     fAltroChannelSize(0),
90     fChannelsPerAltro(0),
91     fPedestalFactor(0),
92     fZSPre(1),
93     fZSPost(1),
94     fZSPedSubtract(kTRUE),
95     fFixedPedestal(100),
96     fFixedPedestalWidth(2),
97     fFixedZeroSuppression(1),
98     fFixedSampleRate(2),
99     fFixedThreshold(0),
100     fFixedMinStrip(0),
101     fFixedMaxStrip(127),
102     fFixedPulseGain(2), 
103     fEdepMip(0),
104     fHasCompleteHeader(kTRUE),
105     fZeroSuppression(0), 
106     fSampleRate(0), 
107     fPedestal(0), 
108     fPulseGain(0), 
109     fDeadMap(0), 
110     fAltroMap(0), 
111     fStripRange(0)
112 {
113   //
114   // Default constructor 
115   //
116   SetVA1MipRange();
117   SetAltroChannelSize();
118   SetChannelsPerAltro();
119   SetZeroSuppression();
120   SetSampleRate();
121   SetPedestal();
122   SetPedestalWidth();
123   SetPedestalFactor();
124   SetThreshold();
125   SetStripRange();
126   SetGain();
127   fAltroMap = new AliFMDAltroMapping;
128 }
129
130 //__________________________________________________________________
131 void
132 AliFMDParameters::Init(Bool_t forceReInit, UInt_t what)
133 {
134   // 
135   // Initialize the manager.  This tries to read the parameters from
136   // CDB.  If that fails, the class uses the hard-coded parameters.
137   // 
138   // Parameters:
139   //    forceReInit Force (re-)initalize flag
140   //    what        What to initialize 
141   //
142   if (forceReInit) fIsInit = kFALSE;
143   if (fIsInit) return;
144   if (what & kPulseGain)       InitPulseGain();
145   if (what & kPedestal)        InitPedestal();
146   if (what & kDeadMap)         InitDeadMap();
147   if (what & kSampleRate)      InitSampleRate();
148   if (what & kZeroSuppression) InitZeroSuppression();
149   if (what & kAltroMap)        InitAltroMap();
150   if (what & kStripRange)      InitStripRange();
151   fIsInit = kTRUE;
152 }
153 //__________________________________________________________________
154 void
155 AliFMDParameters::Init(AliFMDPreprocessor* pp, Bool_t forceReInit, UInt_t what)
156 {
157   // 
158   // Initialize the manager.  This tries to read the parameters from
159   // CDB.  If that fails, the class uses the hard-coded parameters.
160   // 
161   // Parameters:
162   //    pp          Preprocessor 
163   //    forceReInit Force (re-)initalize flag
164   //    what        What to initialize 
165   //
166   if (forceReInit) fIsInit = kFALSE;
167   if (fIsInit) return;
168   if (what & kPulseGain)       InitPulseGain(pp);
169   if (what & kPedestal)        InitPedestal(pp);
170   if (what & kDeadMap)         InitDeadMap(pp);
171   if (what & kSampleRate)      InitSampleRate(pp);
172   if (what & kZeroSuppression) InitZeroSuppression(pp);
173   if (what & kAltroMap)        InitAltroMap(pp);
174   if (what & kStripRange)      InitStripRange(pp);
175   fIsInit = kTRUE;
176 }
177
178 //__________________________________________________________________
179 Bool_t
180 AliFMDParameters::CheckFile(const char* prefix, 
181                             const char* path, 
182                             int         number, 
183                             TString&    f) const
184 {
185   // 
186   // Check if the file <i>prefix</i><i>number</i> exists in @a path, 
187   // and write the full path to @a f.  
188   // 
189   // Parameters:
190   //    prefix  File prefix (cond, peds, gains, ...)
191   //    path    Path to files
192   //    number  Detector number (1, 2, or 3)
193   //    f       On return full path to file (if found)
194   // 
195   // Return:
196   //    @c true if file exists and is readable, @c false otherwise
197   //
198   f = (Form("%s%d.csv", prefix, number));
199   AliFMDDebug(5, ("Checking if %s exists in %s ...", f.Data(), path));
200   f = gSystem->Which(path, f.Data());
201   AliFMDDebug(5, ("Got back '%s'", f.Data()));
202   return !f.IsNull();
203 }
204
205 //__________________________________________________________________
206 void
207 AliFMDParameters::Init(const char* path, Bool_t forceReInit, UInt_t what)
208 {
209   // 
210   // Initialize the manager.  This will try to read some calibrations
211   // (sample rate, strip range, gains, pedestals) from local comma
212   // separated value (CSV) files in the directory pointed at by @a
213   // path.  If they are not found, then they will be retrieved from
214   // OCDB as appropriately.   Other calibrations are always read from
215   // OCDB.  
216   // 
217   // The CSV files should be named as 
218   // 
219   // - Pedestals: <tt>peds</tt><i>det_number</i><tt>.csv</tt>
220   // - Gains: <tt>gains</tt><i>det_number</i><tt>.csv</tt>
221   // - Sample Rate: <tt>conditions</tt><i>det_number</i><tt>.csv</tt>
222   // - Strip Range: <tt>conditions</tt><i>det_number</i><tt>.csv</tt>
223   //
224   // where <i>det_number</i> is the detector number (1, 2, or 3). 
225   // 
226   // Parameters:
227   //    path        Where to look for the CSV files
228   //    forceReInit Always reinitialise 
229   //    what        What calibrations to load. 
230   //  
231   if (forceReInit) fIsInit = kFALSE;
232   if (fIsInit) return;
233
234   AliFMDCalibStripRange*  range = 0;
235   AliFMDCalibSampleRate*  rate  = 0;
236   AliFMDCalibPedestal*    peds  = 0;
237   AliFMDCalibGain*        gains = 0;
238
239   for (Int_t i = 1; i <= 3; i++) { 
240     TString f;
241     if (((what & kSampleRate) || (what & kStripRange)) && 
242         CheckFile("conditions", path, i, f)) {
243       if (!rate  && (what & kSampleRate)) rate  = new AliFMDCalibSampleRate;
244       if (!range && (what & kStripRange)) range = new AliFMDCalibStripRange;
245       std::ifstream in(f.Data());
246       if (range) range->ReadFromFile(in);
247       if (rate)  rate->ReadFromFile(in);
248       in.close();
249     }
250     if ((what & kPedestal) && CheckFile("peds", path, i, f)) {
251       if (!peds) peds  = new AliFMDCalibPedestal;
252       std::ifstream in(f.Data());
253       peds->ReadFromFile(in);
254       in.close();
255     }
256     if ((what & kPulseGain) && CheckFile("gains", path, i, f)) { 
257       if (!gains) gains = new AliFMDCalibGain;
258       std::ifstream in(f.Data());
259       gains->ReadFromFile(in);
260       in.close();
261     }
262   }
263
264   if (range) what &= ~kStripRange;
265   if (rate)  what &= ~kSampleRate;
266   if (peds)  what &= ~kPedestal;
267   if (gains) what &= ~kPulseGain;
268
269   Init(kFALSE, what);
270   
271   if (range) SetStripRange(range);
272   if (rate)  SetSampleRate(rate);
273   if (peds)  SetPedestal(peds);
274   if (gains) SetGain(gains);
275
276   fIsInit = kTRUE;
277 }
278
279 //__________________________________________________________________
280 void
281 AliFMDParameters::MakeDeadMap(Float_t maxNoise, 
282                               Float_t minGain, 
283                               Float_t maxGain)
284 {
285   // 
286   // Automatically generate a dead map from the pedestals and gains.
287   // A channel is marked as dead of the noise is too high (currently
288   // more than 10 ADC counts), or the gain is unreasonable (currently
289   // larger than 10, or smaller than 0.1). 
290   // 
291   // The procedure does not overwrite channels previously marked as
292   // dead - e.g., channels marked as dead in the calibration loaded
293   // from OCDB will continue to be marked as dead.  That is, this
294   // procedure will never make a channel un-dead. 
295   // 
296   // Parameters:
297   //    maxNoise  Maximum noise value before a channel is marked
298   // as dead. 
299   //    minGain   Minimum value of the calibrated gain before a
300   // channel is considered dead. 
301   //    maxGain   Maximum value of the calibrated gain before a
302   // channel is considered dead. 
303   //
304   if (fPedestal)  
305     fDeadMap = fPedestal->MakeDeadMap(maxNoise, fDeadMap);
306   if (fPulseGain) 
307     fDeadMap = fPulseGain->MakeDeadMap(minGain, maxGain, fDeadMap);
308 }
309 //__________________________________________________________________
310 #define DET2IDX(det,ring,sec,str) \
311   (det * 1000 + (ring == 'I' ? 0 : 512) + str)  
312   
313 //__________________________________________________________________
314 void
315 AliFMDParameters::Draw(Option_t* option)
316 {
317   // 
318   // Draw parameters. 
319   // 
320   // Parameters:
321   //    option What to draw. Should be one of 
322   // - dead       Dead channels
323   // - threshold Threshold
324   // - gain       Gain
325   // - pedestal  Pedestal
326   // - noise      Noise (or pedestal width)
327   // - zero       Zero suppression
328   // - rate       Sampling rate (VA1 clock / ALTRO clock)
329   // - min        Minimum strip read out
330   // - max        Maximum strip read out
331   // - map        hardware address
332   //
333   TString opt(option);
334   enum {
335     kLocalPulseGain,       // Path to PulseGain calib object
336     kLocalThreshold,       // Path to PulseGain calib object
337     kLocalPedestal,        // Path to Pedestal calib object
338     kLocalPedestalWidth,   // Path to Pedestal calib object
339     kLocalDead,            // Path to Dead calib object
340     kLocalSampleRate,      // Path to SampleRate calib object
341     kLocalAltroMap,        // Path to AltroMap calib object
342     kLocalZeroSuppression, // Path to ZeroSuppression cal object
343     kLocalMinStripRange,   // Path to strip range cal object
344     kLocalMaxStripRange    // Path to strip range cal object
345   } what;
346     
347   if      (opt.Contains("dead", TString::kIgnoreCase)) 
348     what = kLocalDead;
349   else if (opt.Contains("threshold",TString::kIgnoreCase)) 
350     what = kLocalThreshold;
351   else if (opt.Contains("gain",TString::kIgnoreCase)) 
352     what = kLocalPulseGain;
353   else if (opt.Contains("pedestal",TString::kIgnoreCase)) 
354     what = kLocalPedestal;
355   else if (opt.Contains("noise",TString::kIgnoreCase)) 
356     what = kLocalPedestalWidth;
357   else if (opt.Contains("zero",TString::kIgnoreCase)) 
358     what = kLocalZeroSuppression;
359   else if (opt.Contains("rate",TString::kIgnoreCase)) 
360     what = kLocalSampleRate;
361   else if (opt.Contains("min",TString::kIgnoreCase)) 
362     what = kLocalMinStripRange;
363   else if (opt.Contains("max",TString::kIgnoreCase)) 
364     what = kLocalMaxStripRange;
365   else if (opt.Contains("map",TString::kIgnoreCase)) 
366     what = kLocalAltroMap;
367   else {
368     Warning("Draw", "unknown parameter: %s\n\tShould be one of\n\t"
369             "dead, threshold, gain, pedestal, noise, zero, rate, "
370             "min, max, map",  
371             option); 
372     return;
373   }
374
375   TArrayD xbins(3 * 512 + 2 * 256 + 5);
376   Int_t i = 1;
377   Bool_t skip = kTRUE;
378   for (UShort_t det = 1; det <= 3; det++) {
379     UShort_t nRings = (det == 1 ? 1 : 2);
380     for (UShort_t iring = 0; iring < nRings; iring++) {
381       UShort_t nStrip  = (iring == 0 ? 512 : 256);
382       Char_t   ring    = (iring == 0 ? 'I' : 'O');
383       for (UShort_t str = 0; str < nStrip; str++) {
384         // UShort_t nSec    = (iring == 0 ? 20  : 40);
385         // Char_t   ring    = (iring == 0 ? 'I' : 'O');
386         // for (UShort_t sec = 0; sec < nSec; sec++) {
387         Int_t idx = DET2IDX(det, ring, 0, str);
388         // Int_t idx = DET2IDX(det, ring, sec, 0);
389         if (skip) {
390           xbins[i-1] = idx - .5;
391           skip  = kFALSE;
392         }
393         xbins[i] = idx + .5;
394         i++;
395       }
396       skip = kTRUE;
397       i++;
398     }
399   }
400   TArrayD ybins(41);
401   for (/*Int_t*/ i = 0; i < ybins.fN; i++) ybins[i] = Float_t(i - .5);
402   TH2D* hist = new TH2D("calib", Form("Calibration %s", option), 
403                         xbins.fN-1, xbins.fArray,  
404                         ybins.fN-1, ybins.fArray);
405   hist->GetXaxis()->SetTitle("1000 #times detector + 512 #times ring + strip");
406   hist->GetYaxis()->SetTitle("sector");
407   
408   // hist->Draw("Lego");
409   // return;
410   
411   for (UShort_t det = 1; det <= 3; det++) {
412     UShort_t nRings = (det == 1 ? 1 : 2);
413     for (UShort_t iring = 0; iring < nRings; iring++) {
414       UShort_t nSector = (iring == 0 ?  20 : 40);
415       UShort_t nStrip  = (iring == 0 ? 512 : 256);
416       Char_t   ring    = (iring == 0 ? 'I' : 'O');
417       for (UShort_t sec = 0; sec < nSector; sec++) {
418         for (UShort_t str = 0; str < nStrip; str++) {
419           Int_t idx = DET2IDX(det, ring, sec, str);
420           UShort_t ddl, addr, time, sam=0;
421           Double_t val = 0;
422           switch (what) {
423           case kLocalPulseGain:       // Path to PulseGain calib object
424             val = GetPulseGain(det,ring,sec,str); break;
425           case kLocalThreshold:       // Path to PulseGain calib object
426             val = GetThreshold(); break;
427           case kLocalPedestal:        // Path to Pedestal calib object
428             val = GetPedestal(det,ring,sec,str); break;
429           case kLocalPedestalWidth:   // Path to Pedestal calib object
430             val = GetPedestalWidth(det,ring,sec,str); break;
431           case kLocalDead:            // Path to Dead calib object
432             val = IsDead(det,ring,sec,str); break;
433           case kLocalSampleRate:      // Path to SampleRate calib object
434             val = GetSampleRate(det,ring,sec,str); break;
435           case kLocalAltroMap:        // Path to AltroMap calib object
436             Detector2Hardware(det,ring,sec,str,sam,ddl,addr,time); 
437             val = addr; break;
438           case kLocalZeroSuppression: // Path to ZeroSuppression cal object
439             val = GetZeroSuppression(det,ring,sec,str); break;
440           case kLocalMinStripRange:   // Path to strip range cal object
441             val = GetMinStrip(det,ring,sec,str); break;
442           case kLocalMaxStripRange:    // Path to strip range cal object
443             val = GetMaxStrip(det,ring,sec,str); break;
444           }
445           hist->Fill(idx,sec,val);
446           // hist->Fill(idx,str,val);
447         }
448       }
449     }
450   }
451   hist->Draw("lego");
452 }
453
454 //__________________________________________________________________
455 void
456 AliFMDParameters::Print(Option_t* option) const
457 {
458   // Print information. 
459   // If option contains an 'A' then everything is printed. 
460   // If the option contains the string "FMD" the function will search 
461   // for detector, ring, sector, and strip numbers to print, in the
462   // format 
463   // 
464   //    FMD<detector><ring>[<sector>,<string>] 
465   // 
466   // The wild card '*' means all of <detector>, <ring>, <sector>, or 
467   // <strip>. 
468   TString opt(option);
469   Bool_t showStrips  = opt.Contains("a", TString::kIgnoreCase);
470   UShort_t ds[]      = { 1, 2, 3, 0 };
471   Char_t   rs[]      = { 'I', 'O', '\0' };
472   UShort_t minStrip  = 0;
473   UShort_t maxStrip  = 512;
474   UShort_t minSector = 0;
475   UShort_t maxSector = 40;
476   
477   
478   if (opt.Contains("fmd",TString::kIgnoreCase)) {
479     Int_t   i    = opt.Index("fmd",TString::kIgnoreCase);
480     Int_t   j    = opt.Index("]",TString::kIgnoreCase);
481     if (j != kNPOS)
482       showStrips    = kTRUE;
483     else 
484       j = opt.Length();
485     enum {
486       kReadDet, 
487       kReadRing, 
488       kReadLbrack,
489       kReadSector,
490       kReadComma,
491       kReadStrip,
492       kReadRbrack, 
493       kEnd
494     } state = kReadDet;
495     std::stringstream s(opt(i+4, j-i-3).Data());
496     while (state != kEnd) {
497       Char_t tmp = s.peek();
498       if (tmp == ' ' || tmp == '\t') {
499         s.get();
500         continue;
501       }
502       switch (state) {
503       case kReadDet: { // First, try to kRead the detector 
504         if (tmp == '*') s.get();
505         else { 
506           UShort_t det;
507           s >> det;
508           if (!s.bad()) {
509             ds[0] = det;
510             ds[1] = 0;
511           }
512         }
513         state = (s.bad() ? kEnd : kReadRing);
514       } break;
515       case kReadRing: { // Then try to read the ring;
516         Char_t ring;
517         s >> ring;
518         if (ring != '*' && !s.bad()) {
519           rs[0] = ring;
520           rs[1] = '\0';
521         }
522         state = (s.bad() ? kEnd : kReadLbrack);
523       } break;
524       case kReadLbrack: { // Try to read a left bracket 
525         Char_t lbrack;
526         s >> lbrack;
527         state = (s.bad() ? kEnd : kReadSector);
528       } break;
529       case kReadSector: { // Try to read a sector 
530         if (tmp == '*') s.get();
531         else {
532           UShort_t sec;
533           s >> sec;
534           if (!s.bad()) {
535             minSector = sec;
536             maxSector = sec + 1;
537           }
538         }
539         state = (s.bad() ? kEnd : kReadComma);
540       } break;
541       case kReadComma: { // Try to read a left bracket 
542         Char_t comma;
543         s >> comma;
544         state = (s.bad() ? kEnd : kReadStrip);
545       } break;
546       case kReadStrip: { // Try to read a strip 
547         if (tmp == '*') s.get();
548         else {
549           UShort_t str;
550           s >> str;
551           if (!s.bad()) {
552             minStrip = str;
553             maxStrip = str + 1;
554           }
555         }
556         state = (s.bad() ? kEnd : kReadRbrack);
557       } break;
558       case kReadRbrack: { // Try to read a left bracket 
559         Char_t rbrack;
560         s >> rbrack;
561         state = kEnd;
562       } break;
563       case kEnd: 
564         break;
565       }
566     }
567   }
568   UShort_t* dp = ds;
569   UShort_t  det;
570   while ((det = *(dp++))) {
571
572     Char_t* rp = rs;
573     Char_t  ring;
574     while ((ring = *(rp++))) {
575       if (det == 1 && ring == 'O') continue;
576       UShort_t min  = GetMinStrip(det, ring, 0, 0);
577       UShort_t max  = GetMaxStrip(det, ring, 0, 0);
578       std::cout << "FMD" << det << ring 
579                 << "  Strip range: " 
580                 << std::setw(3) << min << "," 
581                 << std::setw(3) << max << std::endl;
582
583       UShort_t nSec = ( ring == 'I' ? 20  :  40 );
584       UShort_t nStr = ( ring == 'I' ? 512 : 256 );
585       for (UShort_t sec = minSector; sec < maxSector && sec < nSec; sec++) {
586
587         UShort_t rate = GetSampleRate(det, ring, sec, 0);
588         std::cout << "FMD" << det << ring << "[" << std::setw(2) << sec 
589                   << "] sample rate: " << rate << std::endl;
590
591         if (!showStrips) continue;
592         std::cout 
593           << "  Strip |     Pedestal      |    Gain    | ZS thr. | Address\n" 
594           << "--------+-------------------+------------+---------+---------" 
595           << std::endl;
596         for (UShort_t str = minStrip; str < nStr && str < maxStrip; str++) {
597           if (str == minStrip) std::cout << std::setw(3) << sec << ",";
598           else std::cout << "    ";
599           std::cout << std::setw(3) << str << " | ";
600           if (IsDead(det, ring, sec, str)) {
601             std::cout << "dead" << std::endl;
602             continue;
603           }
604           UShort_t ddl, addr, time, sam=0;
605           Detector2Hardware(det, ring, sec, str, sam, ddl, addr, time);
606           std::cout << std::setw(7) << GetPedestal(det, ring, sec, str) 
607                     << "+/-" << std::setw(7) 
608                     << GetPedestalWidth(det, ring, sec, str) 
609                     << " | " << std::setw(10) 
610                     << GetPulseGain(det, ring, sec, str) 
611                     << " | " << std::setw(7) 
612                     << GetZeroSuppression(det, ring, sec, str) 
613                     << " | 0x" << std::hex << std::setw(4) 
614                     << std::setfill('0') << ddl << ",0x" << std::setw(3) 
615                     << addr << std::dec << std::setfill(' ') << std::endl;
616         } // for (strip)
617       } // for (sector)
618       std::cout
619         << "=============================================================" 
620         << std::endl;
621     } // while (ring)
622   } // while (det)
623   
624 }
625
626 //__________________________________________________________________
627 AliCDBEntry*
628 AliFMDParameters::GetEntry(const char* path, AliFMDPreprocessor* pp, 
629                            Bool_t fatal) const
630 {
631   // 
632   // Get an entry from either global AliCDBManager or passed
633   // AliFMDPreprocessor. 
634   // 
635   // Parameters:
636   //    path  Path to CDB object. 
637   //    pp    AliFMDPreprocessor 
638   //    fatal If true, raise a fatal flag if we didn't get the entry.
639   // Return:
640   //    AliCDBEntry if found 
641   // 
642   AliCDBEntry* entry = 0;
643   if (!pp) {
644     AliCDBManager* cdb = AliCDBManager::Instance();
645     entry              = cdb->Get(path);
646   }
647   else {
648     const char* third  = gSystem->BaseName(path);
649     const char* second = gSystem->BaseName(gSystem->DirName(path));
650     entry              = pp->GetFromCDB(second, third);
651   }
652   if (!entry) { 
653     TString msg(Form("No %s found in CDB, perhaps you need to "
654                      "use AliFMDCalibFaker?", path));
655     if (fatal) { AliFatal(msg.Data()); }
656     else       AliLog::Message(AliLog::kWarning, msg.Data(), "FMD", 
657                                "AliFMDParameters", "GetEntry", __FILE__, 
658                                __LINE__);
659     return 0;
660   }
661   if (entry && AliLog::GetDebugLevel("FMD", "") > 0) { 
662     AliInfoF("Got entry %p for %s", entry, path);
663     entry->PrintId();
664     entry->PrintMetaData();                     
665     entry->Print();
666   }
667   return entry;
668 }
669
670     
671 //__________________________________________________________________
672 void
673 AliFMDParameters::InitPulseGain(AliFMDPreprocessor* pp)
674 {
675   // 
676   // Initialize gains.  Try to get them from CDB 
677   // 
678   // Parameters:
679   //    pp Pre-processor if called from shuttle
680   //
681   AliCDBEntry*   gain     = GetEntry(fgkPulseGain, pp);
682   if (!gain) return;
683   
684   AliFMDDebug(5, ("Got gain from CDB"));
685   fPulseGain = dynamic_cast<AliFMDCalibGain*>(gain->GetObject());
686   if (!fPulseGain) AliFatal("Invalid pulser gain object from CDB");
687   if (!fPulseGain->Values().Ptr()) 
688     AliFatal("Empty pulser gain object from CDB");
689 }
690 //__________________________________________________________________
691 void
692 AliFMDParameters::InitPedestal(AliFMDPreprocessor* pp)
693 {
694   //
695   // Initialize pedestals.  Try to get them from CDB
696   // 
697   // Parameters:
698   //    pp Pre-processor if called from shuttle
699   //
700   AliCDBEntry*   pedestal = GetEntry(fgkPedestal, pp);
701   if (!pedestal) return;
702
703   AliFMDDebug(5, ("Got pedestal from CDB"));
704   fPedestal = dynamic_cast<AliFMDCalibPedestal*>(pedestal->GetObject());
705   if (!fPedestal) AliFatal("Invalid pedestal object from CDB");
706   if (!fPedestal->Values().Ptr()) AliFatal("Empty pedestal object from CDB");
707 }
708
709 //__________________________________________________________________
710 void
711 AliFMDParameters::InitDeadMap(AliFMDPreprocessor* pp)
712 {
713   //
714   // Initialize dead map.  Try to get it from CDB
715   // 
716   // Parameters:
717   //    pp Pre-processor if called from shuttle
718   //
719   AliCDBEntry*   deadMap  = GetEntry(fgkDead, pp);
720   if (!deadMap) return;
721   
722   AliFMDDebug(5, ("Got dead map from CDB"));
723   fDeadMap = dynamic_cast<AliFMDCalibDeadMap*>(deadMap->GetObject());
724   if (!fDeadMap) AliFatal("Invalid dead map object from CDB");
725   if (!fDeadMap->Ptr()) AliFatal("Empty dead map object from CDB");
726 }
727
728 //__________________________________________________________________
729 void
730 AliFMDParameters::InitZeroSuppression(AliFMDPreprocessor* pp)
731 {
732   //
733   // Initialize zero suppression thresholds.  Try to get them from CDB
734   // 
735   // Parameters:
736   //    pp Pre-processor if called from shuttle
737   //
738   AliCDBEntry*   zeroSup  = GetEntry(fgkZeroSuppression, pp);
739   if (!zeroSup) return;
740   AliFMDDebug(5, ("Got zero suppression from CDB"));
741   fZeroSuppression = 
742     dynamic_cast<AliFMDCalibZeroSuppression*>(zeroSup->GetObject());
743   if (!fZeroSuppression)AliFatal("Invalid zero suppression object from CDB");
744   if (!fZeroSuppression->Ptr()) {
745     AliWarningF("Empty zero suppression object from CDB, assuming %d",
746                 fFixedZeroSuppression);
747     AliCDBManager* cdbMan = AliCDBManager::Instance();
748     if(!cdbMan || !cdbMan->GetCacheFlag())
749       delete fZeroSuppression;
750     fZeroSuppression = 0;
751   }
752 }
753
754 //__________________________________________________________________
755 void
756 AliFMDParameters::InitSampleRate(AliFMDPreprocessor* pp)
757 {
758   //
759   // Initialize sample rates.  Try to get them from CDB
760   // 
761   // Parameters:
762   //    pp Pre-processor if called from shuttle
763   //
764   AliCDBEntry*   sampRat  = GetEntry(fgkSampleRate, pp);
765   if (!sampRat) return;
766   AliFMDDebug(5, ("Got zero suppression from CDB"));
767   fSampleRate = dynamic_cast<AliFMDCalibSampleRate*>(sampRat->GetObject());
768   if (!fSampleRate) AliFatal("Invalid sample rate object from CDB");
769   if (!fSampleRate->Rates().Ptr()) 
770     AliFatal("empty sample rate object from CDB");
771 }
772
773 //__________________________________________________________________
774 void
775 AliFMDParameters::InitAltroMap(AliFMDPreprocessor* pp)
776 {
777   //
778   // Initialize hardware map.  Try to get it from CDB
779   // 
780   // Parameters:
781   //    pp Pre-processor if called from shuttle
782   //
783   if (fAltroMap) { 
784     delete fAltroMap;
785     fAltroMap = 0;
786   }
787   AliCDBEntry*   hwMap    = GetEntry(fgkAltroMap, pp, kFALSE);       
788   if (!hwMap) return;
789
790   AliFMDDebug(5, ("Got ALTRO map from CDB"));
791   fAltroMap = dynamic_cast<AliFMDAltroMapping*>(hwMap->GetObject());
792   if (!fAltroMap) {
793     AliFatal("Invalid ALTRO map object from CDB");
794     fAltroMap = new AliFMDAltroMapping;
795   }
796 }
797
798 //__________________________________________________________________
799 void
800 AliFMDParameters::InitStripRange(AliFMDPreprocessor* pp)
801 {
802   //
803   // Initialize strip range.  Try to get it from CDB
804   // 
805   // Parameters:
806   //    pp Pre-processor if called from shuttle
807   //
808   AliCDBEntry*   range    = GetEntry(fgkStripRange, pp);
809   if (!range) return;
810   AliFMDDebug(5, ("Got strip range from CDB"));
811   fStripRange = dynamic_cast<AliFMDCalibStripRange*>(range->GetObject());
812   if (!fStripRange) AliFatal("Invalid strip range object from CDB");
813   if (!fStripRange->Ranges().Ptr()) 
814     AliFatal("Empty strip range object from CDB");
815 }
816
817
818 //__________________________________________________________________
819 Float_t
820 AliFMDParameters::GetThreshold() const
821 {
822   // 
823   // Get the threshold in the pulser gain 
824   // 
825   // 
826   // Return:
827   //    Threshold from pulser 
828   //
829   if (!fPulseGain) return fFixedThreshold;
830   return fPulseGain->Threshold();
831 }
832
833 //__________________________________________________________________
834 Float_t
835 AliFMDParameters::GetPulseGain(UShort_t detector, Char_t ring, 
836                                UShort_t sector, UShort_t strip) const
837 {
838   // 
839   // Gain of pre-amp. for strip, sector, ring, detector 
840   //
841   // For simulations this is normally set to 
842   //
843   // @f[ 
844   //  \frac{\mbox{VA1_MIP_Range}{\mbox{ALTRO_channel_size}}\mbox{MIP_Energy_Loss}
845   // @f]
846   // 
847   // 
848   // Parameters:
849   //    detector Detector # (1-3)
850   //    ring     Ring ID ('I' or 'O')
851   //    sector   Sector number (0-39)
852   //    strip    Strip number (0-511)
853   //
854   // Return:
855   //    Gain of pre-amp.  
856   //
857   if (!fPulseGain) { 
858     if (fFixedPulseGain <= 0)
859       fFixedPulseGain = fVA1MipRange * GetEdepMip() / fAltroChannelSize;
860     return fFixedPulseGain;
861   }  
862   AliFMDDebug(50, ("pulse gain for FMD%d%c[%2d,%3d]=%f",
863                     detector, ring, sector, strip,
864                     fPulseGain->Value(detector, ring, sector, strip)));
865   return fPulseGain->Value(detector, ring, sector, strip);
866 }
867
868 //__________________________________________________________________
869 Bool_t
870 AliFMDParameters::IsDead(UShort_t detector, Char_t ring, 
871                          UShort_t sector, UShort_t strip) const
872 {
873   // 
874   // Whether the strip is considered dead
875   // 
876   // Parameters:
877   //    detector Detector # (1-3)
878   //    ring     Ring ID ('I' or 'O')
879   //    sector   Sector number (0-39)
880   //    strip    Strip number (0-511)
881   //
882   // Return:
883   //    @c true if the strip is considered dead, @c false if it's
884   // OK.
885   //
886   if (!fDeadMap) return kFALSE;
887   AliFMDDebug(50, ("Dead for FMD%d%c[%2d,%3d]=%s",
888                     detector, ring, sector, strip,
889                     fDeadMap->operator()(detector, ring, sector, strip) ? 
890                     "no" : "yes"));
891   return fDeadMap->operator()(detector, ring, sector, strip);
892 }
893
894 //__________________________________________________________________
895 UShort_t
896 AliFMDParameters::GetZeroSuppression(UShort_t detector, Char_t ring, 
897                                      UShort_t sector, UShort_t strip) const
898 {
899   // 
900   // zero suppression threshold (in ADC counts)
901   // 
902   // Parameters:
903   //    detector Detector # (1-3)
904   //    ring     Ring ID ('I' or 'O')
905   //    sector   Sector number (0-39)
906   //    strip    Strip number (0-511)
907   //
908   // Return:
909   //    zero suppression threshold (in ADC counts) 
910   //
911   if (!fZeroSuppression) return fFixedZeroSuppression;
912
913   // In case of empty zero suppression objects. 
914   if (!fZeroSuppression->Ptr() || 
915       fZeroSuppression->MaxIndex() <= 0) return fFixedZeroSuppression;
916
917   // Need to map strip to ALTRO chip. 
918   AliFMDDebug(50, ("zero sup. for FMD%d%c[%2d,%3d]=%d",
919                     detector, ring, sector, strip,
920                     fZeroSuppression->operator()(detector, ring, 
921                                                  sector, strip)));
922   return fZeroSuppression->operator()(detector, ring, sector, strip/128);
923 }
924
925 //__________________________________________________________________
926 UShort_t
927 AliFMDParameters::GetSampleRate(UShort_t det, Char_t ring, UShort_t sector, 
928                                 UShort_t str) const
929 {
930   // 
931   // Get the sampling rate
932   // 
933   // Parameters:
934   //    detector Detector # (1-3)
935   //    ring     Ring ID ('I' or 'O')
936   //    sector   Sector number (0-39)
937   //    strip    Strip number (0-511)
938   //
939   // Return:
940   //    The sampling rate 
941   //
942   if (!fSampleRate) return fFixedSampleRate;
943   // Need to map sector to digitizier card. 
944   UInt_t ret = fSampleRate->Rate(det, ring, sector, str);
945   AliFMDDebug(50, ("Sample rate for FMD%d%c[%2d,%3d]=%d", 
946                     det, ring, sector, str, ret));
947   return ret;
948 }
949
950 //__________________________________________________________________
951 UShort_t
952 AliFMDParameters::GetMinStrip(UShort_t det, Char_t ring, UShort_t sector, 
953                               UShort_t str) const
954 {
955   // 
956   // Get the minimum strip in the read-out range
957   // 
958   // Parameters:
959   //    detector Detector # (1-3)
960   //    ring     Ring ID ('I' or 'O')
961   //    sector   Sector number (0-39)
962   //    strip    Strip number (0-511)
963   //
964   // Return:
965   //    Minimum strip 
966   //
967   if (!fStripRange) return fFixedMinStrip;
968   // Need to map sector to digitizier card. 
969   UInt_t ret = fStripRange->Min(det, ring, sector, str);
970   AliFMDDebug(50, ("Min strip # for FMD%d%c[%2d,%3d]=%d", 
971                     det, ring, sector, str, ret));
972   return ret;
973 }
974
975 //__________________________________________________________________
976 UShort_t
977 AliFMDParameters::GetMaxStrip(UShort_t det, Char_t ring, UShort_t sector, 
978                               UShort_t str) const
979 {
980   // 
981   // Get the maximum strip in the read-out range
982   // 
983   // Parameters:
984   //    detector Detector # (1-3)
985   //    ring     Ring ID ('I' or 'O')
986   //    sector   Sector number (0-39)
987   //    strip    Strip number (0-511)
988   //
989   // Return:
990   //    Maximum strip 
991   //
992   if (!fStripRange) return fFixedMaxStrip;
993   // Need to map sector to digitizier card. 
994   UInt_t ret = fStripRange->Max(det, ring, sector, str);
995   AliFMDDebug(50, ("Max strip # for FMD%d%c[%2d,%3d]=%d", 
996                     det, ring, sector, str, ret));
997   return ret;
998 }
999
1000 //__________________________________________________________________
1001 Float_t
1002 AliFMDParameters::GetPedestal(UShort_t detector, Char_t ring, 
1003                               UShort_t sector, UShort_t strip) const
1004 {
1005   // 
1006   // Get mean of pedestal
1007   // 
1008   // Parameters:
1009   //    detector Detector # (1-3)
1010   //    ring     Ring ID ('I' or 'O')
1011   //    sector   Sector number (0-39)
1012   //    strip    Strip number (0-511)
1013   //
1014   // Return:
1015   //    Mean of pedestal 
1016   //
1017   if (!fPedestal) return fFixedPedestal;
1018   AliFMDDebug(50, ("pedestal for FMD%d%c[%2d,%3d]=%f",
1019                     detector, ring, sector, strip,
1020                     fPedestal->Value(detector, ring, sector, strip)));
1021   return fPedestal->Value(detector, ring, sector, strip);
1022 }
1023
1024 //__________________________________________________________________
1025 Float_t
1026 AliFMDParameters::GetPedestalWidth(UShort_t detector, Char_t ring, 
1027                                    UShort_t sector, UShort_t strip) const
1028 {
1029   // 
1030   // Width of pedestal
1031   // 
1032   // Parameters:
1033   //    detector Detector # (1-3)
1034   //    ring     Ring ID ('I' or 'O')
1035   //    sector   Sector number (0-39)
1036   //    strip    Strip number (0-511)
1037   //
1038   // Return:
1039   //    Width of pedestal 
1040   //
1041   if (!fPedestal) return fFixedPedestalWidth;
1042   AliFMDDebug(50, ("pedetal width for FMD%d%c[%2d,%3d]=%f",
1043                     detector, ring, sector, strip,
1044                     fPedestal->Width(detector, ring, sector, strip)));
1045   return fPedestal->Width(detector, ring, sector, strip);
1046 }
1047   
1048 //__________________________________________________________________
1049 AliFMDAltroMapping*
1050 AliFMDParameters::GetAltroMap() const
1051 {
1052   // 
1053   // Get the map that translates hardware to detector coordinates 
1054   //
1055   // Return:
1056   //    Get the map that translates hardware to detector
1057   // coordinates 
1058   // 
1059   return fAltroMap;
1060 }
1061
1062
1063 //____________________________________________________________________
1064 Bool_t 
1065 AliFMDParameters::Hardware2Detector(UShort_t  ddl,       UShort_t addr,
1066                                     UShort_t  timebin,   
1067                                     UShort_t& det,       Char_t&  ring, 
1068                                     UShort_t& sec,       Short_t& str,
1069                                     UShort_t& sam) const
1070 {
1071   // 
1072   // Map a hardware address into a detector index. 
1073   // 
1074   // Parameters:
1075   //    ddl        Hardware DDL number 
1076   //    addr       Hardware address.  
1077   //    timebin    Timebin 
1078   //    det        On return, the detector #
1079   //    ring       On return, the ring ID
1080   //    sec        On return, the sector #
1081   //    str        On return, the base of strip #
1082   //    sam        On return, the sample number for this strip
1083   //
1084   // Return:
1085   //    @c true on success, false otherwise 
1086   //
1087   if (!fAltroMap) return kFALSE;
1088   UShort_t board, chip, chan;
1089   fAltroMap->ChannelAddress(addr, board, chip, chan);
1090   return Hardware2Detector(ddl,board,chip,chan,timebin,det,ring,sec,str,sam);
1091 }
1092 //____________________________________________________________________
1093 Bool_t 
1094 AliFMDParameters::Hardware2Detector(UShort_t  ddl,       UShort_t   board,
1095                                     UShort_t  chip,      UShort_t   chan,
1096                                     UShort_t  timebin,   
1097                                     UShort_t& det,       Char_t&   ring, 
1098                                     UShort_t& sec,       Short_t& str,
1099                                     UShort_t& sam) const
1100 {
1101   // 
1102   // Map a hardware address into a detector index. 
1103   // 
1104   // Parameters:
1105   //    ddl        Hardware DDL number 
1106   //    board      FEC number
1107   //    altro      ALTRO number 
1108   //    channel    Channel number 
1109   //    timebin    Timebin 
1110   //    det        On return, the detector #
1111   //    ring       On return, the ring ID
1112   //    sec        On return, the sector #
1113   //    str        On return, the base of strip #
1114   //    sam        On return, the sample number for this strip
1115   //
1116   // Return:
1117   //    @c true on success, false otherwise 
1118   //
1119   if (!fAltroMap) {
1120     AliFMDDebug(1, ("No ALTRO map available"));
1121     return kFALSE;
1122   }
1123   if (fAltroMap->DDL2Detector(ddl) < 0) { 
1124     AliFMDDebug(1, ("Invalid DDL number %d", ddl));
1125     return kFALSE;
1126   }
1127   det = fAltroMap->DDL2Detector(ddl);
1128   Short_t stripBase = 0;
1129   if (!fAltroMap->Channel2StripBase(board,chip,chan, ring, sec, stripBase)) {
1130     AliFMDDebug(1, ("Failed to translate  "
1131                     "%d/0x%02x/0x%x/0x%x/%04d -> "
1132                     "FMD%d%c[%2d,%3d] to detector", 
1133                     ddl, board, chip, chan, timebin, 
1134                     det, ring, sec, stripBase));
1135     return kFALSE;
1136   }
1137   UShort_t preSamples = GetPreSamples(det, ring, sec, stripBase);
1138   UShort_t sampleRate = GetSampleRate(det, ring, sec, stripBase);
1139   Short_t stripOff = 0;
1140   fAltroMap->Timebin2Strip(sec, timebin, preSamples, sampleRate, stripOff, sam);
1141   str = stripBase + stripOff;
1142   AliFMDDebug(50, ("%d/0x%02x/0x%x/0x%x/%04d -> FMD%d%c[%02d,%03d]-%d"
1143                   " (pre=%2d, rate=%d)", 
1144                    ddl, board, chip, chan, timebin, 
1145                    det, ring, sec, str, sam, preSamples, sampleRate));
1146   return kTRUE;
1147 }
1148
1149
1150 //____________________________________________________________________
1151 Bool_t 
1152 AliFMDParameters::Detector2Hardware(UShort_t  det,        Char_t    ring, 
1153                                     UShort_t  sec,        UShort_t  str,
1154                                     UShort_t  sam, 
1155                                     UShort_t& ddl,        UShort_t& board, 
1156                                     UShort_t& altro,      UShort_t& channel, 
1157                                     UShort_t& timebin) const
1158 {
1159   // 
1160   // Map a detector index into a hardware address. 
1161   // 
1162   // Parameters:
1163   //    det         The detector #
1164   //    ring        The ring ID
1165   //    sec         The sector #
1166   //    str         The strip #
1167   //    sam         The sample number 
1168   //    ddl         On return, hardware DDL number 
1169   //    board       On return, the FEC board address (local to DDL)
1170   //    altro       On return, the ALTRO number (local to FEC)
1171   //    channel     On return, the channel number (local to ALTRO)
1172   //    timebin     On return, the timebin number (local to ALTRO)
1173   //
1174   // Return:
1175   //    @c true on success, false otherwise 
1176   //
1177   if (!fAltroMap) { 
1178     AliFMDDebug(1, ("No ALTRO map available"));
1179     return kFALSE;
1180   }
1181   UShort_t preSamples = GetPreSamples(det, ring, sec, str);
1182   UShort_t sampleRate = GetSampleRate(det, ring, sec, str);
1183   UShort_t strip      = str - GetMinStrip(det,ring,sec,str);
1184   return fAltroMap->Detector2Hardware(det, ring, sec, strip, sam,
1185                                       preSamples, sampleRate,
1186                                       ddl, board, altro, channel, timebin);
1187 }
1188
1189   
1190
1191 //____________________________________________________________________
1192 Bool_t 
1193 AliFMDParameters::Detector2Hardware(UShort_t  det,        Char_t    ring, 
1194                                     UShort_t  sec,        UShort_t  str,
1195                                     UShort_t  sam, 
1196                                     UShort_t&   ddl,        UShort_t&   addr,
1197                                     UShort_t& timebin) const
1198 {
1199   // 
1200   // Map a detector index into a hardware address. 
1201   // 
1202   // Parameters:
1203   //    det         The detector #
1204   //    ring        The ring ID
1205   //    sec         The sector #
1206   //    str         The strip #
1207   //    sam         The sample number 
1208   //    ddl         On return, hardware DDL number 
1209   //    addr      On return, hardware address.  
1210   //    timebin     On return, the timebin number (local to ALTRO)
1211   //
1212   // Return:
1213   //    @c true on success, false otherwise 
1214   //
1215   if (!fAltroMap) return kFALSE;
1216   UShort_t preSamples = GetPreSamples(det, ring, sec, str);
1217   UShort_t sampleRate = GetSampleRate(det, ring, sec, str);
1218   UShort_t strip      = str - GetMinStrip(det,ring,sec,str);
1219   return fAltroMap->Detector2Hardware(det, ring, sec, strip, sam,
1220                                       preSamples, sampleRate,
1221                                       ddl, addr, timebin);
1222 }
1223
1224
1225 //__________________________________________________________________
1226 Float_t
1227 AliFMDParameters::GetEdepMip() const 
1228
1229   // 
1230   // Return:
1231   //    The average energy deposited by one MIP 
1232   //
1233   if (fEdepMip <= 0){
1234     AliFMDGeometry* fmd = AliFMDGeometry::Instance();
1235     fEdepMip = (fkSiDeDxMip 
1236                 * fmd->GetRing('I')->GetSiThickness() 
1237                 * fmd->GetSiDensity());
1238   }
1239   return fEdepMip;
1240 }
1241 //____________________________________________________________________
1242 Float_t  
1243 AliFMDParameters::GetDACPerMIP() const
1244 {
1245   // 
1246   // This is the conversion from Digital-to-Analog-Converter setting
1247   // to the number of MIPs. The number was measured in the NBI lab during
1248   // August 2008.
1249   //
1250   // Return:
1251   //    The conversion factor from DAC to ADC 
1252   //
1253   return 29.67;
1254   
1255 }
1256  
1257 //____________________________________________________________________
1258 //
1259 // EOF
1260 //