Commented unnecessary include AliLog
[u/mrichter/AliRoot.git] / TRD / AliTRDPreprocessorOffline.cxx
index 3858665..c6e0ccc 100644 (file)
@@ -46,6 +46,8 @@
 #include "TH1I.h"
 #include "TH2F.h"
 #include "TH1F.h"
+#include "TMath.h"
+#include "THnSparse.h"
 #include "TProfile2D.h"
 #include "AliTRDCalDet.h"
 #include "AliTRDCalPad.h"
 #include "AliTRDCalibraMode.h"
 #include "AliTRDCalibraFit.h"
 #include "AliTRDCalibraVdriftLinearFit.h"
+#include "AliTRDCalibraExbAltFit.h"
 #include "AliTRDPreprocessorOffline.h"
 #include "AliTRDCalChamberStatus.h"
-
+#include "AliTRDCalibChamberStatus.h"
+#include "AliTRDCommonParam.h"
+#include "AliCDBManager.h"
+#include "AliCDBEntry.h"
+#include "AliTRDdEdxBaseUtils.h"
+#include "AliTRDdEdxCalibHistArray.h"
+#include "AliTRDdEdxCalibUtils.h"
 
 ClassImp(AliTRDPreprocessorOffline)
 
-AliTRDPreprocessorOffline::AliTRDPreprocessorOffline():
+  AliTRDPreprocessorOffline::AliTRDPreprocessorOffline():
   TNamed("TPCPreprocessorOffline","TPCPreprocessorOffline"),
   fMethodSecond(kTRUE),
   fNameList("TRDCalib"),
   fCalDetGainUsed(0x0),
   fCalDetVdriftUsed(0x0),
+  fCalDetExBUsed(0x0),
   fCH2d(0x0),
   fPH2d(0x0),
   fPRF2d(0x0),
+  fSparse(0x0),
   fAliTRDCalibraVdriftLinearFit(0x0),
+  fAliTRDCalibraExbAltFit(0x0),
   fNEvents(0x0),
   fAbsoluteGain(0x0),
-  fPlots(new TObjArray(8)),
-  fCalibObjects(new TObjArray(8)),
+  fPlots(new TObjArray(kNumCalibObjs)),
+  fCalibObjects(new TObjArray(kNumCalibObjs)),
+  fFirstRunGainUsed(0),
   fVersionGainUsed(0),
   fSubVersionGainUsed(0),
+  fFirstRunVdriftUsed(0),
   fVersionVdriftUsed(0), 
   fSubVersionVdriftUsed(0),
+  fFirstRunExBUsed(0),
+  fVersionExBUsed(0), 
+  fSubVersionExBUsed(0),
+  fNoExBUsedInReco(kFALSE),
   fSwitchOnValidation(kTRUE),
   fVdriftValidated(kFALSE),
+  fExBValidated(kFALSE),
   fT0Validated(kFALSE),
   fMinStatsVdriftT0PH(800*20),
   fMinStatsVdriftLinear(800),
   fMinStatsGain(800),
