Coding conventions (Christian)
[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 // Eventually, this class will use the Conditions DB to get the
28 // various parameters, which code can then request from here.
29 //                                                       
30 #include "AliLog.h"                // ALILOG_H
31 #include "AliFMDParameters.h"      // ALIFMDPARAMETERS_H
32 #include "AliFMDGeometry.h"        // ALIFMDGEOMETRY_H
33 #include "AliFMDRing.h"            // ALIFMDRING_H
34 #include "AliFMDCalibGain.h"       // ALIFMDCALIBGAIN_H
35 #include "AliFMDCalibPedestal.h"   // ALIFMDCALIBPEDESTAL_H
36 #include "AliFMDCalibSampleRate.h" // ALIFMDCALIBSAMPLERATE_H
37 #include "AliFMDCalibStripRange.h" // ALIFMDCALIBSTRIPRANGE_H
38 #include "AliFMDAltroMapping.h"    // ALIFMDALTROMAPPING_H
39 #include <AliCDBManager.h>         // ALICDBMANAGER_H
40 #include <AliCDBEntry.h>           // ALICDBMANAGER_H
41 #include <Riostream.h>
42
43 //====================================================================
44 ClassImp(AliFMDParameters)
45 #if 0
46   ; // This is here to keep Emacs for indenting the next line
47 #endif
48
49 //____________________________________________________________________
50 AliFMDParameters* AliFMDParameters::fgInstance = 0;
51
52 //____________________________________________________________________
53 const char* AliFMDParameters::fgkPulseGain       = "FMD/Calib/PulseGain";
54 const char* AliFMDParameters::fgkPedestal        = "FMD/Calib/Pedestal";
55 const char* AliFMDParameters::fgkDead            = "FMD/Calib/Dead";
56 const char* AliFMDParameters::fgkSampleRate      = "FMD/Calib/SampleRate";
57 const char* AliFMDParameters::fgkAltroMap        = "FMD/Calib/AltroMap";
58 const char* AliFMDParameters::fgkZeroSuppression = "FMD/Calib/ZeroSuppression";
59 const char* AliFMDParameters::fgkStripRange      = "FMD/Calib/StripRange";
60
61
62 //____________________________________________________________________
63 AliFMDParameters* 
64 AliFMDParameters::Instance() 
65 {
66   // Get static instance 
67   if (!fgInstance) fgInstance = new AliFMDParameters;
68   return fgInstance;
69 }
70
71 //____________________________________________________________________
72 AliFMDParameters::AliFMDParameters() 
73   : fIsInit(kFALSE),
74     fkSiDeDxMip(1.664), 
75     fFixedPulseGain(0), 
76     fEdepMip(0),
77     fZeroSuppression(0), 
78     fSampleRate(0), 
79     fPedestal(0), 
80     fPulseGain(0), 
81     fDeadMap(0), 
82     fAltroMap(0), 
83     fStripRange(0)
84 {
85   // Default constructor 
86   SetVA1MipRange();
87   SetAltroChannelSize();
88   SetChannelsPerAltro();
89   SetZeroSuppression();
90   SetSampleRate();
91   SetPedestal();
92   SetPedestalWidth();
93   SetPedestalFactor();
94   SetThreshold();
95   SetStripRange();
96 }
97
98 //__________________________________________________________________
99 void
100 AliFMDParameters::Init()
101 {
102   // Initialize the parameters manager.  We need to get stuff from the
103   // CDB here. 
104   if (fIsInit) return;
105   InitPulseGain();
106   InitPedestal();
107   InitDeadMap();
108   InitSampleRate();
109   InitZeroSuppression();
110   InitAltroMap();
111   fIsInit = kTRUE;
112   
113 }
114
115 //__________________________________________________________________
116 void
117 AliFMDParameters::Print(Option_t* option) const
118 {
119   // Print information. 
120   // If option contains an 'A' then everything is printed. 
121   TString opt(option);
122   Bool_t showStrips = opt.Contains("a", TString::kIgnoreCase);
123   for (UShort_t det=1 ; det <= 3; det++) {
124     std::cout << "FMD" << det << std::endl;
125     Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'), '\0' };
126     for (Char_t* ring = rings; *ring != '\0'; ring++) {
127       std::cout << " Ring " << *ring << std::endl;
128       UShort_t nSec = ( *ring == 'I' ? 20  :  40 );
129       UShort_t nStr = ( *ring == 'I' ? 512 : 256 );
130       for (UShort_t sec = 0; sec < nSec; sec++) {
131         UShort_t min  = GetMinStrip(det, *ring, sec, 0);
132         UShort_t max  = GetMaxStrip(det, *ring, sec, 0);
133         UShort_t rate = GetSampleRate(det, *ring, sec, 0);
134         std::cout << "  Sector " << std::setw(2) << sec 
135                   << "  Strip range: " << std::setw(3) << min << "," 
136                   << std::setw(3) << max << "  Rate: " << std::setw(2) 
137                   << rate << std::endl;
138         if (!showStrips) continue;
139         std::cout 
140           << "  Strip |     Pedestal      |   Gain   | ZS thr. | Address\n" 
141           << "--------+-------------------+----------+---------+---------" 
142           << std::endl;
143         for (UShort_t str = 0; str < nStr; str++) {
144           std::cout << "    " << std::setw(3) << str << " | ";
145           if (IsDead(det, *ring, sec, str)) {
146             std::cout << "dead" << std::endl;
147             continue;
148           }
149           UInt_t ddl, addr;
150           Detector2Hardware(det, *ring, sec, str, ddl, addr);
151           std::cout << std::setw(7) << GetPedestal(det, *ring, sec, str) 
152                     << "+/-" << std::setw(7) 
153                     << GetPedestalWidth(det, *ring, sec, str) 
154                     << " | " << std::setw(8) 
155                     << GetPulseGain(det, *ring, sec, str) 
156                     << " | " << std::setw(5) 
157                     << GetZeroSuppression(det, *ring, sec, str) 
158                     << " | 0x" << std::hex << std::setw(4) 
159                     << std::setfill('0') << ddl << ",0x" << std::setw(3) 
160                     << addr << std::dec << std::setfill(' ') << std::endl;
161         }
162       }
163     }
164   }
165 }
166
167 //__________________________________________________________________
168 void
169 AliFMDParameters::SetStripRange(UShort_t min, UShort_t max) 
170 {
171   // Set fixed strip range 
172   fFixedMinStrip = min;
173   fFixedMaxStrip = max;
174 }
175
176 //__________________________________________________________________
177 void
178 AliFMDParameters::InitPulseGain()
179 {
180   // Get pulse gain from CDB or used fixed 
181   AliCDBManager* cdb      = AliCDBManager::Instance();
182   AliCDBEntry*   gain     = cdb->Get(fgkPulseGain);
183   if (!gain) {
184     AliWarning(Form("No %s found in CDB, perhaps you need to "
185                     "use AliFMDCalibFaker?", fgkPulseGain));
186     return;
187   }
188   
189   AliDebug(1, Form("Got gain from CDB"));
190   fPulseGain = dynamic_cast<AliFMDCalibGain*>(gain->GetObject());
191   if (!fPulseGain) AliWarning("Invalid pulser gain object from CDB");
192 }
193 //__________________________________________________________________
194 void
195 AliFMDParameters::InitPedestal()
196 {
197   // Initialize the pedestals from CDB 
198   AliCDBManager* cdb      = AliCDBManager::Instance();
199   AliCDBEntry*   pedestal = cdb->Get(fgkPedestal);
200   if (!pedestal) {
201     AliWarning(Form("No %s found in CDB, perhaps you need to "
202                     "use AliFMDCalibFaker?", fgkPedestal));
203     return;
204   }
205   AliDebug(1, Form("Got pedestal from CDB"));
206   fPedestal = dynamic_cast<AliFMDCalibPedestal*>(pedestal->GetObject());
207   if (!fPedestal) AliWarning("Invalid pedestal object from CDB");
208 }
209
210 //__________________________________________________________________
211 void
212 AliFMDParameters::InitDeadMap()
213 {
214   // Get Dead-channel-map from CDB 
215   AliCDBManager* cdb      = AliCDBManager::Instance();
216   AliCDBEntry*   deadMap  = cdb->Get(fgkDead);
217   if (!deadMap) {
218     AliWarning(Form("No %s found in CDB, perhaps you need to "
219                     "use AliFMDCalibFaker?", fgkDead));
220     return;
221   }
222   AliDebug(1, Form("Got dead map from CDB"));
223   fDeadMap = dynamic_cast<AliFMDCalibDeadMap*>(deadMap->GetObject());
224   if (!fDeadMap) AliWarning("Invalid dead map object from CDB");
225 }
226
227 //__________________________________________________________________
228 void
229 AliFMDParameters::InitZeroSuppression()
230 {
231   // Get 0-suppression from CDB 
232   AliCDBManager* cdb      = AliCDBManager::Instance();
233   AliCDBEntry*   zeroSup  = cdb->Get(fgkZeroSuppression);
234   if (!zeroSup) {
235     AliWarning(Form("No %s found in CDB, perhaps you need to "
236                     "use AliFMDCalibFaker?", fgkZeroSuppression));
237     return;
238   }
239   AliDebug(1, Form("Got zero suppression from CDB"));
240   fZeroSuppression = 
241     dynamic_cast<AliFMDCalibZeroSuppression*>(zeroSup->GetObject());
242   if (!fZeroSuppression)AliWarning("Invalid zero suppression object from CDB");
243 }
244
245 //__________________________________________________________________
246 void
247 AliFMDParameters::InitSampleRate()
248 {
249   // get Sample rate from CDB
250   AliCDBManager* cdb      = AliCDBManager::Instance();
251   AliCDBEntry*   sampRat  = cdb->Get(fgkSampleRate);
252   if (!sampRat) {
253     AliWarning(Form("No %s found in CDB, perhaps you need to "
254                     "use AliFMDCalibFaker?", fgkSampleRate));
255     return;
256   }
257   AliDebug(1, Form("Got zero suppression from CDB"));
258   fSampleRate = dynamic_cast<AliFMDCalibSampleRate*>(sampRat->GetObject());
259   if (!fSampleRate) AliWarning("Invalid zero suppression object from CDB");
260 }
261
262 //__________________________________________________________________
263 void
264 AliFMDParameters::InitAltroMap()
265 {
266   // Get hardware mapping from CDB
267   AliCDBManager* cdb      = AliCDBManager::Instance();
268   AliCDBEntry*   hwMap    = cdb->Get(fgkAltroMap);       
269   if (!hwMap) {
270     AliWarning(Form("No %s found in CDB, perhaps you need to "
271                     "use AliFMDCalibFaker?", fgkAltroMap));
272     fAltroMap = new AliFMDAltroMapping;
273     return;
274   }
275   AliDebug(1, Form("Got ALTRO map from CDB"));
276   fAltroMap = dynamic_cast<AliFMDAltroMapping*>(hwMap->GetObject());
277   if (!fAltroMap) {
278     AliWarning("Invalid ALTRO map object from CDB");
279     fAltroMap = new AliFMDAltroMapping;
280   }
281 }
282
283 //__________________________________________________________________
284 void
285 AliFMDParameters::InitStripRange()
286 {
287   // Get strips read-out from CDB
288   AliCDBManager* cdb      = AliCDBManager::Instance();
289   AliCDBEntry*   range    = cdb->Get(fgkStripRange);
290   if (!range) {
291     AliWarning(Form("No %s found in CDB, perhaps you need to "
292                     "use AliFMDCalibFaker?", fgkStripRange));
293     return;
294   }
295   AliDebug(1, Form("Got strip range from CDB"));
296   fStripRange = dynamic_cast<AliFMDCalibStripRange*>(range->GetObject());
297   if (!fStripRange) AliWarning("Invalid strip range object from CDB");
298 }
299
300
301 //__________________________________________________________________
302 Float_t
303 AliFMDParameters::GetThreshold() const
304 {
305   // Get threshold from CDB
306   if (!fPulseGain) return fFixedThreshold;
307   return fPulseGain->Threshold();
308 }
309
310 //__________________________________________________________________
311 Float_t
312 AliFMDParameters::GetPulseGain(UShort_t detector, Char_t ring, 
313                                UShort_t sector, UShort_t strip) const
314 {
315   // Returns the pulser calibrated gain for strip # strip in sector #
316   // sector or ring id ring of detector # detector. 
317   // 
318   // For simulation, this is normally set to 
319   // 
320   //       VA1_MIP_Range 
321   //    ------------------ * MIP_Energy_Loss
322   //    ALTRO_channel_size
323   // 
324   if (!fPulseGain) { 
325     if (fFixedPulseGain <= 0)
326       fFixedPulseGain = fVA1MipRange * GetEdepMip() / fAltroChannelSize;
327     return fFixedPulseGain;
328   }  
329   AliDebug(50, Form("pulse gain for FMD%d%c[%2d,%3d]=%f",
330                     detector, ring, sector, strip,
331                     fPulseGain->Value(detector, ring, sector, strip)));
332   return fPulseGain->Value(detector, ring, sector, strip);
333 }
334
335 //__________________________________________________________________
336 Bool_t
337 AliFMDParameters::IsDead(UShort_t detector, Char_t ring, 
338                          UShort_t sector, UShort_t strip) const
339 {
340   // Check if the channel is dead 
341   if (!fDeadMap) return kFALSE;
342   AliDebug(50, Form("Dead for FMD%d%c[%2d,%3d]=%s",
343                     detector, ring, sector, strip,
344                     fDeadMap->operator()(detector, ring, sector, strip) ? 
345                     "no" : "yes"));
346   return fDeadMap->operator()(detector, ring, sector, strip);
347 }
348
349 //__________________________________________________________________
350 UShort_t
351 AliFMDParameters::GetZeroSuppression(UShort_t detector, Char_t ring, 
352                                      UShort_t sector, UShort_t strip) const
353 {
354   // Get zero suppression threshold 
355   if (!fZeroSuppression) return fFixedZeroSuppression;
356   // Need to map strip to ALTRO chip. 
357   AliDebug(50, Form("zero sup. for FMD%d%c[%2d,%3d]=%f",
358                     detector, ring, sector, strip,
359                     fZeroSuppression->operator()(detector, ring, 
360                                                  sector, strip)));
361   return fZeroSuppression->operator()(detector, ring, sector, strip/128);
362 }
363
364 //__________________________________________________________________
365 UShort_t
366 AliFMDParameters::GetSampleRate(UShort_t det, Char_t ring, UShort_t sector, 
367                                 UShort_t str) const
368 {
369   // Get sampl rate 
370   if (!fSampleRate) return fFixedSampleRate;
371   // Need to map sector to digitizier card. 
372   UInt_t ret = fSampleRate->Rate(det, ring, sector, str);
373   AliDebug(50, Form("Sample rate for FMD%d%c[%2d,%3d]=%d", 
374                     det, ring, sector, str, ret));
375   return ret;
376 }
377
378 //__________________________________________________________________
379 UShort_t
380 AliFMDParameters::GetMinStrip(UShort_t det, Char_t ring, UShort_t sector, 
381                               UShort_t str) const
382 {
383   // Get strip range read out 
384   if (!fStripRange) return fFixedMinStrip;
385   // Need to map sector to digitizier card. 
386   UInt_t ret = fStripRange->Min(det, ring, sector, str);
387   AliDebug(50, Form("Min strip # for FMD%d%c[%2d,%3d]=%d", 
388                     det, ring, sector, str, ret));
389   return ret;
390 }
391
392 //__________________________________________________________________
393 UShort_t
394 AliFMDParameters::GetMaxStrip(UShort_t det, Char_t ring, UShort_t sector, 
395                               UShort_t str) const
396 {
397   // Get strip range read out 
398   if (!fStripRange) return fFixedMaxStrip;
399   // Need to map sector to digitizier card. 
400   UInt_t ret = fStripRange->Max(det, ring, sector, str);
401   AliDebug(50, Form("Max strip # for FMD%d%c[%2d,%3d]=%d", 
402                     det, ring, sector, str, ret));
403   return ret;
404 }
405
406 //__________________________________________________________________
407 Float_t
408 AliFMDParameters::GetPedestal(UShort_t detector, Char_t ring, 
409                               UShort_t sector, UShort_t strip) const
410 {
411   // Get the pedesal 
412   if (!fPedestal) return fFixedPedestal;
413   AliDebug(50, Form("pedestal for FMD%d%c[%2d,%3d]=%f",
414                     detector, ring, sector, strip,
415                     fPedestal->Value(detector, ring, sector, strip)));
416   return fPedestal->Value(detector, ring, sector, strip);
417 }
418
419 //__________________________________________________________________
420 Float_t
421 AliFMDParameters::GetPedestalWidth(UShort_t detector, Char_t ring, 
422                                    UShort_t sector, UShort_t strip) const
423 {
424   // Get the pedesal 
425   if (!fPedestal) return fFixedPedestalWidth;
426   AliDebug(50, Form("pedetal width for FMD%d%c[%2d,%3d]=%f",
427                     detector, ring, sector, strip,
428                     fPedestal->Width(detector, ring, sector, strip)));
429   return fPedestal->Width(detector, ring, sector, strip);
430 }
431   
432 //__________________________________________________________________
433 AliFMDAltroMapping*
434 AliFMDParameters::GetAltroMap() const
435 {
436   // Get the hardware address to detector index map 
437   return fAltroMap;
438 }
439
440
441 //__________________________________________________________________
442 Bool_t
443 AliFMDParameters::Hardware2Detector(UInt_t ddl, UInt_t addr, UShort_t& det,
444                                     Char_t& ring, UShort_t& sec, 
445                                     UShort_t& str) const
446 {
447   // Map hardware address to detector index
448   if (!fAltroMap) return kFALSE;
449   return fAltroMap->Hardware2Detector(ddl, addr, det, ring, sec, str);
450 }
451
452 //__________________________________________________________________
453 Bool_t
454 AliFMDParameters::Detector2Hardware(UShort_t det, Char_t ring, UShort_t sec, 
455                                     UShort_t str, UInt_t& ddl, 
456                                     UInt_t& addr) const                       
457 {
458   // Map detector index to hardware address
459   if (!fAltroMap) return kFALSE;
460   return fAltroMap->Detector2Hardware(det, ring, sec, str, ddl, addr);
461 }
462
463
464 //__________________________________________________________________
465 Float_t
466 AliFMDParameters::GetEdepMip() const 
467
468   // Get energy deposited by a MIP in the silicon sensors
469   if (fEdepMip <= 0){
470     AliFMDGeometry* fmd = AliFMDGeometry::Instance();
471     fEdepMip = (fkSiDeDxMip 
472                 * fmd->GetRing('I')->GetSiThickness() 
473                 * fmd->GetSiDensity());
474   }
475   return fEdepMip;
476 }
477
478
479   
480   
481   
482 //____________________________________________________________________
483 //
484 // EOF
485 //