Commented unnecessary include AliLog
[u/mrichter/AliRoot.git] / TRD / AliTRDPreprocessorOffline.cxx
index 4e47b38..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)
 
@@ -68,35 +77,66 @@ ClassImp(AliTRDPreprocessorOffline)
   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(9)),
-  fCalibObjects(new TObjArray(9)),
+  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),
+  fMinStatsChamberStatus(20),
+  fMinSingleStatsChamberStatus(0.05),
   fBackCorrectGain(kFALSE),  
   fBackCorrectVdrift(kTRUE),
   fNotEnoughStatisticsForTheGain(kFALSE),
   fNotEnoughStatisticsForTheVdriftLinear(kFALSE),
-  fStatus(0)
+  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() {
@@ -106,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){
@@ -132,11 +209,12 @@ 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)) AnalyzeVdriftLinearFit();
+  if(ReadVdriftLinearFitGlobal(file) && fCalDetVdriftUsed && fCalDetExBUsed) AnalyzeVdriftLinearFit();
   if(ReadVdriftT0Global(file)) AnalyzeVdriftT0();
   //
   // 3. Append QA plots
@@ -147,22 +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);
-  UpdateOCDBExB(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){
@@ -185,7 +302,7 @@ void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumb
   //
   AnalyzeGain();
   if(fBackCorrectGain) CorrectFromDetGainUsed();
-  if(fBackCorrectVdrift) CorrectFromDetVdriftUsed();
+  //if(fBackCorrectVdrift) CorrectFromDetVdriftUsed();
   //
   // 3. Append QA plots
   //
@@ -195,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;
   }
   //
@@ -235,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;
   }
   //
@@ -246,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;
+
+  UpdateOCDBPHQ(startRunNumber,endRunNumber,ocdbStorage);
+}
+
+//________________________________________________________________________________________________________________
 
-void AliTRDPreprocessorOffline::CalibChamberStatus(Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
+void AliTRDPreprocessorOffline::CalibChamberStatus(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
   //
   // make calibration of the chamber status
   // Input parameters:
@@ -257,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;
@@ -270,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
   //
   //
-  if((!fNotEnoughStatisticsForTheGain) && (!fNotEnoughStatisticsForTheGain)) UpdateOCDBChamberStatus(startRunNumber,endRunNumber,ocdbStorage);
+  if((!fNotEnoughStatisticsForTheVdriftLinear) && (!fNotEnoughStatisticsForTheGain)) UpdateOCDBChamberStatus(startRunNumber,endRunNumber,ocdbStorage);
+  //UpdateOCDBChamberStatus(startRunNumber,endRunNumber,ocdbStorage);
   
 }
 //______________________________________________________________________________________________________
@@ -300,20 +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) && (fVersionGainUsed == 0)) fStatus = -1;
+  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
@@ -390,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){
   //
@@ -423,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);
 
@@ -453,6 +666,8 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){
   }
   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);
@@ -468,14 +683,15 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){
        fPlots->AddAt(coefGain,kGain);
        // 
        ok = kTRUE;
-       fStatus += 1000000;
+       fStatusNeg = fStatusNeg | kGainNotEnoughStatsButFill;
       }
       else {
-       fStatus += 1000;
+       fStatusPos = fStatusPos | kGainErrorOld;
       }      
     }
     else {
-      fStatus += 1000;
+      if(gainoverallnotnormalized <= 0.0) fStatusNeg = fStatusNeg | kGainNotEnoughStatsNotFill;
+      if(!fCalDetGainUsed) fStatusPos = fStatusPos | kGainErrorOld;
     }
   }
   
@@ -535,7 +751,8 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftT0(){
     ok = kTRUE;
   }
   else {
-    fStatus += 100;
+    //printf("Not enough stats timeoffset\n");
+    fStatusNeg = fStatusNeg | kTimeOffsetNotEnoughStatsNotFill;
   }
   calibra->ResetVectorFit();
  
