TRD/AliTRDPreprocessorOffline.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   Responsible: marian.ivanov@cern.ch
  20   Code to analyze the TPC calibration and to produce OCDB entries
  21
  22
  23    .x ~/rootlogon.C
  24    gSystem->Load("libANALYSIS");
  25    gSystem->Load("libTPCcalib");
  26
  27    AliTRDPreprocessorOffline proces;
  28    TString ocdbPath="local:////"
  29    ocdbPath+=gSystem->GetFromPipe("pwd");
  30
  31    proces.CalibTimeGain("CalibObjects.root",run0,run1,ocdbPath);
  32    proces.CalibTimeVdrift("CalibObjects.root",run0,run1,ocdbPath);
  33   // take the raw calibration data from the file CalibObjects.root
  34   // and make a OCDB entry with run  validity run0-run1
  35   // results are stored at the ocdbPath - local or alien ...
  36   // default storage ""- data stored at current working directory
  37
  38 */
  39 #include "Riostream.h"
  40 #include <fstream>
  41 #include "TFile.h"
  42 #include "TCanvas.h"
  43 #include "TLegend.h"
  44 #include "TH2I.h"
  45 #include "TH1I.h"
  46 #include "TH2F.h"
  47 #include "TH1F.h"
  48 #include "TProfile2D.h"
  49 #include "AliTRDCalDet.h"
  50 #include "AliTRDCalPad.h"
  51 #include "AliCDBMetaData.h"
  52 #include "AliCDBId.h"
  53 #include "AliCDBManager.h"
  54 #include "AliCDBStorage.h"
  55 #include "AliTRDCalibraMode.h"
  56 #include "AliTRDCalibraFit.h"
  57 #include "AliTRDCalibraVdriftLinearFit.h"
  58 #include "AliTRDPreprocessorOffline.h"
  59
  60
  61 ClassImp(AliTRDPreprocessorOffline)
  62
  63 AliTRDPreprocessorOffline::AliTRDPreprocessorOffline():
  64   TNamed("TPCPreprocessorOffline","TPCPreprocessorOffline"),
  65   fMethodSecond(kTRUE),
  66   fNameList("TRDCalib"),
  67   fCalDetGainUsed(0x0),
  68   fCH2d(0x0),
  69   fPH2d(0x0),
  70   fPRF2d(0x0),
  71   fAliTRDCalibraVdriftLinearFit(0x0),
  72   fNEvents(0x0),
  73   fAbsoluteGain(0x0),
  74   fPlots(new TObjArray(8)),
  75   fCalibObjects(new TObjArray(8))
  76 {
  77   //
  78   // default constructor
  79   //
  80 }
  81
  82 AliTRDPreprocessorOffline::~AliTRDPreprocessorOffline() {
  83   //
  84   // Destructor
  85   //
  86
  87   if(fCalDetGainUsed) delete fCalDetGainUsed;
  88   if(fCH2d) delete fCH2d;
  89   if(fPH2d) delete fPH2d;
  90   if(fPRF2d) delete fPRF2d;
  91   if(fAliTRDCalibraVdriftLinearFit) delete fAliTRDCalibraVdriftLinearFit;
  92   if(fNEvents) delete fNEvents;
  93   if(fAbsoluteGain) delete fAbsoluteGain;
  94   if(fPlots) delete fPlots;
  95   if(fCalibObjects) delete fCalibObjects;
  96
  97 }
  98
  99 void AliTRDPreprocessorOffline::CalibVdriftT0(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
 100   //
 101   // make calibration of the drift velocity
 102   // Input parameters:
 103   //      file                             - the location of input file
 104   //      startRunNumber, endRunNumber     - run validity period
 105   //      ocdbStorage                      - path to the OCDB storage
 106   //                                       - if empty - local storage 'pwd' uesed
 107   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
 108   //
 109   // 1. Initialization
 110   //
 111   //
 112   // 2. extraction of the information
 113   //
 114   if(ReadVdriftT0Global(file)) AnalyzeVdriftT0();
 115   if(ReadVdriftLinearFitGlobal(file)) AnalyzeVdriftLinearFit();
 116   //
 117   // 3. Append QA plots
 118   //
 119   //MakeDefaultPlots(fVdriftArray,fVdriftArray);
 120   //
 121   //
 122   // 4. update of OCDB
 123   //
 124   //
 125   UpdateOCDBVdrift(startRunNumber,endRunNumber,ocdbStorage);
 126   UpdateOCDBT0(startRunNumber,endRunNumber,ocdbStorage);
 127
 128 }
 129
 130
 131 void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
 132   //
 133   // make calibration of the drift velocity
 134   // Input parameters:
 135   //      file                             - the location of input file
 136   //      startRunNumber, endRunNumber     - run validity period
 137   //      ocdbStorage                      - path to the OCDB storage
 138   //                                       - if empty - local storage 'pwd' uesed
 139   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
 140   //
 141   // 1. Initialization
 142   if(!ReadGainGlobal(file)) return;
 143   //
 144   //
 145   // 2. extraction of the information
 146   //
 147   AnalyzeGain();
 148   if(fCalDetGainUsed) CorrectFromDetGainUsed();
 149   //
 150   // 3. Append QA plots
 151   //
 152   //MakeDefaultPlots(fVdriftArray,fVdriftArray);
 153   //
 154   //
 155   // 4. update of OCDB
 156   //
 157   //
 158   UpdateOCDBGain(startRunNumber,endRunNumber,ocdbStorage);
 159
 160 }
 161
 162
 163 void AliTRDPreprocessorOffline::CalibPRF(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
 164   //
 165   // make calibration of the drift velocity
 166   // Input parameters:
 167   //      file                             - the location of input file
 168   //      startRunNumber, endRunNumber     - run validity period
 169   //      ocdbStorage                      - path to the OCDB storage
 170   //                                       - if empty - local storage 'pwd' uesed
 171   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
 172   //
 173   // 1. Initialization
 174   if(!ReadPRFGlobal(file)) return;
 175   //
 176   //
 177   // 2. extraction of the information
 178   //
 179   AnalyzePRF();
 180   //
 181   // 3. Append QA plots
 182   //
 183   //MakeDefaultPlots(fVdriftArray,fVdriftArray);
 184   //
 185   //
 186   // 4. update of OCDB
 187   //
 188   //
 189   UpdateOCDBPRF(startRunNumber,endRunNumber,ocdbStorage);
 190
 191 }
 192
 193
 194 Bool_t AliTRDPreprocessorOffline::ReadGainGlobal(const Char_t* fileName){
 195   //
 196   // read calibration entries from file
 197   //
 198   TFile fcalib(fileName);
 199   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
 200   if (array){
 201     TH2I *ch2d = (TH2I *) array->FindObject("CH2d");
 202     if(!ch2d) return kFALSE;
 203     fCH2d = (TH2I*)ch2d->Clone();
 204     //fNEvents = (TH1I *) array->FindObject("NEvents");
 205     //fAbsoluteGain = (TH2F *) array->FindObject("AbsoluteGain");
 206   }else{
 207     TH2I *ch2d = (TH2I *) fcalib.Get("CH2d");
 208     if(!ch2d) return kFALSE;
 209     fCH2d = (TH2I*)ch2d->Clone();
 210     //fNEvents = (TH1I *) fcalib.Get("NEvents");
 211     //fAbsoluteGain = (TH2F *) fcalib.Get("AbsoluteGain");
 212   }
 213   fCH2d->SetDirectory(0);
 214   //printf("title of CH2d %s\n",fCH2d->GetTitle());
 215
 216   return kTRUE;
 217
 218 }
 219
 220 Bool_t AliTRDPreprocessorOffline::ReadVdriftT0Global(const Char_t* fileName){
 221   //
 222   // read calibration entries from file
 223   //
 224   TFile fcalib(fileName);
 225   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
 226   if (array){
 227     TProfile2D *ph2d = (TProfile2D *) array->FindObject("PH2d");
 228     if(!ph2d) return kFALSE;
 229     fPH2d = (TProfile2D*)ph2d->Clone();
 230     //fNEvents = (TH1I *) array->FindObject("NEvents");
 231   }else{
 232     TProfile2D *ph2d = (TProfile2D *) fcalib.Get("PH2d");
 233     if(!ph2d) return kFALSE;
 234     fPH2d = (TProfile2D*)ph2d->Clone();
 235     //fNEvents = (TH1I *) fcalib.Get("NEvents");
 236   }
 237   fPH2d->SetDirectory(0);
 238   //printf("title of PH2d %s\n",fPH2d->GetTitle());
 239
 240   return kTRUE;
 241
 242 }
 243
 244 Bool_t AliTRDPreprocessorOffline::ReadVdriftLinearFitGlobal(const Char_t* fileName){
 245   //
 246   // read calibration entries from file
 247   //
 248   TFile fcalib(fileName);
 249   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
 250   if (array){
 251     fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) array->FindObject("AliTRDCalibraVdriftLinearFit");
 252     //fNEvents = (TH1I *) array->FindObject("NEvents");
 253   }else{
 254     fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) fcalib.Get("AliTRDCalibraVdriftLinearFit");
 255     //fNEvents = (TH1I *) fcalib.Get("NEvents");
 256   }
 257   if(!fAliTRDCalibraVdriftLinearFit) {
 258     //printf("No AliTRDCalibraVdriftLinearFit\n");
 259     return kFALSE;
 260   }
 261   return kTRUE;
 262
 263 }
 264
 265 Bool_t AliTRDPreprocessorOffline::ReadPRFGlobal(const Char_t* fileName){
 266   //
 267   // read calibration entries from file
 268   //
 269   TFile fcalib(fileName);
 270   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
 271   if (array){
 272     TProfile2D *prf2d = (TProfile2D *) array->FindObject("PRF2d");
 273     if(!prf2d) return kFALSE;
 274     fPRF2d = (TProfile2D*)prf2d->Clone();
 275     //fNEvents = (TH1I *) array->FindObject("NEvents");
 276   }else{
 277     TProfile2D *prf2d = (TProfile2D *) fcalib.Get("PRF2d");
 278     if(!prf2d) return kFALSE;
 279     fPRF2d = (TProfile2D*)prf2d->Clone();
 280     //fNEvents = (TH1I *) fcalib.Get("NEvents");
 281   }
 282   fPRF2d->SetDirectory(0);
 283   //printf("title of PRF2d %s\n",fPRF2d->GetTitle());
 284
 285   return kTRUE;
 286
 287 }
 288
 289
 290
 291 Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){
 292   //
 293   // Analyze gain - produce the calibration objects
 294   //
 295
 296   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 297   calibra->SetMinEntries(800); // If there is less than 1000 entries in the histo: no fit
 298   calibra->AnalyseCH(fCH2d);
 299
 300   Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
 301     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
 302   Int_t nbfit       = calibra->GetNumberFit();
 303   Int_t nbE         = calibra->GetNumberEnt();
 304
 305
 306   Bool_t ok = kFALSE;
 307   // enough statistics
 308   if ((nbtg >                  0) &&
 309       (nbfit        >= 0.5*nbE) && (nbE > 30)) {
 310     // create the cal objects
 311     calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 312     TObjArray object           = calibra->GetVectorFit();
 313     AliTRDCalDet *calDetGain   = calibra->CreateDetObjectGain(&object);
 314     TH1F *coefGain  = calDetGain->MakeHisto1DAsFunctionOfDet();
 315     // Put them in the array
 316     fCalibObjects->AddAt(calDetGain,kGain);
 317     fPlots->AddAt(coefGain,kGain);
 318     //
 319     ok = kTRUE;
 320   }
 321
 322   calibra->ResetVectorFit();
 323
 324   return ok;
 325
 326 }
 327
 328 Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftT0(){
 329   //
 330   // Analyze VdriftT0 - produce the calibration objects
 331   //
 332
 333   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 334   calibra->SetMinEntries(800*20); // If there is less than 1000 entries in the histo: no fit
 335   calibra->AnalysePH(fPH2d);
 336
 337   Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
 338     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
 339   Int_t nbfit       = calibra->GetNumberFit();
 340   Int_t nbfitSuccess = calibra->GetNumberFitSuccess();
 341   Int_t nbE         = calibra->GetNumberEnt();
 342
 343   //printf("nbtg %d, nbfit %d, nbE %d, nbfitSuccess %d\n",nbtg,nbfit,nbE,nbfitSuccess);
 344
 345   Bool_t ok = kFALSE;
 346   if ((nbtg >                  0) &&
 347       (nbfit        >= 0.5*nbE) && (nbE > 30) && (nbfitSuccess > 30)) {
 348     //printf("Pass the cut for VdriftT0\n");
 349     // create the cal objects
 350     calibra->RemoveOutliers(1,kFALSE);
 351     calibra->PutMeanValueOtherVectorFit(1,kFALSE);
 352     calibra->RemoveOutliers2(kFALSE);
 353     calibra->PutMeanValueOtherVectorFit2(1,kFALSE);
 354     //
 355     TObjArray object = calibra->GetVectorFit();
 356     AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object);
 357     TH1F *coefVdriftPH  = calDetVdrift->MakeHisto1DAsFunctionOfDet();
 358     AliTRDCalPad *calPadVdrift = (AliTRDCalPad *)calibra->CreatePadObjectVdrift(&object,calDetVdrift);
 359     TH1F *coefPadVdrift   = calPadVdrift->MakeHisto1D();
 360     object       = calibra->GetVectorFit2();
 361     AliTRDCalDet *calDetT0  = calibra->CreateDetObjectT0(&object);
 362     TH1F *coefT0  = calDetT0->MakeHisto1DAsFunctionOfDet();
 363     AliTRDCalPad *calPadT0 = (AliTRDCalPad *)calibra->CreatePadObjectT0(&object,calDetT0);
 364     TH1F *coefPadT0  = calPadT0->MakeHisto1D();
 365     // Put them in the array
 366     fCalibObjects->AddAt(calDetT0,kT0PHDet);
 367     fCalibObjects->AddAt(calDetVdrift,kVdriftPHDet);
 368     fCalibObjects->AddAt(calPadT0,kT0PHPad);
 369     fCalibObjects->AddAt(calPadVdrift,kVdriftPHPad);
 370     fPlots->AddAt(coefVdriftPH,kVdriftPHDet);
 371     fPlots->AddAt(coefT0,kT0PHDet);
 372     fPlots->AddAt(coefPadVdrift,kVdriftPHPad);
 373     fPlots->AddAt(coefPadT0,kT0PHPad);
 374     //
 375     ok = kTRUE;
 376   }
 377   calibra->ResetVectorFit();
 378
 379   return ok;
 380
 381 }
 382
 383 Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){
 384   //
 385   // Analyze vdrift linear fit - produce the calibration objects
 386   //
 387
 388   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 389   calibra->SetMinEntries(800); // If there is less than 1000 entries in the histo: no fit
 390   fAliTRDCalibraVdriftLinearFit->FillPEArray();
 391   calibra->AnalyseLinearFitters(fAliTRDCalibraVdriftLinearFit);
 392
 393   //Int_t nbtg        = 540;
 394   Int_t nbfit       = calibra->GetNumberFit();
 395   Int_t nbE         = calibra->GetNumberEnt();
 396
 397
 398   Bool_t ok = kFALSE;
 399   // enough statistics
 400   if ((nbfit        >= 0.5*nbE) && (nbE > 30)) {
 401     // create the cal objects
 402     //calibra->RemoveOutliers(1,kTRUE);
 403     calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 404     //calibra->RemoveOutliers2(kTRUE);
 405     calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
 406     //
 407     TObjArray object  = calibra->GetVectorFit();
 408     AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object,kTRUE);
 409     TH1F *coefDriftLinear      = calDetVdrift->MakeHisto1DAsFunctionOfDet();
 410     object                     = calibra->GetVectorFit2();
 411     AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectLorentzAngle(&object);
 412     TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
 413     // Put them in the array
 414     fCalibObjects->AddAt(calDetVdrift,kVdriftLinear);
 415     fCalibObjects->AddAt(calDetLorentz,kLorentzLinear);
 416     fPlots->AddAt(coefDriftLinear,kVdriftLinear);
 417     fPlots->AddAt(coefLorentzAngle,kLorentzLinear);
 418     //
 419     ok = kTRUE;
 420   }
 421
 422   calibra->ResetVectorFit();
 423
 424   return ok;
 425
 426 }
 427
 428
 429 Bool_t AliTRDPreprocessorOffline::AnalyzePRF(){
 430   //
 431   // Analyze PRF - produce the calibration objects
 432   //
 433
 434   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 435   calibra->SetMinEntries(600); // If there is less than 1000 entries in the histo: no fit
 436   calibra->AnalysePRFMarianFit(fPRF2d);
 437
 438   Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
 439     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
 440   Int_t nbfit       = calibra->GetNumberFit();
 441   Int_t nbE         = calibra->GetNumberEnt();
 442
 443
 444   Bool_t ok = kFALSE;
 445   // enough statistics
 446   if ((nbtg >                  0) &&
 447       (nbfit        >= 0.95*nbE) && (nbE > 30)) {
 448     // create the cal objects
 449     TObjArray object  = calibra->GetVectorFit();
 450     AliTRDCalPad *calPadPRF = (AliTRDCalPad*) calibra->CreatePadObjectPRF(&object);
 451     TH1F *coefPRF           = calPadPRF->MakeHisto1D();
 452     // Put them in the array
 453     fCalibObjects->AddAt(calPadPRF,kPRF);
 454     fPlots->AddAt(coefPRF,kPRF);
 455     //
 456     ok = kTRUE;
 457   }
 458
 459   calibra->ResetVectorFit();
 460
 461   return ok;
 462
 463 }
 464
 465 void AliTRDPreprocessorOffline::CorrectFromDetGainUsed() {
 466
 467   AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
 468   if(!calDetGain) return;
 469
 470   for(Int_t det = 0; det < 540; det++) {
 471
 472     Float_t gaininit = fCalDetGainUsed->GetValue(det);
 473     Float_t gainout = calDetGain->GetValue(det);
 474
 475     calDetGain->SetValue(det,gaininit*gainout);
 476
 477   }
 478
 479
 480 }
 481
 482 void AliTRDPreprocessorOffline::UpdateOCDBGain(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
 483   //
 484   // Update OCDB entry
 485   //
 486
 487   AliCDBMetaData *metaData= new AliCDBMetaData();
 488   metaData->SetObjectClassName("AliTRDCalDet");
 489   metaData->SetResponsible("Raphaelle Bailhache");
 490   metaData->SetBeamPeriod(1);
 491
 492   AliCDBId id1("TRD/Calib/ChamberGainFactor", startRunNumber, endRunNumber);
 493   AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
 494   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
 495   if(calDet) gStorage->Put(calDet, id1, metaData);
 496   //else {
 497   //  printf("No calDet object for Gain\n");
 498   //}
 499
 500
 501
 502 }
 503
 504 void AliTRDPreprocessorOffline::UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
 505   //
 506   // Update OCDB entry
 507   //
 508
 509   Int_t detVdrift = kVdriftPHDet;
 510
 511   if(fMethodSecond) detVdrift = kVdriftLinear;
 512
 513   AliCDBMetaData *metaData= new AliCDBMetaData();
 514   metaData->SetObjectClassName("AliTRDCalDet");
 515   metaData->SetResponsible("Raphaelle Bailhache");
 516   metaData->SetBeamPeriod(1);
 517
 518   AliCDBId id1("TRD/Calib/ChamberVdrift", startRunNumber, endRunNumber);
 519   AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
 520   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
 521   if(calDet) gStorage->Put(calDet, id1, metaData);
 522   //else {
 523   //  printf("No calDet object for Vdrift\n");
 524   //}
 525
 526   //
 527
 528   if(!fMethodSecond) {
 529
 530     AliCDBMetaData *metaDataPad= new AliCDBMetaData();
 531     metaDataPad->SetObjectClassName("AliTRDCalPad");
 532     metaDataPad->SetResponsible("Raphaelle Bailhache");
 533     metaDataPad->SetBeamPeriod(1);
 534
 535     AliCDBId id1Pad("TRD/Calib/LocalVdrift", startRunNumber, endRunNumber);
 536     AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
 537     if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
 538     //else {
 539     //  printf("No calPad object for Vdrift\n");
 540     //}
 541
 542
 543   }
 544
 545 }
 546
 547 void AliTRDPreprocessorOffline::UpdateOCDBT0(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
 548   //
 549   // Update OCDB entry
 550   //
 551
 552   AliCDBMetaData *metaData= new AliCDBMetaData();
 553   metaData->SetObjectClassName("AliTRDCalDet");
 554   metaData->SetResponsible("Raphaelle Bailhache");
 555   metaData->SetBeamPeriod(1);
 556
 557   AliCDBId id1("TRD/Calib/ChamberT0", startRunNumber, endRunNumber);
 558   AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
 559   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
 560   if(calDet) gStorage->Put(calDet, id1, metaData);
 561   //else {
 562   //  printf("No calDet object for T0\n");
 563   //}
 564
 565
 566   //
 567
 568   AliCDBMetaData *metaDataPad= new AliCDBMetaData();
 569   metaDataPad->SetObjectClassName("AliTRDCalPad");
 570   metaDataPad->SetResponsible("Raphaelle Bailhache");
 571   metaDataPad->SetBeamPeriod(1);
 572
 573   AliCDBId id1Pad("TRD/Calib/LocalT0", startRunNumber, endRunNumber);
 574   AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
 575   if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
 576   //else {
 577   //  printf("No calPad object for T0\n");
 578   //}
 579
 580
 581 }
 582
 583 void AliTRDPreprocessorOffline::UpdateOCDBPRF(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
 584   //
 585   // Update OCDB entry
 586   //
 587
 588   AliCDBMetaData *metaData= new AliCDBMetaData();
 589   metaData->SetObjectClassName("AliTRDCalPad");
 590   metaData->SetResponsible("Raphaelle Bailhache");
 591   metaData->SetBeamPeriod(1);
 592
 593   AliCDBId id1("TRD/Calib/PRFWidth", startRunNumber, endRunNumber);
 594   AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
 595   AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
 596   if(calPad) gStorage->Put(calPad, id1, metaData);
 597   //else {
 598   //  printf("No calPad object for PRF\n");
 599   //}
 600
 601
 602 }
 603