e637a159fb83a660ccc0dc84bc5c560ed6b06e7f
[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 /** @file    AliFMDParameters.cxx
17     @author  Christian Holm Christensen <cholm@nbi.dk>
18     @date    Mon Mar 27 12:44:26 2006
19     @brief   Manager of FMD parameters     
20 */
21 //____________________________________________________________________
22 //                                                                          
23 // Forward Multiplicity Detector based on Silicon wafers. 
24 //
25 // This class is a singleton that handles various parameters of
26 // the FMD detectors.  
27 // The manager normally serves the parameters from the Conditions
28 // Database (CDB).  These are retrivied by the member function
29 // `Init'.  Optionally, the class can serve hard-coded constants, if
30 // no CDB is available. 
31 //                                                       
32 #include "AliLog.h"                // ALILOG_H
33 #include "AliFMDParameters.h"      // ALIFMDPARAMETERS_H
34 #include "AliFMDGeometry.h"        // ALIFMDGEOMETRY_H
35 #include "AliFMDRing.h"            // ALIFMDRING_H
36 #include "AliFMDCalibGain.h"       // ALIFMDCALIBGAIN_H
37 #include "AliFMDCalibPedestal.h"   // ALIFMDCALIBPEDESTAL_H
38 #include "AliFMDCalibSampleRate.h" // ALIFMDCALIBSAMPLERATE_H
39 #include "AliFMDCalibStripRange.h" // ALIFMDCALIBSTRIPRANGE_H
40 #include "AliFMDAltroMapping.h"    // ALIFMDALTROMAPPING_H
41 #include <AliCDBManager.h>         // ALICDBMANAGER_H
42 #include <AliCDBEntry.h>           // ALICDBMANAGER_H
43 #include <Riostream.h>
44 #include <sstream>
45 #include <TArrayF.h>
46 #include <TH2D.h>
47
48 //====================================================================
49 ClassImp(AliFMDParameters)
50 #if 0
51   ; // This is here to keep Emacs for indenting the next line
52 #endif
53
54 //____________________________________________________________________
55 AliFMDParameters* AliFMDParameters::fgInstance = 0;
56
57 //____________________________________________________________________
58 const char* AliFMDParameters::fgkPulseGain       = "FMD/Calib/PulseGain";
59 const char* AliFMDParameters::fgkPedestal        = "FMD/Calib/Pedestal";
60 const char* AliFMDParameters::fgkDead            = "FMD/Calib/Dead";
61 const char* AliFMDParameters::fgkSampleRate      = "FMD/Calib/SampleRate";
62 const char* AliFMDParameters::fgkAltroMap        = "FMD/Calib/AltroMap";
63 const char* AliFMDParameters::fgkZeroSuppression = "FMD/Calib/ZeroSuppression";
64 const char* AliFMDParameters::fgkStripRange      = "FMD/Calib/StripRange";
65
66
67 //____________________________________________________________________
68 AliFMDParameters* 
69 AliFMDParameters::Instance() 
70 {
71   // Get static instance 
72   if (!fgInstance) fgInstance = new AliFMDParameters;
73   return fgInstance;
74 }
75
76 //____________________________________________________________________
77 AliFMDParameters::AliFMDParameters() 
78   : fIsInit(kFALSE),
79     fkSiDeDxMip(1.664), 
80     fVA1MipRange(0),
81     fAltroChannelSize(0),
82     fChannelsPerAltro(0),
83     fPedestalFactor(0),
84     fFixedPedestal(0),
85     fFixedPedestalWidth(0),
86     fFixedZeroSuppression(0),
87     fFixedSampleRate(0),
88     fFixedThreshold(0),
89     fFixedMinStrip(0),
90     fFixedMaxStrip(0),
91     fFixedPulseGain(0), 
92     fEdepMip(0),
93     fZeroSuppression(0), 
94     fSampleRate(0), 
95     fPedestal(0), 
96     fPulseGain(0), 
97     fDeadMap(0), 
98     fAltroMap(0), 
99     fStripRange(0)
100 {
101   // Default constructor 
102   SetVA1MipRange();
103   SetAltroChannelSize();
104   SetChannelsPerAltro();
105   SetZeroSuppression();
106   SetSampleRate();
107   SetPedestal();
108   SetPedestalWidth();
109   SetPedestalFactor();
110   SetThreshold();
111   SetStripRange();
112 }
113
114 //__________________________________________________________________
115 void
116 AliFMDParameters::Init()
117 {
118   // Initialize the parameters manager.  We need to get stuff from the
119   // CDB here. 
120   if (fIsInit) return;
121   InitPulseGain();
122   InitPedestal();
123   InitDeadMap();
124   InitSampleRate();
125   InitZeroSuppression();
126   InitAltroMap();
127   fIsInit = kTRUE;
128   
129 }
130
131 //__________________________________________________________________
132 #define DET2IDX(det,ring,sec,str) \
133   (det * 10000 + (ring == 'I' ? 0 : 1000) + str)  
134   
135 //__________________________________________________________________
136 void
137 AliFMDParameters::Draw(Option_t* option)
138 {
139   TString opt(option);
140   enum {
141     kPulseGain,       // Path to PulseGain calib object
142     kThreshold,       // Path to PulseGain calib object
143     kPedestal,        // Path to Pedestal calib object
144     kPedestalWidth,   // Path to Pedestal calib object
145     kDead,            // Path to Dead calib object
146     kSampleRate,      // Path to SampleRate calib object
147     kAltroMap,        // Path to AltroMap calib object
148     kZeroSuppression, // Path to ZeroSuppression cal object
149     kMinStripRange,   // Path to strip range cal object
150     kMaxStripRange    // Path to strip range cal object
151   } what;
152   
153     
154   if      (opt.Contains("dead", TString::kIgnoreCase)) 
155     what = kDead;
156   else if (opt.Contains("threshold",TString::kIgnoreCase)) 
157     what = kThreshold;
158   else if (opt.Contains("gain",TString::kIgnoreCase)) 
159     what = kPulseGain;
160   else if (opt.Contains("pedestal",TString::kIgnoreCase)) 
161     what = kPedestal;
162   else if (opt.Contains("noise",TString::kIgnoreCase)) 
163     what = kPedestalWidth;
164   else if (opt.Contains("zero",TString::kIgnoreCase)) 
165     what = kZeroSuppression;
166   else if (opt.Contains("rate",TString::kIgnoreCase)) 
167     what = kSampleRate;
168   else if (opt.Contains("min",TString::kIgnoreCase)) 
169     what = kMinStripRange;
170   else if (opt.Contains("max",TString::kIgnoreCase)) 
171     what = kMaxStripRange;
172   else if (opt.Contains("map",TString::kIgnoreCase)) 
173     what = kAltroMap;
174   else {
175     Warning("Draw", "unknown parameter: %s\n\tShould be one of\n\t"
176             "dead, threshold, gain, pedestal, noise, zero, rate, "
177             "min, max, map",  
178             option); 
179     return;
180   }
181
182   TArrayD xbins(3 * 512 + 2 * 256 + 5);
183   Int_t i = 1;
184   Bool_t skip = kTRUE;
185   for (UShort_t det = 1; det <= 3; det++) {
186     UShort_t nRings = (det == 1 ? 1 : 2);
187     for (UShort_t iring = 0; iring < nRings; iring++) {
188       UShort_t nStrip  = (iring == 0 ? 512 : 256);
189       Char_t   ring    = (iring == 0 ? 'I' : 'O');
190       for (UShort_t str = 0; str < nStrip; str++) {
191         Int_t idx = DET2IDX(det, ring, 0, str);
192         if (skip) {
193           xbins[i-1] = idx - .5;
194           skip  = kFALSE;
195         }
196         xbins[i] = idx + .5;
197         i++;
198       }
199       skip = kTRUE;
200       i++;
201     }
202   }
203   TArrayD ybins(41);
204   for (Int_t i = 0; i < 41; i++) ybins[i] = Float_t(i - .5);
205   TH2D* hist = new TH2D("calib", Form("Calibration %s", option), 
206                         xbins.fN-1, xbins.fArray,  
207                         ybins.fN-1, ybins.fArray);
208
209   // hist->Draw("Lego");
210   // return;
211   
212   for (UShort_t det = 1; det <= 3; det++) {
213     UShort_t nRings = (det == 1 ? 1 : 2);
214     for (UShort_t iring = 0; iring < nRings; iring++) {
215       UShort_t nSector = (iring == 0 ?  20 : 40);
216       UShort_t nStrip  = (iring == 0 ? 512 : 256);
217       Char_t   ring    = (iring == 0 ? 'I' : 'O');
218       for (UShort_t sec = 0; sec < nSector; sec++) {
219         for (UShort_t str = 0; str < nStrip; str++) {
220           Int_t idx = DET2IDX(det, ring, sec, str);
221           UInt_t ddl, addr;
222           Double_t val = 0;
223           switch (what) {
224           case kPulseGain:       // Path to PulseGain calib object
225             val = GetPulseGain(det,ring,sec,str); break;
226           case kThreshold:       // Path to PulseGain calib object
227             val = GetThreshold(); break;
228           case kPedestal:        // Path to Pedestal calib object
229             val = GetPedestal(det,ring,sec,str); break;
230           case kPedestalWidth:   // Path to Pedestal calib object
231             val = GetPedestalWidth(det,ring,sec,str); break;
232           case kDead:            // Path to Dead calib object
233             val = IsDead(det,ring,sec,str); break;
234           case kSampleRate:      // Path to SampleRate calib object
235             val = GetSampleRate(det,ring,sec,str); break;
236           case kAltroMap:        // Path to AltroMap calib object
237             Detector2Hardware(det,ring,sec,str, ddl, addr); 
238             val = addr; break;
239           case kZeroSuppression: // Path to ZeroSuppression cal object
240             val = GetZeroSuppression(det,ring,sec,str); break;
241           case kMinStripRange:   // Path to strip range cal object
242             val = GetMinStrip(det,ring,sec,str); break;
243           case kMaxStripRange:    // Path to strip range cal object
244             val = GetMaxStrip(det,ring,sec,str); break;
245           }
246           hist->Fill(idx,sec,val);
247         }
248       }
249     }
250   }
251   hist->Draw("lego");
252 }
253
254 //__________________________________________________________________
255 void
256 AliFMDParameters::Print(Option_t* option) const
257 {
258   // Print information. 
259   // If option contains an 'A' then everything is printed. 
260   TString opt(option);
261   Bool_t showStrips = opt.Contains("a", TString::kIgnoreCase);
262   if (opt.Contains("fmd",TString::kIgnoreCase)) {
263     size_t   i   = opt.Index("fmd",TString::kIgnoreCase);
264     size_t   j   = opt.Index("]",TString::kIgnoreCase);
265     UShort_t det, sec, str;
266     Char_t ring, lbrack, rbrack, comma;
267     UInt_t ddl, addr;
268     std::stringstream s(opt(i+4, j-i-3).Data());
269     s >> det >> ring >> lbrack >> sec >> comma >> str >> rbrack;
270     Detector2Hardware(det, ring, sec, str, ddl, addr);
271     std::cout 
272       << "     Strip    |     Pedestal      |    Gain    | ZS thr. | Address\n"
273       << "--------------+-------------------+------------+---------+---------" 
274       << "\nFMD" << det << ring << "[" << std::setw(2) << sec << "," 
275       << std::setw(3) << str << "] | " 
276       << std::setw(7) << GetPedestal(det, ring, sec, str) 
277       << "+/-" << std::setw(7) 
278       << GetPedestalWidth(det, ring, sec, str) 
279       << " | " << std::setw(10) 
280       << GetPulseGain(det, ring, sec, str) 
281       << " | " << std::setw(7) 
282       << GetZeroSuppression(det, ring, sec, str) 
283       << " | 0x" << std::hex << std::setw(4) 
284       << std::setfill('0') << ddl << ",0x" << std::setw(3) 
285       << addr << std::dec << std::setfill(' ') << std::endl;
286     return;
287   }
288   for (UShort_t det=1 ; det <= 3; det++) {
289     std::cout << "FMD" << det << std::endl;
290     Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'), '\0' };
291     for (Char_t* ring = rings; *ring != '\0'; ring++) {
292       std::cout << " Ring " << *ring << std::endl;
293       UShort_t nSec = ( *ring == 'I' ? 20  :  40 );
294       UShort_t nStr = ( *ring == 'I' ? 512 : 256 );
295       for (UShort_t sec = 0; sec < nSec; sec++) {
296         UShort_t min  = GetMinStrip(det, *ring, sec, 0);
297         UShort_t max  = GetMaxStrip(det, *ring, sec, 0);
298         UShort_t rate = GetSampleRate(det, *ring, sec, 0);
299         std::cout << "  Sector " << std::setw(2) << sec 
300                   << "  Strip range: " << std::setw(3) << min << "," 
301                   << std::setw(3) << max << "  Rate: " << std::setw(2) 
302                   << rate << std::endl;
303         if (!showStrips) continue;
304         std::cout 
305           << "  Strip |     Pedestal      |    Gain    | ZS thr. | Address\n" 
306           << "--------+-------------------+------------+---------+---------" 
307           << std::endl;
308         for (UShort_t str = 0; str < nStr; str++) {
309           std::cout << "    " << std::setw(3) << str << " | ";
310           if (IsDead(det, *ring, sec, str)) {
311             std::cout << "dead" << std::endl;
312             continue;
313           }
314           UInt_t ddl, addr;
315           Detector2Hardware(det, *ring, sec, str, ddl, addr);
316           std::cout << std::setw(7) << GetPedestal(det, *ring, sec, str) 
317                     << "+/-" << std::setw(7) 
318                     << GetPedestalWidth(det, *ring, sec, str) 
319                     << " | " << std::setw(10) 
320                     << GetPulseGain(det, *ring, sec, str) 
321                     << " | " << std::setw(5) 
322                     << GetZeroSuppression(det, *ring, sec, str) 
323                     << " | 0x" << std::hex << std::setw(4) 
324                     << std::setfill('0') << ddl << ",0x" << std::setw(3) 
325                     << addr << std::dec << std::setfill(' ') << std::endl;
326         }
327       }
328     }
329   }
330 }
331
332 //__________________________________________________________________
333 void
334 AliFMDParameters::SetStripRange(UShort_t min, UShort_t max) 
335 {
336   // Set fixed strip range 
337   fFixedMinStrip = min;
338   fFixedMaxStrip = max;
339 }
340
341 //__________________________________________________________________
342 void
343 AliFMDParameters::InitPulseGain()
344 {
345   // Get pulse gain from CDB or used fixed 
346   AliCDBManager* cdb      = AliCDBManager::Instance();
347   AliCDBEntry*   gain     = cdb->Get(fgkPulseGain);
348   if (!gain) {
349     AliWarning(Form("No %s found in CDB, perhaps you need to "
350                     "use AliFMDCalibFaker?", fgkPulseGain));
351     return;
352   }
353   
354   AliDebug(1, Form("Got gain from CDB"));
355   fPulseGain = dynamic_cast<AliFMDCalibGain*>(gain->GetObject());
356   if (!fPulseGain) AliWarning("Invalid pulser gain object from CDB");
357 }
358 //__________________________________________________________________
359 void
360 AliFMDParameters::InitPedestal()
361 {
362   // Initialize the pedestals from CDB 
363   AliCDBManager* cdb      = AliCDBManager::Instance();
364   AliCDBEntry*   pedestal = cdb->Get(fgkPedestal);
365   if (!pedestal) {
366     AliWarning(Form("No %s found in CDB, perhaps you need to "
367                     "use AliFMDCalibFaker?", fgkPedestal));
368     return;
369   }
370   AliDebug(1, Form("Got pedestal from CDB"));
371   fPedestal = dynamic_cast<AliFMDCalibPedestal*>(pedestal->GetObject());
372   if (!fPedestal) AliWarning("Invalid pedestal object from CDB");
373 }
374
375 //__________________________________________________________________
376 void
377 AliFMDParameters::InitDeadMap()
378 {
379   // Get Dead-channel-map from CDB 
380   AliCDBManager* cdb      = AliCDBManager::Instance();
381   AliCDBEntry*   deadMap  = cdb->Get(fgkDead);
382   if (!deadMap) {
383     AliWarning(Form("No %s found in CDB, perhaps you need to "
384                     "use AliFMDCalibFaker?", fgkDead));
385     return;
386   }
387   AliDebug(1, Form("Got dead map from CDB"));
388   fDeadMap = dynamic_cast<AliFMDCalibDeadMap*>(deadMap->GetObject());
389   if (!fDeadMap) AliWarning("Invalid dead map object from CDB");
390 }
391
392 //__________________________________________________________________
393 void
394 AliFMDParameters::InitZeroSuppression()
395 {
396   // Get 0-suppression from CDB 
397   AliCDBManager* cdb      = AliCDBManager::Instance();
398   AliCDBEntry*   zeroSup  = cdb->Get(fgkZeroSuppression);
399   if (!zeroSup) {
400     AliWarning(Form("No %s found in CDB, perhaps you need to "
401                     "use AliFMDCalibFaker?", fgkZeroSuppression));
402     return;
403   }
404   AliDebug(1, Form("Got zero suppression from CDB"));
405   fZeroSuppression = 
406     dynamic_cast<AliFMDCalibZeroSuppression*>(zeroSup->GetObject());
407   if (!fZeroSuppression)AliWarning("Invalid zero suppression object from CDB");
408 }
409
410 //__________________________________________________________________
411 void
412 AliFMDParameters::InitSampleRate()
413 {
414   // get Sample rate from CDB
415   AliCDBManager* cdb      = AliCDBManager::Instance();
416   AliCDBEntry*   sampRat  = cdb->Get(fgkSampleRate);
417   if (!sampRat) {
418     AliWarning(Form("No %s found in CDB, perhaps you need to "
419                     "use AliFMDCalibFaker?", fgkSampleRate));
420     return;
421   }
422   AliDebug(1, Form("Got zero suppression from CDB"));
423   fSampleRate = dynamic_cast<AliFMDCalibSampleRate*>(sampRat->GetObject());
424   if (!fSampleRate) AliWarning("Invalid zero suppression object from CDB");
425 }
426
427 //__________________________________________________________________
428 void
429 AliFMDParameters::InitAltroMap()
430 {
431   // Get hardware mapping from CDB
432   AliCDBManager* cdb      = AliCDBManager::Instance();
433   AliCDBEntry*   hwMap    = cdb->Get(fgkAltroMap);       
434   if (!hwMap) {
435     AliWarning(Form("No %s found in CDB, perhaps you need to "
436                     "use AliFMDCalibFaker?", fgkAltroMap));
437     fAltroMap = new AliFMDAltroMapping;
438     return;
439   }
440   AliDebug(1, Form("Got ALTRO map from CDB"));
441   fAltroMap = dynamic_cast<AliFMDAltroMapping*>(hwMap->GetObject());
442   if (!fAltroMap) {
443     AliWarning("Invalid ALTRO map object from CDB");
444     fAltroMap = new AliFMDAltroMapping;
445   }
446 }
447
448 //__________________________________________________________________
449 void
450 AliFMDParameters::InitStripRange()
451 {
452   // Get strips read-out from CDB
453   AliCDBManager* cdb      = AliCDBManager::Instance();
454   AliCDBEntry*   range    = cdb->Get(fgkStripRange);
455   if (!range) {
456     AliWarning(Form("No %s found in CDB, perhaps you need to "
457                     "use AliFMDCalibFaker?", fgkStripRange));
458     return;
459   }
460   AliDebug(1, Form("Got strip range from CDB"));
461   fStripRange = dynamic_cast<AliFMDCalibStripRange*>(range->GetObject());
462   if (!fStripRange) AliWarning("Invalid strip range object from CDB");
463 }
464
465
466 //__________________________________________________________________
467 Float_t
468 AliFMDParameters::GetThreshold() const
469 {
470   // Get threshold from CDB
471   if (!fPulseGain) return fFixedThreshold;
472   return fPulseGain->Threshold();
473 }
474
475 //__________________________________________________________________
476 Float_t
477 AliFMDParameters::GetPulseGain(UShort_t detector, Char_t ring, 
478                                UShort_t sector, UShort_t strip) const
479 {
480   // Returns the pulser calibrated gain for strip # strip in sector #
481   // sector or ring id ring of detector # detector. 
482   // 
483   // For simulation, this is normally set to 
484   // 
485   //       VA1_MIP_Range 
486   //    ------------------ * MIP_Energy_Loss
487   //    ALTRO_channel_size
488   // 
489   if (!fPulseGain) { 
490     if (fFixedPulseGain <= 0)
491       fFixedPulseGain = fVA1MipRange * GetEdepMip() / fAltroChannelSize;
492     return fFixedPulseGain;
493   }  
494   AliDebug(50, Form("pulse gain for FMD%d%c[%2d,%3d]=%f",
495                     detector, ring, sector, strip,
496                     fPulseGain->Value(detector, ring, sector, strip)));
497   return fPulseGain->Value(detector, ring, sector, strip);
498 }
499
500 //__________________________________________________________________
501 Bool_t
502 AliFMDParameters::IsDead(UShort_t detector, Char_t ring, 
503                          UShort_t sector, UShort_t strip) const
504 {
505   // Check if the channel is dead 
506   if (!fDeadMap) return kFALSE;
507   AliDebug(50, Form("Dead for FMD%d%c[%2d,%3d]=%s",
508                     detector, ring, sector, strip,
509                     fDeadMap->operator()(detector, ring, sector, strip) ? 
510                     "no" : "yes"));
511   return fDeadMap->operator()(detector, ring, sector, strip);
512 }
513
514 //__________________________________________________________________
515 UShort_t
516 AliFMDParameters::GetZeroSuppression(UShort_t detector, Char_t ring, 
517                                      UShort_t sector, UShort_t strip) const
518 {
519   // Get zero suppression threshold 
520   if (!fZeroSuppression) return fFixedZeroSuppression;
521   // Need to map strip to ALTRO chip. 
522   AliDebug(50, Form("zero sup. for FMD%d%c[%2d,%3d]=%f",
523                     detector, ring, sector, strip,
524                     fZeroSuppression->operator()(detector, ring, 
525                                                  sector, strip)));
526   return fZeroSuppression->operator()(detector, ring, sector, strip/128);
527 }
528
529 //__________________________________________________________________
530 UShort_t
531 AliFMDParameters::GetSampleRate(UShort_t det, Char_t ring, UShort_t sector, 
532                                 UShort_t str) const
533 {
534   // Get sampl rate 
535   if (!fSampleRate) return fFixedSampleRate;
536   // Need to map sector to digitizier card. 
537   UInt_t ret = fSampleRate->Rate(det, ring, sector, str);
538   AliDebug(50, Form("Sample rate for FMD%d%c[%2d,%3d]=%d", 
539                     det, ring, sector, str, ret));
540   return ret;
541 }
542
543 //__________________________________________________________________
544 UShort_t
545 AliFMDParameters::GetMinStrip(UShort_t det, Char_t ring, UShort_t sector, 
546                               UShort_t str) const
547 {
548   // Get strip range read out 
549   if (!fStripRange) return fFixedMinStrip;
550   // Need to map sector to digitizier card. 
551   UInt_t ret = fStripRange->Min(det, ring, sector, str);
552   AliDebug(50, Form("Min strip # for FMD%d%c[%2d,%3d]=%d", 
553                     det, ring, sector, str, ret));
554   return ret;
555 }
556
557 //__________________________________________________________________
558 UShort_t
559 AliFMDParameters::GetMaxStrip(UShort_t det, Char_t ring, UShort_t sector, 
560                               UShort_t str) const
561 {
562   // Get strip range read out 
563   if (!fStripRange) return fFixedMaxStrip;
564   // Need to map sector to digitizier card. 
565   UInt_t ret = fStripRange->Max(det, ring, sector, str);
566   AliDebug(50, Form("Max strip # for FMD%d%c[%2d,%3d]=%d", 
567                     det, ring, sector, str, ret));
568   return ret;
569 }
570
571 //__________________________________________________________________
572 Float_t
573 AliFMDParameters::GetPedestal(UShort_t detector, Char_t ring, 
574                               UShort_t sector, UShort_t strip) const
575 {
576   // Get the pedesal 
577   if (!fPedestal) return fFixedPedestal;
578   AliDebug(50, Form("pedestal for FMD%d%c[%2d,%3d]=%f",
579                     detector, ring, sector, strip,
580                     fPedestal->Value(detector, ring, sector, strip)));
581   return fPedestal->Value(detector, ring, sector, strip);
582 }
583
584 //__________________________________________________________________
585 Float_t
586 AliFMDParameters::GetPedestalWidth(UShort_t detector, Char_t ring, 
587                                    UShort_t sector, UShort_t strip) const
588 {
589   // Get the pedesal 
590   if (!fPedestal) return fFixedPedestalWidth;
591   AliDebug(50, Form("pedetal width for FMD%d%c[%2d,%3d]=%f",
592                     detector, ring, sector, strip,
593                     fPedestal->Width(detector, ring, sector, strip)));
594   return fPedestal->Width(detector, ring, sector, strip);
595 }
596   
597 //__________________________________________________________________
598 AliFMDAltroMapping*
599 AliFMDParameters::GetAltroMap() const
600 {
601   // Get the hardware address to detector index map 
602   return fAltroMap;
603 }
604
605
606 //__________________________________________________________________
607 Bool_t
608 AliFMDParameters::Hardware2Detector(UInt_t ddl, UInt_t addr, UShort_t& det,
609                                     Char_t& ring, UShort_t& sec, 
610                                     UShort_t& str) const
611 {
612   // Map hardware address to detector index
613   if (!fAltroMap) return kFALSE;
614   return fAltroMap->Hardware2Detector(ddl, addr, det, ring, sec, str);
615 }
616
617 //__________________________________________________________________
618 Bool_t
619 AliFMDParameters::Detector2Hardware(UShort_t det, Char_t ring, UShort_t sec, 
620                                     UShort_t str, UInt_t& ddl, 
621                                     UInt_t& addr) const                       
622 {
623   // Map detector index to hardware address
624   if (!fAltroMap) return kFALSE;
625   return fAltroMap->Detector2Hardware(det, ring, sec, str, ddl, addr);
626 }
627
628
629 //__________________________________________________________________
630 Float_t
631 AliFMDParameters::GetEdepMip() const 
632
633   // Get energy deposited by a MIP in the silicon sensors
634   if (fEdepMip <= 0){
635     AliFMDGeometry* fmd = AliFMDGeometry::Instance();
636     fEdepMip = (fkSiDeDxMip 
637                 * fmd->GetRing('I')->GetSiThickness() 
638                 * fmd->GetSiDensity());
639   }
640   return fEdepMip;
641 }
642
643
644   
645   
646   
647 //____________________________________________________________________
648 //
649 // EOF
650 //