Updated reconstruction to (optionally) make angle correction.
[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(Bool_t forceReInit)
117 {
118   // Initialize the parameters manager.  We need to get stuff from the
119   // CDB here. 
120   if (forceReInit) fIsInit = kFALSE;
121   if (fIsInit) return;
122   InitPulseGain();
123   InitPedestal();
124   InitDeadMap();
125   InitSampleRate();
126   InitZeroSuppression();
127   InitAltroMap();
128   fIsInit = kTRUE;
129   
130 }
131
132 //__________________________________________________________________
133 #define DET2IDX(det,ring,sec,str) \
134   (det * 1000 + (ring == 'I' ? 0 : 512) + str)  
135   
136 //__________________________________________________________________
137 void
138 AliFMDParameters::Draw(Option_t* option)
139 {
140   TString opt(option);
141   enum {
142     kPulseGain,       // Path to PulseGain calib object
143     kThreshold,       // Path to PulseGain calib object
144     kPedestal,        // Path to Pedestal calib object
145     kPedestalWidth,   // Path to Pedestal calib object
146     kDead,            // Path to Dead calib object
147     kSampleRate,      // Path to SampleRate calib object
148     kAltroMap,        // Path to AltroMap calib object
149     kZeroSuppression, // Path to ZeroSuppression cal object
150     kMinStripRange,   // Path to strip range cal object
151     kMaxStripRange    // Path to strip range cal object
152   } what;
153   
154     
155   if      (opt.Contains("dead", TString::kIgnoreCase)) 
156     what = kDead;
157   else if (opt.Contains("threshold",TString::kIgnoreCase)) 
158     what = kThreshold;
159   else if (opt.Contains("gain",TString::kIgnoreCase)) 
160     what = kPulseGain;
161   else if (opt.Contains("pedestal",TString::kIgnoreCase)) 
162     what = kPedestal;
163   else if (opt.Contains("noise",TString::kIgnoreCase)) 
164     what = kPedestalWidth;
165   else if (opt.Contains("zero",TString::kIgnoreCase)) 
166     what = kZeroSuppression;
167   else if (opt.Contains("rate",TString::kIgnoreCase)) 
168     what = kSampleRate;
169   else if (opt.Contains("min",TString::kIgnoreCase)) 
170     what = kMinStripRange;
171   else if (opt.Contains("max",TString::kIgnoreCase)) 
172     what = kMaxStripRange;
173   else if (opt.Contains("map",TString::kIgnoreCase)) 
174     what = kAltroMap;
175   else {
176     Warning("Draw", "unknown parameter: %s\n\tShould be one of\n\t"
177             "dead, threshold, gain, pedestal, noise, zero, rate, "
178             "min, max, map",  
179             option); 
180     return;
181   }
182
183   TArrayD xbins(3 * 512 + 2 * 256 + 5);
184   Int_t i = 1;
185   Bool_t skip = kTRUE;
186   for (UShort_t det = 1; det <= 3; det++) {
187     UShort_t nRings = (det == 1 ? 1 : 2);
188     for (UShort_t iring = 0; iring < nRings; iring++) {
189       UShort_t nStrip  = (iring == 0 ? 512 : 256);
190       Char_t   ring    = (iring == 0 ? 'I' : 'O');
191       for (UShort_t str = 0; str < nStrip; str++) {
192         // UShort_t nSec    = (iring == 0 ? 20  : 40);
193         // Char_t   ring    = (iring == 0 ? 'I' : 'O');
194         // for (UShort_t sec = 0; sec < nSec; sec++) {
195         Int_t idx = DET2IDX(det, ring, 0, str);
196         // Int_t idx = DET2IDX(det, ring, sec, 0);
197         if (skip) {
198           xbins[i-1] = idx - .5;
199           skip  = kFALSE;
200         }
201         xbins[i] = idx + .5;
202         i++;
203       }
204       skip = kTRUE;
205       i++;
206     }
207   }
208   TArrayD ybins(41);
209   for (Int_t i = 0; i < ybins.fN; i++) ybins[i] = Float_t(i - .5);
210   TH2D* hist = new TH2D("calib", Form("Calibration %s", option), 
211                         xbins.fN-1, xbins.fArray,  
212                         ybins.fN-1, ybins.fArray);
213   hist->GetXaxis()->SetTitle("1000 #times detector + 512 #times ring + strip");
214   hist->GetYaxis()->SetTitle("sector");
215   
216   // hist->Draw("Lego");
217   // return;
218   
219   for (UShort_t det = 1; det <= 3; det++) {
220     UShort_t nRings = (det == 1 ? 1 : 2);
221     for (UShort_t iring = 0; iring < nRings; iring++) {
222       UShort_t nSector = (iring == 0 ?  20 : 40);
223       UShort_t nStrip  = (iring == 0 ? 512 : 256);
224       Char_t   ring    = (iring == 0 ? 'I' : 'O');
225       for (UShort_t sec = 0; sec < nSector; sec++) {
226         for (UShort_t str = 0; str < nStrip; str++) {
227           Int_t idx = DET2IDX(det, ring, sec, str);
228           UInt_t ddl, addr;
229           Double_t val = 0;
230           switch (what) {
231           case kPulseGain:       // Path to PulseGain calib object
232             val = GetPulseGain(det,ring,sec,str); break;
233           case kThreshold:       // Path to PulseGain calib object
234             val = GetThreshold(); break;
235           case kPedestal:        // Path to Pedestal calib object
236             val = GetPedestal(det,ring,sec,str); break;
237           case kPedestalWidth:   // Path to Pedestal calib object
238             val = GetPedestalWidth(det,ring,sec,str); break;
239           case kDead:            // Path to Dead calib object
240             val = IsDead(det,ring,sec,str); break;
241           case kSampleRate:      // Path to SampleRate calib object
242             val = GetSampleRate(det,ring,sec,str); break;
243           case kAltroMap:        // Path to AltroMap calib object
244             Detector2Hardware(det,ring,sec,str, ddl, addr); 
245             val = addr; break;
246           case kZeroSuppression: // Path to ZeroSuppression cal object
247             val = GetZeroSuppression(det,ring,sec,str); break;
248           case kMinStripRange:   // Path to strip range cal object
249             val = GetMinStrip(det,ring,sec,str); break;
250           case kMaxStripRange:    // Path to strip range cal object
251             val = GetMaxStrip(det,ring,sec,str); break;
252           }
253           hist->Fill(idx,sec,val);
254           // hist->Fill(idx,str,val);
255         }
256       }
257     }
258   }
259   hist->Draw("lego");
260 }
261
262 //__________________________________________________________________
263 void
264 AliFMDParameters::Print(Option_t* option) const
265 {
266   // Print information. 
267   // If option contains an 'A' then everything is printed. 
268   // If the option contains the string "FMD" the function will search 
269   // for detector, ring, sector, and strip numbers to print, in the
270   // format 
271   // 
272   //    FMD<detector><ring>[<sector>,<string>] 
273   // 
274   // The wild card '*' means all of <detector>, <ring>, <sector>, or 
275   // <strip>. 
276   TString opt(option);
277   Bool_t showStrips  = opt.Contains("a", TString::kIgnoreCase);
278   UShort_t ds[]      = { 1, 2, 3, 0 };
279   Char_t   rs[]      = { 'I', 'O', '\0' };
280   UShort_t minStrip  = 0;
281   UShort_t maxStrip  = 512;
282   UShort_t minSector = 0;
283   UShort_t maxSector = 40;
284   
285   
286   if (opt.Contains("fmd",TString::kIgnoreCase)) {
287     showStrips    = kTRUE;
288     size_t   i    = opt.Index("fmd",TString::kIgnoreCase);
289     size_t   j    = opt.Index("]",TString::kIgnoreCase);
290     enum {
291       read_det, 
292       read_ring, 
293       read_lbrack,
294       read_sector,
295       read_comma,
296       read_strip,
297       read_rbrack, 
298       end
299     } state = read_det;
300     std::stringstream s(opt(i+4, j-i-3).Data());
301     while (state != end) {
302       Char_t tmp = s.peek();
303       if (tmp == ' ' || tmp == '\t') {
304         s.get();
305         continue;
306       }
307       switch (state) {
308       case read_det: { // First, try to read the detector 
309         if (tmp == '*') s.get();
310         else { 
311           UShort_t det;
312           s >> det;
313           if (!s.bad()) {
314             ds[0] = det;
315             ds[1] = 0;
316           }
317         }
318         state = (s.bad() ? end : read_ring);
319       } break;
320       case read_ring: { // Then try to read the ring;
321         Char_t ring;
322         s >> ring;
323         if (ring != '*' && !s.bad()) {
324           rs[0] = ring;
325           rs[1] = '\0';
326         }
327         state = (s.bad() ? end : read_lbrack);
328       } break;
329       case read_lbrack: { // Try to read a left bracket 
330         Char_t lbrack;
331         s >> lbrack;
332         state = (s.bad() ? end : read_sector);
333       } break;
334       case read_sector: { // Try to read a sector 
335         if (tmp == '*') s.get();
336         else {
337           UShort_t sec;
338           s >> sec;
339           if (!s.bad()) {
340             minSector = sec;
341             maxSector = sec + 1;
342           }
343         }
344         state = (s.bad() ? end : read_comma);
345       } break;
346       case read_comma: { // Try to read a left bracket 
347         Char_t comma;
348         s >> comma;
349         state = (s.bad() ? end : read_strip);
350       } break;
351       case read_strip: { // Try to read a strip 
352         if (tmp == '*') s.get();
353         else {
354           UShort_t str;
355           s >> str;
356           if (!s.bad()) {
357             minStrip = str;
358             maxStrip = str + 1;
359           }
360         }
361         state = (s.bad() ? end : read_rbrack);
362       } break;
363       case read_rbrack: { // Try to read a left bracket 
364         Char_t rbrack;
365         s >> rbrack;
366         state = end;
367       } break;
368       case end: 
369         break;
370       }
371     }
372   }
373   UShort_t* dp = ds;
374   UShort_t  det;
375   while ((det = *(dp++))) {
376
377     Char_t* rp = rs;
378     Char_t  ring;
379     while ((ring = *(rp++))) {
380       if (det == 1 && ring == 'O') continue;
381       UShort_t min  = GetMinStrip(det, ring, 0, 0);
382       UShort_t max  = GetMaxStrip(det, ring, 0, 0);
383       UShort_t rate = GetSampleRate(det, ring, 0, 0);
384       std::cout << "FMD" << det << ring 
385                 << "  Strip range: " 
386                 << std::setw(3) << min << "," 
387                 << std::setw(3) << max << "  Rate: " 
388                 << std::setw(2) << rate << std::endl;
389
390       if (!showStrips) continue;
391       UShort_t nSec = ( ring == 'I' ? 20  :  40 );
392       UShort_t nStr = ( ring == 'I' ? 512 : 256 );
393       for (UShort_t sec = minSector; sec < maxSector && sec < nSec; sec++) {
394         std::cout 
395           << "  Strip |     Pedestal      |    Gain    | ZS thr. | Address\n" 
396           << "--------+-------------------+------------+---------+---------" 
397           << std::endl;
398         for (UShort_t str = minStrip; str < nStr && str < maxStrip; str++) {
399           if (str == minStrip) std::cout << std::setw(3) << sec << ",";
400           else std::cout << "    ";
401           std::cout << std::setw(3) << str << " | ";
402           if (IsDead(det, ring, sec, str)) {
403             std::cout << "dead" << std::endl;
404             continue;
405           }
406           UInt_t ddl, addr;
407           Detector2Hardware(det, ring, sec, str, ddl, addr);
408           std::cout << std::setw(7) << GetPedestal(det, ring, sec, str) 
409                     << "+/-" << std::setw(7) 
410                     << GetPedestalWidth(det, ring, sec, str) 
411                     << " | " << std::setw(10) 
412                     << GetPulseGain(det, ring, sec, str) 
413                     << " | " << std::setw(7) 
414                     << GetZeroSuppression(det, ring, sec, str) 
415                     << " | 0x" << std::hex << std::setw(4) 
416                     << std::setfill('0') << ddl << ",0x" << std::setw(3) 
417                     << addr << std::dec << std::setfill(' ') << std::endl;
418         } // for (strip)
419       } // for (sector)
420       std::cout
421         << "=============================================================" 
422         << std::endl;
423     } // while (ring)
424   } // while (det)
425   
426 }
427
428 //__________________________________________________________________
429 void
430 AliFMDParameters::SetStripRange(UShort_t min, UShort_t max) 
431 {
432   // Set fixed strip range 
433   fFixedMinStrip = min;
434   fFixedMaxStrip = max;
435 }
436
437 //__________________________________________________________________
438 void
439 AliFMDParameters::InitPulseGain()
440 {
441   // Get pulse gain from CDB or used fixed 
442   AliCDBManager* cdb      = AliCDBManager::Instance();
443   AliCDBEntry*   gain     = cdb->Get(fgkPulseGain);
444   if (!gain) {
445     AliWarning(Form("No %s found in CDB, perhaps you need to "
446                     "use AliFMDCalibFaker?", fgkPulseGain));
447     return;
448   }
449   
450   AliDebug(1, Form("Got gain from CDB"));
451   fPulseGain = dynamic_cast<AliFMDCalibGain*>(gain->GetObject());
452   if (!fPulseGain) AliWarning("Invalid pulser gain object from CDB");
453 }
454 //__________________________________________________________________
455 void
456 AliFMDParameters::InitPedestal()
457 {
458   // Initialize the pedestals from CDB 
459   AliCDBManager* cdb      = AliCDBManager::Instance();
460   AliCDBEntry*   pedestal = cdb->Get(fgkPedestal);
461   if (!pedestal) {
462     AliWarning(Form("No %s found in CDB, perhaps you need to "
463                     "use AliFMDCalibFaker?", fgkPedestal));
464     return;
465   }
466   AliDebug(1, Form("Got pedestal from CDB"));
467   fPedestal = dynamic_cast<AliFMDCalibPedestal*>(pedestal->GetObject());
468   if (!fPedestal) AliWarning("Invalid pedestal object from CDB");
469 }
470
471 //__________________________________________________________________
472 void
473 AliFMDParameters::InitDeadMap()
474 {
475   // Get Dead-channel-map from CDB 
476   AliCDBManager* cdb      = AliCDBManager::Instance();
477   AliCDBEntry*   deadMap  = cdb->Get(fgkDead);
478   if (!deadMap) {
479     AliWarning(Form("No %s found in CDB, perhaps you need to "
480                     "use AliFMDCalibFaker?", fgkDead));
481     return;
482   }
483   AliDebug(1, Form("Got dead map from CDB"));
484   fDeadMap = dynamic_cast<AliFMDCalibDeadMap*>(deadMap->GetObject());
485   if (!fDeadMap) AliWarning("Invalid dead map object from CDB");
486 }
487
488 //__________________________________________________________________
489 void
490 AliFMDParameters::InitZeroSuppression()
491 {
492   // Get 0-suppression from CDB 
493   AliCDBManager* cdb      = AliCDBManager::Instance();
494   AliCDBEntry*   zeroSup  = cdb->Get(fgkZeroSuppression);
495   if (!zeroSup) {
496     AliWarning(Form("No %s found in CDB, perhaps you need to "
497                     "use AliFMDCalibFaker?", fgkZeroSuppression));
498     return;
499   }
500   AliDebug(1, Form("Got zero suppression from CDB"));
501   fZeroSuppression = 
502     dynamic_cast<AliFMDCalibZeroSuppression*>(zeroSup->GetObject());
503   if (!fZeroSuppression)AliWarning("Invalid zero suppression object from CDB");
504 }
505
506 //__________________________________________________________________
507 void
508 AliFMDParameters::InitSampleRate()
509 {
510   // get Sample rate from CDB
511   AliCDBManager* cdb      = AliCDBManager::Instance();
512   AliCDBEntry*   sampRat  = cdb->Get(fgkSampleRate);
513   if (!sampRat) {
514     AliWarning(Form("No %s found in CDB, perhaps you need to "
515                     "use AliFMDCalibFaker?", fgkSampleRate));
516     return;
517   }
518   AliDebug(1, Form("Got zero suppression from CDB"));
519   fSampleRate = dynamic_cast<AliFMDCalibSampleRate*>(sampRat->GetObject());
520   if (!fSampleRate) AliWarning("Invalid zero suppression object from CDB");
521 }
522
523 //__________________________________________________________________
524 void
525 AliFMDParameters::InitAltroMap()
526 {
527   // Get hardware mapping from CDB
528   AliCDBManager* cdb      = AliCDBManager::Instance();
529   AliCDBEntry*   hwMap    = cdb->Get(fgkAltroMap);       
530   if (!hwMap) {
531     AliWarning(Form("No %s found in CDB, perhaps you need to "
532                     "use AliFMDCalibFaker?", fgkAltroMap));
533     fAltroMap = new AliFMDAltroMapping;
534     return;
535   }
536   AliDebug(1, Form("Got ALTRO map from CDB"));
537   fAltroMap = dynamic_cast<AliFMDAltroMapping*>(hwMap->GetObject());
538   if (!fAltroMap) {
539     AliWarning("Invalid ALTRO map object from CDB");
540     fAltroMap = new AliFMDAltroMapping;
541   }
542 }
543
544 //__________________________________________________________________
545 void
546 AliFMDParameters::InitStripRange()
547 {
548   // Get strips read-out from CDB
549   AliCDBManager* cdb      = AliCDBManager::Instance();
550   AliCDBEntry*   range    = cdb->Get(fgkStripRange);
551   if (!range) {
552     AliWarning(Form("No %s found in CDB, perhaps you need to "
553                     "use AliFMDCalibFaker?", fgkStripRange));
554     return;
555   }
556   AliDebug(1, Form("Got strip range from CDB"));
557   fStripRange = dynamic_cast<AliFMDCalibStripRange*>(range->GetObject());
558   if (!fStripRange) AliWarning("Invalid strip range object from CDB");
559 }
560
561
562 //__________________________________________________________________
563 Float_t
564 AliFMDParameters::GetThreshold() const
565 {
566   // Get threshold from CDB
567   if (!fPulseGain) return fFixedThreshold;
568   return fPulseGain->Threshold();
569 }
570
571 //__________________________________________________________________
572 Float_t
573 AliFMDParameters::GetPulseGain(UShort_t detector, Char_t ring, 
574                                UShort_t sector, UShort_t strip) const
575 {
576   // Returns the pulser calibrated gain for strip # strip in sector #
577   // sector or ring id ring of detector # detector. 
578   // 
579   // For simulation, this is normally set to 
580   // 
581   //       VA1_MIP_Range 
582   //    ------------------ * MIP_Energy_Loss
583   //    ALTRO_channel_size
584   // 
585   if (!fPulseGain) { 
586     if (fFixedPulseGain <= 0)
587       fFixedPulseGain = fVA1MipRange * GetEdepMip() / fAltroChannelSize;
588     return fFixedPulseGain;
589   }  
590   AliDebug(50, Form("pulse gain for FMD%d%c[%2d,%3d]=%f",
591                     detector, ring, sector, strip,
592                     fPulseGain->Value(detector, ring, sector, strip)));
593   return fPulseGain->Value(detector, ring, sector, strip);
594 }
595
596 //__________________________________________________________________
597 Bool_t
598 AliFMDParameters::IsDead(UShort_t detector, Char_t ring, 
599                          UShort_t sector, UShort_t strip) const
600 {
601   // Check if the channel is dead 
602   if (!fDeadMap) return kFALSE;
603   AliDebug(50, Form("Dead for FMD%d%c[%2d,%3d]=%s",
604                     detector, ring, sector, strip,
605                     fDeadMap->operator()(detector, ring, sector, strip) ? 
606                     "no" : "yes"));
607   return fDeadMap->operator()(detector, ring, sector, strip);
608 }
609
610 //__________________________________________________________________
611 UShort_t
612 AliFMDParameters::GetZeroSuppression(UShort_t detector, Char_t ring, 
613                                      UShort_t sector, UShort_t strip) const
614 {
615   // Get zero suppression threshold 
616   if (!fZeroSuppression) return fFixedZeroSuppression;
617   // Need to map strip to ALTRO chip. 
618   AliDebug(50, Form("zero sup. for FMD%d%c[%2d,%3d]=%f",
619                     detector, ring, sector, strip,
620                     fZeroSuppression->operator()(detector, ring, 
621                                                  sector, strip)));
622   return fZeroSuppression->operator()(detector, ring, sector, strip/128);
623 }
624
625 //__________________________________________________________________
626 UShort_t
627 AliFMDParameters::GetSampleRate(UShort_t det, Char_t ring, UShort_t sector, 
628                                 UShort_t str) const
629 {
630   // Get sampl rate 
631   if (!fSampleRate) return fFixedSampleRate;
632   // Need to map sector to digitizier card. 
633   UInt_t ret = fSampleRate->Rate(det, ring, sector, str);
634   AliDebug(50, Form("Sample rate for FMD%d%c[%2d,%3d]=%d", 
635                     det, ring, sector, str, ret));
636   return ret;
637 }
638
639 //__________________________________________________________________
640 UShort_t
641 AliFMDParameters::GetMinStrip(UShort_t det, Char_t ring, UShort_t sector, 
642                               UShort_t str) const
643 {
644   // Get strip range read out 
645   if (!fStripRange) return fFixedMinStrip;
646   // Need to map sector to digitizier card. 
647   UInt_t ret = fStripRange->Min(det, ring, sector, str);
648   AliDebug(50, Form("Min strip # for FMD%d%c[%2d,%3d]=%d", 
649                     det, ring, sector, str, ret));
650   return ret;
651 }
652
653 //__________________________________________________________________
654 UShort_t
655 AliFMDParameters::GetMaxStrip(UShort_t det, Char_t ring, UShort_t sector, 
656                               UShort_t str) const
657 {
658   // Get strip range read out 
659   if (!fStripRange) return fFixedMaxStrip;
660   // Need to map sector to digitizier card. 
661   UInt_t ret = fStripRange->Max(det, ring, sector, str);
662   AliDebug(50, Form("Max strip # for FMD%d%c[%2d,%3d]=%d", 
663                     det, ring, sector, str, ret));
664   return ret;
665 }
666
667 //__________________________________________________________________
668 Float_t
669 AliFMDParameters::GetPedestal(UShort_t detector, Char_t ring, 
670                               UShort_t sector, UShort_t strip) const
671 {
672   // Get the pedesal 
673   if (!fPedestal) return fFixedPedestal;
674   AliDebug(50, Form("pedestal for FMD%d%c[%2d,%3d]=%f",
675                     detector, ring, sector, strip,
676                     fPedestal->Value(detector, ring, sector, strip)));
677   return fPedestal->Value(detector, ring, sector, strip);
678 }
679
680 //__________________________________________________________________
681 Float_t
682 AliFMDParameters::GetPedestalWidth(UShort_t detector, Char_t ring, 
683                                    UShort_t sector, UShort_t strip) const
684 {
685   // Get the pedesal 
686   if (!fPedestal) return fFixedPedestalWidth;
687   AliDebug(50, Form("pedetal width for FMD%d%c[%2d,%3d]=%f",
688                     detector, ring, sector, strip,
689                     fPedestal->Width(detector, ring, sector, strip)));
690   return fPedestal->Width(detector, ring, sector, strip);
691 }
692   
693 //__________________________________________________________________
694 AliFMDAltroMapping*
695 AliFMDParameters::GetAltroMap() const
696 {
697   // Get the hardware address to detector index map 
698   return fAltroMap;
699 }
700
701
702 //__________________________________________________________________
703 Bool_t
704 AliFMDParameters::Hardware2Detector(UInt_t ddl, UInt_t addr, UShort_t& det,
705                                     Char_t& ring, UShort_t& sec, 
706                                     UShort_t& str) const
707 {
708   // Map hardware address to detector index
709   if (!fAltroMap) return kFALSE;
710   return fAltroMap->Hardware2Detector(ddl, addr, det, ring, sec, str);
711 }
712
713 //__________________________________________________________________
714 Bool_t
715 AliFMDParameters::Detector2Hardware(UShort_t det, Char_t ring, UShort_t sec, 
716                                     UShort_t str, UInt_t& ddl, 
717                                     UInt_t& addr) const                       
718 {
719   // Map detector index to hardware address
720   if (!fAltroMap) return kFALSE;
721   return fAltroMap->Detector2Hardware(det, ring, sec, str, ddl, addr);
722 }
723
724
725 //__________________________________________________________________
726 Float_t
727 AliFMDParameters::GetEdepMip() const 
728
729   // Get energy deposited by a MIP in the silicon sensors
730   if (fEdepMip <= 0){
731     AliFMDGeometry* fmd = AliFMDGeometry::Instance();
732     fEdepMip = (fkSiDeDxMip 
733                 * fmd->GetRing('I')->GetSiThickness() 
734                 * fmd->GetSiDensity());
735   }
736   return fEdepMip;
737 }
738
739
740   
741   
742   
743 //____________________________________________________________________
744 //
745 // EOF
746 //