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