TPC/AliTPCcalibDB.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
  16
  17 ///////////////////////////////////////////////////////////////////////////////
  18 //                                                                           //
  19 // Class providing the calibration parameters by accessing the CDB           //
  20 //                                                                           //
  21 // Request an instance with AliTPCcalibDB::Instance()                        //
  22 // If a new event is processed set the event number with SetRun              //
  23 // Then request the calibration data                                         ////
  24
  25 //
  26 //
  27 // Calibration data:
  28 // 1.)  pad by pad calibration -  AliTPCCalPad
  29 //
  30 //      a.) fPadGainFactor
  31 //          Simulation: AliTPCDigitizer::ExecFast - Multiply by gain
  32 //          Reconstruction : AliTPCclustererMI::Digits2Clusters - Divide by gain
  33 //
  34 //      b.) fPadNoise -
  35 //          Simulation:        AliTPCDigitizer::ExecFast
  36 //          Reconstruction:    AliTPCclustererMI::FindClusters(AliTPCCalROC * noiseROC)
  37 //                             Noise depending cut on clusters (n sigma)
  38 //      c.) fPedestal:
  39 //          Simulation:     Not used yet - To be impleneted - Rounding to the nearest integer
  40 //          Reconstruction: Used in AliTPCclustererMI::Digits2Clusters(AliRawReader* rawReader)
  41 //                          if data taken without zero suppression
  42 //                          Currently switch in  fRecoParam->GetCalcPedestal();
  43 //
  44 //      d.) fPadTime0
  45 //          Simulation:      applied in the AliTPC::MakeSector - adding offset
  46 //          Reconstruction:  AliTPCTransform::Transform() - remove offset
  47 //                           AliTPCTransform::Transform() - to be called
  48 //                           in AliTPCtracker::Transform()
  49 ///////////////////////////////////////////////////////////////////////////////
  50
  51 #include <iostream>
  52 #include <fstream>
  53
  54
  55 #include <AliCDBManager.h>
  56 #include <AliCDBEntry.h>
  57 #include <AliLog.h>
  58
  59 #include "AliTPCcalibDB.h"
  60 #include "AliTPCExB.h"
  61
  62 #include "AliTPCCalROC.h"
  63 #include "AliTPCCalPad.h"
  64 #include "AliTPCSensorTempArray.h"
  65 #include "AliTPCTransform.h"
  66 class AliCDBStorage;
  67 class AliTPCCalDet;
  68 //
  69 //
  70
  71 #include "TFile.h"
  72 #include "TKey.h"
  73
  74 #include "TObjArray.h"
  75 #include "TObjString.h"
  76 #include "TString.h"
  77 #include "AliTPCCalPad.h"
  78 #include "AliTPCCalibPulser.h"
  79 #include "AliTPCCalibPedestal.h"
  80 #include "AliTPCCalibCE.h"
  81
  82
  83
  84
  85
  86 ClassImp(AliTPCcalibDB)
  87
  88 AliTPCcalibDB* AliTPCcalibDB::fgInstance = 0;
  89 Bool_t AliTPCcalibDB::fgTerminated = kFALSE;
  90
  91
  92 //_ singleton implementation __________________________________________________
  93 AliTPCcalibDB* AliTPCcalibDB::Instance()
  94 {
  95   //
  96   // Singleton implementation
  97   // Returns an instance of this class, it is created if neccessary
  98   //
  99
 100   if (fgTerminated != kFALSE)
 101     return 0;
 102
 103   if (fgInstance == 0)
 104     fgInstance = new AliTPCcalibDB();
 105
 106   return fgInstance;
 107 }
 108
 109 void AliTPCcalibDB::Terminate()
 110 {
 111   //
 112   // Singleton implementation
 113   // Deletes the instance of this class and sets the terminated flag, instances cannot be requested anymore
 114   // This function can be called several times.
 115   //
 116
 117   fgTerminated = kTRUE;
 118
 119   if (fgInstance != 0)
 120   {
 121     delete fgInstance;
 122     fgInstance = 0;
 123   }
 124 }
 125
 126 //_____________________________________________________________________________
 127 AliTPCcalibDB::AliTPCcalibDB():
 128   fRun(-1),
 129   fTransform(0),
 130   fExB(0),
 131   fPadGainFactor(0),
 132   fPadTime0(0),
 133   fPadNoise(0),
 134   fPedestals(0),
 135   fTemperature(0),
 136   fParam(0)
 137 {
 138   //
 139   // constructor
 140   //
 141   //
 142   Update();    // temporary
 143 }
 144
 145 //_____________________________________________________________________________
 146 AliTPCcalibDB::~AliTPCcalibDB()
 147 {
 148   //
 149   // destructor
 150   //
 151
 152   // don't delete anything, CDB cache is active!
 153   //if (fPadGainFactor) delete fPadGainFactor;
 154   //if (fPadTime0) delete fPadTime0;
 155   //if (fPadNoise) delete fPadNoise;
 156 }
 157
 158
 159 //_____________________________________________________________________________
 160 AliCDBEntry* AliTPCcalibDB::GetCDBEntry(const char* cdbPath)
 161 {
 162   //
 163   // Retrieves an entry with path <cdbPath> from the CDB.
 164   //
 165   char chinfo[1000];
 166
 167   AliCDBEntry* entry = AliCDBManager::Instance()->Get(cdbPath, fRun);
 168   if (!entry)
 169   {
 170     sprintf(chinfo,"AliTPCcalibDB: Failed to get entry:\t%s ", cdbPath);
 171     AliError(chinfo);
 172     return 0;
 173   }
 174   return entry;
 175 }
 176
 177
 178 //_____________________________________________________________________________
 179 void AliTPCcalibDB::SetRun(Long64_t run)
 180 {
 181   //
 182   // Sets current run number. Calibration data is read from the corresponding file.
 183   //
 184   if (fRun == run)
 185     return;
 186   fRun = run;
 187   Update();
 188 }
 189
 190
 191
 192 void AliTPCcalibDB::Update(){
 193   //
 194   AliCDBEntry * entry=0;
 195
 196   Bool_t cdbCache = AliCDBManager::Instance()->GetCacheFlag(); // save cache status
 197   AliCDBManager::Instance()->SetCacheFlag(kTRUE); // activate CDB cache
 198
 199   //
 200   entry          = GetCDBEntry("TPC/Calib/PadGainFactor");
 201   if (entry){
 202     //if (fPadGainFactor) delete fPadGainFactor;
 203     entry->SetOwner(kTRUE);
 204     fPadGainFactor = (AliTPCCalPad*)entry->GetObject();
 205   }
 206   //
 207   entry          = GetCDBEntry("TPC/Calib/PadTime0");
 208   if (entry){
 209     //if (fPadTime0) delete fPadTime0;
 210     entry->SetOwner(kTRUE);
 211     fPadTime0 = (AliTPCCalPad*)entry->GetObject();
 212   }
 213   //
 214   //
 215   entry          = GetCDBEntry("TPC/Calib/PadNoise");
 216   if (entry){
 217     //if (fPadNoise) delete fPadNoise;
 218     entry->SetOwner(kTRUE);
 219     fPadNoise = (AliTPCCalPad*)entry->GetObject();
 220   }
 221
 222   entry          = GetCDBEntry("TPC/Calib/Pedestals");
 223   if (entry){
 224     //if (fPedestals) delete fPedestals;
 225     entry->SetOwner(kTRUE);
 226     fPedestals = (AliTPCCalPad*)entry->GetObject();
 227   }
 228
 229   entry          = GetCDBEntry("TPC/Calib/Temperature");
 230   if (entry){
 231     //if (fTemperature) delete fTemperature;
 232     entry->SetOwner(kTRUE);
 233     fTemperature = (AliTPCSensorTempArray*)entry->GetObject();
 234   }
 235
 236   entry          = GetCDBEntry("TPC/Calib/Parameters");
 237   if (entry){
 238     //if (fPadNoise) delete fPadNoise;
 239     entry->SetOwner(kTRUE);
 240     fParam = (AliTPCParam*)(entry->GetObject()->Clone());
 241   }
 242
 243   entry          = GetCDBEntry("TPC/Calib/ExB");
 244   if (entry) {
 245     entry->SetOwner(kTRUE);
 246     fExB=dynamic_cast<AliTPCExB*>(entry->GetObject()->Clone());
 247   }
 248
 249   if (!fTransform) {
 250     fTransform=new AliTPCTransform();
 251   }
 252
 253   //
 254   AliCDBManager::Instance()->SetCacheFlag(cdbCache); // reset original CDB cache
 255
 256 }
 257 AliTPCcalibDB::AliTPCcalibDB(const AliTPCcalibDB& org)
 258 {
 259   //
 260   // Copy constructor invalid -- singleton implementation
 261   //
 262    Error("copy constructor","invalid -- singleton implementation");
 263 }
 264
 265 AliTPCcalibDB& AliTPCcalibDB::operator= (const AliTPCcalibDB& rhs)
 266 {
 267 //
 268 // Singleton implementation - no assignment operator
 269 //
 270   Error("operator =", "assignment operator not implemented");
 271   return *this;
 272 }
 273
 274
 275
 276 void AliTPCcalibDB::CreateObjectList(const Char_t *filename, TObjArray *calibObjects)
 277 {
 278 //
 279 // Create calibration objects and read contents from OCDB
 280 //
 281    if ( calibObjects == 0x0 ) return;
 282    ifstream in;
 283    in.open(filename);
 284    if ( !in.is_open() ){
 285       fprintf(stderr,"Error: cannot open list file '%s'", filename);
 286       return;
 287    }
 288
 289    AliTPCCalPad *calPad=0x0;
 290
 291    TString sFile;
 292    sFile.ReadFile(in);
 293    in.close();
 294
 295    TObjArray *arrFileLine = sFile.Tokenize("\n");
 296
 297    TIter nextLine(arrFileLine);
 298
 299    TObjString *sObjLine=0x0;
 300    while ( sObjLine = (TObjString*)nextLine() ){
 301       TString sLine(sObjLine->GetString());
 302
 303       TObjArray *arrNextCol = sLine.Tokenize("\t");
 304
 305       TObjString *sObjType     = (TObjString*)(arrNextCol->At(0));
 306       TObjString *sObjFileName = (TObjString*)(arrNextCol->At(1));
 307
 308       if ( !sObjType || ! sObjFileName ) continue;
 309       TString sType(sObjType->GetString());
 310       TString sFileName(sObjFileName->GetString());
 311       printf("%s\t%s\n",sType.Data(),sFileName.Data());
 312
 313       TFile *fIn = TFile::Open(sFileName);
 314       if ( !fIn ){
 315          fprintf(stderr,"File not found: '%s'", sFileName.Data());
 316          continue;
 317       }
 318
 319       if ( sType == "CE" ){
 320          AliTPCCalibCE *ce = (AliTPCCalibCE*)fIn->Get("AliTPCCalibCE");
 321
 322          calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadT0());
 323          calPad->SetNameTitle("CETmean","CETmean");
 324          calibObjects->Add(calPad);
 325
 326          calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadQ());
 327          calPad->SetNameTitle("CEQmean","CEQmean");
 328          calibObjects->Add(calPad);
 329
 330          calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadRMS());
 331          calPad->SetNameTitle("CETrms","CETrms");
 332          calibObjects->Add(calPad);
 333
 334       } else if ( sType == "Pulser") {
 335          AliTPCCalibPulser *sig = (AliTPCCalibPulser*)fIn->Get("AliTPCCalibPulser");
 336
 337          calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadT0());
 338          calPad->SetNameTitle("PulserTmean","PulserTmean");
 339          calibObjects->Add(calPad);
 340
 341          calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadQ());
 342          calPad->SetNameTitle("PulserQmean","PulserQmean");
 343          calibObjects->Add(calPad);
 344
 345          calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadRMS());
 346          calPad->SetNameTitle("PulserTrms","PulserTrms");
 347          calibObjects->Add(calPad);
 348
 349       } else if ( sType == "Pedestals") {
 350          AliTPCCalibPedestal *ped = (AliTPCCalibPedestal*)fIn->Get("AliTPCCalibPedestal");
 351
 352          calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadPedestal());
 353          calPad->SetNameTitle("Pedestals","Pedestals");
 354          calibObjects->Add(calPad);
 355
 356          calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadRMS());
 357          calPad->SetNameTitle("Noise","Noise");
 358          calibObjects->Add(calPad);
 359
 360       } else {
 361          fprintf(stderr,"Undefined Type: '%s'",sType.Data());
 362
 363       }
 364       delete fIn;
 365    }
 366 }
 367
 368
 369
 370 void AliTPCcalibDB::MakeTree(const char * fileName, TObjArray * array, const char * mapFileName, AliTPCCalPad* outlierPad, Float_t ltmFraction) {
 371   //
 372   // Write a tree with all available information
 373   // if mapFileName is specified, the Map information are also written to the tree
 374   // pads specified in outlierPad are not used for calculating statistics
 375   //  - the same function as AliTPCCalPad::MakeTree -
 376   //
 377    AliTPCROC* tpcROCinstance = AliTPCROC::Instance();
 378
 379    TObjArray* mapIROCs = 0;
 380    TObjArray* mapOROCs = 0;
 381    TVectorF *mapIROCArray = 0;
 382    TVectorF *mapOROCArray = 0;
 383    Int_t mapEntries = 0;
 384    TString* mapNames = 0;
 385
 386    if (mapFileName) {
 387       TFile mapFile(mapFileName, "read");
 388
 389       TList* listOfROCs = mapFile.GetListOfKeys();
 390       mapEntries = listOfROCs->GetEntries()/2;
 391       mapIROCs = new TObjArray(mapEntries*2);
 392       mapOROCs = new TObjArray(mapEntries*2);
 393       mapIROCArray = new TVectorF[mapEntries];
 394       mapOROCArray = new TVectorF[mapEntries];
 395
 396       mapNames = new TString[mapEntries];
 397       for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
 398         TString nameROC(((TKey*)(listOfROCs->At(ivalue*2)))->GetName());
 399          nameROC.Remove(nameROC.Length()-4, 4);
 400          mapIROCs->AddAt((AliTPCCalROC*)mapFile.Get((nameROC + "IROC").Data()), ivalue);
 401          mapOROCs->AddAt((AliTPCCalROC*)mapFile.Get((nameROC + "OROC").Data()), ivalue);
 402          mapNames[ivalue].Append(nameROC);
 403       }
 404
 405       for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
 406          mapIROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(0));
 407          mapOROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(36));
 408
 409          for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(0); ichannel++)
 410             (mapIROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapIROCs->At(ivalue)))->GetValue(ichannel);
 411          for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(36); ichannel++)
 412             (mapOROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapOROCs->At(ivalue)))->GetValue(ichannel);
 413       }
 414
 415    } //  if (mapFileName)
 416
 417    TTreeSRedirector cstream(fileName);
 418    Int_t arrayEntries = array->GetEntries();
 419
 420    TString* names = new TString[arrayEntries];
 421    for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
 422       names[ivalue].Append(((AliTPCCalPad*)array->At(ivalue))->GetName());
 423
 424    for (UInt_t isector = 0; isector < tpcROCinstance->GetNSectors(); isector++) {
 425       //
 426       // get statistic for given sector
 427       //
 428       TVectorF median(arrayEntries);
 429       TVectorF mean(arrayEntries);
 430       TVectorF rms(arrayEntries);
 431       TVectorF ltm(arrayEntries);
 432       TVectorF ltmrms(arrayEntries);
 433       TVectorF medianWithOut(arrayEntries);
 434       TVectorF meanWithOut(arrayEntries);
 435       TVectorF rmsWithOut(arrayEntries);
 436       TVectorF ltmWithOut(arrayEntries);
 437       TVectorF ltmrmsWithOut(arrayEntries);
 438
 439       TVectorF *vectorArray = new TVectorF[arrayEntries];
 440       for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
 441          vectorArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
 442
 443       for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
 444          AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
 445          AliTPCCalROC* calROC = calPad->GetCalROC(isector);
 446          AliTPCCalROC* outlierROC = 0;
 447          if (outlierPad) outlierROC = outlierPad->GetCalROC(isector);
 448          if (calROC) {
 449             median[ivalue] = calROC->GetMedian();
 450             mean[ivalue] = calROC->GetMean();
 451             rms[ivalue] = calROC->GetRMS();
 452             Double_t ltmrmsValue = 0;
 453             ltm[ivalue] = calROC->GetLTM(&ltmrmsValue, ltmFraction);
 454             ltmrms[ivalue] = ltmrmsValue;
 455             if (outlierROC) {
 456                medianWithOut[ivalue] = calROC->GetMedian(outlierROC);
 457                meanWithOut[ivalue] = calROC->GetMean(outlierROC);
 458                rmsWithOut[ivalue] = calROC->GetRMS(outlierROC);
 459                ltmrmsValue = 0;
 460                ltmWithOut[ivalue] = calROC->GetLTM(&ltmrmsValue, ltmFraction, outlierROC);
 461                ltmrmsWithOut[ivalue] = ltmrmsValue;
 462             }
 463          }
 464          else {
 465             median[ivalue] = 0.;
 466             mean[ivalue] = 0.;
 467             rms[ivalue] = 0.;
 468             ltm[ivalue] = 0.;
 469             ltmrms[ivalue] = 0.;
 470             medianWithOut[ivalue] = 0.;
 471             meanWithOut[ivalue] = 0.;
 472             rmsWithOut[ivalue] = 0.;
 473             ltmWithOut[ivalue] = 0.;
 474             ltmrmsWithOut[ivalue] = 0.;
 475          }
 476       }
 477
 478       //
 479       // fill vectors of variable per pad
 480       //
 481       TVectorF *posArray = new TVectorF[8];
 482       for (Int_t ivalue = 0; ivalue < 8; ivalue++)
 483          posArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
 484
 485       Float_t posG[3] = {0};
 486       Float_t posL[3] = {0};
 487       Int_t ichannel = 0;
 488       for (UInt_t irow = 0; irow < tpcROCinstance->GetNRows(isector); irow++) {
 489          for (UInt_t ipad = 0; ipad < tpcROCinstance->GetNPads(isector, irow); ipad++) {
 490             tpcROCinstance->GetPositionLocal(isector, irow, ipad, posL);
 491             tpcROCinstance->GetPositionGlobal(isector, irow, ipad, posG);
 492             posArray[0][ichannel] = irow;
 493             posArray[1][ichannel] = ipad;
 494             posArray[2][ichannel] = posL[0];
 495             posArray[3][ichannel] = posL[1];
 496             posArray[4][ichannel] = posG[0];
 497             posArray[5][ichannel] = posG[1];
 498             posArray[6][ichannel] = (Int_t)(ipad - (Double_t)(tpcROCinstance->GetNPads(isector, irow))/2);
 499             posArray[7][ichannel] = ichannel;
 500
 501             // loop over array containing AliTPCCalPads
 502             for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
 503                AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
 504                AliTPCCalROC* calROC = calPad->GetCalROC(isector);
 505                if (calROC)
 506                   (vectorArray[ivalue])[ichannel] = calROC->GetValue(irow, ipad);
 507                else
 508                   (vectorArray[ivalue])[ichannel] = 0;
 509             }
 510             ichannel++;
 511          }
 512       }
 513
 514       cstream << "calPads" <<
 515          "sector=" << isector;
 516
 517       for  (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
 518          cstream << "calPads" <<
 519             (Char_t*)((names[ivalue] + "_Median=").Data()) << median[ivalue] <<
 520             (Char_t*)((names[ivalue] + "_Mean=").Data()) << mean[ivalue] <<
 521             (Char_t*)((names[ivalue] + "_RMS=").Data()) << rms[ivalue] <<
 522             (Char_t*)((names[ivalue] + "_LTM=").Data()) << ltm[ivalue] <<
 523             (Char_t*)((names[ivalue] + "_RMS_LTM=").Data()) << ltmrms[ivalue];
 524          if (outlierPad) {
 525             cstream << "calPads" <<
 526                (Char_t*)((names[ivalue] + "_Median_OutlierCutted=").Data()) << medianWithOut[ivalue] <<
 527                (Char_t*)((names[ivalue] + "_Mean_OutlierCutted=").Data()) << meanWithOut[ivalue] <<
 528                (Char_t*)((names[ivalue] + "_RMS_OutlierCutted=").Data()) << rmsWithOut[ivalue] <<
 529                (Char_t*)((names[ivalue] + "_LTM_OutlierCutted=").Data()) << ltmWithOut[ivalue] <<
 530                (Char_t*)((names[ivalue] + "_RMS_LTM_OutlierCutted=").Data()) << ltmrmsWithOut[ivalue];
 531          }
 532       }
 533
 534       for  (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
 535          cstream << "calPads" <<
 536             (Char_t*)((names[ivalue] + ".=").Data()) << &vectorArray[ivalue];
 537       }
 538
 539       if (mapFileName) {
 540          for  (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
 541             if (isector < 36)
 542                cstream << "calPads" <<
 543                   (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapIROCArray[ivalue];
 544             else
 545                cstream << "calPads" <<
 546                   (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapOROCArray[ivalue];
 547          }
 548       }
 549
 550       cstream << "calPads" <<
 551          "row.=" << &posArray[0] <<
 552          "pad.=" << &posArray[1] <<
 553          "lx.=" << &posArray[2] <<
 554          "ly.=" << &posArray[3] <<
 555          "gx.=" << &posArray[4] <<
 556          "gy.=" << &posArray[5] <<
 557          "rpad.=" << &posArray[6] <<
 558          "channel.=" << &posArray[7];
 559
 560       cstream << "calPads" <<
 561          "\n";
 562
 563       delete[] posArray;
 564       delete[] vectorArray;
 565    }
 566
 567
 568    delete[] names;
 569    if (mapFileName) {
 570       delete mapIROCs;
 571       delete mapOROCs;
 572       delete[] mapIROCArray;
 573       delete[] mapOROCArray;
 574       delete[] mapNames;
 575    }
 576 }
 577