-  fMinStatsPRF(600)
+  fMinStatsPRF(600),
+  fMinStatsChamberStatus(20),
+  fMinSingleStatsChamberStatus(0.05),
+  fBackCorrectGain(kFALSE),  
+  fBackCorrectVdrift(kTRUE),
+  fNotEnoughStatisticsForTheGain(kFALSE),
+  fNotEnoughStatisticsForTheVdriftLinear(kFALSE),
+  fStatusNeg(0),
+  fStatusPos(0),
+  fBadCalibValidate(40),
+  fNoDataValidate(40),
+  fRMSBadCalibratedGain(20.0),
+  fRMSBadCalibratedVdrift(20.0),
+  fRMSBadCalibratedExB(20.0),
+  fRobustFitDriftVelocity(kTRUE),
+  fRobustFitExbAlt(kFALSE),
+  fAlternativeVdrfitFit(kFALSE),
+  fAlternativeExbAltFit(kFALSE),
+  fMinNbOfPointVdriftFit(11),
+  fMethodeGain(0),
+  fOutliersFitChargeLow(0.03),
+  fOutliersFitChargeHigh(0.7),
+  fBeginFitCharge(3.5),
+  fPHQon(kTRUE),
+  fDebugPHQon(kFALSE)
 {
   //
   // default constructor
   //
+
+  memset(fBadCalib, 0, sizeof(Int_t) * 18);
+  memset(fNoData, 0, sizeof(Int_t) * 18);
 }
 //_________________________________________________________________________________________________________________
 AliTRDPreprocessorOffline::~AliTRDPreprocessorOffline() {
@@ -100,16 +146,53 @@ AliTRDPreprocessorOffline::~AliTRDPreprocessorOffline() {
 
   if(fCalDetGainUsed) delete fCalDetGainUsed;
   if(fCalDetVdriftUsed) delete fCalDetVdriftUsed;
+  if(fCalDetExBUsed) delete fCalDetExBUsed;
   if(fCH2d) delete fCH2d;
   if(fPH2d) delete fPH2d;
   if(fPRF2d) delete fPRF2d;
+  if(fSparse) delete fSparse;
+
+  if(IsPHQon()){
+    AliTRDdEdxCalibUtils::DeleteHistArray();
+    AliTRDdEdxCalibUtils::DeleteObjArray();
+  }
+
   if(fAliTRDCalibraVdriftLinearFit) delete fAliTRDCalibraVdriftLinearFit;
+  if(fAliTRDCalibraExbAltFit) delete fAliTRDCalibraExbAltFit;
   if(fNEvents) delete fNEvents;
   if(fAbsoluteGain) delete fAbsoluteGain;
   if(fPlots) delete fPlots;
   if(fCalibObjects) delete fCalibObjects;
   
 }
+//___________________________________________________________________________________
+void AliTRDPreprocessorOffline::Process(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage) 
+{
+  //
+  // Process to the gain, vdrift, timeoffset, exb and chamber status calibration
+  //
+  
+  if(SetCalDetGain(startRunNumber,fVersionGainUsed,fSubVersionGainUsed) && SetCalDetVdriftExB(startRunNumber,fVersionVdriftUsed,fSubVersionVdriftUsed,fVersionExBUsed,fSubVersionExBUsed)) {
+    
+    CalibVdriftT0(file,startRunNumber,endRunNumber,ocdbStorage);
+    CalibGain(file,startRunNumber,endRunNumber,ocdbStorage);
+    CalibChamberStatus(file,startRunNumber,endRunNumber,ocdbStorage);
+    CalibExbAlt(file,startRunNumber,endRunNumber,ocdbStorage);
+
+  }
+
+  if(IsPHQon()){
+    printf("\n                  AliTRDPreprocessorOffline PHQ on!!\n\n");
+    AliTRDdEdxBaseUtils::PrintControl();
+    CalibPHQ(file, startRunNumber, endRunNumber, ocdbStorage);
+  }
+  else{
+    printf("\n                  AliTRDPreprocessorOffline PHQ off!!\n\n");
+  }
+
+  PrintStatus();
+  
+}
 //___________________________________________________________________________________________________________________
 
 void AliTRDPreprocessorOffline::CalibVdriftT0(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
@@ -126,12 +209,13 @@ void AliTRDPreprocessorOffline::CalibVdriftT0(const Char_t* file, Int_t startRun
   //
   fVdriftValidated = kTRUE;
   fT0Validated = kTRUE;
+  fExBValidated = kTRUE;
+  fNotEnoughStatisticsForTheVdriftLinear = kFALSE;
   //
   // 2. extraction of the information
   //
+  if(ReadVdriftLinearFitGlobal(file) && fCalDetVdriftUsed && fCalDetExBUsed) AnalyzeVdriftLinearFit();
   if(ReadVdriftT0Global(file)) AnalyzeVdriftT0();
-  //printf("Finish PH\n");
-  if(ReadVdriftLinearFitGlobal(file)) AnalyzeVdriftLinearFit();
   //
   // 3. Append QA plots
   //
@@ -141,21 +225,61 @@ void AliTRDPreprocessorOffline::CalibVdriftT0(const Char_t* file, Int_t startRun
   // 4. validate OCDB entries
   //
   if(fSwitchOnValidation==kTRUE && ValidateVdrift()==kFALSE) { 
-    AliError("TRD vdrift OCDB parameters out of range!");
+    //AliError("TRD vdrift OCDB parameters out of range!");
     fVdriftValidated = kFALSE;
   }
   if(fSwitchOnValidation==kTRUE && ValidateT0()==kFALSE) { 
-    AliError("TRD t0 OCDB parameters out of range!");
+    //AliError("TRD t0 OCDB parameters out of range!");
     fT0Validated = kFALSE;
   }
+  if(fSwitchOnValidation==kTRUE && ValidateExB()==kFALSE) { 
+    //AliError("TRD t0 OCDB parameters out of range!");
+    fExBValidated = kFALSE;
+  }
   //
   // 5. update of OCDB
   //
   //
   if(fVdriftValidated) UpdateOCDBVdrift(startRunNumber,endRunNumber,ocdbStorage);
   if(fT0Validated) UpdateOCDBT0(startRunNumber,endRunNumber,ocdbStorage);
+  if(fExBValidated) UpdateOCDBExB(startRunNumber,endRunNumber,ocdbStorage);
+  
+}
+//___________________________________________________________________________________________________________________
+
+void AliTRDPreprocessorOffline::CalibExbAlt(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
+  //
+  // make calibration of the drift velocity
+  // Input parameters:
+  //      file                             - the location of input file
+  //      startRunNumber, endRunNumber     - run validity period 
+  //      ocdbStorage                      - path to the OCDB storage
+  //                                       - if empty - local storage 'pwd' uesed
+  if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
+  //
+  // 1. Initialization 
+  //
+
+  //
+  // 2. extraction of the information
+  //
+  if(ReadExbAltFitGlobal(file)) AnalyzeExbAltFit();
+  //
+  // 3. Append QA plots
+  //
+  //MakeDefaultPlots(fVdriftArray,fVdriftArray);
+  //
+  //
+  // 4. validate OCDB entries
+  //
+  //
+  // 5. update of OCDB
+  //
+  //
+  UpdateOCDBExBAlt(startRunNumber,endRunNumber,ocdbStorage);
   
 }
+
 //_________________________________________________________________________________________________________________
 
 void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
@@ -168,6 +292,8 @@ void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumb
   //                                       - if empty - local storage 'pwd' uesed
   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
   //
+  fNotEnoughStatisticsForTheGain = kFALSE;
+  //
   // 1. Initialization 
   if(!ReadGainGlobal(file)) return;
   //
@@ -175,8 +301,8 @@ void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumb
   // 2. extraction of the information
   //
   AnalyzeGain();
-  if(fCalDetGainUsed) CorrectFromDetGainUsed();
-  if(fCalDetVdriftUsed) CorrectFromDetVdriftUsed();
+  if(fBackCorrectGain) CorrectFromDetGainUsed();
+  //if(fBackCorrectVdrift) CorrectFromDetVdriftUsed();
   //
   // 3. Append QA plots
   //
@@ -186,7 +312,7 @@ void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumb
   // 4. validate OCDB entries
   //
   if(fSwitchOnValidation==kTRUE && ValidateGain()==kFALSE) { 
-    AliError("TRD gain OCDB parameters out of range!");
+    //AliError("TRD gain OCDB parameters out of range!");
     return;
   }
   //
@@ -226,7 +352,7 @@ void AliTRDPreprocessorOffline::CalibPRF(const Char_t* file, Int_t startRunNumbe
   // 4. validate OCDB entries
   //
   if(fSwitchOnValidation==kTRUE && ValidatePRF()==kFALSE) { 
-    AliError("TRD prf OCDB parameters out of range!");
+    //AliError("TRD prf OCDB parameters out of range!");
     return;
   }
   //
@@ -237,8 +363,29 @@ void AliTRDPreprocessorOffline::CalibPRF(const Char_t* file, Int_t startRunNumbe
   
 }
 //________________________________________________________________________________________________________________
+void AliTRDPreprocessorOffline::CalibPHQ(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage)
+{
+  //
+  // make calibration of puls height Q
+  // Input parameters:
+  //      startRunNumber, endRunNumber     - run validity period 
+  //      ocdbStorage                      - path to the OCDB storage
+  //                                       - if empty - local storage 'pwd' uesed
+  //
+
+  if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
+  //printf("test %s\n", ocdbStorage.Data());
+
+  if(!ReadPHQGlobal(file)) return;
+
+  if(!AnalyzePHQ(startRunNumber)) return;
 
-void AliTRDPreprocessorOffline::CalibChamberStatus(Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
+  UpdateOCDBPHQ(startRunNumber,endRunNumber,ocdbStorage);
+}
+
+//________________________________________________________________________________________________________________
+
+void AliTRDPreprocessorOffline::CalibChamberStatus(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
   //
   // make calibration of the chamber status
   // Input parameters:
@@ -248,6 +395,11 @@ void AliTRDPreprocessorOffline::CalibChamberStatus(Int_t startRunNumber, Int_t e
   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
   //
   //
+  // 1. Initialization  
+  if(!ReadStatusGlobal(file)) return;
+  //
+  //
+  //
   // 2. extraction of the information
   //
   if(!AnalyzeChamberStatus()) return;
@@ -261,14 +413,15 @@ void AliTRDPreprocessorOffline::CalibChamberStatus(Int_t startRunNumber, Int_t e
   // 4. validate OCDB entries
   //
   if(fSwitchOnValidation==kTRUE && ValidateChamberStatus()==kFALSE) { 
-    AliError("TRD Chamber status OCDB parameters not ok!");
+    //AliError("TRD Chamber status OCDB parameters not ok!");
     return;
   }
   //
   // 5. update of OCDB
   //
   //
-  UpdateOCDBChamberStatus(startRunNumber,endRunNumber,ocdbStorage);
+  if((!fNotEnoughStatisticsForTheVdriftLinear) && (!fNotEnoughStatisticsForTheGain)) UpdateOCDBChamberStatus(startRunNumber,endRunNumber,ocdbStorage);
+  //UpdateOCDBChamberStatus(startRunNumber,endRunNumber,ocdbStorage);
   
 }
 //______________________________________________________________________________________________________
@@ -280,6 +433,7 @@ Bool_t AliTRDPreprocessorOffline::Init(const Char_t* fileName){
   if(ReadVdriftT0Global(fileName)) {
     
     TString nameph = fPH2d->GetTitle();
+    fFirstRunVdriftUsed = GetFirstRun(nameph); 
     fVersionVdriftUsed = GetVersion(nameph);  
     fSubVersionVdriftUsed = GetSubVersion(nameph);    
 
@@ -290,18 +444,63 @@ Bool_t AliTRDPreprocessorOffline::Init(const Char_t* fileName){
   if(ReadGainGlobal(fileName)) {
 
     TString namech = fCH2d->GetTitle();
+    fFirstRunGainUsed = GetFirstRun(namech); 
     fVersionGainUsed = GetVersion(namech);  
     fSubVersionGainUsed = GetSubVersion(namech);    
 
     //printf("Found Version %d, Subversion %d for gain\n",fVersionGainUsed,fSubVersionGainUsed);
 
   }
+  
+  if(ReadVdriftLinearFitGlobal(fileName)) {
+
+    TString namelinear = fAliTRDCalibraVdriftLinearFit->GetNameCalibUsed();
+    fFirstRunExBUsed = GetFirstRun(namelinear); 
+    fVersionExBUsed = GetVersion(namelinear);  
+    fSubVersionExBUsed = GetSubVersion(namelinear);   
+
+    //printf("Found Version %d, Subversion %d, run %d for ExB\n",fVersionExBUsed,fSubVersionExBUsed,fFirstRunExBUsed);
+    
+  }
    
+  if(fVersionVdriftUsed == 0) fStatusPos = fStatusPos |kVdriftErrorOld;
+  if(fVersionGainUsed == 0) fStatusPos = fStatusPos | kGainErrorOld;
+
   return kTRUE;
   
 }
 //___________________________________________________________________________________________________________________
 
+Bool_t AliTRDPreprocessorOffline::ReadStatusGlobal(const Char_t* fileName){
+  //
+  // read calibration entries from file
+  // 
+  if(fSparse) return kTRUE;
+  TFile fcalib(fileName);
+  TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
+  if (array){
+    fSparse = (THnSparseI *) array->FindObject("NumberOfEntries");
+    if(!fSparse) return kFALSE;
+  }
+  else 
+    return kFALSE;
+  
+  return kTRUE;
+  
+}
+//___________________________________________________________________________________________________________________
+
+Bool_t AliTRDPreprocessorOffline::ReadPHQGlobal(const Char_t* fileName)
+{
+  //
+  // read calibration entries from file
+  //
+
+  return AliTRDdEdxCalibUtils::ReadHistArray(fileName, fNameList);
+}
+
+//___________________________________________________________________________________________________________________
+
 Bool_t AliTRDPreprocessorOffline::ReadGainGlobal(const Char_t* fileName){
   //
   // read calibration entries from file
@@ -378,6 +577,28 @@ Bool_t AliTRDPreprocessorOffline::ReadVdriftLinearFitGlobal(const Char_t* fileNa
   
 }
 //_____________________________________________________________________________________________________________
+Bool_t AliTRDPreprocessorOffline::ReadExbAltFitGlobal(const Char_t* fileName){
+  //
+  // read calibration entries from file
+  // 
+  if(fAliTRDCalibraExbAltFit) return kTRUE;
+  TFile fcalib(fileName);
+  TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
+  if (array){
+    fAliTRDCalibraExbAltFit = (AliTRDCalibraExbAltFit *) array->FindObject("AliTRDCalibraExbAltFit");
+    //fNEvents = (TH1I *) array->FindObject("NEvents");
+  }else{
+    fAliTRDCalibraExbAltFit = (AliTRDCalibraExbAltFit *) fcalib.Get("AliTRDCalibraExbAltFit");
+    //fNEvents = (TH1I *) fcalib.Get("NEvents");
+  }
+  if(!fAliTRDCalibraExbAltFit) {
+    //printf("No AliTRDCalibraExbAltFit\n");
+    return kFALSE;
+  }
+  return kTRUE;
+  
+}
+//_____________________________________________________________________________________________________________
 
 Bool_t AliTRDPreprocessorOffline::ReadPRFGlobal(const Char_t* fileName){
   //
@@ -411,6 +632,10 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){
   //
 
   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
+  calibra->ChooseMethod(fMethodeGain);
+  calibra->SetBeginFitCharge(fBeginFitCharge);
+  calibra->SetFitOutliersChargeLow(fOutliersFitChargeLow);
+  calibra->SetFitOutliersChargeHigh(fOutliersFitChargeHigh);
   calibra->SetMinEntries(fMinStatsGain); // If there is less than 1000 entries in the histo: no fit
   calibra->AnalyseCH(fCH2d);
 
@@ -426,7 +651,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){
   if ((nbtg >                  0) && 
       (nbfit        >= 0.5*nbE) && (nbE > 30)) {
     // create the cal objects
-    if(!fCalDetGainUsed) {
+    if(!fBackCorrectGain) {
       calibra->PutMeanValueOtherVectorFit(1,kTRUE);
       meanother = kTRUE;
     }
@@ -439,6 +664,36 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){
     //
     ok = kTRUE;
   }
+  else {
+    fNotEnoughStatisticsForTheGain = kTRUE;
+    Int_t minStatsGain = fMinStatsGain*30;
+    calibra->SetMinEntries(minStatsGain); // Because we do it for all, we increase this
+    Double_t gainoverallnotnormalized =  calibra->AnalyseCHAllTogether(fCH2d);
+    if(fCalDetGainUsed && (gainoverallnotnormalized > 0.0)) {
+      AliTRDCalDet *calDetGain = new AliTRDCalDet(*fCalDetGainUsed);
+      Double_t oldmean = fCalDetGainUsed->CalcMean(kFALSE);
+      //printf("oldmean %f\n",oldmean);
+      if(oldmean > 0.0)  {
+       Double_t scalefactor = calibra->GetScaleFactorGain();
+       //printf("Correction factor %f\n",gainoverallnotnormalized*scalefactor);
+       calDetGain->Multiply(gainoverallnotnormalized*scalefactor/oldmean);
+       //printf("newmean %f\n",calDetGain->CalcMean(kFALSE));
+       TH1F *coefGain  = calDetGain->MakeHisto1DAsFunctionOfDet();
+       fCalibObjects->AddAt(calDetGain,kGain);
+       fPlots->AddAt(coefGain,kGain);
+       // 
+       ok = kTRUE;
+       fStatusNeg = fStatusNeg | kGainNotEnoughStatsButFill;
+      }
+      else {
+       fStatusPos = fStatusPos | kGainErrorOld;
+      }      
+    }
+    else {
+      if(gainoverallnotnormalized <= 0.0) fStatusNeg = fStatusNeg | kGainNotEnoughStatsNotFill;
+      if(!fCalDetGainUsed) fStatusPos = fStatusPos | kGainErrorOld;
+    }
+  }
   
   calibra->ResetVectorFit();
   
@@ -495,6 +750,10 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftT0(){
     //
     ok = kTRUE;
   }
+  else {
+    //printf("Not enough stats timeoffset\n");
+    fStatusNeg = fStatusNeg | kTimeOffsetNotEnoughStatsNotFill;
+  }
   calibra->ResetVectorFit();
  
   return ok;
@@ -508,10 +767,18 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){
 
   //printf("Analyse linear fit\n");
 
+  
   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
+  calibra->SetCalDetVdriftExB(fCalDetVdriftUsed,fCalDetExBUsed);
   calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit
+  printf("The mean stat is by %d for VdriftLinear\n",fMinStatsVdriftLinear);
   //printf("Fill PE Array\n");
-  fAliTRDCalibraVdriftLinearFit->FillPEArray();
+  fAliTRDCalibraVdriftLinearFit->SetRobustFit(fRobustFitDriftVelocity);
+  fAliTRDCalibraVdriftLinearFit->SetMinNumberOfPointsForFit(fMinNbOfPointVdriftFit);
+  if(!fAlternativeVdrfitFit)
+    fAliTRDCalibraVdriftLinearFit->FillPEArray();
+  else
+    fAliTRDCalibraVdriftLinearFit->FillPEArray2();
   //printf("AliTRDCalibraFit\n");
   calibra->AnalyseLinearFitters(fAliTRDCalibraVdriftLinearFit);
   //printf("After\n");
@@ -536,6 +803,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){
     object                     = calibra->GetVectorFit2();
     AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectLorentzAngle(&object);
     TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
+    //if(!calDetLorentz) printf("No lorentz created\n");
     // Put them in the array
     fCalibObjects->AddAt(calDetVdrift,kVdriftLinear);
     fCalibObjects->AddAt(calDetLorentz,kLorentzLinear);
@@ -544,6 +812,97 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){
     //
     ok = kTRUE;
   }
+  else {
+    fNotEnoughStatisticsForTheVdriftLinear = kTRUE;
+    Int_t minNumberOfEntriesForAll = fMinStatsVdriftLinear*30;
+    calibra->SetMinEntries(minNumberOfEntriesForAll); // Because we do it for all, we increase this
+    Double_t vdriftoverall = -100.0;
+    Double_t exboverall = 100.0;
+    calibra->AnalyseLinearFittersAllTogether(fAliTRDCalibraVdriftLinearFit,vdriftoverall,exboverall);
+    //printf("Found mean vdrift %f and exb %f\n",vdriftoverall,exboverall);
+    if(fCalDetVdriftUsed && (vdriftoverall > 0.0) && (exboverall < 70.0)) {
+      AliTRDCalDet *calDetVdrift = new AliTRDCalDet(*fCalDetVdriftUsed);
+      AliTRDCalDet *calDetLorentz = new AliTRDCalDet(*fCalDetExBUsed);
+      Double_t oldmeanvdrift = fCalDetVdriftUsed->CalcMean(kFALSE);
+      Double_t oldmeanexb = fCalDetExBUsed->CalcMean(kFALSE);
+      //printf("oldmean %f\n",oldmean);
+      if((oldmeanvdrift > 0.0) && (oldmeanexb < 70.0))  {
+       //printf("Correction factor %f\n",vdriftoverall);
+       calDetVdrift->Multiply(vdriftoverall/oldmeanvdrift);
+       if(TMath::Abs(oldmeanexb) > 0.0001) calDetLorentz->Multiply(exboverall/oldmeanexb);
+       //printf("newmean %f\n",calDetVdrift->CalcMean(kFALSE));
+       TH1F *coefDriftLinear  = calDetVdrift->MakeHisto1DAsFunctionOfDet();
+       TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
+       // Put them in the array
+       fCalibObjects->AddAt(calDetVdrift,kVdriftLinear);
+       fCalibObjects->AddAt(calDetLorentz,kLorentzLinear);
+       fPlots->AddAt(coefDriftLinear,kVdriftLinear);
+       fPlots->AddAt(coefLorentzAngle,kLorentzLinear);
+       // 
+       ok = kTRUE;
+       fStatusNeg = fStatusNeg | kVdriftNotEnoughStatsButFill;
+      }
+      else {
+       if(oldmeanvdrift) fStatusPos = fStatusPos | kVdriftErrorOld;
+       if(oldmeanexb) fStatusPos = fStatusPos | kExBErrorOld;
+      }      
+    }
+    else {
+      if((vdriftoverall <= 0.0) && (exboverall > 70.0)) fStatusNeg = fStatusNeg | kVdriftNotEnoughStatsNotFill;
+      if(!fCalDetVdriftUsed) fStatusPos = fStatusPos | kVdriftErrorOld;
+      if(!fCalDetExBUsed) fStatusPos = fStatusPos | kExBErrorOld;
+    }
+  }
+  
+  calibra->ResetVectorFit();
+  
+  return ok;
+  
+}
+//________________________________________________________________________________________________________________
+
+Bool_t AliTRDPreprocessorOffline::AnalyzeExbAltFit(){
+  //
+  // Analyze vdrift linear fit - produce the calibration objects
+  //
+
+  //printf("Analyse linear fit\n");
+
+  
+  AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
+  calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit
+  //printf("Fill PE Array\n");
+  fAliTRDCalibraExbAltFit->SetRobustFit(fRobustFitExbAlt);
+  if(!fAlternativeExbAltFit)
+    fAliTRDCalibraExbAltFit->FillPEArray();
+  else
+    fAliTRDCalibraExbAltFit->FillPEArray2();
+  //printf("AliTRDCalibraFit\n");
+  calibra->AnalyseExbAltFit(fAliTRDCalibraExbAltFit);
+  //printf("After\n");
+
+  //Int_t nbtg        = 540;
+  Int_t nbfit       = calibra->GetNumberFit();
+  Int_t nbE         = calibra->GetNumberEnt();
+
+  
+  Bool_t ok = kFALSE;
+  // enough statistics
+  if ((nbfit        >= 0.5*nbE) && (nbE > 30)) {
+    // create the cal objects
+    //calibra->RemoveOutliers(1,kTRUE);
+    calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
+    //
+    TObjArray object  = calibra->GetVectorFit2();
+    AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectExbAlt(&object);
+    TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
+    //if(!calDetLorentz) printf("No lorentz created\n");
+    // Put them in the array
+    fCalibObjects->AddAt(calDetLorentz,kExbAlt);
+    fPlots->AddAt(coefLorentzAngle,kExbAlt);
+    //
+    ok = kTRUE;
+  }
   
   calibra->ResetVectorFit();
   
@@ -589,35 +948,80 @@ Bool_t AliTRDPreprocessorOffline::AnalyzePRF(){
 }
 
 //_____________________________________________________________________________
+Bool_t AliTRDPreprocessorOffline::AnalyzePHQ(Int_t startRunNumber)
+{
+  //
+  //Produce PHQ calibration results
+  //
+  TList *lout = 0x0;
+  TTreeSRedirector *calibStream = 0x0;
+  if(IsDebugPHQon()){
+    lout = new TList;
+    lout->SetOwner();
+
+    calibStream = new TTreeSRedirector(Form("TRDCalibStream_%010d.root", startRunNumber));
+  }
+
+  for(Int_t iter=0; iter<AliTRDdEdxCalibUtils::GetHistArray()->GetSize(); iter++){
+    THnBase *hi = (THnBase*) AliTRDdEdxCalibUtils::GetHistAt(iter);
+    TObjArray *obji = AliTRDdEdxCalibUtils::HistToObj(hi, startRunNumber, lout, calibStream);
+    //printf("test analyze %s\n", obji->GetName());
+    AliTRDdEdxCalibUtils::GetObjArray()->AddAt(obji, iter);
+  }
+
+  fCalibObjects->AddAt(AliTRDdEdxCalibUtils::GetObjArray(), kPHQ);
+
+  if(lout){
+    TFile *fout=new TFile(Form("TRDCalibList_%010d.root", startRunNumber),"recreate");
+    fout->cd();
+    lout->Write();
+    fout->Save();
+    fout->Close();
+    delete fout;
+  }
+  delete calibStream;
+  delete lout;
+
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
 Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
 {
   //
   // Produce AliTRDCalChamberStatus out of calibration results
   //
-
-  // set up AliTRDCalChamberStatus
-  AliTRDCalChamberStatus *CalChamberStatus = new AliTRDCalChamberStatus();
-  for(Int_t det = 0; det < 540; det++) CalChamberStatus->SetStatus(det,1);
+  
+  // set up AliTRDCalibChamberStatus
+  AliTRDCalibChamberStatus *chamberStatus = new AliTRDCalibChamberStatus();
+  chamberStatus->SetSparseI(fSparse);
+  chamberStatus->AnalyseHisto(fMinStatsChamberStatus, fMinSingleStatsChamberStatus);
+  // get AliTRDCalChamberStatus
+  AliTRDCalChamberStatus *calChamberStatus = chamberStatus->GetCalChamberStatus();
 
   // get calibration objects
   AliTRDCalDet *calDetGain   = (AliTRDCalDet *) fCalibObjects->At(kGain);
   AliTRDCalDet *calDetVDrift = (AliTRDCalDet *) fCalibObjects->At(kVdriftLinear);
+  AliTRDCalDet *calDetExB    = (AliTRDCalDet *) fCalibObjects->At(kLorentzLinear);
 
   // Check
-  if((!calDetGain) || (!calDetVDrift)) return kFALSE;
+  if((!calDetGain) || (!calDetVDrift) || (!fCH2d) || (!calDetExB) || (!calChamberStatus)) return kFALSE;
 
   // Gain
-  Double_t gainmean = calDetGain->GetMean();
+  Double_t gainmean   = calDetGain->GetMean();
   Double_t vdriftmean = calDetVDrift->GetMean();
+  Double_t exbmean    = calDetExB->GetMean();
 
-  Double_t gainrms = calDetGain->GetRMSRobust();
-  Double_t vdriftrms = calDetVDrift->GetRMSRobust();
+  Double_t gainrms    = calDetGain->GetRMSRobust();
+  Double_t vdriftrms  = calDetVDrift->GetRMSRobust();
+  Double_t exbrms     = calDetExB->GetRMSRobust();
 
   //printf("Gain mean: %f, rms: %f\n",gainmean,gainrms);
   //printf("Vdrift mean: %f, rms: %f\n",vdriftmean,vdriftrms);
-  
+  //printf("ExB mean: %f, rms: %f\n",exbmean,exbrms);
+
   // Check
-  if((TMath::Abs(gainrms) < 0.001) || (TMath::Abs(vdriftrms) < 0.001)) return kFALSE;
+  if((TMath::Abs(gainrms) < 0.001) || (TMath::Abs(vdriftrms) < 0.001) || (TMath::Abs(exbrms) < 0.0000001)) return kFALSE;
 
   // mask chambers with empty gain entries
   //Int_t counter = 0;
@@ -626,6 +1030,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
     // ch2d
     TH1I *projch =  (TH1I *) fCH2d->ProjectionX("projch",idet+1,idet+1,(Option_t *)"e");
     Double_t entries = projch->GetEntries();
+    //printf("Number of entries %f for det %d\n",entries,idet);
 
     // gain
     Double_t gain = calDetGain->GetValue(idet);
@@ -633,47 +1038,60 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
     // vdrift
     Double_t vdrift = calDetVDrift->GetValue(idet);
 
+    // exb
+    Double_t exb = calDetExB->GetValue(idet);
+
 
-    if(entries<=0.5 ||
-       TMath::Abs(gainmean-gain) > (15.0*gainrms) ||
-       TMath::Abs(vdriftmean-vdrift) > (15.0*vdriftrms)) {
+    if( (entries<50 && !calChamberStatus->IsNoData(idet))  ||
+        TMath::Abs(gainmean-gain) > (fRMSBadCalibratedGain*gainrms)          ||
+        TMath::Abs(vdriftmean-vdrift) > (fRMSBadCalibratedVdrift*vdriftrms)    ||
+        TMath::Abs(exbmean-exb) > (fRMSBadCalibratedExB*exbrms) ) {
      
       //printf(" chamber det %03d masked \n",idet);
       //printf(" gainmean %f and gain %f, gainrms %f \n",gainmean,gain,gainrms);
       //printf(" vdriftmean %f and vdrift %f, vdriftrms %f \n",vdriftmean,vdrift,vdriftrms);
-      CalChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kMasked);
+      //printf(" exbmean %f and exb %f, exbrms %f \n",exbmean,exb,exbrms);
+      
+      calChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kBadCalibrated);
       //counter++;
     }
 
-     /*
-     // installed supermodules+1 -> abort
-     if(counter > (7+1)*30) {
-       printf("ERROR: more than one SM to be masked!! \n Abort...\n");
-       if(projch) delete projch;
-       return 0x0;
-     }
-     */
-
-     if(projch) delete projch;
-
-   }
-
-   // Security
-   for(Int_t sm=0; sm < 18; sm++) {
-     Int_t counter = 0;
-     for(Int_t det = 0; det < 30; det++){
-       Int_t detector = sm*30+det;
-       if(CalChamberStatus->IsMasked(detector)) counter++;
-     }
-     if(counter >= 10) {
-       for(Int_t det = 0; det < 30; det++){
-        Int_t detector = sm*30+det;
-        CalChamberStatus->SetStatus(detector,AliTRDCalChamberStatus::kInstalled);
-       }
-     }
+    delete projch;
+    
    }
 
-   fCalibObjects->AddAt(CalChamberStatus,kChamberStatus);
+  // Security
+  for(Int_t sm=0; sm < 18; sm++) {
+    Int_t smnodata   = 0;
+    Int_t smbadcalib = 0;
+    for(Int_t det = 0; det < 30; det++){
+      Int_t detector = sm*30+det;
+      if(calChamberStatus->IsNoData(detector)) smnodata++;
+      else {
+       if(calChamberStatus->IsBadCalibrated(detector)) smbadcalib++;
+      }
+    }
+    fNoData[sm]  = smnodata;
+    fBadCalib[sm]= smbadcalib;
+    //printf("No Data %d, bad calibrated %d for %d\n",fNoData[sm],fBadCalib[sm],sm);
+  }
+  
+  // Security
+  //   for(Int_t sm=0; sm < 18; sm++) {
+  //     Int_t counter = 0;
+  //     for(Int_t det = 0; det < 30; det++){
+  //       Int_t detector = sm*30+det;
+  //       if(calChamberStatus->IsBadCalibrated(detector)) counter++;
+  //     }
+  //     if(counter >= 20) {
+  //       for(Int_t det = 0; det < 30; det++){
+  //   Int_t detector = sm*30+det;
+  //   calChamberStatus->SetStatus(detector,AliTRDCalChamberStatus::kGood);
+  //       }
+  //     }
+  //  }
+
+   fCalibObjects->AddAt(calChamberStatus,kChamberStatus);
    return kTRUE;
 
  }
@@ -709,8 +1127,18 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
      Float_t gaininit = fCalDetGainUsed->GetValue(det);
      Float_t gainout = calDetGain->GetValue(det);
 
-     if(TMath::Abs(gainout-1.0) > 0.000001) calDetGain->SetValue(det,gaininit*gainout);
-     else calDetGain->SetValue(det,mean);
+     if(TMath::Abs(gainout-1.0) > 0.000001) {
+       Double_t newgain = gaininit*gainout;
+       if(newgain < 0.1) newgain = 0.1;
+       if(newgain > 1.9) newgain = 1.9;
+       calDetGain->SetValue(det,newgain);
+     }
+     else {
+       Double_t newgain = mean;
+       if(newgain < 0.1) newgain = 0.1;
+       if(newgain > 1.9) newgain = 1.9;
+       calDetGain->SetValue(det,newgain);
+     }
    }
 
 
@@ -732,21 +1160,37 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
    if(!calDetVdrift) return;
 
    // Calculate mean
-
-   for(Int_t det = 0; det < 540; det++) {
-
-     Float_t vdriftinit = fCalDetVdriftUsed->GetValue(det);
-     Float_t vdriftout = calDetVdrift->GetValue(det);
-
-     Float_t gain = calDetGain->GetValue(det);
-     if(vdriftout > 0.0) gain = gain*vdriftinit/vdriftout;
-     calDetGain->SetValue(det,gain);
-
-
+   if(!fNotEnoughStatisticsForTheVdriftLinear) {
+     for(Int_t det = 0; det < 540; det++) {
+       
+       Float_t vdriftinit = fCalDetVdriftUsed->GetValue(det);
+       Float_t vdriftout = calDetVdrift->GetValue(det);
+       
+       Float_t gain = calDetGain->GetValue(det);
+       if(vdriftout > 0.0) gain = gain*vdriftinit/vdriftout;
+       if(gain < 0.1) gain = 0.1;
+       if(gain > 1.9) gain = 1.9;
+       calDetGain->SetValue(det,gain);
+     }
    }
-
+   else {
+     
+     Float_t vdriftinit = fCalDetVdriftUsed->CalcMean(kFALSE);
+     Float_t vdriftout = calDetVdrift->CalcMean(kFALSE);
+     Float_t factorcorrectif = 1.0;
+     if(vdriftout > 0.0) factorcorrectif = vdriftinit/vdriftout;
+     for(Int_t det = 0; det < 540; det++) {
+       Float_t gain = calDetGain->GetValue(det);
+       gain = gain*factorcorrectif;
+       if(gain < 0.1) gain = 0.1;
+       if(gain > 1.9) gain = 1.9;
+       calDetGain->SetValue(det,gain);
+     }
+     
+   }
+   
  }
- //_________________________________________________________________________________________________________________
+//_________________________________________________________________________________________________________________
  void AliTRDPreprocessorOffline::UpdateOCDBGain(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
    //
    // Update OCDB entry
@@ -755,6 +1199,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
    AliCDBMetaData *metaData= new AliCDBMetaData();
    metaData->SetObjectClassName("AliTRDCalDet");
    metaData->SetResponsible("Raphaelle Bailhache");
+   metaData->AddDateToComment();
    metaData->SetBeamPeriod(1);
 
    AliCDBId id1("TRD/Calib/ChamberGainFactor", startRunNumber, endRunNumber);
@@ -765,6 +1210,54 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
 
  }
  //___________________________________________________________________________________________________________________
+ void AliTRDPreprocessorOffline::UpdateOCDBExB(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
+   //
+   // Update OCDB entry
+   //
+
+   Int_t detExB = kLorentzLinear;
+   if(!fMethodSecond) return;
+
+   //printf("Pass\n");
+
+   AliCDBMetaData *metaData= new AliCDBMetaData();
+   metaData->SetObjectClassName("AliTRDCalDet");
+   metaData->SetResponsible("Raphaelle Bailhache");
+   metaData->AddDateToComment();
+   metaData->SetBeamPeriod(1);
+
+   AliCDBId id1("TRD/Calib/ChamberExB", startRunNumber, endRunNumber);
+   AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
+   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detExB);
+   if(calDet) gStorage->Put(calDet, id1, metaData);
+   //if(!calDet) printf("No caldet\n");
+
+ }
+//___________________________________________________________________________________________________________________
+void AliTRDPreprocessorOffline::UpdateOCDBExBAlt(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
+  //
+  // Update OCDB entry
+  //
+
+  Int_t detExB = kExbAlt;
+  if(!fMethodSecond) return;
+
+  //printf("Pass\n");
+
+  AliCDBMetaData *metaData= new AliCDBMetaData();
+  metaData->SetObjectClassName("AliTRDCalDet");
+  metaData->SetResponsible("Theo Rascanu");
+  metaData->AddDateToComment();
+  metaData->SetBeamPeriod(1);
+
+  AliCDBId id1("TRD/Calib/ChamberExBAlt", startRunNumber, endRunNumber);
+  AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
+  AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detExB);
+  if(calDet) gStorage->Put(calDet, id1, metaData);
+  //if(!calDet) printf("No caldet\n");
+
+}
+ //___________________________________________________________________________________________________________________
  void AliTRDPreprocessorOffline::UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
    //
    // Update OCDB entry
@@ -777,6 +1270,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
    AliCDBMetaData *metaData= new AliCDBMetaData();
    metaData->SetObjectClassName("AliTRDCalDet");
    metaData->SetResponsible("Raphaelle Bailhache");
+   metaData->AddDateToComment();
    metaData->SetBeamPeriod(1);
 
    AliCDBId id1("TRD/Calib/ChamberVdrift", startRunNumber, endRunNumber);
@@ -791,6 +1285,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
      AliCDBMetaData *metaDataPad= new AliCDBMetaData();
      metaDataPad->SetObjectClassName("AliTRDCalPad");
      metaDataPad->SetResponsible("Raphaelle Bailhache");
+     metaDataPad->AddDateToComment();
      metaDataPad->SetBeamPeriod(1);
 
      AliCDBId id1Pad("TRD/Calib/LocalVdrift", startRunNumber, endRunNumber);
@@ -809,6 +1304,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
    AliCDBMetaData *metaData= new AliCDBMetaData();
    metaData->SetObjectClassName("AliTRDCalDet");
    metaData->SetResponsible("Raphaelle Bailhache");
+   metaData->AddDateToComment();
    metaData->SetBeamPeriod(1);
 
    AliCDBId id1("TRD/Calib/ChamberT0", startRunNumber, endRunNumber);
@@ -821,6 +1317,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
    AliCDBMetaData *metaDataPad= new AliCDBMetaData();
    metaDataPad->SetObjectClassName("AliTRDCalPad");
    metaDataPad->SetResponsible("Raphaelle Bailhache");
+   metaDataPad->AddDateToComment();
    metaDataPad->SetBeamPeriod(1);
 
    AliCDBId id1Pad("TRD/Calib/LocalT0", startRunNumber, endRunNumber);
@@ -839,8 +1336,10 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
    AliCDBMetaData *metaData= new AliCDBMetaData();
    metaData->SetObjectClassName("AliTRDCalPad");
    metaData->SetResponsible("Raphaelle Bailhache");
+   metaData->AddDateToComment();
    metaData->SetBeamPeriod(1);
 
+
    AliCDBId id1("TRD/Calib/PRFWidth", startRunNumber, endRunNumber);
    AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
    AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
@@ -848,6 +1347,27 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
 
 
  }
+//_________________________________________________________________________________________________________________
+void AliTRDPreprocessorOffline::UpdateOCDBPHQ(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath)
+{
+  //
+  // Update OCDB entry
+  //
+  AliCDBMetaData *metaData= new AliCDBMetaData();
+  metaData->SetObjectClassName("TObjArray");
+  metaData->SetResponsible("Raphaelle Bailhache and Xianguo Lu");
+  metaData->AddDateToComment();
+  metaData->SetBeamPeriod(1);
+
+  AliCDBId id1("TRD/Calib/PHQ", startRunNumber, endRunNumber);
+  AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
+  TObjArray *cobj = (TObjArray *) fCalibObjects->At(kPHQ);
+  if(cobj){
+    //cobj->Print();
+    gStorage->Put(cobj, id1, metaData);
+  }
+}
+
  //_________________________________________________________________________________________________________________
  void AliTRDPreprocessorOffline::UpdateOCDBChamberStatus(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
    //
@@ -856,7 +1376,8 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
 
    AliCDBMetaData *metaData= new AliCDBMetaData();
    metaData->SetObjectClassName("AliTRDCalChamberStatus");
-   metaData->SetResponsible("Raphaelle Bailhache");
+   metaData->SetResponsible("Raphaelle Bailhache and Julian Book");
+   metaData->AddDateToComment();
    metaData->SetBeamPeriod(1);
 
    AliCDBId id1("TRD/Calib/ChamberStatus", startRunNumber, endRunNumber);
@@ -867,7 +1388,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
 
  }
  //__________________________________________________________________________________________________________________________
- Bool_t AliTRDPreprocessorOffline::ValidateGain() const {
+ Bool_t AliTRDPreprocessorOffline::ValidateGain() {
    //
    // Validate OCDB entry
    //
@@ -878,9 +1399,13 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
      Double_t rms = calDet->GetRMSRobust();
      if((mean > 0.2) && (mean < 1.4) && (rms < 0.5)) return kTRUE;
      //if((mean > 0.2) && (mean < 1.4)) return kTRUE;
-     else return kFALSE;
+     else {
+       fStatusPos = fStatusPos | kGainErrorRange;
+       return kFALSE;
+     }
    }
    else return kFALSE;
+   
 
 
  }
@@ -900,7 +1425,10 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
      Double_t mean = calDet->GetMean();
      Double_t rms = calDet->GetRMSRobust();
      //printf("Vdrift::mean %f, rms %f\n",mean,rms);
-     if(!((mean > 1.0) && (mean < 2.0) && (rms < 0.5))) ok = kFALSE;
+     if(!((mean > 1.0) && (mean < 2.0) && (rms < 0.5))) {
+       fStatusPos = fStatusPos | kVdriftErrorRange;
+       ok = kFALSE;
+     }
    }
    else return kFALSE; 
 
@@ -910,7 +1438,10 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
        Double_t mean = calPad->GetMean();
        Double_t rms = calPad->GetRMS();
        //printf("Vdrift::meanpad %f, rmspad %f\n",mean,rms);
-       if(!((mean > 0.9) && (mean < 1.1) && (rms < 0.6))) ok = kFALSE;
+       if(!((mean > 0.9) && (mean < 1.1) && (rms < 0.6))) {
+        fStatusPos = fStatusPos | kVdriftErrorRange;
+        ok = kFALSE;
+       }
      }
      else return kFALSE;
    }
@@ -919,6 +1450,26 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
 
  }
  //__________________________________________________________________________________________________________________________
+ Bool_t AliTRDPreprocessorOffline::ValidateExB(){
+   //
+   // Update OCDB entry
+   //
+
+   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kLorentzLinear);
+   if(calDet) {
+     Double_t mean = calDet->GetMean();
+     Double_t rms = calDet->GetRMSRobust();
+     //printf("Vdrift::mean %f, rms %f\n",mean,rms);
+     if(!((mean > -1.0) && (mean < 1.0) && (rms < 0.5))) {
+       fStatusNeg = fStatusNeg | kExBErrorRange;
+       return kFALSE;
+     }
+     else return kTRUE;
+   }
+   else return kFALSE; 
+   
+ }
+ //__________________________________________________________________________________________________________________________
  Bool_t AliTRDPreprocessorOffline::ValidateT0(){
    //
    // Update OCDB entry
@@ -933,7 +1484,10 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
      //Double_t rmspad = calPad->GetRMS();
      //printf("T0::minimum %f, rmsdet %f,meanpad %f, rmspad %f\n",meandet,rmsdet,meanpad,rmspad);
      if((meandet > -1.5) && (meandet < 5.0) && (rmsdet < 4.0) && (meanpad < 5.0) && (meanpad > -0.5)) return kTRUE;
-     else return kFALSE;
+     else {
+       fStatusPos = fStatusPos | kTimeOffsetErrorRange;
+       return kFALSE;
+     }
    }
    else return kFALSE;
 
@@ -957,23 +1511,35 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
 
  }
  //__________________________________________________________________________________________________________________________
