FMD/AliFMDParameters.cxx

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