@@ -552,9 +769,16 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){
 
   
   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");
@@ -590,26 +814,94 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){
   }
   else {
     fNotEnoughStatisticsForTheVdriftLinear = kTRUE;
-    Double_t vdriftoverall =  calibra->AnalyseLinearFittersAllTogether(fAliTRDCalibraVdriftLinearFit);
-    if(fCalDetVdriftUsed && (vdriftoverall > 0.0)) {
+    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);
-      Double_t oldmean = fCalDetVdriftUsed->CalcMean(kFALSE);
+      AliTRDCalDet *calDetLorentz = new AliTRDCalDet(*fCalDetExBUsed);
+      Double_t oldmeanvdrift = fCalDetVdriftUsed->CalcMean(kFALSE);
+      Double_t oldmeanexb = fCalDetExBUsed->CalcMean(kFALSE);
       //printf("oldmean %f\n",oldmean);
-      if(oldmean > 0.0)  {
+      if((oldmeanvdrift > 0.0) && (oldmeanexb < 70.0))  {
        //printf("Correction factor %f\n",vdriftoverall);
-       calDetVdrift->Multiply(vdriftoverall/oldmean);
+       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;
-       fStatus += 10000;
+       fStatusNeg = fStatusNeg | kVdriftNotEnoughStatsButFill;
       }
-      else fStatus += 1;      
+      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;
     }
-    else fStatus += 1;
+  }
+  
+  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();
@@ -656,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) || (!fCH2d)) 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;
@@ -693,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);
@@ -700,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;
-     }
-     */
-
     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);
-       }
-     }
-   }
-
-   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;
 
  }
@@ -809,7 +1160,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
    if(!calDetVdrift) return;
 
    // Calculate mean
-   if(!fNotEnoughStatisticsForTheGain) {
+   if(!fNotEnoughStatisticsForTheVdriftLinear) {
      for(Int_t det = 0; det < 540; det++) {
        
        Float_t vdriftinit = fCalDetVdriftUsed->GetValue(det);
@@ -848,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);
@@ -871,6 +1223,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/ChamberExB", startRunNumber, endRunNumber);
@@ -880,6 +1233,30 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
    //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){
    //
@@ -893,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);
@@ -907,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);
@@ -925,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);
@@ -937,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);
@@ -955,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);
@@ -964,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){
    //
@@ -972,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);
@@ -995,7 +1400,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
      if((mean > 0.2) && (mean < 1.4) && (rms < 0.5)) return kTRUE;
      //if((mean > 0.2) && (mean < 1.4)) return kTRUE;
      else {
-       fStatus += 1000000000;
+       fStatusPos = fStatusPos | kGainErrorRange;
        return kFALSE;
      }
    }
@@ -1021,7 +1426,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
      Double_t rms = calDet->GetRMSRobust();
      //printf("Vdrift::mean %f, rms %f\n",mean,rms);
      if(!((mean > 1.0) && (mean < 2.0) && (rms < 0.5))) {
-       fStatus += 10000000;
+       fStatusPos = fStatusPos | kVdriftErrorRange;
        ok = kFALSE;
      }
    }
@@ -1034,7 +1439,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
        Double_t rms = calPad->GetRMS();
        //printf("Vdrift::meanpad %f, rmspad %f\n",mean,rms);
        if(!((mean > 0.9) && (mean < 1.1) && (rms < 0.6))) {
-        fStatus += 10000000;
+        fStatusPos = fStatusPos | kVdriftErrorRange;
         ok = kFALSE;
        }
      }
@@ -1045,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
@@ -1060,7 +1485,7 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
      //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 {
-       fStatus += 100000000;
+       fStatusPos = fStatusPos | kTimeOffsetErrorRange;
        return kFALSE;
      }
    }
@@ -1086,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 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;
     }
-    //printf("Number of chambers masked %d\n",detectormasked);
-    if(detectormasked > 40) return kFALSE;
-    else return kTRUE;
+    return kTRUE;
   }
   else return kFALSE;
+  
 }
 //_____________________________________________________________________________
 Int_t AliTRDPreprocessorOffline::GetVersion(TString name) const
@@ -1195,4 +1632,162 @@ Int_t AliTRDPreprocessorOffline::GetFirstRun(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;
+
+}