Bringing CMakeLists under svn maintenance
[u/mrichter/AliRoot.git] / FMD / AliFMDParameters.cxx
CommitLineData
09b6c804 1/*************************************************************************
1a1fdef7 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. *
09b6c804 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 */
1a1fdef7 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.
6169f936 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.
1a1fdef7 32//
f95a63c4 33#include "AliFMDDebug.h" // ALILOG_H
8f6ee336 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
c2fc1258 39#include "AliFMDCalibSampleRate.h" // ALIFMDCALIBSAMPLERATE_H
40#include "AliFMDCalibStripRange.h" // ALIFMDCALIBSTRIPRANGE_H
57c3c593 41#include "AliFMDAltroMapping.h" // ALIFMDALTROMAPPING_H
42#include <AliCDBManager.h> // ALICDBMANAGER_H
43#include <AliCDBEntry.h> // ALICDBMANAGER_H
dc02d468 44#include <AliFMDPreprocessor.h>
45#include <AliLog.h>
1a1fdef7 46#include <Riostream.h>
8ec606c2 47#include <sstream>
dc02d468 48#include <TSystem.h>
6169f936 49#include <TArrayF.h>
50#include <TH2D.h>
1a1fdef7 51
52//====================================================================
53ClassImp(AliFMDParameters)
54#if 0
55 ; // This is here to keep Emacs for indenting the next line
56#endif
57
58//____________________________________________________________________
59AliFMDParameters* AliFMDParameters::fgInstance = 0;
60
61//____________________________________________________________________
77186f44 62const char* AliFMDParameters::fgkPulseGain = "FMD/Calib/PulseGain";
63const char* AliFMDParameters::fgkPedestal = "FMD/Calib/Pedestal";
64const char* AliFMDParameters::fgkDead = "FMD/Calib/Dead";
65const char* AliFMDParameters::fgkSampleRate = "FMD/Calib/SampleRate";
66const char* AliFMDParameters::fgkAltroMap = "FMD/Calib/AltroMap";
67const char* AliFMDParameters::fgkZeroSuppression = "FMD/Calib/ZeroSuppression";
68const char* AliFMDParameters::fgkStripRange = "FMD/Calib/StripRange";
69const char* AliFMDParameters::fkPedestalShuttleID = "pedestals";
70const char* AliFMDParameters::fkGainShuttleID = "gains";
71const char* AliFMDParameters::fkConditionsShuttleID = "conditions";
57c3c593 72
73//____________________________________________________________________
1a1fdef7 74AliFMDParameters*
75AliFMDParameters::Instance()
76{
09b6c804 77 //
1a1fdef7 78 // Get static instance
09b6c804 79 //
1a1fdef7 80 if (!fgInstance) fgInstance = new AliFMDParameters;
81 return fgInstance;
82}
83
84//____________________________________________________________________
85AliFMDParameters::AliFMDParameters()
57c3c593 86 : fIsInit(kFALSE),
02a27b50 87 fkSiDeDxMip(1.664),
b5ee4425 88 fVA1MipRange(0),
89 fAltroChannelSize(0),
90 fChannelsPerAltro(0),
91 fPedestalFactor(0),
045a97a7 92 fZSPre(1),
93 fZSPost(1),
94 fZSPedSubtract(kTRUE),
95 fFixedPedestal(100),
96 fFixedPedestalWidth(2),
97 fFixedZeroSuppression(1),
98 fFixedSampleRate(2),
b5ee4425 99 fFixedThreshold(0),
100 fFixedMinStrip(0),
045a97a7 101 fFixedMaxStrip(127),
102 fFixedPulseGain(2),
8f6ee336 103 fEdepMip(0),
625d7886 104 fHasCompleteHeader(kTRUE),
8f6ee336 105 fZeroSuppression(0),
106 fSampleRate(0),
107 fPedestal(0),
108 fPulseGain(0),
57c3c593 109 fDeadMap(0),
c2fc1258 110 fAltroMap(0),
3d7ed4ed 111 fStripRange(0)
1a1fdef7 112{
09b6c804 113 //
1a1fdef7 114 // Default constructor
09b6c804 115 //
1a1fdef7 116 SetVA1MipRange();
117 SetAltroChannelSize();
118 SetChannelsPerAltro();
119 SetZeroSuppression();
120 SetSampleRate();
121 SetPedestal();
122 SetPedestalWidth();
123 SetPedestalFactor();
8f6ee336 124 SetThreshold();
c2fc1258 125 SetStripRange();
045a97a7 126 SetGain();
06ca6759 127 fAltroMap = new AliFMDAltroMapping;
1a1fdef7 128}
129
8f6ee336 130//__________________________________________________________________
57c3c593 131void
f6449cc0 132AliFMDParameters::Init(Bool_t forceReInit, UInt_t what)
57c3c593 133{
09b6c804 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 //
a9579262 142 if (forceReInit) fIsInit = kFALSE;
57c3c593 143 if (fIsInit) return;
f6449cc0 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();
6bf06d81 150 if (what & kStripRange) InitStripRange();
1e8f773e 151 fIsInit = kTRUE;
dc02d468 152}
153//__________________________________________________________________
154void
155AliFMDParameters::Init(AliFMDPreprocessor* pp, Bool_t forceReInit, UInt_t what)
156{
09b6c804 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 //
dc02d468 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);
6bf06d81 174 if (what & kStripRange) InitStripRange(pp);
dc02d468 175 fIsInit = kTRUE;
1e8f773e 176}
c2fc1258 177
178//__________________________________________________________________
f560b28c 179Bool_t
180AliFMDParameters::CheckFile(const char* prefix,
181 const char* path,
182 int number,
183 TString& f) const
184{
09b6c804 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 //
f560b28c 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//__________________________________________________________________
206void
207AliFMDParameters::Init(const char* path, Bool_t forceReInit, UInt_t what)
208{
09b6c804 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 //
f560b28c 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//__________________________________________________________________
280void
281AliFMDParameters::MakeDeadMap(Float_t maxNoise,
282 Float_t minGain,
283 Float_t maxGain)
284{
09b6c804 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 //
f560b28c 304 if (fPedestal)
305 fDeadMap = fPedestal->MakeDeadMap(maxNoise, fDeadMap);
306 if (fPulseGain)
307 fDeadMap = fPulseGain->MakeDeadMap(minGain, maxGain, fDeadMap);
308}
309//__________________________________________________________________
6169f936 310#define DET2IDX(det,ring,sec,str) \
a9579262 311 (det * 1000 + (ring == 'I' ? 0 : 512) + str)
6169f936 312
313//__________________________________________________________________
314void
315AliFMDParameters::Draw(Option_t* option)
316{
09b6c804 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 //
6169f936 333 TString opt(option);
334 enum {
458e52e8 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
6169f936 345 } what;
6169f936 346
347 if (opt.Contains("dead", TString::kIgnoreCase))
458e52e8 348 what = kLocalDead;
6169f936 349 else if (opt.Contains("threshold",TString::kIgnoreCase))
458e52e8 350 what = kLocalThreshold;
6169f936 351 else if (opt.Contains("gain",TString::kIgnoreCase))
458e52e8 352 what = kLocalPulseGain;
6169f936 353 else if (opt.Contains("pedestal",TString::kIgnoreCase))
458e52e8 354 what = kLocalPedestal;
6169f936 355 else if (opt.Contains("noise",TString::kIgnoreCase))
458e52e8 356 what = kLocalPedestalWidth;
6169f936 357 else if (opt.Contains("zero",TString::kIgnoreCase))
458e52e8 358 what = kLocalZeroSuppression;
6169f936 359 else if (opt.Contains("rate",TString::kIgnoreCase))
458e52e8 360 what = kLocalSampleRate;
6169f936 361 else if (opt.Contains("min",TString::kIgnoreCase))
458e52e8 362 what = kLocalMinStripRange;
6169f936 363 else if (opt.Contains("max",TString::kIgnoreCase))
458e52e8 364 what = kLocalMaxStripRange;
6169f936 365 else if (opt.Contains("map",TString::kIgnoreCase))
458e52e8 366 what = kLocalAltroMap;
6169f936 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++) {
a9579262 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++) {
6169f936 387 Int_t idx = DET2IDX(det, ring, 0, str);
a9579262 388 // Int_t idx = DET2IDX(det, ring, sec, 0);
6169f936 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);
458e52e8 401 for (/*Int_t*/ i = 0; i < ybins.fN; i++) ybins[i] = Float_t(i - .5);
6169f936 402 TH2D* hist = new TH2D("calib", Form("Calibration %s", option),
403 xbins.fN-1, xbins.fArray,
404 ybins.fN-1, ybins.fArray);
a9579262 405 hist->GetXaxis()->SetTitle("1000 #times detector + 512 #times ring + strip");
406 hist->GetYaxis()->SetTitle("sector");
407
6169f936 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);
b995fc28 420 UShort_t ddl, addr, time, sam=0;
6169f936 421 Double_t val = 0;
422 switch (what) {
458e52e8 423 case kLocalPulseGain: // Path to PulseGain calib object
6169f936 424 val = GetPulseGain(det,ring,sec,str); break;
458e52e8 425 case kLocalThreshold: // Path to PulseGain calib object
6169f936 426 val = GetThreshold(); break;
458e52e8 427 case kLocalPedestal: // Path to Pedestal calib object
6169f936 428 val = GetPedestal(det,ring,sec,str); break;
458e52e8 429 case kLocalPedestalWidth: // Path to Pedestal calib object
6169f936 430 val = GetPedestalWidth(det,ring,sec,str); break;
458e52e8 431 case kLocalDead: // Path to Dead calib object
6169f936 432 val = IsDead(det,ring,sec,str); break;
458e52e8 433 case kLocalSampleRate: // Path to SampleRate calib object
6169f936 434 val = GetSampleRate(det,ring,sec,str); break;
458e52e8 435 case kLocalAltroMap: // Path to AltroMap calib object
b995fc28 436 Detector2Hardware(det,ring,sec,str,sam,ddl,addr,time);
6169f936 437 val = addr; break;
458e52e8 438 case kLocalZeroSuppression: // Path to ZeroSuppression cal object
6169f936 439 val = GetZeroSuppression(det,ring,sec,str); break;
458e52e8 440 case kLocalMinStripRange: // Path to strip range cal object
6169f936 441 val = GetMinStrip(det,ring,sec,str); break;
458e52e8 442 case kLocalMaxStripRange: // Path to strip range cal object
6169f936 443 val = GetMaxStrip(det,ring,sec,str); break;
444 }
445 hist->Fill(idx,sec,val);
a9579262 446 // hist->Fill(idx,str,val);
6169f936 447 }
448 }
449 }
450 }
451 hist->Draw("lego");
452}
453
454//__________________________________________________________________
c2fc1258 455void
456AliFMDParameters::Print(Option_t* option) const
457{
02a27b50 458 // Print information.
459 // If option contains an 'A' then everything is printed.
a9579262 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>.
c2fc1258 468 TString opt(option);
a9579262 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
8ec606c2 478 if (opt.Contains("fmd",TString::kIgnoreCase)) {
7868d9e2 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();
a9579262 485 enum {
97e94238 486 kReadDet,
487 kReadRing,
488 kReadLbrack,
489 kReadSector,
490 kReadComma,
491 kReadStrip,
492 kReadRbrack,
493 kEnd
494 } state = kReadDet;
8ec606c2 495 std::stringstream s(opt(i+4, j-i-3).Data());
97e94238 496 while (state != kEnd) {
a9579262 497 Char_t tmp = s.peek();
498 if (tmp == ' ' || tmp == '\t') {
499 s.get();
500 continue;
501 }
502 switch (state) {
97e94238 503 case kReadDet: { // First, try to kRead the detector
a9579262 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 }
97e94238 513 state = (s.bad() ? kEnd : kReadRing);
a9579262 514 } break;
97e94238 515 case kReadRing: { // Then try to read the ring;
a9579262 516 Char_t ring;
517 s >> ring;
518 if (ring != '*' && !s.bad()) {
519 rs[0] = ring;
520 rs[1] = '\0';
521 }
97e94238 522 state = (s.bad() ? kEnd : kReadLbrack);
a9579262 523 } break;
97e94238 524 case kReadLbrack: { // Try to read a left bracket
a9579262 525 Char_t lbrack;
526 s >> lbrack;
97e94238 527 state = (s.bad() ? kEnd : kReadSector);
a9579262 528 } break;
97e94238 529 case kReadSector: { // Try to read a sector
a9579262 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 }
97e94238 539 state = (s.bad() ? kEnd : kReadComma);
a9579262 540 } break;
97e94238 541 case kReadComma: { // Try to read a left bracket
a9579262 542 Char_t comma;
543 s >> comma;
97e94238 544 state = (s.bad() ? kEnd : kReadStrip);
a9579262 545 } break;
97e94238 546 case kReadStrip: { // Try to read a strip
a9579262 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 }
97e94238 556 state = (s.bad() ? kEnd : kReadRbrack);
a9579262 557 } break;
97e94238 558 case kReadRbrack: { // Try to read a left bracket
a9579262 559 Char_t rbrack;
560 s >> rbrack;
97e94238 561 state = kEnd;
a9579262 562 } break;
97e94238 563 case kEnd:
a9579262 564 break;
565 }
566 }
8ec606c2 567 }
a9579262 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);
a9579262 578 std::cout << "FMD" << det << ring
579 << " Strip range: "
580 << std::setw(3) << min << ","
ef8e8623 581 << std::setw(3) << max << std::endl;
a9579262 582
a9579262 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++) {
ef8e8623 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;
c2fc1258 592 std::cout
8ec606c2 593 << " Strip | Pedestal | Gain | ZS thr. | Address\n"
594 << "--------+-------------------+------------+---------+---------"
c2fc1258 595 << std::endl;
a9579262 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)) {
c2fc1258 601 std::cout << "dead" << std::endl;
602 continue;
603 }
b995fc28 604 UShort_t ddl, addr, time, sam=0;
605 Detector2Hardware(det, ring, sec, str, sam, ddl, addr, time);
a9579262 606 std::cout << std::setw(7) << GetPedestal(det, ring, sec, str)
c2fc1258 607 << "+/-" << std::setw(7)
a9579262 608 << GetPedestalWidth(det, ring, sec, str)
8ec606c2 609 << " | " << std::setw(10)
a9579262 610 << GetPulseGain(det, ring, sec, str)
611 << " | " << std::setw(7)
612 << GetZeroSuppression(det, ring, sec, str)
c2fc1258 613 << " | 0x" << std::hex << std::setw(4)
614 << std::setfill('0') << ddl << ",0x" << std::setw(3)
615 << addr << std::dec << std::setfill(' ') << std::endl;
a9579262 616 } // for (strip)
617 } // for (sector)
618 std::cout
619 << "============================================================="
620 << std::endl;
621 } // while (ring)
622 } // while (det)
623
c2fc1258 624}
625
626//__________________________________________________________________
dc02d468 627AliCDBEntry*
628AliFMDParameters::GetEntry(const char* path, AliFMDPreprocessor* pp,
629 Bool_t fatal) const
630{
09b6c804 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 //
dc02d468 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 }
045a97a7 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 }
dc02d468 667 return entry;
668}
669
670
671//__________________________________________________________________
1e8f773e 672void
dc02d468 673AliFMDParameters::InitPulseGain(AliFMDPreprocessor* pp)
1e8f773e 674{
09b6c804 675 //
676 // Initialize gains. Try to get them from CDB
677 //
678 // Parameters:
679 // pp Pre-processor if called from shuttle
680 //
dc02d468 681 AliCDBEntry* gain = GetEntry(fgkPulseGain, pp);
682 if (!gain) return;
57c3c593 683
42f1b2f5 684 AliFMDDebug(5, ("Got gain from CDB"));
1e8f773e 685 fPulseGain = dynamic_cast<AliFMDCalibGain*>(gain->GetObject());
f95a63c4 686 if (!fPulseGain) AliFatal("Invalid pulser gain object from CDB");
045a97a7 687 if (!fPulseGain->Values().Ptr())
688 AliFatal("Empty pulser gain object from CDB");
1e8f773e 689}
690//__________________________________________________________________
691void
dc02d468 692AliFMDParameters::InitPedestal(AliFMDPreprocessor* pp)
1e8f773e 693{
09b6c804 694 //
695 // Initialize pedestals. Try to get them from CDB
696 //
697 // Parameters:
698 // pp Pre-processor if called from shuttle
699 //
dc02d468 700 AliCDBEntry* pedestal = GetEntry(fgkPedestal, pp);
701 if (!pedestal) return;
702
42f1b2f5 703 AliFMDDebug(5, ("Got pedestal from CDB"));
1e8f773e 704 fPedestal = dynamic_cast<AliFMDCalibPedestal*>(pedestal->GetObject());
f95a63c4 705 if (!fPedestal) AliFatal("Invalid pedestal object from CDB");
045a97a7 706 if (!fPedestal->Values().Ptr()) AliFatal("Empty pedestal object from CDB");
1e8f773e 707}
708
709//__________________________________________________________________
710void
dc02d468 711AliFMDParameters::InitDeadMap(AliFMDPreprocessor* pp)
1e8f773e 712{
09b6c804 713 //
714 // Initialize dead map. Try to get it from CDB
715 //
716 // Parameters:
717 // pp Pre-processor if called from shuttle
718 //
dc02d468 719 AliCDBEntry* deadMap = GetEntry(fgkDead, pp);
720 if (!deadMap) return;
721
42f1b2f5 722 AliFMDDebug(5, ("Got dead map from CDB"));
1e8f773e 723 fDeadMap = dynamic_cast<AliFMDCalibDeadMap*>(deadMap->GetObject());
f95a63c4 724 if (!fDeadMap) AliFatal("Invalid dead map object from CDB");
045a97a7 725 if (!fDeadMap->Ptr()) AliFatal("Empty dead map object from CDB");
1e8f773e 726}
727
728//__________________________________________________________________
729void
dc02d468 730AliFMDParameters::InitZeroSuppression(AliFMDPreprocessor* pp)
1e8f773e 731{
09b6c804 732 //
733 // Initialize zero suppression thresholds. Try to get them from CDB
734 //
735 // Parameters:
736 // pp Pre-processor if called from shuttle
737 //
dc02d468 738 AliCDBEntry* zeroSup = GetEntry(fgkZeroSuppression, pp);
739 if (!zeroSup) return;
42f1b2f5 740 AliFMDDebug(5, ("Got zero suppression from CDB"));
1e8f773e 741 fZeroSuppression =
742 dynamic_cast<AliFMDCalibZeroSuppression*>(zeroSup->GetObject());
f95a63c4 743 if (!fZeroSuppression)AliFatal("Invalid zero suppression object from CDB");
045a97a7 744 if (!fZeroSuppression->Ptr()) {
745 AliWarningF("Empty zero suppression object from CDB, assuming %d",
746 fFixedZeroSuppression);
70da18af 747 AliCDBManager* cdbMan = AliCDBManager::Instance();
748 if(!cdbMan || !cdbMan->GetCacheFlag())
749 delete fZeroSuppression;
045a97a7 750 fZeroSuppression = 0;
751 }
1e8f773e 752}
753
754//__________________________________________________________________
755void
dc02d468 756AliFMDParameters::InitSampleRate(AliFMDPreprocessor* pp)
1e8f773e 757{
09b6c804 758 //
759 // Initialize sample rates. Try to get them from CDB
760 //
761 // Parameters:
762 // pp Pre-processor if called from shuttle
763 //
dc02d468 764 AliCDBEntry* sampRat = GetEntry(fgkSampleRate, pp);
765 if (!sampRat) return;
42f1b2f5 766 AliFMDDebug(5, ("Got zero suppression from CDB"));
1e8f773e 767 fSampleRate = dynamic_cast<AliFMDCalibSampleRate*>(sampRat->GetObject());
045a97a7 768 if (!fSampleRate) AliFatal("Invalid sample rate object from CDB");
769 if (!fSampleRate->Rates().Ptr())
770 AliFatal("empty sample rate object from CDB");
1e8f773e 771}
772
773//__________________________________________________________________
774void
dc02d468 775AliFMDParameters::InitAltroMap(AliFMDPreprocessor* pp)
1e8f773e 776{
09b6c804 777 //
778 // Initialize hardware map. Try to get it from CDB
779 //
780 // Parameters:
781 // pp Pre-processor if called from shuttle
782 //
06ca6759 783 if (fAltroMap) {
784 delete fAltroMap;
785 fAltroMap = 0;
786 }
458e52e8 787 AliCDBEntry* hwMap = GetEntry(fgkAltroMap, pp, kFALSE);
dc02d468 788 if (!hwMap) return;
789
42f1b2f5 790 AliFMDDebug(5, ("Got ALTRO map from CDB"));
1e8f773e 791 fAltroMap = dynamic_cast<AliFMDAltroMapping*>(hwMap->GetObject());
792 if (!fAltroMap) {
f95a63c4 793 AliFatal("Invalid ALTRO map object from CDB");
1e8f773e 794 fAltroMap = new AliFMDAltroMapping;
57c3c593 795 }
57c3c593 796}
797
c2fc1258 798//__________________________________________________________________
799void
dc02d468 800AliFMDParameters::InitStripRange(AliFMDPreprocessor* pp)
c2fc1258 801{
09b6c804 802 //
803 // Initialize strip range. Try to get it from CDB
804 //
805 // Parameters:
806 // pp Pre-processor if called from shuttle
807 //
dc02d468 808 AliCDBEntry* range = GetEntry(fgkStripRange, pp);
809 if (!range) return;
42f1b2f5 810 AliFMDDebug(5, ("Got strip range from CDB"));
c2fc1258 811 fStripRange = dynamic_cast<AliFMDCalibStripRange*>(range->GetObject());
f95a63c4 812 if (!fStripRange) AliFatal("Invalid strip range object from CDB");
045a97a7 813 if (!fStripRange->Ranges().Ptr())
814 AliFatal("Empty strip range object from CDB");
c2fc1258 815}
816
1e8f773e 817
57c3c593 818//__________________________________________________________________
8f6ee336 819Float_t
820AliFMDParameters::GetThreshold() const
821{
09b6c804 822 //
823 // Get the threshold in the pulser gain
824 //
825 //
826 // Return:
827 // Threshold from pulser
828 //
8f6ee336 829 if (!fPulseGain) return fFixedThreshold;
830 return fPulseGain->Threshold();
831}
832
833//__________________________________________________________________
834Float_t
835AliFMDParameters::GetPulseGain(UShort_t detector, Char_t ring,
836 UShort_t sector, UShort_t strip) const
837{
8f6ee336 838 //
09b6c804 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]
8f6ee336 846 //
8f6ee336 847 //
09b6c804 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 //
8f6ee336 857 if (!fPulseGain) {
858 if (fFixedPulseGain <= 0)
859 fFixedPulseGain = fVA1MipRange * GetEdepMip() / fAltroChannelSize;
860 return fFixedPulseGain;
861 }
f95a63c4 862 AliFMDDebug(50, ("pulse gain for FMD%d%c[%2d,%3d]=%f",
1e8f773e 863 detector, ring, sector, strip,
864 fPulseGain->Value(detector, ring, sector, strip)));
8f6ee336 865 return fPulseGain->Value(detector, ring, sector, strip);
866}
867
868//__________________________________________________________________
869Bool_t
870AliFMDParameters::IsDead(UShort_t detector, Char_t ring,
871 UShort_t sector, UShort_t strip) const
872{
09b6c804 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 //
8f6ee336 886 if (!fDeadMap) return kFALSE;
f95a63c4 887 AliFMDDebug(50, ("Dead for FMD%d%c[%2d,%3d]=%s",
1e8f773e 888 detector, ring, sector, strip,
889 fDeadMap->operator()(detector, ring, sector, strip) ?
890 "no" : "yes"));
8f6ee336 891 return fDeadMap->operator()(detector, ring, sector, strip);
892}
893
894//__________________________________________________________________
895UShort_t
896AliFMDParameters::GetZeroSuppression(UShort_t detector, Char_t ring,
897 UShort_t sector, UShort_t strip) const
898{
09b6c804 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 //
8f6ee336 911 if (!fZeroSuppression) return fFixedZeroSuppression;
045a97a7 912
913 // In case of empty zero suppression objects.
914 if (!fZeroSuppression->Ptr() ||
915 fZeroSuppression->MaxIndex() <= 0) return fFixedZeroSuppression;
916
8f6ee336 917 // Need to map strip to ALTRO chip.
4f8dd8ab 918 AliFMDDebug(50, ("zero sup. for FMD%d%c[%2d,%3d]=%d",
1e8f773e 919 detector, ring, sector, strip,
920 fZeroSuppression->operator()(detector, ring,
921 sector, strip)));
8f6ee336 922 return fZeroSuppression->operator()(detector, ring, sector, strip/128);
923}
924
925//__________________________________________________________________
926UShort_t
c2fc1258 927AliFMDParameters::GetSampleRate(UShort_t det, Char_t ring, UShort_t sector,
928 UShort_t str) const
8f6ee336 929{
09b6c804 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 //
8f6ee336 942 if (!fSampleRate) return fFixedSampleRate;
943 // Need to map sector to digitizier card.
c2fc1258 944 UInt_t ret = fSampleRate->Rate(det, ring, sector, str);
f95a63c4 945 AliFMDDebug(50, ("Sample rate for FMD%d%c[%2d,%3d]=%d",
c2fc1258 946 det, ring, sector, str, ret));
947 return ret;
948}
949
950//__________________________________________________________________
951UShort_t
952AliFMDParameters::GetMinStrip(UShort_t det, Char_t ring, UShort_t sector,
953 UShort_t str) const
954{
09b6c804 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 //
c2fc1258 967 if (!fStripRange) return fFixedMinStrip;
968 // Need to map sector to digitizier card.
969 UInt_t ret = fStripRange->Min(det, ring, sector, str);
f95a63c4 970 AliFMDDebug(50, ("Min strip # for FMD%d%c[%2d,%3d]=%d",
c2fc1258 971 det, ring, sector, str, ret));
972 return ret;
973}
974
975//__________________________________________________________________
976UShort_t
977AliFMDParameters::GetMaxStrip(UShort_t det, Char_t ring, UShort_t sector,
978 UShort_t str) const
979{
09b6c804 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 //
c2fc1258 992 if (!fStripRange) return fFixedMaxStrip;
993 // Need to map sector to digitizier card.
994 UInt_t ret = fStripRange->Max(det, ring, sector, str);
f95a63c4 995 AliFMDDebug(50, ("Max strip # for FMD%d%c[%2d,%3d]=%d",
c2fc1258 996 det, ring, sector, str, ret));
997 return ret;
8f6ee336 998}
1a1fdef7 999
8f6ee336 1000//__________________________________________________________________
1001Float_t
1002AliFMDParameters::GetPedestal(UShort_t detector, Char_t ring,
1003 UShort_t sector, UShort_t strip) const
1004{
09b6c804 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 //
8f6ee336 1017 if (!fPedestal) return fFixedPedestal;
f95a63c4 1018 AliFMDDebug(50, ("pedestal for FMD%d%c[%2d,%3d]=%f",
1e8f773e 1019 detector, ring, sector, strip,
1020 fPedestal->Value(detector, ring, sector, strip)));
8f6ee336 1021 return fPedestal->Value(detector, ring, sector, strip);
1022}
1023
1024//__________________________________________________________________
1025Float_t
1026AliFMDParameters::GetPedestalWidth(UShort_t detector, Char_t ring,
1027 UShort_t sector, UShort_t strip) const
1028{
09b6c804 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 //
8f6ee336 1041 if (!fPedestal) return fFixedPedestalWidth;
f95a63c4 1042 AliFMDDebug(50, ("pedetal width for FMD%d%c[%2d,%3d]=%f",
1e8f773e 1043 detector, ring, sector, strip,
1044 fPedestal->Width(detector, ring, sector, strip)));
8f6ee336 1045 return fPedestal->Width(detector, ring, sector, strip);
1046}
1047
1a1fdef7 1048//__________________________________________________________________
57c3c593 1049AliFMDAltroMapping*
1050AliFMDParameters::GetAltroMap() const
1051{
09b6c804 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 //
57c3c593 1059 return fAltroMap;
1a1fdef7 1060}
1061
57c3c593 1062
f38b1653 1063//____________________________________________________________________
1064Bool_t
b995fc28 1065AliFMDParameters::Hardware2Detector(UShort_t ddl, UShort_t addr,
f38b1653 1066 UShort_t timebin,
b995fc28 1067 UShort_t& det, Char_t& ring,
f38b1653 1068 UShort_t& sec, Short_t& str,
1069 UShort_t& sam) const
1070{
f38b1653 1071 //
09b6c804 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 //
b995fc28 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);
f38b1653 1091}
1092//____________________________________________________________________
1093Bool_t
83dbc5b8 1094AliFMDParameters::Hardware2Detector(UShort_t ddl, UShort_t board,
1095 UShort_t chip, UShort_t chan,
f38b1653 1096 UShort_t timebin,
1097 UShort_t& det, Char_t& ring,
1098 UShort_t& sec, Short_t& str,
1099 UShort_t& sam) const
1100{
f38b1653 1101 //
09b6c804 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 //
83dbc5b8 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);
b995fc28 1128 Short_t stripBase = 0;
83dbc5b8 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));
b995fc28 1135 return kFALSE;
83dbc5b8 1136 }
b995fc28 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));
f38b1653 1146 return kTRUE;
1147}
1148
bf000c32 1149
f38b1653 1150//____________________________________________________________________
1151Bool_t
1152AliFMDParameters::Detector2Hardware(UShort_t det, Char_t ring,
1153 UShort_t sec, UShort_t str,
1154 UShort_t sam,
b995fc28 1155 UShort_t& ddl, UShort_t& board,
1156 UShort_t& altro, UShort_t& channel,
f38b1653 1157 UShort_t& timebin) const
1158{
09b6c804 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 //
83dbc5b8 1177 if (!fAltroMap) {
1178 AliFMDDebug(1, ("No ALTRO map available"));
1179 return kFALSE;
1180 }
f38b1653 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
f38b1653 1191//____________________________________________________________________
1192Bool_t
1193AliFMDParameters::Detector2Hardware(UShort_t det, Char_t ring,
1194 UShort_t sec, UShort_t str,
1195 UShort_t sam,
b995fc28 1196 UShort_t& ddl, UShort_t& addr,
f38b1653 1197 UShort_t& timebin) const
1198{
09b6c804 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 //
f38b1653 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
57c3c593 1224
1225//__________________________________________________________________
1226Float_t
1227AliFMDParameters::GetEdepMip() const
1228{
09b6c804 1229 //
1230 // Return:
1231 // The average energy deposited by one MIP
1232 //
57c3c593 1233 if (fEdepMip <= 0){
1234 AliFMDGeometry* fmd = AliFMDGeometry::Instance();
02a27b50 1235 fEdepMip = (fkSiDeDxMip
57c3c593 1236 * fmd->GetRing('I')->GetSiThickness()
1237 * fmd->GetSiDensity());
1238 }
1239 return fEdepMip;
1240}
68aba90a 1241//____________________________________________________________________
1242Float_t
1243AliFMDParameters::GetDACPerMIP() const
1244{
09b6c804 1245 //
1246 // This is the conversion from Digital-to-Analog-Converter setting
68aba90a 1247 // to the number of MIPs. The number was measured in the NBI lab during
1248 // August 2008.
09b6c804 1249 //
1250 // Return:
1251 // The conversion factor from DAC to ADC
1252 //
68aba90a 1253 return 29.67;
bf000c32 1254
68aba90a 1255}
1256
1a1fdef7 1257//____________________________________________________________________
1258//
1259// EOF
1260//