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