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 "TProfile2D.h"
  50 #include "AliTRDCalDet.h"
  51 #include "AliTRDCalPad.h"
  52 #include "AliCDBMetaData.h"
  53 #include "AliCDBId.h"
  54 #include "AliCDBManager.h"
  55 #include "AliCDBStorage.h"
  56 #include "AliTRDCalibraMode.h"
  57 #include "AliTRDCalibraFit.h"
  58 #include "AliTRDCalibraVdriftLinearFit.h"
  59 #include "AliTRDPreprocessorOffline.h"
  60 #include "AliTRDCalChamberStatus.h"
  61
  62
  63 ClassImp(AliTRDPreprocessorOffline)
  64
  65   AliTRDPreprocessorOffline::AliTRDPreprocessorOffline():
  66   TNamed("TPCPreprocessorOffline","TPCPreprocessorOffline"),
  67   fMethodSecond(kTRUE),
  68   fNameList("TRDCalib"),
  69   fCalDetGainUsed(0x0),
  70   fCalDetVdriftUsed(0x0),
  71   fCH2d(0x0),
  72   fPH2d(0x0),
  73   fPRF2d(0x0),
  74   fAliTRDCalibraVdriftLinearFit(0x0),
  75   fNEvents(0x0),
  76   fAbsoluteGain(0x0),
  77   fPlots(new TObjArray(9)),
  78   fCalibObjects(new TObjArray(9)),
  79   fVersionGainUsed(0),
  80   fSubVersionGainUsed(0),
  81   fFirstRunVdriftUsed(0),
  82   fVersionVdriftUsed(0),
  83   fSubVersionVdriftUsed(0),
  84   fSwitchOnValidation(kTRUE),
  85   fVdriftValidated(kFALSE),
  86   fT0Validated(kFALSE),
  87   fMinStatsVdriftT0PH(800*20),
  88   fMinStatsVdriftLinear(800),
  89   fMinStatsGain(800),
  90   fMinStatsPRF(600),
  91   fBackCorrectGain(kFALSE),
  92   fBackCorrectVdrift(kTRUE),
  93   fNotEnoughStatisticsForTheGain(kFALSE),
  94   fNotEnoughStatisticsForTheVdriftLinear(kFALSE),
  95   fStatus(0)
  96 {
  97   //
  98   // default constructor
  99   //
 100 }
 101 //_________________________________________________________________________________________________________________
 102 AliTRDPreprocessorOffline::~AliTRDPreprocessorOffline() {
 103   //
 104   // Destructor
 105   //
 106
 107   if(fCalDetGainUsed) delete fCalDetGainUsed;
 108   if(fCalDetVdriftUsed) delete fCalDetVdriftUsed;
 109   if(fCH2d) delete fCH2d;
 110   if(fPH2d) delete fPH2d;
 111   if(fPRF2d) delete fPRF2d;
 112   if(fAliTRDCalibraVdriftLinearFit) delete fAliTRDCalibraVdriftLinearFit;
 113   if(fNEvents) delete fNEvents;
 114   if(fAbsoluteGain) delete fAbsoluteGain;
 115   if(fPlots) delete fPlots;
 116   if(fCalibObjects) delete fCalibObjects;
 117
 118 }
 119 //___________________________________________________________________________________________________________________
 120
 121 void AliTRDPreprocessorOffline::CalibVdriftT0(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
 122   //
 123   // make calibration of the drift velocity
 124   // Input parameters:
 125   //      file                             - the location of input file
 126   //      startRunNumber, endRunNumber     - run validity period
 127   //      ocdbStorage                      - path to the OCDB storage
 128   //                                       - if empty - local storage 'pwd' uesed
 129   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
 130   //
 131   // 1. Initialization
 132   //
 133   fVdriftValidated = kTRUE;
 134   fT0Validated = kTRUE;
 135   fNotEnoughStatisticsForTheVdriftLinear = kFALSE;
 136   //
 137   // 2. extraction of the information
 138   //
 139   if(ReadVdriftLinearFitGlobal(file)) AnalyzeVdriftLinearFit();
 140   if(ReadVdriftT0Global(file)) AnalyzeVdriftT0();
 141   //
 142   // 3. Append QA plots
 143   //
 144   //MakeDefaultPlots(fVdriftArray,fVdriftArray);
 145   //
 146   //
 147   // 4. validate OCDB entries
 148   //
 149   if(fSwitchOnValidation==kTRUE && ValidateVdrift()==kFALSE) {
 150     AliError("TRD vdrift OCDB parameters out of range!");
 151     fVdriftValidated = kFALSE;
 152   }
 153   if(fSwitchOnValidation==kTRUE && ValidateT0()==kFALSE) {
 154     AliError("TRD t0 OCDB parameters out of range!");
 155     fT0Validated = kFALSE;
 156   }
 157   //
 158   // 5. update of OCDB
 159   //
 160   //
 161   if(fVdriftValidated) UpdateOCDBVdrift(startRunNumber,endRunNumber,ocdbStorage);
 162   if(fT0Validated) UpdateOCDBT0(startRunNumber,endRunNumber,ocdbStorage);
 163   UpdateOCDBExB(startRunNumber,endRunNumber,ocdbStorage);
 164
 165 }
 166 //_________________________________________________________________________________________________________________
 167
 168 void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
 169   //
 170   // make calibration of the drift velocity
 171   // Input parameters:
 172   //      file                             - the location of input file
 173   //      startRunNumber, endRunNumber     - run validity period
 174   //      ocdbStorage                      - path to the OCDB storage
 175   //                                       - if empty - local storage 'pwd' uesed
 176   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
 177   //
 178   fNotEnoughStatisticsForTheGain = kFALSE;
 179   //
 180   // 1. Initialization
 181   if(!ReadGainGlobal(file)) return;
 182   //
 183   //
 184   // 2. extraction of the information
 185   //
 186   AnalyzeGain();
 187   if(fBackCorrectGain) CorrectFromDetGainUsed();
 188   if(fBackCorrectVdrift) CorrectFromDetVdriftUsed();
 189   //
 190   // 3. Append QA plots
 191   //
 192   //MakeDefaultPlots(fVdriftArray,fVdriftArray);
 193   //
 194   //
 195   // 4. validate OCDB entries
 196   //
 197   if(fSwitchOnValidation==kTRUE && ValidateGain()==kFALSE) {
 198     AliError("TRD gain OCDB parameters out of range!");
 199     return;
 200   }
 201   //
 202   // 5. update of OCDB
 203   //
 204   //
 205   if((!fCalDetVdriftUsed) || (fCalDetVdriftUsed && fVdriftValidated)) UpdateOCDBGain(startRunNumber,endRunNumber,ocdbStorage);
 206
 207
 208 }
 209 //________________________________________________________________________________________________________________
 210
 211 void AliTRDPreprocessorOffline::CalibPRF(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
 212   //
 213   // make calibration of the drift velocity
 214   // Input parameters:
 215   //      file                             - the location of input file
 216   //      startRunNumber, endRunNumber     - run validity period
 217   //      ocdbStorage                      - path to the OCDB storage
 218   //                                       - if empty - local storage 'pwd' uesed
 219   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
 220   //
 221   // 1. Initialization
 222   if(!ReadPRFGlobal(file)) return;
 223   //
 224   //
 225   // 2. extraction of the information
 226   //
 227   AnalyzePRF();
 228   //
 229   // 3. Append QA plots
 230   //
 231   //MakeDefaultPlots(fVdriftArray,fVdriftArray);
 232   //
 233   //
 234   //
 235   // 4. validate OCDB entries
 236   //
 237   if(fSwitchOnValidation==kTRUE && ValidatePRF()==kFALSE) {
 238     AliError("TRD prf OCDB parameters out of range!");
 239     return;
 240   }
 241   //
 242   // 5. update of OCDB
 243   //
 244   //
 245   UpdateOCDBPRF(startRunNumber,endRunNumber,ocdbStorage);
 246
 247 }
 248 //________________________________________________________________________________________________________________
 249
 250 void AliTRDPreprocessorOffline::CalibChamberStatus(Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
 251   //
 252   // make calibration of the chamber status
 253   // Input parameters:
 254   //      startRunNumber, endRunNumber     - run validity period
 255   //      ocdbStorage                      - path to the OCDB storage
 256   //                                       - if empty - local storage 'pwd' uesed
 257   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
 258   //
 259   //
 260   // 2. extraction of the information
 261   //
 262   if(!AnalyzeChamberStatus()) return;
 263   //
 264   // 3. Append QA plots
 265   //
 266   //MakeDefaultPlots(fVdriftArray,fVdriftArray);
 267   //
 268   //
 269   //
 270   // 4. validate OCDB entries
 271   //
 272   if(fSwitchOnValidation==kTRUE && ValidateChamberStatus()==kFALSE) {
 273     AliError("TRD Chamber status OCDB parameters not ok!");
 274     return;
 275   }
 276   //
 277   // 5. update of OCDB
 278   //
 279   //
 280   if((!fNotEnoughStatisticsForTheGain) && (!fNotEnoughStatisticsForTheGain)) UpdateOCDBChamberStatus(startRunNumber,endRunNumber,ocdbStorage);
 281
 282 }
 283 //______________________________________________________________________________________________________
 284 Bool_t AliTRDPreprocessorOffline::Init(const Char_t* fileName){
 285   //
 286   // read the calibration used during the reconstruction
 287   //
 288
 289   if(ReadVdriftT0Global(fileName)) {
 290
 291     TString nameph = fPH2d->GetTitle();
 292     fFirstRunVdriftUsed = GetFirstRun(nameph);
 293     fVersionVdriftUsed = GetVersion(nameph);
 294     fSubVersionVdriftUsed = GetSubVersion(nameph);
 295
 296     //printf("Found Version %d, Subversion %d for vdrift\n",fVersionVdriftUsed,fSubVersionVdriftUsed);
 297
 298   }
 299
 300   if(ReadGainGlobal(fileName)) {
 301
 302     TString namech = fCH2d->GetTitle();
 303     fVersionGainUsed = GetVersion(namech);
 304     fSubVersionGainUsed = GetSubVersion(namech);
 305
 306     //printf("Found Version %d, Subversion %d for gain\n",fVersionGainUsed,fSubVersionGainUsed);
 307
 308   }
 309
 310   if((fVersionVdriftUsed == 0) && (fVersionGainUsed == 0)) fStatus = -1;
 311
 312   return kTRUE;
 313
 314 }
 315 //___________________________________________________________________________________________________________________
 316
 317 Bool_t AliTRDPreprocessorOffline::ReadGainGlobal(const Char_t* fileName){
 318   //
 319   // read calibration entries from file
 320   //
 321   if(fCH2d) return kTRUE;
 322   TFile fcalib(fileName);
 323   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
 324   if (array){
 325     TH2I *ch2d = (TH2I *) array->FindObject("CH2d");
 326     if(!ch2d) return kFALSE;
 327     fCH2d = (TH2I*)ch2d->Clone();
 328     //fNEvents = (TH1I *) array->FindObject("NEvents");
 329     //fAbsoluteGain = (TH2F *) array->FindObject("AbsoluteGain");
 330   }else{
 331     TH2I *ch2d = (TH2I *) fcalib.Get("CH2d");
 332     if(!ch2d) return kFALSE;
 333     fCH2d = (TH2I*)ch2d->Clone();
 334     //fNEvents = (TH1I *) fcalib.Get("NEvents");
 335     //fAbsoluteGain = (TH2F *) fcalib.Get("AbsoluteGain");
 336   }
 337   fCH2d->SetDirectory(0);
 338   //printf("title of CH2d %s\n",fCH2d->GetTitle());
 339
 340   return kTRUE;
 341
 342 }
 343 //_________________________________________________________________________________________________________________
 344
 345 Bool_t AliTRDPreprocessorOffline::ReadVdriftT0Global(const Char_t* fileName){
 346   //
 347   // read calibration entries from file
 348   //
 349   if(fPH2d) return kTRUE;
 350   TFile fcalib(fileName);
 351   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
 352   if (array){
 353     TProfile2D *ph2d = (TProfile2D *) array->FindObject("PH2d");
 354     if(!ph2d) return kFALSE;
 355     fPH2d = (TProfile2D*)ph2d->Clone();
 356     //fNEvents = (TH1I *) array->FindObject("NEvents");
 357   }else{
 358     TProfile2D *ph2d = (TProfile2D *) fcalib.Get("PH2d");
 359     if(!ph2d) return kFALSE;
 360     fPH2d = (TProfile2D*)ph2d->Clone();
 361     //fNEvents = (TH1I *) fcalib.Get("NEvents");
 362   }
 363   fPH2d->SetDirectory(0);
 364   //printf("title of PH2d %s\n",fPH2d->GetTitle());
 365
 366   return kTRUE;
 367
 368 }
 369 //___________________________________________________________________________________________________________________
 370
 371 Bool_t AliTRDPreprocessorOffline::ReadVdriftLinearFitGlobal(const Char_t* fileName){
 372   //
 373   // read calibration entries from file
 374   //
 375   if(fAliTRDCalibraVdriftLinearFit) return kTRUE;
 376   TFile fcalib(fileName);
 377   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
 378   if (array){
 379     fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) array->FindObject("AliTRDCalibraVdriftLinearFit");
 380     //fNEvents = (TH1I *) array->FindObject("NEvents");
 381   }else{
 382     fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) fcalib.Get("AliTRDCalibraVdriftLinearFit");
 383     //fNEvents = (TH1I *) fcalib.Get("NEvents");
 384   }
 385   if(!fAliTRDCalibraVdriftLinearFit) {
 386     //printf("No AliTRDCalibraVdriftLinearFit\n");
 387     return kFALSE;
 388   }
 389   return kTRUE;
 390
 391 }
 392 //_____________________________________________________________________________________________________________
 393
 394 Bool_t AliTRDPreprocessorOffline::ReadPRFGlobal(const Char_t* fileName){
 395   //
 396   // read calibration entries from file
 397   //
 398   if(fPRF2d) return kTRUE;
 399   TFile fcalib(fileName);
 400   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
 401   if (array){
 402     TProfile2D *prf2d = (TProfile2D *) array->FindObject("PRF2d");
 403     if(!prf2d) return kFALSE;
 404     fPRF2d = (TProfile2D*)prf2d->Clone();
 405     //fNEvents = (TH1I *) array->FindObject("NEvents");
 406   }else{
 407     TProfile2D *prf2d = (TProfile2D *) fcalib.Get("PRF2d");
 408     if(!prf2d) return kFALSE;
 409     fPRF2d = (TProfile2D*)prf2d->Clone();
 410     //fNEvents = (TH1I *) fcalib.Get("NEvents");
 411   }
 412   fPRF2d->SetDirectory(0);
 413   //printf("title of PRF2d %s\n",fPRF2d->GetTitle());
 414
 415   return kTRUE;
 416
 417 }
 418 //__________________________________________________________________________________________________________
 419
 420 Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){
 421   //
 422   // Analyze gain - produce the calibration objects
 423   //
 424
 425   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 426   calibra->SetMinEntries(fMinStatsGain); // If there is less than 1000 entries in the histo: no fit
 427   calibra->AnalyseCH(fCH2d);
 428
 429   Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
 430     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
 431   Int_t nbfit       = calibra->GetNumberFit();
 432   Int_t nbE         = calibra->GetNumberEnt();
 433
 434
 435   Bool_t ok = kFALSE;
 436   Bool_t meanother = kFALSE;
 437   // enough statistics
 438   if ((nbtg >                  0) &&
 439       (nbfit        >= 0.5*nbE) && (nbE > 30)) {
 440     // create the cal objects
 441     if(!fBackCorrectGain) {
 442       calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 443       meanother = kTRUE;
 444     }
 445     TObjArray object           = calibra->GetVectorFit();
 446     AliTRDCalDet *calDetGain   = calibra->CreateDetObjectGain(&object,meanother);
 447     TH1F *coefGain  = calDetGain->MakeHisto1DAsFunctionOfDet();
 448     // Put them in the array
 449     fCalibObjects->AddAt(calDetGain,kGain);
 450     fPlots->AddAt(coefGain,kGain);
 451     //
 452     ok = kTRUE;
 453   }
 454   else {
 455     fNotEnoughStatisticsForTheGain = kTRUE;
 456     Int_t minStatsGain = fMinStatsGain*30;
 457     calibra->SetMinEntries(minStatsGain); // Because we do it for all, we increase this
 458     Double_t gainoverallnotnormalized =  calibra->AnalyseCHAllTogether(fCH2d);
 459     if(fCalDetGainUsed && (gainoverallnotnormalized > 0.0)) {
 460       AliTRDCalDet *calDetGain = new AliTRDCalDet(*fCalDetGainUsed);
 461       Double_t oldmean = fCalDetGainUsed->CalcMean(kFALSE);
 462       //printf("oldmean %f\n",oldmean);
 463       if(oldmean > 0.0)  {
 464         Double_t scalefactor = calibra->GetScaleFactorGain();
 465         //printf("Correction factor %f\n",gainoverallnotnormalized*scalefactor);
 466         calDetGain->Multiply(gainoverallnotnormalized*scalefactor/oldmean);
 467         //printf("newmean %f\n",calDetGain->CalcMean(kFALSE));
 468         TH1F *coefGain  = calDetGain->MakeHisto1DAsFunctionOfDet();
 469         fCalibObjects->AddAt(calDetGain,kGain);
 470         fPlots->AddAt(coefGain,kGain);
 471         //
 472         ok = kTRUE;
 473         fStatus += 1000000;
 474       }
 475       else {
 476         fStatus += 1000;
 477       }
 478     }
 479     else {
 480       fStatus += 1000;
 481     }
 482   }
 483
 484   calibra->ResetVectorFit();
 485
 486   return ok;
 487
 488 }
 489 //_____________________________________________________________________________________________________
 490 Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftT0(){
 491   //
 492   // Analyze VdriftT0 - produce the calibration objects
 493   //
 494
 495   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 496   calibra->SetMinEntries(fMinStatsVdriftT0PH); // If there is less than 1000 entries in the histo: no fit
 497   calibra->AnalysePH(fPH2d);
 498
 499   Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
 500     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
 501   Int_t nbfit       = calibra->GetNumberFit();
 502   Int_t nbfitSuccess = calibra->GetNumberFitSuccess();
 503   Int_t nbE         = calibra->GetNumberEnt();
 504
 505   //printf("nbtg %d, nbfit %d, nbE %d, nbfitSuccess %d\n",nbtg,nbfit,nbE,nbfitSuccess);
 506
 507   Bool_t ok = kFALSE;
 508   if ((nbtg >                  0) &&
 509       (nbfit        >= 0.5*nbE) && (nbE > 30) && (nbfitSuccess > 30)) {
 510     //printf("Pass the cut for VdriftT0\n");
 511     // create the cal objects
 512     calibra->RemoveOutliers(1,kFALSE);
 513     calibra->PutMeanValueOtherVectorFit(1,kFALSE);
 514     calibra->RemoveOutliers2(kFALSE);
 515     calibra->PutMeanValueOtherVectorFit2(1,kFALSE);
 516     //
 517     TObjArray object = calibra->GetVectorFit();
 518     AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object);
 519     TH1F *coefVdriftPH  = calDetVdrift->MakeHisto1DAsFunctionOfDet();
 520     AliTRDCalPad *calPadVdrift = (AliTRDCalPad *)calibra->CreatePadObjectVdrift(&object,calDetVdrift);
 521     TH1F *coefPadVdrift   = calPadVdrift->MakeHisto1D();
 522     object       = calibra->GetVectorFit2();
 523     AliTRDCalDet *calDetT0  = calibra->CreateDetObjectT0(&object);
 524     TH1F *coefT0  = calDetT0->MakeHisto1DAsFunctionOfDet();
 525     AliTRDCalPad *calPadT0 = (AliTRDCalPad *)calibra->CreatePadObjectT0(&object,calDetT0);
 526     TH1F *coefPadT0  = calPadT0->MakeHisto1D();
 527     // Put them in the array
 528     fCalibObjects->AddAt(calDetT0,kT0PHDet);
 529     fCalibObjects->AddAt(calDetVdrift,kVdriftPHDet);
 530     fCalibObjects->AddAt(calPadT0,kT0PHPad);
 531     fCalibObjects->AddAt(calPadVdrift,kVdriftPHPad);
 532     fPlots->AddAt(coefVdriftPH,kVdriftPHDet);
 533     fPlots->AddAt(coefT0,kT0PHDet);
 534     fPlots->AddAt(coefPadVdrift,kVdriftPHPad);
 535     fPlots->AddAt(coefPadT0,kT0PHPad);
 536     //
 537     ok = kTRUE;
 538   }
 539   else {
 540     fStatus += 100;
 541   }
 542   calibra->ResetVectorFit();
 543
 544   return ok;
 545
 546 }
 547 //____________________________________________________________________________________________________________________
 548 Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){
 549   //
 550   // Analyze vdrift linear fit - produce the calibration objects
 551   //
 552
 553   //printf("Analyse linear fit\n");
 554
 555
 556   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 557   calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit
 558   //printf("Fill PE Array\n");
 559   fAliTRDCalibraVdriftLinearFit->FillPEArray();
 560   //printf("AliTRDCalibraFit\n");
 561   calibra->AnalyseLinearFitters(fAliTRDCalibraVdriftLinearFit);
 562   //printf("After\n");
 563
 564   //Int_t nbtg        = 540;
 565   Int_t nbfit       = calibra->GetNumberFit();
 566   Int_t nbE         = calibra->GetNumberEnt();
 567
 568
 569   Bool_t ok = kFALSE;
 570   // enough statistics
 571   if ((nbfit        >= 0.5*nbE) && (nbE > 30)) {
 572     // create the cal objects
 573     //calibra->RemoveOutliers(1,kTRUE);
 574     calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 575     //calibra->RemoveOutliers2(kTRUE);
 576     calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
 577     //
 578     TObjArray object  = calibra->GetVectorFit();
 579     AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object,kTRUE);
 580     TH1F *coefDriftLinear      = calDetVdrift->MakeHisto1DAsFunctionOfDet();
 581     object                     = calibra->GetVectorFit2();
 582     AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectLorentzAngle(&object);
 583     TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
 584     //if(!calDetLorentz) printf("No lorentz created\n");
 585     // Put them in the array
 586     fCalibObjects->AddAt(calDetVdrift,kVdriftLinear);
 587     fCalibObjects->AddAt(calDetLorentz,kLorentzLinear);
 588     fPlots->AddAt(coefDriftLinear,kVdriftLinear);
 589     fPlots->AddAt(coefLorentzAngle,kLorentzLinear);
 590     //
 591     ok = kTRUE;
 592   }
 593   else {
 594     fNotEnoughStatisticsForTheVdriftLinear = kTRUE;
 595     Int_t minNumberOfEntriesForAll = fMinStatsVdriftLinear*30;
 596     calibra->SetMinEntries(minNumberOfEntriesForAll); // Because we do it for all, we increase this
 597     Double_t vdriftoverall =  calibra->AnalyseLinearFittersAllTogether(fAliTRDCalibraVdriftLinearFit);
 598     if(fCalDetVdriftUsed && (vdriftoverall > 0.0)) {
 599       AliTRDCalDet *calDetVdrift = new AliTRDCalDet(*fCalDetVdriftUsed);
 600       Double_t oldmean = fCalDetVdriftUsed->CalcMean(kFALSE);
 601       //printf("oldmean %f\n",oldmean);
 602       if(oldmean > 0.0)  {
 603         //printf("Correction factor %f\n",vdriftoverall);
 604         calDetVdrift->Multiply(vdriftoverall/oldmean);
 605         //printf("newmean %f\n",calDetVdrift->CalcMean(kFALSE));
 606         TH1F *coefDriftLinear  = calDetVdrift->MakeHisto1DAsFunctionOfDet();
 607         // Put them in the array
 608         fCalibObjects->AddAt(calDetVdrift,kVdriftLinear);
 609         fPlots->AddAt(coefDriftLinear,kVdriftLinear);
 610         //
 611         ok = kTRUE;
 612         fStatus += 10000;
 613       }
 614       else fStatus += 1;
 615     }
 616     else fStatus += 1;
 617   }
 618
 619   calibra->ResetVectorFit();
 620
 621   return ok;
 622
 623 }
 624 //________________________________________________________________________________________________________________
 625
 626 Bool_t AliTRDPreprocessorOffline::AnalyzePRF(){
 627   //
 628   // Analyze PRF - produce the calibration objects
 629   //
 630
 631   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 632   calibra->SetMinEntries(fMinStatsPRF); // If there is less than 1000 entries in the histo: no fit
 633   calibra->AnalysePRFMarianFit(fPRF2d);
 634
 635   Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
 636     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
 637   Int_t nbfit       = calibra->GetNumberFit();
 638   Int_t nbE         = calibra->GetNumberEnt();
 639
 640
 641   Bool_t ok = kFALSE;
 642   // enough statistics
 643   if ((nbtg >                  0) &&
 644       (nbfit        >= 0.95*nbE) && (nbE > 30)) {
 645     // create the cal objects
 646     TObjArray object  = calibra->GetVectorFit();
 647     AliTRDCalPad *calPadPRF = (AliTRDCalPad*) calibra->CreatePadObjectPRF(&object);
 648     TH1F *coefPRF           = calPadPRF->MakeHisto1D();
 649     // Put them in the array
 650     fCalibObjects->AddAt(calPadPRF,kPRF);
 651     fPlots->AddAt(coefPRF,kPRF);
 652     //
 653     ok = kTRUE;
 654   }
 655
 656   calibra->ResetVectorFit();
 657
 658   return ok;
 659
 660 }
 661
 662 //_____________________________________________________________________________
 663 Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
 664 {
 665   //
 666   // Produce AliTRDCalChamberStatus out of calibration results
 667   //
 668
 669   // set up AliTRDCalChamberStatus
 670   AliTRDCalChamberStatus *CalChamberStatus = new AliTRDCalChamberStatus();
 671   for(Int_t det = 0; det < 540; det++) CalChamberStatus->SetStatus(det,1);
 672
 673   // get calibration objects
 674   AliTRDCalDet *calDetGain   = (AliTRDCalDet *) fCalibObjects->At(kGain);
 675   AliTRDCalDet *calDetVDrift = (AliTRDCalDet *) fCalibObjects->At(kVdriftLinear);
 676
 677   // Check
 678   if((!calDetGain) || (!calDetVDrift) || (!fCH2d)) return kFALSE;
 679
 680   // Gain
 681   Double_t gainmean = calDetGain->GetMean();
 682   Double_t vdriftmean = calDetVDrift->GetMean();
 683
 684   Double_t gainrms = calDetGain->GetRMSRobust();
 685   Double_t vdriftrms = calDetVDrift->GetRMSRobust();
 686
 687   //printf("Gain mean: %f, rms: %f\n",gainmean,gainrms);
 688   //printf("Vdrift mean: %f, rms: %f\n",vdriftmean,vdriftrms);
 689
 690   // Check
 691   if((TMath::Abs(gainrms) < 0.001) || (TMath::Abs(vdriftrms) < 0.001)) return kFALSE;
 692
 693   // mask chambers with empty gain entries
 694   //Int_t counter = 0;
 695   for (Int_t idet = 0; idet < 540; idet++) {
 696
 697     // ch2d
 698     TH1I *projch =  (TH1I *) fCH2d->ProjectionX("projch",idet+1,idet+1,(Option_t *)"e");
 699     Double_t entries = projch->GetEntries();
 700
 701     // gain
 702     Double_t gain = calDetGain->GetValue(idet);
 703
 704     // vdrift
 705     Double_t vdrift = calDetVDrift->GetValue(idet);
 706
 707
 708     if(entries<=0.5 ||
 709        TMath::Abs(gainmean-gain) > (15.0*gainrms) ||
 710        TMath::Abs(vdriftmean-vdrift) > (15.0*vdriftrms)) {
 711
 712       //printf(" chamber det %03d masked \n",idet);
 713       //printf(" gainmean %f and gain %f, gainrms %f \n",gainmean,gain,gainrms);
 714       //printf(" vdriftmean %f and vdrift %f, vdriftrms %f \n",vdriftmean,vdrift,vdriftrms);
 715       CalChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kMasked);
 716       //counter++;
 717     }
 718
 719      /*
 720      // installed supermodules+1 -> abort
 721      if(counter > (7+1)*30) {
 722        printf("ERROR: more than one SM to be masked!! \n Abort...\n");
 723        if(projch) delete projch;
 724        return 0x0;
 725      }
 726      */
 727
 728     delete projch;
 729
 730    }
 731
 732    // Security
 733    for(Int_t sm=0; sm < 18; sm++) {
 734      Int_t counter = 0;
 735      for(Int_t det = 0; det < 30; det++){
 736        Int_t detector = sm*30+det;
 737        if(CalChamberStatus->IsMasked(detector)) counter++;
 738      }
 739      if(counter >= 10) {
 740        for(Int_t det = 0; det < 30; det++){
 741          Int_t detector = sm*30+det;
 742          CalChamberStatus->SetStatus(detector,AliTRDCalChamberStatus::kInstalled);
 743        }
 744      }
 745    }
 746
 747    fCalibObjects->AddAt(CalChamberStatus,kChamberStatus);
 748    return kTRUE;
 749
 750  }
 751
 752
 753  //________________________________________________________________________________________________
 754  void AliTRDPreprocessorOffline::CorrectFromDetGainUsed() {
 755    //
 756    // Correct from the gas gain used afterwards
 757    //
 758    AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
 759    if(!calDetGain) return;
 760
 761    // Calculate mean
 762    Double_t mean = 0.0;
 763    Int_t nbdet = 0;
 764
 765    for(Int_t det = 0; det < 540; det++) {
 766
 767      Float_t gaininit = fCalDetGainUsed->GetValue(det);
 768      Float_t gainout = calDetGain->GetValue(det);
 769
 770
 771      if(TMath::Abs(gainout-1.0) > 0.000001) {
 772        mean += (gaininit*gainout);
 773        nbdet++;
 774      }
 775    }
 776    if(nbdet > 0) mean = mean/nbdet;
 777
 778    for(Int_t det = 0; det < 540; det++) {
 779
 780      Float_t gaininit = fCalDetGainUsed->GetValue(det);
 781      Float_t gainout = calDetGain->GetValue(det);
 782
 783      if(TMath::Abs(gainout-1.0) > 0.000001) {
 784        Double_t newgain = gaininit*gainout;
 785        if(newgain < 0.1) newgain = 0.1;
 786        if(newgain > 1.9) newgain = 1.9;
 787        calDetGain->SetValue(det,newgain);
 788      }
 789      else {
 790        Double_t newgain = mean;
 791        if(newgain < 0.1) newgain = 0.1;
 792        if(newgain > 1.9) newgain = 1.9;
 793        calDetGain->SetValue(det,newgain);
 794      }
 795    }
 796
 797
 798  }
 799  //________________________________________________________________________________________________
 800  void AliTRDPreprocessorOffline::CorrectFromDetVdriftUsed() {
 801    //
 802    // Correct from the drift velocity
 803    //
 804
 805    //printf("Correct for vdrift\n");
 806
 807    AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
 808    if(!calDetGain) return;
 809
 810    Int_t detVdrift = kVdriftPHDet;
 811    if(fMethodSecond) detVdrift = kVdriftLinear;
 812    AliTRDCalDet *calDetVdrift = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
 813    if(!calDetVdrift) return;
 814
 815    // Calculate mean
 816    if(!fNotEnoughStatisticsForTheVdriftLinear) {
 817      for(Int_t det = 0; det < 540; det++) {
 818
 819        Float_t vdriftinit = fCalDetVdriftUsed->GetValue(det);
 820        Float_t vdriftout = calDetVdrift->GetValue(det);
 821
 822        Float_t gain = calDetGain->GetValue(det);
 823        if(vdriftout > 0.0) gain = gain*vdriftinit/vdriftout;
 824        if(gain < 0.1) gain = 0.1;
 825        if(gain > 1.9) gain = 1.9;
 826        calDetGain->SetValue(det,gain);
 827      }
 828    }
 829    else {
 830
 831      Float_t vdriftinit = fCalDetVdriftUsed->CalcMean(kFALSE);
 832      Float_t vdriftout = calDetVdrift->CalcMean(kFALSE);
 833      Float_t factorcorrectif = 1.0;
 834      if(vdriftout > 0.0) factorcorrectif = vdriftinit/vdriftout;
 835      for(Int_t det = 0; det < 540; det++) {
 836        Float_t gain = calDetGain->GetValue(det);
 837        gain = gain*factorcorrectif;
 838        if(gain < 0.1) gain = 0.1;
 839        if(gain > 1.9) gain = 1.9;
 840        calDetGain->SetValue(det,gain);
 841      }
 842
 843    }
 844
 845  }
 846 //_________________________________________________________________________________________________________________
 847  void AliTRDPreprocessorOffline::UpdateOCDBGain(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
 848    //
 849    // Update OCDB entry
 850    //
 851
 852    AliCDBMetaData *metaData= new AliCDBMetaData();
 853    metaData->SetObjectClassName("AliTRDCalDet");
 854    metaData->SetResponsible("Raphaelle Bailhache");
 855    metaData->SetBeamPeriod(1);
 856
 857    AliCDBId id1("TRD/Calib/ChamberGainFactor", startRunNumber, endRunNumber);
 858    AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
 859    AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
 860    if(calDet) gStorage->Put(calDet, id1, metaData);
 861
 862
 863  }
 864  //___________________________________________________________________________________________________________________
 865  void AliTRDPreprocessorOffline::UpdateOCDBExB(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
 866    //
 867    // Update OCDB entry
 868    //
 869
 870    Int_t detExB = kLorentzLinear;
 871    if(!fMethodSecond) return;
 872
 873    //printf("Pass\n");
 874
 875    AliCDBMetaData *metaData= new AliCDBMetaData();
 876    metaData->SetObjectClassName("AliTRDCalDet");
 877    metaData->SetResponsible("Raphaelle Bailhache");
 878    metaData->SetBeamPeriod(1);
 879
 880    AliCDBId id1("TRD/Calib/ChamberExB", startRunNumber, endRunNumber);
 881    AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
 882    AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detExB);
 883    if(calDet) gStorage->Put(calDet, id1, metaData);
 884    //if(!calDet) printf("No caldet\n");
 885
 886  }
 887  //___________________________________________________________________________________________________________________
 888  void AliTRDPreprocessorOffline::UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
 889    //
 890    // Update OCDB entry
 891    //
 892
 893    Int_t detVdrift = kVdriftPHDet;
 894
 895    if(fMethodSecond) detVdrift = kVdriftLinear;
 896
 897    AliCDBMetaData *metaData= new AliCDBMetaData();
 898    metaData->SetObjectClassName("AliTRDCalDet");
 899    metaData->SetResponsible("Raphaelle Bailhache");
 900    metaData->SetBeamPeriod(1);
 901
 902    AliCDBId id1("TRD/Calib/ChamberVdrift", startRunNumber, endRunNumber);
 903    AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
 904    AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
 905    if(calDet) gStorage->Put(calDet, id1, metaData);
 906
 907    //
 908
 909    if(!fMethodSecond) {
 910
 911      AliCDBMetaData *metaDataPad= new AliCDBMetaData();
 912      metaDataPad->SetObjectClassName("AliTRDCalPad");
 913      metaDataPad->SetResponsible("Raphaelle Bailhache");
 914      metaDataPad->SetBeamPeriod(1);
 915
 916      AliCDBId id1Pad("TRD/Calib/LocalVdrift", startRunNumber, endRunNumber);
 917      AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
 918      if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
 919
 920    }
 921
 922  }
 923  //________________________________________________________________________________________________________________________
 924  void AliTRDPreprocessorOffline::UpdateOCDBT0(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
 925    //
 926    // Update OCDB entry
 927    //
 928
 929    AliCDBMetaData *metaData= new AliCDBMetaData();
 930    metaData->SetObjectClassName("AliTRDCalDet");
 931    metaData->SetResponsible("Raphaelle Bailhache");
 932    metaData->SetBeamPeriod(1);
 933
 934    AliCDBId id1("TRD/Calib/ChamberT0", startRunNumber, endRunNumber);
 935    AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
 936    AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
 937    if(calDet) gStorage->Put(calDet, id1, metaData);
 938
 939    //
 940
 941    AliCDBMetaData *metaDataPad= new AliCDBMetaData();
 942    metaDataPad->SetObjectClassName("AliTRDCalPad");
 943    metaDataPad->SetResponsible("Raphaelle Bailhache");
 944    metaDataPad->SetBeamPeriod(1);
 945
 946    AliCDBId id1Pad("TRD/Calib/LocalT0", startRunNumber, endRunNumber);
 947    AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
 948    if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
 949
 950
 951
 952  }
 953  //_________________________________________________________________________________________________________________
 954  void AliTRDPreprocessorOffline::UpdateOCDBPRF(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
 955    //
 956    // Update OCDB entry
 957    //
 958
 959    AliCDBMetaData *metaData= new AliCDBMetaData();
 960    metaData->SetObjectClassName("AliTRDCalPad");
 961    metaData->SetResponsible("Raphaelle Bailhache");
 962    metaData->SetBeamPeriod(1);
 963
 964    AliCDBId id1("TRD/Calib/PRFWidth", startRunNumber, endRunNumber);
 965    AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
 966    AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
 967    if(calPad) gStorage->Put(calPad, id1, metaData);
 968
 969
 970  }
 971  //_________________________________________________________________________________________________________________
 972  void AliTRDPreprocessorOffline::UpdateOCDBChamberStatus(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
 973    //
 974    // Update OCDB entry
 975    //
 976
 977    AliCDBMetaData *metaData= new AliCDBMetaData();
 978    metaData->SetObjectClassName("AliTRDCalChamberStatus");
 979    metaData->SetResponsible("Raphaelle Bailhache");
 980    metaData->SetBeamPeriod(1);
 981
 982    AliCDBId id1("TRD/Calib/ChamberStatus", startRunNumber, endRunNumber);
 983    AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
 984    AliTRDCalChamberStatus *calChamberStatus = (AliTRDCalChamberStatus *) fCalibObjects->At(kChamberStatus);
 985    if(calChamberStatus) gStorage->Put(calChamberStatus, id1, metaData);
 986
 987
 988  }
 989  //__________________________________________________________________________________________________________________________
 990  Bool_t AliTRDPreprocessorOffline::ValidateGain() {
 991    //
 992    // Validate OCDB entry
 993    //
 994
 995    AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
 996    if(calDet) {
 997      Double_t mean = calDet->GetMean();
 998      Double_t rms = calDet->GetRMSRobust();
 999      if((mean > 0.2) && (mean < 1.4) && (rms < 0.5)) return kTRUE;
1000      //if((mean > 0.2) && (mean < 1.4)) return kTRUE;
1001      else {
1002        fStatus += 1000000000;
1003        return kFALSE;
1004      }
1005    }
1006    else return kFALSE;
1007
1008
1009
1010  }
1011  //__________________________________________________________________________________________________________________________
1012  Bool_t AliTRDPreprocessorOffline::ValidateVdrift(){
1013    //
1014    // Update OCDB entry
1015    //
1016
1017    Int_t detVdrift = kVdriftPHDet;
1018    Bool_t ok = kTRUE;
1019
1020    if(fMethodSecond) detVdrift = kVdriftLinear;
1021
1022    AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
1023    if(calDet) {
1024      Double_t mean = calDet->GetMean();
1025      Double_t rms = calDet->GetRMSRobust();
1026      //printf("Vdrift::mean %f, rms %f\n",mean,rms);
1027      if(!((mean > 1.0) && (mean < 2.0) && (rms < 0.5))) {
1028        fStatus += 10000000;
1029        ok = kFALSE;
1030      }
1031    }
1032    else return kFALSE;
1033
1034    if(!fMethodSecond) {
1035      AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
1036      if(calPad) {
1037        Double_t mean = calPad->GetMean();
1038        Double_t rms = calPad->GetRMS();
1039        //printf("Vdrift::meanpad %f, rmspad %f\n",mean,rms);
1040        if(!((mean > 0.9) && (mean < 1.1) && (rms < 0.6))) {
1041          fStatus += 10000000;
1042          ok = kFALSE;
1043        }
1044      }
1045      else return kFALSE;
1046    }
1047
1048    return ok;
1049
1050  }
1051  //__________________________________________________________________________________________________________________________
1052  Bool_t AliTRDPreprocessorOffline::ValidateT0(){
1053    //
1054    // Update OCDB entry
1055    //
1056
1057    AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
1058    AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
1059    if(calDet && calPad) {
1060      Double_t meandet = calDet->GetMean();
1061      Double_t rmsdet = calDet->GetRMSRobust();
1062      Double_t meanpad = calPad->GetMean();
1063      //Double_t rmspad = calPad->GetRMS();
1064      //printf("T0::minimum %f, rmsdet %f,meanpad %f, rmspad %f\n",meandet,rmsdet,meanpad,rmspad);
1065      if((meandet > -1.5) && (meandet < 5.0) && (rmsdet < 4.0) && (meanpad < 5.0) && (meanpad > -0.5)) return kTRUE;
1066      else {
1067        fStatus += 100000000;
1068        return kFALSE;
1069      }
1070    }
1071    else return kFALSE;
1072
1073  }
1074  //__________________________________________________________________________________________________________________________
1075  Bool_t AliTRDPreprocessorOffline::ValidatePRF() const{
1076    //
1077    // Update OCDB entry
1078    //
1079
1080    AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
1081    if(calPad) {
1082      Double_t meanpad = calPad->GetMean();
1083      Double_t rmspad = calPad->GetRMS();
1084      //printf("PRF::meanpad %f, rmspad %f\n",meanpad,rmspad);
1085      if((meanpad < 1.0) && (rmspad < 0.8)) return kTRUE;
1086      else return kFALSE;
1087    }
1088    else return kFALSE;
1089
1090
1091  }
1092  //__________________________________________________________________________________________________________________________
1093 Bool_t AliTRDPreprocessorOffline::ValidateChamberStatus() const{
1094   //
1095   // Update OCDB entry
1096   //
1097
1098   AliTRDCalChamberStatus *calChamberStatus = (AliTRDCalChamberStatus *) fCalibObjects->At(kChamberStatus);
1099   if(calChamberStatus) {
1100     Int_t detectormasked = 0;
1101     for(Int_t det = 0; det < 540; det++) {
1102       if(calChamberStatus->IsMasked(det)) detectormasked++;
1103     }
1104     //printf("Number of chambers masked %d\n",detectormasked);
1105     if(detectormasked > 40) return kFALSE;
1106     else return kTRUE;
1107   }
1108   else return kFALSE;
1109
1110 }
1111 //_____________________________________________________________________________
1112 Int_t AliTRDPreprocessorOffline::GetVersion(TString name) const
1113 {
1114   //
1115   // Get version from the title
1116   //
1117
1118   // Some patterns
1119   const Char_t *version = "Ver";
1120   if(!strstr(name.Data(),version)) return -1;
1121   const Char_t *after = "Subver";
1122   if(!strstr(name.Data(),after)) return -1;
1123
1124   for(Int_t ver = 0; ver < 999999999; ver++) {
1125
1126     TString vertry(version);
1127     vertry += ver;
1128     vertry += after;
1129
1130     //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1131
1132     if(strstr(name.Data(),vertry.Data())) return ver;
1133
1134   }
1135
1136   return -1;
1137
1138 }
1139
1140 //_____________________________________________________________________________
1141 Int_t AliTRDPreprocessorOffline::GetSubVersion(TString name) const
1142 {
1143   //
1144   // Get subversion from the title
1145   //
1146
1147   // Some patterns
1148   const Char_t *subversion = "Subver";
1149   if(!strstr(name.Data(),subversion)) return -1;
1150   const Char_t *after = "FirstRun";
1151   if(!strstr(name.Data(),after)) {
1152     after = "Nz";
1153   }
1154   if(!strstr(name.Data(),after)) return -1;
1155
1156
1157   for(Int_t ver = 0; ver < 999999999; ver++) {
1158
1159     TString vertry(subversion);
1160     vertry += ver;
1161     vertry += after;
1162
1163     //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1164
1165     if(strstr(name.Data(),vertry.Data())) return ver;
1166
1167   }
1168
1169   return -1;
1170
1171 }
1172
1173 //_____________________________________________________________________________
1174 Int_t AliTRDPreprocessorOffline::GetFirstRun(TString name) const
1175 {
1176   //
1177   // Get first run from the title
1178   //
1179
1180   // Some patterns
1181   const Char_t *firstrun = "FirstRun";
1182   if(!strstr(name.Data(),firstrun)) return -1;
1183   const Char_t *after = "Nz";
1184   if(!strstr(name.Data(),after)) return -1;
1185
1186
1187   for(Int_t ver = 0; ver < 999999999; ver++) {
1188
1189     TString vertry(firstrun);
1190     vertry += ver;
1191     vertry += after;
1192
1193     //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1194
1195     if(strstr(name.Data(),vertry.Data())) return ver;
1196
1197   }
1198
1199   return -1;
1200
1201 }
1202