-Bool_t AliTRDPreprocessorOffline::ValidateChamberStatus() const{
+Bool_t AliTRDPreprocessorOffline::ValidateChamberStatus(){
   //
   // Update OCDB entry
   //
   
   AliTRDCalChamberStatus *calChamberStatus = (AliTRDCalChamberStatus *) fCalibObjects->At(kChamberStatus);
   if(calChamberStatus) {
-    Int_t detectormasked = 0;
-    for(Int_t det = 0; det < 540; det++) {
-      if(calChamberStatus->IsMasked(det)) detectormasked++;
+
+    Int_t detectornodata   = 0;
+    Int_t detectorbadcalib = 0;
+    
+    for(Int_t sm=0; sm < 18; sm++) {
+      //printf("%d chambers w/o data in sm %d\n",fNoData[sm],sm);
+      //printf("%d bad calibrated chambers in sm %d\n",fBadCalib[sm],sm);
+      if(fNoData[sm] != 30) detectornodata += fNoData[sm];
+      detectorbadcalib+=fBadCalib[sm];
     }
-    //printf("Number of chambers masked %d\n",detectormasked);
-    if(detectormasked > 29) return kFALSE;
-    else return kTRUE;
+    //printf("Number of chambers w/o data %d\n",detectornodata);
+    //printf("Number of chambers bad calibrated %d\n",detectorbadcalib);
+
+    if((detectornodata > fNoDataValidate) ||
+       (detectorbadcalib > fBadCalibValidate)){
+      fStatusPos = fStatusPos | kChamberStatusErrorRange;
+      return kFALSE;
+    }
+    return kTRUE;
   }
   else return kFALSE;
+  
 }
 //_____________________________________________________________________________
 Int_t AliTRDPreprocessorOffline::GetVersion(TString name) const
@@ -985,12 +1551,14 @@ Int_t AliTRDPreprocessorOffline::GetVersion(TString name) const
   // Some patterns
   const Char_t *version = "Ver";
   if(!strstr(name.Data(),version)) return -1;
-  
+  const Char_t *after = "Subver";  
+  if(!strstr(name.Data(),after)) return -1;
+
   for(Int_t ver = 0; ver < 999999999; ver++) {
 
     TString vertry(version);
     vertry += ver;
-    vertry += "Subver";
+    vertry += after;
 
     //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
 
@@ -1012,12 +1580,48 @@ Int_t AliTRDPreprocessorOffline::GetSubVersion(TString name) const
   // Some patterns
   const Char_t *subversion = "Subver";
   if(!strstr(name.Data(),subversion)) return -1;
+  const Char_t *after = "FirstRun";
+  if(!strstr(name.Data(),after)) {
+    after = "Nz";
+  }
+  if(!strstr(name.Data(),after)) return -1;
+
   
   for(Int_t ver = 0; ver < 999999999; ver++) {
     
     TString vertry(subversion);
     vertry += ver;
-    vertry += "Nz";
+    vertry += after;
+
+    //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
+
+    if(strstr(name.Data(),vertry.Data())) return ver;
+    
+  }
+  
+  return -1;
+
+}
+
+//_____________________________________________________________________________
+Int_t AliTRDPreprocessorOffline::GetFirstRun(TString name) const
+{
+  //
+  // Get first run from the title
+  //
+  
+  // Some patterns
+  const Char_t *firstrun = "FirstRun";
+  if(!strstr(name.Data(),firstrun)) return -1;
+  const Char_t *after = "Nz";  
+  if(!strstr(name.Data(),after)) return -1;
+  
+  
+  for(Int_t ver = 0; ver < 999999999; ver++) {
+
+    TString vertry(firstrun);
+    vertry += ver;
+    vertry += after;
 
     //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
 
@@ -1028,5 +1632,162 @@ Int_t AliTRDPreprocessorOffline::GetSubVersion(TString name) const
   return -1;
 
 }
+//_____________________________________________________________________________
+Bool_t AliTRDPreprocessorOffline::CheckStatus(Int_t status, Int_t bitMask) const
+{
+  //
+  // Checks the status
+  //
 
+  return (status & bitMask) ? kTRUE : kFALSE;
+  
+}
+//_____________________________________________________________________________
+Int_t AliTRDPreprocessorOffline::GetStatus() const
+{
+  //
+  // Checks the status
+  // fStatusPos: errors
+  // fStatusNeg: only info
+  //
+
+  if(fStatusPos > 0) return fStatusPos;
+  else return (-TMath::Abs(fStatusNeg));
+  
+}
+//_____________________________________________________________________________
+void AliTRDPreprocessorOffline::PrintStatus() const
+{
+  //
+  // Do Summary
+  //
+
+  AliInfo(Form("The error status is %d",fStatusPos));
+  AliInfo(Form("IsGainErrorOld? %d",(Int_t)IsGainErrorOld()));
+  AliInfo(Form("IsVdriftErrorOld? %d",(Int_t)IsVdriftErrorOld()));
+  AliInfo(Form("IsGainErrorRange? %d",(Int_t)IsGainErrorRange()));
+  AliInfo(Form("IsVdriftErrorRange? %d",(Int_t)IsVdriftErrorRange()));
+  AliInfo(Form("IsTimeOffsetErrorRange? %d",(Int_t)IsTimeOffsetErrorRange()));
+  AliInfo(Form("IsChamberStatusErrorRange? %d",(Int_t)IsChamberStatusErrorRange()));
+
+  AliInfo(Form("The info status is %d",fStatusNeg));
+  AliInfo(Form("IsGainNotEnoughStatsButFill? %d",(Int_t)IsGainNotEnoughStatsButFill()));
+  AliInfo(Form("IsVdriftNotEnoughStatsButFill? %d",(Int_t)IsVdriftNotEnoughStatsButFill()));
+  AliInfo(Form("IsGainNotEnoughStatsNotFill? %d",(Int_t)IsGainNotEnoughStatsNotFill()));
+  AliInfo(Form("IsVdriftNotEnoughStatsNotFill? %d",(Int_t)IsVdriftNotEnoughStatsNotFill()));
+  AliInfo(Form("IsTimeOffsetNotEnoughStatsNotFill? %d",(Int_t)IsTimeOffsetNotEnoughStatsNotFill()));
+
+  AliInfo(Form("IsExBErrorRange? %d",(Int_t)IsExBErrorRange()));
+  AliInfo(Form("IsExBErrorOld? %d",(Int_t)IsExBErrorOld()));
+  
+}
+//___________________________________________________________________________________
+void AliTRDPreprocessorOffline::SetCalDetVdrift(AliTRDCalDet *calDetVdriftUsed) 
+{
+
+  fCalDetVdriftUsed = calDetVdriftUsed;
+
+  fCalDetExBUsed = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
+  for(Int_t k = 0; k < 540; k++){
+    fCalDetExBUsed->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDetVdriftUsed->GetValue(k)));
+    //printf("Set the exb object for detector %d, vdrift %f and exb %f\n",k,fCalDetVdriftUsed->GetValue(k),fCalDetExBUsed->GetValue(k));
+  }
+  
+};
+//___________________________________________________________________________________
+Bool_t AliTRDPreprocessorOffline::SetCalDetGain(Int_t runNumber, Int_t version, Int_t subversion) 
+{
+  //
+  // Set the fCalDetGainUsed
+  //
+
+  if((version == 0) && (subversion == 0)) return kFALSE;
+
+  AliCDBEntry *entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberGainFactor",runNumber, version, subversion);
+  if(!entry) {
+    AliError("Found no entry\n");
+    fStatusPos = fStatusPos | kGainErrorOld;
+    return kFALSE;
+  }
+  //const AliCDBId id = entry->GetId();
+  //version = id.GetVersion();
+  //subversion = id.GetSubVersion();
+  //printf("Found version %d and subversion %d for vdrift\n",version,subversion);
+  AliTRDCalDet* calDet = (AliTRDCalDet *)entry->GetObject();
+  if(calDet) fCalDetGainUsed = calDet;
+  else {
+    fStatusPos = fStatusPos | kGainErrorOld;
+    return kFALSE;
+  }
+  
+  return kTRUE;
+
+}
+//___________________________________________________________________________________
+Bool_t AliTRDPreprocessorOffline::SetCalDetVdriftExB(Int_t runNumber, Int_t versionv, Int_t subversionv, Int_t versionexb, Int_t subversionexb) 
+{
+  //
+  // Set the fCalDetVdriftUsed and fCalDetExBUsed
+  //
+
+  if((versionv == 0) && (subversionv == 0)) return kFALSE;
+
+  AliCDBEntry *entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberVdrift",runNumber, versionv, subversionv);
+  if(!entry) {
+    AliError("Found no entry\n");
+    fStatusPos = fStatusPos | kVdriftErrorOld;
+    return kFALSE;
+  }
+  AliTRDCalDet* calDet = (AliTRDCalDet *)entry->GetObject();
+  if(calDet) fCalDetVdriftUsed = calDet;
+  else {
+    fStatusPos = fStatusPos | kVdriftErrorOld;
+    return kFALSE;
+  }
+
+  // ExB object
+
+  if((versionexb == 0) && (subversionexb == 0)) {
+    
+    fCalDetExBUsed = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
+    for(Int_t k = 0; k < 540; k++){
+      fCalDetExBUsed->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDetVdriftUsed->GetValue(k)));
+      //printf("Nothing found: set the exb object for detector %d, vdrift %f and exb %f\n",k,fCalDetVdriftUsed->GetValue(k),fCalDetExBUsed->GetValue(k));
+    }
+  }
+  else {
+
+    entry = 0x0;
+    entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberExB",runNumber, versionexb, subversionexb);
+    if(!entry) {
+      //printf("Found no entry\n");
+      fStatusPos = fStatusPos | kExBErrorOld;   
+      return kFALSE;
+    }
+    AliTRDCalDet* calDetexb = (AliTRDCalDet *)entry->GetObject();
+    if(!calDetexb) {
+      fStatusPos = fStatusPos | kExBErrorOld;   
+      return kFALSE;
+    }
+    
+    Double_t meanexb = calDetexb->GetMean();
+    //printf("Mean value %f\n",meanexb);
+    if((meanexb > 70) || (fNoExBUsedInReco)) {
+      fCalDetExBUsed = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
+      for(Int_t k = 0; k < 540; k++){
+       fCalDetExBUsed->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDetVdriftUsed->GetValue(k)));
+       //printf("Found but: set the exb object for detector %d, vdrift %f and exb %f\n",k,fCalDetVdriftUsed->GetValue(k),fCalDetExBUsed->GetValue(k));
+      }
+    }
+    else {
+      fCalDetExBUsed = calDetexb;
+    }
+    
+  }
+
+  
+  return kTRUE;
+
+}