gcc 4.3 warnings fixed
[u/mrichter/AliRoot.git] / TRD / AliTRDCalibraFillHisto.cxx
index c6974b0..8c52989 100644 (file)
 /* $Id$ */
 
 /////////////////////////////////////////////////////////////////////////////////
-// 
+//                                                                             
 // AliTRDCalibraFillHisto                                                               
 //                                                                             
 // This class is for the TRD calibration of the relative gain factor, the drift velocity,
 // the time 0 and the pad response function. It fills histos or vectors.        
 // It can be used for the calibration per chamber but also per group of pads and eventually per pad.
-// The user has to choose with the functions SetNz and SetNrphi the precision of the
-// calibration (see AliTRDCalibraMode). 
+// The user has to choose with the functions SetNz and SetNrphi the precision of the calibration (see AliTRDCalibraMode). 
 // 2D Histograms (Histo2d) or vectors (Vector2d), then converted in Trees, will be filled
 // from RAW DATA in a run or from reconstructed TRD tracks during the offline tracking 
 // in the function "FollowBackProlongation" (AliTRDtracker)
 //                            
 //////////////////////////////////////////////////////////////////////////////////////
 
-#include <TTree.h>
 #include <TProfile2D.h>
 #include <TProfile.h>
 #include <TFile.h>
-#include <TChain.h>
 #include <TStyle.h>
 #include <TCanvas.h>
-#include <TGraphErrors.h>
 #include <TObjArray.h>
+#include <TObject.h>
 #include <TH1F.h>
 #include <TH2I.h>
 #include <TH2.h>
 #include <TStopwatch.h>
 #include <TMath.h>
 #include <TDirectory.h>
-#include <TROOT.h>
+#include <TTreeStream.h>
+#include <TVectorD.h>
 
 #include "AliLog.h"
-#include "AliCDBManager.h"
 
 #include "AliTRDCalibraFillHisto.h"
 #include "AliTRDCalibraMode.h"
 #include "AliTRDCalibraVector.h"
+#include "AliTRDCalibraVdriftLinearFit.h"
 #include "AliTRDcalibDB.h"
 #include "AliTRDCommonParam.h"
 #include "AliTRDmcmTracklet.h"
+#include "AliTRDmcm.h"
+#include "AliTRDtrigParam.h"
 #include "AliTRDpadPlane.h"
 #include "AliTRDcluster.h"
 #include "AliTRDtrack.h"
+#include "AliTRDtrackV1.h"
+#include "AliTRDrawStreamBase.h"
+#include "AliRawReader.h"
+#include "AliRawReaderDate.h"
+#include "AliTRDgeometry.h"
+#include "./Cal/AliTRDCalROC.h"
+#include "./Cal/AliTRDCalDet.h"
+
+#ifdef ALI_DATE
+#include "event.h"
+#endif
 
 
 ClassImp(AliTRDCalibraFillHisto)
@@ -109,101 +120,144 @@ void AliTRDCalibraFillHisto::Terminate()
 //______________________________________________________________________________________
 AliTRDCalibraFillHisto::AliTRDCalibraFillHisto()
   :TObject()
-  ,fMITracking(kFALSE)
-  ,fMcmTracking(kFALSE)
+  ,fGeo(0)
   ,fMcmCorrectAngle(kFALSE)
   ,fCH2dOn(kFALSE)
   ,fPH2dOn(kFALSE)
   ,fPRF2dOn(kFALSE)
   ,fHisto2d(kFALSE)
   ,fVector2d(kFALSE)
+  ,fLinearFitterOn(kFALSE)
+  ,fLinearFitterDebugOn(kFALSE)
   ,fRelativeScale(0)
-  ,fCountRelativeScale(0)
-  ,fRelativeScaleAuto(kFALSE)
-  ,fThresholdClusterPRF1(0.0)
-  ,fThresholdClusterPRF2(0.0)
-  ,fCenterOfflineCluster(kFALSE)
-  ,fWriteName(0)
-  ,fCalibraMode(0)
-  ,fDetectorAliTRDtrack(kFALSE)
-  ,fChamberAliTRDtrack(-1)
+  ,fThresholdClusterPRF2(15.0)
+  ,fLimitChargeIntegration(kFALSE)
+  ,fFillWithZero(kFALSE)
+  ,fCalibraMode(new AliTRDCalibraMode())
+  ,fDebugStreamer(0)
+  ,fDebugLevel(0)
   ,fDetectorPreviousTrack(-1)
-  ,fGoodTrack(kTRUE)
-  ,fAmpTotal(0x0)
-  ,fPHPlace(0x0)
-  ,fPHValue(0x0)
+  ,fMCMPrevious(-1)
+  ,fROBPrevious(-1)
   ,fNumberClusters(0)
-  ,fProcent(0.0)
-  ,fDifference(0)
+  ,fNumberClustersf(30)
+  ,fProcent(6.0)
+  ,fDifference(17)
   ,fNumberTrack(0)
   ,fTimeMax(0)
-  ,fSf(0.0)
-  ,fNumberBinCharge(0)
-  ,fNumberBinPRF(0)
-  ,fCalibraVector(0)
+  ,fSf(10.0)
+  ,fNumberBinCharge(100)
+  ,fNumberBinPRF(40)
+  ,fNgroupprf(0)
+  ,fAmpTotal(0x0)
+  ,fPHPlace(0x0)
+  ,fPHValue(0x0)
+  ,fGoodTracklet(kTRUE)
+  ,fLinearFitterTracklet(0x0)
+  ,fEntriesCH(0x0)
+  ,fEntriesLinearFitter(0x0)
+  ,fCalibraVector(0x0)
   ,fPH2d(0x0)
   ,fPRF2d(0x0)
   ,fCH2d(0x0)
+  ,fLinearFitterArray(540)
+  ,fLinearVdriftFit(0x0)
+  ,fCalDetGain(0x0)
+  ,fCalROCGain(0x0)
 {
   //
   // Default constructor
   //
 
-  fCalibraMode = new AliTRDCalibraMode();
-
-  // Write
-  for (Int_t i = 0; i < 3; i++) {
-    fWrite[i]     = kFALSE;
-  }
+  //
+  // Init some default values
+  //
 
-  // Init
-  Init();
+  fNumberUsedCh[0]       = 0;
+  fNumberUsedCh[1]       = 0;
+  fNumberUsedPh[0]       = 0;
+  fNumberUsedPh[1]       = 0;
   
+  fGeo = new AliTRDgeometry();
+
 }
 
 //______________________________________________________________________________________
 AliTRDCalibraFillHisto::AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c)
   :TObject(c)
-  ,fMITracking(kFALSE)
-  ,fMcmTracking(kFALSE)
-  ,fMcmCorrectAngle(kFALSE)
-  ,fCH2dOn(kFALSE)
-  ,fPH2dOn(kFALSE)
-  ,fPRF2dOn(kFALSE)
-  ,fHisto2d(kFALSE)
-  ,fVector2d(kFALSE)
-  ,fRelativeScale(0)
-  ,fCountRelativeScale(0)
-  ,fRelativeScaleAuto(kFALSE)
-  ,fThresholdClusterPRF1(0.0)
-  ,fThresholdClusterPRF2(0.0)
-  ,fCenterOfflineCluster(kFALSE)
-  ,fWriteName(0)
-  ,fCalibraMode(0)
-  ,fDetectorAliTRDtrack(kFALSE)
-  ,fChamberAliTRDtrack(-1)
-  ,fDetectorPreviousTrack(-1)
-  ,fGoodTrack(kTRUE)
+  ,fGeo(0)
+  ,fMcmCorrectAngle(c.fMcmCorrectAngle)
+  ,fCH2dOn(c.fCH2dOn)
+  ,fPH2dOn(c.fPH2dOn)
+  ,fPRF2dOn(c.fPRF2dOn)
+  ,fHisto2d(c.fHisto2d)
+  ,fVector2d(c.fVector2d)
+  ,fLinearFitterOn(c.fLinearFitterOn)
+  ,fLinearFitterDebugOn(c.fLinearFitterDebugOn)
+  ,fRelativeScale(c.fRelativeScale)
+  ,fThresholdClusterPRF2(c.fThresholdClusterPRF2)
+  ,fLimitChargeIntegration(c.fLimitChargeIntegration)
+  ,fFillWithZero(c.fFillWithZero)
+  ,fCalibraMode(0x0)
+  ,fDebugStreamer(0)
+  ,fDebugLevel(c.fDebugLevel)
+  ,fDetectorPreviousTrack(c.fDetectorPreviousTrack)
+  ,fMCMPrevious(c.fMCMPrevious)
+  ,fROBPrevious(c.fROBPrevious)
+  ,fNumberClusters(c.fNumberClusters)
+  ,fNumberClustersf(c.fNumberClustersf)
+  ,fProcent(c.fProcent)
+  ,fDifference(c.fDifference)
+  ,fNumberTrack(c.fNumberTrack)
+  ,fTimeMax(c.fTimeMax)
+  ,fSf(c.fSf)
+  ,fNumberBinCharge(c.fNumberBinCharge)
+  ,fNumberBinPRF(c.fNumberBinPRF)
+  ,fNgroupprf(c.fNgroupprf)
   ,fAmpTotal(0x0)
   ,fPHPlace(0x0)
   ,fPHValue(0x0)
-  ,fNumberClusters(0)
-  ,fProcent(0.0)
-  ,fDifference(0)
-  ,fNumberTrack(0)
-  ,fTimeMax(0)
-  ,fSf(0.0)
-  ,fNumberBinCharge(0)
-  ,fNumberBinPRF(0)
-  ,fCalibraVector(0)
+  ,fGoodTracklet(c.fGoodTracklet)
+  ,fLinearFitterTracklet(0x0)
+  ,fEntriesCH(0x0)
+  ,fEntriesLinearFitter(0x0)
+  ,fCalibraVector(0x0)
   ,fPH2d(0x0)
   ,fPRF2d(0x0)
-  ,fCH2d(0x0) 
+  ,fCH2d(0x0)
+  ,fLinearFitterArray(540)
+  ,fLinearVdriftFit(0x0)
+  ,fCalDetGain(0x0)
+  ,fCalROCGain(0x0)
 {
   //
   // Copy constructor
   //
+  if(c.fCalibraMode)   fCalibraMode = new AliTRDCalibraMode(*c.fCalibraMode);
+  if(c.fCalibraVector) fCalibraVector = new AliTRDCalibraVector(*c.fCalibraVector);
+  if(c.fPH2d) {
+    fPH2d = new TProfile2D(*c.fPH2d);
+    fPH2d->SetDirectory(0);
+  }
+  if(c.fPRF2d) {
+    fPRF2d = new TProfile2D(*c.fPRF2d);
+    fPRF2d->SetDirectory(0);
+  }
+  if(c.fCH2d) {
+    fCH2d = new TH2I(*c.fCH2d);
+    fCH2d->SetDirectory(0);
+  }
+  if(c.fLinearVdriftFit){
+    fLinearVdriftFit = new AliTRDCalibraVdriftLinearFit(*c.fLinearVdriftFit);
+  }
 
+  if(c.fCalDetGain)  fCalDetGain   = new AliTRDCalDet(*c.fCalDetGain);
+  if(c.fCalROCGain)  fCalROCGain   = new AliTRDCalROC(*c.fCalROCGain);
+
+  if (fGeo) {
+    delete fGeo;
+  }
+  fGeo = new AliTRDgeometry();
 }
 
 //____________________________________________________________________________________
@@ -214,9 +268,28 @@ AliTRDCalibraFillHisto::~AliTRDCalibraFillHisto()
   //
 
   ClearHistos();
+  if ( fDebugStreamer ) delete fDebugStreamer;
+
+  if ( fCalDetGain )  delete fCalDetGain;
+  if ( fCalROCGain )  delete fCalROCGain;
+
+  if( fLinearFitterTracklet ) { delete fLinearFitterTracklet; }
+  
+  delete [] fPHPlace;
+  delete [] fPHValue;
+  delete [] fEntriesCH;
+  delete [] fEntriesLinearFitter;
+  delete [] fAmpTotal;
+  
+  for(Int_t idet=0; idet<AliTRDgeometry::kNdet; idet++){ 
+    TLinearFitter *f = (TLinearFitter*)fLinearFitterArray.At(idet);
+    if(f) { delete f;}
+  }
+  if (fGeo) {
+    delete fGeo;
+  }
   
 }
-
 //_____________________________________________________________________________
 void AliTRDCalibraFillHisto::Destroy() 
 {
@@ -228,9 +301,17 @@ void AliTRDCalibraFillHisto::Destroy()
     delete fgInstance;
     fgInstance = 0x0;
   }
-
 }
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::DestroyDebugStreamer() 
+{
+  //
+  // Delete DebugStreamer
+  //
 
+  if ( fDebugStreamer ) delete fDebugStreamer;
+}
 //_____________________________________________________________________________
 void AliTRDCalibraFillHisto::ClearHistos() 
 {
@@ -250,52 +331,16 @@ void AliTRDCalibraFillHisto::ClearHistos()
     delete fPRF2d;
     fPRF2d = 0x0;
   }
-
-}
-
-//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::Init() 
-{
-  //
-  // Init some default values
-  //
-
-  // How to fill the 2D
-  fThresholdClusterPRF1 = 2.0;
-  fThresholdClusterPRF2 = 15.0;
-  
-  // Store the Info
-  fNumberBinCharge      = 100;
-  fNumberBinPRF         = 40;
-  
-  // Write
-  fWriteName            = "TRD.calibration.root";
   
-  // Internal variables
-  
-  // Fill the 2D histos in the offline tracking
-  fDetectorPreviousTrack = -1;
-  fChamberAliTRDtrack    = -1;
-  fGoodTrack             = kTRUE;
-
-  fProcent               = 6.0;
-  fDifference            = 17;
-  fNumberClusters        = 18;
-  fNumberTrack           = 0;
-  fNumberUsedCh[0]       = 0;
-  fNumberUsedCh[1]       = 0;
-  fNumberUsedPh[0]       = 0;
-  fNumberUsedPh[1]       = 0;
 }
-
+//////////////////////////////////////////////////////////////////////////////////
+// calibration with AliTRDtrackV1: Init, Update 
+//////////////////////////////////////////////////////////////////////////////////
 //____________Functions for initialising the AliTRDCalibraFillHisto in the code_________
 Bool_t AliTRDCalibraFillHisto::Init2Dhistos()
 {
   //
-  // For the offline tracking
-  // This function will be called in the function AliReconstruction::Run() 
-  // Init the calibration mode (Nz, Nrphi), the 2D histograms if fHisto2d = kTRUE, 
+  // Init the histograms and stuff to be filled 
   //
 
   // DB Setting
@@ -312,21 +357,65 @@ Bool_t AliTRDCalibraFillHisto::Init2Dhistos()
   }
 
   // Some parameters
-  fTimeMax = cal->GetNumberOfTimeBins();
-  fSf      = parCom->GetSamplingFrequency();
-  if (fRelativeScaleAuto) {
-    fRelativeScale = 0;
-  }
-  else {
-    fRelativeScale = 20;
+  fTimeMax            = cal->GetNumberOfTimeBins();
+  fSf                 = parCom->GetSamplingFrequency();
+  fRelativeScale      = 20;
+  fNumberClustersf    = fTimeMax;
+  fNumberClusters     = (Int_t)(0.5*fTimeMax);
+  // Init linear fitter
+  if(!fLinearFitterTracklet) {
+    fLinearFitterTracklet = new TLinearFitter(2,"pol1");
+    fLinearFitterTracklet->StoreData(kFALSE);
   }
 
-  //If vector method On initialised all the stuff
-  if(fVector2d){
+  //calib object from database used for reconstruction
+  if( fCalDetGain ){ 
+    fCalDetGain->~AliTRDCalDet();
+    new(fCalDetGain) AliTRDCalDet(*(cal->GetGainFactorDet()));
+  }else fCalDetGain = new AliTRDCalDet(*(cal->GetGainFactorDet()));
+  
+  // Calcul Xbins Chambd0, Chamb2
+  Int_t ntotal0 = CalculateTotalNumberOfBins(0);
+  Int_t ntotal1 = CalculateTotalNumberOfBins(1);
+  Int_t ntotal2 = CalculateTotalNumberOfBins(2);
+
+  // If vector method On initialised all the stuff
+  if(fVector2d){   
     fCalibraVector = new AliTRDCalibraVector();
+    fCalibraVector->SetNumberBinCharge(fNumberBinCharge);
+    fCalibraVector->SetTimeMax(fTimeMax);
+    if(fNgroupprf != 0) {
+      fCalibraVector->SetNumberBinPRF(2*fNgroupprf*fNumberBinPRF);
+      fCalibraVector->SetPRFRange((Float_t)(3.0*fNgroupprf));
+    }
+    else {
+      fCalibraVector->SetNumberBinPRF(fNumberBinPRF);
+      fCalibraVector->SetPRFRange(1.5);
+    }
+    for(Int_t k = 0; k < 3; k++){
+      fCalibraVector->SetDetCha0(k,fCalibraMode->GetDetChamb0(k));
+      fCalibraVector->SetDetCha2(k,fCalibraMode->GetDetChamb2(k));
+    }
+    TString namech("Nz");
+    namech += fCalibraMode->GetNz(0);
+    namech += "Nrphi";
+    namech += fCalibraMode->GetNrphi(0);
+    fCalibraVector->SetNameCH((const char* ) namech);
+    TString nameph("Nz");
+    nameph += fCalibraMode->GetNz(1);
+    nameph += "Nrphi";
+    nameph += fCalibraMode->GetNrphi(1);
+    fCalibraVector->SetNamePH((const char* ) nameph);
+    TString nameprf("Nz");
+    nameprf += fCalibraMode->GetNz(2);
+    nameprf += "Nrphi";
+    nameprf += fCalibraMode->GetNrphi(2);
+    nameprf += "Ngp";
+    nameprf += fNgroupprf;
+    fCalibraVector->SetNamePRF((const char* ) nameprf);
   }
-
-
   // Create the 2D histos corresponding to the pad groupCalibration mode
   if (fCH2dOn) {
 
@@ -334,60 +423,32 @@ Bool_t AliTRDCalibraFillHisto::Init2Dhistos()
                 ,fCalibraMode->GetNz(0)
                 ,fCalibraMode->GetNrphi(0)));
     
-    // Calcul the number of Xbins
-    Int_t Ntotal0 = 0;
-    fCalibraMode->ModePadCalibration(2,0);
-    fCalibraMode->ModePadFragmentation(0,2,0,0);
-    fCalibraMode->SetDetChamb2(0);
-    Ntotal0 += 6 * 18 * fCalibraMode->GetDetChamb2(0);
-    fCalibraMode->ModePadCalibration(0,0);
-    fCalibraMode->ModePadFragmentation(0,0,0,0);
-    fCalibraMode->SetDetChamb0(0);
-    Ntotal0 += 6 * 4 * 18 * fCalibraMode->GetDetChamb0(0);
-    AliInfo(Form("Total number of Xbins: %d",Ntotal0));
-
     // Create the 2D histo
     if (fHisto2d) {
-      CreateCH2d(Ntotal0);
-    }
-    if (fVector2d) {
-      fCalibraVector->SetNumberBinCharge(fNumberBinCharge);
+      CreateCH2d(ntotal0);
     }
-
     // Variable
     fAmpTotal = new Float_t[TMath::Max(fCalibraMode->GetDetChamb2(0),fCalibraMode->GetDetChamb0(0))];
     for (Int_t k = 0; k < TMath::Max(fCalibraMode->GetDetChamb2(0),fCalibraMode->GetDetChamb0(0)); k++) {
       fAmpTotal[k] = 0.0;
     } 
-
+    //Statistics
+    fEntriesCH = new Int_t[ntotal0];
+    for(Int_t k = 0; k < ntotal0; k++){
+      fEntriesCH[k] = 0;
+    }
+    
   }
