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