Simple scripts to run various steps.
[u/mrichter/AliRoot.git] / FMD / AliFMDParameters.cxx
CommitLineData
1a1fdef7 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 **************************************************************************/
1a1fdef7 15/* $Id$ */
c2fc1258 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*/
1a1fdef7 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.
6169f936 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.
1a1fdef7 31//
f95a63c4 32#include "AliFMDDebug.h" // ALILOG_H
8f6ee336 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
c2fc1258 38#include "AliFMDCalibSampleRate.h" // ALIFMDCALIBSAMPLERATE_H
39#include "AliFMDCalibStripRange.h" // ALIFMDCALIBSTRIPRANGE_H
57c3c593 40#include "AliFMDAltroMapping.h" // ALIFMDALTROMAPPING_H
41#include <AliCDBManager.h> // ALICDBMANAGER_H
42#include <AliCDBEntry.h> // ALICDBMANAGER_H
dc02d468 43#include <AliFMDPreprocessor.h>
44#include <AliLog.h>
1a1fdef7 45#include <Riostream.h>
8ec606c2 46#include <sstream>
dc02d468 47#include <TSystem.h>
6169f936 48#include <TArrayF.h>
49#include <TH2D.h>
1a1fdef7 50
51//====================================================================
52ClassImp(AliFMDParameters)
53#if 0
54 ; // This is here to keep Emacs for indenting the next line
55#endif
56
57//____________________________________________________________________
58AliFMDParameters* AliFMDParameters::fgInstance = 0;
59
57c3c593 60//____________________________________________________________________
77186f44 61const char* AliFMDParameters::fgkPulseGain = "FMD/Calib/PulseGain";
62const char* AliFMDParameters::fgkPedestal = "FMD/Calib/Pedestal";
63const char* AliFMDParameters::fgkDead = "FMD/Calib/Dead";
64const char* AliFMDParameters::fgkSampleRate = "FMD/Calib/SampleRate";
65const char* AliFMDParameters::fgkAltroMap = "FMD/Calib/AltroMap";
66const char* AliFMDParameters::fgkZeroSuppression = "FMD/Calib/ZeroSuppression";
67const char* AliFMDParameters::fgkStripRange = "FMD/Calib/StripRange";
68const char* AliFMDParameters::fkPedestalShuttleID = "pedestals";
69const char* AliFMDParameters::fkGainShuttleID = "gains";
70const char* AliFMDParameters::fkConditionsShuttleID = "conditions";
57c3c593 71
1a1fdef7 72//____________________________________________________________________
73AliFMDParameters*
74AliFMDParameters::Instance()
75{
76 // Get static instance
77 if (!fgInstance) fgInstance = new AliFMDParameters;
78 return fgInstance;
79}
80
81//____________________________________________________________________
82AliFMDParameters::AliFMDParameters()
57c3c593 83 : fIsInit(kFALSE),
02a27b50 84 fkSiDeDxMip(1.664),
b5ee4425 85 fVA1MipRange(0),
86 fAltroChannelSize(0),
87 fChannelsPerAltro(0),
88 fPedestalFactor(0),
89 fFixedPedestal(0),
90 fFixedPedestalWidth(0),
91 fFixedZeroSuppression(0),
92 fFixedSampleRate(0),
93 fFixedThreshold(0),
94 fFixedMinStrip(0),
95 fFixedMaxStrip(0),
8f6ee336 96 fFixedPulseGain(0),
97 fEdepMip(0),
625d7886 98 fHasCompleteHeader(kTRUE),
8f6ee336 99 fZeroSuppression(0),
100 fSampleRate(0),
101 fPedestal(0),
102 fPulseGain(0),
57c3c593 103 fDeadMap(0),
c2fc1258 104 fAltroMap(0),
105 fStripRange(0)
1a1fdef7 106{
107 // Default constructor
108 SetVA1MipRange();
109 SetAltroChannelSize();
110 SetChannelsPerAltro();
111 SetZeroSuppression();
112 SetSampleRate();
113 SetPedestal();
114 SetPedestalWidth();
115 SetPedestalFactor();
8f6ee336 116 SetThreshold();
c2fc1258 117 SetStripRange();
06ca6759 118 fAltroMap = new AliFMDAltroMapping;
1a1fdef7 119}
120
57c3c593 121//__________________________________________________________________
122void
f6449cc0 123AliFMDParameters::Init(Bool_t forceReInit, UInt_t what)
57c3c593 124{
125 // Initialize the parameters manager. We need to get stuff from the
126 // CDB here.
a9579262 127 if (forceReInit) fIsInit = kFALSE;
57c3c593 128 if (fIsInit) return;
f6449cc0 129 if (what & kPulseGain) InitPulseGain();
130 if (what & kPedestal) InitPedestal();
131 if (what & kDeadMap) InitDeadMap();
132 if (what & kSampleRate) InitSampleRate();
133 if (what & kZeroSuppression) InitZeroSuppression();
134 if (what & kAltroMap) InitAltroMap();
6bf06d81 135 if (what & kStripRange) InitStripRange();
1e8f773e 136 fIsInit = kTRUE;
dc02d468 137}
138//__________________________________________________________________
139void
140AliFMDParameters::Init(AliFMDPreprocessor* pp, Bool_t forceReInit, UInt_t what)
141{
142 // Initialize the parameters manager. We need to get stuff from the
143 // CDB here.
144 if (forceReInit) fIsInit = kFALSE;
145 if (fIsInit) return;
146 if (what & kPulseGain) InitPulseGain(pp);
147 if (what & kPedestal) InitPedestal(pp);
148 if (what & kDeadMap) InitDeadMap(pp);
149 if (what & kSampleRate) InitSampleRate(pp);
150 if (what & kZeroSuppression) InitZeroSuppression(pp);
151 if (what & kAltroMap) InitAltroMap(pp);
6bf06d81 152 if (what & kStripRange) InitStripRange(pp);
dc02d468 153 fIsInit = kTRUE;
1e8f773e 154}
c2fc1258 155
6169f936 156//__________________________________________________________________
157#define DET2IDX(det,ring,sec,str) \
a9579262 158 (det * 1000 + (ring == 'I' ? 0 : 512) + str)
6169f936 159
160//__________________________________________________________________
161void
162AliFMDParameters::Draw(Option_t* option)
163{
164 TString opt(option);
165 enum {
458e52e8 166 kLocalPulseGain, // Path to PulseGain calib object
167 kLocalThreshold, // Path to PulseGain calib object
168 kLocalPedestal, // Path to Pedestal calib object
169 kLocalPedestalWidth, // Path to Pedestal calib object
170 kLocalDead, // Path to Dead calib object
171 kLocalSampleRate, // Path to SampleRate calib object
172 kLocalAltroMap, // Path to AltroMap calib object
173 kLocalZeroSuppression, // Path to ZeroSuppression cal object
174 kLocalMinStripRange, // Path to strip range cal object
175 kLocalMaxStripRange // Path to strip range cal object
6169f936 176 } what;
6169f936 177
178 if (opt.Contains("dead", TString::kIgnoreCase))
458e52e8 179 what = kLocalDead;
6169f936 180 else if (opt.Contains("threshold",TString::kIgnoreCase))
458e52e8 181 what = kLocalThreshold;
6169f936 182 else if (opt.Contains("gain",TString::kIgnoreCase))
458e52e8 183 what = kLocalPulseGain;
6169f936 184 else if (opt.Contains("pedestal",TString::kIgnoreCase))
458e52e8 185 what = kLocalPedestal;
6169f936 186 else if (opt.Contains("noise",TString::kIgnoreCase))
458e52e8 187 what = kLocalPedestalWidth;
6169f936 188 else if (opt.Contains("zero",TString::kIgnoreCase))
458e52e8 189 what = kLocalZeroSuppression;
6169f936 190 else if (opt.Contains("rate",TString::kIgnoreCase))
458e52e8 191 what = kLocalSampleRate;
6169f936 192 else if (opt.Contains("min",TString::kIgnoreCase))
458e52e8 193 what = kLocalMinStripRange;
6169f936 194 else if (opt.Contains("max",TString::kIgnoreCase))
458e52e8 195 what = kLocalMaxStripRange;
6169f936 196 else if (opt.Contains("map",TString::kIgnoreCase))
458e52e8 197 what = kLocalAltroMap;
6169f936 198 else {
199 Warning("Draw", "unknown parameter: %s\n\tShould be one of\n\t"
200 "dead, threshold, gain, pedestal, noise, zero, rate, "
201 "min, max, map",
202 option);
203 return;
204 }
205
206 TArrayD xbins(3 * 512 + 2 * 256 + 5);
207 Int_t i = 1;
208 Bool_t skip = kTRUE;
209 for (UShort_t det = 1; det <= 3; det++) {
210 UShort_t nRings = (det == 1 ? 1 : 2);
211 for (UShort_t iring = 0; iring < nRings; iring++) {
212 UShort_t nStrip = (iring == 0 ? 512 : 256);
213 Char_t ring = (iring == 0 ? 'I' : 'O');
214 for (UShort_t str = 0; str < nStrip; str++) {
a9579262 215 // UShort_t nSec = (iring == 0 ? 20 : 40);
216 // Char_t ring = (iring == 0 ? 'I' : 'O');
217 // for (UShort_t sec = 0; sec < nSec; sec++) {
6169f936 218 Int_t idx = DET2IDX(det, ring, 0, str);
a9579262 219 // Int_t idx = DET2IDX(det, ring, sec, 0);
6169f936 220 if (skip) {
221 xbins[i-1] = idx - .5;
222 skip = kFALSE;
223 }
224 xbins[i] = idx + .5;
225 i++;
226 }
227 skip = kTRUE;
228 i++;
229 }
230 }
231 TArrayD ybins(41);
458e52e8 232 for (/*Int_t*/ i = 0; i < ybins.fN; i++) ybins[i] = Float_t(i - .5);
6169f936 233 TH2D* hist = new TH2D("calib", Form("Calibration %s", option),
234 xbins.fN-1, xbins.fArray,
235 ybins.fN-1, ybins.fArray);
a9579262 236 hist->GetXaxis()->SetTitle("1000 #times detector + 512 #times ring + strip");
237 hist->GetYaxis()->SetTitle("sector");
238
6169f936 239 // hist->Draw("Lego");
240 // return;
241
242 for (UShort_t det = 1; det <= 3; det++) {
243 UShort_t nRings = (det == 1 ? 1 : 2);
244 for (UShort_t iring = 0; iring < nRings; iring++) {
245 UShort_t nSector = (iring == 0 ? 20 : 40);
246 UShort_t nStrip = (iring == 0 ? 512 : 256);
247 Char_t ring = (iring == 0 ? 'I' : 'O');
248 for (UShort_t sec = 0; sec < nSector; sec++) {
249 for (UShort_t str = 0; str < nStrip; str++) {
250 Int_t idx = DET2IDX(det, ring, sec, str);
251 UInt_t ddl, addr;
252 Double_t val = 0;
253 switch (what) {
458e52e8 254 case kLocalPulseGain: // Path to PulseGain calib object
6169f936 255 val = GetPulseGain(det,ring,sec,str); break;
458e52e8 256 case kLocalThreshold: // Path to PulseGain calib object
6169f936 257 val = GetThreshold(); break;
458e52e8 258 case kLocalPedestal: // Path to Pedestal calib object
6169f936 259 val = GetPedestal(det,ring,sec,str); break;
458e52e8 260 case kLocalPedestalWidth: // Path to Pedestal calib object
6169f936 261 val = GetPedestalWidth(det,ring,sec,str); break;
458e52e8 262 case kLocalDead: // Path to Dead calib object
6169f936 263 val = IsDead(det,ring,sec,str); break;
458e52e8 264 case kLocalSampleRate: // Path to SampleRate calib object
6169f936 265 val = GetSampleRate(det,ring,sec,str); break;
458e52e8 266 case kLocalAltroMap: // Path to AltroMap calib object
6169f936 267 Detector2Hardware(det,ring,sec,str, ddl, addr);
268 val = addr; break;
458e52e8 269 case kLocalZeroSuppression: // Path to ZeroSuppression cal object
6169f936 270 val = GetZeroSuppression(det,ring,sec,str); break;
458e52e8 271 case kLocalMinStripRange: // Path to strip range cal object
6169f936 272 val = GetMinStrip(det,ring,sec,str); break;
458e52e8 273 case kLocalMaxStripRange: // Path to strip range cal object
6169f936 274 val = GetMaxStrip(det,ring,sec,str); break;
275 }
276 hist->Fill(idx,sec,val);
a9579262 277 // hist->Fill(idx,str,val);
6169f936 278 }
279 }
280 }
281 }
282 hist->Draw("lego");
283}
284
c2fc1258 285//__________________________________________________________________
286void
287AliFMDParameters::Print(Option_t* option) const
288{
02a27b50 289 // Print information.
290 // If option contains an 'A' then everything is printed.
a9579262 291 // If the option contains the string "FMD" the function will search
292 // for detector, ring, sector, and strip numbers to print, in the
293 // format
294 //
295 // FMD<detector><ring>[<sector>,<string>]
296 //
297 // The wild card '*' means all of <detector>, <ring>, <sector>, or
298 // <strip>.
c2fc1258 299 TString opt(option);
a9579262 300 Bool_t showStrips = opt.Contains("a", TString::kIgnoreCase);
301 UShort_t ds[] = { 1, 2, 3, 0 };
302 Char_t rs[] = { 'I', 'O', '\0' };
303 UShort_t minStrip = 0;
304 UShort_t maxStrip = 512;
305 UShort_t minSector = 0;
306 UShort_t maxSector = 40;
307
308
8ec606c2 309 if (opt.Contains("fmd",TString::kIgnoreCase)) {
7868d9e2 310 Int_t i = opt.Index("fmd",TString::kIgnoreCase);
311 Int_t j = opt.Index("]",TString::kIgnoreCase);
312 if (j != kNPOS)
313 showStrips = kTRUE;
314 else
315 j = opt.Length();
a9579262 316 enum {
97e94238 317 kReadDet,
318 kReadRing,
319 kReadLbrack,
320 kReadSector,
321 kReadComma,
322 kReadStrip,
323 kReadRbrack,
324 kEnd
325 } state = kReadDet;
8ec606c2 326 std::stringstream s(opt(i+4, j-i-3).Data());
97e94238 327 while (state != kEnd) {
a9579262 328 Char_t tmp = s.peek();
329 if (tmp == ' ' || tmp == '\t') {
330 s.get();
331 continue;
332 }
333 switch (state) {
97e94238 334 case kReadDet: { // First, try to kRead the detector
a9579262 335 if (tmp == '*') s.get();
336 else {
337 UShort_t det;
338 s >> det;
339 if (!s.bad()) {
340 ds[0] = det;
341 ds[1] = 0;
342 }
343 }
97e94238 344 state = (s.bad() ? kEnd : kReadRing);
a9579262 345 } break;
97e94238 346 case kReadRing: { // Then try to read the ring;
a9579262 347 Char_t ring;
348 s >> ring;
349 if (ring != '*' && !s.bad()) {
350 rs[0] = ring;
351 rs[1] = '\0';
352 }
97e94238 353 state = (s.bad() ? kEnd : kReadLbrack);
a9579262 354 } break;
97e94238 355 case kReadLbrack: { // Try to read a left bracket
a9579262 356 Char_t lbrack;
357 s >> lbrack;
97e94238 358 state = (s.bad() ? kEnd : kReadSector);
a9579262 359 } break;
97e94238 360 case kReadSector: { // Try to read a sector
a9579262 361 if (tmp == '*') s.get();
362 else {
363 UShort_t sec;
364 s >> sec;
365 if (!s.bad()) {
366 minSector = sec;
367 maxSector = sec + 1;
368 }
369 }
97e94238 370 state = (s.bad() ? kEnd : kReadComma);
a9579262 371 } break;
97e94238 372 case kReadComma: { // Try to read a left bracket
a9579262 373 Char_t comma;
374 s >> comma;
97e94238 375 state = (s.bad() ? kEnd : kReadStrip);
a9579262 376 } break;
97e94238 377 case kReadStrip: { // Try to read a strip
a9579262 378 if (tmp == '*') s.get();
379 else {
380 UShort_t str;
381 s >> str;
382 if (!s.bad()) {
383 minStrip = str;
384 maxStrip = str + 1;
385 }
386 }
97e94238 387 state = (s.bad() ? kEnd : kReadRbrack);
a9579262 388 } break;
97e94238 389 case kReadRbrack: { // Try to read a left bracket
a9579262 390 Char_t rbrack;
391 s >> rbrack;
97e94238 392 state = kEnd;
a9579262 393 } break;
97e94238 394 case kEnd:
a9579262 395 break;
396 }
397 }
8ec606c2 398 }
a9579262 399 UShort_t* dp = ds;
400 UShort_t det;
401 while ((det = *(dp++))) {
402
403 Char_t* rp = rs;
404 Char_t ring;
405 while ((ring = *(rp++))) {
406 if (det == 1 && ring == 'O') continue;
407 UShort_t min = GetMinStrip(det, ring, 0, 0);
408 UShort_t max = GetMaxStrip(det, ring, 0, 0);
a9579262 409 std::cout << "FMD" << det << ring
410 << " Strip range: "
411 << std::setw(3) << min << ","
ef8e8623 412 << std::setw(3) << max << std::endl;
a9579262 413
a9579262 414 UShort_t nSec = ( ring == 'I' ? 20 : 40 );
415 UShort_t nStr = ( ring == 'I' ? 512 : 256 );
416 for (UShort_t sec = minSector; sec < maxSector && sec < nSec; sec++) {
ef8e8623 417
418 UShort_t rate = GetSampleRate(det, ring, sec, 0);
419 std::cout << "FMD" << det << ring << "[" << std::setw(2) << sec
420 << "] sample rate: " << rate << std::endl;
421
422 if (!showStrips) continue;
c2fc1258 423 std::cout
8ec606c2 424 << " Strip | Pedestal | Gain | ZS thr. | Address\n"
425 << "--------+-------------------+------------+---------+---------"
c2fc1258 426 << std::endl;
a9579262 427 for (UShort_t str = minStrip; str < nStr && str < maxStrip; str++) {
428 if (str == minStrip) std::cout << std::setw(3) << sec << ",";
429 else std::cout << " ";
430 std::cout << std::setw(3) << str << " | ";
431 if (IsDead(det, ring, sec, str)) {
c2fc1258 432 std::cout << "dead" << std::endl;
433 continue;
434 }
435 UInt_t ddl, addr;
a9579262 436 Detector2Hardware(det, ring, sec, str, ddl, addr);
437 std::cout << std::setw(7) << GetPedestal(det, ring, sec, str)
c2fc1258 438 << "+/-" << std::setw(7)
a9579262 439 << GetPedestalWidth(det, ring, sec, str)
8ec606c2 440 << " | " << std::setw(10)
a9579262 441 << GetPulseGain(det, ring, sec, str)
442 << " | " << std::setw(7)
443 << GetZeroSuppression(det, ring, sec, str)
c2fc1258 444 << " | 0x" << std::hex << std::setw(4)
445 << std::setfill('0') << ddl << ",0x" << std::setw(3)
446 << addr << std::dec << std::setfill(' ') << std::endl;
a9579262 447 } // for (strip)
448 } // for (sector)
449 std::cout
450 << "============================================================="
451 << std::endl;
452 } // while (ring)
453 } // while (det)
454
c2fc1258 455}
456
457//__________________________________________________________________
458void
459AliFMDParameters::SetStripRange(UShort_t min, UShort_t max)
460{
02a27b50 461 // Set fixed strip range
c2fc1258 462 fFixedMinStrip = min;
463 fFixedMaxStrip = max;
464}
465
dc02d468 466//__________________________________________________________________
467AliCDBEntry*
468AliFMDParameters::GetEntry(const char* path, AliFMDPreprocessor* pp,
469 Bool_t fatal) const
470{
471 // Get an entry from the CDB or via preprocessor
472 AliCDBEntry* entry = 0;
473 if (!pp) {
474 AliCDBManager* cdb = AliCDBManager::Instance();
475 entry = cdb->Get(path);
476 }
477 else {
478 const char* third = gSystem->BaseName(path);
479 const char* second = gSystem->BaseName(gSystem->DirName(path));
480 entry = pp->GetFromCDB(second, third);
481 }
482 if (!entry) {
483 TString msg(Form("No %s found in CDB, perhaps you need to "
484 "use AliFMDCalibFaker?", path));
485 if (fatal) { AliFatal(msg.Data()); }
486 else AliLog::Message(AliLog::kWarning, msg.Data(), "FMD",
487 "AliFMDParameters", "GetEntry", __FILE__,
488 __LINE__);
489 return 0;
490 }
491 return entry;
492}
493
494
1e8f773e 495//__________________________________________________________________
496void
dc02d468 497AliFMDParameters::InitPulseGain(AliFMDPreprocessor* pp)
1e8f773e 498{
02a27b50 499 // Get pulse gain from CDB or used fixed
dc02d468 500 AliCDBEntry* gain = GetEntry(fgkPulseGain, pp);
501 if (!gain) return;
57c3c593 502
42f1b2f5 503 AliFMDDebug(5, ("Got gain from CDB"));
1e8f773e 504 fPulseGain = dynamic_cast<AliFMDCalibGain*>(gain->GetObject());
f95a63c4 505 if (!fPulseGain) AliFatal("Invalid pulser gain object from CDB");
1e8f773e 506}
507//__________________________________________________________________
508void
dc02d468 509AliFMDParameters::InitPedestal(AliFMDPreprocessor* pp)
1e8f773e 510{
02a27b50 511 // Initialize the pedestals from CDB
dc02d468 512 AliCDBEntry* pedestal = GetEntry(fgkPedestal, pp);
513 if (!pedestal) return;
514
42f1b2f5 515 AliFMDDebug(5, ("Got pedestal from CDB"));
1e8f773e 516 fPedestal = dynamic_cast<AliFMDCalibPedestal*>(pedestal->GetObject());
f95a63c4 517 if (!fPedestal) AliFatal("Invalid pedestal object from CDB");
1e8f773e 518}
519
520//__________________________________________________________________
521void
dc02d468 522AliFMDParameters::InitDeadMap(AliFMDPreprocessor* pp)
1e8f773e 523{
02a27b50 524 // Get Dead-channel-map from CDB
dc02d468 525 AliCDBEntry* deadMap = GetEntry(fgkDead, pp);
526 if (!deadMap) return;
527
42f1b2f5 528 AliFMDDebug(5, ("Got dead map from CDB"));
1e8f773e 529 fDeadMap = dynamic_cast<AliFMDCalibDeadMap*>(deadMap->GetObject());
f95a63c4 530 if (!fDeadMap) AliFatal("Invalid dead map object from CDB");
1e8f773e 531}
532
533//__________________________________________________________________
534void
dc02d468 535AliFMDParameters::InitZeroSuppression(AliFMDPreprocessor* pp)
1e8f773e 536{
02a27b50 537 // Get 0-suppression from CDB
dc02d468 538 AliCDBEntry* zeroSup = GetEntry(fgkZeroSuppression, pp);
539 if (!zeroSup) return;
42f1b2f5 540 AliFMDDebug(5, ("Got zero suppression from CDB"));
1e8f773e 541 fZeroSuppression =
542 dynamic_cast<AliFMDCalibZeroSuppression*>(zeroSup->GetObject());
f95a63c4 543 if (!fZeroSuppression)AliFatal("Invalid zero suppression object from CDB");
1e8f773e 544}
545
546//__________________________________________________________________
547void
dc02d468 548AliFMDParameters::InitSampleRate(AliFMDPreprocessor* pp)
1e8f773e 549{
02a27b50 550 // get Sample rate from CDB
dc02d468 551 AliCDBEntry* sampRat = GetEntry(fgkSampleRate, pp);
552 if (!sampRat) return;
42f1b2f5 553 AliFMDDebug(5, ("Got zero suppression from CDB"));
1e8f773e 554 fSampleRate = dynamic_cast<AliFMDCalibSampleRate*>(sampRat->GetObject());
f95a63c4 555 if (!fSampleRate) AliFatal("Invalid zero suppression object from CDB");
1e8f773e 556}
557
558//__________________________________________________________________
559void
dc02d468 560AliFMDParameters::InitAltroMap(AliFMDPreprocessor* pp)
1e8f773e 561{
02a27b50 562 // Get hardware mapping from CDB
06ca6759 563 if (fAltroMap) {
564 delete fAltroMap;
565 fAltroMap = 0;
566 }
458e52e8 567 AliCDBEntry* hwMap = GetEntry(fgkAltroMap, pp, kFALSE);
dc02d468 568 if (!hwMap) return;
569
42f1b2f5 570 AliFMDDebug(5, ("Got ALTRO map from CDB"));
1e8f773e 571 fAltroMap = dynamic_cast<AliFMDAltroMapping*>(hwMap->GetObject());
572 if (!fAltroMap) {
f95a63c4 573 AliFatal("Invalid ALTRO map object from CDB");
1e8f773e 574 fAltroMap = new AliFMDAltroMapping;
57c3c593 575 }
57c3c593 576}
577
c2fc1258 578//__________________________________________________________________
579void
dc02d468 580AliFMDParameters::InitStripRange(AliFMDPreprocessor* pp)
c2fc1258 581{
02a27b50 582 // Get strips read-out from CDB
dc02d468 583 AliCDBEntry* range = GetEntry(fgkStripRange, pp);
584 if (!range) return;
42f1b2f5 585 AliFMDDebug(5, ("Got strip range from CDB"));
c2fc1258 586 fStripRange = dynamic_cast<AliFMDCalibStripRange*>(range->GetObject());
f95a63c4 587 if (!fStripRange) AliFatal("Invalid strip range object from CDB");
c2fc1258 588}
589
1e8f773e 590
8f6ee336 591//__________________________________________________________________
592Float_t
593AliFMDParameters::GetThreshold() const
594{
02a27b50 595 // Get threshold from CDB
8f6ee336 596 if (!fPulseGain) return fFixedThreshold;
597 return fPulseGain->Threshold();
598}
599
600//__________________________________________________________________
601Float_t
602AliFMDParameters::GetPulseGain(UShort_t detector, Char_t ring,
603 UShort_t sector, UShort_t strip) const
604{
605 // Returns the pulser calibrated gain for strip # strip in sector #
606 // sector or ring id ring of detector # detector.
607 //
608 // For simulation, this is normally set to
609 //
610 // VA1_MIP_Range
611 // ------------------ * MIP_Energy_Loss
612 // ALTRO_channel_size
613 //
614 if (!fPulseGain) {
615 if (fFixedPulseGain <= 0)
616 fFixedPulseGain = fVA1MipRange * GetEdepMip() / fAltroChannelSize;
617 return fFixedPulseGain;
618 }
f95a63c4 619 AliFMDDebug(50, ("pulse gain for FMD%d%c[%2d,%3d]=%f",
1e8f773e 620 detector, ring, sector, strip,
621 fPulseGain->Value(detector, ring, sector, strip)));
8f6ee336 622 return fPulseGain->Value(detector, ring, sector, strip);
623}
624
625//__________________________________________________________________
626Bool_t
627AliFMDParameters::IsDead(UShort_t detector, Char_t ring,
628 UShort_t sector, UShort_t strip) const
629{
02a27b50 630 // Check if the channel is dead
8f6ee336 631 if (!fDeadMap) return kFALSE;
f95a63c4 632 AliFMDDebug(50, ("Dead for FMD%d%c[%2d,%3d]=%s",
1e8f773e 633 detector, ring, sector, strip,
634 fDeadMap->operator()(detector, ring, sector, strip) ?
635 "no" : "yes"));
8f6ee336 636 return fDeadMap->operator()(detector, ring, sector, strip);
637}
638
639//__________________________________________________________________
640UShort_t
641AliFMDParameters::GetZeroSuppression(UShort_t detector, Char_t ring,
642 UShort_t sector, UShort_t strip) const
643{
02a27b50 644 // Get zero suppression threshold
8f6ee336 645 if (!fZeroSuppression) return fFixedZeroSuppression;
646 // Need to map strip to ALTRO chip.
f95a63c4 647 AliFMDDebug(50, ("zero sup. for FMD%d%c[%2d,%3d]=%f",
1e8f773e 648 detector, ring, sector, strip,
649 fZeroSuppression->operator()(detector, ring,
650 sector, strip)));
8f6ee336 651 return fZeroSuppression->operator()(detector, ring, sector, strip/128);
652}
653
654//__________________________________________________________________
655UShort_t
c2fc1258 656AliFMDParameters::GetSampleRate(UShort_t det, Char_t ring, UShort_t sector,
657 UShort_t str) const
8f6ee336 658{
02a27b50 659 // Get sampl rate
8f6ee336 660 if (!fSampleRate) return fFixedSampleRate;
661 // Need to map sector to digitizier card.
c2fc1258 662 UInt_t ret = fSampleRate->Rate(det, ring, sector, str);
f95a63c4 663 AliFMDDebug(50, ("Sample rate for FMD%d%c[%2d,%3d]=%d",
c2fc1258 664 det, ring, sector, str, ret));
665 return ret;
666}
667
668//__________________________________________________________________
669UShort_t
670AliFMDParameters::GetMinStrip(UShort_t det, Char_t ring, UShort_t sector,
671 UShort_t str) const
672{
02a27b50 673 // Get strip range read out
c2fc1258 674 if (!fStripRange) return fFixedMinStrip;
675 // Need to map sector to digitizier card.
676 UInt_t ret = fStripRange->Min(det, ring, sector, str);
f95a63c4 677 AliFMDDebug(50, ("Min strip # for FMD%d%c[%2d,%3d]=%d",
c2fc1258 678 det, ring, sector, str, ret));
679 return ret;
680}
681
682//__________________________________________________________________
683UShort_t
684AliFMDParameters::GetMaxStrip(UShort_t det, Char_t ring, UShort_t sector,
685 UShort_t str) const
686{
02a27b50 687 // Get strip range read out
c2fc1258 688 if (!fStripRange) return fFixedMaxStrip;
689 // Need to map sector to digitizier card.
690 UInt_t ret = fStripRange->Max(det, ring, sector, str);
f95a63c4 691 AliFMDDebug(50, ("Max strip # for FMD%d%c[%2d,%3d]=%d",
c2fc1258 692 det, ring, sector, str, ret));
693 return ret;
8f6ee336 694}
1a1fdef7 695
8f6ee336 696//__________________________________________________________________
697Float_t
698AliFMDParameters::GetPedestal(UShort_t detector, Char_t ring,
699 UShort_t sector, UShort_t strip) const
700{
02a27b50 701 // Get the pedesal
8f6ee336 702 if (!fPedestal) return fFixedPedestal;
f95a63c4 703 AliFMDDebug(50, ("pedestal for FMD%d%c[%2d,%3d]=%f",
1e8f773e 704 detector, ring, sector, strip,
705 fPedestal->Value(detector, ring, sector, strip)));
8f6ee336 706 return fPedestal->Value(detector, ring, sector, strip);
707}
708
709//__________________________________________________________________
710Float_t
711AliFMDParameters::GetPedestalWidth(UShort_t detector, Char_t ring,
712 UShort_t sector, UShort_t strip) const
713{
02a27b50 714 // Get the pedesal
8f6ee336 715 if (!fPedestal) return fFixedPedestalWidth;
f95a63c4 716 AliFMDDebug(50, ("pedetal width for FMD%d%c[%2d,%3d]=%f",
1e8f773e 717 detector, ring, sector, strip,
718 fPedestal->Width(detector, ring, sector, strip)));
8f6ee336 719 return fPedestal->Width(detector, ring, sector, strip);
720}
721
1a1fdef7 722//__________________________________________________________________
57c3c593 723AliFMDAltroMapping*
724AliFMDParameters::GetAltroMap() const
725{
02a27b50 726 // Get the hardware address to detector index map
57c3c593 727 return fAltroMap;
1a1fdef7 728}
729
57c3c593 730
bf000c32 731//__________________________________________________________________
732Bool_t
f6449cc0 733AliFMDParameters::Hardware2Detector(UInt_t ddl, UInt_t board,
734 UInt_t chip, UInt_t chan,
735 UShort_t& det, Char_t& ring,
736 UShort_t& sec, UShort_t& str) const
737{
738 // Map hardware address to detector index
739 if (!fAltroMap) return kFALSE;
740 return fAltroMap->Hardware2Detector(ddl,board,chip,chan, det,ring,sec,str);
741}
742//__________________________________________________________________
743Bool_t
744AliFMDParameters::Hardware2Detector(UInt_t ddl, UInt_t addr,
745 UShort_t& det, Char_t& ring,
746 UShort_t& sec, UShort_t& str) const
bf000c32 747{
02a27b50 748 // Map hardware address to detector index
57c3c593 749 if (!fAltroMap) return kFALSE;
750 return fAltroMap->Hardware2Detector(ddl, addr, det, ring, sec, str);
bf000c32 751}
752
753//__________________________________________________________________
754Bool_t
f6449cc0 755AliFMDParameters::Detector2Hardware(UShort_t det, Char_t ring,
756 UShort_t sec, UShort_t str,
757 UInt_t& ddl, UInt_t& board,
758 UInt_t& chip, UInt_t& chan) const
759{
760 // Map detector index to hardware address
761 if (!fAltroMap) return kFALSE;
762 return fAltroMap->Detector2Hardware(det,ring,sec,str, ddl,board,chip,chan);
763}
764
765//__________________________________________________________________
766Bool_t
767AliFMDParameters::Detector2Hardware(UShort_t det, Char_t ring,
768 UShort_t sec, UShort_t str,
769 UInt_t& ddl, UInt_t& addr) const
bf000c32 770{
02a27b50 771 // Map detector index to hardware address
57c3c593 772 if (!fAltroMap) return kFALSE;
773 return fAltroMap->Detector2Hardware(det, ring, sec, str, ddl, addr);
bf000c32 774}
775
57c3c593 776
777//__________________________________________________________________
778Float_t
779AliFMDParameters::GetEdepMip() const
780{
781 // Get energy deposited by a MIP in the silicon sensors
782 if (fEdepMip <= 0){
783 AliFMDGeometry* fmd = AliFMDGeometry::Instance();
02a27b50 784 fEdepMip = (fkSiDeDxMip
57c3c593 785 * fmd->GetRing('I')->GetSiThickness()
786 * fmd->GetSiDensity());
787 }
788 return fEdepMip;
789}
790
791
bf000c32 792
793
794
1a1fdef7 795//____________________________________________________________________
796//
797// EOF
798//