-
   if (fPH2dOn) {
 
     AliInfo(Form("The pad calibration mode for the drift velocity calibration: Nz %d, and Nrphi %d"
                 ,fCalibraMode->GetNz(1)
                 ,fCalibraMode->GetNrphi(1)));
     
-    // Calcul the number of Xbins
-    Int_t Ntotal1 = 0;
-    fCalibraMode->ModePadCalibration(2,1);
-    fCalibraMode->ModePadFragmentation(0,2,0,1);
-    fCalibraMode->SetDetChamb2(1);
-    Ntotal1 += 6 * 18 * fCalibraMode->GetDetChamb2(1);
-    fCalibraMode->ModePadCalibration(0,1);
-    fCalibraMode->ModePadFragmentation(0,0,0,1);
-    fCalibraMode->SetDetChamb0(1);
-    Ntotal1 += 6 * 4 * 18 * fCalibraMode->GetDetChamb0(1);
-    AliInfo(Form("Total number of Xbins: %d",Ntotal1));
-
     // Create the 2D histo
     if (fHisto2d) {
-      CreatePH2d(Ntotal1);
-    }
-    if (fVector2d) {
-      fCalibraVector->SetTimeMax(fTimeMax);
+      CreatePH2d(ntotal1);
     }
-   
     // Variable
     fPHPlace = new Short_t[fTimeMax];
     for (Int_t k = 0; k < fTimeMax; k++) {
@@ -397,7 +458,15 @@ Bool_t AliTRDCalibraFillHisto::Init2Dhistos()
     for (Int_t k = 0; k < fTimeMax; k++) {
       fPHValue[k] = 0.0;
     }
-
+  }
+  if (fLinearFitterOn) {
+    //fLinearFitterArray.Expand(540);
+    fLinearFitterArray.SetName("ArrayLinearFitters");
+    fEntriesLinearFitter = new Int_t[540];
+    for(Int_t k = 0; k < 540; k++){
+      fEntriesLinearFitter[k] = 0;
+    }
+    fLinearVdriftFit = new AliTRDCalibraVdriftLinearFit();
   }
 
   if (fPRF2dOn) {
@@ -405,585 +474,2595 @@ Bool_t AliTRDCalibraFillHisto::Init2Dhistos()
     AliInfo(Form("The pad calibration mode for the PRF calibration: Nz %d, and Nrphi %d"
                 ,fCalibraMode->GetNz(2)
                 ,fCalibraMode->GetNrphi(2)));
-    
-    // Calcul the number of Xbins
-    Int_t Ntotal2 = 0;
-    fCalibraMode->ModePadCalibration(2,2);
-    fCalibraMode->ModePadFragmentation(0,2,0,2);
-    fCalibraMode->SetDetChamb2(2);
-    Ntotal2 += 6 * 18 * fCalibraMode->GetDetChamb2(2);
-    fCalibraMode->ModePadCalibration(0,2);
-    fCalibraMode->ModePadFragmentation(0,0,0,2);
-    fCalibraMode->SetDetChamb0(2);
-    Ntotal2 += 6 * 4 * 18 * fCalibraMode->GetDetChamb0(2);
-    AliInfo(Form("Total number of Xbins: %d",Ntotal2));
-
     // Create the 2D histo
     if (fHisto2d) {
-      CreatePRF2d(Ntotal2);
-    }
-    if (fVector2d) {
-      fCalibraVector->SetNumberBinPRF(fNumberBinPRF);
+      CreatePRF2d(ntotal2);
     }
-  
   }
 
   return kTRUE;
 
 }
-
-//____________Functions for filling the histos in the code_____________________
-
-//____________Offine tracking in the AliTRDtracker_____________________________
-Bool_t AliTRDCalibraFillHisto::ResetTrack()
+//____________Offline tracking in the AliTRDtracker____________________________
+Bool_t AliTRDCalibraFillHisto::UpdateHistograms(AliTRDtrack *t)
 {
   //
-  // For the offline tracking
-  // This function will be called in the function
-  // AliTRDtracker::FollowBackPropagation() at the beginning 
-  // Reset the parameter to know we have a new TRD track
+  // Use AliTRDtrack for the calibration
   //
+
   
-  fDetectorAliTRDtrack = kFALSE;
-  return kTRUE;
+  AliTRDcluster *cl = 0x0;       // pointeur to cluster
+  Int_t index0 = 0;              // index of the first cluster in the current chamber
+  Int_t index1 = 0;              // index of the current cluster in the current chamber
+
+  //////////////////////////////  
+  // loop over the clusters
+  ///////////////////////////////
+  while((cl = t->GetCluster(index1))){
+
+    /////////////////////////////////////////////////////////////////////////
+    // Fill the infos for the previous clusters if not the same detector
+    ////////////////////////////////////////////////////////////////////////
+    Int_t detector = cl->GetDetector();
+    if ((detector != fDetectorPreviousTrack) && 
+       (index0 != index1)) {
+      
+      fNumberTrack++;   
+         
+      //If the same track, then look if the previous detector is in
+      //the same plane, if yes: not a good track
+      if ((GetLayer(detector) == GetLayer(fDetectorPreviousTrack))) {
+       return kFALSE;
+      }
+      
+      // Fill only if the track doesn't touch a masked pad or doesn't
+      if (fGoodTracklet) {
+       
+       // drift velocity unables to cut bad tracklets 
+       Bool_t  pass = FindP1TrackPHtracklet(t,index0,index1);
+       
+       // Gain calibration
+       if (fCH2dOn) {
+         FillTheInfoOfTheTrackCH(index1-index0);
+       }
+       
+       // PH calibration
+       if (fPH2dOn) {
+         FillTheInfoOfTheTrackPH();    
+       }
+       
+       if(pass && fPRF2dOn) HandlePRFtracklet(t,index0,index1);
+       
+       
+      } // if a good tracklet
+      // reset stuff     
+      ResetfVariablestracklet();
+      index0 = index1;
+   
+    } // Fill at the end the charge
 
-}
 
+    /////////////////////////////////////////////////////////////
+    // Localise and take the calib gain object for the detector
+    ////////////////////////////////////////////////////////////
+    if (detector != fDetectorPreviousTrack) {
+      
+      //Localise the detector
+      LocalisationDetectorXbins(detector);
+      
+      // Get cal
+      AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
+      if (!cal) {
+       AliInfo("Could not get calibDB");
+       return kFALSE;
+      }
+      
+      // Get calib objects
+      if( fCalROCGain ){ 
+        fCalROCGain->~AliTRDCalROC();
+        new(fCalROCGain) AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+      }else fCalROCGain = new AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+      
+    }
+    
+    // Reset the detectbjobsor
+    fDetectorPreviousTrack = detector;
+
+    ///////////////////////////////////////
+    // Store the info of the cluster
+    ///////////////////////////////////////
+    Int_t row = cl->GetPadRow();
+    Int_t col = cl->GetPadCol();
+    CheckGoodTrackletV1(cl);
+    Int_t     group[2] = {0,0};
+    if(fCH2dOn)  group[0]  = CalculateCalibrationGroup(0,row,col);
+    if(fPH2dOn)  group[1]  = CalculateCalibrationGroup(1,row,col);
+    StoreInfoCHPHtrack(cl,t->GetClusterdQdl(index1),group,row,col);
+         
+    index1++;
+
+  } // while on clusters
+
+  ///////////////////////////
+  // Fill the last plane
+  //////////////////////////
+  if( index0 != index1 ){
+    
+    fNumberTrack++; 
+    
+    if (fGoodTracklet) {
+      
+      // drift velocity unables to cut bad tracklets 
+      Bool_t  pass = FindP1TrackPHtracklet(t,index0,index1);
+      
+      // Gain calibration
+      if (fCH2dOn) {
+       FillTheInfoOfTheTrackCH(index1-index0);
+      }
+      
+      // PH calibration
+      if (fPH2dOn) {
+       FillTheInfoOfTheTrackPH();    
+      }
+      
+      if(pass && fPRF2dOn) HandlePRFtracklet(t,index0,index1);
+          
+    } // if a good tracklet
+    
+  }
+
+  // reset stuff     
+  ResetfVariablestracklet();
+   
+  return kTRUE;
+  
+}
 //____________Offline tracking in the AliTRDtracker____________________________
