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: Raphaelle Bailhache (rbailhache@ikf.uni-frankfurt.de)
  20   Code to analyze the TRD calibration and to produce OCDB entries
  21
  22
  23    .x ~/rootlogon.C
  24    gSystem->Load("libANALYSIS");
  25    gSystem->Load("libTRDcalib");
  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 "AliLog.h"
  40 #include "Riostream.h"
  41 #include <fstream>
  42 #include "TFile.h"
  43 #include "TCanvas.h"
  44 #include "TLegend.h"
  45 #include "TH2I.h"
  46 #include "TH1I.h"
  47 #include "TH2F.h"
  48 #include "TH1F.h"
  49 #include "TMath.h"
  50 #include "THnSparse.h"
  51 #include "TProfile2D.h"
  52 #include "AliTRDCalDet.h"
  53 #include "AliTRDCalPad.h"
  54 #include "AliCDBMetaData.h"
  55 #include "AliCDBId.h"
  56 #include "AliCDBManager.h"
  57 #include "AliCDBStorage.h"
  58 #include "AliTRDCalibraMode.h"
  59 #include "AliTRDCalibraFit.h"
  60 #include "AliTRDCalibraVdriftLinearFit.h"
  61 #include "AliTRDCalibraExbAltFit.h"
  62 #include "AliTRDPreprocessorOffline.h"
  63 #include "AliTRDCalChamberStatus.h"
  64 #include "AliTRDCalibChamberStatus.h"
  65 #include "AliTRDCommonParam.h"
  66 #include "AliCDBManager.h"
  67 #include "AliCDBEntry.h"
  68 #include "AliTRDdEdxUtils.h"
  69
  70 ClassImp(AliTRDPreprocessorOffline)
  71
  72   AliTRDPreprocessorOffline::AliTRDPreprocessorOffline():
  73   TNamed("TPCPreprocessorOffline","TPCPreprocessorOffline"),
  74   fMethodSecond(kTRUE),
  75   fNameList("TRDCalib"),
  76   fCalDetGainUsed(0x0),
  77   fCalDetVdriftUsed(0x0),
  78   fCalDetExBUsed(0x0),
  79   fCH2d(0x0),
  80   fPH2d(0x0),
  81   fPRF2d(0x0),
  82   fSparse(0x0),
  83   fAliTRDCalibraVdriftLinearFit(0x0),
  84   fAliTRDCalibraExbAltFit(0x0),
  85   fNEvents(0x0),
  86   fAbsoluteGain(0x0),
  87   fPlots(new TObjArray(kNumCalibObjs)),
  88   fCalibObjects(new TObjArray(kNumCalibObjs)),
  89   fFirstRunGainUsed(0),
  90   fVersionGainUsed(0),
  91   fSubVersionGainUsed(0),
  92   fFirstRunVdriftUsed(0),
  93   fVersionVdriftUsed(0),
  94   fSubVersionVdriftUsed(0),
  95   fFirstRunExBUsed(0),
  96   fVersionExBUsed(0),
  97   fSubVersionExBUsed(0),
  98   fNoExBUsedInReco(kFALSE),
  99   fSwitchOnValidation(kTRUE),
 100   fVdriftValidated(kFALSE),
 101   fExBValidated(kFALSE),
 102   fT0Validated(kFALSE),
 103   fMinStatsVdriftT0PH(800*20),
 104   fMinStatsVdriftLinear(800),
 105   fMinStatsGain(800),
 106   fMinStatsPRF(600),
 107   fMinStatsChamberStatus(20),
 108   fMinSingleStatsChamberStatus(0.05),
 109   fBackCorrectGain(kFALSE),
 110   fBackCorrectVdrift(kTRUE),
 111   fNotEnoughStatisticsForTheGain(kFALSE),
 112   fNotEnoughStatisticsForTheVdriftLinear(kFALSE),
 113   fStatusNeg(0),
 114   fStatusPos(0),
 115   fBadCalibValidate(40),
 116   fNoDataValidate(40),
 117   fRMSBadCalibratedGain(20.0),
 118   fRMSBadCalibratedVdrift(20.0),
 119   fRMSBadCalibratedExB(20.0),
 120   fRobustFitDriftVelocity(kTRUE),
 121   fRobustFitExbAlt(kFALSE),
 122   fAlternativeVdrfitFit(kFALSE),
 123   fAlternativeExbAltFit(kFALSE),
 124   fMinNbOfPointVdriftFit(11),
 125   fMethodeGain(0),
 126   fOutliersFitChargeLow(0.03),
 127   fOutliersFitChargeHigh(0.7),
 128   fBeginFitCharge(3.5),
 129   fPHQon(kTRUE)
 130 {
 131   //
 132   // default constructor
 133   //
 134
 135   memset(fBadCalib, 0, sizeof(Int_t) * 18);
 136   memset(fNoData, 0, sizeof(Int_t) * 18);
 137 }
 138 //_________________________________________________________________________________________________________________
 139 AliTRDPreprocessorOffline::~AliTRDPreprocessorOffline() {
 140   //
 141   // Destructor
 142   //
 143
 144   if(fCalDetGainUsed) delete fCalDetGainUsed;
 145   if(fCalDetVdriftUsed) delete fCalDetVdriftUsed;
 146   if(fCalDetExBUsed) delete fCalDetExBUsed;
 147   if(fCH2d) delete fCH2d;
 148   if(fPH2d) delete fPH2d;
 149   if(fPRF2d) delete fPRF2d;
 150   if(fSparse) delete fSparse;
 151
 152   if(IsPHQon()){
 153     AliTRDdEdxUtils::DeleteCalibHist();
 154     AliTRDdEdxUtils::DeleteCalibObj();
 155   }
 156
 157   if(fAliTRDCalibraVdriftLinearFit) delete fAliTRDCalibraVdriftLinearFit;
 158   if(fAliTRDCalibraExbAltFit) delete fAliTRDCalibraExbAltFit;
 159   if(fNEvents) delete fNEvents;
 160   if(fAbsoluteGain) delete fAbsoluteGain;
 161   if(fPlots) delete fPlots;
 162   if(fCalibObjects) delete fCalibObjects;
 163
 164 }
 165 //___________________________________________________________________________________
 166 void AliTRDPreprocessorOffline::Process(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage)
 167 {
 168   //
 169   // Process to the gain, vdrift, timeoffset, exb and chamber status calibration
 170   //
 171
 172   if(SetCalDetGain(startRunNumber,fVersionGainUsed,fSubVersionGainUsed) && SetCalDetVdriftExB(startRunNumber,fVersionVdriftUsed,fSubVersionVdriftUsed,fVersionExBUsed,fSubVersionExBUsed)) {
 173
 174     CalibVdriftT0(file,startRunNumber,endRunNumber,ocdbStorage);
 175     CalibGain(file,startRunNumber,endRunNumber,ocdbStorage);
 176     CalibChamberStatus(file,startRunNumber,endRunNumber,ocdbStorage);
 177     CalibExbAlt(file,startRunNumber,endRunNumber,ocdbStorage);
 178
 179   }
 180
 181   if(IsPHQon()){
 182     printf("\n                  AliTRDPreprocessorOffline PHQ on!!\n\n");
 183     AliTRDdEdxUtils::PrintControl();
 184     CalibPHQ(file, startRunNumber, endRunNumber, ocdbStorage);
 185   }
 186   else{
 187     printf("\n                  AliTRDPreprocessorOffline PHQ off!!\n\n");
 188   }
 189
 190   PrintStatus();
 191
 192 }
 193 //___________________________________________________________________________________________________________________
 194
 195 void AliTRDPreprocessorOffline::CalibVdriftT0(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
 196   //
 197   // make calibration of the drift velocity
 198   // Input parameters:
 199   //      file                             - the location of input file
 200   //      startRunNumber, endRunNumber     - run validity period
 201   //      ocdbStorage                      - path to the OCDB storage
 202   //                                       - if empty - local storage 'pwd' uesed
 203   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
 204   //
 205   // 1. Initialization
 206   //
 207   fVdriftValidated = kTRUE;
 208   fT0Validated = kTRUE;
 209   fExBValidated = kTRUE;
 210   fNotEnoughStatisticsForTheVdriftLinear = kFALSE;
 211   //
 212   // 2. extraction of the information
 213   //
 214   if(ReadVdriftLinearFitGlobal(file) && fCalDetVdriftUsed && fCalDetExBUsed) AnalyzeVdriftLinearFit();
 215   if(ReadVdriftT0Global(file)) AnalyzeVdriftT0();
 216   //
 217   // 3. Append QA plots
 218   //
 219   //MakeDefaultPlots(fVdriftArray,fVdriftArray);
 220   //
 221   //
 222   // 4. validate OCDB entries
 223   //
 224   if(fSwitchOnValidation==kTRUE && ValidateVdrift()==kFALSE) {
 225     //AliError("TRD vdrift OCDB parameters out of range!");
 226     fVdriftValidated = kFALSE;
 227   }
 228   if(fSwitchOnValidation==kTRUE && ValidateT0()==kFALSE) {
 229     //AliError("TRD t0 OCDB parameters out of range!");
 230     fT0Validated = kFALSE;
 231   }
 232   if(fSwitchOnValidation==kTRUE && ValidateExB()==kFALSE) {
 233     //AliError("TRD t0 OCDB parameters out of range!");
 234     fExBValidated = kFALSE;
 235   }
 236   //
 237   // 5. update of OCDB
 238   //
 239   //
 240   if(fVdriftValidated) UpdateOCDBVdrift(startRunNumber,endRunNumber,ocdbStorage);
 241   if(fT0Validated) UpdateOCDBT0(startRunNumber,endRunNumber,ocdbStorage);
 242   if(fExBValidated) UpdateOCDBExB(startRunNumber,endRunNumber,ocdbStorage);
 243
 244 }
 245 //___________________________________________________________________________________________________________________
 246
 247 void AliTRDPreprocessorOffline::CalibExbAlt(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
 248   //
 249   // make calibration of the drift velocity
 250   // Input parameters:
 251   //      file                             - the location of input file
 252   //      startRunNumber, endRunNumber     - run validity period
 253   //      ocdbStorage                      - path to the OCDB storage
 254   //                                       - if empty - local storage 'pwd' uesed
 255   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
 256   //
 257   // 1. Initialization
 258   //
 259
 260   //
 261   // 2. extraction of the information
 262   //
 263   if(ReadExbAltFitGlobal(file)) AnalyzeExbAltFit();
 264   //
 265   // 3. Append QA plots
 266   //
 267   //MakeDefaultPlots(fVdriftArray,fVdriftArray);
 268   //
 269   //
 270   // 4. validate OCDB entries
 271   //
 272   //
 273   // 5. update of OCDB
 274   //
 275   //
 276   UpdateOCDBExBAlt(startRunNumber,endRunNumber,ocdbStorage);
 277
 278 }
 279
 280 //_________________________________________________________________________________________________________________
 281
 282 void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
 283   //
 284   // make calibration of the drift velocity
 285   // Input parameters:
 286   //      file                             - the location of input file
 287   //      startRunNumber, endRunNumber     - run validity period
 288   //      ocdbStorage                      - path to the OCDB storage
 289   //                                       - if empty - local storage 'pwd' uesed
 290   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
 291   //
 292   fNotEnoughStatisticsForTheGain = kFALSE;
 293   //
 294   // 1. Initialization
 295   if(!ReadGainGlobal(file)) return;
 296   //
 297   //
 298   // 2. extraction of the information
 299   //
 300   AnalyzeGain();
 301   if(fBackCorrectGain) CorrectFromDetGainUsed();
 302   //if(fBackCorrectVdrift) CorrectFromDetVdriftUsed();
 303   //
 304   // 3. Append QA plots
 305   //
 306   //MakeDefaultPlots(fVdriftArray,fVdriftArray);
 307   //
 308   //
 309   // 4. validate OCDB entries
 310   //
 311   if(fSwitchOnValidation==kTRUE && ValidateGain()==kFALSE) {
 312     //AliError("TRD gain OCDB parameters out of range!");
 313     return;
 314   }
 315   //
 316   // 5. update of OCDB
 317   //
 318   //
 319   if((!fCalDetVdriftUsed) || (fCalDetVdriftUsed && fVdriftValidated)) UpdateOCDBGain(startRunNumber,endRunNumber,ocdbStorage);
 320
 321
 322 }
 323 //________________________________________________________________________________________________________________
 324
 325 void AliTRDPreprocessorOffline::CalibPRF(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
 326   //
 327   // make calibration of the drift velocity
 328   // Input parameters:
 329   //      file                             - the location of input file
 330   //      startRunNumber, endRunNumber     - run validity period
 331   //      ocdbStorage                      - path to the OCDB storage
 332   //                                       - if empty - local storage 'pwd' uesed
 333   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
 334   //
 335   // 1. Initialization
 336   if(!ReadPRFGlobal(file)) return;
 337   //
 338   //
 339   // 2. extraction of the information
 340   //
 341   AnalyzePRF();
 342   //
 343   // 3. Append QA plots
 344   //
 345   //MakeDefaultPlots(fVdriftArray,fVdriftArray);
 346   //
 347   //
 348   //
 349   // 4. validate OCDB entries
 350   //
 351   if(fSwitchOnValidation==kTRUE && ValidatePRF()==kFALSE) {
 352     //AliError("TRD prf OCDB parameters out of range!");
 353     return;
 354   }
 355   //
 356   // 5. update of OCDB
 357   //
 358   //
 359   UpdateOCDBPRF(startRunNumber,endRunNumber,ocdbStorage);
 360
 361 }
 362 //________________________________________________________________________________________________________________
 363 void AliTRDPreprocessorOffline::CalibPHQ(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage)
 364 {
 365   //
 366   // make calibration of puls height Q
 367   // Input parameters:
 368   //      startRunNumber, endRunNumber     - run validity period
 369   //      ocdbStorage                      - path to the OCDB storage
 370   //                                       - if empty - local storage 'pwd' uesed
 371   //
 372
 373   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
 374   //printf("test %s\n", ocdbStorage.Data());
 375
 376   if(!ReadPHQGlobal(file)) return;
 377
 378   if(!AnalyzePHQ(startRunNumber)) return;
 379
 380   UpdateOCDBPHQ(startRunNumber,endRunNumber,ocdbStorage);
 381 }
 382
 383 //________________________________________________________________________________________________________________
 384
 385 void AliTRDPreprocessorOffline::CalibChamberStatus(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
 386   //
 387   // make calibration of the chamber status
 388   // Input parameters:
 389   //      startRunNumber, endRunNumber     - run validity period
 390   //      ocdbStorage                      - path to the OCDB storage
 391   //                                       - if empty - local storage 'pwd' uesed
 392   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
 393   //
 394   //
 395   // 1. Initialization
 396   if(!ReadStatusGlobal(file)) return;
 397   //
 398   //
 399   //
 400   // 2. extraction of the information
 401   //
 402   if(!AnalyzeChamberStatus()) return;
 403   //
 404   // 3. Append QA plots
 405   //
 406   //MakeDefaultPlots(fVdriftArray,fVdriftArray);
 407   //
 408   //
 409   //
 410   // 4. validate OCDB entries
 411   //
 412   if(fSwitchOnValidation==kTRUE && ValidateChamberStatus()==kFALSE) {
 413     //AliError("TRD Chamber status OCDB parameters not ok!");
 414     return;
 415   }
 416   //
 417   // 5. update of OCDB
 418   //
 419   //
 420   if((!fNotEnoughStatisticsForTheVdriftLinear) && (!fNotEnoughStatisticsForTheGain)) UpdateOCDBChamberStatus(startRunNumber,endRunNumber,ocdbStorage);
 421   //UpdateOCDBChamberStatus(startRunNumber,endRunNumber,ocdbStorage);
 422
 423 }
 424 //______________________________________________________________________________________________________
 425 Bool_t AliTRDPreprocessorOffline::Init(const Char_t* fileName){
 426   //
 427   // read the calibration used during the reconstruction
 428   //
 429
 430   if(ReadVdriftT0Global(fileName)) {
 431
 432     TString nameph = fPH2d->GetTitle();
 433     fFirstRunVdriftUsed = GetFirstRun(nameph);
 434     fVersionVdriftUsed = GetVersion(nameph);
 435     fSubVersionVdriftUsed = GetSubVersion(nameph);
 436
 437     //printf("Found Version %d, Subversion %d for vdrift\n",fVersionVdriftUsed,fSubVersionVdriftUsed);
 438
 439   }
 440
 441   if(ReadGainGlobal(fileName)) {
 442
 443     TString namech = fCH2d->GetTitle();
 444     fFirstRunGainUsed = GetFirstRun(namech);
 445     fVersionGainUsed = GetVersion(namech);
 446     fSubVersionGainUsed = GetSubVersion(namech);
 447
 448     //printf("Found Version %d, Subversion %d for gain\n",fVersionGainUsed,fSubVersionGainUsed);
 449
 450   }
 451
 452   if(ReadVdriftLinearFitGlobal(fileName)) {
 453
 454     TString namelinear = fAliTRDCalibraVdriftLinearFit->GetNameCalibUsed();
 455     fFirstRunExBUsed = GetFirstRun(namelinear);
 456     fVersionExBUsed = GetVersion(namelinear);
 457     fSubVersionExBUsed = GetSubVersion(namelinear);
 458
 459     //printf("Found Version %d, Subversion %d, run %d for ExB\n",fVersionExBUsed,fSubVersionExBUsed,fFirstRunExBUsed);
 460
 461   }
 462
 463   if(fVersionVdriftUsed == 0) fStatusPos = fStatusPos |kVdriftErrorOld;
 464   if(fVersionGainUsed == 0) fStatusPos = fStatusPos | kGainErrorOld;
 465
 466   return kTRUE;
 467
 468 }
 469 //___________________________________________________________________________________________________________________
 470
 471 Bool_t AliTRDPreprocessorOffline::ReadStatusGlobal(const Char_t* fileName){
 472   //
 473   // read calibration entries from file
 474   //
 475   if(fSparse) return kTRUE;
 476   TFile fcalib(fileName);
 477   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
 478   if (array){
 479     fSparse = (THnSparseI *) array->FindObject("NumberOfEntries");
 480     if(!fSparse) return kFALSE;
 481   }
 482   else
 483     return kFALSE;
 484
 485   return kTRUE;
 486
 487 }
 488 //___________________________________________________________________________________________________________________
 489
 490 Bool_t AliTRDPreprocessorOffline::ReadPHQGlobal(const Char_t* fileName)
 491 {
 492   //
 493   // read calibration entries from file
 494   //
 495
 496   return AliTRDdEdxUtils::ReadCalibHist(fileName, fNameList);
 497 }
 498
 499 //___________________________________________________________________________________________________________________
 500
 501 Bool_t AliTRDPreprocessorOffline::ReadGainGlobal(const Char_t* fileName){
 502   //
 503   // read calibration entries from file
 504   //
 505   if(fCH2d) return kTRUE;
 506   TFile fcalib(fileName);
 507   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
 508   if (array){
 509     TH2I *ch2d = (TH2I *) array->FindObject("CH2d");
 510     if(!ch2d) return kFALSE;
 511     fCH2d = (TH2I*)ch2d->Clone();
 512     //fNEvents = (TH1I *) array->FindObject("NEvents");
 513     //fAbsoluteGain = (TH2F *) array->FindObject("AbsoluteGain");
 514   }else{
 515     TH2I *ch2d = (TH2I *) fcalib.Get("CH2d");
 516     if(!ch2d) return kFALSE;
 517     fCH2d = (TH2I*)ch2d->Clone();
 518     //fNEvents = (TH1I *) fcalib.Get("NEvents");
 519     //fAbsoluteGain = (TH2F *) fcalib.Get("AbsoluteGain");
 520   }
 521   fCH2d->SetDirectory(0);
 522   //printf("title of CH2d %s\n",fCH2d->GetTitle());
 523
 524   return kTRUE;
 525
 526 }
 527 //_________________________________________________________________________________________________________________
 528
 529 Bool_t AliTRDPreprocessorOffline::ReadVdriftT0Global(const Char_t* fileName){
 530   //
 531   // read calibration entries from file
 532   //
 533   if(fPH2d) return kTRUE;
 534   TFile fcalib(fileName);
 535   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
 536   if (array){
 537     TProfile2D *ph2d = (TProfile2D *) array->FindObject("PH2d");
 538     if(!ph2d) return kFALSE;
 539     fPH2d = (TProfile2D*)ph2d->Clone();
 540     //fNEvents = (TH1I *) array->FindObject("NEvents");
 541   }else{
 542     TProfile2D *ph2d = (TProfile2D *) fcalib.Get("PH2d");
 543     if(!ph2d) return kFALSE;
 544     fPH2d = (TProfile2D*)ph2d->Clone();
 545     //fNEvents = (TH1I *) fcalib.Get("NEvents");
 546   }
 547   fPH2d->SetDirectory(0);
 548   //printf("title of PH2d %s\n",fPH2d->GetTitle());
 549
 550   return kTRUE;
 551
 552 }
 553 //___________________________________________________________________________________________________________________
 554
 555 Bool_t AliTRDPreprocessorOffline::ReadVdriftLinearFitGlobal(const Char_t* fileName){
 556   //
 557   // read calibration entries from file
 558   //
 559   if(fAliTRDCalibraVdriftLinearFit) return kTRUE;
 560   TFile fcalib(fileName);
 561   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
 562   if (array){
 563     fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) array->FindObject("AliTRDCalibraVdriftLinearFit");
 564     //fNEvents = (TH1I *) array->FindObject("NEvents");
 565   }else{
 566     fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) fcalib.Get("AliTRDCalibraVdriftLinearFit");
 567     //fNEvents = (TH1I *) fcalib.Get("NEvents");
 568   }
 569   if(!fAliTRDCalibraVdriftLinearFit) {
 570     //printf("No AliTRDCalibraVdriftLinearFit\n");
 571     return kFALSE;
 572   }
 573   return kTRUE;
 574
 575 }
 576 //_____________________________________________________________________________________________________________
 577 Bool_t AliTRDPreprocessorOffline::ReadExbAltFitGlobal(const Char_t* fileName){
 578   //
 579   // read calibration entries from file
 580   //
 581   if(fAliTRDCalibraExbAltFit) return kTRUE;
 582   TFile fcalib(fileName);
 583   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
 584   if (array){
 585     fAliTRDCalibraExbAltFit = (AliTRDCalibraExbAltFit *) array->FindObject("AliTRDCalibraExbAltFit");
 586     //fNEvents = (TH1I *) array->FindObject("NEvents");
 587   }else{
 588     fAliTRDCalibraExbAltFit = (AliTRDCalibraExbAltFit *) fcalib.Get("AliTRDCalibraExbAltFit");
 589     //fNEvents = (TH1I *) fcalib.Get("NEvents");
 590   }
 591   if(!fAliTRDCalibraExbAltFit) {
 592     //printf("No AliTRDCalibraExbAltFit\n");
 593     return kFALSE;
 594   }
 595   return kTRUE;
 596
 597 }
 598 //_____________________________________________________________________________________________________________
 599
 600 Bool_t AliTRDPreprocessorOffline::ReadPRFGlobal(const Char_t* fileName){
 601   //
 602   // read calibration entries from file
 603   //
 604   if(fPRF2d) return kTRUE;
 605   TFile fcalib(fileName);
 606   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
 607   if (array){
 608     TProfile2D *prf2d = (TProfile2D *) array->FindObject("PRF2d");
 609     if(!prf2d) return kFALSE;
 610     fPRF2d = (TProfile2D*)prf2d->Clone();
 611     //fNEvents = (TH1I *) array->FindObject("NEvents");
 612   }else{
 613     TProfile2D *prf2d = (TProfile2D *) fcalib.Get("PRF2d");
 614     if(!prf2d) return kFALSE;
 615     fPRF2d = (TProfile2D*)prf2d->Clone();
 616     //fNEvents = (TH1I *) fcalib.Get("NEvents");
 617   }
 618   fPRF2d->SetDirectory(0);
 619   //printf("title of PRF2d %s\n",fPRF2d->GetTitle());
 620
 621   return kTRUE;
 622
 623 }
 624 //__________________________________________________________________________________________________________
 625
 626 Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){
 627   //
 628   // Analyze gain - produce the calibration objects
 629   //
 630
 631   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 632   calibra->ChooseMethod(fMethodeGain);
 633   calibra->SetBeginFitCharge(fBeginFitCharge);
 634   calibra->SetFitOutliersChargeLow(fOutliersFitChargeLow);
 635   calibra->SetFitOutliersChargeHigh(fOutliersFitChargeHigh);
 636   calibra->SetMinEntries(fMinStatsGain); // If there is less than 1000 entries in the histo: no fit
 637   calibra->AnalyseCH(fCH2d);
 638
 639   Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
 640     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
 641   Int_t nbfit       = calibra->GetNumberFit();
 642   Int_t nbE         = calibra->GetNumberEnt();
 643
 644
 645   Bool_t ok = kFALSE;
 646   Bool_t meanother = kFALSE;
 647   // enough statistics
 648   if ((nbtg >                  0) &&
 649       (nbfit        >= 0.5*nbE) && (nbE > 30)) {
 650     // create the cal objects
 651     if(!fBackCorrectGain) {
 652       calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 653       meanother = kTRUE;
 654     }
 655     TObjArray object           = calibra->GetVectorFit();
 656     AliTRDCalDet *calDetGain   = calibra->CreateDetObjectGain(&object,meanother);
 657     TH1F *coefGain  = calDetGain->MakeHisto1DAsFunctionOfDet();
 658     // Put them in the array
 659     fCalibObjects->AddAt(calDetGain,kGain);
 660     fPlots->AddAt(coefGain,kGain);
 661     //
 662     ok = kTRUE;
 663   }
 664   else {
 665     fNotEnoughStatisticsForTheGain = kTRUE;
 666     Int_t minStatsGain = fMinStatsGain*30;
 667     calibra->SetMinEntries(minStatsGain); // Because we do it for all, we increase this
 668     Double_t gainoverallnotnormalized =  calibra->AnalyseCHAllTogether(fCH2d);
 669     if(fCalDetGainUsed && (gainoverallnotnormalized > 0.0)) {
 670       AliTRDCalDet *calDetGain = new AliTRDCalDet(*fCalDetGainUsed);
 671       Double_t oldmean = fCalDetGainUsed->CalcMean(kFALSE);
 672       //printf("oldmean %f\n",oldmean);
 673       if(oldmean > 0.0)  {
 674         Double_t scalefactor = calibra->GetScaleFactorGain();
 675         //printf("Correction factor %f\n",gainoverallnotnormalized*scalefactor);
 676         calDetGain->Multiply(gainoverallnotnormalized*scalefactor/oldmean);
 677         //printf("newmean %f\n",calDetGain->CalcMean(kFALSE));
 678         TH1F *coefGain  = calDetGain->MakeHisto1DAsFunctionOfDet();
 679         fCalibObjects->AddAt(calDetGain,kGain);
 680         fPlots->AddAt(coefGain,kGain);
 681         //
 682         ok = kTRUE;
 683         fStatusNeg = fStatusNeg | kGainNotEnoughStatsButFill;
 684       }
 685       else {
 686         fStatusPos = fStatusPos | kGainErrorOld;
 687       }
 688     }
 689     else {
 690       if(gainoverallnotnormalized <= 0.0) fStatusNeg = fStatusNeg | kGainNotEnoughStatsNotFill;
 691       if(!fCalDetGainUsed) fStatusPos = fStatusPos | kGainErrorOld;
 692     }
 693   }
 694
 695   calibra->ResetVectorFit();
 696
 697   return ok;
 698
 699 }
 700 //_____________________________________________________________________________________________________
 701 Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftT0(){
 702   //
 703   // Analyze VdriftT0 - produce the calibration objects
 704   //
 705
 706   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 707   calibra->SetMinEntries(fMinStatsVdriftT0PH); // If there is less than 1000 entries in the histo: no fit
 708   calibra->AnalysePH(fPH2d);
 709
 710   Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
 711     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
 712   Int_t nbfit       = calibra->GetNumberFit();
 713   Int_t nbfitSuccess = calibra->GetNumberFitSuccess();
 714   Int_t nbE         = calibra->GetNumberEnt();
 715
 716   //printf("nbtg %d, nbfit %d, nbE %d, nbfitSuccess %d\n",nbtg,nbfit,nbE,nbfitSuccess);
 717
 718   Bool_t ok = kFALSE;
 719   if ((nbtg >                  0) &&
 720       (nbfit        >= 0.5*nbE) && (nbE > 30) && (nbfitSuccess > 30)) {
 721     //printf("Pass the cut for VdriftT0\n");
 722     // create the cal objects
 723     calibra->RemoveOutliers(1,kFALSE);
 724     calibra->PutMeanValueOtherVectorFit(1,kFALSE);
 725     calibra->RemoveOutliers2(kFALSE);
 726     calibra->PutMeanValueOtherVectorFit2(1,kFALSE);
 727     //
 728     TObjArray object = calibra->GetVectorFit();
 729     AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object);
 730     TH1F *coefVdriftPH  = calDetVdrift->MakeHisto1DAsFunctionOfDet();
 731     AliTRDCalPad *calPadVdrift = (AliTRDCalPad *)calibra->CreatePadObjectVdrift(&object,calDetVdrift);
 732     TH1F *coefPadVdrift   = calPadVdrift->MakeHisto1D();
 733     object       = calibra->GetVectorFit2();
 734     AliTRDCalDet *calDetT0  = calibra->CreateDetObjectT0(&object);
 735     TH1F *coefT0  = calDetT0->MakeHisto1DAsFunctionOfDet();
 736     AliTRDCalPad *calPadT0 = (AliTRDCalPad *)calibra->CreatePadObjectT0(&object,calDetT0);
 737     TH1F *coefPadT0  = calPadT0->MakeHisto1D();
 738     // Put them in the array
 739     fCalibObjects->AddAt(calDetT0,kT0PHDet);
 740     fCalibObjects->AddAt(calDetVdrift,kVdriftPHDet);
 741     fCalibObjects->AddAt(calPadT0,kT0PHPad);
 742     fCalibObjects->AddAt(calPadVdrift,kVdriftPHPad);
 743     fPlots->AddAt(coefVdriftPH,kVdriftPHDet);
 744     fPlots->AddAt(coefT0,kT0PHDet);
 745     fPlots->AddAt(coefPadVdrift,kVdriftPHPad);
 746     fPlots->AddAt(coefPadT0,kT0PHPad);
 747     //
 748     ok = kTRUE;
 749   }
 750   else {
 751     //printf("Not enough stats timeoffset\n");
 752     fStatusNeg = fStatusNeg | kTimeOffsetNotEnoughStatsNotFill;
 753   }
 754   calibra->ResetVectorFit();
 755
 756   return ok;
 757
 758 }
 759 //____________________________________________________________________________________________________________________
 760 Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){
 761   //
 762   // Analyze vdrift linear fit - produce the calibration objects
 763   //
 764
 765   //printf("Analyse linear fit\n");
 766
 767
 768   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 769   calibra->SetCalDetVdriftExB(fCalDetVdriftUsed,fCalDetExBUsed);
 770   calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit
 771   printf("The mean stat is by %d for VdriftLinear\n",fMinStatsVdriftLinear);
 772   //printf("Fill PE Array\n");
 773   fAliTRDCalibraVdriftLinearFit->SetRobustFit(fRobustFitDriftVelocity);
 774   fAliTRDCalibraVdriftLinearFit->SetMinNumberOfPointsForFit(fMinNbOfPointVdriftFit);
 775   if(!fAlternativeVdrfitFit)
 776     fAliTRDCalibraVdriftLinearFit->FillPEArray();
 777   else
 778     fAliTRDCalibraVdriftLinearFit->FillPEArray2();
 779   //printf("AliTRDCalibraFit\n");
 780   calibra->AnalyseLinearFitters(fAliTRDCalibraVdriftLinearFit);
 781   //printf("After\n");
 782
 783   //Int_t nbtg        = 540;
 784   Int_t nbfit       = calibra->GetNumberFit();
 785   Int_t nbE         = calibra->GetNumberEnt();
 786
 787
 788   Bool_t ok = kFALSE;
 789   // enough statistics
 790   if ((nbfit        >= 0.5*nbE) && (nbE > 30)) {
 791     // create the cal objects
 792     //calibra->RemoveOutliers(1,kTRUE);
 793     calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 794     //calibra->RemoveOutliers2(kTRUE);
 795     calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
 796     //
 797     TObjArray object  = calibra->GetVectorFit();
 798     AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object,kTRUE);
 799     TH1F *coefDriftLinear      = calDetVdrift->MakeHisto1DAsFunctionOfDet();
 800     object                     = calibra->GetVectorFit2();
 801     AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectLorentzAngle(&object);
 802     TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
 803     //if(!calDetLorentz) printf("No lorentz created\n");
 804     // Put them in the array
 805     fCalibObjects->AddAt(calDetVdrift,kVdriftLinear);
 806     fCalibObjects->AddAt(calDetLorentz,kLorentzLinear);
 807     fPlots->AddAt(coefDriftLinear,kVdriftLinear);
 808     fPlots->AddAt(coefLorentzAngle,kLorentzLinear);
 809     //
 810     ok = kTRUE;
 811   }
 812   else {
 813     fNotEnoughStatisticsForTheVdriftLinear = kTRUE;
 814     Int_t minNumberOfEntriesForAll = fMinStatsVdriftLinear*30;
 815     calibra->SetMinEntries(minNumberOfEntriesForAll); // Because we do it for all, we increase this
 816     Double_t vdriftoverall = -100.0;
 817     Double_t exboverall = 100.0;
 818     calibra->AnalyseLinearFittersAllTogether(fAliTRDCalibraVdriftLinearFit,vdriftoverall,exboverall);
 819     //printf("Found mean vdrift %f and exb %f\n",vdriftoverall,exboverall);
 820     if(fCalDetVdriftUsed && (vdriftoverall > 0.0) && (exboverall < 70.0)) {
 821       AliTRDCalDet *calDetVdrift = new AliTRDCalDet(*fCalDetVdriftUsed);
 822       AliTRDCalDet *calDetLorentz = new AliTRDCalDet(*fCalDetExBUsed);
 823       Double_t oldmeanvdrift = fCalDetVdriftUsed->CalcMean(kFALSE);
 824       Double_t oldmeanexb = fCalDetExBUsed->CalcMean(kFALSE);
 825       //printf("oldmean %f\n",oldmean);
 826       if((oldmeanvdrift > 0.0) && (oldmeanexb < 70.0))  {
 827         //printf("Correction factor %f\n",vdriftoverall);
 828         calDetVdrift->Multiply(vdriftoverall/oldmeanvdrift);
 829         if(TMath::Abs(oldmeanexb) > 0.0001) calDetLorentz->Multiply(exboverall/oldmeanexb);
 830         //printf("newmean %f\n",calDetVdrift->CalcMean(kFALSE));
 831         TH1F *coefDriftLinear  = calDetVdrift->MakeHisto1DAsFunctionOfDet();
 832         TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
 833         // Put them in the array
 834         fCalibObjects->AddAt(calDetVdrift,kVdriftLinear);
 835         fCalibObjects->AddAt(calDetLorentz,kLorentzLinear);
 836         fPlots->AddAt(coefDriftLinear,kVdriftLinear);
 837         fPlots->AddAt(coefLorentzAngle,kLorentzLinear);
 838         //
 839         ok = kTRUE;
 840         fStatusNeg = fStatusNeg | kVdriftNotEnoughStatsButFill;
 841       }
 842       else {
 843         if(oldmeanvdrift) fStatusPos = fStatusPos | kVdriftErrorOld;
 844         if(oldmeanexb) fStatusPos = fStatusPos | kExBErrorOld;
 845       }
 846     }
 847     else {
 848       if((vdriftoverall <= 0.0) && (exboverall > 70.0)) fStatusNeg = fStatusNeg | kVdriftNotEnoughStatsNotFill;
 849       if(!fCalDetVdriftUsed) fStatusPos = fStatusPos | kVdriftErrorOld;
 850       if(!fCalDetExBUsed) fStatusPos = fStatusPos | kExBErrorOld;
 851     }
 852   }
 853
 854   calibra->ResetVectorFit();
 855
 856   return ok;
 857
 858 }
 859 //________________________________________________________________________________________________________________
 860
 861 Bool_t AliTRDPreprocessorOffline::AnalyzeExbAltFit(){
 862   //
 863   // Analyze vdrift linear fit - produce the calibration objects
 864   //
 865
 866   //printf("Analyse linear fit\n");
 867
 868
 869   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 870   calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit
 871   //printf("Fill PE Array\n");
 872   fAliTRDCalibraExbAltFit->SetRobustFit(fRobustFitExbAlt);
 873   if(!fAlternativeExbAltFit)
 874     fAliTRDCalibraExbAltFit->FillPEArray();
 875   else
 876     fAliTRDCalibraExbAltFit->FillPEArray2();
 877   //printf("AliTRDCalibraFit\n");
 878   calibra->AnalyseExbAltFit(fAliTRDCalibraExbAltFit);
 879   //printf("After\n");
 880
 881   //Int_t nbtg        = 540;
 882   Int_t nbfit       = calibra->GetNumberFit();
 883   Int_t nbE         = calibra->GetNumberEnt();
 884
 885
 886   Bool_t ok = kFALSE;
 887   // enough statistics
 888   if ((nbfit        >= 0.5*nbE) && (nbE > 30)) {
 889     // create the cal objects
 890     //calibra->RemoveOutliers(1,kTRUE);
 891     calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
 892     //
 893     TObjArray object  = calibra->GetVectorFit2();
 894     AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectExbAlt(&object);
 895     TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
 896     //if(!calDetLorentz) printf("No lorentz created\n");
 897     // Put them in the array
 898     fCalibObjects->AddAt(calDetLorentz,kExbAlt);
 899     fPlots->AddAt(coefLorentzAngle,kExbAlt);
 900     //
 901     ok = kTRUE;
 902   }
 903
 904   calibra->ResetVectorFit();
 905
 906   return ok;
 907
 908 }
 909 //________________________________________________________________________________________________________________
 910
 911 Bool_t AliTRDPreprocessorOffline::AnalyzePRF(){
 912   //
 913   // Analyze PRF - produce the calibration objects
 914   //
 915
 916   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 917   calibra->SetMinEntries(fMinStatsPRF); // If there is less than 1000 entries in the histo: no fit
 918   calibra->AnalysePRFMarianFit(fPRF2d);
 919
 920   Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
 921     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
 922   Int_t nbfit       = calibra->GetNumberFit();
 923   Int_t nbE         = calibra->GetNumberEnt();
 924
 925
 926   Bool_t ok = kFALSE;
 927   // enough statistics
 928   if ((nbtg >                  0) &&
 929       (nbfit        >= 0.95*nbE) && (nbE > 30)) {
 930     // create the cal objects
 931     TObjArray object  = calibra->GetVectorFit();
 932     AliTRDCalPad *calPadPRF = (AliTRDCalPad*) calibra->CreatePadObjectPRF(&object);
 933     TH1F *coefPRF           = calPadPRF->MakeHisto1D();
 934     // Put them in the array
 935     fCalibObjects->AddAt(calPadPRF,kPRF);
 936     fPlots->AddAt(coefPRF,kPRF);
 937     //
 938     ok = kTRUE;
 939   }
 940
 941   calibra->ResetVectorFit();
 942
 943   return ok;
 944
 945 }
 946
 947 //_____________________________________________________________________________
 948 Bool_t AliTRDPreprocessorOffline::AnalyzePHQ(Int_t startRunNumber)
 949 {
 950   //
 951   //Produce PHQ calibration results
 952   //
 953   for(Int_t iter=0; iter<8; iter++){
 954     THnSparseD *hi = (THnSparseD*) AliTRDdEdxUtils::GetHistPHQ()->At(iter);
 955     TObjArray *obji = AliTRDdEdxUtils::GetCalibObj(hi, startRunNumber);
 956     //printf("test analyze %s\n", obji->GetName());
 957     AliTRDdEdxUtils::GetObjPHQ()->AddAt(obji, iter);
 958   }
 959
 960   fCalibObjects->AddAt(AliTRDdEdxUtils::GetObjPHQ(), kPHQ);
 961   return kTRUE;
 962 }
 963
 964 //_____________________________________________________________________________
 965 Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
 966 {
 967   //
 968   // Produce AliTRDCalChamberStatus out of calibration results
 969   //
 970
 971   // set up AliTRDCalibChamberStatus
 972   AliTRDCalibChamberStatus *chamberStatus = new AliTRDCalibChamberStatus();
 973   chamberStatus->SetSparseI(fSparse);
 974   chamberStatus->AnalyseHisto(fMinStatsChamberStatus, fMinSingleStatsChamberStatus);
 975   // get AliTRDCalChamberStatus
 976   AliTRDCalChamberStatus *calChamberStatus = chamberStatus->GetCalChamberStatus();
 977
 978   // get calibration objects
 979   AliTRDCalDet *calDetGain   = (AliTRDCalDet *) fCalibObjects->At(kGain);
 980   AliTRDCalDet *calDetVDrift = (AliTRDCalDet *) fCalibObjects->At(kVdriftLinear);
 981   AliTRDCalDet *calDetExB    = (AliTRDCalDet *) fCalibObjects->At(kLorentzLinear);
 982
 983   // Check
 984   if((!calDetGain) || (!calDetVDrift) || (!fCH2d) || (!calDetExB) || (!calChamberStatus)) return kFALSE;
 985
 986   // Gain
 987   Double_t gainmean   = calDetGain->GetMean();
 988   Double_t vdriftmean = calDetVDrift->GetMean();
 989   Double_t exbmean    = calDetExB->GetMean();
 990
 991   Double_t gainrms    = calDetGain->GetRMSRobust();
 992   Double_t vdriftrms  = calDetVDrift->GetRMSRobust();
 993   Double_t exbrms     = calDetExB->GetRMSRobust();
 994
 995   //printf("Gain mean: %f, rms: %f\n",gainmean,gainrms);
 996   //printf("Vdrift mean: %f, rms: %f\n",vdriftmean,vdriftrms);
 997   //printf("ExB mean: %f, rms: %f\n",exbmean,exbrms);
 998
 999   // Check
1000   if((TMath::Abs(gainrms) < 0.001) || (TMath::Abs(vdriftrms) < 0.001) || (TMath::Abs(exbrms) < 0.0000001)) return kFALSE;
1001
1002   // mask chambers with empty gain entries
1003   //Int_t counter = 0;
1004   for (Int_t idet = 0; idet < 540; idet++) {
1005
1006     // ch2d
1007     TH1I *projch =  (TH1I *) fCH2d->ProjectionX("projch",idet+1,idet+1,(Option_t *)"e");
1008     Double_t entries = projch->GetEntries();
1009     //printf("Number of entries %f for det %d\n",entries,idet);
1010
1011     // gain
1012     Double_t gain = calDetGain->GetValue(idet);
1013
1014     // vdrift
1015     Double_t vdrift = calDetVDrift->GetValue(idet);
1016
1017     // exb
1018     Double_t exb = calDetExB->GetValue(idet);
1019
1020
1021     if( (entries<50 && !calChamberStatus->IsNoData(idet))  ||
1022         TMath::Abs(gainmean-gain) > (fRMSBadCalibratedGain*gainrms)          ||
1023         TMath::Abs(vdriftmean-vdrift) > (fRMSBadCalibratedVdrift*vdriftrms)    ||
1024         TMath::Abs(exbmean-exb) > (fRMSBadCalibratedExB*exbrms) ) {
1025
1026       //printf(" chamber det %03d masked \n",idet);
1027       //printf(" gainmean %f and gain %f, gainrms %f \n",gainmean,gain,gainrms);
1028       //printf(" vdriftmean %f and vdrift %f, vdriftrms %f \n",vdriftmean,vdrift,vdriftrms);
1029       //printf(" exbmean %f and exb %f, exbrms %f \n",exbmean,exb,exbrms);
1030
1031       calChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kBadCalibrated);
1032       //counter++;
1033     }
1034
1035     delete projch;
1036
1037    }
1038
1039   // Security
1040   for(Int_t sm=0; sm < 18; sm++) {
1041     Int_t smnodata   = 0;
1042     Int_t smbadcalib = 0;
1043     for(Int_t det = 0; det < 30; det++){
1044       Int_t detector = sm*30+det;
1045       if(calChamberStatus->IsNoData(detector)) smnodata++;
1046       else {
1047         if(calChamberStatus->IsBadCalibrated(detector)) smbadcalib++;
1048       }
1049     }
1050     fNoData[sm]  = smnodata;
1051     fBadCalib[sm]= smbadcalib;
1052     //printf("No Data %d, bad calibrated %d for %d\n",fNoData[sm],fBadCalib[sm],sm);
1053   }
1054
1055   // Security
1056   //   for(Int_t sm=0; sm < 18; sm++) {
1057   //     Int_t counter = 0;
1058   //     for(Int_t det = 0; det < 30; det++){
1059   //       Int_t detector = sm*30+det;
1060   //       if(calChamberStatus->IsBadCalibrated(detector)) counter++;
1061   //     }
1062   //     if(counter >= 20) {
1063   //       for(Int_t det = 0; det < 30; det++){
1064   //    Int_t detector = sm*30+det;
1065   //    calChamberStatus->SetStatus(detector,AliTRDCalChamberStatus::kGood);
1066   //       }
1067   //     }
1068   //  }
1069
1070    fCalibObjects->AddAt(calChamberStatus,kChamberStatus);
1071    return kTRUE;
1072
1073  }
1074
1075
1076  //________________________________________________________________________________________________
1077  void AliTRDPreprocessorOffline::CorrectFromDetGainUsed() {
1078    //
1079    // Correct from the gas gain used afterwards
1080    //
1081    AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
1082    if(!calDetGain) return;
1083
1084    // Calculate mean
1085    Double_t mean = 0.0;
1086    Int_t nbdet = 0;
1087
1088    for(Int_t det = 0; det < 540; det++) {
1089
1090      Float_t gaininit = fCalDetGainUsed->GetValue(det);
1091      Float_t gainout = calDetGain->GetValue(det);
1092
1093
1094      if(TMath::Abs(gainout-1.0) > 0.000001) {
1095        mean += (gaininit*gainout);
1096        nbdet++;
1097      }
1098    }
1099    if(nbdet > 0) mean = mean/nbdet;
1100
1101    for(Int_t det = 0; det < 540; det++) {
1102
1103      Float_t gaininit = fCalDetGainUsed->GetValue(det);
1104      Float_t gainout = calDetGain->GetValue(det);
1105
1106      if(TMath::Abs(gainout-1.0) > 0.000001) {
1107        Double_t newgain = gaininit*gainout;
1108        if(newgain < 0.1) newgain = 0.1;
1109        if(newgain > 1.9) newgain = 1.9;
1110        calDetGain->SetValue(det,newgain);
1111      }
1112      else {
1113        Double_t newgain = mean;
1114        if(newgain < 0.1) newgain = 0.1;
1115        if(newgain > 1.9) newgain = 1.9;
1116        calDetGain->SetValue(det,newgain);
1117      }
1118    }
1119
1120
1121  }
1122  //________________________________________________________________________________________________
1123  void AliTRDPreprocessorOffline::CorrectFromDetVdriftUsed() {
1124    //
1125    // Correct from the drift velocity
1126    //
1127
1128    //printf("Correct for vdrift\n");
1129
1130    AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
1131    if(!calDetGain) return;
1132
1133    Int_t detVdrift = kVdriftPHDet;
1134    if(fMethodSecond) detVdrift = kVdriftLinear;
1135    AliTRDCalDet *calDetVdrift = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
1136    if(!calDetVdrift) return;
1137
1138    // Calculate mean
1139    if(!fNotEnoughStatisticsForTheVdriftLinear) {
1140      for(Int_t det = 0; det < 540; det++) {
1141
1142        Float_t vdriftinit = fCalDetVdriftUsed->GetValue(det);
1143        Float_t vdriftout = calDetVdrift->GetValue(det);
1144
1145        Float_t gain = calDetGain->GetValue(det);
1146        if(vdriftout > 0.0) gain = gain*vdriftinit/vdriftout;
1147        if(gain < 0.1) gain = 0.1;
1148        if(gain > 1.9) gain = 1.9;
1149        calDetGain->SetValue(det,gain);
1150      }
1151    }
1152    else {
1153
1154      Float_t vdriftinit = fCalDetVdriftUsed->CalcMean(kFALSE);
1155      Float_t vdriftout = calDetVdrift->CalcMean(kFALSE);
1156      Float_t factorcorrectif = 1.0;
1157      if(vdriftout > 0.0) factorcorrectif = vdriftinit/vdriftout;
1158      for(Int_t det = 0; det < 540; det++) {
1159        Float_t gain = calDetGain->GetValue(det);
1160        gain = gain*factorcorrectif;
1161        if(gain < 0.1) gain = 0.1;
1162        if(gain > 1.9) gain = 1.9;
1163        calDetGain->SetValue(det,gain);
1164      }
1165
1166    }
1167
1168  }
1169 //_________________________________________________________________________________________________________________
1170  void AliTRDPreprocessorOffline::UpdateOCDBGain(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
1171    //
1172    // Update OCDB entry
1173    //
1174
1175    AliCDBMetaData *metaData= new AliCDBMetaData();
1176    metaData->SetObjectClassName("AliTRDCalDet");
1177    metaData->SetResponsible("Raphaelle Bailhache");
1178    metaData->AddDateToComment();
1179    metaData->SetBeamPeriod(1);
1180
1181    AliCDBId id1("TRD/Calib/ChamberGainFactor", startRunNumber, endRunNumber);
1182    AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
1183    AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
1184    if(calDet) gStorage->Put(calDet, id1, metaData);
1185
1186
1187  }
1188  //___________________________________________________________________________________________________________________
1189  void AliTRDPreprocessorOffline::UpdateOCDBExB(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
1190    //
1191    // Update OCDB entry
1192    //
1193
1194    Int_t detExB = kLorentzLinear;
1195    if(!fMethodSecond) return;
1196
1197    //printf("Pass\n");
1198
1199    AliCDBMetaData *metaData= new AliCDBMetaData();
1200    metaData->SetObjectClassName("AliTRDCalDet");
1201    metaData->SetResponsible("Raphaelle Bailhache");
1202    metaData->AddDateToComment();
1203    metaData->SetBeamPeriod(1);
1204
1205    AliCDBId id1("TRD/Calib/ChamberExB", startRunNumber, endRunNumber);
1206    AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
1207    AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detExB);
1208    if(calDet) gStorage->Put(calDet, id1, metaData);
1209    //if(!calDet) printf("No caldet\n");
1210
1211  }
1212 //___________________________________________________________________________________________________________________
1213 void AliTRDPreprocessorOffline::UpdateOCDBExBAlt(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
1214   //
1215   // Update OCDB entry
1216   //
1217
1218   Int_t detExB = kExbAlt;
1219   if(!fMethodSecond) return;
1220
1221   //printf("Pass\n");
1222
1223   AliCDBMetaData *metaData= new AliCDBMetaData();
1224   metaData->SetObjectClassName("AliTRDCalDet");
1225   metaData->SetResponsible("Theo Rascanu");
1226   metaData->AddDateToComment();
1227   metaData->SetBeamPeriod(1);
1228
1229   AliCDBId id1("TRD/Calib/ChamberExBAlt", startRunNumber, endRunNumber);
1230   AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
1231   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detExB);
1232   if(calDet) gStorage->Put(calDet, id1, metaData);
1233   //if(!calDet) printf("No caldet\n");
1234
1235 }
1236  //___________________________________________________________________________________________________________________
1237  void AliTRDPreprocessorOffline::UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
1238    //
1239    // Update OCDB entry
1240    //
1241
1242    Int_t detVdrift = kVdriftPHDet;
1243
1244    if(fMethodSecond) detVdrift = kVdriftLinear;
1245
1246    AliCDBMetaData *metaData= new AliCDBMetaData();
1247    metaData->SetObjectClassName("AliTRDCalDet");
1248    metaData->SetResponsible("Raphaelle Bailhache");
1249    metaData->AddDateToComment();
1250    metaData->SetBeamPeriod(1);
1251
1252    AliCDBId id1("TRD/Calib/ChamberVdrift", startRunNumber, endRunNumber);
1253    AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
1254    AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
1255    if(calDet) gStorage->Put(calDet, id1, metaData);
1256
1257    //
1258
1259    if(!fMethodSecond) {
1260
1261      AliCDBMetaData *metaDataPad= new AliCDBMetaData();
1262      metaDataPad->SetObjectClassName("AliTRDCalPad");
1263      metaDataPad->SetResponsible("Raphaelle Bailhache");
1264      metaDataPad->AddDateToComment();
1265      metaDataPad->SetBeamPeriod(1);
1266
1267      AliCDBId id1Pad("TRD/Calib/LocalVdrift", startRunNumber, endRunNumber);
1268      AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
1269      if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
1270
1271    }
1272
1273  }
1274  //________________________________________________________________________________________________________________________
1275  void AliTRDPreprocessorOffline::UpdateOCDBT0(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
1276    //
1277    // Update OCDB entry
1278    //
1279
1280    AliCDBMetaData *metaData= new AliCDBMetaData();
1281    metaData->SetObjectClassName("AliTRDCalDet");
1282    metaData->SetResponsible("Raphaelle Bailhache");
1283    metaData->AddDateToComment();
1284    metaData->SetBeamPeriod(1);
1285
1286    AliCDBId id1("TRD/Calib/ChamberT0", startRunNumber, endRunNumber);
1287    AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
1288    AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
1289    if(calDet) gStorage->Put(calDet, id1, metaData);
1290
1291    //
1292
1293    AliCDBMetaData *metaDataPad= new AliCDBMetaData();
1294    metaDataPad->SetObjectClassName("AliTRDCalPad");
1295    metaDataPad->SetResponsible("Raphaelle Bailhache");
1296    metaDataPad->AddDateToComment();
1297    metaDataPad->SetBeamPeriod(1);
1298
1299    AliCDBId id1Pad("TRD/Calib/LocalT0", startRunNumber, endRunNumber);
1300    AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
1301    if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
1302
1303
1304
1305  }
1306  //_________________________________________________________________________________________________________________
1307  void AliTRDPreprocessorOffline::UpdateOCDBPRF(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
1308    //
1309    // Update OCDB entry
1310    //
1311
1312    AliCDBMetaData *metaData= new AliCDBMetaData();
1313    metaData->SetObjectClassName("AliTRDCalPad");
1314    metaData->SetResponsible("Raphaelle Bailhache");
1315    metaData->AddDateToComment();
1316    metaData->SetBeamPeriod(1);
1317
1318
1319    AliCDBId id1("TRD/Calib/PRFWidth", startRunNumber, endRunNumber);
1320    AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
1321    AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
1322    if(calPad) gStorage->Put(calPad, id1, metaData);
1323
1324
1325  }
1326 //_________________________________________________________________________________________________________________
1327 void AliTRDPreprocessorOffline::UpdateOCDBPHQ(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath)
1328 {
1329   //
1330   // Update OCDB entry
1331   //
1332   AliCDBMetaData *metaData= new AliCDBMetaData();
1333   metaData->SetObjectClassName("TObjArray");
1334   metaData->SetResponsible("Raphaelle Bailhache and Xianguo Lu");
1335   metaData->AddDateToComment();
1336   metaData->SetBeamPeriod(1);
1337
1338   AliCDBId id1("TRD/Calib/PHQ", startRunNumber, endRunNumber);
1339   AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
1340   TObjArray *cobj = (TObjArray *) fCalibObjects->At(kPHQ);
1341   if(cobj){
1342     //cobj->Print();
1343     gStorage->Put(cobj, id1, metaData);
1344   }
1345 }
1346
1347  //_________________________________________________________________________________________________________________
1348  void AliTRDPreprocessorOffline::UpdateOCDBChamberStatus(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
1349    //
1350    // Update OCDB entry
1351    //
1352
1353    AliCDBMetaData *metaData= new AliCDBMetaData();
1354    metaData->SetObjectClassName("AliTRDCalChamberStatus");
1355    metaData->SetResponsible("Raphaelle Bailhache and Julian Book");
1356    metaData->AddDateToComment();
1357    metaData->SetBeamPeriod(1);
1358
1359    AliCDBId id1("TRD/Calib/ChamberStatus", startRunNumber, endRunNumber);
1360    AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
1361    AliTRDCalChamberStatus *calChamberStatus = (AliTRDCalChamberStatus *) fCalibObjects->At(kChamberStatus);
1362    if(calChamberStatus) gStorage->Put(calChamberStatus, id1, metaData);
1363
1364
1365  }
1366  //__________________________________________________________________________________________________________________________
1367  Bool_t AliTRDPreprocessorOffline::ValidateGain() {
1368    //
1369    // Validate OCDB entry
1370    //
1371
1372    AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
1373    if(calDet) {
1374      Double_t mean = calDet->GetMean();
1375      Double_t rms = calDet->GetRMSRobust();
1376      if((mean > 0.2) && (mean < 1.4) && (rms < 0.5)) return kTRUE;
1377      //if((mean > 0.2) && (mean < 1.4)) return kTRUE;
1378      else {
1379        fStatusPos = fStatusPos | kGainErrorRange;
1380        return kFALSE;
1381      }
1382    }
1383    else return kFALSE;
1384
1385
1386
1387  }
1388  //__________________________________________________________________________________________________________________________
1389  Bool_t AliTRDPreprocessorOffline::ValidateVdrift(){
1390    //
1391    // Update OCDB entry
1392    //
1393
1394    Int_t detVdrift = kVdriftPHDet;
1395    Bool_t ok = kTRUE;
1396
1397    if(fMethodSecond) detVdrift = kVdriftLinear;
1398
1399    AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
1400    if(calDet) {
1401      Double_t mean = calDet->GetMean();
1402      Double_t rms = calDet->GetRMSRobust();
1403      //printf("Vdrift::mean %f, rms %f\n",mean,rms);
1404      if(!((mean > 1.0) && (mean < 2.0) && (rms < 0.5))) {
1405        fStatusPos = fStatusPos | kVdriftErrorRange;
1406        ok = kFALSE;
1407      }
1408    }
1409    else return kFALSE;
1410
1411    if(!fMethodSecond) {
1412      AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
1413      if(calPad) {
1414        Double_t mean = calPad->GetMean();
1415        Double_t rms = calPad->GetRMS();
1416        //printf("Vdrift::meanpad %f, rmspad %f\n",mean,rms);
1417        if(!((mean > 0.9) && (mean < 1.1) && (rms < 0.6))) {
1418          fStatusPos = fStatusPos | kVdriftErrorRange;
1419          ok = kFALSE;
1420        }
1421      }
1422      else return kFALSE;
1423    }
1424
1425    return ok;
1426
1427  }
1428  //__________________________________________________________________________________________________________________________
1429  Bool_t AliTRDPreprocessorOffline::ValidateExB(){
1430    //
1431    // Update OCDB entry
1432    //
1433
1434    AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kLorentzLinear);
1435    if(calDet) {
1436      Double_t mean = calDet->GetMean();
1437      Double_t rms = calDet->GetRMSRobust();
1438      //printf("Vdrift::mean %f, rms %f\n",mean,rms);
1439      if(!((mean > -1.0) && (mean < 1.0) && (rms < 0.5))) {
1440        fStatusNeg = fStatusNeg | kExBErrorRange;
1441        return kFALSE;
1442      }
1443      else return kTRUE;
1444    }
1445    else return kFALSE;
1446
1447  }
1448  //__________________________________________________________________________________________________________________________
1449  Bool_t AliTRDPreprocessorOffline::ValidateT0(){
1450    //
1451    // Update OCDB entry
1452    //
1453
1454    AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
1455    AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
1456    if(calDet && calPad) {
1457      Double_t meandet = calDet->GetMean();
1458      Double_t rmsdet = calDet->GetRMSRobust();
1459      Double_t meanpad = calPad->GetMean();
1460      //Double_t rmspad = calPad->GetRMS();
1461      //printf("T0::minimum %f, rmsdet %f,meanpad %f, rmspad %f\n",meandet,rmsdet,meanpad,rmspad);
1462      if((meandet > -1.5) && (meandet < 5.0) && (rmsdet < 4.0) && (meanpad < 5.0) && (meanpad > -0.5)) return kTRUE;
1463      else {
1464        fStatusPos = fStatusPos | kTimeOffsetErrorRange;
1465        return kFALSE;
1466      }
1467    }
1468    else return kFALSE;
1469
1470  }
1471  //__________________________________________________________________________________________________________________________
1472  Bool_t AliTRDPreprocessorOffline::ValidatePRF() const{
1473    //
1474    // Update OCDB entry
1475    //
1476
1477    AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
1478    if(calPad) {
1479      Double_t meanpad = calPad->GetMean();
1480      Double_t rmspad = calPad->GetRMS();
1481      //printf("PRF::meanpad %f, rmspad %f\n",meanpad,rmspad);
1482      if((meanpad < 1.0) && (rmspad < 0.8)) return kTRUE;
1483      else return kFALSE;
1484    }
1485    else return kFALSE;
1486
1487
1488  }
1489  //__________________________________________________________________________________________________________________________
1490 Bool_t AliTRDPreprocessorOffline::ValidateChamberStatus(){
1491   //
1492   // Update OCDB entry
1493   //
1494
1495   AliTRDCalChamberStatus *calChamberStatus = (AliTRDCalChamberStatus *) fCalibObjects->At(kChamberStatus);
1496   if(calChamberStatus) {
1497
1498     Int_t detectornodata   = 0;
1499     Int_t detectorbadcalib = 0;
1500
1501     for(Int_t sm=0; sm < 18; sm++) {
1502       //printf("%d chambers w/o data in sm %d\n",fNoData[sm],sm);
1503       //printf("%d bad calibrated chambers in sm %d\n",fBadCalib[sm],sm);
1504       if(fNoData[sm] != 30) detectornodata += fNoData[sm];
1505       detectorbadcalib+=fBadCalib[sm];
1506     }
1507     //printf("Number of chambers w/o data %d\n",detectornodata);
1508     //printf("Number of chambers bad calibrated %d\n",detectorbadcalib);
1509
1510     if((detectornodata > fNoDataValidate) ||
1511        (detectorbadcalib > fBadCalibValidate)){
1512       fStatusPos = fStatusPos | kChamberStatusErrorRange;
1513       return kFALSE;
1514     }
1515     return kTRUE;
1516   }
1517   else return kFALSE;
1518
1519 }
1520 //_____________________________________________________________________________
1521 Int_t AliTRDPreprocessorOffline::GetVersion(TString name) const
1522 {
1523   //
1524   // Get version from the title
1525   //
1526
1527   // Some patterns
1528   const Char_t *version = "Ver";
1529   if(!strstr(name.Data(),version)) return -1;
1530   const Char_t *after = "Subver";
1531   if(!strstr(name.Data(),after)) return -1;
1532
1533   for(Int_t ver = 0; ver < 999999999; ver++) {
1534
1535     TString vertry(version);
1536     vertry += ver;
1537     vertry += after;
1538
1539     //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1540
1541     if(strstr(name.Data(),vertry.Data())) return ver;
1542
1543   }
1544
1545   return -1;
1546
1547 }
1548
1549 //_____________________________________________________________________________
1550 Int_t AliTRDPreprocessorOffline::GetSubVersion(TString name) const
1551 {
1552   //
1553   // Get subversion from the title
1554   //
1555
1556   // Some patterns
1557   const Char_t *subversion = "Subver";
1558   if(!strstr(name.Data(),subversion)) return -1;
1559   const Char_t *after = "FirstRun";
1560   if(!strstr(name.Data(),after)) {
1561     after = "Nz";
1562   }
1563   if(!strstr(name.Data(),after)) return -1;
1564
1565
1566   for(Int_t ver = 0; ver < 999999999; ver++) {
1567
1568     TString vertry(subversion);
1569     vertry += ver;
1570     vertry += after;
1571
1572     //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1573
1574     if(strstr(name.Data(),vertry.Data())) return ver;
1575
1576   }
1577
1578   return -1;
1579
1580 }
1581
1582 //_____________________________________________________________________________
1583 Int_t AliTRDPreprocessorOffline::GetFirstRun(TString name) const
1584 {
1585   //
1586   // Get first run from the title
1587   //
1588
1589   // Some patterns
1590   const Char_t *firstrun = "FirstRun";
1591   if(!strstr(name.Data(),firstrun)) return -1;
1592   const Char_t *after = "Nz";
1593   if(!strstr(name.Data(),after)) return -1;
1594
1595
1596   for(Int_t ver = 0; ver < 999999999; ver++) {
1597
1598     TString vertry(firstrun);
1599     vertry += ver;
1600     vertry += after;
1601
1602     //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1603
1604     if(strstr(name.Data(),vertry.Data())) return ver;
1605
1606   }
1607
1608   return -1;
1609
1610 }
1611 //_____________________________________________________________________________
1612 Bool_t AliTRDPreprocessorOffline::CheckStatus(Int_t status, Int_t bitMask) const
1613 {
1614   //
1615   // Checks the status
1616   //
1617
1618   return (status & bitMask) ? kTRUE : kFALSE;
1619
1620 }
1621 //_____________________________________________________________________________
1622 Int_t AliTRDPreprocessorOffline::GetStatus() const
1623 {
1624   //
1625   // Checks the status
1626   // fStatusPos: errors
1627   // fStatusNeg: only info
1628   //
1629
1630   if(fStatusPos > 0) return fStatusPos;
1631   else return (-TMath::Abs(fStatusNeg));
1632
1633 }
1634 //_____________________________________________________________________________
1635 void AliTRDPreprocessorOffline::PrintStatus() const
1636 {
1637   //
1638   // Do Summary
1639   //
1640
1641   AliInfo(Form("The error status is %d",fStatusPos));
1642   AliInfo(Form("IsGainErrorOld? %d",(Int_t)IsGainErrorOld()));
1643   AliInfo(Form("IsVdriftErrorOld? %d",(Int_t)IsVdriftErrorOld()));
1644   AliInfo(Form("IsGainErrorRange? %d",(Int_t)IsGainErrorRange()));
1645   AliInfo(Form("IsVdriftErrorRange? %d",(Int_t)IsVdriftErrorRange()));
1646   AliInfo(Form("IsTimeOffsetErrorRange? %d",(Int_t)IsTimeOffsetErrorRange()));
1647   AliInfo(Form("IsChamberStatusErrorRange? %d",(Int_t)IsChamberStatusErrorRange()));
1648
1649
1650   AliInfo(Form("The info status is %d",fStatusNeg));
1651   AliInfo(Form("IsGainNotEnoughStatsButFill? %d",(Int_t)IsGainNotEnoughStatsButFill()));
1652   AliInfo(Form("IsVdriftNotEnoughStatsButFill? %d",(Int_t)IsVdriftNotEnoughStatsButFill()));
1653   AliInfo(Form("IsGainNotEnoughStatsNotFill? %d",(Int_t)IsGainNotEnoughStatsNotFill()));
1654   AliInfo(Form("IsVdriftNotEnoughStatsNotFill? %d",(Int_t)IsVdriftNotEnoughStatsNotFill()));
1655   AliInfo(Form("IsTimeOffsetNotEnoughStatsNotFill? %d",(Int_t)IsTimeOffsetNotEnoughStatsNotFill()));
1656
1657   AliInfo(Form("IsExBErrorRange? %d",(Int_t)IsExBErrorRange()));
1658   AliInfo(Form("IsExBErrorOld? %d",(Int_t)IsExBErrorOld()));
1659
1660 }
1661 //___________________________________________________________________________________
1662 void AliTRDPreprocessorOffline::SetCalDetVdrift(AliTRDCalDet *calDetVdriftUsed)
1663 {
1664
1665   fCalDetVdriftUsed = calDetVdriftUsed;
1666
1667   fCalDetExBUsed = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
1668   for(Int_t k = 0; k < 540; k++){
1669     fCalDetExBUsed->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDetVdriftUsed->GetValue(k)));
1670     //printf("Set the exb object for detector %d, vdrift %f and exb %f\n",k,fCalDetVdriftUsed->GetValue(k),fCalDetExBUsed->GetValue(k));
1671   }
1672
1673 };
1674 //___________________________________________________________________________________
1675 Bool_t AliTRDPreprocessorOffline::SetCalDetGain(Int_t runNumber, Int_t version, Int_t subversion)
1676 {
1677   //
1678   // Set the fCalDetGainUsed
1679   //
1680
1681   if((version == 0) && (subversion == 0)) return kFALSE;
1682
1683   AliCDBEntry *entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberGainFactor",runNumber, version, subversion);
1684   if(!entry) {
1685     AliError("Found no entry\n");
1686     fStatusPos = fStatusPos | kGainErrorOld;
1687     return kFALSE;
1688   }
1689   //const AliCDBId id = entry->GetId();
1690   //version = id.GetVersion();
1691   //subversion = id.GetSubVersion();
1692   //printf("Found version %d and subversion %d for vdrift\n",version,subversion);
1693   AliTRDCalDet* calDet = (AliTRDCalDet *)entry->GetObject();
1694   if(calDet) fCalDetGainUsed = calDet;
1695   else {
1696     fStatusPos = fStatusPos | kGainErrorOld;
1697     return kFALSE;
1698   }
1699
1700   return kTRUE;
1701
1702 }
1703 //___________________________________________________________________________________
1704 Bool_t AliTRDPreprocessorOffline::SetCalDetVdriftExB(Int_t runNumber, Int_t versionv, Int_t subversionv, Int_t versionexb, Int_t subversionexb)
1705 {
1706   //
1707   // Set the fCalDetVdriftUsed and fCalDetExBUsed
1708   //
1709
1710   if((versionv == 0) && (subversionv == 0)) return kFALSE;
1711
1712   AliCDBEntry *entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberVdrift",runNumber, versionv, subversionv);
1713   if(!entry) {
1714     AliError("Found no entry\n");
1715     fStatusPos = fStatusPos | kVdriftErrorOld;
1716     return kFALSE;
1717   }
1718   AliTRDCalDet* calDet = (AliTRDCalDet *)entry->GetObject();
1719   if(calDet) fCalDetVdriftUsed = calDet;
1720   else {
1721     fStatusPos = fStatusPos | kVdriftErrorOld;
1722     return kFALSE;
1723   }
1724
1725   // ExB object
1726
1727   if((versionexb == 0) && (subversionexb == 0)) {
1728
1729     fCalDetExBUsed = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
1730     for(Int_t k = 0; k < 540; k++){
1731       fCalDetExBUsed->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDetVdriftUsed->GetValue(k)));
1732       //printf("Nothing found: set the exb object for detector %d, vdrift %f and exb %f\n",k,fCalDetVdriftUsed->GetValue(k),fCalDetExBUsed->GetValue(k));
1733     }
1734   }
1735   else {
1736
1737     entry = 0x0;
1738     entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberExB",runNumber, versionexb, subversionexb);
1739     if(!entry) {
1740       //printf("Found no entry\n");
1741       fStatusPos = fStatusPos | kExBErrorOld;
1742       return kFALSE;
1743     }
1744     AliTRDCalDet* calDetexb = (AliTRDCalDet *)entry->GetObject();
1745     if(!calDetexb) {
1746       fStatusPos = fStatusPos | kExBErrorOld;
1747       return kFALSE;
1748     }
1749
1750     Double_t meanexb = calDetexb->GetMean();
1751     //printf("Mean value %f\n",meanexb);
1752     if((meanexb > 70) || (fNoExBUsedInReco)) {
1753       fCalDetExBUsed = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
1754       for(Int_t k = 0; k < 540; k++){
1755         fCalDetExBUsed->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDetVdriftUsed->GetValue(k)));
1756         //printf("Found but: set the exb object for detector %d, vdrift %f and exb %f\n",k,fCalDetVdriftUsed->GetValue(k),fCalDetExBUsed->GetValue(k));
1757       }
1758     }
1759     else {
1760       fCalDetExBUsed = calDetexb;
1761     }
1762
1763   }
1764
1765
1766   return kTRUE;
1767
1768 }
1769