-Bool_t AliTRDCalibraFillHisto::UpdateHistograms(AliTRDcluster *cl, AliTRDtrack *t)
+Bool_t AliTRDCalibraFillHisto::UpdateHistogramsV1(AliTRDtrackV1 *t)
 {
   //
-  // For the offline tracking
-  // This function will be called in the function
-  // AliTRDtracker::FollowBackPropagation() in the loop over the clusters
-  // of TRD tracks 
-  // Fill the 2D histos or the vectors with the info of the clusters at
-  // the end of a detectors if the track is "good"
+  // Use AliTRDtrackV1 for the calibration
   //
 
-  // Get the parameter object
-  AliTRDCommonParam *parCom = AliTRDCommonParam::Instance();
-  if (!parCom) {
-    AliInfo("Could not get CommonParam");
-    return kFALSE;
-  }
-
-  // Get the parameter object
-  AliTRDcalibDB     *cal    = AliTRDcalibDB::Instance();
+  
+  const AliTRDseedV1 *tracklet = 0x0;          // tracklet per plane
+  AliTRDcluster *cl      = 0x0;                // cluster attached now to the tracklet
+  Bool_t         newtr   = kTRUE;              // new track
+  
+  // Get cal
+  AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
   if (!cal) {
     AliInfo("Could not get calibDB");
     return kFALSE;
   }
-  // Localisation of the detector
-  Int_t detector = cl->GetDetector();
-  Int_t chamber  = GetChamber(detector);
-  Int_t plane    = GetPlane(detector);
-
-  // Fill the infos for the previous clusters if not the same
-  // detector anymore or if not the same track
-  if (((detector != fDetectorPreviousTrack) || (!fDetectorAliTRDtrack)) && 
-      (fDetectorPreviousTrack != -1)) {
-    
-    fNumberTrack++;   
+  
+  ///////////////////////////
+  // loop over the tracklet
+  ///////////////////////////
+  for(Int_t itr = 0; itr < 6; itr++){
     
-    // If the same track, then look if the previous detector is in
-    // the same plane, if yes: not a good track
-    if (fDetectorAliTRDtrack && 
-        (GetPlane(detector) <= GetPlane(fDetectorPreviousTrack))) {
-      fGoodTrack = kFALSE;
+    if(!(tracklet = t->GetTracklet(itr))) continue;
+    if(!tracklet->IsOK()) continue;
+    fNumberTrack++; 
+    ResetfVariablestracklet();
+
+    //////////////////////////////////////////
+    // localisation of the tracklet and dqdl
+    //////////////////////////////////////////
+    Int_t layer    = tracklet->GetPlane();
+    Int_t ic = 0;
+    while(!(cl = tracklet->GetClusters(ic++))) continue;
+    Int_t detector = cl->GetDetector();
+    if (detector != fDetectorPreviousTrack) {
+      // if not a new track
+      if(!newtr){
+       // don't use the rest of this track if in the same plane
+       if (layer == GetLayer(fDetectorPreviousTrack)) {
+         //printf("bad tracklet, same layer for detector %d\n",detector);
+         break;
+       }
+      }
+      //Localise the detector bin
+      LocalisationDetectorXbins(detector);
+      // Get calib objects
+      if( fCalROCGain ){ 
+        fCalROCGain->~AliTRDCalROC();
+        new(fCalROCGain) AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+      }else fCalROCGain = new AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+      
+      // reset
+      fDetectorPreviousTrack = detector;
     }
-
-    // Fill only if the track doesn't touch a masked pad or doesn't
-    // appear in the middle (fGoodTrack)
-    if (fGoodTrack) {
-
+    newtr = kFALSE;
+
+    ////////////////////////////
+    // loop over the clusters
+    ////////////////////////////
+    Int_t nbclusters = 0;
+    for(int jc=0; jc<AliTRDseed::knTimebins; jc++){
+      if(!(cl = tracklet->GetClusters(jc))) continue;
+      nbclusters++;
+      
+      // Store the info bis of the tracklet
+      Int_t row = cl->GetPadRow();
+      Int_t col = cl->GetPadCol();
+      CheckGoodTrackletV1(cl);
+      Int_t     group[2] = {0,0};
+      if(fCH2dOn)  group[0]  = CalculateCalibrationGroup(0,row,col);
+      if(fPH2dOn)  group[1]  = CalculateCalibrationGroup(1,row,col);
+      StoreInfoCHPHtrack(cl, tracklet->GetdQdl(jc),group,row,col);
+    }
+    
+    ////////////////////////////////////////
+    // Fill the stuffs if a good tracklet
+    ////////////////////////////////////////
+    if (fGoodTracklet) {
+      
+      // drift velocity unables to cut bad tracklets 
+      Bool_t  pass = FindP1TrackPHtrackletV1(tracklet, nbclusters);
+       
       // Gain calibration
       if (fCH2dOn) {
-       FillTheInfoOfTheTrackCH();
+       FillTheInfoOfTheTrackCH(nbclusters);
       }
-      
+       
       // PH calibration
       if (fPH2dOn) {
        FillTheInfoOfTheTrackPH();    
       }
-      
-    } // if a good track
+       
+      if(pass && fPRF2dOn) HandlePRFtrackletV1(tracklet,nbclusters);
+               
+    } // if a good tracklet
+  }
+  
+  return kTRUE;
+  
+}
+///////////////////////////////////////////////////////////////////////////////////
+// Routine inside the update with AliTRDtrack
+///////////////////////////////////////////////////////////////////////////////////
+//____________Offine tracking in the AliTRDtracker_____________________________
+Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtracklet(AliTRDtrack *t, Int_t index0, Int_t index1)
+{
+  //
+  // Drift velocity calibration:
+  // Fit the clusters with a straight line
+  // From the slope find the drift velocity
+  //
+
+  //Number of points: if less than 3 return kFALSE
+  Int_t npoints = index1-index0;
+  if(npoints <= 2) return kFALSE;
+
+  /////////////////
+  //Variables
+  ////////////////
+  Int_t    detector                   = ((AliTRDcluster *) t->GetCluster(index0))->GetDetector(); //detector
+  // parameters of the track
+  Double_t snp                        = t->GetSnpPlane(GetLayer(detector)); // sin angle in the plan yx track
+  Double_t tgl                        = t->GetTglPlane(GetLayer(detector)); // dz/dl and not dz/dx!  
+  Double_t tnp                        = 0.0;                                // tan angle in the plan xy track
+  if( TMath::Abs(snp) <  1.){
+    tnp = snp / (TMath::Sqrt(1-(snp*snp)));
+  } 
+  Float_t dzdx                        = tgl*TMath::Sqrt(1+tnp*tnp);         // dz/dx now from dz/dl
+  // tilting pad and cross row
+  Int_t    crossrow                   = 0;                                  // if it crosses a pad row
+  Int_t    rowp                       = -1;                                 // if it crosses a pad row
+  AliTRDpadPlane *padplane            = fGeo->GetPadPlane(GetLayer(detector),GetStack(detector));
+  Double_t tiltingangle               = padplane->GetTiltingAngle();        // tiltingangle of the pad      
+  Float_t  tnt                        = TMath::Tan(tiltingangle/180.*TMath::Pi()); // tan tiltingangle
+  // linear fit
+  fLinearFitterTracklet->ClearPoints();  
+  Double_t dydt                       = 0.0;                                // dydt tracklet after straight line fit
+  Double_t errorpar                   = 0.0;                                // error after straight line fit on dy/dt
+  Double_t pointError                 = 0.0;                                // error after straight line fit 
+  Int_t     nbli                      = 0;                                  // number linear fitter points
+  
+  //////////////////////////////
+  // loop over clusters
+  ////////////////////////////
+  for(Int_t k = 0; k < npoints; k++){
+    
+    AliTRDcluster *cl                 = (AliTRDcluster *) t->GetCluster(k+index0);
+    if((fLimitChargeIntegration) && (!cl->IsInChamber())) continue;
+    Double_t ycluster                 = cl->GetY();
+    Int_t time                        = cl->GetPadTime();
+    Double_t timeis                   = time/fSf;
+    //Double_t q                        = cl->GetQ();
+    //See if cross two pad rows
+    Int_t    row                      = cl->GetPadRow();
+    if(k==0) rowp                     = row;
+    if(row != rowp) crossrow          = 1;
+
+    fLinearFitterTracklet->AddPoint(&timeis,ycluster,1);
+    nbli++;
+
+  }
+
+  //////////////////////////////
+  // linear fit
+  //////////////////////////////
+  if(nbli <= 2){ 
+    fLinearFitterTracklet->ClearPoints();  
+    return kFALSE; 
+  }
+  TVectorD pars;
+  fLinearFitterTracklet->Eval();
+  fLinearFitterTracklet->GetParameters(pars);
+  pointError  =  TMath::Sqrt(fLinearFitterTracklet->GetChisquare()/(nbli-2));
+  errorpar    =  fLinearFitterTracklet->GetParError(1)*pointError;
+  dydt        = pars[1]; 
+  fLinearFitterTracklet->ClearPoints();  
+    
+  /////////////////////////////
+  // debug
+  ////////////////////////////
+  if(fDebugLevel > 0){
+    if ( !fDebugStreamer ) {
+      //debug stream
+      TDirectory *backup = gDirectory;
+      fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
+      if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+    } 
+    
+        
+    (* fDebugStreamer) << "FindP1TrackPHtracklet0"<<
+      //"snpright="<<snpright<<
+      "npoints="<<npoints<<
+      "nbli="<<nbli<<
+      "detector="<<detector<<
+      "snp="<<snp<<
+      "tnp="<<tnp<<
+      "tgl="<<tgl<<
+      "tnt="<<tnt<<
+      "dydt="<<dydt<<
+      "dzdx="<<dzdx<<
+      "crossrow="<<crossrow<<
+      "errorpar="<<errorpar<<
+      "pointError="<<pointError<<
+      "\n";
+
+
+    Int_t nbclusters = index1-index0;
+    Int_t layer      = GetLayer(fDetectorPreviousTrack);
+
+    (* fDebugStreamer) << "FindP1TrackPHtracklet1"<<
+      //"snpright="<<snpright<<
+      "nbclusters="<<nbclusters<<
+      "detector="<<fDetectorPreviousTrack<<
+      "layer="<<layer<<
+      "\n";     
+
+  }
+  
+  ///////////////////////////
+  // quality cuts
+  ///////////////////////////
+  if(npoints < fNumberClusters) return kFALSE;
+  if(npoints > fNumberClustersf) return kFALSE;
+  if(pointError >= 0.1) return kFALSE;
+  if(crossrow == 1) return kFALSE;
+
+  ////////////////////////////
+  // fill
+  ////////////////////////////
+  if(fLinearFitterOn){
+    //Add to the linear fitter of the detector
+    if( TMath::Abs(snp) <  1.){
+      Double_t x = tnp-dzdx*tnt; 
+      (GetLinearFitter(detector,kTRUE))->AddPoint(&x,dydt);
+      if(fLinearFitterDebugOn) {
+       fLinearVdriftFit->Update(detector,x,pars[1]);
+      }
+      fEntriesLinearFitter[detector]++;
+    }
+  }
+  
+  return kTRUE;
+}
+//____________Offine tracking in the AliTRDtracker_____________________________
+Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtrackletV1(const AliTRDseedV1 *tracklet, Int_t nbclusters)
+{
+  //
+  // Drift velocity calibration:
+  // Fit the clusters with a straight line
+  // From the slope find the drift velocity
+  //
+
+  ////////////////////////////////////////////////
+  //Number of points: if less than 3 return kFALSE
+  /////////////////////////////////////////////////
+  if(nbclusters <= 2) return kFALSE;
+
+  ////////////
+  //Variables
+  ////////////
+  // results of the linear fit
+  Double_t dydt                       = 0.0;                                // dydt tracklet after straight line fit
+  Double_t errorpar                   = 0.0;                                // error after straight line fit on dy/dt
+  Double_t pointError                 = 0.0;                                // error after straight line fit 
+  // pad row problemes: avoid tracklet that cross pad rows, tilting angle in the constant
+  Int_t    crossrow                   = 0;                                  // if it crosses a pad row
+  Int_t    rowp                       = -1;                                 // if it crosses a pad row
+  Float_t  tnt                        = tracklet->GetTilt();                // tan tiltingangle
+  fLinearFitterTracklet->ClearPoints();  
+  
+  ///////////////////////////////////////////
+  // Take the parameters of the track
+  //////////////////////////////////////////
+  // take now the snp, tnp and tgl from the track
+  Double_t snp = tracklet->GetSnp();             // sin dy/dx at the end of the chamber
+  Double_t tnp = 0.0;                            // dy/dx at the end of the chamber 
+  if( TMath::Abs(snp) <  1.){
+    tnp = snp / (TMath::Sqrt(1-(snp*snp)));
+  } 
+  Double_t tgl  = tracklet->GetTgl();           // dz/dl
+  Double_t dzdx = tgl*TMath::Sqrt(1+tnp*tnp);   // dz/dx calculated from dz/dl
+  // at the entrance
+  //Double_t tnp = tracklet->GetYref(1);      // dy/dx at the entrance of the chamber
+  //Double_t tgl = tracklet->GetZref(1);      // dz/dl at the entrance of the chamber
+  //Double_t dzdx = tgl;                      //*TMath::Sqrt(1+tnp*tnp); // dz/dx from dz/dl
+  // at the end with correction due to linear fit
+  //Double_t tnp = tracklet->GetYfit(1);      // dy/dx at the end of the chamber after fit correction
+  //Double_t tgl = tracklet->GetZfit(1);      // dz/dl at the end of the chamber after fit correction 
+
+
+  ////////////////////////////
+  // loop over the clusters
+  ////////////////////////////
+  Int_t  nbli = 0;
+  AliTRDcluster *cl                   = 0x0;
+  for(int ic=0; ic<AliTRDseed::knTimebins; ic++){
+    if(!(cl = tracklet->GetClusters(ic))) continue;
+    if((fLimitChargeIntegration) && (!cl->IsInChamber())) continue;
     
-    ResetfVariables();
+    Double_t ycluster                 = cl->GetY();
+    Int_t time                        = cl->GetPadTime();
+    Double_t timeis                   = time/fSf;
+    //See if cross two pad rows
+    Int_t    row                      = cl->GetPadRow();
+    if(rowp==-1) rowp                 = row;
+    if(row != rowp) crossrow          = 1;
+
+    fLinearFitterTracklet->AddPoint(&timeis,ycluster,1);
+    nbli++;  
+
+  }
+  
+  ////////////////////////////////////
+  // Do the straight line fit now
+  ///////////////////////////////////
+  if(nbli <= 2){ 
+    fLinearFitterTracklet->ClearPoints();  
+    return kFALSE; 
+  }
+  TVectorD pars;
+  fLinearFitterTracklet->Eval();
+  fLinearFitterTracklet->GetParameters(pars);
+  pointError  =  TMath::Sqrt(fLinearFitterTracklet->GetChisquare()/(nbli-2));
+  errorpar    =  fLinearFitterTracklet->GetParError(1)*pointError;
+  dydt        = pars[1]; 
+  fLinearFitterTracklet->ClearPoints();  
+  ////////////////////////////////
+  // Debug stuff
+  /////////////////////////////// 
+
+
+  if(fDebugLevel > 0){
+    if ( !fDebugStreamer ) {
+      //debug stream
+      TDirectory *backup = gDirectory;
+      fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
+      if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+    } 
     
-  } // Fill at the end the charge
+
+    Int_t layer = GetLayer(fDetectorPreviousTrack);
+        
+    (* fDebugStreamer) << "FindP1TrackPHtrackletV1"<<
+      //"snpright="<<snpright<<
+      "nbclusters="<<nbclusters<<
+      "detector="<<fDetectorPreviousTrack<<
+      "layer="<<layer<<
+      "snp="<<snp<<
+      "tnp="<<tnp<<
+      "tgl="<<tgl<<
+      "tnt="<<tnt<<
+      "dydt="<<dydt<<
+      "dzdx="<<dzdx<<
+      "crossrow="<<crossrow<<
+      "errorpar="<<errorpar<<
+      "pointError="<<pointError<<
+      "\n";
+
+  }
   
-  // Calcul the position of the detector
-  if (detector != fDetectorPreviousTrack) {
-    LocalisationDetectorXbins(detector);
+  /////////////////////////
+  // Cuts quality
+  ////////////////////////
+
+  if(nbclusters < fNumberClusters) return kFALSE;
+  if(nbclusters > fNumberClustersf) return kFALSE;
+  if(pointError >= 0.1) return kFALSE;
+  if(crossrow == 1) return kFALSE;
+  
+  ///////////////////////
+  // Fill
+  //////////////////////
+
+  if(fLinearFitterOn){
+    //Add to the linear fitter of the detector
+    if( TMath::Abs(snp) <  1.){
+      Double_t x = tnp-dzdx*tnt; 
+      (GetLinearFitter(fDetectorPreviousTrack,kTRUE))->AddPoint(&x,dydt);
+      if(fLinearFitterDebugOn) {
+       fLinearVdriftFit->Update(fDetectorPreviousTrack,x,pars[1]);
+      }
+      fEntriesLinearFitter[fDetectorPreviousTrack]++;
+    }
   }
+  
+  return kTRUE;
+}
+//____________Offine tracking in the AliTRDtracker_____________________________
+Bool_t AliTRDCalibraFillHisto::HandlePRFtracklet(AliTRDtrack *t, Int_t index0, Int_t index1)
+{
+  //
+  // PRF width calibration
+  // Assume a Gaussian shape: determinate the position of the three pad clusters
+  // Fit with a straight line
+  // Take the fitted values for all the clusters (3 or 2 pad clusters)
+  // Fill the PRF as function of angle of the track
+  //
+  //
+
 
-  // Reset the good track for the PRF
-  Bool_t good = kTRUE;
+  //////////////////////////
+  // variables
+  /////////////////////////
+  Int_t npoints  = index1-index0;                                           // number of total points
+  Int_t nb3pc    = 0;                                                       // number of three pads clusters used for fit 
+  Int_t detector = ((AliTRDcluster *) t->GetCluster(index0))->GetDetector(); // detector
+  // To see the difference due to the fit
+  Double_t *padPositions;
+  padPositions = new Double_t[npoints];
+  for(Int_t k = 0; k < npoints; k++){
+    padPositions[k] = 0.0;
+  } 
+  // Take the tgl and snp with the track t now
+  Double_t  tgl = t->GetTglPlane(GetLayer(detector)); //dz/dl and not dz/dx
+  Double_t  snp = t->GetSnpPlane(GetLayer(detector)); // sin angle in xy plan
+  Float_t  dzdx = 0.0;                                // dzdx
+  Float_t  tnp  = 0.0;
+  if(TMath::Abs(snp) < 1.0){
+    tnp = snp / (TMath::Sqrt(1-snp*snp));
+    dzdx = tgl*TMath::Sqrt(1+tnp*tnp);
+  }
+  // linear fitter
+  fLinearFitterTracklet->ClearPoints();
+
+  ///////////////////////////
+  // calcul the tnp group
+  ///////////////////////////
+  Bool_t echec   = kFALSE;
+  Double_t shift = 0.0;
+  //Calculate the shift in x coresponding to this tnp
+  if(fNgroupprf != 0.0){
+    shift      = -3.0*(fNgroupprf-1)-1.5;
+    Double_t limithigh  = -0.2*(fNgroupprf-1);
+    if((tnp < (-0.2*fNgroupprf)) || (tnp > (0.2*fNgroupprf))) echec = kTRUE;
+    else{
+      while(tnp > limithigh){
+       limithigh += 0.2;
+       shift += 3.0;
+      }
+    }
+  }
+  if(echec) {
+    delete [] padPositions;
+    return kFALSE;
+  }
+
+  //////////////////////
+  // loop clusters
+  /////////////////////
+  for(Int_t k = 0;  k < npoints; k++){
+    //Take the cluster
+    AliTRDcluster *cl  = (AliTRDcluster *) t->GetCluster(k+index0);
+    Short_t  *signals  = cl->GetSignals();
+    Double_t     time  = cl->GetLocalTimeBin();
+    //Calculate x if possible 
+    Float_t xcenter    = 0.0;    
+    Bool_t  echec1      = kTRUE;   
+    if((time<=7) || (time>=21)) continue; 
+    // Center 3 balanced: position with the center of the pad
+    if ((((Float_t) signals[3]) > 0.0) && 
+       (((Float_t) signals[2]) > 0.0) && 
+       (((Float_t) signals[4]) > 0.0)) {
+      echec1 = kFALSE;
+      // Security if the denomiateur is 0 
+      if ((((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) / 
+          ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))) != 1.0) {
+       xcenter = 0.5 * (TMath::Log((Float_t) (((Float_t) signals[4]) / ((Float_t) signals[2]))))
+         / (TMath::Log(((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) 
+                       / ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))));
+      }
+      else {
+       echec1 = kTRUE;
+      }
+    }
+    if(TMath::Abs(xcenter) > 0.5) echec = kTRUE;
+    if(echec) continue;
+    //if no echec: calculate with the position of the pad
+    // Position of the cluster
+    Double_t       padPosition = xcenter +  cl->GetPadCol();
+    padPositions[k]            = padPosition;
+    nb3pc++;
+    fLinearFitterTracklet->AddPoint(&time, padPosition,1);
+  }//clusters loop
+
+
+  /////////////////////////////
+  // fit
+  ////////////////////////////
+  if(nb3pc < 3) {
+    delete [] padPositions;
+    fLinearFitterTracklet->ClearPoints();  
+    return kFALSE;
+  }
+  fLinearFitterTracklet->Eval();
+  TVectorD line(2);
+  fLinearFitterTracklet->GetParameters(line);
+  Float_t  pointError  = -1.0;
+  if( fLinearFitterTracklet->GetChisquare()>=0.0) {
+    pointError  =  TMath::Sqrt( fLinearFitterTracklet->GetChisquare()/(nb3pc-2));
+  }
+  fLinearFitterTracklet->ClearPoints();  
   
-  // Localisation of the cluster
-  Double_t pos[3] = { 0.0, 0.0, 0.0 };
-  pos[0] = cl->GetX();
-  pos[1] = cl->GetY();
-  pos[2] = cl->GetZ();
-  Int_t    time   = cl->GetLocalTimeBin();
+  /////////////////////////////////////////////////////
+  // Now fill the PRF: second loop over clusters
+  /////////////////////////////////////////////////////
+  for(Int_t k = 0;  k < npoints; k++){
+    //Take the cluster
+    AliTRDcluster *cl      = (AliTRDcluster *) t->GetCluster(k+index0);
+    Short_t  *signals      = cl->GetSignals();              // signal
+    Double_t     time      = cl->GetLocalTimeBin();              // time bin
+    Float_t padPosTracklet = line[0]+line[1]*time;          // reconstruct position from fit
+    Float_t padPos         = cl->GetPadCol();               // middle pad
+    Double_t dpad          = padPosTracklet - padPos;       // reconstruct position relative to middle pad from fit 
+    Float_t ycenter        = 0.0;                           // relative center charge
+    Float_t ymin           = 0.0;                           // relative left charge
+    Float_t ymax           = 0.0;                           // relative right charge
   
-  // Reset the detector
-  fDetectorPreviousTrack = detector;
-  fDetectorAliTRDtrack   = kTRUE;
+    //Requiere simply two pads clusters at least
+    if(((((Float_t) signals[3]) > 0.0) && (((Float_t) signals[2]) > 0.0)) ||
+       ((((Float_t) signals[3]) > 0.0) && (((Float_t) signals[4]) > 0.0))){
+      Float_t sum     = ((Float_t) signals[2]) + ((Float_t) signals[3]) + ((Float_t) signals[4]);
+      if(sum > 0.0) ycenter = ((Float_t) signals[3])/ sum;
+      if(sum > 0.0) ymin    = ((Float_t) signals[2])/ sum;
+      if(sum > 0.0) ymax    = ((Float_t) signals[4])/ sum; 
+    }
+    
+    //calibration group
+    Int_t     rowcl        = cl->GetPadRow();                           // row of cluster
+    Int_t     colcl        = cl->GetPadCol();                           // col of cluster 
+    Int_t     grouplocal   = CalculateCalibrationGroup(2,rowcl,colcl);  // calcul the corresponding group
+    Int_t     caligroup    = fCalibraMode->GetXbins(2)+ grouplocal;     // calcul the corresponding group
+    Float_t   xcl          = cl->GetY();                                // y cluster
+    Float_t   qcl          = cl->GetQ();                                // charge cluster 
+    Int_t     layer        = GetLayer(detector);                        // layer 
+    Int_t     stack        = GetStack(detector);                        // stack
+    Double_t  xdiff        = dpad;                                      // reconstructed position constant
+    Double_t  x            = dpad;                                      // reconstructed position moved
+    Float_t   ep           = pointError;                                // error of fit
+    Float_t   signal1      = (Float_t)signals[1];                       // signal at the border
+    Float_t   signal3      = (Float_t)signals[3];                       // signal
+    Float_t   signal2      = (Float_t)signals[2];                       // signal
+    Float_t   signal4      = (Float_t)signals[4];                       // signal
+    Float_t   signal5      = (Float_t)signals[5];                       // signal at the border
+   
+    //////////////////////////////
+    // debug
+    /////////////////////////////  
+    if(fDebugLevel > 0){
+      if ( !fDebugStreamer ) {
+       //debug stream
+       TDirectory *backup = gDirectory;
+       fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
+       if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+      }     
+         
+      
+      x = xdiff;
+      Int_t type=0;
+      Float_t y = ycenter;
+      (* fDebugStreamer) << "HandlePRFtracklet"<<
+       "caligroup="<<caligroup<<
+       "detector="<<detector<<
+       "layer="<<layer<<
+       "stack="<< stack <<
+       "npoints="<<npoints<<
+       "Np="<<nb3pc<<
+       "ep="<<ep<<
+       "type="<<type<<
+       "snp="<<snp<<
+       "tnp="<<tnp<<
+       "tgl="<<tgl<<  
+       "dzdx="<<dzdx<< 
+       "padPos="<<padPos<<
+       "padPosition="<<padPositions[k]<<
+       "padPosTracklet="<<padPosTracklet<<
+       "x="<<x<<
+       "y="<<y<<           
+       "xcl="<<xcl<<
+       "qcl="<<qcl<<
+       "signal1="<<signal1<<
+       "signal2="<<signal2<<
+       "signal3="<<signal3<<
+       "signal4="<<signal4<<
+       "signal5="<<signal5<<
+       "time="<<time<<
+       "\n";
+      x=-(xdiff+1);
+      y = ymin;
+      type=-1;
+      (* fDebugStreamer) << "HandlePRFtracklet"<<
+       "caligroup="<<caligroup<<
+       "detector="<<detector<<
+       "layer="<<layer<<
+       "stack="<<stack<<
+       "npoints="<<npoints<<
+       "Np="<<nb3pc<<
+       "ep="<<ep<<
+       "type="<<type<<
+       "snp="<<snp<<
+       "tnp="<<tnp<<
+       "tgl="<<tgl<<  
+       "dzdx="<<dzdx<< 
+       "padPos="<<padPos<<
+       "padPosition="<<padPositions[k]<<
+       "padPosTracklet="<<padPosTracklet<<
+       "x="<<x<<
+       "y="<<y<<
+       "xcl="<<xcl<<
+       "qcl="<<qcl<<
+       "signal1="<<signal1<<
+       "signal2="<<signal2<<
+       "signal3="<<signal3<<
+       "signal4="<<signal4<<
+       "signal5="<<signal5<<
+       "time="<<time<<
+       "\n";
+      x=1-xdiff;
+      y = ymax;
+      type=1;
+      (* fDebugStreamer) << "HandlePRFtracklet"<<
+       "caligroup="<<caligroup<<
+       "detector="<<detector<<
+       "layer="<<layer<<
+       "stack="<<stack<<
+       "npoints="<<npoints<<
+       "Np="<<nb3pc<<
+       "ep="<<ep<<
+       "type="<<type<<
+       "snp="<<snp<<
+       "tnp="<<tnp<<   
+       "tgl="<<tgl<<  
+       "dzdx="<<dzdx<< 
+       "padPos="<<padPos<<
+       "padPosition="<<padPositions[k]<<
+       "padPosTracklet="<<padPosTracklet<<
+       "x="<<x<<
+       "y="<<y<<
+       "xcl="<<xcl<<
+       "qcl="<<qcl<<
+       "signal1="<<signal1<<
+       "signal2="<<signal2<<
+       "signal3="<<signal3<<
+       "signal4="<<signal4<<
+       "signal5="<<signal5<<
+       "time="<<time<<
+       "\n";
+      
+    }
+
+    ////////////////////////////
+    // quality cuts
+    ///////////////////////////
+    if(npoints < fNumberClusters) continue;
+    if(npoints > fNumberClustersf) continue;
+    if(nb3pc <= 5) continue;
+    if((time >= 21) || (time < 7)) continue;
+    if(TMath::Abs(snp) >= 1.0) continue;
+    if(TMath::Abs(qcl) < 80) continue; 
+   
+    ////////////////////////////
+    // Fill
+    ///////////////////////////
+    if (fHisto2d) {
+      if(TMath::Abs(dpad) < 1.5) {
+       fPRF2d->Fill(shift+dpad,(caligroup+0.5),ycenter);
+       fPRF2d->Fill(shift-dpad,(caligroup+0.5),ycenter);
+      }
+      if((ymin > 0.0) && (TMath::Abs(dpad+1.0) < 1.5)) {
+       fPRF2d->Fill(shift-(dpad+1.0),(caligroup+0.5),ymin);
+       fPRF2d->Fill(shift+(dpad+1.0),(caligroup+0.5),ymin);
+      }
+      if((ymax > 0.0) && (TMath::Abs(dpad-1.0) < 1.5)) {
+       fPRF2d->Fill(shift+1.0-dpad,(caligroup+0.5),ymax);
+       fPRF2d->Fill(shift-1.0+dpad,(caligroup+0.5),ymax);
+      }
+    }
+    if (fVector2d) {
+      if(TMath::Abs(dpad) < 1.5) {
+       fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+dpad,ycenter);
+       fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-dpad,ycenter);
+      }
+      if((ymin > 0.0) && (TMath::Abs(dpad+1.0) < 1.5)) {
+       fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-(dpad+1.0),ymin);
+       fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+(dpad+1.0),ymin);
+      }
+      if((ymax > 0.0)  && (TMath::Abs(dpad-1.0) < 1.5)) {
+       fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+1.0-dpad,ymax);
+       fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-1.0+dpad,ymax);
+      }
+    }
+  }
+  delete [] padPositions;
+  return kTRUE;
+  
+}
+//____________Offine tracking in the AliTRDtracker_____________________________
+Bool_t AliTRDCalibraFillHisto::HandlePRFtrackletV1(const AliTRDseedV1 *tracklet, Int_t nbclusters)
+{
+  //
+  // PRF width calibration
+  // Assume a Gaussian shape: determinate the position of the three pad clusters
+  // Fit with a straight line
+  // Take the fitted values for all the clusters (3 or 2 pad clusters)
+  // Fill the PRF as function of angle of the track
+  //
+  //
+
+  //printf("begin\n");
+  ///////////////////////////////////////////
+  // Take the parameters of the track
+  //////////////////////////////////////////
+  // take now the snp, tnp and tgl from the track
+  Double_t snp = tracklet->GetSnp();             // sin dy/dx at the end of the chamber
+  Double_t tnp = 0.0;                            // dy/dx at the end of the chamber 
+  if( TMath::Abs(snp) <  1.){
+    tnp = snp / (TMath::Sqrt(1-(snp*snp)));
+  } 
+  Double_t tgl  = tracklet->GetTgl();           // dz/dl
+  Double_t dzdx = tgl*TMath::Sqrt(1+tnp*tnp);   // dz/dx calculated from dz/dl
+  // at the entrance
+  //Double_t tnp = tracklet->GetYref(1);      // dy/dx at the entrance of the chamber
+  //Double_t tgl = tracklet->GetZref(1);      // dz/dl at the entrance of the chamber
+  //Double_t dzdx = tgl;                      //*TMath::Sqrt(1+tnp*tnp); // dz/dx from dz/dl
+  // at the end with correction due to linear fit
+  //Double_t tnp = tracklet->GetYfit(1);      // dy/dx at the end of the chamber after fit correction
+  //Double_t tgl = tracklet->GetZfit(1);      // dz/dl at the end of the chamber after fit correction 
+
+  ///////////////////////////////
+  // Calculate tnp group shift
+  ///////////////////////////////
+  Bool_t echec   = kFALSE;
+  Double_t shift = 0.0;
+  //Calculate the shift in x coresponding to this tnp
+  if(fNgroupprf != 0.0){
+    shift      = -3.0*(fNgroupprf-1)-1.5;
+    Double_t limithigh  = -0.2*(fNgroupprf-1);
+    if((tnp < (-0.2*fNgroupprf)) || (tnp > (0.2*fNgroupprf))) echec = kTRUE;
+    else{
+      while(tnp > limithigh){
+       limithigh += 0.2;
+       shift += 3.0;
+      }
+    }
+  }
+  // do nothing if out of tnp range
+  //printf("echec %d\n",(Int_t)echec);
+  if(echec) return kFALSE;
+
+  ///////////////////////
+  // Variables
+  //////////////////////
+
+  Int_t nb3pc    = 0;              // number of three pads clusters used for fit 
+  Double_t *padPositions;          // to see the difference between the fit and the 3 pad clusters position
+  padPositions = new Double_t[AliTRDseed::knTimebins];
+  for(Int_t k = 0; k < AliTRDseed::knTimebins; k++){
+    padPositions[k] = 0.0;
+  } 
+  fLinearFitterTracklet->ClearPoints();  
   
-  // Position of the cluster
-  AliTRDpadPlane *padplane = parCom->GetPadPlane(plane,chamber);
-  Int_t    row        = padplane->GetPadRowNumber(pos[2]);
-  Double_t offsetz    = padplane->GetPadRowOffset(row,pos[2]);
-  Double_t offsettilt = padplane->GetTiltOffset(offsetz);
-  Int_t    col        = padplane->GetPadColNumber(pos[1]+offsettilt);
+  //printf("loop clusters \n");
+  ////////////////////////////
+  // loop over the clusters
+  ////////////////////////////
+  AliTRDcluster *cl                   = 0x0;
+  for(int ic=0; ic<AliTRDseed::knTimebins; ic++){
+    if(!(cl = tracklet->GetClusters(ic))) continue;
+    
+    Double_t     time  = cl->GetLocalTimeBin();
+    if((time<=7) || (time>=21)) continue;
+    Short_t  *signals  = cl->GetSignals(); 
+    Float_t xcenter    = 0.0;    
+    Bool_t  echec1      = kTRUE;   
+
+    /////////////////////////////////////////////////////////////
+    // Center 3 balanced: position with the center of the pad
+    /////////////////////////////////////////////////////////////
+    if ((((Float_t) signals[3]) > 0.0) && 
+       (((Float_t) signals[2]) > 0.0) && 
+       (((Float_t) signals[4]) > 0.0)) {
+      echec1 = kFALSE;
+      // Security if the denomiateur is 0 
+      if ((((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) / 
+          ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))) != 1.0) {
+       xcenter = 0.5 * (TMath::Log((Float_t) (((Float_t) signals[4]) / ((Float_t) signals[2]))))
+         / (TMath::Log(((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) 
+                       / ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))));
+      }
+      else {
+       echec1 = kTRUE;
+      }
+    }
+    if(TMath::Abs(xcenter) > 0.5) echec1 = kTRUE;
+    if(echec1) continue;
+
+    ////////////////////////////////////////////////////////
+    //if no echec1: calculate with the position of the pad
+    // Position of the cluster
+    // fill the linear fitter
+    ///////////////////////////////////////////////////////
+    Double_t       padPosition = xcenter +  cl->GetPadCol();
+    padPositions[ic]            = padPosition;
+    nb3pc++;
+    fLinearFitterTracklet->AddPoint(&time, padPosition,1);
+
+
+  }//clusters loop
+
+  //printf("Fin loop clusters \n");
+  //////////////////////////////
+  // fit with a straight line
+  /////////////////////////////
+  if(nb3pc < 3){ 
+    delete [] padPositions;
+    fLinearFitterTracklet->ClearPoints();  
+    delete [] padPositions;
+    return kFALSE;
+  }
+  fLinearFitterTracklet->Eval();
+  TVectorD line(2);
+  fLinearFitterTracklet->GetParameters(line);
+  Float_t  pointError  = -1.0;
+  if( fLinearFitterTracklet->GetChisquare()>=0.0) {
+  pointError  =  TMath::Sqrt( fLinearFitterTracklet->GetChisquare()/(nb3pc-2));
+  }
+  fLinearFitterTracklet->ClearPoints();  
+  //printf("PRF second loop \n");
+  ////////////////////////////////////////////////
+  // Fill the PRF: Second loop over clusters
+  //////////////////////////////////////////////
+  for(int ic=0; ic<AliTRDseed::knTimebins; ic++){
+    if(!(cl = tracklet->GetClusters(ic))) continue;
+
+    Short_t  *signals      = cl->GetSignals();              // signal
+    Double_t     time      = cl->GetLocalTimeBin();         // time bin
+    Float_t padPosTracklet = line[0]+line[1]*time;          // reconstruct position from fit
+    Float_t padPos         = cl->GetPadCol();               // middle pad
+    Double_t dpad          = padPosTracklet - padPos;       // reconstruct position relative to middle pad from fit 
+    Float_t ycenter        = 0.0;                           // relative center charge
+    Float_t ymin           = 0.0;                           // relative left charge
+    Float_t ymax           = 0.0;                           // relative right charge
   
+    ////////////////////////////////////////////////////////////////
+    // Calculate ycenter, ymin and ymax even for two pad clusters
+    ////////////////////////////////////////////////////////////////
+    if(((((Float_t) signals[3]) > 0.0) && (((Float_t) signals[2]) > 0.0)) ||
+       ((((Float_t) signals[3]) > 0.0) && (((Float_t) signals[4]) > 0.0))){
+      Float_t sum     = ((Float_t) signals[2]) + ((Float_t) signals[3]) + ((Float_t) signals[4]);
+      if(sum > 0.0) ycenter = ((Float_t) signals[3])/ sum;
+      if(sum > 0.0) ymin    = ((Float_t) signals[2])/ sum;
+      if(sum > 0.0) ymax    = ((Float_t) signals[4])/ sum; 
+    }
+    
+    /////////////////////////
+    // Calibration group
+    ////////////////////////
+    Int_t     rowcl        = cl->GetPadRow();                           // row of cluster
+    Int_t     colcl        = cl->GetPadCol();                           // col of cluster 
+    Int_t     grouplocal   = CalculateCalibrationGroup(2,rowcl,colcl);  // calcul the corresponding group
+    Int_t     caligroup    = fCalibraMode->GetXbins(2)+ grouplocal;     // calcul the corresponding group
+    Float_t   xcl          = cl->GetY();                                // y cluster
+    Float_t   qcl          = cl->GetQ();                                // charge cluster 
+    Int_t     layer        = GetLayer(fDetectorPreviousTrack);          // layer 
+    Int_t     stack        = GetStack(fDetectorPreviousTrack);          // stack  
+    Double_t  xdiff        = dpad;                                      // reconstructed position constant
+    Double_t  x            = dpad;                                      // reconstructed position moved
+    Float_t   ep           = pointError;                                // error of fit
+    Float_t   signal1      = (Float_t)signals[1];                       // signal at the border
+    Float_t   signal3      = (Float_t)signals[3];                       // signal
+    Float_t   signal2      = (Float_t)signals[2];                       // signal
+    Float_t   signal4      = (Float_t)signals[4];                       // signal
+    Float_t   signal5      = (Float_t)signals[5];                       // signal at the border
+   
+
+
+    /////////////////////
+    // Debug stuff
+    ////////////////////
+
+    if(fDebugLevel > 0){
+      if ( !fDebugStreamer ) {
+       //debug stream
+       TDirectory *backup = gDirectory;
+       fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
+       if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+      }     
+     
+      x = xdiff;
+      Int_t type=0;
+      Float_t y = ycenter;
+      (* fDebugStreamer) << "HandlePRFtrackletV1"<<
+       "caligroup="<<caligroup<<
+       "detector="<<fDetectorPreviousTrack<<
+       "layer="<<layer<<
+       "stack="<<stack<<
+       "npoints="<<nbclusters<<
+       "Np="<<nb3pc<<
+       "ep="<<ep<<
+       "type="<<type<<
+               "snp="<<snp<<
+               "tnp="<<tnp<<
+       "tgl="<<tgl<<  
+       "dzdx="<<dzdx<< 
+       "padPos="<<padPos<<
+       "padPosition="<<padPositions[ic]<<
+       "padPosTracklet="<<padPosTracklet<<
+       "x="<<x<<
+       "y="<<y<<           
+       "xcl="<<xcl<<
+       "qcl="<<qcl<<
+       "signal1="<<signal1<<
+       "signal2="<<signal2<<
+       "signal3="<<signal3<<
+       "signal4="<<signal4<<
+       "signal5="<<signal5<<
+       "time="<<time<<
+       "\n";
+      x=-(xdiff+1);
+      y = ymin;
+      type=-1;
+      (* fDebugStreamer) << "HandlePRFtrackletV1"<<
+       "caligroup="<<caligroup<<
+       "detector="<<fDetectorPreviousTrack<<
+       "layer="<<layer<<
+       "stack="<<stack<<
+       "npoints="<<nbclusters<<
+       "Np="<<nb3pc<<
+       "ep="<<ep<<
+       "type="<<type<<
+       "snp="<<snp<<
+       "tnp="<<tnp<<
+       "tgl="<<tgl<<  
+       "dzdx="<<dzdx<< 
+       "padPos="<<padPos<<
+       "padPosition="<<padPositions[ic]<<
+       "padPosTracklet="<<padPosTracklet<<
+       "x="<<x<<
+       "y="<<y<<
+       "xcl="<<xcl<<
+       "qcl="<<qcl<<
+       "signal1="<<signal1<<
+       "signal2="<<signal2<<
+       "signal3="<<signal3<<
+       "signal4="<<signal4<<
+       "signal5="<<signal5<<
+       "time="<<time<<
+       "\n";
+      x=1-xdiff;
+      y = ymax;
+      type=1;
+      (* fDebugStreamer) << "HandlePRFtrackletV1"<<
+       "caligroup="<<caligroup<<
+       "detector="<<fDetectorPreviousTrack<<
+       "layer="<<layer<<
+       "stack="<<stack<<
+       "npoints="<<nbclusters<<
+       "Np="<<nb3pc<<
+       "ep="<<ep<<
+       "type="<<type<<
+               "snp="<<snp<<   
+               "tnp="<<tnp<<   
+       "tgl="<<tgl<<  
+       "dzdx="<<dzdx<< 
+       "padPos="<<padPos<<
+       "padPosition="<<padPositions[ic]<<
+       "padPosTracklet="<<padPosTracklet<<
+       "x="<<x<<
+       "y="<<y<<
+       "xcl="<<xcl<<
+       "qcl="<<qcl<<
+       "signal1="<<signal1<<
+       "signal2="<<signal2<<
+       "signal3="<<signal3<<
+       "signal4="<<signal4<<
+       "signal5="<<signal5<<
+       "time="<<time<<
+       "\n";
+      
+    }
+    
+    /////////////////////
+    // Cuts quality
+    /////////////////////
+    if(nbclusters < fNumberClusters) continue;
+    if(nbclusters > fNumberClustersf) continue;
+    if(nb3pc <= 5) continue;
+    if((time >= 21) || (time < 7)) continue;
+    if(TMath::Abs(qcl) < 80) continue; 
+    if( TMath::Abs(snp) >  1.) continue;
+
+
+    ////////////////////////
+    // Fill the histos
+    ///////////////////////
+    if (fHisto2d) {
+      if(TMath::Abs(dpad) < 1.5) {
+       fPRF2d->Fill(shift+dpad,(caligroup+0.5),ycenter);
+       fPRF2d->Fill(shift-dpad,(caligroup+0.5),ycenter);
+       //printf("place %f, ycenter %f\n",(shift+dpad),ycenter);
+      }
+      if((ymin > 0.0) && (TMath::Abs(dpad+1.0) < 1.5)) {
+       fPRF2d->Fill(shift-(dpad+1.0),(caligroup+0.5),ymin);
+       fPRF2d->Fill(shift+(dpad+1.0),(caligroup+0.5),ymin);
+      }
+      if((ymax > 0.0) && (TMath::Abs(dpad-1.0) < 1.5)) {
+       fPRF2d->Fill(shift+1.0-dpad,(caligroup+0.5),ymax);
+       fPRF2d->Fill(shift-1.0+dpad,(caligroup+0.5),ymax);
+      }
+    }
+    // vector method
+    if (fVector2d) {
+      if(TMath::Abs(dpad) < 1.5) {
+       fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+dpad,ycenter);
+       fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-dpad,ycenter);
+      }
+      if((ymin > 0.0) && (TMath::Abs(dpad+1.0) < 1.5)) {
+       fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-(dpad+1.0),ymin);
+       fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+(dpad+1.0),ymin);
+      }
+      if((ymax > 0.0)  && (TMath::Abs(dpad-1.0) < 1.5)) {
+       fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+1.0-dpad,ymax);
+       fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-1.0+dpad,ymax);
+      }
+    }
+  } // second loop over clusters
+
+
+  delete [] padPositions;
+  return kTRUE;
+  
+}
+///////////////////////////////////////////////////////////////////////////////////////
+// Pad row col stuff: see if masked or not
+///////////////////////////////////////////////////////////////////////////////////////
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::CheckGoodTrackletV1(AliTRDcluster *cl)
+{
+  //
   // See if we are not near a masked pad
-  if (!IsPadOn(detector,col,row)) {
-    good       = kFALSE;
-    fGoodTrack = kFALSE;
+  //
+
+  if(cl->IsMasked()) fGoodTracklet = kFALSE;
+
+  
+}
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::CheckGoodTrackletV0(Int_t detector, Int_t row, Int_t col)
+{
+  //
+  // See if we are not near a masked pad
+  //
+
+  if (!IsPadOn(detector, col, row)) {
+    fGoodTracklet = kFALSE;
   }
 
   if (col > 0) {
-    if (!IsPadOn(detector,col-1,row)) {
-      fGoodTrack = kFALSE;
-      good       = kFALSE;
+    if (!IsPadOn(detector, col-1, row)) {
+      fGoodTracklet = kFALSE;
     }
   }
 
   if (col < 143) {
-    if (!IsPadOn(detector,col+1,row)) {
-      fGoodTrack = kFALSE;
-      good       = kFALSE;
+    if (!IsPadOn(detector, col+1, row)) {
+      fGoodTracklet = kFALSE;
     }
   }
+  
+}
+//_____________________________________________________________________________
+Bool_t AliTRDCalibraFillHisto::IsPadOn(Int_t detector, Int_t row, Int_t col) const
+{
+  //
+  // Look in the choosen database if the pad is On.
+  // If no the track will be "not good"
+  //
 
-  // Row of the cluster and position in the pad groups
-  Int_t posr[3] = { 0, 0, 0 };
-  if ((fCH2dOn)  && (fCalibraMode->GetNnZ(0) != 0)) {
-    posr[0] = (Int_t) row / fCalibraMode->GetNnZ(0);
+  // Get the parameter object
+  AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
+  if (!cal) {
+    AliInfo("Could not get calibDB");
+    return kFALSE;
   }
-  if ((fPH2dOn)  && (fCalibraMode->GetNnZ(1) != 0)) {
-    posr[1] = (Int_t) row / fCalibraMode->GetNnZ(1);
+  
+  if (!cal->IsChamberInstalled(detector)     || 
+       cal->IsChamberMasked(detector)        ||
+       cal->IsPadMasked(detector,col,row)) {
+    return kFALSE;
+  }
+  else {
+    return kTRUE;
+  }
+  
+}
+///////////////////////////////////////////////////////////////////////////////////////
+// Calibration groups: calculate the number of groups, localise...
+////////////////////////////////////////////////////////////////////////////////////////
+//_____________________________________________________________________________
+Int_t AliTRDCalibraFillHisto::CalculateCalibrationGroup(Int_t i, Int_t row, Int_t col) const
+{
+  //
+  // Calculate the calibration group number for i
+  //
+  // Row of the cluster and position in the pad groups
+  Int_t posr = 0;
+  if (fCalibraMode->GetNnZ(i) != 0) {
+    posr = (Int_t) row / fCalibraMode->GetNnZ(i);
   }
-  if ((fPRF2dOn) && (fCalibraMode->GetNnZ(2) != 0)) {
-    posr[2] = (Int_t) row / fCalibraMode->GetNnZ(2);
-  }  
       
   // Col of the cluster and position in the pad groups
-  Int_t posc[3] = { 0, 0, 0 };
-  if ((fCH2dOn)  && (fCalibraMode->GetNnRphi(0) != 0)) {
-    posc[0] = (Int_t) col / fCalibraMode->GetNnRphi(0);
+  Int_t posc = 0;
+  if (fCalibraMode->GetNnRphi(i) != 0) {
+    posc = (Int_t) col / fCalibraMode->GetNnRphi(i);
+  }
+  
+  return posc*fCalibraMode->GetNfragZ(i)+posr;
+  
+}
+//____________________________________________________________________________________
+Int_t AliTRDCalibraFillHisto::CalculateTotalNumberOfBins(Int_t i)
+{
+  //
+  // Calculate the total number of calibration groups
+  //
+  
+  Int_t ntotal = 0;
+  fCalibraMode->ModePadCalibration(2,i);
+  fCalibraMode->ModePadFragmentation(0,2,0,i);
+  fCalibraMode->SetDetChamb2(i);
+  ntotal += 6 * 18 * fCalibraMode->GetDetChamb2(i);
+  fCalibraMode->ModePadCalibration(0,i);
+  fCalibraMode->ModePadFragmentation(0,0,0,i);
+  fCalibraMode->SetDetChamb0(i);
+  ntotal += 6 * 4 * 18 * fCalibraMode->GetDetChamb0(i);
+  AliInfo(Form("Total number of Xbins: %d for i %d",ntotal,i));
+  return ntotal;
+
+}
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::SetNz(Int_t i, Short_t Nz)
+{
+  //
+  // Set the mode of calibration group in the z direction for the parameter i
+  // 
+
+  if ((Nz >= 0) && 
+      (Nz <  5)) {
+    fCalibraMode->SetNz(i, Nz); 
   }
-  if ((fPH2dOn)  && (fCalibraMode->GetNnRphi(1) != 0)) {
-    posc[1] = (Int_t) col / fCalibraMode->GetNnRphi(1);
+  else { 
+    AliInfo("You have to choose between 0 and 4");
   }
-  if ((fPRF2dOn) && (fCalibraMode->GetNnRphi(2) != 0)) {
-    posc[2] = (Int_t) col / fCalibraMode->GetNnRphi(2);
+
+}
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::SetNrphi(Int_t i, Short_t Nrphi)
+{
+  //
+  // Set the mode of calibration group in the rphi direction for the parameter i
+  //
+  if ((Nrphi >= 0) && 
+      (Nrphi <  7)) {
+    fCalibraMode->SetNrphi(i ,Nrphi); 
+  }
+  else {
+    AliInfo("You have to choose between 0 and 6");
   }
 
-  // Charge in the cluster
-  // For the moment take the abs
-  Float_t  q        = TMath::Abs(cl->GetQ());
-  Short_t  *signals = cl->GetSignals();
+}
+//____________Set the pad calibration variables for the detector_______________
+Bool_t AliTRDCalibraFillHisto::LocalisationDetectorXbins(Int_t detector)
+{
+  //
+  // For the detector calcul the first Xbins and set the number of row
+  // and col pads per calibration groups, the number of calibration
+  // groups in the detector.
+  //
+  
+  // first Xbins of the detector
+  if (fCH2dOn) {
+    fCalibraMode->CalculXBins(detector,0);
+  }
+  if (fPH2dOn) {
+    fCalibraMode->CalculXBins(detector,1);
+  }
+  if (fPRF2dOn) {
+    fCalibraMode->CalculXBins(detector,2);
+  }
+
+  // fragmentation of idect
+  for (Int_t i = 0; i < 3; i++) {
+    fCalibraMode->ModePadCalibration((Int_t) GetStack(detector),i);
+    fCalibraMode->ModePadFragmentation((Int_t) GetLayer(detector)
+                       , (Int_t) GetStack(detector)
+                       , (Int_t) GetSector(detector),i);
+  }
+  
+  return kTRUE;
+
+}
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::SetNumberGroupsPRF(Short_t numberGroupsPRF)
+{
+  //
+  // Should be between 0 and 6
+  //
  
-  // Correction due to the track angle
+  if ((numberGroupsPRF < 0) || (numberGroupsPRF > 6)) {
+    AliInfo("The number of groups must be between 0 and 6!");
+  } 
+  else {
+    fNgroupprf = numberGroupsPRF;
+  }
+
+} 
+///////////////////////////////////////////////////////////////////////////////////////////
+// Per tracklet: store or reset the info, fill the histos with the info
+//////////////////////////////////////////////////////////////////////////////////////////
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::StoreInfoCHPHtrack(AliTRDcluster *cl, Double_t dqdl, Int_t *group, Int_t row, Int_t col)
+{
+  //
+  // Store the infos in fAmpTotal, fPHPlace and fPHValue
+  // Correct from the gain correction before
+  //
+  
+  // time bin of the cluster not corrected
+  Int_t    time     = cl->GetPadTime();
+   
+  //Correct for the gain coefficient used in the database for reconstruction
+  Float_t correctthegain = fCalDetGain->GetValue(fDetectorPreviousTrack)*fCalROCGain->GetValue(col,row);
   Float_t correction    = 1.0;
   Float_t normalisation = 6.67;
-  if ((q >0) && (t->GetNdedx() > 0)) {
-    correction = t->GetClusterdQdl((t->GetNdedx() - 1)) / (normalisation);
-  }
+  // we divide with gain in AliTRDclusterizer::Transform...
+  if( correctthegain > 0 ) normalisation /= correctthegain;
+
+
+  // take dd/dl corrected from the angle of the track
+  correction = dqdl / (normalisation);
+  
 
   // Fill the fAmpTotal with the charge
   if (fCH2dOn) {
-    fAmpTotal[(Int_t) (posc[0]*fCalibraMode->GetNfragZ(0)+posr[0])] += correction;
+    if((!fLimitChargeIntegration) || (cl->IsInChamber())) fAmpTotal[(Int_t) group[0]] += correction;
   }
 
   // Fill the fPHPlace and value
   if (fPH2dOn) {
-    fPHPlace[time] = posc[1]*fCalibraMode->GetNfragZ(1)+posr[1];
+    fPHPlace[time] = group[1];
     fPHValue[time] = correction;
   }
+  
+}
+//____________Offine tracking in the AliTRDtracker_____________________________
+void AliTRDCalibraFillHisto::ResetfVariablestracklet()
+{
+  //
+  // Reset values per tracklet
+  //
+
+  //Reset good tracklet
+  fGoodTracklet = kTRUE;
+
+  // Reset the fPHValue
+  if (fPH2dOn) {
+    //Reset the fPHValue and fPHPlace
+    for (Int_t k = 0; k < fTimeMax; k++) {
+      fPHValue[k] = 0.0;
+      fPHPlace[k] = -1;
+    }
+  }
 
-  // Fill direct the PRF
-  if ((fPRF2dOn) && (good)) {
+  // Reset the fAmpTotal where we put value
+  if (fCH2dOn) {
+    for (Int_t k = 0; k < fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0); k++) {
+      fAmpTotal[k] = 0.0;
+    }
+  }
+}
+//____________Offine tracking in the AliTRDtracker_____________________________
+void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackCH(Int_t nbclusters)
+{
+  //
+  // For the offline tracking or mcm tracklets
+  // This function will be called in the functions UpdateHistogram... 
+  // to fill the info of a track for the relativ gain calibration
+  //
+       
+  Int_t nb            =  0;   // Nombre de zones traversees
+  Int_t fd            = -1;   // Premiere zone non nulle
+  Float_t totalcharge = 0.0;  // Total charge for the supermodule histo
+
+  if(nbclusters < fNumberClusters) return;
+  if(nbclusters > fNumberClustersf) return;
+  
+  
+  // See if the track goes through different zones
+  for (Int_t k = 0; k < fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0); k++) {
+    if (fAmpTotal[k] > 0.0) {
+      totalcharge += fAmpTotal[k];
+      nb++;
+      if (nb == 1) {
+        fd = k;
+      }
+    }
+  }
 
-    Float_t yminus  = 0.0;
-    Float_t xcenter = 0.0;
-    Float_t ycenter = 0.0;
-    Float_t ymax    = 0.0;
-    Bool_t  echec   = kFALSE;
     
-    if ((cl->From3pad()) && (!cl->IsUsed())) { 
-         
-      // Center 3 balanced and cut on the cluster shape
-      if ((((Float_t) signals[3]) > fThresholdClusterPRF2) && 
-          (((Float_t) signals[2]) > fThresholdClusterPRF2) && 
-          (((Float_t) signals[4]) > fThresholdClusterPRF2) && 
-          (((Float_t) signals[1]) < fThresholdClusterPRF1) && 
-          (((Float_t) signals[5]) < fThresholdClusterPRF1) && 
-          ((((Float_t) signals[2])*((Float_t) signals[4])/(((Float_t) signals[3])*((Float_t) signals[3]))) < 0.06)) {
-
-
-       //First calculate the position of the cluster and the y
-       //echec enables to repair cases where it fails
-       //
-       // Col correspond to signals[3]
-       if (fCenterOfflineCluster) {
-          xcenter = cl->GetCenter();
+  switch (nb)
+    { 
+    case 1:
+      fNumberUsedCh[0]++;
+      fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
+      if (fHisto2d) {
+       FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
+       //fCH2d->Fill(fAmpTotal[fd]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+0.5);
+      }
+      if (fVector2d) {
+       fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/fRelativeScale);
+      }
+      break;
+    case 2:
+      if ((fAmpTotal[fd]   > 0.0) && 
+         (fAmpTotal[fd+1] > 0.0)) {
+       // One of the two very big
+       if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+1]) {
+         if (fHisto2d) {
+           FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
+           //fCH2d->Fill(fAmpTotal[fd]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+0.5);
+         }
+         if (fVector2d) {
+           fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/fRelativeScale);
+         }
+         fNumberUsedCh[1]++;
+         fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
        }
-       else {
-         // Security if the denomiateur is 0 
-         if ((((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) / 
-                           ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))) != 1.0) {
-           xcenter = 0.5 * (TMath::Log((Float_t) (((Float_t) signals[4]) / ((Float_t) signals[2]))))
-                          / (TMath::Log(((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) 
-                                      / ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))));
+       if (fAmpTotal[fd+1] > fProcent*fAmpTotal[fd]) {
+         if (fHisto2d) {
+           FillCH2d(fCalibraMode->GetXbins(0)+fd+1,fAmpTotal[fd+1]/fRelativeScale);
+           //fCH2d->Fill(fAmpTotal[fd+1]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+1.5);
          }
-         else {
-            echec = kTRUE;
+         if (fVector2d) {
+           fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+1,fAmpTotal[fd+1]/fRelativeScale);
          }
+         fNumberUsedCh[1]++;
+         fEntriesCH[fCalibraMode->GetXbins(0)+fd+1]++;
        }
-       //after having calculating the position calculate the y
-       if (TMath::Abs(xcenter) < 0.5) {
-         ycenter = (Float_t) (((Float_t) signals[3]) 
-                            / (((Float_t) signals[2]) + ((Float_t) signals[3]) + (((Float_t) signals[4]))));
-         yminus  = (Float_t) (((Float_t) signals[2]) 
-                            / (((Float_t) signals[2]) + ((Float_t) signals[3]) + (((Float_t) signals[4]))));
-         ymax    = (Float_t) (((Float_t) signals[4]) 
-                            / (((Float_t) signals[2]) + ((Float_t) signals[3]) + (((Float_t) signals[4]))));
-         //If the charge of the cluster is too far away from the corrected one cut
-         if ((TMath::Abs(((Float_t) signals[2]) + ((Float_t) signals[3]) + (((Float_t) signals[4])) - q) > 10.0)) {
-            echec = kTRUE;
+      }
+      if (fCalibraMode->GetNfragZ(0) > 1) {
+       if (fAmpTotal[fd] > 0.0) {
+         if ((fd+fCalibraMode->GetNfragZ(0)) < (fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0))) {
+           if (fAmpTotal[fd+fCalibraMode->GetNfragZ(0)] > 0.0) {
+             // One of the two very big
+             if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]) {
+               if (fHisto2d) {
+                 FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
+                 //fCH2d->Fill(fAmpTotal[fd]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+0.5);
+               }
+               if (fVector2d) {
+                 fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/fRelativeScale);
+               }
+               fNumberUsedCh[1]++;
+               fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
+             }
+             if (fAmpTotal[fd+fCalibraMode->GetNfragZ(0)] > fProcent*fAmpTotal[fd]) {
+               if (fHisto2d) {
+                 FillCH2d(fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale);
+                 //fCH2d->Fill(fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)+0.5);
+               }
+               fNumberUsedCh[1]++;
+               fEntriesCH[fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)]++;
+               if (fVector2d) {
+                 fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale);
+               }
+             }
+           }
          }
        }
-       else {
-         echec = kTRUE;
+      }
+      break;
+    default: break;
+    }
+}
+//____________Offine tracking in the AliTRDtracker_____________________________
+void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackPH()
+{
+  //
+  // For the offline tracking or mcm tracklets
+  // This function will be called in the functions UpdateHistogram... 
+  // to fill the info of a track for the drift velocity  calibration
+  //
+    
+  Int_t nb  =  1; // Nombre de zones traversees 1, 2 ou plus de 3
+  Int_t fd1 = -1; // Premiere zone non nulle
+  Int_t fd2 = -1; // Deuxieme zone non nulle
+  Int_t k1  = -1; // Debut de la premiere zone
+  Int_t k2  = -1; // Debut de la seconde zone
+  Int_t nbclusters = 0; // number of clusters
+
+
+
+  // See if the track goes through different zones
+  for (Int_t k = 0; k < fTimeMax; k++) {
+    if (fPHValue[k] > 0.0) {
+      nbclusters++;
+      if (fd1 == -1) {
+       fd1 = fPHPlace[k];
+       k1  = k;              
+      }
+      if (fPHPlace[k] != fd1) {
+       if (fd2 == -1) {
+         k2  = k;
+         fd2 = fPHPlace[k];
+         nb  = 2;
        }
-      
-       //Then Fill the histo if no echec
-       //
-       // Fill only if it is in the drift region!
-       if ((((Float_t) (((Float_t) time) / fSf)) > 0.3) && (!echec)) {
-         if (fHisto2d) {
-           fPRF2d->Fill((fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2]+0.5),xcenter,ycenter);
-           fPRF2d->Fill((fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2]+0.5),-(xcenter+1.0),yminus);
-           fPRF2d->Fill((fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2]+0.5),1.0-xcenter,ymax);
+       if (fPHPlace[k] != fd2) {
+          nb = 3;
+       }
+      }
+    }
+  }
+
+  //printf("nbclusters %d, low limit %d, high limit %d\n",nbclusters,fNumberClusters,fNumberClustersf);
+
+  if(nbclusters < fNumberClusters) return;
+  if(nbclusters > fNumberClustersf) return;
+  
+  switch(nb)
+    {
+    case 1:
+      fNumberUsedPh[0]++;
+      for (Int_t i = 0; i < fTimeMax; i++) {
+       if (fHisto2d) {
+         if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+         else {
+           if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+             }
+         //printf("Fill the time bin %d with %f\n",i,fPHValue[i]);
+       }
+       if (fVector2d) {
+         if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+         else {
+           if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);  
          }
+       }
+      }
+      break;
+    case 2:
+      if ((fd1 == fd2+1) || 
+         (fd2 == fd1+1)) {
+       // One of the two fast all the think
+       if (k2 > (k1+fDifference)) {
+         //we choose to fill the fd1 with all the values
+         fNumberUsedPh[1]++;
+         for (Int_t i = 0; i < fTimeMax; i++) {
+           if (fHisto2d) {
+             if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+             else {
+               if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+                 }
+           }
+           if (fVector2d) {
+             if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+             else {
+               if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+                 }
+           }
+         }
+       }
+       if ((k2+fDifference) < fTimeMax) {
+         //we choose to fill the fd2 with all the values
+         fNumberUsedPh[1]++;
+         for (Int_t i = 0; i < fTimeMax; i++) {
+           if (fHisto2d) {
+             if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
+             else {
+               if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
+             }
+           }
          if (fVector2d) {
-           fCalibraVector->UpdateVectorPRF(fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2],xcenter,ycenter);
-           fCalibraVector->UpdateVectorPRF(fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2],-(xcenter+1.0),yminus);
-           fCalibraVector->UpdateVectorPRF(fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2],1.0-xcenter,ymax);
+           if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
+           else {
+             if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
+           }
          }
-       } // If in the drift region
-      } // center 3 balanced and cut on the cluster shape
-    } // Cluster isole
-  } // PRF2dOn 
-  
-  return kTRUE;
-  
+         }
+       }
+      }
+      // Two zones voisines sinon rien!
+      if (fCalibraMode->GetNfragZ(1) > 1) {
+       // Case 2
+       if ((fd1+fCalibraMode->GetNfragZ(1)) < (fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1))) {
+         if (fd2 == (fd1+fCalibraMode->GetNfragZ(1))) {
+           // One of the two fast all the think
+           if (k2 > (k1+fDifference)) {
+             //we choose to fill the fd1 with all the values
+             fNumberUsedPh[1]++;
+             for (Int_t i = 0; i < fTimeMax; i++) {
+               if (fHisto2d) {
+                 if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+                 else {
+                   if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+                 }
+               }
+               if (fVector2d) {
+                 if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+                 else {
+                   if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+                 }
+               }
+             }
+           }
+           if ((k2+fDifference) < fTimeMax) {
+             //we choose to fill the fd2 with all the values
+             fNumberUsedPh[1]++;
+             for (Int_t i = 0; i < fTimeMax; i++) {
+               if (fHisto2d) {
+                 if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
+                 else {
+                   if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
+                 }
+               }
+               if (fVector2d) {
+                 if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
+                 else {
+                   if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
+                 }
+               }
+             }
+           }
+         }
+       }
+       // Two zones voisines sinon rien!
+       // Case 3
+       if ((fd1 - fCalibraMode->GetNfragZ(1)) >= 0) {
+         if (fd2 == (fd1 - fCalibraMode->GetNfragZ(1))) {
+           // One of the two fast all the think
+           if (k2 > (k1 + fDifference)) {
+             //we choose to fill the fd1 with all the values
+             fNumberUsedPh[1]++;
+             for (Int_t i = 0; i < fTimeMax; i++) {
+               if (fHisto2d) {
+                 if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+                 else {
+                   if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+                 }
+               }
+               if (fVector2d) {
+                 if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+                 else {
+                   if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+                 }
+               }
+             }
+           }
+           if ((k2+fDifference) < fTimeMax) {
+             //we choose to fill the fd2 with all the values
+             fNumberUsedPh[1]++;
+             for (Int_t i = 0; i < fTimeMax; i++) {
+               if (fHisto2d) {
+                 if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
+                 else {
+                   if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
+                 }
+               }
+               if (fVector2d) {
+                 if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
+                 else {
+                   if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
+                 }
+               }
+             }
+           }
+         }
+       }
+      }
+      break;
+    default: break;
+    } 
 }
-
-//____________Online trackling in AliTRDtrigger________________________________
-Bool_t AliTRDCalibraFillHisto::UpdateHistogramcm(AliTRDmcmTracklet *trk)
+//////////////////////////////////////////////////////////////////////////////////////////
+// DAQ process functions
+/////////////////////////////////////////////////////////////////////////////////////////
+//_____________________________________________________________________
+Int_t AliTRDCalibraFillHisto::ProcessEventDAQ(AliTRDrawStreamBase *rawStream, Bool_t nocheck)
 {
   //
-  // For the tracking
-  // This function will be called in the function AliTRDtrigger::TestTracklet
-  // before applying the pt cut on the tracklets 
-  // Fill the infos for the tracklets fTrkTest if the tracklets is "good"
+  // Event Processing loop - AliTRDrawStreamBase
+  // TestBeam 2007 version
+  // 0 timebin problem
+  // 1 no input
+  // 2 input
+  //
+  // Same algorithm as TestBeam but different reader
   //
   
-  // Localisation of the Xbins involved
-  Int_t idect = trk->GetDetector();
-  LocalisationDetectorXbins(idect);
-
-  // Get the parameter object
-  AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
-  if (!cal) {
-    AliInfo("Could not get calibDB");
-    return kFALSE;
-  }
-   
-  // Reset
-  ResetfVariables();
-  // Row of the tracklet and position in the pad groups
-  Int_t row     = trk->GetRow();
-  Int_t posr[3] = { 0, 0, 0 };
-  if ((fCH2dOn)  && (fCalibraMode->GetNnZ(0) != 0)) {
-    posr[0] = (Int_t) row / fCalibraMode->GetNnZ(0);
-  }
-  if ((fPH2dOn)  && (fCalibraMode->GetNnZ(1) != 0)) {
-    posr[1] = (Int_t) row / fCalibraMode->GetNnZ(1);
-  }
-  if ((fPRF2dOn) && (fCalibraMode->GetNnZ(2) != 0)) {
-    posr[2] = (Int_t) row / fCalibraMode->GetNnZ(2);
-  }
-  // Eventuelle correction due to track angle in z direction
-  Float_t correction = 1.0;
-  if (fMcmCorrectAngle) {
-    Float_t z = trk->GetRowz();
-    Float_t r = trk->GetTime0();
-    correction = r / TMath::Sqrt((r*r+z*z));
+  Int_t withInput = 1;
+  
+  Double_t phvalue[16][144][36];
+  for(Int_t k = 0; k < 36; k++){
+    for(Int_t j = 0; j < 16; j++){
+      for(Int_t c = 0; c < 144; c++){
+       phvalue[j][c][k] = 0.0;
+      }
+    }
   }
+  
+  fDetectorPreviousTrack = -1;
+  fMCMPrevious           = -1;
+  fROBPrevious           = -1;
+  Int_t nbtimebin = 0;                                        
+  Int_t baseline  = 10;  
 
-  // Boucle sur les clusters
-  // Condition on number of cluster: don't come from the middle of the detector
-  if (trk->GetNclusters() >= fNumberClusters) {
 
-    for (Int_t icl = 0; icl < trk->GetNclusters(); icl++) {
+  if(!nocheck){
+  
+    fTimeMax = 0;
+       
+    while (rawStream->Next()) {
+      
+      Int_t idetector = rawStream->GetDet();                            //  current detector
+      Int_t imcm      = rawStream->GetMCM();                            //  current MCM
+      Int_t irob      = rawStream->GetROB();                            //  current ROB
 
-      Float_t amp[3] = { 0.0, 0.0, 0.0 };
-      Int_t   time   = trk->GetClusterTime(icl);
-      Int_t   col    = trk->GetClusterCol(icl);
-            
-      amp[0] = trk->GetClusterADC(icl)[0] * correction;
-      amp[1] = trk->GetClusterADC(icl)[1] * correction;
-      amp[2] = trk->GetClusterADC(icl)[2] * correction;
+      //printf("Detector %d\n",idetector);
 
-      
-      if ((amp[0] < 0.0) || 
-          (amp[1] < 0.0) || 
-          (amp[2] < 0.0)) {
-        continue;
-      }
+      if((fDetectorPreviousTrack != idetector) && (fDetectorPreviousTrack != -1)){
+       
+       // Fill
+       withInput = TMath::Max(FillDAQ(phvalue),withInput);
 
-      // Col of cluster and position in the pad groups
-      Int_t posc[3] = { 0, 0, 0 };
-      if ((fCH2dOn)  && (fCalibraMode->GetNnRphi(0) != 0)) {
-        posc[0] = (Int_t) col / fCalibraMode->GetNnRphi(0);
-      }
-      if ((fPH2dOn)  && (fCalibraMode->GetNnRphi(1) != 0)) {
-        posc[1] = (Int_t) col / fCalibraMode->GetNnRphi(1);
-      }
-      if ((fPRF2dOn) && (fCalibraMode->GetNnRphi(2) != 0)) {
-        posc[2] = (Int_t) col / fCalibraMode->GetNnRphi(2);
-      }
 
-      // See if we are not near a masked pad
-      Bool_t good = kTRUE;
-      if (!IsPadOn(idect,col,row)) {
-       fGoodTrack = kFALSE;
-       good       = kFALSE;
+       // reset
+       for(Int_t k = 0; k < 36; k++){
+         for(Int_t j = 0; j < 16; j++){
+           for(Int_t c = 0; c < 144; c++){
+             phvalue[j][c][k] = 0.0;
+           }
+         }
+       }
       }
 
-      if (col >   0) {
-       if (!IsPadOn(idect,col-1,row)) {
-         fGoodTrack = kFALSE;
-         good       = kFALSE;
-       }
+      fDetectorPreviousTrack = idetector;
+      fMCMPrevious           = imcm;
+      fROBPrevious           = irob;
+
+      nbtimebin              = rawStream->GetNumberOfTimeBins();              //  number of time bins read from data
+      if(nbtimebin == 0) return 0;
+      if((fTimeMax != 0) && (nbtimebin != fTimeMax)) return 0;
+      fTimeMax          = nbtimebin;
+
+      //baseline          = rawStream->GetCommonAdditive();                // common additive baseline
+      fNumberClustersf    = fTimeMax;
+      fNumberClusters     = (Int_t)(0.6*fTimeMax);
+
+
+      Int_t *signal     = rawStream->GetSignals();                       //  current ADC signal
+      Int_t  col        = rawStream->GetCol();
+      Int_t row         = rawStream->GetRow();    
+
+      
+      //printf("detector %d, signal[0] %d, signal[1] %d, signal[2] %d, baseline %d\n",idetector,signal[0],signal[1],signal[2], baseline);
+     
+                
+      for(Int_t itime = 0; itime < nbtimebin; itime++){
+       phvalue[row][col][itime] = signal[itime]-baseline;
       }
+    }
+    
+    // fill the last one
+    if(fDetectorPreviousTrack != -1){
+
+      // Fill
+      withInput = TMath::Max(FillDAQ(phvalue),withInput);
       
-      if (col < 143) {
-       if (!IsPadOn(idect,col+1,row)) {
-         fGoodTrack = kFALSE;
-         good       = kFALSE;
+      // reset
+      for(Int_t k = 0; k < 36; k++){
+       for(Int_t j = 0; j < 16; j++){
+         for(Int_t c = 0; c < 144; c++){
+           phvalue[j][c][k] = 0.0;
+         }
        }
       }
+    }
+    
+  }
+  else{
 
-      // Total spectrum
-      if (fPH2dOn) {
-        fPHPlace[time] = posc[1] * fCalibraMode->GetNfragZ(1) + posr[1];
+    while (rawStream->Next()) {
+
+      Int_t idetector = rawStream->GetDet();                            //  current detector
+      Int_t imcm      = rawStream->GetMCM();                            //  current MCM
+      Int_t irob      = rawStream->GetROB();                            //  current ROB
+
+      //printf("Detector %d\n",idetector);
+
+      if((fDetectorPreviousTrack != idetector) && (fDetectorPreviousTrack != -1)){
+
+       // Fill
+       withInput = TMath::Max(FillDAQ(phvalue),withInput);
+       
+       // reset
+       for(Int_t k = 0; k < 36; k++){
+         for(Int_t j = 0; j < 16; j++){
+           for(Int_t c = 0; c < 144; c++){
+             phvalue[j][c][k] = 0.0;
+           }
+         }
+       }
       }
+      
+      fDetectorPreviousTrack = idetector;
+      fMCMPrevious           = imcm;
+      fROBPrevious           = irob;
 
-      if (fCH2dOn) {
-       fAmpTotal[(Int_t) (posc[0]*fCalibraMode->GetNfragZ(0)+posr[0])] += (Float_t) (amp[0]+amp[1]+amp[2]);
+      //baseline          = rawStream->GetCommonAdditive();                //  common baseline
+      
+      fTimeMax          = rawStream->GetNumberOfTimeBins();              //  number of time bins read from data
+      fNumberClustersf    = fTimeMax;
+      fNumberClusters     = (Int_t)(0.6*fTimeMax);
+      Int_t *signal     = rawStream->GetSignals();                       //  current ADC signal
+      Int_t col         = rawStream->GetCol();
+      Int_t row         = rawStream->GetRow();   
+
+       
+      //printf("detector %d, signal[0] %d, signal[1] %d, signal[2] %d, baseline %d\n",idetector,signal[0],signal[1],signal[2], baseline);
+      
+      for(Int_t itime = 0; itime < fTimeMax; itime++){
+       phvalue[row][col][itime] = signal[itime]-baseline;
       }
-      if (fPH2dOn) {
-       fPHValue[time] = (Float_t) (amp[0]+amp[1]+amp[2]);
+    }
+    
+    // fill the last one
+    if(fDetectorPreviousTrack != -1){
+      
+      // Fill
+      withInput = TMath::Max(FillDAQ(phvalue),withInput);
+
+      // reset
+      for(Int_t k = 0; k < 36; k++){
+       for(Int_t j = 0; j < 16; j++){
+         for(Int_t c = 0; c < 144; c++){
+           phvalue[j][c][k] = 0.0;
+         }
+       }
       }
+    }
+  }
+  
+  return withInput;
+  
+}
+//_____________________________________________________________________
+Int_t AliTRDCalibraFillHisto::ProcessEventDAQV1(AliTRDrawStreamBase *rawStream, Bool_t nocheck)
+{
+  //
+  // Event Processing loop - AliTRDrawStreamBase
+  // Use old AliTRDmcmtracklet code
+  // 0 timebin problem
+  // 1 no input
+  // 2 input
+  //
+  // Algorithm with mcm tracklet
+  //
+  
+  Int_t withInput = 1;
+  
+  AliTRDmcm mcm = AliTRDmcm(0);
+  AliTRDtrigParam *param = AliTRDtrigParam::Instance();
+  rawStream->SetSharedPadReadout(kTRUE);
+  
+  fDetectorPreviousTrack = -1;
+  fMCMPrevious           = -1;
+  fROBPrevious           = -1;
+  Int_t row              = -1;
+  Int_t nbtimebin = 0;                                        
+  Int_t baseline  = 10;  
+
+
+  if(!nocheck){
+  
+    fTimeMax = 0;
+       
+    while (rawStream->Next()) {
+      
+      Int_t idetector = rawStream->GetDet();                            //  current detector
+      Int_t imcm      = rawStream->GetMCM();                            //  current MCM
+      Int_t irob      = rawStream->GetROB();                            //  current ROB
+      row       = rawStream->GetRow();    
+  
       
-            
-      // Fill PRF direct
-      if (fPRF2dOn && good) {
+      if(((fDetectorPreviousTrack != idetector) || (fMCMPrevious != imcm) || (fROBPrevious != irob)) && (fDetectorPreviousTrack != -1)){
+       
+       // Fill
+       withInput = TMath::Max(FillDAQ(&mcm),withInput);
        
-       if ((amp[0] > fThresholdClusterPRF2) && 
-            (amp[1] > fThresholdClusterPRF2) && 
-            (amp[2] > fThresholdClusterPRF2) && 
-            ((amp[0]*amp[2]/(amp[1]*amp[1])) < 0.06)) {
        
-         // Security of the denomiateur is 0
-         if ((((Float_t) (((Float_t) amp[1]) * ((Float_t) amp[1]))) 
-             / ((Float_t) (((Float_t) amp[0]) * ((Float_t) amp[2])))) != 1.0) {
-           Float_t xcenter = 0.5 * (TMath::Log(amp[2] / amp[0]))
-                                  / (TMath::Log((amp[1]*amp[1]) / (amp[0]*amp[2])));
-           Float_t ycenter = amp[1] / (amp[0] + amp[1] + amp[2]);
-
-           if (TMath::Abs(xcenter) < 0.5) {
-             Float_t yminus = amp[0] / (amp[0]+amp[1]+amp[2]);
-             Float_t ymax   = amp[2] / (amp[0]+amp[1]+amp[2]);
-             // Fill only if it is in the drift region!
-             if (((Float_t) time / fSf) > 0.3) {
-               if (fHisto2d) {
-                 fPRF2d->Fill((fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2]+0.5),xcenter,ycenter);
-                 fPRF2d->Fill((fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2]+0.5),-(xcenter+1.0),yminus);
-                 fPRF2d->Fill((fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2]+0.5),(1.0-xcenter),ymax);
-               }
-               if (fVector2d) {
-                 fCalibraVector->UpdateVectorPRF((fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2]),xcenter,ycenter);
-                 fCalibraVector->UpdateVectorPRF(fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2],-(xcenter+1.0),yminus);
-                 fCalibraVector->UpdateVectorPRF(fCalibraMode->GetXbins(2)+posc[2]*fCalibraMode->GetNfragZ(2)+posr[2],(1.0-xcenter),ymax);
-               }
-             }//in the drift region 
-           }//in the middle
-         }//denominateur security
-       }//cluster shape and thresholds
-      }//good and PRF On
-      
-    } // Boucle clusters
+       // reset
+       mcm.Reset();
+       mcm.SetRobId(irob);
+       mcm.SetChaId(idetector);
+       mcm.SetRow(row);
+       mcm.SetColRange(0,21);
+  
+      }
+      if(fDetectorPreviousTrack == -1){
+       
+       mcm.SetRobId(irob);
+       mcm.SetChaId(idetector);
+       mcm.SetRow(row);
+       mcm.SetColRange(0,21);
+
+      }
+
+      fDetectorPreviousTrack = idetector;
+      fMCMPrevious           = imcm;
+      fROBPrevious           = irob;
+
+      nbtimebin              = rawStream->GetNumberOfTimeBins();              //  number of time bins read from data
+      if(nbtimebin == 0) return 0;
+      if((fTimeMax != 0) && (nbtimebin != fTimeMax)) return 0;
+      fTimeMax          = nbtimebin;
+      fNumberClustersf  = fTimeMax;
+      fNumberClusters   = (Int_t)(0.6*fTimeMax);
+      param->SetTimeRange(0,fTimeMax);
+
+      //baseline          = rawStream->GetCommonAdditive();                // common additive baseline
+     
+      Int_t *signal     = rawStream->GetSignals();                       //  current ADC signal
+      Int_t  adc        = rawStream->GetADC();
     
-    // Fill the charge
-    if (fCH2dOn && fGoodTrack) {
-      FillTheInfoOfTheTrackCH();
+      
+      //printf("detector %d, signal[0] %d, signal[1] %d, signal[2] %d, baseline %d\n",idetector,signal[0],signal[1],signal[2], baseline);
+     
+      for(Int_t itime = 0; itime < nbtimebin; itime++){
+       mcm.SetADC(adc,itime,(signal[itime]-baseline));
+      }
     }
+    
+    // fill the last one
+    if(fDetectorPreviousTrack != -1){
+
+      // Fill
+      withInput = TMath::Max(FillDAQ(&mcm),withInput);
+
 
-    // PH calibration
-    if (fPH2dOn && fGoodTrack) {
-      FillTheInfoOfTheTrackPH();       
+      // reset
+      mcm.Reset();
+      mcm.SetRobId(fROBPrevious);
+      mcm.SetChaId(fDetectorPreviousTrack);
+      mcm.SetRow(row);
+      mcm.SetColRange(0,21);
+      
     }
+    
+  }
+  else{
 
-    fNumberTrack++;
-        
-  } // Condition on number of clusters
+    while (rawStream->Next()) {
 
-  return kTRUE;
+      Int_t idetector = rawStream->GetDet();                            //  current detector
+      Int_t imcm      = rawStream->GetMCM();                            //  current MCM
+      Int_t irob      = rawStream->GetROB();                            //  current ROB
+      row       = rawStream->GetRow();    
+
+      if(((fDetectorPreviousTrack != idetector) || (fMCMPrevious != imcm) || (fROBPrevious != irob)) && (fDetectorPreviousTrack != -1)){
+
+       // Fill
+       withInput = TMath::Max(FillDAQ(&mcm),withInput);
+
+
+       // reset
+       mcm.Reset();
+       mcm.SetRobId(irob);
+       mcm.SetChaId(idetector);
+       mcm.SetRow(row);
+       mcm.SetColRange(0,21);
+
+      }
+      
+      fDetectorPreviousTrack = idetector;
+      fMCMPrevious           = imcm;
+      fROBPrevious           = irob;
+
+      //baseline          = rawStream->GetCommonAdditive();                //  common baseline
+      
+      fTimeMax          = rawStream->GetNumberOfTimeBins();              //  number of time bins read from data
+      fNumberClustersf  = fTimeMax;
+      fNumberClusters   = (Int_t)(0.6*fTimeMax);
+      param->SetTimeRange(0,fTimeMax);
+      Int_t *signal     = rawStream->GetSignals();                       //  current ADC signal
+      Int_t adc         = rawStream->GetADC();
+       
+      
+      //printf("detector %d, signal[0] %d, signal[1] %d, signal[2] %d, baseline %d\n",idetector,signal[0],signal[1],signal[2], baseline);
+      
+      for(Int_t itime = 0; itime < fTimeMax; itime++){
+       mcm.SetADC(adc,itime,(signal[itime]-baseline));
+      }
+    }
+    
+    // fill the last one
+    if(fDetectorPreviousTrack != -1){
+      
+      // Fill
+      withInput = TMath::Max(FillDAQ(&mcm),withInput);
+      
+      // reset
+      mcm.Reset();
+      mcm.SetRobId(fROBPrevious);
+      mcm.SetChaId(fDetectorPreviousTrack);
+      mcm.SetRow(row);
+      mcm.SetColRange(0,21);
+
+    }
+  }
+  
+  return withInput;
   
 }
+//_____________________________________________________________________
+Int_t AliTRDCalibraFillHisto::ProcessEventDAQ(AliRawReader *rawReader, Bool_t nocheck)
+{
+  //
+  //  Event processing loop - AliRawReader
+  //  Testbeam 2007 version
+  //
 
-//_____________________________________________________________________________
-Bool_t AliTRDCalibraFillHisto::IsPadOn(Int_t detector, Int_t col, Int_t row) const
+  AliTRDrawStreamBase rawStream(rawReader);
+
+  rawReader->Select("TRD");
+
+  return ProcessEventDAQ(&rawStream, nocheck);
+}
+
+//_________________________________________________________________________
+Int_t AliTRDCalibraFillHisto::ProcessEventDAQ(
+#ifdef ALI_DATE
+                                              eventHeaderStruct *event,
+                                              Bool_t nocheck
+#else
+                                              eventHeaderStruct* /*event*/,
+                                              Bool_t /*nocheck*/
+           
+#endif 
+                                  )
 {
   //
-  // Look in the choosen database if the pad is On.
-  // If no the track will be "not good"
+  //  process date event
+  //  Testbeam 2007 version
   //
+#ifdef ALI_DATE
+    AliRawReader *rawReader = new AliRawReaderDate((void*)event);
+    Int_t result=ProcessEventDAQ(rawReader, nocheck);
+    delete rawReader;
+    return result;
+#else
+    Fatal("AliTRDCalibraFillHisto", "this class was compiled without DATE");
+    return 0;
+#endif
 
-  // Get the parameter object
-  AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
-  if (!cal) {
-    AliInfo("Could not get calibDB");
-    return kFALSE;
-  }
+}
+//_____________________________________________________________________
+Int_t AliTRDCalibraFillHisto::ProcessEventDAQV1(AliRawReader *rawReader, Bool_t nocheck)
+{
+  //
+  //  Event processing loop - AliRawReader
+  //  use the old mcm traklet code
+  //
+
+  AliTRDrawStreamBase rawStream(rawReader);
+
+  rawReader->Select("TRD");
+
+  return ProcessEventDAQV1(&rawStream, nocheck);
+}
+//_________________________________________________________________________
+Int_t AliTRDCalibraFillHisto::ProcessEventDAQV1(
+#ifdef ALI_DATE
+                                              eventHeaderStruct *event,
+                                              Bool_t nocheck
+#else
+                                              eventHeaderStruct* /*event*/,
+                                              Bool_t /*nocheck*/
+           
+#endif 
+                                  )
+{
+  //
+  //  process date event
+  //  use the old mcm tracklet code
+  //
+#ifdef ALI_DATE
+    AliRawReader *rawReader = new AliRawReaderDate((void*)event);
+    Int_t result=ProcessEventDAQV1(rawReader, nocheck);
+    delete rawReader;
+    return result;
+#else
+    Fatal("AliTRDCalibraFillHisto", "this class was compiled without DATE");
+    return 0;
+#endif
+
+}
+//////////////////////////////////////////////////////////////////////////////
+// Routine inside the DAQ process
+/////////////////////////////////////////////////////////////////////////////
+//_______________________________________________________________________
+Int_t AliTRDCalibraFillHisto::FillDAQ(AliTRDmcm *mcm){
   
-  if (!cal->IsChamberInstalled(detector)     || 
-       cal->IsChamberMasked(detector)        ||
-       cal->IsPadMasked(detector,col,row)) {
-    return kFALSE;
-  }
-  else {
-    return kTRUE;
+  //
+  // Return 2 if some tracklets are found and used, 1 if nothing
+  //
+
+  Int_t nbev = 0;
+
+  if(mcm->Run()){
+
+    for (Int_t iSeed = 0; iSeed < 4; iSeed++) {
+      
+      if (mcm->GetSeedCol()[iSeed] < 0) {
+       continue;
+      }
+      nbev += TestTracklet(mcm->GetChaId(),mcm->GetRow(),iSeed,mcm);
+    }
+    
   }
+
+  if(nbev > 0) nbev = 2;
+  else nbev = 1;
+
+  return nbev;
   
 }
+//__________________________________________________________________________
+Int_t AliTRDCalibraFillHisto::TestTracklet( Int_t idet, Int_t row, Int_t iSeed, AliTRDmcm *mcm){
+  
+  //
+  // Build the tracklet and return if the tracklet if finally used or not (1/0)
+  //
 
-//____________Functions for plotting the 2D____________________________________
+  Int_t nbev = 0;
 
-//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::Plot2d()
+  AliTRDmcmTracklet mcmtracklet = AliTRDmcmTracklet();  
+  //mcmtracklet.Reset();
+  mcmtracklet.SetDetector(idet);
+  mcmtracklet.SetRow(row);
+  mcmtracklet.SetN(0);
+
+  Int_t iCol, iCol1, iCol2, track[3];
+  iCol = mcm->GetSeedCol()[iSeed];  // 0....20 (MCM)
+  mcm->GetColRange(iCol1,iCol2);   // range in the pad plane
+           
+  Float_t amp[3];
+  for (Int_t iTime = 0; iTime < fTimeMax; iTime++) {
+
+    amp[0] = mcm->GetADC(iCol-1,iTime);
+    amp[1] = mcm->GetADC(iCol  ,iTime);
+    amp[2] = mcm->GetADC(iCol+1,iTime);
+
+    if(mcm->IsCluster(iCol,iTime)) {
+      
+      mcmtracklet.AddCluster(iCol+iCol1,iTime,amp,track);
+      
+    } 
+    else if ((iCol+1+1) < 21) {
+
+      amp[0] = mcm->GetADC(iCol-1+1,iTime);
+      amp[1] = mcm->GetADC(iCol  +1,iTime);
+      amp[2] = mcm->GetADC(iCol+1+1,iTime);
+
+      if(mcm->IsCluster(iCol+1,iTime)) {
+       
+       mcmtracklet.AddCluster(iCol+1+iCol1,iTime,amp,track);
+       
+      }
+      
+    } 
+    
+  } 
+
+
+  nbev = UpdateHistogramcm(&mcmtracklet); 
+
+  return nbev;
+
+}
+//____________Online trackling in AliTRDtrigger________________________________
+Int_t AliTRDCalibraFillHisto::UpdateHistogramcm(AliTRDmcmTracklet *trk)
 {
   //
-  // Plot the 2D histos 
+  // Return if the tracklet is finally used or not (1/0) for calibration
   //
+  
+  Int_t used = 1;
+
+  //fGoodTracklet = kTRUE;
+
+  // Localisation of the Xbins involved
+  Int_t idect = trk->GetDetector();
+  Int_t idectrue = trk->GetDetector();
+  //idect = 0;
+
+  Int_t nbclusters = trk->GetNclusters();
+  
+  // Eventuelle correction due to track angle in z direction
+  Float_t correction = 1.0;
+  if (fMcmCorrectAngle) {
+    Float_t z = trk->GetRowz();
+    Float_t r = trk->GetTime0();
+    correction = r / TMath::Sqrt((r*r+z*z));
+  }
+
+  //row
+  Int_t row = trk->GetRow();
+
+
+  // Boucle sur les clusters
+  // Condition on number of cluster: don't come from the middle of the detector
+  
+  Double_t amph[36];
+  for(Int_t k =0; k < 36; k++) amph[k]=0.0;
+  Double_t ampTotal = 0.0;
+  
+  for (Int_t icl = 0; icl < trk->GetNclusters(); icl++) {
+    
+    Float_t amp[3] = { 0.0, 0.0, 0.0 };
+    Int_t   time   = trk->GetClusterTime(icl);
+    Int_t   col    = trk->GetClusterCol(icl);
+    
+    //CheckGoodTrackletV0(idect,row,col);
+    
+    amp[0] = trk->GetClusterADC(icl)[0] * correction;
+    amp[1] = trk->GetClusterADC(icl)[1] * correction;
+    amp[2] = trk->GetClusterADC(icl)[2] * correction;
+    
+    ampTotal += (Float_t) (amp[0]+amp[1]+amp[2]);
+    amph[time]=amp[0]+amp[1]+amp[2];
+   
+    if(fDebugLevel > 0){
+      if ( !fDebugStreamer ) {
+       //debug stream
+       TDirectory *backup = gDirectory;
+       fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
+       if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+      }     
+      
+      Double_t amp0 = amp[0];
+      Double_t amp1 = amp[1];
+      Double_t amp2 = amp[2];
+
+      (* fDebugStreamer) << "UpdateHistogramcm0"<<
+       "nbclusters="<<nbclusters<<
+       "amp0="<<amp0<<
+       "amp1="<<amp1<<
+       "amp2="<<amp2<<
+       "time="<<time<<
+       "col="<<col<<
+       "row="<<row<<
+       "detector="<<idectrue<<
+       "\n"; 
+    }
  
-  if (fPH2dOn) {
-    TCanvas *cph2d = new TCanvas("cph2d","",50,50,600,800);
-    cph2d->cd();
-    fPH2d->Draw("LEGO");
+  } // Boucle clusters
+
+  if((amph[0] > 100.0) || (!fGoodTracklet) || (trk->GetNclusters() < fNumberClusters) || (trk->GetNclusters() > fNumberClustersf)) used = 0;
+  
+  if (used == 1) {
+    for(Int_t k = 0; k < fTimeMax; k++)  UpdateDAQ(idect,0,0,k,amph[k],fTimeMax); 
+    //((TH2I *)GetCH2d()->Fill(ampTotal/30.0,idect));    
+  } // Condition cut
+
+
+  if(fDebugLevel > 0){
+    if ( !fDebugStreamer ) {
+      //debug stream
+      TDirectory *backup = gDirectory;
+      fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
+      if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+    }     
+
+    Double_t amph0 = amph[0];
+    Double_t amphlast = amph[fTimeMax-1];
+    Double_t rms      = TMath::RMS(fTimeMax,amph);
+    Int_t    goodtracklet = (Int_t) fGoodTracklet; 
+
+    (* fDebugStreamer) << "UpdateHistogramcm1"<<
+      "nbclusters="<<nbclusters<<
+      "ampTotal="<<ampTotal<<
+      "row="<<row<<
+      "detector="<<idectrue<<
+      "amph0="<<amph0<<
+      "amphlast="<<amphlast<<
+      "goodtracklet="<<goodtracklet<<
+      "rms="<<rms<<
+      "\n"; 
   }
-  if (fCH2dOn) {
-    TCanvas *cch2d = new TCanvas("cch2d","",50,50,600,800);
-    cch2d->cd();
-    fCH2d->Draw("LEGO");
+
+  return used;
+
+}
+//_______________________________________________________________________
+Int_t AliTRDCalibraFillHisto::FillDAQ(Double_t phvalue[16][144][36]){
+
+  //
+  // Look for the maximum by collapsing over the time
+  // Sum over four pad col and two pad row
+  //
+
+  Int_t used = 0;
+
+
+  Int_t idect = fDetectorPreviousTrack;      
+  //printf("Enter Detector %d\n",fDetectorPreviousTrack);
+  Double_t sum[36];
+  for(Int_t tb = 0; tb < 36; tb++){
+    sum[tb] = 0.0;
   }
-  if (fPRF2dOn) {
-    TCanvas *cPRF2d = new TCanvas("cPRF2d","",50,50,600,800);
-    cPRF2d->cd();
-    fPRF2d->Draw("LEGO");
+
+  //fGoodTracklet = kTRUE;
+  //fDetectorPreviousTrack = 0;  
+
+
+  ///////////////////////////
+  // look for maximum
+  /////////////////////////
+
+  Int_t imaxRow = 0;
+  Int_t imaxCol = 0;
+  Double_t integralMax = -1;
+  
+  for (Int_t ir = 1; ir <= 15; ir++)
+    {
+      for (Int_t ic = 2; ic <= 142; ic++)
+       {
+         Double_t integral = 0;                  
+         for (Int_t ishiftR = 0; ishiftR < 2; ishiftR++)
+           {
+             for (Int_t ishiftC = -2; ishiftC < 2; ishiftC++)
+               {
+                 if (ir + ishiftR >= 1 && ir + ishiftR <= 16 &&
+                     ic + ishiftC >= 1 && ic + ishiftC <= 144)
+                   {
+
+                     for(Int_t tb = 0; tb< fTimeMax; tb++){
+                       integral += phvalue[ir + ishiftR-1][ic + ishiftC-1][tb];
+                     }// addtb
+                   } //addsignal
+               } //shiftC
+           } // shiftR
+         
+         if (integralMax < integral)
+           {
+             imaxRow = ir;
+             imaxCol = ic;
+             integralMax = integral;
+           } // check max integral
+       } //ic
+    } // ir
+
+  //printf("imaxRow %d, imaxCol %d, fTimeMax %d, integralMax %f\n",imaxRow,imaxCol,fTimeMax, integralMax);
+
+  if((imaxRow == 0) || (imaxCol == 0)) {
+    used=1;
+    return used;
+  }
+  //CheckGoodTrackletV0(fDetectorPreviousTrack,imaxRow,imaxCol);
+  //if(!fGoodTracklet) used = 1;;
+  
+  //  /////////////////////////////////////////////////////
+  // sum ober 2 row and 4 pad cols for each time bins
+  //  ////////////////////////////////////////////////////       
+  
+  
+  for (Int_t ir = imaxRow - 1; ir < imaxRow + 1; ir++)
+    {
+      for (Int_t ic = imaxCol - 2; ic < imaxCol + 2; ic++)
+       {
+         for(Int_t it = 0; it < fTimeMax; it++){
+           sum[it] += phvalue[ir][ic][it];
+         }
+       }//ic
+    }//ir  
+
+  Int_t nbcl = 0;
+  Double_t sumcharge = 0.0;
+  for(Int_t it = 0; it < fTimeMax; it++){
+    sumcharge += sum[it];
+    if(sum[it] > 20.0) nbcl++;
   }
 
+
+  /////////////////////////////////////////////////////////
+  // Debug
+  ////////////////////////////////////////////////////////
+  if(fDebugLevel > 0){
+    if ( !fDebugStreamer ) {
+      //debug stream
+      TDirectory *backup = gDirectory;
+      fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
+      if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+    }     
+
+    Double_t amph0 = sum[0];
+    Double_t amphlast = sum[fTimeMax-1];
+    Double_t rms      = TMath::RMS(fTimeMax,sum);
+    Int_t    goodtracklet = (Int_t) fGoodTracklet;
+    for(Int_t it = 0; it < fTimeMax; it++){
+      Double_t clustera = sum[it]; 
+
+    (* fDebugStreamer) << "FillDAQa"<<
+      "ampTotal="<<sumcharge<<
+      "row="<<imaxRow<<
+      "col="<<imaxCol<<
+      "detector="<<idect<<
+      "amph0="<<amph0<<
+      "amphlast="<<amphlast<<
+      "goodtracklet="<<goodtracklet<<
+      "clustera="<<clustera<<
+      "it="<<it<<
+      "rms="<<rms<<
+      "\n"; 
+    }
+  }
+
+  ////////////////////////////////////////////////////////
+  // fill
+  ///////////////////////////////////////////////////////
+  if(sum[0] > 100.0) used = 1; 
+  if(nbcl < fNumberClusters) used = 1;
+  if(nbcl > fNumberClustersf) used = 1;
+
+  //if(fDetectorPreviousTrack == 15){
+  //  printf("rms %f and first time bin %f\n",TMath::RMS(fTimeMax,sum),sum[0]);
+  //}
+  //if((TMath::RMS(fTimeMax,sum) <= 10.0) && (sum[0] > 200.0)) return 1;
+  if(used == 0){
+    for(Int_t it = 0; it < fTimeMax; it++){
+      if(fFillWithZero) UpdateDAQ(fDetectorPreviousTrack,0,0,it,sum[it],fTimeMax); 
+      else{
+       if(sum[it] > 0.0) UpdateDAQ(fDetectorPreviousTrack,0,0,it,sum[it],fTimeMax); 
+      } 
+    }
+    
+   
+    //((TH2I *)GetCH2d()->Fill(sumcharge/30.0,fDetectorPreviousTrack));
+    used = 2;
+    //printf("Pass Detector %d\n",fDetectorPreviousTrack);
+
+  }
+  return used;
+  
 }
+//____________Online trackling in AliTRDtrigger________________________________
+Bool_t AliTRDCalibraFillHisto::UpdateDAQ(Int_t det, Int_t /*row*/, Int_t /*col*/, Int_t timebin, Float_t signal, Int_t nbtimebins)
+{
+  //
+  // For the DAQ
+  // Fill a simple average pulse height
+  //
 
-//____________Writing the 2D___________________________________________________
+  
+  ((TProfile2D *)GetPH2d(nbtimebins,fSf))->Fill((Float_t) timebin/fSf,det+0.5,(Float_t) signal); 
 
-//_____________________________________________________________________________
-Bool_t AliTRDCalibraFillHisto::Write2d()
+  return kTRUE;
+  
+}
+//____________Write_____________________________________________________
+//_____________________________________________________________________
+void AliTRDCalibraFillHisto::Write2d(const Char_t *filename, Bool_t append)
 {
   //
-  // Write the 2D histograms or the vectors converted in trees in the file
-  // "TRD.calibration.root" 
+  //  Write infos to file
   //
   
-  TFile *fout = TFile::Open(fWriteName,"RECREATE");
-  // Check if the file could be opened
-  if (!fout || !fout->IsOpen()) {
-    AliInfo("No File found!");
-    return kFALSE;
+  //For debugging
+  if ( fDebugStreamer ) {
+    delete fDebugStreamer;
+    fDebugStreamer = 0x0;
   }
+
   AliInfo(Form("Numbertrack: %d Numberusedch[0]: %d, Numberusedch[1]: %d Numberusedph[0]: %d, Numberusedph[1]: %d"
-              ,fNumberTrack
-              ,fNumberUsedCh[0]
-              ,fNumberUsedCh[1]
-              ,fNumberUsedPh[0]
-              ,fNumberUsedPh[1]));
+              ,fNumberTrack
+              ,fNumberUsedCh[0]
+              ,fNumberUsedCh[1]
+              ,fNumberUsedPh[0]
+              ,fNumberUsedPh[1]));
+  
+  TDirectory *backup = gDirectory;
+  TString option;
+  
+  if ( append )
+    option = "update";
+  else
+    option = "recreate";
+  
+  TFile f(filename,option.Data());
   
   TStopwatch stopwatch;
   stopwatch.Start();
-  AliInfo("Write2d");
+  if(fVector2d) {
+    f.WriteTObject(fCalibraVector);
+  }
 
-  if ((fCH2dOn ) && (fWrite[0])) {
+  if (fCH2dOn ) {
     if (fHisto2d) {
-      fout->WriteTObject(fCH2d);
-    }
-    if (fVector2d) {
-      TString name("Nz");
-      name += fCalibraMode->GetNz(0);
-      name += "Nrphi";
-      name += fCalibraMode->GetNrphi(0);
-      TTree *treeCH2d = fCalibraVector->ConvertVectorCTTreeHisto(fCalibraVector->GetVectorCH(),fCalibraVector->GetPlaCH(),"treeCH2d",(const char *) name);
-      fout->WriteTObject(treeCH2d);
+      f.WriteTObject(fCH2d);
     }
   }
-  if ((fPH2dOn ) && (fWrite[1])) {
+  if (fPH2dOn ) {
     if (fHisto2d) {
-      fout->WriteTObject(fPH2d);
-    }
-    if (fVector2d) {
-      TString name("Nz");
-      name += fCalibraMode->GetNz(1);
-      name += "Nrphi";
-      name += fCalibraMode->GetNrphi(1);
-      TTree *treePH2d = fCalibraVector->ConvertVectorPTreeHisto(fCalibraVector->GetVectorPH(),fCalibraVector->GetPlaPH(),"treePH2d",(const char *) name);
-      fout->WriteTObject(treePH2d);
+      f.WriteTObject(fPH2d);
     }
   }
-  if ((fPRF2dOn ) && (fWrite[2])) {
+  if (fPRF2dOn) {
     if (fHisto2d) {
-      fout->WriteTObject(fPRF2d);
-    }
-    if (fVector2d) {
-      TString name("Nz");
-      name += fCalibraMode->GetNz(2);
-      name += "Nrphi";
-      name += fCalibraMode->GetNrphi(2);
-      TTree *treePRF2d = fCalibraVector->ConvertVectorPTreeHisto(fCalibraVector->GetVectorPRF(),fCalibraVector->GetPlaPRF(),"treePRF2d",(const char *) name);
-      fout->WriteTObject(treePRF2d);
+       f.WriteTObject(fPRF2d);
     }
   }
+  if(fLinearFitterOn){
+    AnalyseLinearFitter();
+    f.WriteTObject(fLinearVdriftFit);
+  }
+   
+  f.Close();
   
-  fout->Close();
+  if ( backup ) backup->cd();
   
   AliInfo(Form("Execution time Write2d: R:%.2fs C:%.2fs"
-             ,stopwatch.RealTime(),stopwatch.CpuTime()));
-
-  return kTRUE;
-  
+              ,stopwatch.RealTime(),stopwatch.CpuTime()));
 }
-
-//____________Probe the histos_________________________________________________
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Stats stuff
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//___________________________________________probe the histos__________________________________________________
 Double_t *AliTRDCalibraFillHisto::StatH(TH2 *h, Int_t i)
 {
   //
@@ -996,14 +3075,14 @@ Double_t *AliTRDCalibraFillHisto::StatH(TH2 *h, Int_t i)
   // [3] : maximal number of entries found
   // [4] : calibration group number of the max
   // [5] : mean number of entries found
-  // [6] : mean relativ error
+  // [6] : mean relative error
   //
 
   Double_t *info = new Double_t[7];
    
   // Number of Xbins (detectors or groups of pads)
-  Int_t    nbins   = h->GetNbinsX(); //number of calibration groups
-  Int_t    nybins  = h->GetNbinsY(); //number of bins per histo
+  Int_t    nbins   = h->GetNbinsY(); //number of calibration groups
+  Int_t    nxbins  = h->GetNbinsX(); //number of bins per histo
 
   // Initialise
   Double_t nbwe = 0; //number of calibration groups with entries
@@ -1017,29 +3096,28 @@ Double_t *AliTRDCalibraFillHisto::StatH(TH2 *h, Int_t i)
   Double_t counter = 0;
 
   //Debug
-  TH1F *NbEntries = 0x0;//distribution of the number of entries
-  TH1F *NbEntriesPerGroup = 0x0;//Number of entries per group
-  TProfile *NbEntriesPerSp = 0x0;//Number of entries for one supermodule
+  TH1F *nbEntries = 0x0;//distribution of the number of entries
+  TH1F *nbEntriesPerGroup = 0x0;//Number of entries per group
+  TProfile *nbEntriesPerSp = 0x0;//Number of entries for one supermodule
     
   // Beginning of the loop over the calibration groups 
   for (Int_t idect = 0; idect < nbins; idect++) {
 
-    TH1I *projch = (TH1I *) h->ProjectionY("projch",idect+1,idect+1,(Option_t *)"e");
+    TH1I *projch = (TH1I *) h->ProjectionX("projch",idect+1,idect+1,(Option_t *)"e");
     projch->SetDirectory(0);
     
     // Number of entries for this calibration group
     Double_t nentries = 0.0;
     if((i%2) == 0){
-      for (Int_t k = 0; k < nybins; k++) {
-       nentries += h->GetBinContent(h->GetBin(idect+1,k+1));
+      for (Int_t k = 0; k < nxbins; k++) {
+       nentries += h->GetBinContent(h->GetBin(k+1,idect+1));
       }
     }
     else{
-      for (Int_t k = 0; k < nybins; k++) {
-       nentries += ((TProfile2D *)h)->GetBinEntries(h->GetBin(idect+1,k+1));
-       if(h->GetBinContent(h->GetBin(idect+1,k+1)) != 0) {
-         meanrelativerror += (h->GetBinError(h->GetBin(idect+1,k+1))
-                            / (TMath::Abs(h->GetBinContent(h->GetBin(idect+1,k+1)))));
+      for (Int_t k = 0; k < nxbins; k++) {
+       nentries += ((TProfile2D *)h)->GetBinEntries(h->GetBin(k+1,idect+1));
+       if(h->GetBinContent(h->GetBin(k+1,idect+1)) != 0) {
+         meanrelativerror += (h->GetBinError(h->GetBin(k+1,idect+1))/(TMath::Abs(h->GetBinContent(h->GetBin(k+1,idect+1)))));
          counter++;
        } 
       }
@@ -1047,21 +3125,21 @@ Double_t *AliTRDCalibraFillHisto::StatH(TH2 *h, Int_t i)
 
     //Debug
     if(i > 1){
-      if((!((Bool_t)NbEntries)) && (nentries > 0)){
-       NbEntries = new TH1F("Number of entries","Number of entries"
+      if((!((Bool_t)nbEntries)) && (nentries > 0)){
+       nbEntries = new TH1F("Number of entries","Number of entries"
                                ,100,(Int_t)nentries/2,nentries*2);
-       NbEntries->SetDirectory(0);
-       NbEntriesPerGroup = new TH1F("Number of entries per group","Number of entries per group"
+       nbEntries->SetDirectory(0);
+       nbEntriesPerGroup = new TH1F("Number of entries per group","Number of entries per group"
                                ,nbins,0,nbins);
-       NbEntriesPerGroup->SetDirectory(0);
-       NbEntriesPerSp = new TProfile("Number of entries per supermodule","Number of entries per supermodule"
+       nbEntriesPerGroup->SetDirectory(0);
+       nbEntriesPerSp = new TProfile("Number of entries per supermodule","Number of entries per supermodule"
                                ,(Int_t)(nbins/18),0,(Int_t)(nbins/18));
-       NbEntriesPerSp->SetDirectory(0);
+       nbEntriesPerSp->SetDirectory(0);
       }
-      if(NbEntries){
-       if(nentries > 0) NbEntries->Fill(nentries);
-       NbEntriesPerGroup->Fill(idect+0.5,nentries);
-       NbEntriesPerSp->Fill((idect%((Int_t)(nbins/18)))+0.5,nentries);
+      if(nbEntries){
+       if(nentries > 0) nbEntries->Fill(nentries);
+       nbEntriesPerGroup->Fill(idect+0.5,nentries);
+       nbEntriesPerSp->Fill((idect%((Int_t)(nbins/18)))+0.5,nentries);
       }
     }
 
@@ -1082,7 +3160,6 @@ Double_t *AliTRDCalibraFillHisto::StatH(TH2 *h, Int_t i)
       nbwe++;
       meanstats += nentries;
     }
-
   }//calibration groups loop
   
   if(nbwe > 0) meanstats /= nbwe;
@@ -1112,93 +3189,120 @@ Double_t *AliTRDCalibraFillHisto::StatH(TH2 *h, Int_t i)
     TCanvas *stat = new TCanvas("stat","",50,50,600,800);
     stat->Divide(2,1);
     stat->cd(1);
-    NbEntries->Draw("");
+    nbEntries->Draw("");
     stat->cd(2);
-    NbEntriesPerSp->SetStats(0);
-    NbEntriesPerSp->Draw("");
+    nbEntriesPerSp->SetStats(0);
+    nbEntriesPerSp->Draw("");
     TCanvas *stat1 = new TCanvas("stat1","",50,50,600,800);
     stat1->cd();
-    NbEntriesPerGroup->SetStats(0);
-    NbEntriesPerGroup->Draw("");
+    nbEntriesPerGroup->SetStats(0);
+    nbEntriesPerGroup->Draw("");
   }
 
   return info;
 
 }
-
-//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::SetRelativeScale(Float_t RelativeScale)
+//____________________________________________________________________________
+Double_t *AliTRDCalibraFillHisto::GetMeanMedianRMSNumberCH()
 {
   //
-  // Set the factor that will divide the deposited charge
-  // to fit in the histo range [0,300]
+  // Return a Int_t[4] with:
+  // 0 Mean number of entries
+  // 1 median of number of entries
+  // 2 rms of number of entries
+  // 3 number of group with entries
   //
+
+  Double_t *stat      = new Double_t[4]; 
+  stat[3]             = 0.0;
+
+  Int_t    nbofgroups = CalculateTotalNumberOfBins(0);
+  Double_t *weight    = new Double_t[nbofgroups];
+  Int_t    *nonul     = new Int_t[nbofgroups];
  
-  if (RelativeScale > 0.0) {
-    fRelativeScale = RelativeScale;
-  } 
-  else {
-    AliInfo("RelativeScale must be strict positif!");
+  for(Int_t k = 0; k < nbofgroups; k++){
+    if(fEntriesCH[k] > 0) {
+      weight[k] = 1.0;
+      nonul[(Int_t)stat[3]] = fEntriesCH[k];
+      stat[3]++;
+    }
+    else weight[k] = 0.0;
   }
+  stat[0]          = TMath::Mean(nbofgroups,fEntriesCH,weight); 
+  stat[1]          = TMath::Median(nbofgroups,fEntriesCH,weight); 
+  stat[2]          = TMath::RMS((Int_t)stat[3],nonul); 
 
-} 
+  return stat;
 
-//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::SetNz(Int_t i, Short_t Nz)
+}
+//____________________________________________________________________________
+Double_t *AliTRDCalibraFillHisto::GetMeanMedianRMSNumberLinearFitter() const
 {
   //
-  // Set the mode of calibration group in the z direction for the parameter i
-  // 
+  // Return a Int_t[4] with:
+  // 0 Mean number of entries
+  // 1 median of number of entries
+  // 2 rms of number of entries
+  // 3 number of group with entries
+  //
 
-  if ((Nz >= 0) && 
-      (Nz <  5)) {
-    fCalibraMode->SetNz(i, Nz); 
-  }
-  else { 
-    AliInfo("You have to choose between 0 and 4");
-  }
+  Double_t *stat      = new Double_t[4]; 
+  stat[3]             = 0.0;
 
-}
+  Int_t    nbofgroups = 540;
+  Double_t *weight    = new Double_t[nbofgroups];
+  Int_t    *nonul     = new Int_t[nbofgroups]; 
 
-//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::SetNrphi(Int_t i, Short_t Nrphi)
-{
-  //
-  // Set the mode of calibration group in the rphi direction for the parameter i
-  //
-  if ((Nrphi >= 0) && 
-      (Nrphi <  7)) {
-    fCalibraMode->SetNrphi(i ,Nrphi); 
-  }
-  else {
-    AliInfo("You have to choose between 0 and 6");
+  for(Int_t k = 0; k < nbofgroups; k++){
+    if(fEntriesLinearFitter[k] > 0) {
+      weight[k] = 1.0;
+      nonul[(Int_t) stat[3]] = fEntriesLinearFitter[k];
+      stat[3]++;     
+    }
+    else weight[k] = 0.0;
   }
+  stat[0]          = TMath::Mean(nbofgroups,fEntriesLinearFitter,weight); 
+  stat[1]          = TMath::Median(nbofgroups,fEntriesLinearFitter,weight); 
+  stat[2]          = TMath::RMS((Int_t)stat[3],nonul); 
 
-}
-
-//____________Protected Functions______________________________________________
-//____________Create the 2D histo to be filled online__________________________
-//
+  return stat;
 
+}
+//////////////////////////////////////////////////////////////////////////////////////
+// Create Histos
+//////////////////////////////////////////////////////////////////////////////////////
 //_____________________________________________________________________________
 void AliTRDCalibraFillHisto::CreatePRF2d(Int_t nn)
 {
   //
-  // Create the 2D histos
+  // Create the 2D histos: here we have 2*fNgroupprf bins in tnp of 0.2 amplitude each
+  // If fNgroupprf is zero then no binning in tnp
   //
 
   TString name("Nz");
   name += fCalibraMode->GetNz(2);
   name += "Nrphi";
   name += fCalibraMode->GetNrphi(2);
+  name += "Ngp";
+  name += fNgroupprf;
 
-  fPRF2d = new TProfile2D("PRF2d",(const Char_t *) name
-                                 ,nn,0,nn,fNumberBinPRF,-1.5,1.5);
-  fPRF2d->SetXTitle("Det/pad groups");
-  fPRF2d->SetYTitle("Position x/W [pad width units]");
-  fPRF2d->SetZTitle("Q_{i}/Q_{total}");
-  fPRF2d->SetStats(0);
+  if(fNgroupprf != 0){
+    
+    fPRF2d = new TProfile2D("PRF2d",(const Char_t *) name
+                           ,2*fNgroupprf*fNumberBinPRF,-3.0*fNgroupprf,3.0*fNgroupprf,nn,0,nn);
+    fPRF2d->SetYTitle("Det/pad groups");
+    fPRF2d->SetXTitle("Position x/W [pad width units]");
+    fPRF2d->SetZTitle("Q_{i}/Q_{total}");
+    fPRF2d->SetStats(0);
+  }
+  else{
+    fPRF2d = new TProfile2D("PRF2d",(const Char_t *) name
+                           ,fNumberBinPRF,-1.5,1.5,nn,0,nn);
+    fPRF2d->SetYTitle("Det/pad groups");
+    fPRF2d->SetXTitle("Position x/W [pad width units]");
+    fPRF2d->SetZTitle("Q_{i}/Q_{total}");
+    fPRF2d->SetStats(0);
+  }
 
 }
 
@@ -1213,17 +3317,16 @@ void AliTRDCalibraFillHisto::CreatePH2d(Int_t nn)
   name += fCalibraMode->GetNz(1);
   name += "Nrphi";
   name += fCalibraMode->GetNrphi(1);
-
+  
   fPH2d = new TProfile2D("PH2d",(const Char_t *) name
-                               ,nn,0,nn,fTimeMax
-                               ,-0.5/fSf,(Float_t) (fTimeMax-0.5)/fSf);
-  fPH2d->SetXTitle("Det/pad groups");
-  fPH2d->SetYTitle("time [#mus]");
+                        ,fTimeMax,-0.5/fSf,(Float_t) (fTimeMax-0.5)/fSf
+                        ,nn,0,nn);
+  fPH2d->SetYTitle("Det/pad groups");
+  fPH2d->SetXTitle("time [#mus]");
   fPH2d->SetZTitle("<PH> [a.u.]");
   fPH2d->SetStats(0);
 
 }
-
 //_____________________________________________________________________________
 void AliTRDCalibraFillHisto::CreateCH2d(Int_t nn)
 {
@@ -1237,403 +3340,174 @@ void AliTRDCalibraFillHisto::CreateCH2d(Int_t nn)
   name += fCalibraMode->GetNrphi(0);
 
   fCH2d = new TH2I("CH2d",(const Char_t *) name
-                         ,nn,0,nn,fNumberBinCharge,0,300);
-  fCH2d->SetXTitle("Det/pad groups");
-  fCH2d->SetYTitle("charge deposit [a.u]");
+                  ,fNumberBinCharge,0,300,nn,0,nn);
+  fCH2d->SetYTitle("Det/pad groups");
+  fCH2d->SetXTitle("charge deposit [a.u]");
   fCH2d->SetZTitle("counts");
   fCH2d->SetStats(0);
   fCH2d->Sumw2();
 
 }
-
-//____________Offine tracking in the AliTRDtracker_____________________________
-void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackCH()
+//////////////////////////////////////////////////////////////////////////////////
+// Set relative scale
+/////////////////////////////////////////////////////////////////////////////////
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::SetRelativeScale(Float_t RelativeScale)
 {
   //
-  // For the offline tracking or mcm tracklets
-  // This function will be called in the functions UpdateHistogram... 
-  // to fill the info of a track for the relativ gain calibration
+  // Set the factor that will divide the deposited charge
+  // to fit in the histo range [0,300]
   //
-       
-  Int_t nb =  0; // Nombre de zones traversees
-  Int_t fd = -1; // Premiere zone non nulle
-  
-  
-  // See if the track goes through different zones
-  for (Int_t k = 0; k < fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0); k++) {
-    if (fAmpTotal[k] > 0.0) {
-      nb++;
-      if (nb == 1) {
-        fd = k;
-      }
-    }
-  }
  
-  // If automatic scale
-  if ((fCountRelativeScale < 100) && (fRelativeScaleAuto)) {
-    // Take only the one zone track
-    if (nb == 1) {
-      fRelativeScale += fAmpTotal[fd] * 0.014 * 0.01;
-      fCountRelativeScale++;
-    }
-  }
-
-  // We fill the CH2d after having scale with the first 100
-  if ((fCountRelativeScale >= 100) && (fRelativeScaleAuto)) {
-    // Case of track with only one zone
-    if (nb == 1) {
-      if (fHisto2d) {
-        fCH2d->Fill(fCalibraMode->GetXbins(0)+fd+0.5,fAmpTotal[fd]/fRelativeScale);
-      }
-      if (fVector2d) {
-        fCalibraVector->UpdateVectorCH(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
-      }
-    } // Case 1 zone
-    // Case of track with two zones
-    if (nb == 2) {
-      // Two zones voisines sinon rien!
-      if ((fAmpTotal[fd]   > 0.0) && 
-          (fAmpTotal[fd+1] > 0.0)) {
-       // One of the two very big
-       if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+1]) {
-         if (fHisto2d) {
-            fCH2d->Fill(fCalibraMode->GetXbins(0)+fd+0.5,fAmpTotal[fd]/fRelativeScale);
-         }
-         if (fVector2d) {
-            fCalibraVector->UpdateVectorCH(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
-         }
-       }
-       if (fAmpTotal[fd+1] > fProcent*fAmpTotal[fd])  {
-         if (fHisto2d) {
-            fCH2d->Fill(fCalibraMode->GetXbins(0)+fd+1.5,fAmpTotal[fd+1]/fRelativeScale);
-         }
-         if (fVector2d) {
-            fCalibraVector->UpdateVectorCH(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd+1]/fRelativeScale);
-         }
-       }
-      }
-    } // Case 2 zones
-  }
-
-  // Fill with no automatic scale
-  if (!fRelativeScaleAuto) {
-    // Case of track with only one zone
-    if (nb == 1) {
-      fNumberUsedCh[0]++;
-      if (fHisto2d) {
-        fCH2d->Fill(fCalibraMode->GetXbins(0)+fd+0.5,fAmpTotal[fd]/fRelativeScale);
-      }
-      if (fVector2d) {
-        fCalibraVector->UpdateVectorCH(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
-      }
-    } // Case 1 zone
-    // Case of track with two zones
-    if (nb == 2) {
-      // Two zones voisines sinon rien!
-      // Case 1
-      if ((fAmpTotal[fd]   > 0.0) && 
-          (fAmpTotal[fd+1] > 0.0)) {
-       // One of the two very big
-       if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+1]) {
-         if (fHisto2d) {
-            fCH2d->Fill(fCalibraMode->GetXbins(0)+fd+0.5,fAmpTotal[fd]/fRelativeScale);
-         }
-         if (fVector2d) {
-            fCalibraVector->UpdateVectorCH(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
-         }
-         fNumberUsedCh[1]++;
-       }
-       if (fAmpTotal[fd+1] > fProcent*fAmpTotal[fd]) {
-         if (fHisto2d) {
-            fCH2d->Fill(fCalibraMode->GetXbins(0)+fd+1.5,fAmpTotal[fd+1]/fRelativeScale);
-         }
-         if (fVector2d) {
-            fCalibraVector->UpdateVectorCH(fCalibraMode->GetXbins(0)+fd+1,fAmpTotal[fd+1]/fRelativeScale);
-         }
-         fNumberUsedCh[1]++;
-       }
-      }
-      // Case 2
-      if (fCalibraMode->GetNfragZ(0) > 1) {
-       if (fAmpTotal[fd] > 0.0) {
-         if ((fd+fCalibraMode->GetNfragZ(0)) < (fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0))) {
-           if (fAmpTotal[fd+fCalibraMode->GetNfragZ(0)] > 0.0) {
-             // One of the two very big
-             if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]) {
-               if (fHisto2d) {
-                  fCH2d->Fill(fCalibraMode->GetXbins(0)+fd+0.5,fAmpTotal[fd]/fRelativeScale);
-               }
-               if (fVector2d) {
-                  fCalibraVector->UpdateVectorCH(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
-               }
-               fNumberUsedCh[1]++;
-             }
-             if (fAmpTotal[fd+fCalibraMode->GetNfragZ(0)] > fProcent*fAmpTotal[fd]) {
-               if (fHisto2d) {
-                  fCH2d->Fill(fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)
-                            + 0.5,fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale);
-               }
-               fNumberUsedCh[1]++;
-               if (fVector2d) {
-                  fCalibraVector->UpdateVectorCH(fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)
-                                                ,fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale);
-               }
-             }
-           }
-         }
-       }
-      }
-    } // Case 2 zones
-
+  if (RelativeScale > 0.0) {
+    fRelativeScale = RelativeScale;
+  } 
+  else {
+    AliInfo("RelativeScale must be strict positif!");
   }
 
 }
-
-//____________Offine tracking in the AliTRDtracker_____________________________
-void AliTRDCalibraFillHisto::ResetfVariables()
+//////////////////////////////////////////////////////////////////////////////////
+// Quick way to fill a histo
+//////////////////////////////////////////////////////////////////////////////////
+//_____________________________________________________________________
+void  AliTRDCalibraFillHisto::FillCH2d(Int_t x, Float_t y)
 {
   //
-  // Reset values of fAmpTotal, fPHValue and fPHPlace for
-  // the updateHistogram... functions
-  //
-
-  // Reset the good track
-  fGoodTrack = kTRUE;
+  // FillCH2d: Marian style
+  // 
   
-  // Reset the fAmpTotal where we put value
-  if (fCH2dOn) {
-    for (Int_t k = 0; k < fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0); k++) {
-      fAmpTotal[k] = 0.0;
-    }
-  }
+  //skip simply the value out of range
+  if((y>=300.0) || (y<0.0)) return;
   
-  // Reset the fPHValue
-  if (fPH2dOn) {
-    for (Int_t k = 0; k < fTimeMax; k++) {
-      fPHValue[k] = 0.0;
-      fPHPlace[k] = -1;
-    }
-  }
+  //Calcul the y place
+  Int_t yplace = (Int_t) (fNumberBinCharge*y/300.0)+1;
+  Int_t place = (fNumberBinCharge+2)*(x+1)+yplace;
+  
+  //Fill
+  fCH2d->GetArray()[place]++;
 
 }
-
-//____________Offine tracking in the AliTRDtracker_____________________________
-void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackPH()
+//////////////////////////////////////////////////////////////////////////////////
+// Geometrical functions
+///////////////////////////////////////////////////////////////////////////////////
+//_____________________________________________________________________________
+Int_t AliTRDCalibraFillHisto::GetLayer(Int_t d) const
 {
   //
-  // For the offline tracking or mcm tracklets
-  // This function will be called in the functions UpdateHistogram... 
-  // to fill the info of a track for the drift velocity  calibration
+  // Reconstruct the layer number from the detector number
   //
-    
-  Int_t nb  =  1; // Nombre de zones traversees 1, 2 ou plus de 3
-  Int_t fd1 = -1; // Premiere zone non nulle
-  Int_t fd2 = -1; // Deuxieme zone non nulle
-  Int_t k1  = -1; // Debut de la premiere zone
-  Int_t k2  = -1; // Debut de la seconde zone
-
-  // See if the track goes through different zones
-  for (Int_t k = 0; k < fTimeMax; k++) {
-    if (fPHValue[k] > 0.0) {
-      if (fd1 == -1) {
-       fd1 = fPHPlace[k];
-       k1  = k;              
-      }
-      if (fPHPlace[k] != fd1) {
-       if (fd2 == -1) {
-         k2  = k;
-         fd2 = fPHPlace[k];
-         nb  = 2;
-       }
-       if (fPHPlace[k] != fd2) {
-          nb = 3;
-       }
-      }
-    }
-  }
-  
-  // Fill 
-  // Case of track with only one zone
-  if (nb == 1) {
-    fNumberUsedPh[0]++;
-    //fd1 is the only zone
-    for (Int_t i = 0; i < fTimeMax; i++) {
-      if (fHisto2d) {
-       fPH2d->Fill((fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) i/fSf,(Float_t) fPHValue[i]);
-      }
-      if (fVector2d) {
-       fCalibraVector->UpdateVectorPH((fCalibraMode->GetXbins(1)+fd1),i,fPHValue[i]);
-      }
-    }
-  } // Case 1 zone
-  // Case of track with two zones
-  if (nb == 2) {
-    // Two zones voisines sinon rien!
-    // Case 1
-    if ((fd1 == fd2+1) || 
-        (fd2 == fd1+1)) {
-      // One of the two fast all the think
-      if (k2 > (k1+fDifference)) {
-       //we choose to fill the fd1 with all the values
-       fNumberUsedPh[1]++;
-       for (Int_t i = 0; i < fTimeMax; i++) {
-         if (fHisto2d) {
-           fPH2d->Fill((fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) i/fSf,(Float_t) fPHValue[i]);
-         }
-         if (fVector2d) {
-           fCalibraVector->UpdateVectorPH((fCalibraMode->GetXbins(1)+fd1),i,fPHValue[i]);
-         }
-       }
-      }
-      if ((k2+fDifference) < fTimeMax) {
-       //we choose to fill the fd2 with all the values
-       fNumberUsedPh[1]++;
-       for (Int_t i = 0; i < fTimeMax; i++) {
-         if (fHisto2d) {
-           fPH2d->Fill((fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) i/fSf,(Float_t) fPHValue[i]);
-         }
-         if (fVector2d) {
-           fCalibraVector->UpdateVectorPH((fCalibraMode->GetXbins(1)+fd2),i,fPHValue[i]);
-         }
-       }
-      }
-    }
-    // Two zones voisines sinon rien!
-    if (fCalibraMode->GetNfragZ(1) > 1) {
-      // Case 2
-      if ((fd1+fCalibraMode->GetNfragZ(1)) < (fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1))) {
-       if (fd2 == (fd1+fCalibraMode->GetNfragZ(1))) {
-         // One of the two fast all the think
-         if (k2 > (k1+fDifference)) {
-           //we choose to fill the fd1 with all the values
-           fNumberUsedPh[1]++;
-           for (Int_t i = 0; i < fTimeMax; i++) {
-             if (fHisto2d) {
-               fPH2d->Fill((fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) i/fSf,(Float_t) fPHValue[i]);
-             }
-             if (fVector2d) {
-               fCalibraVector->UpdateVectorPH((fCalibraMode->GetXbins(1)+fd1),i,fPHValue[i]);
-             }
-           }
-         }
-         if ((k2+fDifference) < fTimeMax) {
-           //we choose to fill the fd2 with all the values
-           fNumberUsedPh[1]++;
-           for (Int_t i = 0; i < fTimeMax; i++) {
-             if (fHisto2d) {
-               fPH2d->Fill((fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) i/fSf,(Float_t) fPHValue[i]);
-             }
-             if (fVector2d) {
-               fCalibraVector->UpdateVectorPH((fCalibraMode->GetXbins(1)+fd2),i,fPHValue[i]);
-             }
-           }
-         }
-       }
-      }
-      // Two zones voisines sinon rien!
-      // Case 3
-      if ((fd1 - fCalibraMode->GetNfragZ(1)) >= 0) {
-       if (fd2 == (fd1 - fCalibraMode->GetNfragZ(1))) {
-         // One of the two fast all the think
-         if (k2 > (k1 + fDifference)) {
-           //we choose to fill the fd1 with all the values
-           fNumberUsedPh[1]++;
-           for (Int_t i = 0; i < fTimeMax; i++) {
-             if (fHisto2d) {
-               fPH2d->Fill((fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) i/fSf,(Float_t) fPHValue[i]);
-             }
-             if (fVector2d) {
-               fCalibraVector->UpdateVectorPH((fCalibraMode->GetXbins(1)+fd1),i,fPHValue[i]);
-             }
-           }
-         }
-         if ((k2+fDifference) < fTimeMax) {
-           //we choose to fill the fd2 with all the values
-           fNumberUsedPh[1]++;
-           for (Int_t i = 0; i < fTimeMax; i++) {
-             if (fHisto2d) {
-               fPH2d->Fill((fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) i/fSf,(Float_t) fPHValue[i]);
-             }
-             if (fVector2d) {
-               fCalibraVector->UpdateVectorPH((fCalibraMode->GetXbins(1)+fd2),i,fPHValue[i]);
-             }
-           }
-         }
-       }
-      }
-    }
 
-  } // case 2 zones
+  return ((Int_t) (d % 6));
 
 }
 
-//____________Set the pad calibration variables for the detector_______________
-Bool_t AliTRDCalibraFillHisto::LocalisationDetectorXbins(Int_t detector)
+//_____________________________________________________________________________
+Int_t AliTRDCalibraFillHisto::GetStack(Int_t d) const
 {
   //
-  // For the detector calcul the first Xbins and set the number of row
-  // and col pads per calibration groups, the number of calibration
-  // groups in the detector.
+  // Reconstruct the stack number from the detector number
   //
-  
-  // first Xbins of the detector
-  if (fCH2dOn) {
-    fCalibraMode->CalculXBins(detector,0);
-  }
-  if (fPH2dOn) {
-    fCalibraMode->CalculXBins(detector,1);
-  }
-  if (fPRF2dOn) {
-    fCalibraMode->CalculXBins(detector,2);
-  }
+  const Int_t kNlayer = 6;
 
-  // fragmentation of idect
-  for (Int_t i = 0; i < 3; i++) {
-    fCalibraMode->ModePadCalibration((Int_t) GetChamber(detector),i);
-    fCalibraMode->ModePadFragmentation((Int_t) GetPlane(detector)
-                       , (Int_t) GetChamber(detector)
-                       , (Int_t) GetSector(detector),i);
-  }
-  
-  return kTRUE;
+  return ((Int_t) (d % 30) / kNlayer);
 
 }
 
-//
-//____________Some basic geometry function_____________________________________
-//
-
 //_____________________________________________________________________________
-Int_t AliTRDCalibraFillHisto::GetPlane(Int_t d) const
+Int_t AliTRDCalibraFillHisto::GetSector(Int_t d) const
 {
   //
-  // Reconstruct the plane number from the detector number
+  // Reconstruct the sector number from the detector number
   //
+  Int_t fg = 30;
 
-  return ((Int_t) (d % 6));
+  return ((Int_t) (d / fg));
+
+}
+///////////////////////////////////////////////////////////////////////////////////
+// Getter functions for DAQ of the CH2d and the PH2d
+//////////////////////////////////////////////////////////////////////////////////
+//_____________________________________________________________________
+TProfile2D* AliTRDCalibraFillHisto::GetPH2d(Int_t nbtimebin, Float_t samplefrequency)
+{
+    //
+    // return pointer to fPH2d TProfile2D
+    // create a new TProfile2D if it doesn't exist allready
+    //
+    if ( fPH2d )
+       return fPH2d;
+
+    // Some parameters
+    fTimeMax = nbtimebin;
+    fSf      = samplefrequency;
+  
+    CreatePH2d(540);
 
+    return fPH2d;
 }
+//_____________________________________________________________________
+TH2I* AliTRDCalibraFillHisto::GetCH2d()
+{
+    //
+    // return pointer to fCH2d TH2I
+    // create a new TH2I if it doesn't exist allready
+    //
+    if ( fCH2d )
+        return fCH2d;
 
-//_____________________________________________________________________________
-Int_t AliTRDCalibraFillHisto::GetChamber(Int_t d) const
+    CreateCH2d(540);
+
+    return fCH2d;
+}
+////////////////////////////////////////////////////////////////////////////////////////////
+// Drift velocity calibration
+///////////////////////////////////////////////////////////////////////////////////////////
+//_____________________________________________________________________
+TLinearFitter* AliTRDCalibraFillHisto::GetLinearFitter(Int_t detector, Bool_t force)
 {
-  //
-  // Reconstruct the chamber number from the detector number
-  //
-  Int_t fgkNplan = 6;
+    //
+    // return pointer to TLinearFitter Calibration
+    // if force is true create a new TLinearFitter if it doesn't exist allready
+    //
+
+  if ((!force) || (fLinearFitterArray.UncheckedAt(detector))){
+    return (TLinearFitter*)fLinearFitterArray.UncheckedAt(detector);
+  }
 
-  return ((Int_t) (d % 30) / fgkNplan);
+  // if we are forced and TLinearFitter doesn't yet exist create it
 
+  // new TLinearFitter
+  TLinearFitter *linearfitter = new TLinearFitter(2,"pol1");
+  fLinearFitterArray.AddAt(linearfitter,detector);
+  return linearfitter;
 }
 
-//_____________________________________________________________________________
-Int_t AliTRDCalibraFillHisto::GetSector(Int_t d) const
+//____________________________________________________________________________
+void AliTRDCalibraFillHisto::AnalyseLinearFitter()
 {
   //
-  // Reconstruct the sector number from the detector number
+  // Analyse array of linear fitter because can not be written
+  // Store two arrays: one with the param the other one with the error param + number of entries
   //
-  Int_t fg = 30;
-
-  return ((Int_t) (d / fg));
 
+  for(Int_t k = 0; k < 540; k++){
+    TLinearFitter *linearfitter = GetLinearFitter(k);
+    if((linearfitter!=0) && (fEntriesLinearFitter[k]>10)){
+      TVectorD  *par  = new TVectorD(2);
+      TVectorD   pare = TVectorD(2);
+      TVectorD  *parE = new TVectorD(3);
+      linearfitter->Eval();
+      linearfitter->GetParameters(*par);
+      linearfitter->GetErrors(pare);
+      Float_t  ppointError =  TMath::Sqrt(TMath::Abs(linearfitter->GetChisquare())/fEntriesLinearFitter[k]);
+      (*parE)[0] = pare[0]*ppointError;
+      (*parE)[1] = pare[1]*ppointError;
+      (*parE)[2] = (Double_t) fEntriesLinearFitter[k];
+      ((TObjArray *)fLinearVdriftFit->GetPArray())->AddAt(par,k);
+      ((TObjArray *)fLinearVdriftFit->GetEArray())->AddAt(parE,k);
+    }
+  }
 }
+