ROOT logo
/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

/////////////////////////////////////////////////////////////////////////////////
//                                                                             
// AliTRDCalibraFit                                                               
//                                                                             
// This class is for the TRD calibration of the relative gain factor, the drift velocity,
// the time 0 and the pad response function. It fits the histos.       
// The 2D histograms or vectors (first converted in 1D histos) will be fitted  
// if they have enough entries, otherwise the (default) value of the choosen database 
// will be put. For the relative gain calibration the resulted factors will be globally 
// normalized to the gain factors of the choosen database. It unables to precise     
// previous calibration procedure.
// The function SetDebug enables the user to see:                                     
// _fDebug = 0: nothing, only the values are written in the tree if wanted
// _fDebug = 1: only the fit of the choosen calibration group fFitVoir (SetFitVoir)
// _fDebug = 2: a comparaison of the coefficients found and the default values 
//              in the choosen database.
//              fCoef , histogram of the coefs as function of the calibration group number
//              fDelta , histogram of the relative difference of the coef with the default
//                        value in the database as function of the calibration group number
//              fError , dirstribution of this relative difference
// _fDebug = 3: The coefficients in the choosen detector fDet (SetDet) as function of the
//              pad row and col number
// _fDebug = 4; The coeffcicients in the choosen detector fDet (SetDet) like in the 3 but with
//              also the comparaison histograms of the 1 for this detector
//
//                            
// Author:
//   R. Bailhache (R.Bailhache@gsi.de)
//                            
//////////////////////////////////////////////////////////////////////////////////////

#include <TLine.h>
#include <TH1I.h>
#include <TStyle.h>
#include <TProfile2D.h>
#include <TCanvas.h>
#include <TGraphErrors.h>
#include <TObjArray.h>
#include <TH1.h>
#include <TH1F.h>
#include <TF1.h>
#include <TAxis.h>
#include <TMath.h>
#include <TDirectory.h>
#include <TTreeStream.h>
#include <TLinearFitter.h>
#include <TVectorD.h>
#include <TROOT.h>
#include <TString.h>
#include <TLine.h>

#include "AliLog.h"
#include "AliMathBase.h"

#include "AliTRDCalibraFit.h"
#include "AliTRDCalibraMode.h"
#include "AliTRDCalibraVector.h"
#include "AliTRDCalibraVdriftLinearFit.h"
#include "AliTRDCalibraExbAltFit.h"
#include "AliTRDcalibDB.h"
#include "AliTRDgeometry.h"
#include "AliTRDpadPlane.h"
#include "AliTRDgeometry.h"
#include "AliTRDCommonParam.h"
#include "./Cal/AliTRDCalROC.h"
#include "./Cal/AliTRDCalPad.h"
#include "./Cal/AliTRDCalDet.h"


ClassImp(AliTRDCalibraFit)

AliTRDCalibraFit* AliTRDCalibraFit::fgInstance = 0;
Bool_t AliTRDCalibraFit::fgTerminated = kFALSE;

//_____________singleton implementation_________________________________________________
AliTRDCalibraFit *AliTRDCalibraFit::Instance()
{
  //
  // Singleton implementation
  //

  if (fgTerminated != kFALSE) {
    return 0;
  }

  if (fgInstance == 0) {
    fgInstance = new AliTRDCalibraFit();
  }

  return fgInstance;

}
//______________________________________________________________________________________
void AliTRDCalibraFit::Terminate()
{
  //
  // Singleton implementation
  // Deletes the instance of this class
  //

  fgTerminated = kTRUE;

  if (fgInstance != 0) {
    delete fgInstance;
    fgInstance = 0;
  }

}
//______________________________________________________________________________________
AliTRDCalibraFit::AliTRDCalibraFit()
  :TObject()
  ,fGeo(0)
  ,fNumberOfBinsExpected(0)
  ,fMethod(0)
  ,fBeginFitCharge(3.5)
  ,fOutliersFitChargeLow(0.03)
  ,fOutliersFitChargeHigh(0.80)
  ,fFitPHPeriode(1)
  ,fTakeTheMaxPH(kTRUE)
  ,fT0Shift0(0.124797)
  ,fT0Shift1(0.267451)
  ,fRangeFitPRF(1.0)
  ,fAccCDB(kFALSE)
  ,fMinEntries(800)
  ,fRebin(1)
  ,fScaleGain(0.02431)
  ,fNumberFit(0)
  ,fNumberFitSuccess(0)
  ,fNumberEnt(0)
  ,fStatisticMean(0.0)
  ,fDebugStreamer(0x0)
  ,fDebugLevel(0)
  ,fFitVoir(0)
  ,fMagneticField(0.5)
  ,fCalibraMode(new AliTRDCalibraMode())
  ,fCurrentCoefE(0.0)
  ,fCurrentCoefE2(0.0)
  ,fDect1(0)
  ,fDect2(0)
  ,fScaleFitFactor(0.0)
  ,fEntriesCurrent(0)
  ,fCountDet(0)
  ,fCount(0)
  ,fNbDet(0)
  ,fCalDet(0x0)
  ,fCalROC(0x0)
  ,fCalDet2(0x0)
  ,fCalROC2(0x0)
  ,fCalDetVdriftUsed(0x0)
  ,fCalDetExBUsed(0x0)
  ,fCurrentCoefDetector(0x0)
  ,fCurrentCoefDetector2(0x0)
  ,fVectorFit(0)
  ,fVectorFit2(0)
{
  //
  // Default constructor
  //

  fGeo         = new AliTRDgeometry();  
 
  // Current variables initialised
  for (Int_t k = 0; k < 2; k++) {
    fCurrentCoef[k]  = 0.0;
    fCurrentCoef2[k] = 0.0;
  }
  for (Int_t i = 0; i < 3; i++) {
    fPhd[i]          = 0.0;
    fDet[i]          = 0;
  }
 
}
//______________________________________________________________________________________
AliTRDCalibraFit::AliTRDCalibraFit(const AliTRDCalibraFit &c)
:TObject(c)
,fGeo(0)
,fNumberOfBinsExpected(c.fNumberOfBinsExpected)
,fMethod(c.fMethod)
,fBeginFitCharge(c.fBeginFitCharge)
,fOutliersFitChargeLow(c.fOutliersFitChargeLow)
,fOutliersFitChargeHigh(c.fOutliersFitChargeHigh)
,fFitPHPeriode(c.fFitPHPeriode)
,fTakeTheMaxPH(c.fTakeTheMaxPH)
,fT0Shift0(c.fT0Shift0)
,fT0Shift1(c.fT0Shift1)
,fRangeFitPRF(c.fRangeFitPRF)
,fAccCDB(c.fAccCDB)
,fMinEntries(c.fMinEntries)
,fRebin(c.fRebin)
,fScaleGain(c.fScaleGain)
,fNumberFit(c.fNumberFit)
,fNumberFitSuccess(c.fNumberFitSuccess)
,fNumberEnt(c.fNumberEnt)
,fStatisticMean(c.fStatisticMean)
,fDebugStreamer(0x0)
,fDebugLevel(c.fDebugLevel)
,fFitVoir(c.fFitVoir)
,fMagneticField(c.fMagneticField)
,fCalibraMode(0x0)
,fCurrentCoefE(c.fCurrentCoefE)
,fCurrentCoefE2(c.fCurrentCoefE2)
,fDect1(c.fDect1)
,fDect2(c.fDect2)
,fScaleFitFactor(c.fScaleFitFactor)
,fEntriesCurrent(c.fEntriesCurrent)
,fCountDet(c.fCountDet)
,fCount(c.fCount)
,fNbDet(c.fNbDet)
,fCalDet(0x0)
,fCalROC(0x0)
,fCalDet2(0x0)
,fCalROC2(0x0)
,fCalDetVdriftUsed(0x0)
,fCalDetExBUsed(0x0)
,fCurrentCoefDetector(0x0)
,fCurrentCoefDetector2(0x0)
,fVectorFit(0)
,fVectorFit2(0)
{
  //
  // Copy constructor
  //

  if(c.fCalibraMode)   fCalibraMode = new AliTRDCalibraMode(*c.fCalibraMode);
 
  //Current variables initialised
  for (Int_t k = 0; k < 2; k++) {
    fCurrentCoef[k]  = 0.0;
    fCurrentCoef2[k] = 0.0;
  }
  for (Int_t i = 0; i < 3; i++) {
    fPhd[i]          = 0.0;
    fDet[i]          = 0;
  }
  if(c.fCalDet) fCalDet   = new AliTRDCalDet(*c.fCalDet);
  if(c.fCalDet2) fCalDet2 = new AliTRDCalDet(*c.fCalDet2);
  
  if(c.fCalROC) fCalROC   = new AliTRDCalROC(*c.fCalROC);
  if(c.fCalROC2) fCalROC  = new AliTRDCalROC(*c.fCalROC2);

  if(c.fCalDetVdriftUsed) fCalDetVdriftUsed = new AliTRDCalDet(*c.fCalDetVdriftUsed);
  if(c.fCalDetExBUsed)    fCalDetExBUsed = new AliTRDCalDet(*c.fCalDetExBUsed);

  fVectorFit.SetName(c.fVectorFit.GetName());
  for(Int_t k = 0; k < c.fVectorFit.GetEntriesFast(); k++){
    AliTRDFitInfo *fitInfo = new AliTRDFitInfo();
    Int_t detector         = ((AliTRDFitInfo *)c.fVectorFit.UncheckedAt(k))->GetDetector();
    Int_t ntotal = 1;
    if (GetStack(detector) == 2) {
      ntotal = 1728;
    }
    else {
      ntotal = 2304;
    }
    Float_t *coef = new Float_t[ntotal];
    for (Int_t i = 0; i < ntotal; i++) {
      coef[i] = ((AliTRDFitInfo *)c.fVectorFit.UncheckedAt(k))->GetCoef()[i];
    }
    fitInfo->SetCoef(coef);
    fitInfo->SetDetector(detector);
    fVectorFit.Add((TObject *) fitInfo);
  }
  fVectorFit.SetName(c.fVectorFit.GetName());
  for(Int_t k = 0; k < c.fVectorFit2.GetEntriesFast(); k++){
    AliTRDFitInfo *fitInfo = new AliTRDFitInfo();
    Int_t detector         = ((AliTRDFitInfo *)c.fVectorFit2.UncheckedAt(k))->GetDetector();
    Int_t ntotal = 1;
    if (GetStack(detector) == 2) {
      ntotal = 1728;
    }
    else {
      ntotal = 2304;
    }
    Float_t *coef = new Float_t[ntotal];
    for (Int_t i = 0; i < ntotal; i++) {
      coef[i] = ((AliTRDFitInfo *)c.fVectorFit2.UncheckedAt(k))->GetCoef()[i];
    }
    fitInfo->SetCoef(coef);
    fitInfo->SetDetector(detector);
    fVectorFit2.Add((TObject *) fitInfo);
  }
  if (fGeo) {
    delete fGeo;
  }
  fGeo = new AliTRDgeometry();

}
//____________________________________________________________________________________
AliTRDCalibraFit::~AliTRDCalibraFit()
{
  //
  // AliTRDCalibraFit destructor
  //
  if ( fDebugStreamer ) delete fDebugStreamer;
  if ( fCalDet )  delete fCalDet;
  if ( fCalDet2 ) delete fCalDet2;
  if ( fCalROC )  delete fCalROC;
  if ( fCalROC2 ) delete fCalROC2;
  if ( fCalDetVdriftUsed)  delete fCalDetVdriftUsed;
  if ( fCalDetExBUsed) delete fCalDetExBUsed;
  if( fCurrentCoefDetector ) delete [] fCurrentCoefDetector;
  if( fCurrentCoefDetector2 ) delete [] fCurrentCoefDetector2; 
  fVectorFit.Delete();
  fVectorFit2.Delete();
  if (fGeo) {
    delete fGeo;
  }

}
//_____________________________________________________________________________
void AliTRDCalibraFit::Destroy() 
{
  //
  // Delete instance 
  //

  if (fgInstance) {
    delete fgInstance;
    fgInstance = 0x0;
  }

}
//_____________________________________________________________________________
void AliTRDCalibraFit::DestroyDebugStreamer() 
{
  //
  // Delete DebugStreamer
  //

  if ( fDebugStreamer ) delete fDebugStreamer;
  fDebugStreamer = 0x0;
 
}
//____________Functions fit Online CH2d________________________________________
Bool_t AliTRDCalibraFit::AnalyseCH(const TH2I *ch)
{
  //
  // Fit the 1D histos, projections of the 2D ch on the Xaxis, for each
  // calibration group normalized the resulted coefficients (to 1 normally)
  //

  // Set the calibration mode
  //const char *name = ch->GetTitle();
  TString name = ch->GetTitle();
  if(!SetModeCalibration(name,0)) return kFALSE;

  // Number of Ybins (detectors or groups of pads)
  Int_t    nbins   = ch->GetNbinsX();// charge
  Int_t    nybins  = ch->GetNbinsY();// groups number
  if (!InitFit(nybins,0)) {
    return kFALSE;
  }
  if (!InitFitCH()) {
    return kFALSE;
  }
  fStatisticMean        = 0.0;
  fNumberFit            = 0;
  fNumberFitSuccess     = 0;
  fNumberEnt            = 0;
  // Init fCountDet and fCount
  InitfCountDetAndfCount(0);
  // Beginning of the loop betwwen dect1 and dect2
  for (Int_t idect = fDect1; idect < fDect2; idect++) {
    // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi...
    UpdatefCountDetAndfCount(idect,0);
    ReconstructFitRowMinRowMax(idect, 0);
    // Take the histo
    TH1I *projch = (TH1I *) ch->ProjectionX("projch",idect+1,idect+1,(Option_t *)"e");
    projch->SetDirectory(0);
    // Number of entries for this calibration group
    Double_t nentries = 0.0;
    Double_t mean = 0.0;
    for (Int_t k = 0; k < nbins; k++) {
      Int_t binnb = (nbins+2)*(idect+1)+(k+1);
      nentries += ch->GetBinContent(binnb);
      mean += projch->GetBinCenter(k+1)*projch->GetBinContent(k+1);
      projch->SetBinError(k+1,TMath::Sqrt(projch->GetBinContent(k+1)));
    }
    projch->SetEntries(nentries);
    //printf("The number of entries for the group %d is %f\n",idect,nentries);
    if (nentries > 0) {
      fNumberEnt++;
      mean /= nentries;
    }
    // Rebin and statistic stuff
    if (fRebin > 1) {
      projch = ReBin((TH1I *) projch);
    }
    // This detector has not enough statistics or was off
    if (nentries <= fMinEntries) {
      NotEnoughStatisticCH(idect);
      if (fDebugLevel != 1) {
	delete projch;
      }
      continue;
    }
    // Statistics of the group fitted
    fStatisticMean += nentries;
    fNumberFit++;
    //Method choosen
    switch(fMethod)
      {
      case 0: FitMeanW((TH1 *) projch, nentries); break;
      case 1: FitMean((TH1 *) projch, nentries, mean); break;
      case 2: FitLandau((TH1 *) projch, mean, nentries); break;
      case 3: FitCH((TH1 *) projch, mean, nentries); break;
      case 4: FitBisCH((TH1 *) projch, mean, nentries); break;
      case 5: FitBisCHEx((TH1 *) projch, mean, nentries); break;
      default: return kFALSE;
      }
    // Fill Infos Fit
    FillInfosFitCH(idect);
    // Memory!!!
    if (fDebugLevel != 1) {
      delete projch;
    }
  } // Boucle object
  // Normierungcharge
  if (fDebugLevel != 1) {
    NormierungCharge();
  }
  // Mean Statistic
  if (fNumberFit > 0) {
    AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %f over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Double_t) (fStatisticMean/fNumberFit), fNumberFitSuccess));
    fStatisticMean = fStatisticMean / fNumberFit;
  }
  else {
    AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
  }
  delete fDebugStreamer;
  fDebugStreamer = 0x0;

  return kTRUE;
}
//____________Functions fit Online CH2d________________________________________
Bool_t AliTRDCalibraFit::AnalyseCH(AliTRDCalibraVector *calvect)
{
  //
  // Reconstruct a 1D histo from the vectorCH for each calibration group,
  // fit the histo, normalized the resulted coefficients (to 1 normally)
  //

  // Set the calibraMode
  //const char *name = calvect->GetNameCH();
  TString name = calvect->GetNameCH();
  if(!SetModeCalibration(name,0)) return kFALSE;  

  // Number of Xbins (detectors or groups of pads)
  if (!InitFit((432*calvect->GetDetCha0(0)+108*calvect->GetDetCha2(0)),0)) {
    return kFALSE;
  }
  if (!InitFitCH()) {
    return kFALSE;
  }
  fStatisticMean        = 0.0;
  fNumberFit            = 0;
  fNumberFitSuccess     = 0;
  fNumberEnt            = 0;
  // Init fCountDet and fCount
  InitfCountDetAndfCount(0);
  // Beginning of the loop between dect1 and dect2
  for (Int_t idect = fDect1; idect < fDect2; idect++) {
    // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi...........
    UpdatefCountDetAndfCount(idect,0);
    ReconstructFitRowMinRowMax(idect,0);
    // Take the histo
    Double_t nentries = 0.0;
    Double_t mean = 0.0;
    if(!calvect->GetCHEntries(fCountDet)) {
      NotEnoughStatisticCH(idect);
      continue;
    }
    
    TString tname("CH");
    tname += idect;
    TH1F *projch  = calvect->ConvertVectorCHHisto(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0)))),(const char *) tname);
    projch->SetDirectory(0);
    for (Int_t k = 0; k < calvect->GetNumberBinCharge(); k++) {
      nentries += projch->GetBinContent(k+1);
      mean += projch->GetBinCenter(k+1)*projch->GetBinContent(k+1);
    }
    if (nentries > 0) {
      fNumberEnt++;
      mean /= nentries;
    }
    //printf("The number of entries for the group %d is %f\n",idect,nentries);
    // Rebin
    if (fRebin >  1) {
      projch = ReBin((TH1F *) projch);
    }
    // This detector has not enough statistics or was not found in VectorCH
    if (nentries <= fMinEntries) {
      NotEnoughStatisticCH(idect);
      continue;
    }
    // Statistic of the histos fitted
    fStatisticMean += nentries;
    fNumberFit++;
    //Method choosen
    switch(fMethod)
      {
      case 0: FitMeanW((TH1 *) projch, nentries); break;
      case 1: FitMean((TH1 *) projch, nentries, mean); break;
      case 2: FitLandau((TH1 *) projch, mean, nentries); break;
      case 3: FitCH((TH1 *) projch, mean, nentries); break;
      case 4: FitBisCH((TH1 *) projch, mean, nentries); break;
      case 5: FitBisCHEx((TH1 *) projch, mean, nentries); break;
      default: return kFALSE;
      }
    // Fill Infos Fit
    FillInfosFitCH(idect); 
  } // Boucle object
  // Normierungcharge
  if (fDebugLevel != 1) {
    NormierungCharge();
  }
  // Mean Statistics
  if (fNumberFit > 0) {
    AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %f over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Double_t) (fStatisticMean/fNumberFit), fNumberFitSuccess));
    fStatisticMean = fStatisticMean / fNumberFit;
  }
  else {
    AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
  }
  delete fDebugStreamer;
  fDebugStreamer = 0x0;
  return kTRUE;
}
//____________Functions fit Online CH2d________________________________________
Double_t AliTRDCalibraFit::AnalyseCHAllTogether(const TH2I *ch)
{
  //
  // Fit the 1D histos, projections of the 2D ch on the Xaxis, for each
  // calibration group normalized the resulted coefficients (to 1 normally)
  //
  Int_t    nbins   = ch->GetNbinsX();// charge
  Int_t    nybins  = ch->GetNbinsY();// groups number
  // Take the histo
  TH1I *projch = (TH1I *) ch->ProjectionX("projch",1,nybins+1,(Option_t *)"e");
  projch->SetDirectory(0);
  // Number of entries for this calibration group
  Double_t nentries = 0.0;
  Double_t mean = 0.0;
  for (Int_t k = 0; k < nbins; k++) {
    nentries += projch->GetBinContent(k+1);
    mean += projch->GetBinCenter(k+1)*projch->GetBinContent(k+1);
    projch->SetBinError(k+1,TMath::Sqrt(projch->GetBinContent(k+1)));
  }
  projch->SetEntries(nentries);
  //printf("The number of entries for the group %d is %f\n",idect,nentries);
  if (nentries > 0) {
    mean /= nentries;
  }
  // This detector has not enough statistics or was off
  if (nentries <= fMinEntries) {
    delete projch;
    AliInfo(Form("There are %d entries for all together, it is not enough (%d)",(Int_t) nentries, fMinEntries));
    return -100.0;
  }
  //Method choosen
  switch(fMethod)
    {
    case 0: FitMeanW((TH1 *) projch, nentries); break;
    case 1: FitMean((TH1 *) projch, nentries, mean); break;
    case 2: FitLandau((TH1 *) projch, mean, nentries); break;
    case 3: FitCH((TH1 *) projch, mean, nentries); break;
    case 4: FitBisCH((TH1 *) projch, mean, nentries); break;
    case 5: FitBisCHEx((TH1 *) projch, mean, nentries); break;
    default: return -100.0;
    }
  delete fDebugStreamer;
  fDebugStreamer = 0x0;
  
  if(fCurrentCoef[0] > 0.0) return fCurrentCoef[0];
  else return -100.0;
  
}
//________________functions fit Online PH2d____________________________________
Double_t AliTRDCalibraFit::AnalysePHAllTogether(const TProfile2D *ph)
{
  //
  // Take the 1D profiles (average pulse height), projections of the 2D PH
  // on the Xaxis, for each calibration group
  // Reconstruct a drift velocity
  // A first calibration of T0 is also made  using the same method
  //

  // Number of Xbins (detectors or groups of pads)
  Int_t    nbins   = ph->GetNbinsX();// time
  Int_t    nybins  = ph->GetNbinsY();// calibration group
 
  // Take the histo
  TH1D *projph = (TH1D *) ph->ProjectionX("projph",1,nybins+1,(Option_t *) "e");
  projph->SetDirectory(0); 
  // Number of entries for this calibration group
  Double_t nentries = 0;
  for(Int_t idect = 0; idect < nybins; idect++){
    for (Int_t k = 0; k < nbins; k++) {
      Int_t binnb = (nbins+2)*(idect+1)+(k+1);
      nentries += ph->GetBinEntries(binnb);
    }
  }
  //printf("AnalysePHAllTogether:: the number of entries is %f\n",nentries);
  // This detector has not enough statistics or was off
  if (nentries  <= fMinEntries) {
    AliInfo(Form("There are %d entries for all together, it is not enough (%d)",(Int_t) nentries, fMinEntries));
    if (fDebugLevel != 1) {
      delete projph;
    }
    return -100.0;
  }
  //Method choosen
  //printf("Method\n");
  switch(fMethod)
    {
    case 0: FitLagrangePoly((TH1 *) projph); break;
    case 1: FitPente((TH1 *) projph); break;
    case 2: FitPH((TH1 *) projph,0); break;
    default: return -100.0;
    }
  // Memory!!!
  if (fDebugLevel != 1) {
    delete projph;
  }
  delete fDebugStreamer;
  fDebugStreamer = 0x0;
  
  if(fCurrentCoef[0] > 0.0) return fCurrentCoef[0];
  else return -100.0;
  
}
//____________Functions fit Online PH2d________________________________________
Bool_t AliTRDCalibraFit::AnalysePH(AliTRDCalibraVector *calvect)
{
  //
  // Reconstruct the average pulse height from the vectorPH for each
  // calibration group
  // Reconstruct a drift velocity
  // A first calibration of T0 is also made  using the same method (slope method)
  //

  // Set the calibration mode
  //const char *name = calvect->GetNamePH();
  TString name = calvect->GetNamePH();
  if(!SetModeCalibration(name,1)) return kFALSE;

  // Number of Xbins (detectors or groups of pads)
  if (!InitFit((432*calvect->GetDetCha0(1)+108*calvect->GetDetCha2(1)),1)) {
    return kFALSE;
  }
  if (!InitFitPH()) {
    return kFALSE;
  }
  fStatisticMean        = 0.0;
  fNumberFit            = 0;
  fNumberFitSuccess     = 0;
  fNumberEnt            = 0;
  // Init fCountDet and fCount
  InitfCountDetAndfCount(1);
  // Beginning of the loop
  for (Int_t idect = fDect1; idect < fDect2; idect++) {
    // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi...........
    UpdatefCountDetAndfCount(idect,1);
    ReconstructFitRowMinRowMax(idect,1);
    // Take the histo
    fEntriesCurrent = 0;
    if(!calvect->GetPHEntries(fCountDet)) {
      NotEnoughStatisticPH(idect,fEntriesCurrent);
      continue;
    }
    TString tname("PH");
    tname += idect;
    TH1F *projph  = calvect->CorrectTheError((TGraphErrors *) (calvect->ConvertVectorPHTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) tname)),fEntriesCurrent);
    projph->SetDirectory(0);
    if(fEntriesCurrent > 0) fNumberEnt++;
    //printf("The number of entries for the group %d is %d\n",idect,fEntriesCurrent);
    // This detector has not enough statistics or was off
    if (fEntriesCurrent <=  fMinEntries) {
      //printf("Not enough stat!\n");
      NotEnoughStatisticPH(idect,fEntriesCurrent);
      continue;
    }
    // Statistic of the histos fitted
    fNumberFit++;
    fStatisticMean += fEntriesCurrent;
    // Calcul of "real" coef
    CalculVdriftCoefMean();
    CalculT0CoefMean();
    //Method choosen
    switch(fMethod)
      {
      case 0: FitLagrangePoly((TH1 *) projph); break;
      case 1: FitPente((TH1 *) projph); break;
      case 2: FitPH((TH1 *) projph,(Int_t) (idect - fDect1)); break;
      default: return kFALSE;
      }
    // Fill the tree if end of a detector or only the pointer to the branch!!!
    FillInfosFitPH(idect,fEntriesCurrent);
  } // Boucle object
  
  // Mean Statistic
  if (fNumberFit > 0) {
    AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %f over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Double_t) (fStatisticMean/fNumberFit),fNumberFitSuccess));
    fStatisticMean = fStatisticMean / fNumberFit;
  }
  else {
    AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
  }
  delete fDebugStreamer;
  fDebugStreamer = 0x0;
  return kTRUE;
}
//________________functions fit Online PH2d____________________________________
Bool_t AliTRDCalibraFit::AnalysePH(const TProfile2D *ph)
{
  //
  // Take the 1D profiles (average pulse height), projections of the 2D PH
  // on the Xaxis, for each calibration group
  // Reconstruct a drift velocity
  // A first calibration of T0 is also made  using the same method
  //

  // Set the calibration mode
  //const char *name = ph->GetTitle();
  TString name = ph->GetTitle();
  if(!SetModeCalibration(name,1)) return kFALSE;
  
  //printf("Mode calibration set\n");

  // Number of Xbins (detectors or groups of pads)
  Int_t    nbins   = ph->GetNbinsX();// time
  Int_t    nybins  = ph->GetNbinsY();// calibration group
  if (!InitFit(nybins,1)) {
    return kFALSE;
  }

  //printf("Init fit\n");

  if (!InitFitPH()) {
    return kFALSE;
  }

  //printf("Init fit PH\n");

  fStatisticMean        = 0.0;
  fNumberFit            = 0;
  fNumberFitSuccess     = 0;
  fNumberEnt            = 0;
  // Init fCountDet and fCount
  InitfCountDetAndfCount(1);
  //printf("Init Count Det and fCount %d, %d\n",fDect1,fDect2);

  // Beginning of the loop
  for (Int_t idect = fDect1; idect < fDect2; idect++) {
    //printf("idect = %d\n",idect);
    // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi.......
    UpdatefCountDetAndfCount(idect,1);
    ReconstructFitRowMinRowMax(idect,1);
    // Take the histo
    TH1D *projph = (TH1D *) ph->ProjectionX("projph",idect+1,idect+1,(Option_t *) "e");
    projph->SetDirectory(0); 
    // Number of entries for this calibration group
    Double_t nentries = 0;
    for (Int_t k = 0; k < nbins; k++) {
      Int_t binnb = (nbins+2)*(idect+1)+(k+1);
      nentries += ph->GetBinEntries(binnb);
    }
    if (nentries > 0) {
      fNumberEnt++;
    }  
    //printf("The number of entries for the group %d is %f\n",idect,nentries);
    // This detector has not enough statistics or was off
    if (nentries  <= fMinEntries) {
      //printf("Not enough statistic!\n");
      NotEnoughStatisticPH(idect,nentries);     
      if (fDebugLevel != 1) {
	delete projph;
      }
      continue;
    }
    // Statistics of the histos fitted
    fNumberFit++;
    fStatisticMean += nentries;
    // Calcul of "real" coef
    CalculVdriftCoefMean();
    CalculT0CoefMean();
    //Method choosen
    //printf("Method\n");
    switch(fMethod)
      {
      case 0: FitLagrangePoly((TH1 *) projph); break;
      case 1: FitPente((TH1 *) projph); break;
      case 2: FitPH((TH1 *) projph,(Int_t) (idect - fDect1)); break;
      default: return kFALSE;
      }
    // Fill the tree if end of a detector or only the pointer to the branch!!!
    FillInfosFitPH(idect,nentries);
    // Memory!!!
    if (fDebugLevel != 1) {
      delete projph;
    }
  } // Boucle object
  // Mean Statistic
  if (fNumberFit > 0) {
    AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %f over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Double_t) (fStatisticMean/fNumberFit),fNumberFitSuccess));
    fStatisticMean = fStatisticMean / fNumberFit;
  }
  else {
    AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
  }
  delete fDebugStreamer;
  fDebugStreamer = 0x0;
  return kTRUE;
}
//____________Functions fit Online PRF2d_______________________________________
Bool_t AliTRDCalibraFit::AnalysePRF(const TProfile2D *prf)
{
  //
  // Take the 1D profiles (pad response function), projections of the 2D PRF
  // on the Xaxis, for each calibration group
  // Fit with a gaussian to reconstruct the sigma of the pad response function
  //

  // Set the calibration mode
  //const char *name = prf->GetTitle();
  TString name = prf->GetTitle();
  if(!SetModeCalibration(name,2)) return kFALSE;

  // Number of Ybins (detectors or groups of pads)
  Int_t    nybins  = prf->GetNbinsY();// calibration groups
  Int_t    nbins   = prf->GetNbinsX();// bins
  Int_t    nbg     = GetNumberOfGroupsPRF((const char *)prf->GetTitle());
  if((nbg > 0) || (nbg == -1)) return kFALSE;
  if (!InitFit(nybins,2)) {
    return kFALSE;
  }
  if (!InitFitPRF()) {
    return kFALSE;
  }
  fStatisticMean        = 0.0;
  fNumberFit            = 0;
  fNumberFitSuccess     = 0;
  fNumberEnt            = 0;
  // Init fCountDet and fCount
  InitfCountDetAndfCount(2);
  // Beginning of the loop
  for (Int_t idect = fDect1; idect < fDect2; idect++) {
    // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi......
    UpdatefCountDetAndfCount(idect,2);
    ReconstructFitRowMinRowMax(idect,2);
    // Take the histo
    TH1D *projprf = (TH1D *) prf->ProjectionX("projprf",idect+1,idect+1,(Option_t *) "e");
    projprf->SetDirectory(0);
    // Number of entries for this calibration group
    Double_t nentries = 0;
    for (Int_t k = 0; k < nbins; k++) {
      Int_t binnb = (nbins+2)*(idect+1)+(k+1);
      nentries += prf->GetBinEntries(binnb);
    }
    if(nentries > 0) fNumberEnt++;
    // This detector has not enough statistics or was off
    if (nentries <= fMinEntries) {
      NotEnoughStatisticPRF(idect);
      if (fDebugLevel != 1) {
	delete projprf;
      }
      continue;
    }
    // Statistics of the histos fitted
    fNumberFit++;
    fStatisticMean += nentries;
    // Calcul of "real" coef
    CalculPRFCoefMean();
    //Method choosen
    switch(fMethod)
      {
      case 0: FitPRF((TH1 *) projprf); break;
      case 1: RmsPRF((TH1 *) projprf); break;
      default: return kFALSE;
      }
    // Fill the tree if end of a detector or only the pointer to the branch!!!
    FillInfosFitPRF(idect);
    // Memory!!!
    if (fDebugLevel != 1) {
      delete projprf;
    }
  } // Boucle object
  // Mean Statistic
  if (fNumberFit > 0) {
    AliInfo(Form("There are %d with at least one entries.",fNumberEnt));
    AliInfo(Form("%d fits have been proceeded (sucessfully or not...).",fNumberFit));
    AliInfo(Form("There is a mean statistic of: %f over these fitted histograms and %d successfulled fits"
		 ,(Double_t) (fStatisticMean/fNumberFit),fNumberFitSuccess));
    fStatisticMean = fStatisticMean / fNumberFit;
  }
  else {
    AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
  }
  delete fDebugStreamer;
  fDebugStreamer = 0x0;
  return kTRUE;
}
//____________Functions fit Online PRF2d_______________________________________
Bool_t AliTRDCalibraFit::AnalysePRFMarianFit(const TProfile2D *prf)
{
  //
  // Take the 1D profiles (pad response function), projections of the 2D PRF
  // on the Xaxis, for each calibration group
  // Fit with a gaussian to reconstruct the sigma of the pad response function
  //

  // Set the calibration mode
  //const char *name = prf->GetTitle();
  TString name = prf->GetTitle();
  if(!SetModeCalibration(name,2)) return kFALSE;

  // Number of Ybins (detectors or groups of pads)
  const TAxis   *xprf    = prf->GetXaxis();
  const TAxis   *yprf    = prf->GetYaxis();
  Int_t    nybins  = yprf->GetNbins();// calibration groups
  Int_t    nbins   = xprf->GetNbins();// bins
  Float_t  lowedge = (Float_t) xprf->GetBinLowEdge(1);//lowedge in bins
  Float_t  upedge  = (Float_t) xprf->GetBinUpEdge(nbins);//upedge in bins
  Int_t    nbg     = GetNumberOfGroupsPRF((const char *)name);
  if(nbg == -1) return kFALSE;
  if(nbg > 0) fMethod = 1;
  else fMethod = 0;
  if (!InitFit(nybins,2)) {
    return kFALSE;
  }
  if (!InitFitPRF()) {
    return kFALSE;
  }
  fStatisticMean        = 0.0;
  fNumberFit            = 0;
  fNumberFitSuccess     = 0;
  fNumberEnt            = 0;
  // Init fCountDet and fCount
  InitfCountDetAndfCount(2);
  // Beginning of the loop
  for (Int_t idect = fDect1; idect < fDect2; idect++) {
    // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi.......
    UpdatefCountDetAndfCount(idect,2);
    ReconstructFitRowMinRowMax(idect,2);
    // Build the array of entries and sum
    TArrayD arraye  = TArrayD(nbins);
    TArrayD arraym  = TArrayD(nbins);
    TArrayD arrayme = TArrayD(nbins);
    Double_t nentries = 0;
    //printf("nbins %d\n",nbins);
    for (Int_t k = 0; k < nbins; k++) {
      Int_t binnb = (nbins+2)*(idect+1)+(k+1);
      Double_t entries = (Double_t)prf->GetBinEntries(binnb);
      Double_t mean    = (Double_t)prf->GetBinContent(binnb);
      Double_t error   = (Double_t)prf->GetBinError(binnb); 
      //printf("for %d we have %f\n",k,entries);
      nentries += entries;
      arraye.AddAt(entries,k);
      arraym.AddAt(mean,k);
      arrayme.AddAt(error,k);
    }
    if(nentries > 0) fNumberEnt++;
    //printf("The number of entries for the group %d is %f\n",idect,nentries);
    // This detector has not enough statistics or was off
    if (nentries <= fMinEntries) {
      NotEnoughStatisticPRF(idect);
      continue;
    }
    // Statistics of the histos fitted
    fNumberFit++;
    fStatisticMean += nentries;
    // Calcul of "real" coef
    CalculPRFCoefMean();
    //Method choosen
    switch(fMethod)
      {
      case 0: FitPRFGausMI( arraye.GetArray(), arraym.GetArray(), arrayme.GetArray(), nbins, lowedge, upedge); break;
      case 1: FitTnpRange( arraye.GetArray(), arraym.GetArray(), arrayme.GetArray(), nbg, nbins); break;
      default: return kFALSE;
      }
    // Fill the tree if end of a detector or only the pointer to the branch!!!
    FillInfosFitPRF(idect);
  } // Boucle object
  // Mean Statistic
  if (fNumberFit > 0) {
    AliInfo(Form("There are %d with at least one entries.",fNumberEnt));
    AliInfo(Form("%d fits have been proceeded (sucessfully or not...).",fNumberFit));
    AliInfo(Form("There is a mean statistic of: %f over these fitted histograms and %d successfulled fits"
		 ,(Double_t) (fStatisticMean/fNumberFit),fNumberFitSuccess));
    fStatisticMean = fStatisticMean / fNumberFit;
  }
  else {
    AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
  }
  delete fDebugStreamer;
  fDebugStreamer = 0x0;
  return kTRUE;
}
//____________Functions fit Online PRF2d_______________________________________
Bool_t AliTRDCalibraFit::AnalysePRF(AliTRDCalibraVector *calvect)
{
  //
  // Reconstruct the 1D histo (pad response function) from the vectorPRD for
  // each calibration group
  // Fit with a gaussian to reconstruct the sigma of the pad response function
  //

  // Set the calibra mode
  //const char *name = calvect->GetNamePRF();
  TString name = calvect->GetNamePRF();
  if(!SetModeCalibration(name,2)) return kFALSE;
  //printf("test0 %s\n",name);

  // Number of Xbins (detectors or groups of pads)
  if (!InitFit((432*calvect->GetDetCha0(2)+108*calvect->GetDetCha2(2)),2)) {
    //printf("test1\n");
    return kFALSE;
  }
  if (!InitFitPRF()) {
    ///printf("test2\n");
    return kFALSE;
  }
  fStatisticMean        = 0.0;
  fNumberFit            = 0;
  fNumberFitSuccess     = 0;
  fNumberEnt            = 0;
  // Init fCountDet and fCount
  InitfCountDetAndfCount(2);
  // Beginning of the loop
  for (Int_t idect = fDect1; idect < fDect2; idect++) {
    // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi........
    UpdatefCountDetAndfCount(idect,2);
    ReconstructFitRowMinRowMax(idect,2);
    // Take the histo
    fEntriesCurrent = 0;
    if(!calvect->GetPRFEntries(fCountDet)) {
      NotEnoughStatisticPRF(idect);
      continue;
    }
    TString tname("PRF");
    tname += idect;
    TH1F *projprf  = calvect->CorrectTheError((TGraphErrors *) (calvect->ConvertVectorPRFTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) tname)),fEntriesCurrent);
    projprf->SetDirectory(0);
    if(fEntriesCurrent > 0) fNumberEnt++;
    // This detector has not enough statistics or was off
    if (fEntriesCurrent <= fMinEntries) {
      NotEnoughStatisticPRF(idect);
      continue;
    }
    // Statistic of the histos fitted
    fNumberFit++;
    fStatisticMean += fEntriesCurrent;
    // Calcul of "real" coef
    CalculPRFCoefMean();
    //Method choosen
    switch(fMethod)
      {
      case 1: FitPRF((TH1 *) projprf); break;
      case 2: RmsPRF((TH1 *) projprf); break;
      default: return kFALSE;
      }    
    // Fill the tree if end of a detector or only the pointer to the branch!!!
    FillInfosFitPRF(idect);
  } // Boucle object
  // Mean Statistics
  if (fNumberFit > 0) {
    AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %f over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Double_t) (fStatisticMean/fNumberFit),fNumberFitSuccess));
  }
  else {
    AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
  }
  delete fDebugStreamer;
  fDebugStreamer = 0x0;
  return kTRUE;
}
//____________Functions fit Online PRF2d_______________________________________
Bool_t AliTRDCalibraFit::AnalysePRFMarianFit(AliTRDCalibraVector *calvect)
{
  //
  // Reconstruct the 1D histo (pad response function) from the vectorPRD for
  // each calibration group
  // Fit with a gaussian to reconstruct the sigma of the pad response function
  //

  // Set the calibra mode
  //const char *name = calvect->GetNamePRF();
  TString name = calvect->GetNamePRF();
  if(!SetModeCalibration(name,2)) return kFALSE;
  //printf("test0 %s\n",name);
  Int_t    nbg     = GetNumberOfGroupsPRF((const char *)name);
  //printf("test1 %d\n",nbg);
  if(nbg == -1) return kFALSE;
  if(nbg > 0) fMethod = 1;
  else fMethod = 0;
  // Number of Xbins (detectors or groups of pads)
  if (!InitFit((432*calvect->GetDetCha0(2)+108*calvect->GetDetCha2(2)),2)) {
    //printf("test2\n");
    return kFALSE;
  }
  if (!InitFitPRF()) {
    //printf("test3\n");
    return kFALSE;
  }
  fStatisticMean        = 0.0;
  fNumberFit            = 0;
  fNumberFitSuccess     = 0;
  fNumberEnt            = 0;
  // Variables
  Int_t nbins           = 0;
  Double_t *arrayx       = 0;
  Double_t *arraye       = 0;
  Double_t *arraym       = 0;
  Double_t *arrayme      = 0;
  Float_t lowedge       = 0.0;
  Float_t upedge        = 0.0;
  // Init fCountDet and fCount
  InitfCountDetAndfCount(2);
  // Beginning of the loop
  for (Int_t idect = fDect1; idect < fDect2; idect++) {
    // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi......
    UpdatefCountDetAndfCount(idect,2);
    ReconstructFitRowMinRowMax(idect,2);
    // Take the histo
    fEntriesCurrent  = 0;
    if(!calvect->GetPRFEntries(fCountDet)) {
      NotEnoughStatisticPRF(idect);
      continue;
    }
    TString tname("PRF");
    tname += idect;
    TGraphErrors *projprftree  = calvect->ConvertVectorPRFTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) tname);
    nbins   = projprftree->GetN();
    arrayx  = (Double_t *)projprftree->GetX();
    arraye  = (Double_t *)projprftree->GetEX();
    arraym  = (Double_t *)projprftree->GetY();
    arrayme = (Double_t *)projprftree->GetEY();
    Float_t step = arrayx[1]-arrayx[0];
    lowedge = arrayx[0] - step/2.0;
    upedge  = arrayx[(nbins-1)] + step/2.0;
    //printf("nbins est %d\n",nbins);
    for(Int_t k = 0; k < nbins; k++){
      fEntriesCurrent += (Int_t)arraye[k];
      //printf("for %d we have %f, %f\n",k,arraye[k],((projprftree->GetEX())[k]));
      if(arraye[k]>0.0) arrayme[k] = TMath::Sqrt(TMath::Abs(arrayme[k]-arraym[k]*arraym[k])/arraye[k]);
    }
    if(fEntriesCurrent > 0) fNumberEnt++;
    //printf("The number of entries for the group %d is %d\n",idect,fEntriesCurrent);
    // This detector has not enough statistics or was off
    if (fEntriesCurrent <= fMinEntries) {
      NotEnoughStatisticPRF(idect);
      continue;
    }
    // Statistic of the histos fitted
    fNumberFit++;
    fStatisticMean += fEntriesCurrent;
    // Calcul of "real" coef
    CalculPRFCoefMean();
    //Method choosen
    switch(fMethod)
      {
      case 0: FitPRFGausMI(arraye,arraym,arrayme,nbins,lowedge,upedge); break;
      case 1: FitTnpRange(arraye,arraym,arrayme,nbg,nbins); break;
      default: return kFALSE;
      }    
    // Fill the tree if end of a detector or only the pointer to the branch!!!
    FillInfosFitPRF(idect);
  } // Boucle object
  // Mean Statistics
  if (fNumberFit > 0) {
    AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %f over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Double_t) (fStatisticMean/fNumberFit),fNumberFitSuccess));
  }
  else {
    AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
  }
  delete fDebugStreamer;
  fDebugStreamer = 0x0;
  return kTRUE;
}
//____________Functions fit Online CH2d________________________________________
Bool_t AliTRDCalibraFit::AnalyseLinearFitters(AliTRDCalibraVdriftLinearFit *calivdli)
{
  //
  // The linear method
  //

  fStatisticMean        = 0.0;
  fNumberFit            = 0;
  fNumberFitSuccess     = 0;
  fNumberEnt            = 0;
  if(!InitFitLinearFitter()) return kFALSE;

  
  for(Int_t idet = 0; idet < 540; idet++){


    //printf("detector number %d\n",idet);

    // Take the result
    TVectorD param(2);
    TVectorD error(3);
    Double_t entriesCurrent = 0;
    fCountDet       = idet;
    Bool_t here     = calivdli->GetParam(idet,&param);
    Bool_t heree    = calivdli->GetError(idet,&error);
    //printf("here %d and heree %d\n",here, heree);
    if(heree) {
      entriesCurrent = error[2];
      fNumberEnt++;
    }
    //printf("Number of entries %d\n",fEntriesCurrent);
    // Nothing found or not enough statistic
    if((!heree) || (!here) || (entriesCurrent <= fMinEntries)) {
      NotEnoughStatisticLinearFitter();
      continue;
    }
    //param.Print();
    //error.Print();
    //Statistics
    fNumberFit++;
    fStatisticMean += entriesCurrent;     

    // Check the fit
    if((-(param[1])) <= 0.000001) {
      NotEnoughStatisticLinearFitter();
      continue;
    }

    // CalculDatabaseVdriftandTan
    CalculVdriftLorentzCoef();
    //printf("AliTRDCalibraFit::AnalyzeVdriftLinearFit detector %d, vdrift %f and %f and exB %f and %f\n",idet,fCalDetVdriftUsed->GetValue(idet),fCurrentCoef[1],fCalDetExBUsed->GetValue(idet),fCurrentCoef2[1]);

    // Statistics   
    fNumberFitSuccess ++;

    // Put the fCurrentCoef
    fCurrentCoef[0]  = -param[1];
    // here the database must be the one of the reconstruction for the lorentz angle....
    fCurrentCoef2[0] = (param[0]+fCurrentCoef[1]*fCurrentCoef2[1])/fCurrentCoef[0];
    fCurrentCoefE    = error[1];
    fCurrentCoefE2   = error[0];
    if((TMath::Abs(fCurrentCoef2[0]) > 0.0000001) && (TMath::Abs(param[0]) > 0.0000001)){
      fCurrentCoefE2 = (fCurrentCoefE2/param[0]+fCurrentCoefE/fCurrentCoef[0])*fCurrentCoef2[0];
    }    

    // Fill
    FillInfosFitLinearFitter();

    
  }
  // Mean Statistics
  if (fNumberFit > 0) {
    AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %f over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Double_t) (fStatisticMean/fNumberFit),fNumberFitSuccess));
  }
  else {
    AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
  }
  delete fDebugStreamer;
  fDebugStreamer = 0x0;
  return kTRUE;
  
}
//______________________________________________________________________________________
Bool_t AliTRDCalibraFit::AnalyseExbAltFit(AliTRDCalibraExbAltFit *calivdli)
{
  //
  // The linear method
  //

  fStatisticMean        = 0.0;
  fNumberFit            = 0;
  fNumberFitSuccess     = 0;
  fNumberEnt            = 0;
  if(!InitFitExbAlt()) return kFALSE;

  
  for(Int_t idet = 0; idet < 540; idet++){


    //printf("detector number %d\n",idet);

    // Take the result
    TVectorD param(3);
    TVectorD error(3);
    Double_t entriesCurrent = 0;
    fCountDet       = idet;
    Bool_t here     = calivdli->GetParam(idet,&param);
    Bool_t heree    = calivdli->GetError(idet,&error);
    //printf("here %d and heree %d\n",here, heree);
    if(heree) {
      entriesCurrent =  error[2];
      fNumberEnt++;
    }
    //printf("Number of entries %d\n",fEntriesCurrent);
    // Nothing found or not enough statistic
    if((!heree) || (!here) || (entriesCurrent <= fMinEntries)) {
      NotEnoughStatisticExbAlt();
      continue;
    }
    //param.Print();
    //error.Print();
    //Statistics
    fNumberFit++;
    fStatisticMean += entriesCurrent;

    // Statistics   
    fNumberFitSuccess ++;

    // Put the fCurrentCoef
    if(TMath::Abs(param[2])>0.0001){
      fCurrentCoef2[0]  = -param[1]/2/param[2];
      fCurrentCoefE2    = 0;//error[1];
    }else{
      fCurrentCoef2[0]  = 100;
      fCurrentCoefE2    = 0;//error[1];
    }
    
    // Fill
    FillInfosFitExbAlt();
    
  }
  // Mean Statistics
  if (fNumberFit > 0) {
    AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %f over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Double_t) (fStatisticMean/fNumberFit),fNumberFitSuccess));
  }
  else {
    AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
  }
  delete fDebugStreamer;
  fDebugStreamer = 0x0;
  return kTRUE;
  
}
//____________Functions fit Online CH2d________________________________________
void AliTRDCalibraFit::AnalyseLinearFittersAllTogether(AliTRDCalibraVdriftLinearFit *calivdli, Double_t &vdriftoverall, Double_t &exboverall)
{
  //
  // The linear method
  //

  // Get the mean vdrift and exb used
  Double_t meanvdriftused = 0.0;
  Double_t meanexbused = 0.0;
  Double_t counterdet = 0.0;
  if((!fCalDetVdriftUsed) || (!fCalDetExBUsed)) {
    vdriftoverall = -100.0;
    exboverall = 100.0;
    return;
  }  

  // Add histos

  TH2S *linearfitterhisto = 0x0;
  
  for(Int_t idet = 0; idet < 540; idet++){
    
    TH2S * u = calivdli->GetLinearFitterHistoForce(idet);
    Double_t detectorentries = u->Integral();
    meanvdriftused += fCalDetVdriftUsed->GetValue(idet)*detectorentries;
    meanexbused += fCalDetExBUsed->GetValue(idet)*detectorentries;
    counterdet += detectorentries;

    //printf("detectorentries %f\n",detectorentries);
    
    //printf("AliTRDCalibraFit::AnalyzeVdriftLinearFitsAllTogether detector %d, vdrift %f and exB %f\n",idet,fCalDetVdriftUsed->GetValue(idet),fCalDetExBUsed->GetValue(idet));

    if(idet == 0) linearfitterhisto = u;
    else linearfitterhisto->Add(u);

  }
  if(counterdet > 0.0){
    meanvdriftused = meanvdriftused/counterdet;
    meanexbused = meanexbused/counterdet;    
  }
  else {
    vdriftoverall = -100.0;
    exboverall = 100.0;
    return;
  }
  
  
  //printf("AliTRDCalibraFit::AnalyzeVdriftLinearFitsAllTogether MEAN vdrift %f and exB %f\n",meanvdriftused,meanexbused);

  // Fit

  Double_t entries = 0;
  TAxis *xaxis = linearfitterhisto->GetXaxis();
  TAxis *yaxis = linearfitterhisto->GetYaxis();
  TLinearFitter linearfitter = TLinearFitter(2,"pol1");
  //printf("test\n");
  Double_t integral = linearfitterhisto->Integral();
  //printf("Integral is %f\n",integral);
  Bool_t securitybreaking = kFALSE;
  if(TMath::Abs(integral-1199) < 0.00001) securitybreaking = kTRUE;
  for(Int_t ibinx = 0; ibinx < linearfitterhisto->GetNbinsX(); ibinx++){
    for(Int_t ibiny = 0; ibiny < linearfitterhisto->GetNbinsY(); ibiny++){
      if(linearfitterhisto->GetBinContent(ibinx+1,ibiny+1)>0){
	Double_t x = xaxis->GetBinCenter(ibinx+1);
	Double_t y = yaxis->GetBinCenter(ibiny+1);
	
	for(Int_t k = 0; k < (Int_t)linearfitterhisto->GetBinContent(ibinx+1,ibiny+1); k++){
	  if(!securitybreaking){
	    linearfitter.AddPoint(&x,y);
	    entries = entries+1.;
	  }
	  else {
	    if(entries< 1198.0){
	      linearfitter.AddPoint(&x,y);
	      entries = entries + 1.; 
	    }
	  }
	}
	
      }
    }
  }
      
  //printf("AnalyseLinearFittersAllTogether::Find %d entries\n",entries);
  //printf("Minstats %d\n",fMinEntries);

  

  // Eval the linear fitter
  if(entries > fMinEntries){
    TVectorD  par  = TVectorD(2);
    //printf("Fit\n");
    if((linearfitter.EvalRobust(0.8)==0)) {
      //printf("Take the param\n");
      linearfitter.GetParameters(par);
      //printf("Done\n");
      //par.Print();
      //printf("Finish\n");
      // Put the fCurrentCoef
      fCurrentCoef[0]  = -par[1];
      // here the database must be the one of the reconstruction for the lorentz angle....
      if(fCurrentCoef[0] > 0.00001) fCurrentCoef2[0] = (par[0]+meanvdriftused*meanexbused)/fCurrentCoef[0];
      else fCurrentCoef2[0] = 100.0;      

    }
    else {
      
      fCurrentCoef[0] = -100.0;
      fCurrentCoef2[0] = 100.0;
      
    }
    
    
  }
  else {

    fCurrentCoef[0] = -100.0;
    fCurrentCoef2[0] = 100.0;
    
  }
  
  vdriftoverall = fCurrentCoef[0];
  exboverall = fCurrentCoef2[0];
  

  delete linearfitterhisto;
  delete fDebugStreamer;
  fDebugStreamer = 0x0;
  
}
//____________Functions for seeing if the pad is really okey___________________
//_____________________________________________________________________________
Int_t AliTRDCalibraFit::GetNumberOfGroupsPRF(TString nametitle)
{
  //
  // Get numberofgroupsprf
  //
  
  // Some patterns
  const Char_t *pattern0 = "Ngp0";
  const Char_t *pattern1 = "Ngp1";
  const Char_t *pattern2 = "Ngp2";
  const Char_t *pattern3 = "Ngp3";
  const Char_t *pattern4 = "Ngp4";
  const Char_t *pattern5 = "Ngp5";
  const Char_t *pattern6 = "Ngp6";

  // Nrphi mode
  if (strstr(nametitle.Data(),pattern0)) {
    return 0;
  }
  if (strstr(nametitle.Data(),pattern1)) {
    return 1;
  }
  if (strstr(nametitle.Data(),pattern2)) {
    return 2;
  }
  if (strstr(nametitle.Data(),pattern3)) {
    return 3;
  }
  if (strstr(nametitle.Data(),pattern4)) {
    return 4;
  }
  if (strstr(nametitle.Data(),pattern5)) {
    return 5;
  }
  if (strstr(nametitle.Data(),pattern6)){
    return 6;
  }
  else return -1;
 

}
//_____________________________________________________________________________
Bool_t AliTRDCalibraFit::SetModeCalibration(TString name, Int_t i)
{
  //
  // Set fNz[i] and fNrphi[i] of the AliTRDCalibraFit::Instance()
  // corresponding to the given name
  //

  if(!SetNzFromTObject(name,i)) return kFALSE;
  if(!SetNrphiFromTObject(name,i)) return kFALSE;
  
  return kTRUE; 

}
//_____________________________________________________________________________
Bool_t AliTRDCalibraFit::SetNrphiFromTObject(TString name, Int_t i)
{
  //
  // Set fNrphi[i] of the AliTRDCalibraFit::Instance()
  // corresponding to the given TObject
  //
  
  // Some patterns
  const Char_t *patternrphi0 = "Nrphi0";
  const Char_t *patternrphi1 = "Nrphi1";
  const Char_t *patternrphi2 = "Nrphi2";
  const Char_t *patternrphi3 = "Nrphi3";
  const Char_t *patternrphi4 = "Nrphi4";
  const Char_t *patternrphi5 = "Nrphi5";
  const Char_t *patternrphi6 = "Nrphi6";

  
  const Char_t *patternrphi10 = "Nrphi10";
  const Char_t *patternrphi100 = "Nrphi100";
  const Char_t *patternz10 = "Nz10";
  const Char_t *patternz100 = "Nz100";

  // Nrphi mode
  if ((strstr(name.Data(),patternrphi100)) && (strstr(name.Data(),patternz100))) {
    fCalibraMode->SetAllTogether(i);
    fNbDet = 540;
    if (fDebugLevel > 1) {
      AliInfo(Form("fNbDet %d and 100",fNbDet));
    }
    return kTRUE;
  }
  if ((strstr(name.Data(),patternrphi10)) && (strstr(name.Data(),patternz10))) {
    fCalibraMode->SetPerSuperModule(i);
    fNbDet = 30;
    if (fDebugLevel > 1) {
      AliInfo(Form("fNDet %d and 100",fNbDet));
    }
    return kTRUE;
  }
  
  if (strstr(name.Data(),patternrphi0)) {
    fCalibraMode->SetNrphi(i ,0);
    if (fDebugLevel > 1) {
      AliInfo(Form("fNbDet %d and 0",fNbDet));
    }
    return kTRUE;
  }
  if (strstr(name.Data(),patternrphi1)) {
    fCalibraMode->SetNrphi(i, 1);
    if (fDebugLevel > 1) {
      AliInfo(Form("fNbDet %d and 1",fNbDet));
    }
    return kTRUE;
  }
  if (strstr(name.Data(),patternrphi2)) {
    fCalibraMode->SetNrphi(i, 2);
    if (fDebugLevel > 1) {
      AliInfo(Form("fNbDet %d and 2",fNbDet));
    }    
    return kTRUE;
  }
  if (strstr(name.Data(),patternrphi3)) {
    fCalibraMode->SetNrphi(i, 3);
    if (fDebugLevel > 1) {
      AliInfo(Form("fNbDet %d and 3",fNbDet));
    }   
    return kTRUE;
  }
  if (strstr(name.Data(),patternrphi4)) {
    fCalibraMode->SetNrphi(i, 4);
    if (fDebugLevel > 1) {
      AliInfo(Form("fNbDet %d and 4",fNbDet));
    }   
    return kTRUE;
  }
  if (strstr(name.Data(),patternrphi5)) {
    fCalibraMode->SetNrphi(i, 5);
    if (fDebugLevel > 1) {
      AliInfo(Form("fNbDet %d and 5",fNbDet));
    }
    return kTRUE;
  }
  if (strstr(name.Data(),patternrphi6)) {
    fCalibraMode->SetNrphi(i, 6);
    if (fDebugLevel > 1) {
      AliInfo(Form("fNbDet %d and 6",fNbDet));
    }
    return kTRUE;
  }
  
  if (fDebugLevel > 1) {
    AliInfo(Form("fNbDet %d and rest",fNbDet));
  }
  fCalibraMode->SetNrphi(i ,0);
  return kFALSE;
  
}
//_____________________________________________________________________________
Bool_t AliTRDCalibraFit::SetNzFromTObject(TString name, Int_t i)
{
  //
  // Set fNz[i] of the AliTRDCalibraFit::Instance()
  // corresponding to the given TObject
  //

  // Some patterns
  const Char_t *patternz0    = "Nz0";
  const Char_t *patternz1    = "Nz1";
  const Char_t *patternz2    = "Nz2";
  const Char_t *patternz3    = "Nz3";
  const Char_t *patternz4    = "Nz4";

  const Char_t *patternrphi10 = "Nrphi10";
  const Char_t *patternrphi100 = "Nrphi100";
  const Char_t *patternz10 = "Nz10";
  const Char_t *patternz100 = "Nz100";

  if ((strstr(name.Data(),patternrphi100)) && (strstr(name.Data(),patternz100))) {
    fCalibraMode->SetAllTogether(i);
    fNbDet = 540;
    if (fDebugLevel > 1) {
      AliInfo(Form("fNbDet %d and 100",fNbDet));
    }
    return kTRUE;
  }
  if ((strstr(name.Data(),patternrphi10)) && (strstr(name.Data(),patternz10))) {
    fCalibraMode->SetPerSuperModule(i);
    fNbDet = 30;
    if (fDebugLevel > 1) {
      AliInfo(Form("fNbDet %d and 10",fNbDet));
    }
    return kTRUE;
  }
  if (strstr(name.Data(),patternz0)) {
    fCalibraMode->SetNz(i, 0);
    if (fDebugLevel > 1) {
      AliInfo(Form("fNbDet %d and 0",fNbDet));
    }
    return kTRUE;
  }
  if (strstr(name.Data(),patternz1)) {
    fCalibraMode->SetNz(i ,1);
    if (fDebugLevel > 1) {
      AliInfo(Form("fNbDet %d and 1",fNbDet));
    }
    return kTRUE;
  }
  if (strstr(name.Data(),patternz2)) {
    fCalibraMode->SetNz(i ,2);
    if (fDebugLevel > 1) {    
      AliInfo(Form("fNbDet %d and 2",fNbDet));
    }
    return kTRUE;
  }
  if (strstr(name.Data(),patternz3)) {
    fCalibraMode->SetNz(i ,3);
    if (fDebugLevel > 1) {
      AliInfo(Form("fNbDet %d and 3",fNbDet));
    }
    return kTRUE;  
  }
  if (strstr(name.Data(),patternz4)) {
    fCalibraMode->SetNz(i ,4);
    if (fDebugLevel > 1) {    
      AliInfo(Form("fNbDet %d and 4",fNbDet));
    }
    return kTRUE;
  }
 
  if (fDebugLevel > 1) {
    AliInfo(Form("fNbDet %d and rest",fNbDet));
  }
  fCalibraMode->SetNz(i ,0);
  return kFALSE;
}
//______________________________________________________________________
void AliTRDCalibraFit::RemoveOutliers(Int_t type, Bool_t perdetector){
  //
  // Remove the results too far from the mean value and rms
  // type: 0 gain, 1 vdrift
  // perdetector
  //

  Int_t loop = (Int_t) fVectorFit.GetEntriesFast();
  if(loop != 540) {
    AliInfo("The Vector Fit is not complete!");
    return;
  }
  Int_t detector = -1;
  // Coverity
  //Int_t sector = -1;
  Float_t value  = 0.0;

  /////////////////////////////////
  // Calculate the mean values
  ////////////////////////////////
  // Initialisation
  ////////////////////////
  Double_t meanAll = 0.0;
  Double_t rmsAll = 0.0;
  Int_t countAll = 0;
  ////////////
  // compute
  ////////////
  for (Int_t k = 0; k < loop; k++) {
    detector  = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
    // Coverity
    //sector = GetSector(detector);
    if(perdetector){
      value = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef()[0];
      if(value > 0.0) {
	rmsAll += value*value;
	meanAll += value;
	countAll++;
      }
    }
    else {
      Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
      Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
      for (Int_t row = 0; row < rowMax; row++) {
	for (Int_t col = 0; col < colMax; col++) {
	  value = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
	  if(value > 0.0) {
	    rmsAll += value*value;
	    meanAll += value;
	    countAll++;
	  }
	  
	} // Col
      } // Row
    }
  }  
  if(countAll > 0) {
    meanAll = meanAll/countAll;
    rmsAll = TMath::Sqrt(TMath::Abs(rmsAll/countAll - (meanAll*meanAll)));
  }
  //printf("RemoveOutliers: meanAll %f and rmsAll %f\n",meanAll,rmsAll);
  /////////////////////////////////////////////////
  // Remove outliers
  ////////////////////////////////////////////////
  Double_t defaultvalue = -1.0;
  if(type==1) defaultvalue = -1.5;
  for (Int_t k = 0; k < loop; k++) {
    detector  = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
    // Coverity
    //sector = GetSector(detector);
    Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
    Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
    Float_t *coef = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef();
  
    // remove the results too far away  
    for (Int_t row = 0; row < rowMax; row++) {
      for (Int_t col = 0; col < colMax; col++) {
	value = coef[(Int_t)(col*rowMax+row)];
	if((value > 0.0) && (rmsAll > 0.0) && (TMath::Abs(value-meanAll) > (2*rmsAll))) {
	  coef[(Int_t)(col*rowMax+row)] = defaultvalue;
	}
      } // Col
    } // Row
  }
}
//______________________________________________________________________
void AliTRDCalibraFit::RemoveOutliers2(Bool_t perdetector){
  //
  // Remove the results too far from the mean and rms
  // perdetector
  //

  Int_t loop = (Int_t) fVectorFit2.GetEntriesFast();
  if(loop != 540) {
    AliInfo("The Vector Fit is not complete!");
    return;
  }
  Int_t detector = -1;
  // Coverity
  //Int_t sector = -1;
  Float_t value  = 0.0;

  /////////////////////////////////
  // Calculate the mean values
  ////////////////////////////////
  // Initialisation
  ////////////////////////
  Double_t meanAll = 0.0;
  Double_t rmsAll = 0.0;
  Int_t countAll = 0;
  /////////////
  // compute
  ////////////
  for (Int_t k = 0; k < loop; k++) {
    detector  = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetDetector();
    // Coverity
    //sector = GetSector(detector);
    if(perdetector){
      value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[0];
      if(value < 70.0) {
	meanAll += value;
	rmsAll += value*value;
	countAll++;
      }
    }
    else {
      Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
      Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
      for (Int_t row = 0; row < rowMax; row++) {
	for (Int_t col = 0; col < colMax; col++) {
	  value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
	  if(value < 70.0) {
	    rmsAll += value*value;
	    meanAll += value;
	    countAll++;
	  }	  
	} // Col
      } // Row
    }
  }  
  if(countAll > 0) {
    meanAll = meanAll/countAll;
    rmsAll = TMath::Sqrt(TMath::Abs(rmsAll/countAll - (meanAll*meanAll)));
  }
  //printf("Remove outliers 2: meanAll %f, rmsAll %f\n",meanAll,rmsAll);
  /////////////////////////////////////////////////
  // Remove outliers
  ////////////////////////////////////////////////
  for (Int_t k = 0; k < loop; k++) {
    detector  = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetDetector();
    // Coverity
    //sector = GetSector(detector);
    Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
    Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
    Float_t *coef = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef();
  
    // remove the results too far away  
    for (Int_t row = 0; row < rowMax; row++) {
      for (Int_t col = 0; col < colMax; col++) {
	value = coef[(Int_t)(col*rowMax+row)];
	if((value < 70.0) && (rmsAll > 0.0) && (TMath::Abs(value-meanAll) > (2.5*rmsAll))) {
	  //printf("value outlier %f\n",value);
	  coef[(Int_t)(col*rowMax+row)] = 100.0;
	}
      } // Col
    } // Row
  }
}
//______________________________________________________________________
void AliTRDCalibraFit::PutMeanValueOtherVectorFit(Int_t ofwhat, Bool_t perdetector){
  //
  // ofwhat is equaled to 0: mean value of all passing detectors
  // ofwhat is equaled to 1: mean value of the detector, otherwise supermodule, otherwise all
  //

  Int_t loop = (Int_t) fVectorFit.GetEntriesFast();
  if(loop != 540) {
    AliInfo("The Vector Fit is not complete!");
    return;
  }
  Int_t detector = -1;
  Int_t sector = -1;
  Float_t value  = 0.0;

  /////////////////////////////////
  // Calculate the mean values
  ////////////////////////////////
  // Initialisation
  ////////////////////////
  Double_t meanAll = 0.0;
  Double_t meanSupermodule[18];
  Double_t meanDetector[540];
  Double_t rmsAll = 0.0;
  Double_t rmsSupermodule[18];
  Double_t rmsDetector[540];
  Int_t countAll = 0;
  Int_t countSupermodule[18];
  Int_t countDetector[540];
  for(Int_t sm = 0; sm < 18; sm++){
    rmsSupermodule[sm] = 0.0;
    meanSupermodule[sm] = 0.0;
    countSupermodule[sm] = 0;
  }
  for(Int_t det = 0; det < 540; det++){
    rmsDetector[det] = 0.0;
    meanDetector[det] = 0.0;
    countDetector[det] = 0;
  }
  ////////////
  // compute
  ////////////
  for (Int_t k = 0; k < loop; k++) {
    detector  = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
    sector = GetSector(detector);
    if(perdetector){
      value = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef()[0];
      if(value > 0.0) {
	rmsDetector[detector] += value*value;
	meanDetector[detector] += value;
	countDetector[detector]++;
	rmsSupermodule[sector] += value*value;
	meanSupermodule[sector] += value;
	countSupermodule[sector]++;
	rmsAll += value*value;
	meanAll += value;
	countAll++;
      }
    }
    else {
      Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
      Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
      for (Int_t row = 0; row < rowMax; row++) {
	for (Int_t col = 0; col < colMax; col++) {
	  value = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
	  if(value > 0.0) {
	    rmsDetector[detector] += value*value;
	    meanDetector[detector] += value;
	    countDetector[detector]++;
	    rmsSupermodule[sector] += value*value;
	    meanSupermodule[sector] += value;
	    countSupermodule[sector]++;
	    rmsAll += value*value;
	    meanAll += value;
	    countAll++;
	  }
	  
	} // Col
      } // Row
    }
  }  
  if(countAll > 0) {
    meanAll = meanAll/countAll;
    rmsAll = TMath::Abs(rmsAll/countAll - (meanAll*meanAll));
  }
  for(Int_t sm = 0; sm < 18; sm++){
    if(countSupermodule[sm] > 0) {
      meanSupermodule[sm] = meanSupermodule[sm]/countSupermodule[sm];
      rmsSupermodule[sm] = TMath::Abs(rmsSupermodule[sm]/countSupermodule[sm] - (meanSupermodule[sm]*meanSupermodule[sm]));
    }
  }
  for(Int_t det = 0; det < 540; det++){
    if(countDetector[det] > 0) {
      meanDetector[det] = meanDetector[det]/countDetector[det];
      rmsDetector[det] = TMath::Abs(rmsDetector[det]/countDetector[det] - (meanDetector[det]*meanDetector[det]));
    }
  }
  //printf("Put mean value, meanAll %f, rmsAll %f\n",meanAll,rmsAll);
  ///////////////////////////////////////////////
  // Put the mean value for the no-fitted
  /////////////////////////////////////////////  
  for (Int_t k = 0; k < loop; k++) {
    detector  = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
    sector = GetSector(detector);
    Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
    Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
    Float_t *coef = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef();

    for (Int_t row = 0; row < rowMax; row++) {
      for (Int_t col = 0; col < colMax; col++) {
	value = coef[(Int_t)(col*rowMax+row)];
	if(value < 0.0) {
	  if((ofwhat == 0) && (meanAll > 0.0) && (countAll > 15)) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanAll);
	  if(ofwhat == 1){
	    if((meanDetector[detector] > 0.0) && (countDetector[detector] > 20)) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanDetector[detector]);
	    else if((meanSupermodule[sector] > 0.0) && (countSupermodule[sector] > 15)) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanSupermodule[sector]);
	    else if((meanAll > 0.0) && (countAll > 15)) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanAll);
	  }  
	}
	// Debug
	if(fDebugLevel > 1){
	  
	  if ( !fDebugStreamer ) {
	    //debug stream
	    TDirectory *backup = gDirectory;
	    fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
	    if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
	  } 
	  
	  Float_t coefnow      = coef[(Int_t)(col*rowMax+row)]; 
	  
	  (* fDebugStreamer) << "PutMeanValueOtherVectorFit"<<
	    "detector="<<detector<<
	    "sector="<<sector<<
	    "row="<<row<<
	    "col="<<col<<
	    "before="<<value<<
	    "after="<<coefnow<<
	    "\n";  
	}
      } // Col
    } // Row
  }
}
//______________________________________________________________________
void AliTRDCalibraFit::PutMeanValueOtherVectorFit2(Int_t ofwhat, Bool_t perdetector){
  //
  // ofwhat is equaled to 0: mean value of all passing detectors
  // ofwhat is equaled to 1: mean value of the detector, otherwise supermodule, otherwise all
  //

  Int_t loop = (Int_t) fVectorFit2.GetEntriesFast();
  if(loop != 540) {
    AliInfo("The Vector Fit is not complete!");
    return;
  }
  Int_t detector = -1;
  Int_t sector = -1;
  Float_t value  = 0.0;

  /////////////////////////////////
  // Calculate the mean values
  ////////////////////////////////
  // Initialisation
  ////////////////////////
  Double_t meanAll = 0.0;
  Double_t rmsAll = 0.0;
  Double_t meanSupermodule[18];
  Double_t rmsSupermodule[18];
  Double_t meanDetector[540];
  Double_t rmsDetector[540];
  Int_t countAll = 0;
  Int_t countSupermodule[18];
  Int_t countDetector[540];
  for(Int_t sm = 0; sm < 18; sm++){
    rmsSupermodule[sm] = 0.0;
    meanSupermodule[sm] = 0.0;
    countSupermodule[sm] = 0;
  }
  for(Int_t det = 0; det < 540; det++){
    rmsDetector[det] = 0.0;
    meanDetector[det] = 0.0;
    countDetector[det] = 0;
  }
  // compute
  ////////////
  for (Int_t k = 0; k < loop; k++) {
    detector  = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetDetector();
    sector = GetSector(detector);
    if(perdetector){
      value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[0];
      if(value < 70.0) {
	rmsDetector[detector] += value*value;
	meanDetector[detector] += value;
	countDetector[detector]++;
	rmsSupermodule[sector] += value*value;
	meanSupermodule[sector] += value;
	countSupermodule[sector]++;
	meanAll += value;
	rmsAll += value*value;
	countAll++;
      }
    }
    else {
      Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
      Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
      for (Int_t row = 0; row < rowMax; row++) {
	for (Int_t col = 0; col < colMax; col++) {
	  value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
	  if(value < 70.0) {
	    rmsDetector[detector] += value*value;
	    meanDetector[detector] += value;
	    countDetector[detector]++;
	    rmsSupermodule[sector] += value*value;
	    meanSupermodule[sector] += value;
	    countSupermodule[sector]++;
	    rmsAll += value*value;
	    meanAll += value;
	    countAll++;
	  }
	  
	} // Col
      } // Row
    }
  }  
  if(countAll > 0) {
    meanAll = meanAll/countAll;
    rmsAll = TMath::Abs(rmsAll/countAll - (meanAll*meanAll));
  }
  for(Int_t sm = 0; sm < 18; sm++){
    if(countSupermodule[sm] > 0) {
      meanSupermodule[sm] = meanSupermodule[sm]/countSupermodule[sm];
      rmsSupermodule[sm] = TMath::Abs(rmsSupermodule[sm]/countSupermodule[sm] - (meanSupermodule[sm]*meanSupermodule[sm]));
    }
  }
  for(Int_t det = 0; det < 540; det++){
    if(countDetector[det] > 0) {
      meanDetector[det] = meanDetector[det]/countDetector[det];
      rmsDetector[det] = TMath::Abs(rmsDetector[det]/countDetector[det] - (meanDetector[det]*meanDetector[det]));
    }
  }
  //printf("Put mean value 2: meanAll %f, rmsAll %f\n",meanAll,rmsAll);
  ////////////////////////////////////////////
  // Put the mean value for the no-fitted
  /////////////////////////////////////////////  
  for (Int_t k = 0; k < loop; k++) {
    detector  = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetDetector();
    sector = GetSector(detector);
    Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
    Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
    Float_t *coef = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef();

    for (Int_t row = 0; row < rowMax; row++) {
      for (Int_t col = 0; col < colMax; col++) {
	value = coef[(Int_t)(col*rowMax+row)];
	if(value > 70.0) {
	  if((ofwhat == 0) && (meanAll > -3.0) && (countAll > 15)) coef[(Int_t)(col*rowMax+row)] = meanAll+100.0;
	  if(ofwhat == 1){
	    if((meanDetector[detector] > -3.0) && (countDetector[detector] > 20)) coef[(Int_t)(col*rowMax+row)] = meanDetector[detector]+100.0;
	    else if((meanSupermodule[sector] > -3.0) && (countSupermodule[sector] > 15)) coef[(Int_t)(col*rowMax+row)] = meanSupermodule[sector]+100.0;
	    else if((meanAll > -3.0) && (countAll > 15)) coef[(Int_t)(col*rowMax+row)] = meanAll+100.0;
	  }  
	}
	// Debug
	if(fDebugLevel > 1){
	  
	  if ( !fDebugStreamer ) {
	    //debug stream
	    TDirectory *backup = gDirectory;
	    fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
	    if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
	  } 
	  
	  Float_t coefnow      = coef[(Int_t)(col*rowMax+row)]; 
	  
	  (* fDebugStreamer) << "PutMeanValueOtherVectorFit2"<<
	    "detector="<<detector<<
	    "sector="<<sector<<
	    "row="<<row<<
	    "col="<<col<<
	    "before="<<value<<
	    "after="<<coefnow<<
	    "\n";  
	}
      } // Col
    } // Row
  }
  
}
//_____________________________________________________________________________
AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectVdrift(const TObjArray *vectorFit, Bool_t perdetector)
{
  //
  // It creates the AliTRDCalDet object from the AliTRDFitInfo
  // It takes the mean value of the coefficients per detector 
  // This object has to be written in the database
  //
  
  // Create the DetObject
  AliTRDCalDet *object = new AliTRDCalDet("ChamberVdrift","TRD drift velocities (detector value)");

  Int_t loop = (Int_t) vectorFit->GetEntriesFast();
  if(loop != 540) AliInfo("The Vector Fit is not complete!");
  Int_t detector = -1;
  Float_t value  = 0.0;
  
  //
  for (Int_t k = 0; k < loop; k++) {
    detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
    Float_t mean  = 0.0;
    if(perdetector){
      mean = TMath::Abs(((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0]);
    }
    else {
      Int_t   count = 0;
      Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
      Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
      for (Int_t row = 0; row < rowMax; row++) {
	for (Int_t col = 0; col < colMax; col++) {
	  value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
	  mean += TMath::Abs(value);
	  count++;       
	} // Col
      } // Row
      if(count > 0) mean = mean/count;
    }
    object->SetValue(detector,mean);
  }
  
  return object;
}
//_____________________________________________________________________________
AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectGain(const TObjArray *vectorFit, Bool_t meanOtherBefore, Double_t scaleFitFactor, Bool_t perdetector)
{
  //
  // It creates the AliTRDCalDet object from the AliTRDFitInfo
  // It takes the mean value of the coefficients per detector 
  // This object has to be written in the database
  //
  
  // Create the DetObject
  AliTRDCalDet *object = new AliTRDCalDet("ChamberGainFactor","GainFactor (detector value)");
  
  fScaleGain = scaleFitFactor;
 
  Int_t loop = (Int_t) vectorFit->GetEntriesFast();
  if(loop != 540) AliInfo("The Vector Fit is not complete!");
  Int_t detector = -1;
  Float_t value  = 0.0;

  for (Int_t k = 0; k < loop; k++) {
    detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();  
    Float_t mean  = 0.0;
    if(perdetector){
      value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
      if(!meanOtherBefore){
	if(value > 0) value = value*scaleFitFactor;
      }
      else value = value*scaleFitFactor;
      mean = TMath::Abs(value);
    }
    else{
      Int_t   count = 0;
      Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
      Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
      for (Int_t row = 0; row < rowMax; row++) {
	for (Int_t col = 0; col < colMax; col++) {
	  value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
	  if(!meanOtherBefore) {
	    if(value > 0) value = value*scaleFitFactor;
	  }
	  else value = value*scaleFitFactor;
	  mean += TMath::Abs(value);
	  count++;       
	} // Col
      } // Row
      if(count > 0) mean = mean/count;
    }
    if(mean < 0.1) mean = 0.1;
    object->SetValue(detector,mean);
  }
 
  return object;
}
//_____________________________________________________________________________
AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectT0(const TObjArray *vectorFit, Bool_t perdetector)
{
  //
  // It creates the AliTRDCalDet object from the AliTRDFitInfo2
  // It takes the min value of the coefficients per detector 
  // This object has to be written in the database
  //
  
  // Create the DetObject
  AliTRDCalDet *object = new AliTRDCalDet("ChamberT0","T0 (detector value)");
  
  Int_t loop = (Int_t) vectorFit->GetEntriesFast();
  if(loop != 540) AliInfo("The Vector Fit is not complete!");
  Int_t detector = -1;
  Float_t value  = 0.0;

  for (Int_t k = 0; k < loop; k++) {
    detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();   
    Float_t min  = 100.0;
    if(perdetector){
      value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
      //printf("Create det object %f for %d\n",value,k);
      // check successful
      if(value > 70.0) value = value-100.0;
      //
      min = value;
    }
    else{
      Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
      Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
      for (Int_t row = 0; row < rowMax; row++) {
	for (Int_t col = 0; col < colMax; col++) {
	  value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
	  // check successful
	  if(value > 70.0) value = value-100.0;
	  //
	  if(min > value) min = value;
	} // Col
      } // Row
    }
    object->SetValue(detector,min);
  }

  return object;

}
//_____________________________________________________________________________
AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectLorentzAngle(const TObjArray *vectorFit)
{
  //
  // It creates the AliTRDCalDet object from the AliTRDFitInfo2
  // It takes the min value of the coefficients per detector 
  // This object has to be written in the database
  //
  
  // Create the DetObject
  AliTRDCalDet *object = new AliTRDCalDet("tan(lorentzangle)","tan(lorentzangle) (detector value)");
  
  
  Int_t loop = (Int_t) vectorFit->GetEntriesFast();
  if(loop != 540) AliInfo("The Vector Fit is not complete!");
  Int_t detector = -1;
  Float_t value  = 0.0;

  for (Int_t k = 0; k < loop; k++) {
    detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
    /*
      Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
      Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
      Float_t min  = 100.0;
      for (Int_t row = 0; row < rowMax; row++) {
      for (Int_t col = 0; col < colMax; col++) {
      value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
      mean += -TMath::Abs(value);
      count++;       
      } // Col
      } // Row
      if(count > 0) mean = mean/count;
    */
    value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
    if(value > 70.0) value = value-100.0;
    object->SetValue(detector,value);
  }

  return object;
  
}
//_____________________________________________________________________________
AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectExbAlt(const TObjArray *vectorFit)
{
  //
  // It creates the AliTRDCalDet object from the AliTRDFitInfo2
  // It takes the min value of the coefficients per detector 
  // This object has to be written in the database
  //
  
  // Create the DetObject
  AliTRDCalDet *object = new AliTRDCalDet("tan(lorentzangle)","tan(lorentzangle) (detector value)");
  
  
  Int_t loop = (Int_t) vectorFit->GetEntriesFast();
  if(loop != 540) AliInfo("The Vector Fit is not complete!");
  Int_t detector = -1;
  Float_t value  = 0.0;

  for (Int_t k = 0; k < loop; k++) {
    detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
    /*
      Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
      Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
      Float_t min  = 100.0;
      for (Int_t row = 0; row < rowMax; row++) {
      for (Int_t col = 0; col < colMax; col++) {
      value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
      mean += -TMath::Abs(value);
      count++;       
      } // Col
      } // Row
      if(count > 0) mean = mean/count;
    */
    value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
    //if(value > 70.0) value = value-100.0;
    object->SetValue(detector,value);
  }

  return object;
  
}
//_____________________________________________________________________________
TObject *AliTRDCalibraFit::CreatePadObjectGain(const TObjArray *vectorFit, Double_t scaleFitFactor, const AliTRDCalDet *detobject)
{
  //
  // It Creates the AliTRDCalPad object from AliTRDFitInfo
  // You need first to create the object for the detectors,
  // where the mean value is put.
  // This object has to be written in the database
  //
  
  // Create the DetObject
  AliTRDCalPad *object = new AliTRDCalPad("GainFactor","GainFactor (local variations)");
  
  if(!vectorFit){
    for(Int_t k = 0; k < 540; k++){
      AliTRDCalROC *calROC = object->GetCalROC(k);
      Int_t nchannels = calROC->GetNchannels();
      for(Int_t ch = 0; ch < nchannels; ch++){
	calROC->SetValue(ch,1.0);
      }
    }
  }
  else{

    Int_t loop = (Int_t) vectorFit->GetEntriesFast();
    if(loop != 540) AliInfo("The Vector Fit is not complete!");
    Int_t detector = -1;
    Float_t value  = 0.0;
    
    for (Int_t k = 0; k < loop; k++) {
      detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
      AliTRDCalROC *calROC = object->GetCalROC(detector);
      Float_t mean         = detobject->GetValue(detector);
      if(TMath::Abs(mean) <= 0.0000000001) continue;
      Int_t rowMax    = calROC->GetNrows();
      Int_t colMax    = calROC->GetNcols();
      for (Int_t row = 0; row < rowMax; row++) {
	for (Int_t col = 0; col < colMax; col++) {
	  value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
	  if(value > 0) value = value*scaleFitFactor;
	  calROC->SetValue(col,row,TMath::Abs(value)/mean);
	} // Col
      } // Row
    } 
  }

  return object;  
}
//_____________________________________________________________________________
TObject *AliTRDCalibraFit::CreatePadObjectVdrift(const TObjArray *vectorFit, const AliTRDCalDet *detobject)
{
  //
  // It Creates the AliTRDCalPad object from AliTRDFitInfo
  // You need first to create the object for the detectors,
  // where the mean value is put.
  // This object has to be written in the database
  //

  // Create the DetObject
  AliTRDCalPad *object = new AliTRDCalPad("LocalVdrift","TRD drift velocities (local variations)");

  if(!vectorFit){
    for(Int_t k = 0; k < 540; k++){
      AliTRDCalROC *calROC = object->GetCalROC(k);
      Int_t nchannels = calROC->GetNchannels();
      for(Int_t ch = 0; ch < nchannels; ch++){
	calROC->SetValue(ch,1.0);
      }
    }
  }
  else {
    
    Int_t loop = (Int_t) vectorFit->GetEntriesFast();
    if(loop != 540) AliInfo("The Vector Fit is not complete!");
    Int_t detector = -1;
    Float_t value  = 0.0;
    
    for (Int_t k = 0; k < loop; k++) {
      detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
      AliTRDCalROC *calROC = object->GetCalROC(detector);
      Float_t mean         = detobject->GetValue(detector);
      if(mean == 0) continue;
      Int_t rowMax    = calROC->GetNrows();
      Int_t colMax    = calROC->GetNcols();
      for (Int_t row = 0; row < rowMax; row++) {
	for (Int_t col = 0; col < colMax; col++) {
	  value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
	  calROC->SetValue(col,row,TMath::Abs(value)/mean);
	} // Col
      } // Row
    } 
  }
  return object;    

}
//_____________________________________________________________________________
TObject *AliTRDCalibraFit::CreatePadObjectT0(const TObjArray *vectorFit, const AliTRDCalDet *detobject)
{
  //
  // It Creates the AliTRDCalPad object from AliTRDFitInfo2
  // You need first to create the object for the detectors,
  // where the mean value is put.
  // This object has to be written in the database
  //
  
  // Create the DetObject
  AliTRDCalPad *object = new AliTRDCalPad("LocalT0","T0 (local variations)");

  if(!vectorFit){
    for(Int_t k = 0; k < 540; k++){
      AliTRDCalROC *calROC = object->GetCalROC(k);
      Int_t nchannels = calROC->GetNchannels();
      for(Int_t ch = 0; ch < nchannels; ch++){
	calROC->SetValue(ch,0.0);
      }
    }
  }
  else {
    
    Int_t loop = (Int_t) vectorFit->GetEntriesFast();
    if(loop != 540) AliInfo("The Vector Fit is not complete!");
    Int_t detector = -1;
    Float_t value  = 0.0;
    
    for (Int_t k = 0; k < loop; k++) {
      detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
      AliTRDCalROC *calROC = object->GetCalROC(detector);
      Float_t min          = detobject->GetValue(detector);
      Int_t rowMax    = calROC->GetNrows();
      Int_t colMax    = calROC->GetNcols();
      for (Int_t row = 0; row < rowMax; row++) {
	for (Int_t col = 0; col < colMax; col++) {
	  value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
	  // check successful
	  if(value > 70.0) value = value - 100.0;
	  //
	  calROC->SetValue(col,row,value-min);
	} // Col
      } // Row
    } 
  }
  return object;    

}
//_____________________________________________________________________________
TObject *AliTRDCalibraFit::CreatePadObjectPRF(const TObjArray *vectorFit)
{
  //
  // It Creates the AliTRDCalPad object from AliTRDFitInfo
  // This object has to be written in the database
  //
  
  // Create the DetObject
  AliTRDCalPad *object = new AliTRDCalPad("PRFWidth","PRFWidth");

  Int_t loop = (Int_t) vectorFit->GetEntriesFast();
  if(loop != 540) AliInfo("The Vector Fit is not complete!");
  Int_t detector = -1;
  Float_t value  = 0.0;

  for (Int_t k = 0; k < loop; k++) {
    detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
    AliTRDCalROC *calROC = object->GetCalROC(detector);
    Int_t rowMax    = calROC->GetNrows();
    Int_t colMax    = calROC->GetNcols();
    for (Int_t row = 0; row < rowMax; row++) {
      for (Int_t col = 0; col < colMax; col++) {
	value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
       	calROC->SetValue(col,row,TMath::Abs(value));
      } // Col
    } // Row
  } 

  return object;  

}
//_____________________________________________________________________________
AliTRDCalDet *AliTRDCalibraFit::MakeOutliersStatDet(const TObjArray *vectorFit, const char *name, Double_t &mean)
{
  //
  // It Creates the AliTRDCalDet object from AliTRDFitInfo
  // 0 successful fit 1 not successful fit
  // mean is the mean value over the successful fit
  // do not use it for t0: no meaning
  //
  
  // Create the CalObject
  AliTRDCalDet *object = new AliTRDCalDet(name,name);
  mean = 0.0;
  Int_t count = 0;
  
  Int_t loop = (Int_t) vectorFit->GetEntriesFast();
  if(loop != 540) {
    AliInfo("The Vector Fit is not complete! We initialise all outliers");
    for(Int_t k = 0; k < 540; k++){
      object->SetValue(k,1.0);
    }
  }
  Int_t detector = -1;
  Float_t value  = 0.0;
  
  for (Int_t k = 0; k < loop; k++) {
    detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
    value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
    if(value <= 0) object->SetValue(detector,1.0);
    else {
      object->SetValue(detector,0.0);
      mean += value;
      count++;
    }
  }
  if(count > 0) mean /= count;
  return object;  
}
//_____________________________________________________________________________
TObject *AliTRDCalibraFit::MakeOutliersStatPad(const TObjArray *vectorFit, const char *name, Double_t &mean)
{
  //
  // It Creates the AliTRDCalPad object from AliTRDFitInfo
  // 0 not successful fit 1 successful fit
  // mean mean value over the successful fit
  //
  
  // Create the CalObject
  AliTRDCalPad *object = new AliTRDCalPad(name,name);
  mean = 0.0;
  Int_t count = 0;
  
  Int_t loop = (Int_t) vectorFit->GetEntriesFast();
  if(loop != 540) {
    AliInfo("The Vector Fit is not complete! We initialise all outliers");
    for(Int_t k = 0; k < 540; k++){
      AliTRDCalROC *calROC = object->GetCalROC(k);
      Int_t nchannels = calROC->GetNchannels();
      for(Int_t ch = 0; ch < nchannels; ch++){
	calROC->SetValue(ch,1.0);
      }
    }
  }
  Int_t detector = -1;
  Float_t value  = 0.0;
  
  for (Int_t k = 0; k < loop; k++) {
    detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
    AliTRDCalROC *calROC = object->GetCalROC(detector);
    Int_t nchannels    = calROC->GetNchannels();
    for (Int_t ch = 0; ch < nchannels; ch++) {
      value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[ch];
      if(value <= 0) calROC->SetValue(ch,1.0);
      else {
	calROC->SetValue(ch,0.0);
	mean += value;
	count++;
      }
    } // channels
  }
  if(count > 0) mean /= count;
  return object;  
}
//_____________________________________________________________________________
void AliTRDCalibraFit::SetPeriodeFitPH(Int_t periodeFitPH)
{ 
  //
  // Set FitPH if 1 then each detector will be fitted
  //

  if (periodeFitPH > 0) {
    fFitPHPeriode   = periodeFitPH; 
  }
  else {
    AliInfo("periodeFitPH must be higher than 0!");
  }

}
//_____________________________________________________________________________
void AliTRDCalibraFit::SetBeginFitCharge(Float_t beginFitCharge)
{ 
  //
  // The fit of the deposited charge distribution begins at
  // histo->Mean()/beginFitCharge
  // You can here set beginFitCharge
  //

  if (beginFitCharge > 0) {
    fBeginFitCharge = beginFitCharge; 
  }
  else {
    AliInfo("beginFitCharge must be strict positif!");
  }

}

//_____________________________________________________________________________
void AliTRDCalibraFit::SetT0Shift0(Float_t t0Shift) 
{ 
  //
  // The t0 calculated with the maximum positif slope is shift from t0Shift0
  // You can here set t0Shift0
  //

  if (t0Shift > 0) {
    fT0Shift0 = t0Shift; 
  } 
  else {
    AliInfo("t0Shift0 must be strict positif!");
  }

}

//_____________________________________________________________________________
void AliTRDCalibraFit::SetT0Shift1(Float_t t0Shift) 
{ 
  //
  // The t0 calculated with the maximum of the amplification region is shift from t0Shift1
  // You can here set t0Shift1
  //

  if (t0Shift > 0) {
    fT0Shift1 = t0Shift; 
  } 
  else {
    AliInfo("t0Shift must be strict positif!");
  }

}

//_____________________________________________________________________________
void AliTRDCalibraFit::SetRangeFitPRF(Float_t rangeFitPRF)
{ 
  //
  // The fit of the PRF is from -rangeFitPRF to rangeFitPRF
  // You can here set rangeFitPRF
  //

  if ((rangeFitPRF >    0) && 
      (rangeFitPRF <= 1.5)) {
    fRangeFitPRF = rangeFitPRF;
  } 
  else {
    AliInfo("rangeFitPRF must be between 0 and 1.0");
  }

}

//_____________________________________________________________________________
void AliTRDCalibraFit::SetMinEntries(Int_t minEntries)
{ 
  //
  // Minimum entries for fitting
  //

  if (minEntries >    0) {
    fMinEntries = minEntries;
  } 
  else {
    AliInfo("fMinEntries must be >= 0.");
  }

}

//_____________________________________________________________________________
void AliTRDCalibraFit::SetRebin(Short_t rebin)
{ 
  //
  // Rebin with rebin time less bins the Ch histo
  // You can set here rebin that should divide the number of bins of CH histo
  //

  if (rebin > 0) {
    fRebin = rebin; 
    AliInfo("You have to be sure that fRebin divides fNumberBinCharge used!");
  } 
  else {
    AliInfo("You have to choose a positiv value!");
  }

}
//_____________________________________________________________________________
Bool_t AliTRDCalibraFit::FillVectorFit()
{
  //
  // For the Fit functions fill the vector Fit
  //

  AliTRDFitInfo *fitInfo = new AliTRDFitInfo();

  Int_t ntotal = 1;
  if (GetStack(fCountDet) == 2) {
    ntotal = 1728;
  }
  else {
    ntotal = 2304;
  }

  //printf("For the detector %d , ntotal %d and fCoefCH[0] %f\n",countdet,ntotal,fCoefCH[0]);
  Float_t *coef = new Float_t[ntotal];
  for (Int_t i = 0; i < ntotal; i++) {
    coef[i] = fCurrentCoefDetector[i];
  }
  
  Int_t detector = fCountDet;
  // Set
  fitInfo->SetCoef(coef);
  fitInfo->SetDetector(detector);
  fVectorFit.Add((TObject *) fitInfo);

  return kTRUE;

}
//_____________________________________________________________________________
Bool_t AliTRDCalibraFit::FillVectorFit2()
{
  //
  // For the Fit functions fill the vector Fit
  //

  AliTRDFitInfo *fitInfo = new AliTRDFitInfo();

  Int_t ntotal = 1;
  if (GetStack(fCountDet) == 2) {
    ntotal = 1728;
  }
  else {
    ntotal = 2304;
  }

  //printf("For the detector %d , ntotal %d and fCoefCH[0] %f\n",countdet,ntotal,fCoefCH[0]);
  Float_t *coef = new Float_t[ntotal];
  for (Int_t i = 0; i < ntotal; i++) {
    coef[i] = fCurrentCoefDetector2[i];
  }
  
  Int_t detector = fCountDet;
  // Set
  fitInfo->SetCoef(coef);
  fitInfo->SetDetector(detector);
  fVectorFit2.Add((TObject *) fitInfo);

  return kTRUE;

}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::InitFit(Int_t nbins, Int_t i)
{
  //
  // Init the number of expected bins and fDect1[i] fDect2[i] 
  //

  gStyle->SetPalette(1);
  gStyle->SetOptStat(1111);
  gStyle->SetPadBorderMode(0);
  gStyle->SetCanvasColor(10);
  gStyle->SetPadLeftMargin(0.13);
  gStyle->SetPadRightMargin(0.01);
  
  // Mode groups of pads: the total number of bins!
  CalculNumberOfBinsExpected(i);
  
  // Quick verification that we have the good pad calibration mode!
  if (fNumberOfBinsExpected != nbins) {
    AliInfo(Form("It doesn't correspond to the mode of pad group calibration: expected %d and seen %d!",fNumberOfBinsExpected,nbins));
    return kFALSE;
  }
  
  // Security for fDebug 3 and 4
  if ((fDebugLevel >= 3) && 
      ((fDet[0] >  5) || 
       (fDet[1] >  4) || 
       (fDet[2] > 17))) {
    AliInfo("This detector doesn't exit!");
    return kFALSE;
  }

  // Determine fDet1 and fDet2 and set the fNfragZ and fNfragRphi for debug 3 and 4
  CalculDect1Dect2(i);

 
  return kTRUE;
}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::InitFitCH()
{
  //
  // Init the fVectorFitCH for normalisation
  // Init the histo for debugging 
  //

  gDirectory = gROOT;
 
  fScaleFitFactor = 0.0;
  if( fCurrentCoefDetector ) delete [] fCurrentCoefDetector;
  fCurrentCoefDetector   = new Float_t[2304];
  for (Int_t k = 0; k < 2304; k++) {
    fCurrentCoefDetector[k] = 0.0;    
  }
  fVectorFit.SetName("gainfactorscoefficients");

  // fDebug == 0 nothing
  // fDebug == 1 and fFitVoir no histo
  if (fDebugLevel == 1) {
    if(!CheckFitVoir()) return kFALSE;
  }
  //Get the CalDet object
  if(fAccCDB){
    AliTRDcalibDB     *cal    = AliTRDcalibDB::Instance();
    if (!cal) {
      AliInfo("Could not get calibDB");
      return kFALSE;
    }
    if(fCalDet) delete fCalDet;
    fCalDet = new AliTRDCalDet(*(cal->GetGainFactorDet()));
  }
  else{
    Float_t devalue = 1.0;
    if(fCalDet) delete fCalDet;
    fCalDet = new AliTRDCalDet("ChamberGainFactor","GainFactor (detector value)");
    for(Int_t k = 0; k < 540; k++){
      fCalDet->SetValue(k,devalue);
    }
  }
  return kTRUE;
  
}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::InitFitPH()
{
  //
  // Init the arrays of results 
  // Init the histos for debugging 
  //

  gDirectory = gROOT;
  fVectorFit.SetName("driftvelocitycoefficients");
  fVectorFit2.SetName("t0coefficients");

  if( fCurrentCoefDetector ) delete [] fCurrentCoefDetector;
  fCurrentCoefDetector   = new Float_t[2304];
  for (Int_t k = 0; k < 2304; k++) {
    fCurrentCoefDetector[k] = 0.0;    
  }
  if( fCurrentCoefDetector2 ) delete [] fCurrentCoefDetector2;
  fCurrentCoefDetector2   = new Float_t[2304];
  for (Int_t k = 0; k < 2304; k++) {
    fCurrentCoefDetector2[k] = 0.0;    
  }
 
  //fDebug == 0 nothing
  // fDebug == 1 and fFitVoir no histo
  if (fDebugLevel == 1) {
    if(!CheckFitVoir()) return kFALSE;
  }
  //Get the CalDet object
  if(fAccCDB){
    AliTRDcalibDB     *cal    = AliTRDcalibDB::Instance();
    if (!cal) {
      AliInfo("Could not get calibDB");
      return kFALSE;
    }
    if(fCalDet) delete fCalDet;
    if(fCalDet2) delete fCalDet2;
    fCalDet  = new AliTRDCalDet(*(cal->GetVdriftDet()));
    fCalDet2 = new AliTRDCalDet(*(cal->GetT0Det())); 
  }
  else{
    Float_t devalue  = 1.5;
    Float_t devalue2 = 0.0; 
    if(fCalDet) delete fCalDet;
    if(fCalDet2) delete fCalDet2;
    fCalDet  = new AliTRDCalDet("ChamberVdrift","TRD drift velocities (detector value)");
    fCalDet2 = new AliTRDCalDet("ChamberT0","T0 (detector value)");
    for(Int_t k = 0; k < 540; k++){
      fCalDet->SetValue(k,devalue);
      fCalDet2->SetValue(k,devalue2);
    }
  }
  return kTRUE;
}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::InitFitPRF()
{
  //
  // Init the calibration mode (Nz, Nrphi), the histograms for
  // debugging the fit methods if fDebug > 0, 
  //
  
  gDirectory = gROOT;
  fVectorFit.SetName("prfwidthcoefficients");
 
  if( fCurrentCoefDetector ) delete [] fCurrentCoefDetector;
  fCurrentCoefDetector   = new Float_t[2304];
  for (Int_t k = 0; k < 2304; k++) {
    fCurrentCoefDetector[k] = 0.0;    
  }
  
  // fDebug == 0 nothing
  // fDebug == 1 and fFitVoir no histo
  if (fDebugLevel == 1) {
    if(!CheckFitVoir()) return kFALSE;
  }
  return kTRUE;
}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::InitFitLinearFitter()
{
  //
  // Init the fCalDet, fVectorFit fCurrentCoefDetector 
  //
  
  gDirectory = gROOT;
 
 if( fCurrentCoefDetector ) delete [] fCurrentCoefDetector;
 if( fCurrentCoefDetector2 ) delete [] fCurrentCoefDetector2;
  fCurrentCoefDetector   = new Float_t[2304];
  fCurrentCoefDetector2  = new Float_t[2304];
  for (Int_t k = 0; k < 2304; k++) {
    fCurrentCoefDetector[k]  = 0.0;
    fCurrentCoefDetector2[k] = 0.0;    
  }

  if((!fCalDetVdriftUsed) || (!fCalDetExBUsed)) return kFALSE; 

  return kTRUE;
}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::InitFitExbAlt()
{
  //
  // Init the fCalDet, fVectorFit fCurrentCoefDetector 
  //
  
  gDirectory = gROOT;
 
  if( fCurrentCoefDetector2 ) delete [] fCurrentCoefDetector2;
  fCurrentCoefDetector2   = new Float_t[2304];
  for (Int_t k = 0; k < 2304; k++) {
    fCurrentCoefDetector2[k]  = 0.0;
  }

  return kTRUE;
}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
void AliTRDCalibraFit::InitfCountDetAndfCount(Int_t i)
{
  //
  // Init the current detector where we are fCountDet and the
  // next fCount for the functions Fit... 
  //

  // Loop on the Xbins of ch!!
  fCountDet = -1; // Current detector
  fCount    =  0; // To find the next detector
  
  // If fDebug >= 3
  if (fDebugLevel >= 3) {
    // Set countdet to the detector
    fCountDet = AliTRDgeometry::GetDetector(fDet[0],fDet[1],fDet[2]);
    // Set counter to write at the end of the detector
    fCount = fDect2;
    // Get the right calib objects
    SetCalROC(i);
  }
  if(fDebugLevel == 1) {
    fCountDet = 0;
    fCalibraMode->CalculXBins(fCountDet,i);
    if((fCalibraMode->GetNz(i)!=100) && (fCalibraMode->GetNrphi(i)!=100)){
      while(fCalibraMode->GetXbins(i) <=fFitVoir){
	fCountDet++;
	fCalibraMode->CalculXBins(fCountDet,i);
	//printf("GetXBins %d\n",fCalibraMode->GetXbins(i));
      }      
    }
    else {
      fCountDet++;
    }
    fCount    = fCalibraMode->GetXbins(i);
    fCountDet--;
    // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
    fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
    fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
				      ,(Int_t) GetStack(fCountDet)
				      ,(Int_t) GetSector(fCountDet),i);
  }
}
//_______________________________________________________________________________
void AliTRDCalibraFit::CalculNumberOfBinsExpected(Int_t i)
{
  //
  // Calculate the number of bins expected (calibration groups)
  //
  
  fNumberOfBinsExpected = 0;
  // All
  if((fCalibraMode->GetNz(i) == 100) && (fCalibraMode->GetNrphi(i) == 100)){
    fNumberOfBinsExpected = 1;
    return;
  }
  // Per supermodule
  if((fCalibraMode->GetNz(i) == 10) && (fCalibraMode->GetNrphi(i) == 10)){
    fNumberOfBinsExpected = 18;
    return;
  }
  // More
  fCalibraMode->ModePadCalibration(2,i);
  fCalibraMode->ModePadFragmentation(0,2,0,i);
  fCalibraMode->SetDetChamb2(i);
  if (fDebugLevel > 1) {
    AliInfo(Form("For the chamber 2: %d",fCalibraMode->GetDetChamb2(i)));
  }
  fNumberOfBinsExpected += 6 * 18 * fCalibraMode->GetDetChamb2(i);
  fCalibraMode->ModePadCalibration(0,i);
  fCalibraMode->ModePadFragmentation(0,0,0,i);
  fCalibraMode->SetDetChamb0(i);
  if (fDebugLevel > 1) {
    AliInfo(Form("For the other chamber 0: %d",fCalibraMode->GetDetChamb0(i)));
  }
  fNumberOfBinsExpected += 6 * 4 * 18 * fCalibraMode->GetDetChamb0(i);
 
}
//_______________________________________________________________________________
void AliTRDCalibraFit::CalculDect1Dect2(Int_t i)
{
  //
  // Calculate the range of fits
  //
  
  fDect1 = -1;
  fDect2 = -1;
  if (fDebugLevel == 1) {
    fDect1 = fFitVoir;
    fDect2 = fDect1 +1;
  }
  if ((fDebugLevel == 2) || (fDebugLevel == 0)) {
    fDect1 = 0;
    fDect2 = fNumberOfBinsExpected;
  }
  if (fDebugLevel >= 3) {
    fCountDet = AliTRDgeometry::GetDetector(fDet[0],fDet[1],fDet[2]);
    fCalibraMode->CalculXBins(fCountDet,i);
    fDect1 = fCalibraMode->GetXbins(i);
    // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
    fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
    fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
				      ,(Int_t) GetStack(fCountDet)
				      ,(Int_t) GetSector(fCountDet),i);
    // Set for the next detector
    fDect2 = fDect1 + fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i);
  }
}
//_______________________________________________________________________________
Bool_t AliTRDCalibraFit::CheckFitVoir()
{
  //
  // Check if fFitVoir is in the range
  //
  
  if (fFitVoir < fNumberOfBinsExpected) {
    AliInfo(Form("We will see the fit of the object %d",fFitVoir));
  }
  else {
    AliInfo("fFitVoir is out of range of the histo!");
    return kFALSE;
  }
  return kTRUE;
}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
void AliTRDCalibraFit::UpdatefCountDetAndfCount(Int_t idect, Int_t i)
{
  //
  // See if we are in a new detector and update the
  // variables fNfragZ and fNfragRphi if yes 
  // Will never happen for only one detector (3 and 4)
  // Doesn't matter for 2
  //
  if (fCount == idect) {
    // On en est au detector (or first detector in the group)
    fCountDet += 1;
    AliDebug(2,Form("We are at the detector %d\n",fCountDet));
    // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
    fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
    fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
			     	       ,(Int_t) GetStack(fCountDet)
                                       ,(Int_t) GetSector(fCountDet),i);
    // Set for the next detector
    fCount += fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i);
    // calib objects
    SetCalROC(i);
  }
}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
void AliTRDCalibraFit::ReconstructFitRowMinRowMax(Int_t idect, Int_t i)
{
  //
  // Reconstruct the min pad row, max pad row, min pad col and
  // max pad col of the calibration group for the Fit functions
  // idect is the calibration group inside the detector
  //
  if (fDebugLevel !=  1) {
    fCalibraMode->ReconstructionRowPadGroup((Int_t) (idect-(fCount-(fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)))),i);
  }
  AliDebug(2,Form("AliTRDCalibraFit::ReconstructFitRowMinRowMax: the local calibration group is %d",idect-(fCount-(fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)))));
  AliDebug(2,Form("AliTRDCalibraFit::ReconstructFitRowMinRowMax: the number of group per detector is %d",fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)));
}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::NotEnoughStatisticCH(Int_t idect)
{
  //
  // For the case where there are not enough entries in the histograms
  // of the calibration group, the value present in the choosen database
  // will be put. A negativ sign enables to know that a fit was not possible.
  //
  
  if (fDebugLevel == 1) {
    AliInfo("The element has not enough statistic to be fitted");
  }
  else if (fNbDet > 0){
    Int_t firstdetector = fCountDet;
    Int_t lastdetector  = fCountDet+fNbDet;
    //AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted",idect,firstdetector,lastdetector));
    // loop over detectors
    for(Int_t det = firstdetector; det < lastdetector; det++){

      //Set the calibration object again
      fCountDet = det;
      SetCalROC(0);   

      // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
      // Put them at 1
      fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),0);
      fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
					 ,(Int_t) GetStack(fCountDet)
					 ,(Int_t) GetSector(fCountDet),0);
      // Reconstruct row min row max
      ReconstructFitRowMinRowMax(idect,0);      

      // Calcul the coef from the database choosen for the detector
      CalculChargeCoefMean(kFALSE);
      
      //stack 2, not stack 2
      Int_t factor = 0;
      if(GetStack(fCountDet) == 2) factor = 12;
      else factor = 16;
      
      // Fill the fCurrentCoefDetector with negative value to say: not fitted
      for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
	for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
	  fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
	}
      }
      
      //Put default value negative
      fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
      fCurrentCoefE   = 0.0;
      
      // Fill the stuff
      FillVectorFit();
      // Debug
      if(fDebugLevel > 1){ 
	
	if ( !fDebugStreamer ) {
	  //debug stream
	  TDirectory *backup = gDirectory;
	  fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
	  if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
	} 
	
	Int_t   detector   = fCountDet;
	Int_t   caligroup  = idect;
	Short_t rowmin     = fCalibraMode->GetRowMin(0);
	Short_t rowmax     = fCalibraMode->GetRowMax(0);
	Short_t colmin     = fCalibraMode->GetColMin(0);
	Short_t colmax     = fCalibraMode->GetColMax(0);
	Float_t gf         = fCurrentCoef[0]; 
	Float_t gfs        = fCurrentCoef[1]; 
	Float_t gfE        = fCurrentCoefE;
	
	(*fDebugStreamer) << "FillFillCH" <<
	  "detector=" << detector <<
	  "caligroup=" << caligroup <<
	  "rowmin=" << rowmin <<
	  "rowmax=" << rowmax <<
	  "colmin=" << colmin <<
	  "colmax=" << colmax <<
	  "gf=" << gf <<
	  "gfs=" << gfs <<
	  "gfE=" << gfE <<
	  "\n"; 
	
      }
      // Reset
      for (Int_t k = 0; k < 2304; k++) {
	fCurrentCoefDetector[k] = 0.0;
      }
      
    }// loop detector
    AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
  }
  else {

//AliInfo(Form("The element %d in this detector %d has not enough statistic to be fitted",idect-(fCount-(fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0))),fCountDet));
    
    // Calcul the coef from the database choosen
    CalculChargeCoefMean(kFALSE);

    //stack 2, not stack 2
    Int_t factor = 0;
    if(GetStack(fCountDet) == 2) factor = 12;
    else factor = 16;
    
    // Fill the fCurrentCoefDetector with negative value to say: not fitted
    for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
      for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
	fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
      }
    }
    
    //Put default value negative
    fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
    fCurrentCoefE   = 0.0;
   
    FillFillCH(idect);
  }
  
  return kTRUE;
}


//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::NotEnoughStatisticPH(Int_t idect,Double_t nentries)
{
  //
  // For the case where there are not enough entries in the histograms
  // of the calibration group, the value present in the choosen database
  // will be put. A negativ sign enables to know that a fit was not possible.
  //
  if (fDebugLevel == 1) {
    AliInfo("The element has not enough statistic to be fitted");
  }
  else if (fNbDet > 0) {

    Int_t firstdetector = fCountDet;
    Int_t lastdetector  = fCountDet+fNbDet;
//AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted",idect,firstdetector,lastdetector));
    // loop over detectors
    for(Int_t det = firstdetector; det < lastdetector; det++){

      //Set the calibration object again
      fCountDet = det;
      SetCalROC(1);   

      // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
      // Put them at 1
      fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),1);
      fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
					 ,(Int_t) GetStack(fCountDet)
					 ,(Int_t) GetSector(fCountDet),1);
      // Reconstruct row min row max
      ReconstructFitRowMinRowMax(idect,1);      

      // Calcul the coef from the database choosen for the detector
      CalculVdriftCoefMean();
      CalculT0CoefMean();
      
      //stack 2, not stack 2
      Int_t factor = 0;
      if(GetStack(fCountDet) == 2) factor = 12;
      else factor = 16;
      
      // Fill the fCurrentCoefDetector with negative value to say: not fitted
      for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
	for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
	  fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
	  fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[1] + 100.0;
      	}
      }
      
      //Put default value negative
      fCurrentCoef[0]  = -TMath::Abs(fCurrentCoef[1]);
      fCurrentCoefE    = 0.0;
      fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
      fCurrentCoefE2   = 0.0;
            
      // Fill the stuff
      FillVectorFit();
      FillVectorFit2();
      // Debug
      if(fDebugLevel > 1){ 

	if ( !fDebugStreamer ) {
	  //debug stream
	  TDirectory *backup = gDirectory;
	  fDebugStreamer = new TTreeSRedirector("TRDDebugFitPH.root");
	  if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
	} 
	
	
	Int_t   detector     = fCountDet;
	Int_t   caligroup    = idect;
	Short_t rowmin       = fCalibraMode->GetRowMin(1);
	Short_t rowmax       = fCalibraMode->GetRowMax(1);
	Short_t colmin       = fCalibraMode->GetColMin(1);
	Short_t colmax       = fCalibraMode->GetColMax(1);
	Float_t vf           = fCurrentCoef[0]; 
	Float_t vs           = fCurrentCoef[1]; 
	Float_t vfE          = fCurrentCoefE;
	Float_t t0f          = fCurrentCoef2[0]; 
	Float_t t0s          = fCurrentCoef2[1]; 
	Float_t t0E          = fCurrentCoefE2;
	
	
	
	(* fDebugStreamer) << "FillFillPH"<<
	"detector="<<detector<<
	  "nentries="<<nentries<<
	  "caligroup="<<caligroup<<
	  "rowmin="<<rowmin<<
	  "rowmax="<<rowmax<<
	  "colmin="<<colmin<<
	  "colmax="<<colmax<<
	  "vf="<<vf<<
	  "vs="<<vs<<
	  "vfE="<<vfE<<
	  "t0f="<<t0f<<
	  "t0s="<<t0s<<
	  "t0E="<<t0E<<
	  "\n";  
      }
      // Reset
      for (Int_t k = 0; k < 2304; k++) {
	fCurrentCoefDetector[k] = 0.0;
	fCurrentCoefDetector2[k] = 0.0;
      }
      
    }// loop detector
    AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
  }    
  else {

//AliInfo(Form("The element %d in this detector %d has not enough statistic to be fitted",idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1))),fCountDet));

    CalculVdriftCoefMean();
    CalculT0CoefMean();
  
    //stack 2 and not stack 2
    Int_t factor = 0;
    if(GetStack(fCountDet) == 2) factor = 12;
    else factor = 16;


    // Fill the fCurrentCoefDetector 2
    for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
      for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
	fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
	fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[1] + 100.0;
      }
    }

    // Put the default value
    fCurrentCoef[0]  = -TMath::Abs(fCurrentCoef[1]);
    fCurrentCoefE    = 0.0;
    fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
    fCurrentCoefE2   = 0.0;
     
    FillFillPH(idect,nentries);
    
  }
  
  return kTRUE;
  
}


//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::NotEnoughStatisticPRF(Int_t idect)
{
  //
  // For the case where there are not enough entries in the histograms
  // of the calibration group, the value present in the choosen database
  // will be put. A negativ sign enables to know that a fit was not possible.
  //
  
  if (fDebugLevel == 1) {
    AliInfo("The element has not enough statistic to be fitted");
  }
  else if (fNbDet > 0){
  
    Int_t firstdetector = fCountDet;
    Int_t lastdetector  = fCountDet+fNbDet;
//  AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted",idect,firstdetector,lastdetector));
    
    // loop over detectors
    for(Int_t det = firstdetector; det < lastdetector; det++){

      //Set the calibration object again
      fCountDet = det;
      SetCalROC(2);   

      // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
      // Put them at 1
      fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),2);
      fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
					 ,(Int_t) GetStack(fCountDet)
					 ,(Int_t) GetSector(fCountDet),2);
      // Reconstruct row min row max
      ReconstructFitRowMinRowMax(idect,2);      

      // Calcul the coef from the database choosen for the detector
      CalculPRFCoefMean();
      
      //stack 2, not stack 2
      Int_t factor = 0;
      if(GetStack(fCountDet) == 2) factor = 12;
      else factor = 16;
      
      // Fill the fCurrentCoefDetector with negative value to say: not fitted
      for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
	for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
	  fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
	}
      }
      
      //Put default value negative
      fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
      fCurrentCoefE   = 0.0;
      
      // Fill the stuff
      FillVectorFit();
      // Debug
      if(fDebugLevel > 1){
	
	if ( !fDebugStreamer ) {
	  //debug stream
	  TDirectory *backup = gDirectory;
	  fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
	  if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
	} 
	
	Int_t   detector     = fCountDet;
	Int_t   layer        = GetLayer(fCountDet);
	Int_t   caligroup    = idect;
	Short_t rowmin       = fCalibraMode->GetRowMin(2);
	Short_t rowmax       = fCalibraMode->GetRowMax(2);
	Short_t colmin       = fCalibraMode->GetColMin(2);
	Short_t colmax       = fCalibraMode->GetColMax(2);
	Float_t widf         = fCurrentCoef[0]; 
	Float_t wids         = fCurrentCoef[1]; 
	Float_t widfE        = fCurrentCoefE;
	
	(* fDebugStreamer) << "FillFillPRF"<<
	  "detector="<<detector<<
	  "layer="<<layer<<
	  "caligroup="<<caligroup<<
	  "rowmin="<<rowmin<<
	  "rowmax="<<rowmax<<
	  "colmin="<<colmin<<
	  "colmax="<<colmax<<
	  "widf="<<widf<<
	  "wids="<<wids<<
	  "widfE="<<widfE<<
	  "\n";  
      }
      // Reset
      for (Int_t k = 0; k < 2304; k++) {
	fCurrentCoefDetector[k] = 0.0;
      }
      
    }// loop detector
    AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
  }
  else {
    
//  AliInfo(Form("The element %d in this detector %d has not enough statistic to be fitted",idect-(fCount-(fCalibraMode->GetNfragZ(2)*fCalibraMode->GetNfragRphi(2))),fCountDet));
    
    CalculPRFCoefMean();
    
    // stack 2 and not stack 2
    Int_t factor = 0;
    if(GetStack(fCountDet) == 2) factor = 12;
    else factor = 16;

    
    // Fill the fCurrentCoefDetector
    for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
      for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
	fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
      }
    }

    // Put the default value
    fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
    fCurrentCoefE   = 0.0;
    
    FillFillPRF(idect);
  }
  
  return kTRUE;

}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::NotEnoughStatisticLinearFitter()
{
  //
  // For the case where there are not enough entries in the histograms
  // of the calibration group, the value present in the choosen database
  // will be put. A negativ sign enables to know that a fit was not possible.
  //
  
  // Calcul the coef from the database choosen
  CalculVdriftLorentzCoef();

  Int_t factor = 0;
  if(GetStack(fCountDet) == 2) factor = 1728;
  else factor = 2304;
    
    
  // Fill the fCurrentCoefDetector
  for (Int_t k = 0; k < factor; k++) {
    fCurrentCoefDetector[k] = -TMath::Abs(fCurrentCoef[1]);
    // should be negative
    fCurrentCoefDetector2[k] = fCurrentCoef2[1]+100.0;
  }
   
  
  //Put default opposite sign only for vdrift
  fCurrentCoef[0]  = -TMath::Abs(fCurrentCoef[1]);
  fCurrentCoefE    = 0.0;
  fCurrentCoef2[0] = fCurrentCoef2[1]+100.0;
  fCurrentCoefE2 = 0.0; 
  
  FillFillLinearFitter();
    
  return kTRUE;
}

//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::NotEnoughStatisticExbAlt()
{
  //
  // For the case where there are not enough entries in the histograms
  // of the calibration group, the value present in the choosen database
  // will be put. A negativ sign enables to know that a fit was not possible.
  //
  
  Int_t factor = 0;
  if(GetStack(fCountDet) == 2) factor = 1728;
  else factor = 2304;
    
    
  // Fill the fCurrentCoefDetector
  for (Int_t k = 0; k < factor; k++) {
    fCurrentCoefDetector2[k] = 100.0;
  }
   
  fCurrentCoef2[0] = 100.0;
  fCurrentCoefE2 = 0.0; 
  
  FillFillExbAlt();
    
  return kTRUE;
}

//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::FillInfosFitCH(Int_t idect)
{
  //
  // Fill the coefficients found with the fits or other
  // methods from the Fit functions
  //

  if (fDebugLevel != 1) {
    if (fNbDet > 0){
      Int_t firstdetector = fCountDet;
      Int_t lastdetector  = fCountDet+fNbDet;
      //    AliInfo(Form("The element %d containing the detectors %d to %d has been fitted",idect,firstdetector,lastdetector));
      // loop over detectors
      for(Int_t det = firstdetector; det < lastdetector; det++){
	
	//Set the calibration object again
	fCountDet = det;
	SetCalROC(0);   
	
	// Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
	// Put them at 1
	fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),0);
	fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
					   ,(Int_t) GetStack(fCountDet)
					   ,(Int_t) GetSector(fCountDet),0);
	// Reconstruct row min row max
	ReconstructFitRowMinRowMax(idect,0);      
	
	// Calcul the coef from the database choosen for the detector
	if(fCurrentCoef[0] < 0.0) CalculChargeCoefMean(kFALSE);
	else CalculChargeCoefMean(kTRUE);
	
	//stack 2, not stack 2
	Int_t factor = 0;
	if(GetStack(fCountDet) == 2) factor = 12;
	else factor = 16;
	
	// Fill the fCurrentCoefDetector with negative value to say: not fitted
	Double_t coeftoput = 1.0;
	if(fCurrentCoef[0] < 0.0) coeftoput = - TMath::Abs(fCurrentCoef[1]);
	else coeftoput = fCurrentCoef[0];
	for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
	  for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
	    fCurrentCoefDetector[(Int_t)(j*factor+k)] = coeftoput;
	  }
	}
	
	// Fill the stuff
	FillVectorFit();
	// Debug
	if(fDebugLevel > 1){ 
	  
	  if ( !fDebugStreamer ) {
	    //debug stream
	    TDirectory *backup = gDirectory;
	    fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
	    if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
	  } 
	  
	  Int_t   detector   = fCountDet;
	  Int_t   caligroup  = idect;
	  Short_t rowmin     = fCalibraMode->GetRowMin(0);
	  Short_t rowmax     = fCalibraMode->GetRowMax(0);
	  Short_t colmin     = fCalibraMode->GetColMin(0);
	  Short_t colmax     = fCalibraMode->GetColMax(0);
	  Float_t gf         = fCurrentCoef[0]; 
	  Float_t gfs        = fCurrentCoef[1]; 
	  Float_t gfE        = fCurrentCoefE;
	  
	  (*fDebugStreamer) << "FillFillCH" <<
	    "detector=" << detector <<
	    "caligroup=" << caligroup <<
	    "rowmin=" << rowmin <<
	    "rowmax=" << rowmax <<
	    "colmin=" << colmin <<
	    "colmax=" << colmax <<
	    "gf=" << gf <<
	    "gfs=" << gfs <<
	    "gfE=" << gfE <<
	    "\n"; 
	  
	}
	// Reset
	for (Int_t k = 0; k < 2304; k++) {
	  fCurrentCoefDetector[k] = 0.0;
	}
	
      }// loop detector
      //printf("Check the count now: fCountDet %d\n",fCountDet);
    }
    else{
      
      Int_t factor = 0;
      if(GetStack(fCountDet) == 2) factor = 12;
      else factor = 16; 
      
      for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
	for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
	  fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
	}
      }
      
      FillFillCH(idect);
    }
  }

  return kTRUE;

}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::FillInfosFitPH(Int_t idect,Double_t nentries)
{
  //
  // Fill the coefficients found with the fits or other
  // methods from the Fit functions
  //

  if (fDebugLevel != 1) {
    if (fNbDet > 0){
      
      Int_t firstdetector = fCountDet;
      Int_t lastdetector  = fCountDet+fNbDet;
// AliInfo(Form("The element %d containing the detectors %d to %d has been fitted",idect,firstdetector,lastdetector));
      
      // loop over detectors
      for(Int_t det = firstdetector; det < lastdetector; det++){
	
	//Set the calibration object again
	fCountDet = det;
	SetCalROC(1);   
	
	// Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
	// Put them at 1
	fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),1);
	fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
					   ,(Int_t) GetStack(fCountDet)
					   ,(Int_t) GetSector(fCountDet),1);
	// Reconstruct row min row max
	ReconstructFitRowMinRowMax(idect,1);      
	
	// Calcul the coef from the database choosen for the detector
	CalculVdriftCoefMean();
	CalculT0CoefMean();
	 	
	//stack 2, not stack 2
	Int_t factor = 0;
	if(GetStack(fCountDet) == 2) factor = 12;
	else factor = 16;
	
	// Fill the fCurrentCoefDetector with negative value to say: not fitted
	Double_t coeftoput  = 1.5;
	Double_t coeftoput2 = 0.0; 

	if(fCurrentCoef[0] < 0.0) coeftoput = - TMath::Abs(fCurrentCoef[1]);
	else coeftoput = fCurrentCoef[0];

	if(fCurrentCoef2[0] > 70.0) coeftoput2 = fCurrentCoef2[1] + 100.0;
	else coeftoput2 = fCurrentCoef2[0];

	for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
	  for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
	    fCurrentCoefDetector[(Int_t)(j*factor+k)]  = coeftoput;
	    fCurrentCoefDetector2[(Int_t)(j*factor+k)] = coeftoput2;
	  }
	}
	
	// Fill the stuff
	FillVectorFit();
	FillVectorFit2();
	// Debug
	if(fDebugLevel > 1){ 
	  
	  if ( !fDebugStreamer ) {
	    //debug stream
	    TDirectory *backup = gDirectory;
	    fDebugStreamer = new TTreeSRedirector("TRDDebugFitPH.root");
	    if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
	  } 
	  
	  
	  Int_t   detector     = fCountDet;
	  Int_t   caligroup    = idect;
	  Short_t rowmin       = fCalibraMode->GetRowMin(1);
	  Short_t rowmax       = fCalibraMode->GetRowMax(1);
	  Short_t colmin       = fCalibraMode->GetColMin(1);
	  Short_t colmax       = fCalibraMode->GetColMax(1);
	  Float_t vf           = fCurrentCoef[0]; 
	  Float_t vs           = fCurrentCoef[1]; 
	  Float_t vfE          = fCurrentCoefE;
	  Float_t t0f          = fCurrentCoef2[0]; 
	  Float_t t0s          = fCurrentCoef2[1]; 
	  Float_t t0E          = fCurrentCoefE2;
	  
	  
	  
	  (* fDebugStreamer) << "FillFillPH"<<
	    "detector="<<detector<<
	    "nentries="<<nentries<<
	    "caligroup="<<caligroup<<
	    "rowmin="<<rowmin<<
	    "rowmax="<<rowmax<<
	    "colmin="<<colmin<<
	    "colmax="<<colmax<<
	    "vf="<<vf<<
	    "vs="<<vs<<
	    "vfE="<<vfE<<
	    "t0f="<<t0f<<
	    "t0s="<<t0s<<
	    "t0E="<<t0E<<
	    "\n";  
	}
	// Reset
	for (Int_t k = 0; k < 2304; k++) {
	  fCurrentCoefDetector[k] = 0.0;
	  fCurrentCoefDetector2[k] = 0.0;
	}
	
      }// loop detector
      //printf("Check the count now: fCountDet %d\n",fCountDet);
    }
    else {
      
      Int_t factor = 0;
      if(GetStack(fCountDet) == 2) factor = 12;
      else factor = 16; 
      
      for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
	for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
	  fCurrentCoefDetector[(Int_t)(j*factor+k)]  = fCurrentCoef[0];
	  fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[0];
	}
      }  
      
      FillFillPH(idect,nentries);
    }
  }
  return kTRUE;
}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::FillInfosFitPRF(Int_t idect)
{
  //
  // Fill the coefficients found with the fits or other
  // methods from the Fit functions
  //
  
  if (fDebugLevel != 1) {
    if (fNbDet > 0){
    
      Int_t firstdetector = fCountDet;
      Int_t lastdetector  = fCountDet+fNbDet;
//    AliInfo(Form("The element %d containing the detectors %d to %d has been fitted",idect,firstdetector,lastdetector));
      
      // loop over detectors
      for(Int_t det = firstdetector; det < lastdetector; det++){
	
	//Set the calibration object again
	fCountDet = det;
	SetCalROC(2);   
	
	// Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
	// Put them at 1
	fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),2);
	fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
					   ,(Int_t) GetStack(fCountDet)
					   ,(Int_t) GetSector(fCountDet),2);
	// Reconstruct row min row max
	ReconstructFitRowMinRowMax(idect,2);      
	
	// Calcul the coef from the database choosen for the detector
	CalculPRFCoefMean();
	
	//stack 2, not stack 2
	Int_t factor = 0;
	if(GetStack(fCountDet) == 2) factor = 12;
	else factor = 16;
	
	// Fill the fCurrentCoefDetector with negative value to say: not fitted
	Double_t coeftoput = 1.0;
	if(fCurrentCoef[0] < 0.0) coeftoput = - TMath::Abs(fCurrentCoef[1]);
	else coeftoput = fCurrentCoef[0];
	for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
	  for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
	    fCurrentCoefDetector[(Int_t)(j*factor+k)] = coeftoput;
	  }
	}
	
	// Fill the stuff
	FillVectorFit();
	// Debug
	if(fDebugLevel > 1){
	  
	  if ( !fDebugStreamer ) {
	    //debug stream
	    TDirectory *backup = gDirectory;
	    fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
	    if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
	  } 
	  
	  Int_t   detector     = fCountDet;
	  Int_t   layer        = GetLayer(fCountDet);
	  Int_t   caligroup    = idect;
	  Short_t rowmin       = fCalibraMode->GetRowMin(2);
	  Short_t rowmax       = fCalibraMode->GetRowMax(2);
	  Short_t colmin       = fCalibraMode->GetColMin(2);
	  Short_t colmax       = fCalibraMode->GetColMax(2);
	  Float_t widf         = fCurrentCoef[0]; 
	  Float_t wids         = fCurrentCoef[1]; 
	  Float_t widfE        = fCurrentCoefE;
	  
	  (* fDebugStreamer) << "FillFillPRF"<<
	    "detector="<<detector<<
	    "layer="<<layer<<
	    "caligroup="<<caligroup<<
	    "rowmin="<<rowmin<<
	    "rowmax="<<rowmax<<
	    "colmin="<<colmin<<
	    "colmax="<<colmax<<
	    "widf="<<widf<<
	    "wids="<<wids<<
	    "widfE="<<widfE<<
	    "\n";  
	}
	// Reset
	for (Int_t k = 0; k < 2304; k++) {
	  fCurrentCoefDetector[k] = 0.0;
	}
	
      }// loop detector
      //printf("Check the count now: fCountDet %d\n",fCountDet);
    }
    else {
      
      Int_t factor = 0;
      if(GetStack(fCountDet) == 2) factor = 12;
      else factor = 16; 
      
      // Pointer to the branch
      for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
	for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
	  fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
	}
      }
      FillFillPRF(idect);   
    }
  }
  
  return kTRUE;

}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::FillInfosFitLinearFitter()
{
  //
  // Fill the coefficients found with the fits or other
  // methods from the Fit functions
  //
  
  Int_t factor = 0;
  if(GetStack(fCountDet) == 2) factor = 1728;
  else factor = 2304; 
  
  // Pointer to the branch
  for (Int_t k = 0; k < factor; k++) {
    fCurrentCoefDetector[k]  = fCurrentCoef[0];
    fCurrentCoefDetector2[k] = fCurrentCoef2[0];
  }
  
  FillFillLinearFitter();
  
  return kTRUE;

}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::FillInfosFitExbAlt()
{
  //
  // Fill the coefficients found with the fits or other
  // methods from the Fit functions
  //
  
  Int_t factor = 0;
  if(GetStack(fCountDet) == 2) factor = 1728;
  else factor = 2304; 
  
  // Pointer to the branch
  for (Int_t k = 0; k < factor; k++) {
    fCurrentCoefDetector2[k]  = fCurrentCoef2[0];
  }
  
  FillFillExbAlt();
  
  return kTRUE;

}
//________________________________________________________________________________
void AliTRDCalibraFit::FillFillCH(Int_t idect)
{
  //
  // DebugStream and fVectorFit
  //

  // End of one detector
  if (idect == (fCount-1)) {
    FillVectorFit();
    // Reset
    for (Int_t k = 0; k < 2304; k++) {
      fCurrentCoefDetector[k] = 0.0;
    }
  }

  if(fDebugLevel > 1){ 

    if ( !fDebugStreamer ) {
      //debug stream
      TDirectory *backup = gDirectory;
      fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
      if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
    } 
    
    Int_t   detector   = fCountDet;
    Int_t   caligroup  = idect;
    Short_t rowmin     = fCalibraMode->GetRowMin(0);
    Short_t rowmax     = fCalibraMode->GetRowMax(0);
    Short_t colmin     = fCalibraMode->GetColMin(0);
    Short_t colmax     = fCalibraMode->GetColMax(0);
    Float_t gf         = fCurrentCoef[0]; 
    Float_t gfs        = fCurrentCoef[1]; 
    Float_t gfE        = fCurrentCoefE;
    
    (*fDebugStreamer) << "FillFillCH" <<
      "detector=" << detector <<
      "caligroup=" << caligroup <<
      "rowmin=" << rowmin <<
      "rowmax=" << rowmax <<
      "colmin=" << colmin <<
      "colmax=" << colmax <<
      "gf=" << gf <<
      "gfs=" << gfs <<
      "gfE=" << gfE <<
      "\n"; 
    
  }
}
//________________________________________________________________________________
void AliTRDCalibraFit::FillFillPH(Int_t idect,Double_t nentries)
{
  //
  // DebugStream and fVectorFit and fVectorFit2
  //
  
  // End of one detector
    if (idect == (fCount-1)) {
      FillVectorFit();
      FillVectorFit2();
      // Reset
      for (Int_t k = 0; k < 2304; k++) {
	fCurrentCoefDetector[k] = 0.0;
	fCurrentCoefDetector2[k] = 0.0;
      }
    }

    if(fDebugLevel > 1){ 

      if ( !fDebugStreamer ) {
	//debug stream
	TDirectory *backup = gDirectory;
	fDebugStreamer = new TTreeSRedirector("TRDDebugFitPH.root");
	if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
      } 
      
       
      Int_t   detector     = fCountDet;
      Int_t   caligroup    = idect;
      Short_t rowmin       = fCalibraMode->GetRowMin(1);
      Short_t rowmax       = fCalibraMode->GetRowMax(1);
      Short_t colmin       = fCalibraMode->GetColMin(1);
      Short_t colmax       = fCalibraMode->GetColMax(1);
      Float_t vf           = fCurrentCoef[0]; 
      Float_t vs           = fCurrentCoef[1]; 
      Float_t vfE          = fCurrentCoefE;
      Float_t t0f          = fCurrentCoef2[0]; 
      Float_t t0s          = fCurrentCoef2[1]; 
      Float_t t0E          = fCurrentCoefE2;
   


      (* fDebugStreamer) << "FillFillPH"<<
	"detector="<<detector<<
	"nentries="<<nentries<<
	"caligroup="<<caligroup<<
	"rowmin="<<rowmin<<
	"rowmax="<<rowmax<<
	"colmin="<<colmin<<
	"colmax="<<colmax<<
	"vf="<<vf<<
	"vs="<<vs<<
	"vfE="<<vfE<<
	"t0f="<<t0f<<
	"t0s="<<t0s<<
	"t0E="<<t0E<<
	"\n";  
    }

}
//________________________________________________________________________________
void AliTRDCalibraFit::FillFillPRF(Int_t idect)
{
  //
  // DebugStream and fVectorFit
  //

    // End of one detector
    if (idect == (fCount-1)) {
      FillVectorFit();
      // Reset
      for (Int_t k = 0; k < 2304; k++) {
	fCurrentCoefDetector[k] = 0.0;
      }
    }

    
    if(fDebugLevel > 1){

      if ( !fDebugStreamer ) {
	//debug stream
	TDirectory *backup = gDirectory;
	fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
	if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
      } 
      
      Int_t   detector     = fCountDet;
      Int_t   layer        = GetLayer(fCountDet);
      Int_t   caligroup    = idect;
      Short_t rowmin       = fCalibraMode->GetRowMin(2);
      Short_t rowmax       = fCalibraMode->GetRowMax(2);
      Short_t colmin       = fCalibraMode->GetColMin(2);
      Short_t colmax       = fCalibraMode->GetColMax(2);
      Float_t widf         = fCurrentCoef[0]; 
      Float_t wids         = fCurrentCoef[1]; 
      Float_t widfE        = fCurrentCoefE;

      (* fDebugStreamer) << "FillFillPRF"<<
	"detector="<<detector<<
	"layer="<<layer<<
	"caligroup="<<caligroup<<
	"rowmin="<<rowmin<<
	"rowmax="<<rowmax<<
	"colmin="<<colmin<<
	"colmax="<<colmax<<
	"widf="<<widf<<
	"wids="<<wids<<
	"widfE="<<widfE<<
	"\n";  
    }

}
//________________________________________________________________________________
void AliTRDCalibraFit::FillFillLinearFitter()
{
  //
  // DebugStream and fVectorFit
  //

  // End of one detector
  FillVectorFit();
  FillVectorFit2();
  
  
  // Reset
  for (Int_t k = 0; k < 2304; k++) {
  fCurrentCoefDetector[k]  = 0.0;
  fCurrentCoefDetector2[k] = 0.0;
  }
  

  if(fDebugLevel > 1){

    if ( !fDebugStreamer ) {
      //debug stream
      TDirectory *backup = gDirectory;
      fDebugStreamer = new TTreeSRedirector("TRDDebugFitLinearFitter.root");
      if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
    } 
    
    //Debug: comparaison of the different methods (okey for first time but not for iterative procedure)
    AliTRDpadPlane *padplane = fGeo->GetPadPlane(GetLayer(fCountDet),GetStack(fCountDet));
    Float_t rowmd            = (padplane->GetRow0()+padplane->GetRowEnd())/2.;
    Float_t r                = AliTRDgeometry::GetTime0(GetLayer(fCountDet)); 
    Float_t tiltangle        = padplane->GetTiltingAngle();
    Int_t   detector         = fCountDet;
    Int_t   stack            = GetStack(fCountDet);
    Int_t   layer            = GetLayer(fCountDet);
    Float_t vf               = fCurrentCoef[0]; 
    Float_t vs               = fCurrentCoef[1]; 
    Float_t vfE              = fCurrentCoefE;
    Float_t lorentzangler    = fCurrentCoef2[0];
    Float_t elorentzangler   = fCurrentCoefE2;
    Float_t lorentzangles    = fCurrentCoef2[1];
   
    (* fDebugStreamer) << "FillFillLinearFitter"<<
      "detector="<<detector<<
      "stack="<<stack<<
      "layer="<<layer<<
      "rowmd="<<rowmd<<
      "r="<<r<<
      "tiltangle="<<tiltangle<<
      "vf="<<vf<<
      "vs="<<vs<<
      "vfE="<<vfE<<
      "lorentzangler="<<lorentzangler<<
      "Elorentzangler="<<elorentzangler<<
      "lorentzangles="<<lorentzangles<<
      "\n";  
  }
  
}
//________________________________________________________________________________
void AliTRDCalibraFit::FillFillExbAlt()
{
  //
  // DebugStream and fVectorFit
  //

  // End of one detector
  FillVectorFit2();
  
  
  // Reset
  for (Int_t k = 0; k < 2304; k++) {
    fCurrentCoefDetector2[k]  = 0.0;
  }
  

  if(fDebugLevel > 1){

    if ( !fDebugStreamer ) {
      //debug stream
      TDirectory *backup = gDirectory;
      fDebugStreamer = new TTreeSRedirector("TRDDebugFitExbAlt.root");
      if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
    } 
    
    //Debug: comparaison of the different methods (okey for first time but not for iterative procedure)
    AliTRDpadPlane *padplane = fGeo->GetPadPlane(GetLayer(fCountDet),GetStack(fCountDet));
    Float_t rowmd            = (padplane->GetRow0()+padplane->GetRowEnd())/2.;
    Float_t r                = AliTRDgeometry::GetTime0(GetLayer(fCountDet)); 
    Float_t tiltangle        = padplane->GetTiltingAngle();
    Int_t   detector         = fCountDet;
    Int_t   stack            = GetStack(fCountDet);
    Int_t   layer            = GetLayer(fCountDet);
    Float_t vf               = fCurrentCoef2[0]; 
    Float_t vfE              = fCurrentCoefE2;
   
    (* fDebugStreamer) << "FillFillLinearFitter"<<
      "detector="<<detector<<
      "stack="<<stack<<
      "layer="<<layer<<
      "rowmd="<<rowmd<<
      "r="<<r<<
      "tiltangle="<<tiltangle<<
      "vf="<<vf<<
      "vfE="<<vfE<<
      "\n";  
  }
  
}
//
//____________Calcul Coef Mean_________________________________________________
//
//_____________________________________________________________________________
Bool_t AliTRDCalibraFit::CalculT0CoefMean()
{
  //
  // For the detector Dect calcul the mean time 0
  // for the calibration group idect from the choosen database
  //

  fCurrentCoef2[1] = 0.0;
  if(fDebugLevel != 1){
    if(((fCalibraMode->GetNz(1) > 0) ||
       (fCalibraMode->GetNrphi(1) > 0)) && ((fCalibraMode->GetNz(1)    != 10) && (fCalibraMode->GetNz(1)    != 100))) {

      for (Int_t row = fCalibraMode->GetRowMin(1); row < fCalibraMode->GetRowMax(1); row++) {
	for (Int_t col = fCalibraMode->GetColMin(1); col < fCalibraMode->GetColMax(1); col++) {
	  fCurrentCoef2[1] += (Float_t) (fCalROC2->GetValue(col,row)+fCalDet2->GetValue(fCountDet));
	}
      }
      
      fCurrentCoef2[1] = fCurrentCoef2[1] / ((fCalibraMode->GetColMax(1)-fCalibraMode->GetColMin(1))*(fCalibraMode->GetRowMax(1)-fCalibraMode->GetRowMin(1)));
    
    }
    else {
     
      if(!fAccCDB){
	fCurrentCoef2[1] = fCalDet2->GetValue(fCountDet);
      }
      else{
	
	for(Int_t row = 0; row < fGeo->GetRowMax(GetLayer(fCountDet),GetStack(fCountDet),GetSector(fCountDet)); row++){
	  for(Int_t col = 0; col < fGeo->GetColMax(GetLayer(fCountDet)); col++){
	    fCurrentCoef2[1] += (Float_t) (fCalROC2->GetValue(col,row)+fCalDet2->GetValue(fCountDet));
	  }
	}
	fCurrentCoef2[1] = fCurrentCoef2[1] / ((fGeo->GetRowMax(GetLayer(fCountDet),GetStack(fCountDet),GetSector(fCountDet)))*(fGeo->GetColMax(GetLayer(fCountDet))));
      
      }
    }
  }
  return kTRUE;
}

//_____________________________________________________________________________
Bool_t AliTRDCalibraFit::CalculChargeCoefMean(Bool_t vrai)
{
  //
  // For the detector Dect calcul the mean gain factor
  // for the calibration group idect from the choosen database
  //

  fCurrentCoef[1] = 0.0;
  if(fDebugLevel != 1){
    if (((fCalibraMode->GetNz(0)    > 0) || 
	(fCalibraMode->GetNrphi(0) > 0)) && ((fCalibraMode->GetNz(0)    != 10) && (fCalibraMode->GetNz(0)    != 100))) {
      for (Int_t row = fCalibraMode->GetRowMin(0); row < fCalibraMode->GetRowMax(0); row++) {
	for (Int_t col = fCalibraMode->GetColMin(0); col < fCalibraMode->GetColMax(0); col++) {
	  fCurrentCoef[1] += (Float_t) (fCalROC->GetValue(col,row)*fCalDet->GetValue(fCountDet));
	  if (vrai) fScaleFitFactor += (Float_t) (fCalROC->GetValue(col,row)*fCalDet->GetValue(fCountDet));
	}
      }
      fCurrentCoef[1] = fCurrentCoef[1] / ((fCalibraMode->GetColMax(0)-fCalibraMode->GetColMin(0))*(fCalibraMode->GetRowMax(0)-fCalibraMode->GetRowMin(0)));
    }
    else {
      //Per detectors
      fCurrentCoef[1] = (Float_t) fCalDet->GetValue(fCountDet);
      if (vrai) fScaleFitFactor += ((Float_t) fCalDet->GetValue(fCountDet))*(fCalibraMode->GetColMax(0)-fCalibraMode->GetColMin(0))*(fCalibraMode->GetRowMax(0)-fCalibraMode->GetRowMin(0));
    }    
  }
  return kTRUE;
}
//_____________________________________________________________________________
Bool_t AliTRDCalibraFit::CalculPRFCoefMean()
{
  //
  // For the detector Dect calcul the mean sigma of pad response
  // function for the calibration group idect from the choosen database
  //
  
  fCurrentCoef[1] = 0.0;
  if(fDebugLevel != 1){
    for (Int_t row = fCalibraMode->GetRowMin(2); row < fCalibraMode->GetRowMax(2); row++) {
      for (Int_t col = fCalibraMode->GetColMin(2); col < fCalibraMode->GetColMax(2); col++) {
	fCurrentCoef[1] += (Float_t) fCalROC->GetValue(col,row);
      }
    }
    fCurrentCoef[1] = fCurrentCoef[1] / ((fCalibraMode->GetColMax(2)-fCalibraMode->GetColMin(2))*(fCalibraMode->GetRowMax(2)-fCalibraMode->GetRowMin(2)));
  }
  return kTRUE;
}
//_____________________________________________________________________________
Bool_t AliTRDCalibraFit::CalculVdriftCoefMean()
{
  //
  // For the detector dect calcul the mean drift velocity for the
  // calibration group idect from the choosen database
  //

  fCurrentCoef[1] = 0.0;
  if(fDebugLevel != 1){
    if (((fCalibraMode->GetNz(1)    > 0) || 
	(fCalibraMode->GetNrphi(1) > 0)) && ((fCalibraMode->GetNz(1)    != 10) && (fCalibraMode->GetNz(1)    != 100))) {
      
      for (Int_t row = fCalibraMode->GetRowMin(1); row < fCalibraMode->GetRowMax(1); row++) {
	for (Int_t col = fCalibraMode->GetColMin(1); col < fCalibraMode->GetColMax(1); col++) {
	  fCurrentCoef[1] += (Float_t) (fCalROC->GetValue(col,row)*fCalDet->GetValue(fCountDet));
	}
      }
      
      fCurrentCoef[1] = fCurrentCoef[1] / ((fCalibraMode->GetColMax(1)-fCalibraMode->GetColMin(1))*(fCalibraMode->GetRowMax(1)-fCalibraMode->GetRowMin(1)));
    
    }
    else {
      //per detectors
      fCurrentCoef[1] = (Float_t) fCalDet->GetValue(fCountDet);
    }  
  }
  return kTRUE;
}
//_____________________________________________________________________________
Bool_t AliTRDCalibraFit::CalculVdriftLorentzCoef()
{
  //
  // For the detector fCountDet, mean drift velocity and tan lorentzangle
  //

  fCurrentCoef[1]  = fCalDetVdriftUsed->GetValue(fCountDet);
  fCurrentCoef2[1] = fCalDetExBUsed->GetValue(fCountDet); 

  return kTRUE;
}
//_____________________________________________________________________________
Float_t AliTRDCalibraFit::GetPRFDefault(Int_t layer) const
{
  //
  // Default width of the PRF if there is no database as reference
  //
  switch(layer)
    {
      // default database
      //case 0:  return 0.515;
      //case 1:  return 0.502;
      //case 2:  return 0.491;
      //case 3:  return 0.481;
      //case 4:  return 0.471;
      //case 5:  return 0.463;
      //default: return 0.0;

      // fit database
    case 0:  return 0.538429;
    case 1:  return 0.524302;
    case 2:  return 0.511591;
    case 3:  return 0.500140;
    case 4:  return 0.489821;
    case 5:  return 0.480524;
    default: return 0.0;
  }
}
//________________________________________________________________________________
void AliTRDCalibraFit::SetCalROC(Int_t i)
{
  //
  // Set the calib object for fCountDet
  //

  Float_t value = 0.0;
  
  //Get the CalDet object
  if(fAccCDB){
    AliTRDcalibDB     *cal    = AliTRDcalibDB::Instance();
    if (!cal) {
      AliInfo("Could not get calibDB");
      return;
    }
    switch (i)
      {
      case 0: 
	if( fCalROC ){ 
	  fCalROC->~AliTRDCalROC();
	  new(fCalROC) AliTRDCalROC(*(cal->GetGainFactorROC(fCountDet)));
	}else fCalROC = new AliTRDCalROC(*(cal->GetGainFactorROC(fCountDet)));
	break;
      case 1:
	if( fCalROC ){ 
	  fCalROC->~AliTRDCalROC();
	  new(fCalROC) AliTRDCalROC(*(cal->GetVdriftROC(fCountDet)));
	}else fCalROC = new AliTRDCalROC(*(cal->GetVdriftROC(fCountDet)));
	if( fCalROC2 ){ 
	  fCalROC2->~AliTRDCalROC();
	  new(fCalROC2) AliTRDCalROC(*(cal->GetT0ROC(fCountDet)));
	}else fCalROC2 = new AliTRDCalROC(*(cal->GetT0ROC(fCountDet)));
	break;
      case 2:
	if( fCalROC ){ 
	  fCalROC->~AliTRDCalROC();
	  new(fCalROC) AliTRDCalROC(*(cal->GetPRFROC(fCountDet)));
	}else fCalROC = new AliTRDCalROC(*(cal->GetPRFROC(fCountDet)));
	break; 
      default: return;
      }
  }
  else{
    switch (i)
      {
      case 0:
	if(fCalROC) delete fCalROC;
	fCalROC = new AliTRDCalROC(GetLayer(fCountDet),GetStack(fCountDet)); 
	for(Int_t k = 0; k < fCalROC->GetNchannels(); k++){
	  fCalROC->SetValue(k,1.0);
	}
	break;
      case 1:
	if(fCalROC)  delete fCalROC;
	if(fCalROC2) delete fCalROC2;
	fCalROC  = new AliTRDCalROC(GetLayer(fCountDet),GetStack(fCountDet));
	fCalROC2 = new AliTRDCalROC(GetLayer(fCountDet),GetStack(fCountDet));
	for(Int_t k = 0; k < fCalROC->GetNchannels(); k++){
	  fCalROC->SetValue(k,1.0);
	  fCalROC2->SetValue(k,0.0);
	}
	break;
      case 2:
	if(fCalROC) delete fCalROC;
	value = GetPRFDefault(GetLayer(fCountDet));
	fCalROC = new AliTRDCalROC(GetLayer(fCountDet),GetStack(fCountDet)); 
	for(Int_t k = 0; k < fCalROC->GetNchannels(); k++){
	  fCalROC->SetValue(k,value);
	}
	break;
      default: return; 
      }
  }
  
}
//____________Fit Methods______________________________________________________

//_____________________________________________________________________________
void AliTRDCalibraFit::FitPente(TH1* projPH)
{
  //
  // Slope methode for the drift velocity
  //
  
  // Constants
  const Float_t kDrWidth = AliTRDgeometry::DrThick();
  Int_t binmax           = 0;
  Int_t binmin           = 0;
  fPhd[0]                = 0.0;
  fPhd[1]                = 0.0;
  fPhd[2]                = 0.0;
  Int_t ju               = 0;
  fCurrentCoefE          = 0.0;
  fCurrentCoefE2         = 0.0;
  fCurrentCoef[0]        = 0.0;
  fCurrentCoef2[0]       = 0.0;
  TLine *line            = new TLine();

  // Some variables
  TAxis   *xpph    = projPH->GetXaxis();
  Int_t    nbins   = xpph->GetNbins();
  Double_t lowedge = xpph->GetBinLowEdge(1);
  Double_t upedge  = xpph->GetBinUpEdge(xpph->GetNbins());
  Double_t widbins = (upedge - lowedge) / nbins;
  Double_t limit   = upedge + 0.5 * widbins; 
  Bool_t put = kTRUE;

  // Beginning of the signal
  TH1D *pentea = new TH1D("pentea","pentea",projPH->GetNbinsX(),0,(Float_t) limit);
  for (Int_t k = 1; k <  projPH->GetNbinsX(); k++) {
    pentea->SetBinContent(k,(Double_t) (projPH->GetBinContent(k+1) - projPH->GetBinContent(k)));
  }
  binmax = (Int_t) pentea->GetMaximumBin();
  if (binmax <= 1) {
    binmax = 2;
    AliInfo("Put the binmax from 1 to 2 to enable the fit");
  }
  if (binmax >= nbins) {
    binmax = nbins-1;
    put = kFALSE;
    AliInfo("Put the binmax from nbins-1 to nbins-2 to enable the fit");
  }
  pentea->Fit("pol2","0MR","",TMath::Max(pentea->GetBinCenter(binmax-1),0.0),pentea->GetBinCenter(binmax+1));
  Float_t l3P1am = pentea->GetFunction("pol2")->GetParameter(1);
  Float_t l3P2am = pentea->GetFunction("pol2")->GetParameter(2);
  Float_t l3P1amE = pentea->GetFunction("pol2")->GetParError(1);
  Float_t l3P2amE = pentea->GetFunction("pol2")->GetParError(2);
  if (TMath::Abs(l3P2am) > 0.00000001) {
    fPhd[0] = -(l3P1am / (2 * l3P2am));
  }
  if(!fTakeTheMaxPH){
    if((TMath::Abs(l3P1am) > 0.0000000001) && (TMath::Abs(l3P2am) > 0.00000000001)){
      fCurrentCoefE2 = (l3P1amE/l3P1am + l3P2amE/l3P2am)*fPhd[0];
    }
  }
  // Amplification region
  binmax = 0;
  ju     = 0;
  for (Int_t kbin = 1; kbin < projPH->GetNbinsX(); kbin ++) {
    if (((projPH->GetBinContent(kbin+1) - projPH->GetBinContent(kbin)) <= 0.0) && (ju == 0) && (kbin > (fPhd[0]/widbins))) {
      binmax = kbin;
      ju     = 1;
    }
  }
  if (binmax <= 1) {
    binmax = 2;
    AliInfo("Put the binmax from 1 to 2 to enable the fit");
  }
  if (binmax >= nbins) {
    binmax = nbins-1;
    put = kFALSE;
    AliInfo("Put the binmax from nbins-1 to nbins-2 to enable the fit");
  }
  projPH->Fit("pol2","0MR","",TMath::Max(projPH->GetBinCenter(binmax-1),0.0),projPH->GetBinCenter(binmax+1));
  Float_t l3P1amf = projPH->GetFunction("pol2")->GetParameter(1);
  Float_t l3P2amf = projPH->GetFunction("pol2")->GetParameter(2);
  Float_t l3P1amfE = projPH->GetFunction("pol2")->GetParError(1);
  Float_t l3P2amfE = projPH->GetFunction("pol2")->GetParError(2);
  if (TMath::Abs(l3P2amf) > 0.00000000001) {
    fPhd[1] = -(l3P1amf / (2 * l3P2amf));
  }
  if((TMath::Abs(l3P1amf) > 0.0000000001) && (TMath::Abs(l3P2amf) > 0.000000001)){
    fCurrentCoefE = (l3P1amfE/l3P1amf + l3P2amfE/l3P2amf)*fPhd[1];
  }
  if(fTakeTheMaxPH){
    fCurrentCoefE2 = fCurrentCoefE;
  }
  // Drift region
  TH1D *pente = new TH1D("pente","pente",projPH->GetNbinsX(),0,(Float_t) limit);
  for (Int_t k = TMath::Min(binmax+4,projPH->GetNbinsX()); k <  projPH->GetNbinsX(); k++) {
    pente->SetBinContent(k,(Double_t) (projPH->GetBinContent(k+1) - projPH->GetBinContent(k)));
  }
  binmin = 0;
  if(pente->GetEntries() > 0) binmin = (Int_t) pente->GetMinimumBin();
  if (binmin <= 1) {
    binmin = 2;
    AliInfo("Put the binmax from 1 to 2 to enable the fit");
  }
  if (binmin >= nbins) {
    binmin = nbins-1;
    put = kFALSE;
    AliInfo("Put the binmax from nbins-1 to nbins-2 to enable the fit");
  }
  pente->Fit("pol2"
            ,"0MR"
            ,""
            ,TMath::Max(pente->GetBinCenter(binmin-1),             0.0)
            ,TMath::Min(pente->GetBinCenter(binmin+1),(Double_t) limit));
  Float_t l3P1dr = pente->GetFunction("pol2")->GetParameter(1);
  Float_t l3P2dr = pente->GetFunction("pol2")->GetParameter(2);
  Float_t l3P1drE = pente->GetFunction("pol2")->GetParError(1);
  Float_t l3P2drE = pente->GetFunction("pol2")->GetParError(2);
  if (TMath::Abs(l3P2dr) > 0.00000001) {
    fPhd[2] = -(l3P1dr / (2 * l3P2dr));
  }
  if((TMath::Abs(l3P1dr) > 0.0000000001) && (TMath::Abs(l3P2dr) > 0.00000000001)){
    fCurrentCoefE += (l3P1drE/l3P1dr + l3P2drE/l3P2dr)*fPhd[2]; 
  }
  Float_t fPhdt0  = 0.0;
  Float_t t0Shift = 0.0;
  if(fTakeTheMaxPH) {
    fPhdt0 = fPhd[1];
    t0Shift = fT0Shift1;
  }
  else {
    fPhdt0 = fPhd[0];
    t0Shift = fT0Shift0;
  }

  if ((fPhd[2] > fPhd[0]) && 
      (fPhd[2] > fPhd[1]) && 
      (fPhd[1] > fPhd[0]) &&
      (put)) {
    fCurrentCoef[0] = (kDrWidth) / (fPhd[2]-fPhd[1]);
    fNumberFitSuccess++;

    if (fPhdt0 >= 0.0) {
      fCurrentCoef2[0] = (fPhdt0 - t0Shift) / widbins;
      if (fCurrentCoef2[0] < -3.0) {
        fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
      }
    }
    else {
      fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
    }

  }
  else {
    fCurrentCoef[0]  = -TMath::Abs(fCurrentCoef[1]);
    fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
  }

  if (fDebugLevel == 1) {
    TCanvas *cpentei = new TCanvas("cpentei","cpentei",50,50,600,800);
    cpentei->cd();
    projPH->Draw();
    line->SetLineColor(2);
    line->DrawLine(fPhd[0],0,fPhd[0],projPH->GetMaximum());
    line->DrawLine(fPhd[1],0,fPhd[1],projPH->GetMaximum());
    line->DrawLine(fPhd[2],0,fPhd[2],projPH->GetMaximum());
    AliInfo(Form("fPhd[0] (beginning of the signal): %f"                  ,(Float_t) fPhd[0]));
    AliInfo(Form("fPhd[1] (end of the amplification region): %f"          ,(Float_t) fPhd[1]));
    AliInfo(Form("fPhd[2] (end of the drift region): %f"                  ,(Float_t) fPhd[2]));
    AliInfo(Form("fVriftCoef[1] (with only the drift region(default)): %f",(Float_t) fCurrentCoef[0]));
    TCanvas *cpentei2 = new TCanvas("cpentei2","cpentei2",50,50,600,800);
    cpentei2->cd();
    pentea->Draw();
    TCanvas *cpentei3 = new TCanvas("cpentei3","cpentei3",50,50,600,800);
    cpentei3->cd();
    pente->Draw();
  }
  else {
    delete pentea;
    delete pente;
  }
}
//_____________________________________________________________________________
void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
{
  //
  // Slope methode but with polynomes de Lagrange
  //

  // Constants
  const Float_t kDrWidth = AliTRDgeometry::DrThick();
  Int_t binmax      = 0;
  Int_t binmin      = 0;
  //Double_t    *x    = new Double_t[5];
  //Double_t    *y    = new Double_t[5];
  Double_t x[5];
  Double_t y[5];
  x[0]              = 0.0;
  x[1]              = 0.0;
  x[2]              = 0.0;
  x[3]              = 0.0;
  x[4]              = 0.0;
  y[0]              = 0.0;
  y[1]              = 0.0;
  y[2]              = 0.0;
  y[3]              = 0.0;
  y[4]              = 0.0;
  fPhd[0]           = 0.0;
  fPhd[1]           = 0.0;
  fPhd[2]           = 0.0;
  Int_t ju          = 0;
  fCurrentCoefE     = 0.0;
  fCurrentCoefE2    = 1.0;
  fCurrentCoef[0]   = 0.0;
  fCurrentCoef2[0]  = 0.0;
  TLine *line = new TLine();
  TF1 * polynome = 0x0;
  TF1 * polynomea = 0x0;
  TF1 * polynomeb = 0x0;
  Double_t c0 = 0.0;
  Double_t c1 = 0.0;
  Double_t c2 = 0.0;
  Double_t c3 = 0.0;
  Double_t c4 = 0.0;
  
  // Some variables
  TAxis   *xpph    = projPH->GetXaxis();
  Int_t    nbins   = xpph->GetNbins();
  Double_t lowedge = xpph->GetBinLowEdge(1);
  Double_t upedge  = xpph->GetBinUpEdge(xpph->GetNbins());
  Double_t widbins = (upedge - lowedge) / nbins;
  Double_t limit   = upedge + 0.5 * widbins;

  
  Bool_t put = kTRUE;

  ///////////////////////////////
  // Beginning of the signal
  //////////////////////////////
  TH1D *pentea = new TH1D("pentea","pentea",projPH->GetNbinsX(),0,(Float_t) limit);
  for (Int_t k = 1; k <  projPH->GetNbinsX(); k++) {
    pentea->SetBinContent(k,(Double_t) (projPH->GetBinContent(k+1) - projPH->GetBinContent(k)));
  }

  binmax = (Int_t) pentea->GetMaximumBin();

  Double_t minnn = 0.0;
  Double_t maxxx = 0.0;

  Int_t kase = nbins-binmax;
  
  switch(kase)
    {
    case 0:
      put = kFALSE;
      break;
    case 1:
      minnn = pentea->GetBinCenter(binmax-2);
      maxxx = pentea->GetBinCenter(binmax);
      x[0] = pentea->GetBinCenter(binmax-2);
      x[1] = pentea->GetBinCenter(binmax-1);
      x[2] = pentea->GetBinCenter(binmax);
      y[0] = pentea->GetBinContent(binmax-2);
      y[1] = pentea->GetBinContent(binmax-1);
      y[2] = pentea->GetBinContent(binmax);
      CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
      //AliInfo("At the limit for beginning!");
      break;  
    case 2:
      minnn = pentea->GetBinCenter(binmax-2);
      maxxx = pentea->GetBinCenter(binmax+1);
      x[0] = pentea->GetBinCenter(binmax-2);
      x[1] = pentea->GetBinCenter(binmax-1);
      x[2] = pentea->GetBinCenter(binmax);
      x[3] = pentea->GetBinCenter(binmax+1);
      y[0] = pentea->GetBinContent(binmax-2);
      y[1] = pentea->GetBinContent(binmax-1);
      y[2] = pentea->GetBinContent(binmax);
      y[3] = pentea->GetBinContent(binmax+1);
      CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
      break;
    default:
      switch(binmax){
      case 0:
	put = kFALSE;
	break;
      case 1:
	minnn = pentea->GetBinCenter(binmax);
	maxxx = pentea->GetBinCenter(binmax+2);
	x[0] = pentea->GetBinCenter(binmax);
	x[1] = pentea->GetBinCenter(binmax+1);
	x[2] = pentea->GetBinCenter(binmax+2);
	y[0] = pentea->GetBinContent(binmax);
	y[1] = pentea->GetBinContent(binmax+1);
	y[2] = pentea->GetBinContent(binmax+2);
	CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
	break;
      case 2:
	minnn = pentea->GetBinCenter(binmax-1);
	maxxx = pentea->GetBinCenter(binmax+2);
	x[0] = pentea->GetBinCenter(binmax-1);
	x[1] = pentea->GetBinCenter(binmax);
	x[2] = pentea->GetBinCenter(binmax+1);
	x[3] = pentea->GetBinCenter(binmax+2);
	y[0] = pentea->GetBinContent(binmax-1);
	y[1] = pentea->GetBinContent(binmax);
	y[2] = pentea->GetBinContent(binmax+1);
	y[3] = pentea->GetBinContent(binmax+2);
       	CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
	break;
      default:
     	minnn = pentea->GetBinCenter(binmax-2);
	maxxx = pentea->GetBinCenter(binmax+2);
	x[0] = pentea->GetBinCenter(binmax-2);
	x[1] = pentea->GetBinCenter(binmax-1);
	x[2] = pentea->GetBinCenter(binmax);
	x[3] = pentea->GetBinCenter(binmax+1);
	x[4] = pentea->GetBinCenter(binmax+2);
	y[0] = pentea->GetBinContent(binmax-2);
	y[1] = pentea->GetBinContent(binmax-1);
	y[2] = pentea->GetBinContent(binmax);
	y[3] = pentea->GetBinContent(binmax+1);
	y[4] = pentea->GetBinContent(binmax+2);
	CalculPolynomeLagrange4(x,y,c0,c1,c2,c3,c4);
	break;
      }
      break;
    }
  
  
  if(put) {
    polynomeb = new TF1("polb","[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x",minnn,maxxx);
    polynomeb->SetParameters(c0,c1,c2,c3,c4);
      
    Double_t step = (maxxx-minnn)/10000;
    Double_t l = minnn;
    Double_t maxvalue = 0.0;
    Double_t placemaximum = minnn;
    for(Int_t o = 0; o < 10000; o++){
      if(o == 0) maxvalue = polynomeb->Eval(l);
      if(maxvalue < (polynomeb->Eval(l))){
	maxvalue = polynomeb->Eval(l);
	placemaximum = l;
      }
      l += step;
    }
    fPhd[0] = placemaximum;
  }
  
  /////////////////////////////
  // Amplification region
  /////////////////////////////
  binmax = 0;
  ju     = 0;
  for (Int_t kbin = 1; kbin < projPH->GetNbinsX(); kbin ++) {
    if (((projPH->GetBinContent(kbin+1) - projPH->GetBinContent(kbin)) <= 0.0) && (ju == 0) && (kbin > (fPhd[0]/widbins))) {
      binmax = kbin;
      ju     = 1;
    }
  }
   
  Double_t minn = 0.0;
  Double_t maxx = 0.0;
  x[0] = 0.0;
  x[1] = 0.0;
  x[2] = 0.0;
  x[3] = 0.0;
  x[4] = 0.0;
  y[0] = 0.0;
  y[1] = 0.0;
  y[2] = 0.0;
  y[3] = 0.0;
  y[4] = 0.0;

  Int_t    kase1 = nbins - binmax;

  //Determination of minn and maxx
  //case binmax = nbins
  //pol2
  switch(kase1)
    {
    case 0:
      minn = projPH->GetBinCenter(binmax-2);
      maxx = projPH->GetBinCenter(binmax);
      x[0] = projPH->GetBinCenter(binmax-2);
      x[1] = projPH->GetBinCenter(binmax-1);
      x[2] = projPH->GetBinCenter(binmax);
      y[0] = projPH->GetBinContent(binmax-2);
      y[1] = projPH->GetBinContent(binmax-1);
      y[2] = projPH->GetBinContent(binmax);
      CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
      //AliInfo("At the limit for the drift!");
      break;
    case 1:
      minn = projPH->GetBinCenter(binmax-2);
      maxx = projPH->GetBinCenter(binmax+1);
      x[0] = projPH->GetBinCenter(binmax-2);
      x[1] = projPH->GetBinCenter(binmax-1);
      x[2] = projPH->GetBinCenter(binmax);
      x[3] = projPH->GetBinCenter(binmax+1);
      y[0] = projPH->GetBinContent(binmax-2);
      y[1] = projPH->GetBinContent(binmax-1);
      y[2] = projPH->GetBinContent(binmax);
      y[3] = projPH->GetBinContent(binmax+1);
      CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
      break;
    default:
      switch(binmax)
	{
	case 0:
	  put = kFALSE;
	  break;
	case 1:
	  minn = projPH->GetBinCenter(binmax);
	  maxx = projPH->GetBinCenter(binmax+2);
	  x[0] = projPH->GetBinCenter(binmax);
	  x[1] = projPH->GetBinCenter(binmax+1);
	  x[2] = projPH->GetBinCenter(binmax+2);
	  y[0] = projPH->GetBinContent(binmax);
	  y[1] = projPH->GetBinContent(binmax+1);
	  y[2] = projPH->GetBinContent(binmax+2);
	  CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
	  break;
	case 2:
	  minn = projPH->GetBinCenter(binmax-1);
	  maxx = projPH->GetBinCenter(binmax+2);
	  x[0] = projPH->GetBinCenter(binmax-1);
	  x[1] = projPH->GetBinCenter(binmax);
	  x[2] = projPH->GetBinCenter(binmax+1);
	  x[3] = projPH->GetBinCenter(binmax+2);
	  y[0] = projPH->GetBinContent(binmax-1);
	  y[1] = projPH->GetBinContent(binmax);
	  y[2] = projPH->GetBinContent(binmax+1);
	  y[3] = projPH->GetBinContent(binmax+2);
	  CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
	  break;
	default:
	  minn = projPH->GetBinCenter(binmax-2);
	  maxx = projPH->GetBinCenter(binmax+2);
	  x[0] = projPH->GetBinCenter(binmax-2);
	  x[1] = projPH->GetBinCenter(binmax-1);
	  x[2] = projPH->GetBinCenter(binmax);
	  x[3] = projPH->GetBinCenter(binmax+1);
	  x[4] = projPH->GetBinCenter(binmax+2);
	  y[0] = projPH->GetBinContent(binmax-2);
	  y[1] = projPH->GetBinContent(binmax-1);
	  y[2] = projPH->GetBinContent(binmax);
	  y[3] = projPH->GetBinContent(binmax+1);
	  y[4] = projPH->GetBinContent(binmax+2);
	  CalculPolynomeLagrange4(x,y,c0,c1,c2,c3,c4);
	  break;
	}
      break;
    }
  
  if(put) {
    polynomea = new TF1("pola","[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x",minn,maxx);
    polynomea->SetParameters(c0,c1,c2,c3,c4);
       
    Double_t step = (maxx-minn)/1000;
    Double_t l = minn;
    Double_t maxvalue = 0.0;
    Double_t placemaximum = minn;
    for(Int_t o = 0; o < 1000; o++){
      if(o == 0) maxvalue = polynomea->Eval(l);
      if(maxvalue < (polynomea->Eval(l))){
	maxvalue = polynomea->Eval(l);
	placemaximum = l;
      }
      l += step;
    }
    fPhd[1] = placemaximum;
  }

  //////////////////  
  // Drift region
  //////////////////
  Bool_t putd = kTRUE;
  TH1D *pente = new TH1D("pente","pente", projPH->GetNbinsX(),0,(Float_t) limit);
  for (Int_t k = TMath::Min(binmax+4, projPH->GetNbinsX()); k <  projPH->GetNbinsX(); k++) {
    pente->SetBinContent(k,(Double_t) (projPH->GetBinContent(k+1) - projPH->GetBinContent(k)));
  }
  binmin = 0;
  if(pente->GetEntries() > 0) binmin = (Int_t) pente->GetMinimumBin();

  //should not happen
  if (binmin <= 1) {
    binmin = 2;
    putd = 1;
    //AliInfo("Put the binmax from 1 to 2 to enable the fit");
  }
  
  //check
  if((projPH->GetBinContent(binmin)-projPH->GetBinError(binmin)) < (projPH->GetBinContent(binmin+1))) {
    //AliInfo("Too many fluctuations at the end!");
    putd = kFALSE;
  }
  if((projPH->GetBinContent(binmin)+projPH->GetBinError(binmin)) > (projPH->GetBinContent(binmin-1))) {
    //AliInfo("Too many fluctuations at the end!");
    putd = kFALSE;
  }
  if(TMath::Abs(pente->GetBinContent(binmin+1)) <= 0.0000000000001){
    //AliInfo("No entries for the next bin!");
    pente->SetBinContent(binmin,0);
    if(pente->GetEntries() > 0) binmin = (Int_t) pente->GetMinimumBin();
  }

  
  x[0] = 0.0;
  x[1] = 0.0;
  x[2] = 0.0;
  x[3] = 0.0;
  x[4] = 0.0;
  y[0] = 0.0;
  y[1] = 0.0;
  y[2] = 0.0;
  y[3] = 0.0;
  y[4] = 0.0;
  Double_t min = 0.0;
  Double_t max = 0.0;
  Bool_t case1 = kFALSE;
  Bool_t case2 = kFALSE;
  Bool_t case4 = kFALSE;

  //Determination of min and max
  //case binmin <= nbins-3
  //pol4 case 3
  if((binmin <= (nbins-3)) && ((binmin-2) >= TMath::Min(binmax+4, projPH->GetNbinsX()))){
    min = pente->GetBinCenter(binmin-2);
    max = pente->GetBinCenter(binmin+2);
    x[0] = pente->GetBinCenter(binmin-2);
    x[1] = pente->GetBinCenter(binmin-1);
    x[2] = pente->GetBinCenter(binmin);
    x[3] = pente->GetBinCenter(binmin+1);
    x[4] = pente->GetBinCenter(binmin+2);
    y[0] = pente->GetBinContent(binmin-2);
    y[1] = pente->GetBinContent(binmin-1);
    y[2] = pente->GetBinContent(binmin);
    y[3] = pente->GetBinContent(binmin+1);
    y[4] = pente->GetBinContent(binmin+2);
    //Calcul the polynome de Lagrange
    CalculPolynomeLagrange4(x,y,c0,c1,c2,c3,c4);
    //richtung +/-
    if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1)) &&
       (pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
      //AliInfo("polynome 4 false 1");
      putd = kFALSE;
    }
    if(((binmin+3) <= (nbins-1)) &&
       (pente->GetBinContent(binmin+3) <= pente->GetBinContent(binmin+2)) &&
       ((binmin-3) >= TMath::Min(binmax+4, projPH->GetNbinsX())) &&
       (pente->GetBinContent(binmin-3) <= pente->GetBinContent(binmin-2))) {
      //AliInfo("polynome 4 false 2");
      putd = kFALSE;
    }
    // poly 3
    if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1)) &&
       (pente->GetBinContent(binmin-2) > pente->GetBinContent(binmin-1))) {
      //AliInfo("polynome 4 case 1");
      case1 = kTRUE;
    }
    if((pente->GetBinContent(binmin+2) > pente->GetBinContent(binmin+1)) &&
       (pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
      //AliInfo("polynome 4 case 4");
      case4 = kTRUE;
    }
    
  }
  //case binmin = nbins-2
  //pol3 case 1
  if(((binmin == (nbins-2)) && ((binmin-2) >= TMath::Min(binmax+4, projPH->GetNbinsX()))) ||
     (case1)){
    min = pente->GetBinCenter(binmin-2);
    max = pente->GetBinCenter(binmin+1);
    x[0] = pente->GetBinCenter(binmin-2);
    x[1] = pente->GetBinCenter(binmin-1);
    x[2] = pente->GetBinCenter(binmin);
    x[3] = pente->GetBinCenter(binmin+1);
    y[0] = pente->GetBinContent(binmin-2);
    y[1] = pente->GetBinContent(binmin-1);
    y[2] = pente->GetBinContent(binmin);
    y[3] = pente->GetBinContent(binmin+1);
    //Calcul the polynome de Lagrange
    CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
    //richtung +: nothing
    //richtung -
    if((pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
      //AliInfo("polynome 3- case 2");
      case2 = kTRUE;
    }
  }
  //pol3 case 4
  if(((binmin <= (nbins-3)) && ((binmin-1) == TMath::Min(binmax+4, projPH->GetNbinsX()))) ||
     (case4)){
    min = pente->GetBinCenter(binmin-1);
    max = pente->GetBinCenter(binmin+2);
    x[0] = pente->GetBinCenter(binmin-1);
    x[1] = pente->GetBinCenter(binmin);
    x[2] = pente->GetBinCenter(binmin+1);
    x[3] = pente->GetBinCenter(binmin+2);
    y[0] = pente->GetBinContent(binmin-1);
    y[1] = pente->GetBinContent(binmin);
    y[2] = pente->GetBinContent(binmin+1);
    y[3] = pente->GetBinContent(binmin+2);
    //Calcul the polynome de Lagrange
    CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
    //richtung +
    if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1))) {
      //AliInfo("polynome 3+ case 2");      
      case2 = kTRUE;
    }
  }
  //pol2 case 5
  if((binmin <= (nbins-3)) && (binmin == TMath::Min(binmax+4, projPH->GetNbinsX()))){
    min = pente->GetBinCenter(binmin);
    max = pente->GetBinCenter(binmin+2);
    x[0] = pente->GetBinCenter(binmin);
    x[1] = pente->GetBinCenter(binmin+1);
    x[2] = pente->GetBinCenter(binmin+2);
    y[0] = pente->GetBinContent(binmin);
    y[1] = pente->GetBinContent(binmin+1);
    y[2] = pente->GetBinContent(binmin+2);
    //Calcul the polynome de Lagrange
    CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
    //richtung +
    if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1))) {
      //AliInfo("polynome 2+ false");
      putd = kFALSE;
    }
  }
  //pol2 case 2
  if(((binmin == (nbins-2)) && ((binmin-1) == TMath::Min(binmax+4, projPH->GetNbinsX()))) ||
     (case2)){
    min = pente->GetBinCenter(binmin-1);
    max = pente->GetBinCenter(binmin+1);
    x[0] = pente->GetBinCenter(binmin-1);
    x[1] = pente->GetBinCenter(binmin);
    x[2] = pente->GetBinCenter(binmin+1);
    y[0] = pente->GetBinContent(binmin-1);
    y[1] = pente->GetBinContent(binmin);
    y[2] = pente->GetBinContent(binmin+1);
    //Calcul the polynome de Lagrange
    CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
    //richtung +: nothing
    //richtung -: nothing
  }
  //case binmin = nbins-1
  //pol2 case 0
  if((binmin == (nbins-1)) && ((binmin-2) >= TMath::Min(binmax+4, projPH->GetNbinsX()))){
    min = pente->GetBinCenter(binmin-2);
    max = pente->GetBinCenter(binmin);
    x[0] = pente->GetBinCenter(binmin-2);
    x[1] = pente->GetBinCenter(binmin-1);
    x[2] = pente->GetBinCenter(binmin);
    y[0] = pente->GetBinContent(binmin-2);
    y[1] = pente->GetBinContent(binmin-1);
    y[2] = pente->GetBinContent(binmin);
    //Calcul the polynome de Lagrange
    CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
    //AliInfo("At the limit for the drift!");
    //fluctuation too big!
    //richtung +: nothing
    //richtung -
    if((pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
      //AliInfo("polynome 2- false ");
      putd = kFALSE;
    }
  }
  if((binmin == (nbins-1)) && ((binmin-2) < TMath::Min(binmax+4, projPH->GetNbinsX()))) {
    putd = kFALSE;
    //AliInfo("At the limit for the drift and not usable!");
  }

  //pass
  if((binmin == (nbins-2)) && ((binmin-1) < TMath::Min(binmax+4, projPH->GetNbinsX()))){
    putd = kFALSE;
    //AliInfo("For the drift...problem!");
  }
  //pass but should not happen
  if((binmin <= (nbins-3)) && (binmin < TMath::Min(binmax+6, projPH->GetNbinsX()))){
    putd = kFALSE;
    //AliInfo("For the drift...problem!");
  }
  
  if(putd) {
    polynome = new TF1("pol","[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x",min,max);
    polynome->SetParameters(c0,c1,c2,c3,c4);
    //AliInfo(Form("GetMinimum of the function %f",polynome->GetMinimumX()));
    Double_t step = (max-min)/1000;
    Double_t l = min;
    Double_t minvalue = 0.0;
    Double_t placeminimum = min;
    for(Int_t o = 0; o < 1000; o++){
      if(o == 0) minvalue = polynome->Eval(l);
      if(minvalue > (polynome->Eval(l))){
	minvalue = polynome->Eval(l);
	placeminimum = l;
      }
      l += step;
    }
    fPhd[2] = placeminimum;
  }
  //printf("La fin %d\n",((Int_t)(fPhd[2]*10.0))+2);
  if((((Int_t)(fPhd[2]*10.0))+2) >= projPH->GetNbinsX()) fPhd[2] = 0.0;
  if(((((Int_t)(fPhd[2]*10.0))+2) < projPH->GetNbinsX()) && (projPH->GetBinContent(((Int_t)(fPhd[2]*10.0))+2)==0)) fPhd[2] = 0.0;
  
  Float_t fPhdt0  = 0.0;
  Float_t t0Shift = 0.0;
  if(fTakeTheMaxPH) {
    fPhdt0 = fPhd[1];
    t0Shift = fT0Shift1;
  }
  else {
    fPhdt0 = fPhd[0];
    t0Shift = fT0Shift0;
  }

  if ((fPhd[2] > fPhd[0]) && 
      (fPhd[2] > fPhd[1]) && 
      (fPhd[1] > fPhd[0]) &&
      (put) &&
      (putd)) {
    fCurrentCoef[0] = (kDrWidth) / (fPhd[2]-fPhd[1]);
    if(fCurrentCoef[0] > 2.5) fCurrentCoef[0] =  -TMath::Abs(fCurrentCoef[1]);
    else fNumberFitSuccess++;
    if (fPhdt0 >= 0.0) {
      fCurrentCoef2[0] = (fPhdt0 - t0Shift) / widbins;
      //printf("Value of timeoffset %f\n",fCurrentCoef2[0]);
      if (fCurrentCoef2[0] < -3.0) {
        fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
      }
    }
    else {
      fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
    }
  }
  else {
    ////printf("Put default %f\n",-TMath::Abs(fCurrentCoef[1]));
    fCurrentCoef[0]      = -TMath::Abs(fCurrentCoef[1]);
    
    if((fPhd[1] > fPhd[0]) &&
       (put)) {
      if (fPhdt0 >= 0.0) {
	fCurrentCoef2[0] = (fPhdt0 - t0Shift) / widbins;
	if (fCurrentCoef2[0] < -3.0) {
	  fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
	}
	else fNumberFitSuccess++;
      }
      else {
	fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
      }
    }
    else{
      fCurrentCoef2[0]     = fCurrentCoef2[1] + 100.0;
      //printf("Fit failed!\n");
    }
  }
  
  if (fDebugLevel == 1) {
    TCanvas *cpentei = new TCanvas("cpentei","cpentei",50,50,600,800);
    cpentei->cd();
    projPH->Draw();
    if(polynomea) polynomea->Draw("same");
    line->SetLineColor(2);
    line->DrawLine(fPhd[0],0,fPhd[0],projPH->GetMaximum());
    line->DrawLine(fPhd[1],0,fPhd[1],projPH->GetMaximum());
    line->DrawLine(fPhd[2],0,fPhd[2],projPH->GetMaximum());
    AliInfo(Form("fPhd[0] (beginning of the signal): %f"                  ,(Float_t) fPhd[0]));
    AliInfo(Form("fPhd[1] (end of the amplification region): %f"          ,(Float_t) fPhd[1]));
    AliInfo(Form("fPhd[2] (end of the drift region): %f"                  ,(Float_t) fPhd[2]));
    AliInfo(Form("Vdrift (with only the drift region(default)): %f",(Float_t) fCurrentCoef[0]));
    AliInfo(Form("Timeoffset (with only the drift region(default)): %f",(Float_t) fCurrentCoef2[0]));
    TCanvas *cpentei2 = new TCanvas("cpentei2","cpentei2",50,50,600,800);
    cpentei2->cd();
    pentea->Draw();
    TCanvas *cpentei3 = new TCanvas("cpentei3","cpentei3",50,50,600,800);
    cpentei3->cd();
    pente->Draw();
  }
  else {
    delete pentea;
    delete pente;
    if(polynome) delete polynome;
    if(polynomea) delete polynomea;
    if(polynomeb) delete polynomeb;
    //if(x) delete [] x;
    //if(y) delete [] y;
    if(line) delete line;

  }

  //Provisoire
  //if(fCurrentCoef[0] > 1.7) fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
  //if((fCurrentCoef2[0] > 2.6) || (fCurrentCoef2[0] < 2.1)) fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
  //printf("Value of timeoffset final %f\n",fCurrentCoef2[0]);
  projPH->SetDirectory(0);

}

//_____________________________________________________________________________
void AliTRDCalibraFit::FitPH(TH1* projPH, Int_t idect)
{
  //
  // Fit methode for the drift velocity
  //
  
  // Constants
  const Float_t kDrWidth = AliTRDgeometry::DrThick();  

  // Some variables
  TAxis   *xpph   = projPH->GetXaxis();
  Double_t upedge = xpph->GetBinUpEdge(xpph->GetNbins());

  TF1 *fPH = new TF1("fPH",AliTRDCalibraFit::PH,-0.05,3.2,6);
  fPH->SetParameter(0,0.469);     // Scaling
  fPH->SetParameter(1,0.18);      // Start 
  fPH->SetParameter(2,0.0857325); // AR
  fPH->SetParameter(3,1.89);      // DR
  fPH->SetParameter(4,0.08);      // QA/QD
  fPH->SetParameter(5,0.0);       // Baseline

  TLine *line = new TLine();

  fCurrentCoef[0]     = 0.0;
  fCurrentCoef2[0]    = 0.0;
  fCurrentCoefE       = 0.0;
  fCurrentCoefE2      = 0.0;
 
  if (idect%fFitPHPeriode == 0) {

    AliInfo(Form("The detector %d will be fitted",idect));
    fPH->SetParameter(0,(projPH->Integral()-(projPH->GetBinContent(1)*projPH->GetNbinsX())) * 0.00028); // Scaling
    fPH->SetParameter(1,fPhd[0] - 0.1);                                                                 // Start 
    fPH->SetParameter(2,fPhd[1] - fPhd[0]);                                                             // AR
    fPH->SetParameter(3,fPhd[2] - fPhd[1]);                                                             // DR
    fPH->SetParameter(4,0.225);                                                                         // QA/QD
    fPH->SetParameter(5,(Float_t) projPH->GetBinContent(1));
    
    if (fDebugLevel != 1) {
      projPH->Fit(fPH,"0M","",0.0,upedge);
    }
    else {
      TCanvas *cpente = new TCanvas("cpente","cpente",50,50,600,800);
      cpente->cd();
      projPH->Fit(fPH,"M+","",0.0,upedge);
      projPH->Draw("E0");
      line->SetLineColor(4);
      line->DrawLine(fPH->GetParameter(1)
                    ,0
                    ,fPH->GetParameter(1)
                    ,projPH->GetMaximum());
      line->DrawLine(fPH->GetParameter(1)+fPH->GetParameter(2)
                    ,0
                    ,fPH->GetParameter(1)+fPH->GetParameter(2)
                    ,projPH->GetMaximum());
      line->DrawLine(fPH->GetParameter(1)+fPH->GetParameter(2)+fPH->GetParameter(3)
                    ,0
                    ,fPH->GetParameter(1)+fPH->GetParameter(2)+fPH->GetParameter(3)
                    ,projPH->GetMaximum());
    }

    if (fPH->GetParameter(3) != 0) {
      fNumberFitSuccess++;
      fCurrentCoef[0]    = kDrWidth / (fPH->GetParameter(3));
      fCurrentCoefE      = (fPH->GetParError(3)/fPH->GetParameter(3))*fCurrentCoef[0];
      fCurrentCoef2[0]   = fPH->GetParameter(1);
      fCurrentCoefE2     = fPH->GetParError(1);
    } 
    else {
      fCurrentCoef[0]     = -TMath::Abs(fCurrentCoef[1]);
      fCurrentCoef2[0]    = fCurrentCoef2[1] + 100.0;
    }
 
  }
  else {

    // Put the default value
    fCurrentCoef[0]  = -TMath::Abs(fCurrentCoef[1]);
    fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
  }

  if (fDebugLevel != 1) {
    delete fPH;
  }
  
}
//_____________________________________________________________________________
Bool_t AliTRDCalibraFit::FitPRFGausMI(Double_t *arraye, Double_t *arraym, Double_t *arrayme, Int_t nBins, Float_t xMin, Float_t xMax)
{
  //
  // Fit methode for the sigma of the pad response function
  //

  TVectorD param(3);
  
  fCurrentCoef[0]  = 0.0;
  fCurrentCoefE = 0.0;

  Double_t ret = FitGausMI(arraye, arraym, arrayme, nBins, xMin, xMax,&param); 

  if(TMath::Abs(ret+4) <= 0.000000001){
    fCurrentCoef[0] = -fCurrentCoef[1];
    return kFALSE;
  }
  else {
    fNumberFitSuccess++;
    fCurrentCoef[0] = param[2];
    fCurrentCoefE   = ret;
    return kTRUE;
  }
}
//_____________________________________________________________________________
Double_t AliTRDCalibraFit::FitGausMI(Double_t *arraye, Double_t *arraym, Double_t *arrayme, Int_t nBins, Float_t xMin, Float_t xMax, TVectorD *param, Bool_t bError)
{
  //
  // Fit methode for the sigma of the pad response function
  //

  //We should have at least 3 points
  if(nBins <=3) return -4.0;

  TLinearFitter fitter(3,"pol2");
  fitter.StoreData(kFALSE);
  fitter.ClearPoints();
  TVectorD  par(3);
  Float_t binWidth = (xMax-xMin)/(Float_t)nBins;
  Float_t entries = 0;
  Int_t   nbbinwithentries = 0;
  for (Int_t i=0; i<nBins; i++){
    entries+=arraye[i];
    if(arraye[i] > 15) nbbinwithentries++;
    //printf("entries for i %d: %f\n",i,arraye[i]);
  }
  if ((entries<700) || (nbbinwithentries < ((Int_t)(nBins/2)))) return -4;
  //printf("entries %f\n",entries);
  //printf("nbbinwithentries %d\n",nbbinwithentries);  

  Int_t npoints=0;
  Float_t errorm = 0.0;
  Float_t errorn = 0.0;
  Float_t error  = 0.0;
  
  //
  for (Int_t ibin=0;ibin<nBins; ibin++){
      Float_t entriesI = arraye[ibin];
      Float_t valueI   = arraym[ibin];
      Double_t xcenter = 0.0;
      Float_t  val     = 0.0;
      if ((entriesI>15) && (valueI>0.0)){
      	xcenter = xMin+(ibin+0.5)*binWidth;
	errorm   = 0.0;
	errorn   = 0.0;
	error    = 0.0;
	if(!bError){
	  if((valueI + 0.01) > 0.0) errorm = TMath::Log((valueI + 0.01)/valueI);
	  if((valueI - 0.01) > 0.0) errorn = TMath::Log((valueI - 0.01)/valueI);
	  error = TMath::Max(TMath::Abs(errorm),TMath::Abs(errorn));
	}
	else{
	  if((valueI + arrayme[ibin]) > 0.0) errorm = TMath::Log((valueI + arrayme[ibin])/valueI);
	  if((valueI - arrayme[ibin]) > 0.0) errorn = TMath::Log((valueI - arrayme[ibin])/valueI);
	  error = TMath::Max(TMath::Abs(errorm),TMath::Abs(errorn));
	}
	if(TMath::Abs(error) < 0.000000001) continue;
	val      = TMath::Log(Float_t(valueI));
	fitter.AddPoint(&xcenter,val,error);
	npoints++;
      }

      if(fDebugLevel > 1){

      if ( !fDebugStreamer ) {
	//debug stream
	TDirectory *backup = gDirectory;
	fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
	if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
      } 
      
      Int_t    detector     = fCountDet;
      Int_t    layer        = GetLayer(fCountDet);
      Int_t    group        = ibin;    
     
      (* fDebugStreamer) << "FitGausMIFill"<<
	"detector="<<detector<<
	"layer="<<layer<<
	"nbins="<<nBins<<
	"group="<<group<<
	"entriesI="<<entriesI<<
	"valueI="<<valueI<<
	"val="<<val<<
	"xcenter="<<xcenter<<
	"errorm="<<errorm<<
	"errorn="<<errorn<<
	"error="<<error<<
	"bError="<<bError<<
	"\n";  
    }

  }

  if(npoints <=3) return -4.0;  

  Double_t chi2 = 0;
  if (npoints>3){
    fitter.Eval();
    fitter.GetParameters(par);
    chi2 = fitter.GetChisquare()/Float_t(npoints);
    
        
    if (!param)  param  = new TVectorD(3);
    if(TMath::Abs(par[2]) <= 0.000000001) return -4.0;
    Double_t  x      = TMath::Sqrt(TMath::Abs(-2*par[2])); 
    Double_t deltax = (fitter.GetParError(2))/x;
    Double_t errorparam2 = TMath::Abs(deltax)/(x*x);
    chi2 = errorparam2;
    
    (*param)[1] = par[1]/(-2.*par[2]);
    (*param)[2] = 1./TMath::Sqrt(TMath::Abs(-2.*par[2]));
    Double_t lnparam0 = par[0]+ par[1]* (*param)[1] +  par[2]*(*param)[1]*(*param)[1];
    if ( lnparam0>307 ) return -4;
    (*param)[0] = TMath::Exp(lnparam0);

    if(fDebugLevel > 1){

      if ( !fDebugStreamer ) {
	//debug stream
	TDirectory *backup = gDirectory;
	fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
	if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
      } 
      
      Int_t    detector     = fCountDet;
      Int_t    layer        = GetLayer(fCountDet);
           
     
      (* fDebugStreamer) << "FitGausMIFit"<<
	"detector="<<detector<<
	"layer="<<layer<<
	"nbins="<<nBins<<
	"errorsigma="<<chi2<<
	"mean="<<(*param)[1]<<
	"sigma="<<(*param)[2]<<
	"constant="<<(*param)[0]<<
	"\n";  
    }
  }

  if((chi2/(*param)[2]) > 0.1){
    if(bError){
      chi2 = FitGausMI(arraye,arraym,arrayme,nBins,xMin,xMax,param,kFALSE);
    }
    else return -4.0;
  }

  if(fDebugLevel == 1){
    TString name("PRF");
    name += (Int_t)xMin;
    name += (Int_t)xMax;  
    TCanvas *c1 = new TCanvas((const char *)name,(const char *)name,50,50,600,800);  
    c1->cd();
    name += "histo";
    TH1F *histo = new TH1F((const char *)name,(const char *)name,nBins,xMin,xMax);
    for(Int_t k = 0; k < nBins; k++){
      histo->SetBinContent(k+1,arraym[k]);
      histo->SetBinError(k+1,arrayme[k]);
    }
    histo->Draw();
    name += "functionf";
    TF1 *f1= new TF1((const char*)name,"[0]*exp(-(x-[1])^2/(2*[2]*[2]))",xMin,xMax);
    f1->SetParameter(0, (*param)[0]);
    f1->SetParameter(1, (*param)[1]);
    f1->SetParameter(2, (*param)[2]);
    f1->Draw("same");
  }

  
  return chi2;
 
}
//_____________________________________________________________________________
void AliTRDCalibraFit::FitPRF(TH1 *projPRF)
{
  //
  // Fit methode for the sigma of the pad response function
  //
  
  fCurrentCoef[0]  = 0.0;
  fCurrentCoefE = 0.0;

  if (fDebugLevel != 1) {
    projPRF->Fit("gaus","0M","",-fRangeFitPRF,fRangeFitPRF);
  }
  else {
    TCanvas *cfit = new TCanvas("cfit","cfit",50,50,600,800);
    cfit->cd();
    projPRF->Fit("gaus","M+","",-fRangeFitPRF,fRangeFitPRF);
    projPRF->Draw();
  }
  fCurrentCoef[0]  = projPRF->GetFunction("gaus")->GetParameter(2);
  fCurrentCoefE = projPRF->GetFunction("gaus")->GetParError(2);
  if(fCurrentCoef[0] <= 0.0) fCurrentCoef[0] = -fCurrentCoef[1];
  else {
    fNumberFitSuccess++;
  }
}
//_____________________________________________________________________________
void AliTRDCalibraFit::RmsPRF(TH1 *projPRF)
{
  //
  // Fit methode for the sigma of the pad response function
  //
  fCurrentCoef[0]   = 0.0;
  fCurrentCoefE  = 0.0;
  if (fDebugLevel == 1) {
    TCanvas *cfit = new TCanvas("cfit","cfit",50,50,600,800);
    cfit->cd();
    projPRF->Draw();
  }
  fCurrentCoef[0] = projPRF->GetRMS();
  if(fCurrentCoef[0] <= 0.0) fCurrentCoef[0] = -fCurrentCoef[1];
  else {
    fNumberFitSuccess++;
  }
}
//_____________________________________________________________________________
void AliTRDCalibraFit::FitTnpRange(Double_t *arraye, Double_t *arraym, Double_t *arrayme, Int_t nbg, Int_t nybins)
{
  //
  // Fit methode for the sigma of the pad response function with 2*nbg tan bins
  //
  
  TLinearFitter linearfitter = TLinearFitter(3,"pol2");
 

  Int_t   nbins    = (Int_t)(nybins/(2*nbg));
  Float_t lowedge  = -3.0*nbg;
  Float_t upedge   = lowedge + 3.0; 
  Int_t   offset   = 0;
  Int_t   npoints  = 0;
  Double_t xvalues = -0.2*nbg+0.1;
  Double_t y       = 0.0;
  Int_t   total    = 2*nbg;

  
  for(Int_t k = 0; k < total; k++){
    if(FitPRFGausMI(arraye+offset, arraym+offset, arrayme+offset, nbins, lowedge, upedge)){
      npoints++;
      y = fCurrentCoef[0]*fCurrentCoef[0];
      linearfitter.AddPoint(&xvalues,y,2*fCurrentCoefE*fCurrentCoef[0]);
    }
    
    if(fDebugLevel > 1){

      if ( !fDebugStreamer ) {
	//debug stream
	TDirectory *backup = gDirectory;
	fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
	if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
      } 
      
      Int_t    detector     = fCountDet;
      Int_t    layer        = GetLayer(fCountDet);
      Int_t    nbtotal      = total;  
      Int_t    group        = k;    
      Float_t  low          = lowedge;
      Float_t  up           = upedge;
      Float_t  tnp          = xvalues;
      Float_t  wid          = fCurrentCoef[0];
      Float_t  widfE        = fCurrentCoefE;

      (* fDebugStreamer) << "FitTnpRange0"<<
	"detector="<<detector<<
	"layer="<<layer<<
	"nbtotal="<<nbtotal<<
	"group="<<group<<
	"low="<<low<<
	"up="<<up<<
	"offset="<<offset<<
	"tnp="<<tnp<<
	"wid="<<wid<<
	"widfE="<<widfE<<
	"\n";  
    }
    
    offset  += nbins;
    lowedge += 3.0;
    upedge  += 3.0;
    xvalues += 0.2;

  }

  fCurrentCoefE = 0.0;
  fCurrentCoef[0] = 0.0;

  //printf("npoints\n",npoints);

  if(npoints < 3){
    fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
  }
  else{
  
    TVectorD pars0;
    linearfitter.Eval();
    linearfitter.GetParameters(pars0);
    // Coverity
    //Double_t pointError0  =  TMath::Sqrt(linearfitter.GetChisquare()/npoints);
    //Double_t errorsx0     =  linearfitter.GetParError(2)*pointError0;
    Double_t min0         = 0.0;
    // Coverity
    //Double_t ermin0       = 0.0;
    //Double_t prfe0      = 0.0;
    Double_t prf0         = 0.0;
    if((pars0[2] > 0.000000000001) && (TMath::Abs(pars0[1]) >= 0.000000000001)) {
      min0 = -pars0[1]/(2*pars0[2]);
      // Coverity
      //ermin0 = TMath::Abs(min0*(errorsx0/pars0[2]+linearfitter.GetParError(1)*pointError0/pars0[1]));
      prf0 = pars0[0]+pars0[1]*min0+pars0[2]*min0*min0;
      if(prf0 > 0.0) {
	/*
	  prfe0 = linearfitter->GetParError(0)*pointError0
	  +(linearfitter->GetParError(1)*pointError0/pars0[1]+ermin0/min0)*pars0[1]*min0
	  +(linearfitter->GetParError(2)*pointError0/pars0[2]+2*ermin0/min0)*pars0[2]*min0*min0;
	  prfe0 = prfe0/(2*TMath::Sqrt(prf0));
	  fCurrentCoefE   = (Float_t) prfe0;
	*/
	fCurrentCoef[0] = (Float_t) TMath::Sqrt(TMath::Abs(prf0));
      }
      else{
	fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
      }
    }
    else {
      fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
    }

    if(fDebugLevel > 1){

      if ( !fDebugStreamer ) {
	//debug stream
	TDirectory *backup = gDirectory;
	fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
	if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
      } 
      
      Int_t    detector     = fCountDet;
      Int_t    layer        = GetLayer(fCountDet);
      Int_t    nbtotal      = total;
      Double_t colsize[6]   = {0.635,0.665,0.695,0.725,0.755,0.785};  
      Double_t sigmax       = TMath::Sqrt(TMath::Abs(pars0[2]))*10000*colsize[layer];      

      (* fDebugStreamer) << "FitTnpRange1"<<
	"detector="<<detector<<
	"layer="<<layer<<
	"nbtotal="<<nbtotal<<
	"par0="<<pars0[0]<<
	"par1="<<pars0[1]<<
	"par2="<<pars0[2]<<
	"npoints="<<npoints<<
	"sigmax="<<sigmax<<
	"tan="<<min0<<
	"sigmaprf="<<fCurrentCoef[0]<<
	"sigprf="<<fCurrentCoef[1]<<
	"\n";  
    }
    
  }
  
}
//_____________________________________________________________________________
void AliTRDCalibraFit::FitMean(TH1 *projch, Double_t nentries, Double_t mean)
{
  //
  // Only mean methode for the gain factor
  //
 
  fCurrentCoef[0] = mean;
  fCurrentCoefE   = 0.0;
  if(nentries > 0) fCurrentCoefE = projch->GetRMS()/TMath::Sqrt(nentries);
  if (fDebugLevel == 1) {
    TCanvas *cpmean = new TCanvas("cpmean","cpmean",50,50,600,800);
    cpmean->cd();
    projch->Draw();
  }
  CalculChargeCoefMean(kTRUE);
  fNumberFitSuccess++;
}
//_____________________________________________________________________________
void AliTRDCalibraFit::FitMeanW(TH1 *projch, Double_t nentries)
{
  //
  // mean w methode for the gain factor
  //

  //Number of bins
  Int_t nybins = projch->GetNbinsX();
 
  //The weight function
  Double_t a = 0.00228515;
  Double_t b = -0.00231487;
  Double_t c = 0.00044298;
  Double_t d = -0.00379239;
  Double_t e = 0.00338349;

//   0 |0.00228515
//    1 |-0.00231487
//    2 |0.00044298
//    3 |-0.00379239
//    4 |0.00338349



  //A arbitrary error for the moment
  fCurrentCoefE = 0.0;
  fCurrentCoef[0] = 0.0;
  
  //Calcul 
  Double_t sumw = 0.0;
  Double_t sum = 0.0; 
  Float_t sumAll   = (Float_t) nentries;
  Int_t sumCurrent = 0;
  for(Int_t k = 0; k <nybins; k++){
    Double_t fraction = Float_t(sumCurrent)/Float_t(sumAll);
    if (fraction<fOutliersFitChargeLow) {
      sumCurrent += (Int_t) projch->GetBinContent(k+1);
      //printf("Take only after bin %d\n",k);
      continue;
    }
    if (fraction>fOutliersFitChargeHigh) {
      //printf("Break by the bin %d\n",k);
      break;
    }
    Double_t weight = a + b*fraction + c*fraction*fraction + d *fraction*fraction*fraction+
      e*fraction*fraction*fraction*fraction;
    sumw += weight*projch->GetBinContent(k+1)*projch->GetBinCenter(k+1);
    sum  += weight*projch->GetBinContent(k+1); 
    sumCurrent += (Int_t) projch->GetBinContent(k+1);
    //printf("fraction %f, weight %f, bincontent %f\n",fraction,weight,projch->GetBinContent(k+1));   
  }
  if(sum > 0.0) fCurrentCoef[0] = (sumw/sum);

  if (fDebugLevel == 1) {
    TCanvas *cpmeanw = new TCanvas("cpmeanw","cpmeanw",50,50,600,800);
    cpmeanw->cd();
    projch->Draw();
    TLine *line = new TLine(fCurrentCoef[0],0.0,fCurrentCoef[0],20000.0);
    line->Draw("same");
  }
  fNumberFitSuccess++;
  CalculChargeCoefMean(kTRUE);
}
//_____________________________________________________________________________
void AliTRDCalibraFit::FitMeanWSm(TH1 *projch, Float_t sumAll)
{
  //
  // mean w methode for the gain factor
  //

  //Number of bins
  Int_t nybins = projch->GetNbinsX();
 
  //The weight function
  Double_t a = 0.00228515;
  Double_t b = -0.00231487;
  Double_t c = 0.00044298;
  Double_t d = -0.00379239;
  Double_t e = 0.00338349;

//   0 |0.00228515
//    1 |-0.00231487
//    2 |0.00044298
//    3 |-0.00379239
//    4 |0.00338349



  //A arbitrary error for the moment
  fCurrentCoefE = 0.0;
  fCurrentCoef[0] = 0.0;
  
  //Calcul 
  Double_t sumw = 0.0;
  Double_t sum = 0.0; 
  Int_t sumCurrent = 0;
  for(Int_t k = 0; k <nybins; k++){
    Double_t fraction = Float_t(sumCurrent)/Float_t(sumAll);
    if (fraction>0.95) break;
    Double_t weight = a + b*fraction + c*fraction*fraction + d *fraction*fraction*fraction+
      e*fraction*fraction*fraction*fraction;
    sumw += weight*projch->GetBinContent(k+1)*projch->GetBinCenter(k+1);
    sum  += weight*projch->GetBinContent(k+1); 
    sumCurrent += (Int_t) projch->GetBinContent(k+1);
    //printf("fraction %f, weight %f, bincontent %f\n",fraction,weight,projch->GetBinContent(k+1));   
  }
  if(sum > 0.0) fCurrentCoef[0] = (sumw/sum);

  if (fDebugLevel == 1) {
    TCanvas *cpmeanw = new TCanvas("cpmeanw","cpmeanw",50,50,600,800);
    cpmeanw->cd();
    projch->Draw();
    TLine *line = new TLine(fCurrentCoef[0],0.0,fCurrentCoef[0],20000.0);
    line->Draw("same");
  }
  fNumberFitSuccess++;
}
//_____________________________________________________________________________
void AliTRDCalibraFit::FitLandau(TH1 *projch, Double_t mean, Double_t nentries)
{
  //
  // Fit methode for the gain factor
  //

  
  //Calcul Range of the fit 
  Double_t lastvalue = 0.0;
  Float_t sumAll   = (Float_t) nentries;
  Int_t sumCurrent = 0;
  //printf("There are %d bins\n",nybins);
  for(Int_t k = 0; k <projch->GetNbinsX(); k++){
    Double_t fraction = Float_t(sumCurrent)/Float_t(sumAll);
    if (fraction>fOutliersFitChargeHigh) {
      lastvalue = projch->GetBinCenter(k+1); 
      //printf("Break by %f\n",lastvalue);
      break;
    }
    sumCurrent += (Int_t) projch->GetBinContent(k+1);
  }
  //
 
  fCurrentCoef[0]  = 0.0;
  fCurrentCoefE    = 0.0;
  // Coverity
  //Double_t chisqrl = 0.0;
  
  projch->Fit("landau","WWQ+",""
             ,(Double_t) mean/fBeginFitCharge
             ,lastvalue);
  // Coverity
  //chisqrl = projch->GetFunction("landau")->GetChisquare();
 
  if (fDebugLevel == 1) {
    TCanvas *cp = new TCanvas("cp","cp",50,50,600,800);
    cp->cd();
    projch->Draw();
    TLine *line = new TLine( projch->GetFunction("landau")->GetParameter(1),0.0,projch->GetFunction("landau")->GetParameter(1),20000.0);
    line->Draw("same");
  }
  
  if ((projch->GetFunction("landau")->GetParameter(1) > 0) && (projch->GetFunction("landau")->GetParError(1) < (0.05*projch->GetFunction("landau")->GetParameter(1)))) {
    fNumberFitSuccess++;
    CalculChargeCoefMean(kTRUE);
    fCurrentCoef[0]  = projch->GetFunction("landau")->GetParameter(1);
    fCurrentCoefE    = projch->GetFunction("landau")->GetParError(1);
  }
  else {
    CalculChargeCoefMean(kFALSE);
    fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
  }
   
  

}
//_____________________________________________________________________________
void AliTRDCalibraFit::FitCH(TH1 *projch, Double_t mean, Double_t nentries)
{
  //
  // Fit methode for the gain factor
  //

  //Calcul Range of the fit 
  Double_t lastvalue = 0.0;
  Float_t sumAll   = (Float_t) nentries;
  Int_t sumCurrent = 0;
  //printf("There are %d bins\n",nybins);
  for(Int_t k = 0; k <projch->GetNbinsX(); k++){
    Double_t fraction = Float_t(sumCurrent)/Float_t(sumAll);
    if (fraction>fOutliersFitChargeHigh) {
      lastvalue = projch->GetBinCenter(k+1); 
      //printf("Break by %f\n",lastvalue);
      break;
    }
    sumCurrent += (Int_t) projch->GetBinContent(k+1);
  }
  //
 
  fCurrentCoef[0]  = 0.0;
  fCurrentCoefE    = 0.0;
  Double_t chisqrl = 0.0;
  Double_t chisqrg = 0.0;
  Double_t chisqr  = 0.0;
  TF1 *fLandauGaus = new TF1("fLandauGaus",FuncLandauGaus,(Double_t) mean/fBeginFitCharge,lastvalue,5);

  projch->Fit("landau","WWQ0",""
             ,(Double_t) mean/fBeginFitCharge
             ,lastvalue);
  Double_t l3P0         = projch->GetFunction("landau")->GetParameter(0);
  Double_t l3P1         = projch->GetFunction("landau")->GetParameter(1);
  Double_t l3P2         = projch->GetFunction("landau")->GetParameter(2);
  chisqrl = projch->GetFunction("landau")->GetChisquare();
    
  projch->Fit("gaus","WWQ0",""
	      ,(Double_t) mean/fBeginFitCharge
	      ,lastvalue);
  Double_t g3P0         = projch->GetFunction("gaus")->GetParameter(0);
  Double_t g3P2         = projch->GetFunction("gaus")->GetParameter(2);
  chisqrg = projch->GetFunction("gaus")->GetChisquare();
        
  fLandauGaus->SetParameters(l3P0,l3P1,l3P2,g3P0,g3P2);
  if (fDebugLevel != 1) {
    projch->Fit("fLandauGaus","WWQ0",""
		,(Double_t) mean/fBeginFitCharge
		,lastvalue);
    chisqr = projch->GetFunction("fLandauGaus")->GetChisquare();
  } 
  else  {
    TCanvas *cp = new TCanvas("cp","cp",50,50,600,800);
    cp->cd();
    projch->Fit("fLandauGaus","WWQ+",""
		,(Double_t) mean/fBeginFitCharge
		,lastvalue);
    chisqr = projch->GetFunction("fLandauGaus")->GetChisquare();
    projch->Draw();
    fLandauGaus->Draw("same");
    TLine *line = new TLine(projch->GetFunction("fLandauGaus")->GetParameter(1),0.0,projch->GetFunction("fLandauGaus")->GetParameter(1),20000.0);
    line->Draw("same");
  }
  
  if ((projch->GetFunction("fLandauGaus")->GetParameter(1) > 0) && (projch->GetFunction("fLandauGaus")->GetParError(1) < (0.05*projch->GetFunction("fLandauGaus")->GetParameter(1))) && (chisqr < chisqrl) && (chisqr < chisqrg)) {
    fNumberFitSuccess++;
    CalculChargeCoefMean(kTRUE);
    fCurrentCoef[0]  = projch->GetFunction("fLandauGaus")->GetParameter(1);
    fCurrentCoefE    = projch->GetFunction("fLandauGaus")->GetParError(1);
  }
  else {
    CalculChargeCoefMean(kFALSE);
    fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
  }
   
  if (fDebugLevel != 1) {
    delete fLandauGaus;
  }

}
//_____________________________________________________________________________
void AliTRDCalibraFit::FitBisCH(TH1* projch, Double_t mean, Double_t nentries)
{
  //
  // Fit methode for the gain factor more time consuming
  //

  //Calcul Range of the fit 
  Double_t lastvalue = 0.0;
  Float_t sumAll   = (Float_t) nentries;
  Int_t sumCurrent = 0;
  //printf("There are %d bins\n",nybins);
  for(Int_t k = 0; k <projch->GetNbinsX(); k++){
    Double_t fraction = Float_t(sumCurrent)/Float_t(sumAll);
    if (fraction>fOutliersFitChargeHigh) {
      lastvalue = projch->GetBinCenter(k+1); 
      //printf("Break by %f\n",lastvalue);
      break;
    }
    sumCurrent += (Int_t) projch->GetBinContent(k+1);
  }
  //

  //Some parameters to initialise
  Double_t widthLandau, widthGaus, mPV, integral;
  Double_t chisquarel = 0.0;
  Double_t chisquareg = 0.0;
  projch->Fit("landau","WWQ0M+",""
	      ,(Double_t) mean/fBeginFitCharge
	      ,lastvalue);
  widthLandau  = projch->GetFunction("landau")->GetParameter(2);
  chisquarel = projch->GetFunction("landau")->GetChisquare();
  projch->Fit("gaus","WWQ0M+",""
	      ,(Double_t) mean/fBeginFitCharge
	      ,lastvalue);
  widthGaus    = projch->GetFunction("gaus")->GetParameter(2);
  chisquareg = projch->GetFunction("gaus")->GetChisquare();
    
  mPV = (projch->GetFunction("landau")->GetParameter(1))/2;
  integral = (projch->GetFunction("gaus")->Integral(0.3*mean,3*mean)+projch->GetFunction("landau")->Integral(0.3*mean,3*mean))/2;
  
  // Setting fit range and start values
  Double_t fr[2];
  Double_t sv[4]   = { widthLandau, mPV, integral, widthGaus};
  Double_t pllo[4] = { 0.001, 0.001, projch->Integral()/3, 0.001};
  Double_t plhi[4] = { 300.0, 300.0, 30*projch->Integral(), 300.0};
  Double_t fp[4]   = { 1.0, 1.0, 1.0, 1.0 };
  Double_t fpe[4]  = { 1.0, 1.0, 1.0, 1.0 };
  fr[0]            = mean/fBeginFitCharge;
  fr[1]            = lastvalue;
  fCurrentCoef[0]  = 0.0;
  fCurrentCoefE    = 0.0;

  Double_t chisqr;
  Int_t    ndf;
  TF1 *fitsnr = LanGauFit(projch,&fr[0],&sv[0]
                                ,&pllo[0],&plhi[0]
                                ,&fp[0],&fpe[0]
                                ,&chisqr,&ndf);
    
  //Double_t projchPeak;
  //Double_t projchFWHM;
  //LanGauPro(fp,projchPeak,projchFWHM);

  if ((fp[1] > 0) && ((fpe[1] < (0.05*fp[1])) && (chisqr < chisquarel) && (chisqr < chisquareg))) {
    //if ((fp[1] > 0) && ((chisqr < chisquarel) && (chisqr < chisquareg))) {
    fNumberFitSuccess++;
    CalculChargeCoefMean(kTRUE);
    fCurrentCoef[0]  = fp[1];
    fCurrentCoefE = fpe[1];
    //chargeCoefE2 = chisqr;
  } 
  else {
    CalculChargeCoefMean(kFALSE);
    fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
  }
  if (fDebugLevel == 1) {
    AliInfo(Form("fChargeCoef[0]: %f",(Float_t) fCurrentCoef[0]));
    TCanvas *cpy = new TCanvas("cpy","cpy",50,50,600,800);
    cpy->cd();
    projch->Draw();
    fitsnr->Draw("same");
    TLine *line = new TLine(fp[1],0.0,fp[1],20000.0);
    line->Draw("same");
  }
  else {
    delete fitsnr;
  }
} 
//_____________________________________________________________________________
void AliTRDCalibraFit::FitBisCHEx(TH1* projch, Double_t mean, Double_t nentries)
{
  //
  // Fit methode for the gain factor more time consuming
  //

  //Calcul Range of the fit 
  Double_t lastvalue = 0.0;
  Float_t sumAll   = (Float_t) nentries;
  Int_t sumCurrent = 0;
  //printf("There are %d bins\n",nybins);
  for(Int_t k = 0; k <projch->GetNbinsX(); k++){
    Double_t fraction = Float_t(sumCurrent)/Float_t(sumAll);
    if (fraction>fOutliersFitChargeHigh) {
      lastvalue = projch->GetBinCenter(k+1); 
      //printf("Break by %f\n",lastvalue);
      break;
    }
    sumCurrent += (Int_t) projch->GetBinContent(k+1);
  }
  //


  //Some parameters to initialise
  Double_t widthLandau, widthGaus, mPV, integral;
  Double_t chisquarel = 0.0;
  Double_t chisquareg = 0.0;
  projch->Fit("landau","WWQM+",""
	      ,(Double_t) mean/fBeginFitCharge
	      ,lastvalue);
  widthLandau  = projch->GetFunction("landau")->GetParameter(2);
  chisquarel = projch->GetFunction("landau")->GetChisquare();
  projch->Fit("gaus","WWQM+",""
	      ,(Double_t) mean/fBeginFitCharge
	      ,lastvalue);
  widthGaus    = projch->GetFunction("gaus")->GetParameter(2);
  chisquareg = projch->GetFunction("gaus")->GetChisquare();
    
  mPV = (projch->GetFunction("landau")->GetParameter(1))/2;
  integral = (projch->GetFunction("gaus")->Integral(0.3*mean,3*mean)+projch->GetFunction("landau")->Integral(0.3*mean,3*mean))/2;
  
  // Setting fit range and start values
  Double_t fr[2];
  //Double_t sv[4] = { l3P2, fChargeCoef[1], projch->Integral("width"), fG3P2 };
  //Double_t sv[4]   = { fL3P2, fChargeCoef[1], fL3P0, fG3P2 };
  Double_t sv[5]   = { widthLandau, mPV, integral, widthGaus, 0.0};
  Double_t pllo[5] = { 0.001, 0.001, projch->Integral()/3, 0.001, 0.0};
  Double_t plhi[5] = { 300.0, 300.0, 30*projch->Integral(), 300.0, 2.0};
  Double_t fp[5]   = { 1.0, 1.0, 1.0, 1.0, 1.0};
  Double_t fpe[5]  = { 1.0, 1.0, 1.0, 1.0, 1.0};
  //
  //fr[0]            = 0.3 * mean;
  //fr[1]            = 3.0 * mean;
  //
  fr[0]            = mean/fBeginFitCharge;
  fr[1]            = lastvalue;
  
  fCurrentCoef[0]  = 0.0;
  fCurrentCoefE    = 0.0;

  Double_t chisqr = 100.0;
  Int_t    ndf = 1;
  
  TF1 *fitsnr = 0x0;
  
  if((mPV > 0.0) && (projch->GetFunction("gaus")->GetParameter(1) > 0.0)) {
    fitsnr = LanGauFitEx(projch,&fr[0],&sv[0]
			 ,&pllo[0],&plhi[0]
			 ,&fp[0],&fpe[0]
			 ,&chisqr,&ndf);
  }  

  //Double_t projchPeak;
  //Double_t projchFWHM;
  //LanGauProEx(fp,projchPeak,projchFWHM);

  if ((fp[1] > 0) && ((fpe[1] < (0.05*fp[1])) && (chisqr < chisquarel) && (chisqr < chisquareg))) {
    //if ((fp[1] > 0) && ((chisqr < chisquarel) && (chisqr < chisquareg))) {
    fNumberFitSuccess++;
    CalculChargeCoefMean(kTRUE);
    fCurrentCoef[0]  = fp[1];
    fCurrentCoefE = fpe[1];
    //chargeCoefE2 = chisqr;
  } 
  else {
    CalculChargeCoefMean(kFALSE);
    fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
  }
  if (fDebugLevel == 1) {
    AliInfo(Form("fChargeCoef[0]: %f",(Float_t) fCurrentCoef[0]));
    TCanvas *cpy = new TCanvas("cpy","cpy",50,50,600,800);
    cpy->cd();
    projch->Draw();
    if(fitsnr) fitsnr->Draw("same");
    TLine *line = new TLine(fp[1],0.0,fp[1],20000.0);
    line->Draw("same");
  }
  else {
    delete fitsnr;
  }
} 
//_____________________________________________________________________________
void AliTRDCalibraFit::CalculPolynomeLagrange2(const Double_t *x, const Double_t *y, Double_t &c0, Double_t &c1, Double_t &c2, Double_t &c3, Double_t &c4) const
{
  //
  // Calcul the coefficients of the polynome passant par ces trois points de degre 2
  //
  Double_t x0 = y[0]/((x[0]-x[1])*(x[0]-x[2]));
  Double_t x1 = y[1]/((x[1]-x[0])*(x[1]-x[2]));
  Double_t x2 = y[2]/((x[2]-x[0])*(x[2]-x[1]));

  c4 = 0.0;
  c3 = 0.0;
  c2 = x0+x1+x2;
  c1 = -(x0*(x[1]+x[2])+x1*(x[0]+x[2])+x2*(x[0]+x[1]));
  c0 = x0*x[1]*x[2]+x1*x[0]*x[2]+x2*x[0]*x[1];

}

//_____________________________________________________________________________
void AliTRDCalibraFit::CalculPolynomeLagrange3(const Double_t *x, const Double_t *y, Double_t &c0, Double_t &c1, Double_t &c2, Double_t &c3, Double_t &c4) const
{
  //
  // Calcul the coefficients of the polynome passant par ces quatre points de degre 3
  //
  Double_t x0 = y[0]/((x[0]-x[1])*(x[0]-x[2])*(x[0]-x[3]));
  Double_t x1 = y[1]/((x[1]-x[0])*(x[1]-x[2])*(x[1]-x[3]));
  Double_t x2 = y[2]/((x[2]-x[0])*(x[2]-x[1])*(x[2]-x[3]));
  Double_t x3 = y[3]/((x[3]-x[0])*(x[3]-x[1])*(x[3]-x[2]));

  c4 = 0.0;
  c3 = x0+x1+x2+x3;
  c2 = -(x0*(x[1]+x[2]+x[3])
	   +x1*(x[0]+x[2]+x[3])
	   +x2*(x[0]+x[1]+x[3])
	   +x3*(x[0]+x[1]+x[2]));
  c1 = (x0*(x[1]*x[2]+x[1]*x[3]+x[2]*x[3])
	  +x1*(x[0]*x[2]+x[0]*x[3]+x[2]*x[3])
	  +x2*(x[0]*x[1]+x[0]*x[3]+x[1]*x[3])
	  +x3*(x[0]*x[1]+x[0]*x[2]+x[1]*x[2]));
  
  c0 = -(x0*x[1]*x[2]*x[3]
	  +x1*x[0]*x[2]*x[3]
	  +x2*x[0]*x[1]*x[3]
	  +x3*x[0]*x[1]*x[2]);  


}

//_____________________________________________________________________________
void AliTRDCalibraFit::CalculPolynomeLagrange4(const Double_t *x, const Double_t *y, Double_t &c0, Double_t &c1, Double_t &c2, Double_t &c3, Double_t &c4) const
{
  //
  // Calcul the coefficients of the polynome passant par ces cinqs points de degre 4
  //
  Double_t x0 = y[0]/((x[0]-x[1])*(x[0]-x[2])*(x[0]-x[3])*(x[0]-x[4]));
  Double_t x1 = y[1]/((x[1]-x[0])*(x[1]-x[2])*(x[1]-x[3])*(x[1]-x[4]));
  Double_t x2 = y[2]/((x[2]-x[0])*(x[2]-x[1])*(x[2]-x[3])*(x[2]-x[4]));
  Double_t x3 = y[3]/((x[3]-x[0])*(x[3]-x[1])*(x[3]-x[2])*(x[3]-x[4]));
  Double_t x4 = y[4]/((x[4]-x[0])*(x[4]-x[1])*(x[4]-x[2])*(x[4]-x[3]));
 

  c4 = x0+x1+x2+x3+x4;
  c3 = -(x0*(x[1]+x[2]+x[3]+x[4])
	   +x1*(x[0]+x[2]+x[3]+x[4])
	   +x2*(x[0]+x[1]+x[3]+x[4])
	   +x3*(x[0]+x[1]+x[2]+x[4])
	   +x4*(x[0]+x[1]+x[2]+x[3]));
  c2 = (x0*(x[1]*x[2]+x[1]*x[3]+x[1]*x[4]+x[2]*x[3]+x[2]*x[4]+x[3]*x[4])
	  +x1*(x[0]*x[2]+x[0]*x[3]+x[0]*x[4]+x[2]*x[3]+x[2]*x[4]+x[3]*x[4])
	  +x2*(x[0]*x[1]+x[0]*x[3]+x[0]*x[4]+x[1]*x[3]+x[1]*x[4]+x[3]*x[4])
	  +x3*(x[0]*x[1]+x[0]*x[2]+x[0]*x[4]+x[1]*x[2]+x[1]*x[4]+x[2]*x[4])
	  +x4*(x[0]*x[1]+x[0]*x[2]+x[0]*x[3]+x[1]*x[2]+x[1]*x[3]+x[2]*x[3]));

  c1 = -(x0*(x[1]*x[2]*x[3]+x[1]*x[2]*x[4]+x[1]*x[3]*x[4]+x[2]*x[3]*x[4])
	  +x1*(x[0]*x[2]*x[3]+x[0]*x[2]*x[4]+x[0]*x[3]*x[4]+x[2]*x[3]*x[4])
	  +x2*(x[0]*x[1]*x[3]+x[0]*x[1]*x[4]+x[0]*x[3]*x[4]+x[1]*x[3]*x[4])
	  +x3*(x[0]*x[1]*x[2]+x[0]*x[1]*x[4]+x[0]*x[2]*x[4]+x[1]*x[2]*x[4])
	  +x4*(x[0]*x[1]*x[2]+x[0]*x[1]*x[3]+x[0]*x[2]*x[3]+x[1]*x[2]*x[3]));

  c0 = (x0*x[1]*x[2]*x[3]*x[4]
	  +x1*x[0]*x[2]*x[3]*x[4]
	  +x2*x[0]*x[1]*x[3]*x[4]
	  +x3*x[0]*x[1]*x[2]*x[4]
	  +x4*x[0]*x[1]*x[2]*x[3]);

}
//_____________________________________________________________________________
void AliTRDCalibraFit::NormierungCharge()
{
  //
  // Normalisation of the gain factor resulting for the fits
  //
  
  // Calcul of the mean of choosen method by fFitChargeNDB
  Double_t sum         = 0.0;
  //printf("total number of entries %d\n",fVectorFitCH->GetEntriesFast());
  for (Int_t k = 0; k < (Int_t) fVectorFit.GetEntriesFast(); k++) {
    Int_t    total    = 0;
    Int_t    detector = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
    Float_t *coef     = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef();
    //printf("detector %d coef[0] %f\n",detector,coef[0]);
    if (GetStack(detector) == 2) {
      total = 1728;
    }
    if (GetStack(detector) != 2) {
      total = 2304;
    }
    for (Int_t j = 0; j < total; j++) {
      if (coef[j] >= 0) {
	sum += coef[j];
      }
    }
  }

  if (sum > 0) {
    fScaleFitFactor = fScaleFitFactor / sum;
  }
  else {
    fScaleFitFactor = 1.0;
  }  

  //methode de boeuf mais bon...
  Double_t scalefactor = fScaleFitFactor;
  
  if(fDebugLevel > 1){
    
    if ( !fDebugStreamer ) {
      //debug stream
      TDirectory *backup = gDirectory;
      fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
      if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
    } 
    (* fDebugStreamer) << "NormierungCharge"<<
      "scalefactor="<<scalefactor<<
      "\n";  
    }
}
//_____________________________________________________________________________
TH1I *AliTRDCalibraFit::ReBin(const TH1I *hist) const
{
  //
  // Rebin of the 1D histo for the gain calibration if needed.
  // you have to choose fRebin, divider of fNumberBinCharge
  //

  const TAxis *xhist  = hist->GetXaxis();
 TH1I  *rehist = new TH1I("projrebin","",(Int_t) xhist->GetNbins()/fRebin
                                        ,xhist->GetBinLowEdge(1)
                                        ,xhist->GetBinUpEdge(xhist->GetNbins()));

 AliInfo(Form("fRebin: %d",fRebin));
 Int_t i = 1;
 for (Int_t k = 1; k <= (Int_t) xhist->GetNbins()/fRebin; k++) {
   Double_t sum = 0.0;
   for (Int_t ji = i; ji < i+fRebin; ji++) {
     sum += hist->GetBinContent(ji);
   }
   sum = sum / fRebin;
   rehist->SetBinContent(k,sum);
   i += fRebin;
 }

 return rehist;

}

//_____________________________________________________________________________
TH1F *AliTRDCalibraFit::ReBin(const TH1F *hist) const
{
  //
  // Rebin of the 1D histo for the gain calibration if needed
  // you have to choose fRebin divider of fNumberBinCharge
  //

  const TAxis *xhist  = hist->GetXaxis();
  TH1F  *rehist = new TH1F("projrebin","",(Int_t) xhist->GetNbins()/fRebin
                                         ,xhist->GetBinLowEdge(1)
                                         ,xhist->GetBinUpEdge(xhist->GetNbins()));

  AliInfo(Form("fRebin: %d",fRebin));
  Int_t i = 1;
  for (Int_t k = 1; k <= (Int_t) xhist->GetNbins()/fRebin; k++) {
    Double_t sum = 0.0;
    for (Int_t ji = i; ji < i+fRebin; ji++) {
      sum += hist->GetBinContent(ji);
    }
    sum = sum/fRebin;
    rehist->SetBinContent(k,sum);
    i += fRebin;
  }

  return rehist;
  
}
//
//____________Some basic geometry function_____________________________________
//

//_____________________________________________________________________________
Int_t AliTRDCalibraFit::GetLayer(Int_t d) const
{
  //
  // Reconstruct the plane number from the detector number
  //

  return ((Int_t) (d % 6));

}

//_____________________________________________________________________________
Int_t AliTRDCalibraFit::GetStack(Int_t d) const
{
  //
  // Reconstruct the stack number from the detector number
  //
  const Int_t kNlayer = 6;

  return ((Int_t) (d % 30) / kNlayer);

}

//_____________________________________________________________________________
Int_t AliTRDCalibraFit::GetSector(Int_t d) const
{
  //
  // Reconstruct the sector number from the detector number
  //
  Int_t fg = 30;

  return ((Int_t) (d / fg));

}

//
//____________Fill and Init tree Gain, PRF, Vdrift and T0______________________
//
//_______________________________________________________________________________
void AliTRDCalibraFit::ResetVectorFit()
{
  //
  // Reset the VectorFits
  //

  fVectorFit.SetOwner();
  fVectorFit.Clear();
  fVectorFit2.SetOwner();
  fVectorFit2.Clear();
  
}
//
//____________Private Functions________________________________________________
//

//_____________________________________________________________________________
Double_t AliTRDCalibraFit::PH(const Double_t *x, const Double_t *par) 
{
  //
  // Function for the fit
  //

  //TF1 *fAsymmGauss = new TF1("fAsymmGauss",AsymmGauss,0,4,6);

  //PARAMETERS FOR FIT PH
  // PASAv.4
  //fAsymmGauss->SetParameter(0,0.113755);
  //fAsymmGauss->SetParameter(1,0.350706);
  //fAsymmGauss->SetParameter(2,0.0604244);
  //fAsymmGauss->SetParameter(3,7.65596);
  //fAsymmGauss->SetParameter(4,1.00124);
  //fAsymmGauss->SetParameter(5,0.870597);  // No tail cancelation

  Double_t xx = x[0];
  
  if (xx < par[1]) {
    return par[5];
  }

  Double_t dx       = 0.005;
  Double_t xs       = par[1];
  Double_t ss       = 0.0;
  Double_t paras[2] = { 0.0, 0.0 };

  while (xs < xx) {
    if ((xs >= par[1]) &&
        (xs < (par[1]+par[2]))) {
      //fAsymmGauss->SetParameter(0,par[0]);
      //fAsymmGauss->SetParameter(1,xs);
      //ss += fAsymmGauss->Eval(xx);
      paras[0] = par[0];
      paras[1] = xs;
      ss += AsymmGauss(&xx,paras);
    }
    if ((xs >= (par[1]+par[2])) && 
        (xs <  (par[1]+par[2]+par[3]))) {
      //fAsymmGauss->SetParameter(0,par[0]*par[4]);
      //fAsymmGauss->SetParameter(1,xs);
      //ss += fAsymmGauss->Eval(xx);
      paras[0] = par[0]*par[4];
      paras[1] = xs;
      ss += AsymmGauss(&xx,paras);
    }
    xs += dx;
  }
  
  return ss + par[5];

}

//_____________________________________________________________________________
Double_t AliTRDCalibraFit::AsymmGauss(const Double_t *x, const Double_t *par)
{
  //
  // Function for the fit
  //

  //par[0] = normalization
  //par[1] = mean
  //par[2] = sigma
  //norm0  = 1
  //par[3] = lambda0
  //par[4] = norm1
  //par[5] = lambda1
  
  Double_t par1save = par[1];    
  //Double_t par2save = par[2];
  Double_t par2save = 0.0604244;
  //Double_t par3save = par[3];
  Double_t par3save = 7.65596;
  //Double_t par5save = par[5];
  Double_t par5save = 0.870597;
  Double_t dx       = x[0] - par1save;

  Double_t  sigma2  = par2save*par2save;
  Double_t  sqrt2   = TMath::Sqrt(2.0);
  Double_t  exp1    = par3save * TMath::Exp(-par3save * (dx - 0.5 * par3save * sigma2))
                               * (1.0 - AliMathBase::ErfFast((par3save * sigma2 - dx) / (sqrt2 * par2save)));
  Double_t  exp2    = par5save * TMath::Exp(-par5save * (dx - 0.5 * par5save * sigma2))
                               * (1.0 - AliMathBase::ErfFast((par5save * sigma2 - dx) / (sqrt2 * par2save)));

  //return par[0]*(exp1+par[4]*exp2);
  return par[0] * (exp1 + 1.00124 * exp2);

}

//_____________________________________________________________________________
Double_t AliTRDCalibraFit::FuncLandauGaus(const Double_t *x, const Double_t *par)
{
  //
  // Sum Landau + Gaus with identical mean
  //

  Double_t valLandau = par[0] * TMath::Landau(x[0],par[1],par[2]);
  //Double_t valGaus   = par[3] * TMath::Gaus(x[0],par[4],par[5]);
  Double_t valGaus   = par[3] * TMath::Gaus(x[0],par[1],par[4]);
  Double_t val       = valLandau + valGaus;

  return val;

}

//_____________________________________________________________________________
Double_t AliTRDCalibraFit::LanGauFun(const Double_t *x, const Double_t *par) 
{
  //
  // Function for the fit
  //
  // Fit parameters:
  // par[0]=Width (scale) parameter of Landau density
  // par[1]=Most Probable (MP, location) parameter of Landau density
  // par[2]=Total area (integral -inf to inf, normalization constant)
  // par[3]=Width (sigma) of convoluted Gaussian function
  //
  // In the Landau distribution (represented by the CERNLIB approximation), 
  // the maximum is located at x=-0.22278298 with the location parameter=0.
  // This shift is corrected within this function, so that the actual
  // maximum is identical to the MP parameter.
  //  

  // Numeric constants
  Double_t invsq2pi = 0.3989422804014;   // (2 pi)^(-1/2)
  Double_t mpshift  = -0.22278298;       // Landau maximum location
  
  // Control constants
  Double_t np       = 100.0;             // Number of convolution steps
  Double_t sc       =   5.0;             // Convolution extends to +-sc Gaussian sigmas
  
  // Variables
  Double_t xx = 0.0;
  Double_t mpc = 0.0;
  Double_t fland = 0.0;
  Double_t sum = 0.0;
  Double_t xlow = 0.0;
  Double_t xupp = 0.0;
  Double_t step = 0.0;
  Double_t i = 0.0;
  
  // MP shift correction
  mpc = par[1] - mpshift * par[0]; 

  // Range of convolution integral
  xlow = x[0] - sc * par[3];
  xupp = x[0] + sc * par[3];
  
  step = (xupp - xlow) / np;

  // Convolution integral of Landau and Gaussian by sum
  for (i = 1.0; i <= np/2; i++) {

    xx    = xlow + (i-.5) * step;
    if(par[0] > 0.0) fland = TMath::Landau(xx,mpc,par[0]) / par[0];
    sum  += fland * TMath::Gaus(x[0],xx,par[3]);
    
    xx    = xupp - (i-.5) * step;
    if(par[0] > 0.0) fland = TMath::Landau(xx,mpc,par[0]) / par[0];
    sum  += fland * TMath::Gaus(x[0],xx,par[3]);

  }

  if(par[3] > 0.0) return (par[2] * step * sum * invsq2pi / par[3]);
  else return 0.0;

}
//_____________________________________________________________________________
Double_t AliTRDCalibraFit::LanGauFunEx(const Double_t *x, const Double_t *par) 
{
  //
  // Function for the fit
  //
  // Fit parameters:
  // par[0]=Width (scale) parameter of Landau density
  // par[1]=Most Probable (MP, location) parameter of Landau density
  // par[2]=Total area (integral -inf to inf, normalization constant)
  // par[3]=Width (sigma) of convoluted Gaussian function
  // par[4]=Exponential Slope Parameter
  //
  // In the Landau distribution (represented by the CERNLIB approximation), 
  // the maximum is located at x=-0.22278298 with the location parameter=0.
  // This shift is corrected within this function, so that the actual
  // maximum is identical to the MP parameter.
  //  

  // Numeric constants
  Double_t invsq2pi = 0.3989422804014;   // (2 pi)^(-1/2)
  Double_t mpshift  = -0.22278298;       // Landau maximum location
  
  // Control constants
  Double_t np       = 100.0;             // Number of convolution steps
  Double_t sc       =   5.0;             // Convolution extends to +-sc Gaussian sigmas
  
  // Variables
  Double_t xx= 0.0;
  Double_t mpc= 0.0;
  Double_t fland = 0.0;
  Double_t sum = 0.0;
  Double_t xlow= 0.0;
  Double_t xupp= 0.0;
  Double_t step= 0.0;
  Double_t i= 0.0;
  
  // MP shift correction
  mpc = par[1] - mpshift * par[0]; 

  // Range of convolution integral
  xlow = x[0] - sc * par[3];
  xupp = x[0] + sc * par[3];
  
  step = (xupp - xlow) / np;

  // Convolution integral of Landau and Gaussian by sum
  for (i = 1.0; i <= np/2; i++) {

    xx    = xlow + (i-.5) * step;
    if(par[0] > 0.0) fland = TMath::Landau(xx,mpc,par[0])*TMath::Exp(-par[4]*xx) / par[0];
    sum  += fland * TMath::Gaus(x[0],xx,par[3]);
    
    xx    = xupp - (i-.5) * step;
    if(par[0] > 0.0) fland = TMath::Landau(xx,mpc,par[0])*TMath::Exp(-par[4]*xx) / par[0];
    sum  += fland * TMath::Gaus(x[0],xx,par[3]);

  }

  if(par[3] > 0.0) return (par[2] * step * sum * invsq2pi / par[3]);
  else return 0.0;

}
//_____________________________________________________________________________
TF1 *AliTRDCalibraFit::LanGauFit(TH1 *his, const Double_t *fitrange, const Double_t *startvalues
                                      , const Double_t *parlimitslo, const Double_t *parlimitshi
                                      , Double_t *fitparams, Double_t *fiterrors
                                      , Double_t *chiSqr, Int_t *ndf) const
{
  //
  // Function for the fit
  //
  
  Int_t i;
  Char_t funname[100];
  
  TF1 *ffitold = (TF1 *) gROOT->GetListOfFunctions()->FindObject(funname);
  if (ffitold) {
    delete ffitold;
  }  

  TF1 *ffit    = new TF1(funname,LanGauFun,fitrange[0],fitrange[1],4);
  ffit->SetParameters(startvalues);
  ffit->SetParNames("Width","MP","Area","GSigma");
  
  for (i = 0; i < 4; i++) {
    ffit->SetParLimits(i,parlimitslo[i],parlimitshi[i]);
  }
  
  his->Fit(funname,"WWQRB0");                   // Fit within specified range, use ParLimits, do not plot
  
  ffit->GetParameters(fitparams);            // Obtain fit parameters
  for (i = 0; i < 4; i++) {
    fiterrors[i] = ffit->GetParError(i);     // Obtain fit parameter errors
  }
  chiSqr[0] = ffit->GetChisquare();          // Obtain chi^2
  ndf[0]    = ffit->GetNDF();                // Obtain ndf

  return (ffit);                             // Return fit function
   
}
//_____________________________________________________________________________
TF1 *AliTRDCalibraFit::LanGauFitEx(TH1 *his, const Double_t *fitrange, const Double_t *startvalues
                                      , const Double_t *parlimitslo, const Double_t *parlimitshi
                                      , Double_t *fitparams, Double_t *fiterrors
                                      , Double_t *chiSqr, Int_t *ndf) const
{
  //
  // Function for the fit
  //
  
  Int_t i;
  Char_t funname[100];
  
  TF1 *ffitold = (TF1 *) gROOT->GetListOfFunctions()->FindObject(funname);
  if (ffitold) {
    delete ffitold;
  }  

  TF1 *ffit    = new TF1(funname,LanGauFunEx,fitrange[0],fitrange[1],5);
  ffit->SetParameters(startvalues);
  ffit->SetParNames("Width","MP","Area","GSigma","Ex");
  
  for (i = 0; i < 5; i++) {
    ffit->SetParLimits(i,parlimitslo[i],parlimitshi[i]);
  }
  
  his->Fit(funname,"WWQRB0");                   // Fit within specified range, use ParLimits, do not plot
  
  ffit->GetParameters(fitparams);            // Obtain fit parameters
  for (i = 0; i < 5; i++) {
    fiterrors[i] = ffit->GetParError(i);     // Obtain fit parameter errors
  }
  chiSqr[0] = ffit->GetChisquare();          // Obtain chi^2
  ndf[0]    = ffit->GetNDF();                // Obtain ndf

  return (ffit);                             // Return fit function
   
}




 AliTRDCalibraFit.cxx:1
 AliTRDCalibraFit.cxx:2
 AliTRDCalibraFit.cxx:3
 AliTRDCalibraFit.cxx:4
 AliTRDCalibraFit.cxx:5
 AliTRDCalibraFit.cxx:6
 AliTRDCalibraFit.cxx:7
 AliTRDCalibraFit.cxx:8
 AliTRDCalibraFit.cxx:9
 AliTRDCalibraFit.cxx:10
 AliTRDCalibraFit.cxx:11
 AliTRDCalibraFit.cxx:12
 AliTRDCalibraFit.cxx:13
 AliTRDCalibraFit.cxx:14
 AliTRDCalibraFit.cxx:15
 AliTRDCalibraFit.cxx:16
 AliTRDCalibraFit.cxx:17
 AliTRDCalibraFit.cxx:18
 AliTRDCalibraFit.cxx:19
 AliTRDCalibraFit.cxx:20
 AliTRDCalibraFit.cxx:21
 AliTRDCalibraFit.cxx:22
 AliTRDCalibraFit.cxx:23
 AliTRDCalibraFit.cxx:24
 AliTRDCalibraFit.cxx:25
 AliTRDCalibraFit.cxx:26
 AliTRDCalibraFit.cxx:27
 AliTRDCalibraFit.cxx:28
 AliTRDCalibraFit.cxx:29
 AliTRDCalibraFit.cxx:30
 AliTRDCalibraFit.cxx:31
 AliTRDCalibraFit.cxx:32
 AliTRDCalibraFit.cxx:33
 AliTRDCalibraFit.cxx:34
 AliTRDCalibraFit.cxx:35
 AliTRDCalibraFit.cxx:36
 AliTRDCalibraFit.cxx:37
 AliTRDCalibraFit.cxx:38
 AliTRDCalibraFit.cxx:39
 AliTRDCalibraFit.cxx:40
 AliTRDCalibraFit.cxx:41
 AliTRDCalibraFit.cxx:42
 AliTRDCalibraFit.cxx:43
 AliTRDCalibraFit.cxx:44
 AliTRDCalibraFit.cxx:45
 AliTRDCalibraFit.cxx:46
 AliTRDCalibraFit.cxx:47
 AliTRDCalibraFit.cxx:48
 AliTRDCalibraFit.cxx:49
 AliTRDCalibraFit.cxx:50
 AliTRDCalibraFit.cxx:51
 AliTRDCalibraFit.cxx:52
 AliTRDCalibraFit.cxx:53
 AliTRDCalibraFit.cxx:54
 AliTRDCalibraFit.cxx:55
 AliTRDCalibraFit.cxx:56
 AliTRDCalibraFit.cxx:57
 AliTRDCalibraFit.cxx:58
 AliTRDCalibraFit.cxx:59
 AliTRDCalibraFit.cxx:60
 AliTRDCalibraFit.cxx:61
 AliTRDCalibraFit.cxx:62
 AliTRDCalibraFit.cxx:63
 AliTRDCalibraFit.cxx:64
 AliTRDCalibraFit.cxx:65
 AliTRDCalibraFit.cxx:66
 AliTRDCalibraFit.cxx:67
 AliTRDCalibraFit.cxx:68
 AliTRDCalibraFit.cxx:69
 AliTRDCalibraFit.cxx:70
 AliTRDCalibraFit.cxx:71
 AliTRDCalibraFit.cxx:72
 AliTRDCalibraFit.cxx:73
 AliTRDCalibraFit.cxx:74
 AliTRDCalibraFit.cxx:75
 AliTRDCalibraFit.cxx:76
 AliTRDCalibraFit.cxx:77
 AliTRDCalibraFit.cxx:78
 AliTRDCalibraFit.cxx:79
 AliTRDCalibraFit.cxx:80
 AliTRDCalibraFit.cxx:81
 AliTRDCalibraFit.cxx:82
 AliTRDCalibraFit.cxx:83
 AliTRDCalibraFit.cxx:84
 AliTRDCalibraFit.cxx:85
 AliTRDCalibraFit.cxx:86
 AliTRDCalibraFit.cxx:87
 AliTRDCalibraFit.cxx:88
 AliTRDCalibraFit.cxx:89
 AliTRDCalibraFit.cxx:90
 AliTRDCalibraFit.cxx:91
 AliTRDCalibraFit.cxx:92
 AliTRDCalibraFit.cxx:93
 AliTRDCalibraFit.cxx:94
 AliTRDCalibraFit.cxx:95
 AliTRDCalibraFit.cxx:96
 AliTRDCalibraFit.cxx:97
 AliTRDCalibraFit.cxx:98
 AliTRDCalibraFit.cxx:99
 AliTRDCalibraFit.cxx:100
 AliTRDCalibraFit.cxx:101
 AliTRDCalibraFit.cxx:102
 AliTRDCalibraFit.cxx:103
 AliTRDCalibraFit.cxx:104
 AliTRDCalibraFit.cxx:105
 AliTRDCalibraFit.cxx:106
 AliTRDCalibraFit.cxx:107
 AliTRDCalibraFit.cxx:108
 AliTRDCalibraFit.cxx:109
 AliTRDCalibraFit.cxx:110
 AliTRDCalibraFit.cxx:111
 AliTRDCalibraFit.cxx:112
 AliTRDCalibraFit.cxx:113
 AliTRDCalibraFit.cxx:114
 AliTRDCalibraFit.cxx:115
 AliTRDCalibraFit.cxx:116
 AliTRDCalibraFit.cxx:117
 AliTRDCalibraFit.cxx:118
 AliTRDCalibraFit.cxx:119
 AliTRDCalibraFit.cxx:120
 AliTRDCalibraFit.cxx:121
 AliTRDCalibraFit.cxx:122
 AliTRDCalibraFit.cxx:123
 AliTRDCalibraFit.cxx:124
 AliTRDCalibraFit.cxx:125
 AliTRDCalibraFit.cxx:126
 AliTRDCalibraFit.cxx:127
 AliTRDCalibraFit.cxx:128
 AliTRDCalibraFit.cxx:129
 AliTRDCalibraFit.cxx:130
 AliTRDCalibraFit.cxx:131
 AliTRDCalibraFit.cxx:132
 AliTRDCalibraFit.cxx:133
 AliTRDCalibraFit.cxx:134
 AliTRDCalibraFit.cxx:135
 AliTRDCalibraFit.cxx:136
 AliTRDCalibraFit.cxx:137
 AliTRDCalibraFit.cxx:138
 AliTRDCalibraFit.cxx:139
 AliTRDCalibraFit.cxx:140
 AliTRDCalibraFit.cxx:141
 AliTRDCalibraFit.cxx:142
 AliTRDCalibraFit.cxx:143
 AliTRDCalibraFit.cxx:144
 AliTRDCalibraFit.cxx:145
 AliTRDCalibraFit.cxx:146
 AliTRDCalibraFit.cxx:147
 AliTRDCalibraFit.cxx:148
 AliTRDCalibraFit.cxx:149
 AliTRDCalibraFit.cxx:150
 AliTRDCalibraFit.cxx:151
 AliTRDCalibraFit.cxx:152
 AliTRDCalibraFit.cxx:153
 AliTRDCalibraFit.cxx:154
 AliTRDCalibraFit.cxx:155
 AliTRDCalibraFit.cxx:156
 AliTRDCalibraFit.cxx:157
 AliTRDCalibraFit.cxx:158
 AliTRDCalibraFit.cxx:159
 AliTRDCalibraFit.cxx:160
 AliTRDCalibraFit.cxx:161
 AliTRDCalibraFit.cxx:162
 AliTRDCalibraFit.cxx:163
 AliTRDCalibraFit.cxx:164
 AliTRDCalibraFit.cxx:165
 AliTRDCalibraFit.cxx:166
 AliTRDCalibraFit.cxx:167
 AliTRDCalibraFit.cxx:168
 AliTRDCalibraFit.cxx:169
 AliTRDCalibraFit.cxx:170
 AliTRDCalibraFit.cxx:171
 AliTRDCalibraFit.cxx:172
 AliTRDCalibraFit.cxx:173
 AliTRDCalibraFit.cxx:174
 AliTRDCalibraFit.cxx:175
 AliTRDCalibraFit.cxx:176
 AliTRDCalibraFit.cxx:177
 AliTRDCalibraFit.cxx:178
 AliTRDCalibraFit.cxx:179
 AliTRDCalibraFit.cxx:180
 AliTRDCalibraFit.cxx:181
 AliTRDCalibraFit.cxx:182
 AliTRDCalibraFit.cxx:183
 AliTRDCalibraFit.cxx:184
 AliTRDCalibraFit.cxx:185
 AliTRDCalibraFit.cxx:186
 AliTRDCalibraFit.cxx:187
 AliTRDCalibraFit.cxx:188
 AliTRDCalibraFit.cxx:189
 AliTRDCalibraFit.cxx:190
 AliTRDCalibraFit.cxx:191
 AliTRDCalibraFit.cxx:192
 AliTRDCalibraFit.cxx:193
 AliTRDCalibraFit.cxx:194
 AliTRDCalibraFit.cxx:195
 AliTRDCalibraFit.cxx:196
 AliTRDCalibraFit.cxx:197
 AliTRDCalibraFit.cxx:198
 AliTRDCalibraFit.cxx:199
 AliTRDCalibraFit.cxx:200
 AliTRDCalibraFit.cxx:201
 AliTRDCalibraFit.cxx:202
 AliTRDCalibraFit.cxx:203
 AliTRDCalibraFit.cxx:204
 AliTRDCalibraFit.cxx:205
 AliTRDCalibraFit.cxx:206
 AliTRDCalibraFit.cxx:207
 AliTRDCalibraFit.cxx:208
 AliTRDCalibraFit.cxx:209
 AliTRDCalibraFit.cxx:210
 AliTRDCalibraFit.cxx:211
 AliTRDCalibraFit.cxx:212
 AliTRDCalibraFit.cxx:213
 AliTRDCalibraFit.cxx:214
 AliTRDCalibraFit.cxx:215
 AliTRDCalibraFit.cxx:216
 AliTRDCalibraFit.cxx:217
 AliTRDCalibraFit.cxx:218
 AliTRDCalibraFit.cxx:219
 AliTRDCalibraFit.cxx:220
 AliTRDCalibraFit.cxx:221
 AliTRDCalibraFit.cxx:222
 AliTRDCalibraFit.cxx:223
 AliTRDCalibraFit.cxx:224
 AliTRDCalibraFit.cxx:225
 AliTRDCalibraFit.cxx:226
 AliTRDCalibraFit.cxx:227
 AliTRDCalibraFit.cxx:228
 AliTRDCalibraFit.cxx:229
 AliTRDCalibraFit.cxx:230
 AliTRDCalibraFit.cxx:231
 AliTRDCalibraFit.cxx:232
 AliTRDCalibraFit.cxx:233
 AliTRDCalibraFit.cxx:234
 AliTRDCalibraFit.cxx:235
 AliTRDCalibraFit.cxx:236
 AliTRDCalibraFit.cxx:237
 AliTRDCalibraFit.cxx:238
 AliTRDCalibraFit.cxx:239
 AliTRDCalibraFit.cxx:240
 AliTRDCalibraFit.cxx:241
 AliTRDCalibraFit.cxx:242
 AliTRDCalibraFit.cxx:243
 AliTRDCalibraFit.cxx:244
 AliTRDCalibraFit.cxx:245
 AliTRDCalibraFit.cxx:246
 AliTRDCalibraFit.cxx:247
 AliTRDCalibraFit.cxx:248
 AliTRDCalibraFit.cxx:249
 AliTRDCalibraFit.cxx:250
 AliTRDCalibraFit.cxx:251
 AliTRDCalibraFit.cxx:252
 AliTRDCalibraFit.cxx:253
 AliTRDCalibraFit.cxx:254
 AliTRDCalibraFit.cxx:255
 AliTRDCalibraFit.cxx:256
 AliTRDCalibraFit.cxx:257
 AliTRDCalibraFit.cxx:258
 AliTRDCalibraFit.cxx:259
 AliTRDCalibraFit.cxx:260
 AliTRDCalibraFit.cxx:261
 AliTRDCalibraFit.cxx:262
 AliTRDCalibraFit.cxx:263
 AliTRDCalibraFit.cxx:264
 AliTRDCalibraFit.cxx:265
 AliTRDCalibraFit.cxx:266
 AliTRDCalibraFit.cxx:267
 AliTRDCalibraFit.cxx:268
 AliTRDCalibraFit.cxx:269
 AliTRDCalibraFit.cxx:270
 AliTRDCalibraFit.cxx:271
 AliTRDCalibraFit.cxx:272
 AliTRDCalibraFit.cxx:273
 AliTRDCalibraFit.cxx:274
 AliTRDCalibraFit.cxx:275
 AliTRDCalibraFit.cxx:276
 AliTRDCalibraFit.cxx:277
 AliTRDCalibraFit.cxx:278
 AliTRDCalibraFit.cxx:279
 AliTRDCalibraFit.cxx:280
 AliTRDCalibraFit.cxx:281
 AliTRDCalibraFit.cxx:282
 AliTRDCalibraFit.cxx:283
 AliTRDCalibraFit.cxx:284
 AliTRDCalibraFit.cxx:285
 AliTRDCalibraFit.cxx:286
 AliTRDCalibraFit.cxx:287
 AliTRDCalibraFit.cxx:288
 AliTRDCalibraFit.cxx:289
 AliTRDCalibraFit.cxx:290
 AliTRDCalibraFit.cxx:291
 AliTRDCalibraFit.cxx:292
 AliTRDCalibraFit.cxx:293
 AliTRDCalibraFit.cxx:294
 AliTRDCalibraFit.cxx:295
 AliTRDCalibraFit.cxx:296
 AliTRDCalibraFit.cxx:297
 AliTRDCalibraFit.cxx:298
 AliTRDCalibraFit.cxx:299
 AliTRDCalibraFit.cxx:300
 AliTRDCalibraFit.cxx:301
 AliTRDCalibraFit.cxx:302
 AliTRDCalibraFit.cxx:303
 AliTRDCalibraFit.cxx:304
 AliTRDCalibraFit.cxx:305
 AliTRDCalibraFit.cxx:306
 AliTRDCalibraFit.cxx:307
 AliTRDCalibraFit.cxx:308
 AliTRDCalibraFit.cxx:309
 AliTRDCalibraFit.cxx:310
 AliTRDCalibraFit.cxx:311
 AliTRDCalibraFit.cxx:312
 AliTRDCalibraFit.cxx:313
 AliTRDCalibraFit.cxx:314
 AliTRDCalibraFit.cxx:315
 AliTRDCalibraFit.cxx:316
 AliTRDCalibraFit.cxx:317
 AliTRDCalibraFit.cxx:318
 AliTRDCalibraFit.cxx:319
 AliTRDCalibraFit.cxx:320
 AliTRDCalibraFit.cxx:321
 AliTRDCalibraFit.cxx:322
 AliTRDCalibraFit.cxx:323
 AliTRDCalibraFit.cxx:324
 AliTRDCalibraFit.cxx:325
 AliTRDCalibraFit.cxx:326
 AliTRDCalibraFit.cxx:327
 AliTRDCalibraFit.cxx:328
 AliTRDCalibraFit.cxx:329
 AliTRDCalibraFit.cxx:330
 AliTRDCalibraFit.cxx:331
 AliTRDCalibraFit.cxx:332
 AliTRDCalibraFit.cxx:333
 AliTRDCalibraFit.cxx:334
 AliTRDCalibraFit.cxx:335
 AliTRDCalibraFit.cxx:336
 AliTRDCalibraFit.cxx:337
 AliTRDCalibraFit.cxx:338
 AliTRDCalibraFit.cxx:339
 AliTRDCalibraFit.cxx:340
 AliTRDCalibraFit.cxx:341
 AliTRDCalibraFit.cxx:342
 AliTRDCalibraFit.cxx:343
 AliTRDCalibraFit.cxx:344
 AliTRDCalibraFit.cxx:345
 AliTRDCalibraFit.cxx:346
 AliTRDCalibraFit.cxx:347
 AliTRDCalibraFit.cxx:348
 AliTRDCalibraFit.cxx:349
 AliTRDCalibraFit.cxx:350
 AliTRDCalibraFit.cxx:351
 AliTRDCalibraFit.cxx:352
 AliTRDCalibraFit.cxx:353
 AliTRDCalibraFit.cxx:354
 AliTRDCalibraFit.cxx:355
 AliTRDCalibraFit.cxx:356
 AliTRDCalibraFit.cxx:357
 AliTRDCalibraFit.cxx:358
 AliTRDCalibraFit.cxx:359
 AliTRDCalibraFit.cxx:360
 AliTRDCalibraFit.cxx:361
 AliTRDCalibraFit.cxx:362
 AliTRDCalibraFit.cxx:363
 AliTRDCalibraFit.cxx:364
 AliTRDCalibraFit.cxx:365
 AliTRDCalibraFit.cxx:366
 AliTRDCalibraFit.cxx:367
 AliTRDCalibraFit.cxx:368
 AliTRDCalibraFit.cxx:369
 AliTRDCalibraFit.cxx:370
 AliTRDCalibraFit.cxx:371
 AliTRDCalibraFit.cxx:372
 AliTRDCalibraFit.cxx:373
 AliTRDCalibraFit.cxx:374
 AliTRDCalibraFit.cxx:375
 AliTRDCalibraFit.cxx:376
 AliTRDCalibraFit.cxx:377
 AliTRDCalibraFit.cxx:378
 AliTRDCalibraFit.cxx:379
 AliTRDCalibraFit.cxx:380
 AliTRDCalibraFit.cxx:381
 AliTRDCalibraFit.cxx:382
 AliTRDCalibraFit.cxx:383
 AliTRDCalibraFit.cxx:384
 AliTRDCalibraFit.cxx:385
 AliTRDCalibraFit.cxx:386
 AliTRDCalibraFit.cxx:387
 AliTRDCalibraFit.cxx:388
 AliTRDCalibraFit.cxx:389
 AliTRDCalibraFit.cxx:390
 AliTRDCalibraFit.cxx:391
 AliTRDCalibraFit.cxx:392
 AliTRDCalibraFit.cxx:393
 AliTRDCalibraFit.cxx:394
 AliTRDCalibraFit.cxx:395
 AliTRDCalibraFit.cxx:396
 AliTRDCalibraFit.cxx:397
 AliTRDCalibraFit.cxx:398
 AliTRDCalibraFit.cxx:399
 AliTRDCalibraFit.cxx:400
 AliTRDCalibraFit.cxx:401
 AliTRDCalibraFit.cxx:402
 AliTRDCalibraFit.cxx:403
 AliTRDCalibraFit.cxx:404
 AliTRDCalibraFit.cxx:405
 AliTRDCalibraFit.cxx:406
 AliTRDCalibraFit.cxx:407
 AliTRDCalibraFit.cxx:408
 AliTRDCalibraFit.cxx:409
 AliTRDCalibraFit.cxx:410
 AliTRDCalibraFit.cxx:411
 AliTRDCalibraFit.cxx:412
 AliTRDCalibraFit.cxx:413
 AliTRDCalibraFit.cxx:414
 AliTRDCalibraFit.cxx:415
 AliTRDCalibraFit.cxx:416
 AliTRDCalibraFit.cxx:417
 AliTRDCalibraFit.cxx:418
 AliTRDCalibraFit.cxx:419
 AliTRDCalibraFit.cxx:420
 AliTRDCalibraFit.cxx:421
 AliTRDCalibraFit.cxx:422
 AliTRDCalibraFit.cxx:423
 AliTRDCalibraFit.cxx:424
 AliTRDCalibraFit.cxx:425
 AliTRDCalibraFit.cxx:426
 AliTRDCalibraFit.cxx:427
 AliTRDCalibraFit.cxx:428
 AliTRDCalibraFit.cxx:429
 AliTRDCalibraFit.cxx:430
 AliTRDCalibraFit.cxx:431
 AliTRDCalibraFit.cxx:432
 AliTRDCalibraFit.cxx:433
 AliTRDCalibraFit.cxx:434
 AliTRDCalibraFit.cxx:435
 AliTRDCalibraFit.cxx:436
 AliTRDCalibraFit.cxx:437
 AliTRDCalibraFit.cxx:438
 AliTRDCalibraFit.cxx:439
 AliTRDCalibraFit.cxx:440
 AliTRDCalibraFit.cxx:441
 AliTRDCalibraFit.cxx:442
 AliTRDCalibraFit.cxx:443
 AliTRDCalibraFit.cxx:444
 AliTRDCalibraFit.cxx:445
 AliTRDCalibraFit.cxx:446
 AliTRDCalibraFit.cxx:447
 AliTRDCalibraFit.cxx:448
 AliTRDCalibraFit.cxx:449
 AliTRDCalibraFit.cxx:450
 AliTRDCalibraFit.cxx:451
 AliTRDCalibraFit.cxx:452
 AliTRDCalibraFit.cxx:453
 AliTRDCalibraFit.cxx:454
 AliTRDCalibraFit.cxx:455
 AliTRDCalibraFit.cxx:456
 AliTRDCalibraFit.cxx:457
 AliTRDCalibraFit.cxx:458
 AliTRDCalibraFit.cxx:459
 AliTRDCalibraFit.cxx:460
 AliTRDCalibraFit.cxx:461
 AliTRDCalibraFit.cxx:462
 AliTRDCalibraFit.cxx:463
 AliTRDCalibraFit.cxx:464
 AliTRDCalibraFit.cxx:465
 AliTRDCalibraFit.cxx:466
 AliTRDCalibraFit.cxx:467
 AliTRDCalibraFit.cxx:468
 AliTRDCalibraFit.cxx:469
 AliTRDCalibraFit.cxx:470
 AliTRDCalibraFit.cxx:471
 AliTRDCalibraFit.cxx:472
 AliTRDCalibraFit.cxx:473
 AliTRDCalibraFit.cxx:474
 AliTRDCalibraFit.cxx:475
 AliTRDCalibraFit.cxx:476
 AliTRDCalibraFit.cxx:477
 AliTRDCalibraFit.cxx:478
 AliTRDCalibraFit.cxx:479
 AliTRDCalibraFit.cxx:480
 AliTRDCalibraFit.cxx:481
 AliTRDCalibraFit.cxx:482
 AliTRDCalibraFit.cxx:483
 AliTRDCalibraFit.cxx:484
 AliTRDCalibraFit.cxx:485
 AliTRDCalibraFit.cxx:486
 AliTRDCalibraFit.cxx:487
 AliTRDCalibraFit.cxx:488
 AliTRDCalibraFit.cxx:489
 AliTRDCalibraFit.cxx:490
 AliTRDCalibraFit.cxx:491
 AliTRDCalibraFit.cxx:492
 AliTRDCalibraFit.cxx:493
 AliTRDCalibraFit.cxx:494
 AliTRDCalibraFit.cxx:495
 AliTRDCalibraFit.cxx:496
 AliTRDCalibraFit.cxx:497
 AliTRDCalibraFit.cxx:498
 AliTRDCalibraFit.cxx:499
 AliTRDCalibraFit.cxx:500
 AliTRDCalibraFit.cxx:501
 AliTRDCalibraFit.cxx:502
 AliTRDCalibraFit.cxx:503
 AliTRDCalibraFit.cxx:504
 AliTRDCalibraFit.cxx:505
 AliTRDCalibraFit.cxx:506
 AliTRDCalibraFit.cxx:507
 AliTRDCalibraFit.cxx:508
 AliTRDCalibraFit.cxx:509
 AliTRDCalibraFit.cxx:510
 AliTRDCalibraFit.cxx:511
 AliTRDCalibraFit.cxx:512
 AliTRDCalibraFit.cxx:513
 AliTRDCalibraFit.cxx:514
 AliTRDCalibraFit.cxx:515
 AliTRDCalibraFit.cxx:516
 AliTRDCalibraFit.cxx:517
 AliTRDCalibraFit.cxx:518
 AliTRDCalibraFit.cxx:519
 AliTRDCalibraFit.cxx:520
 AliTRDCalibraFit.cxx:521
 AliTRDCalibraFit.cxx:522
 AliTRDCalibraFit.cxx:523
 AliTRDCalibraFit.cxx:524
 AliTRDCalibraFit.cxx:525
 AliTRDCalibraFit.cxx:526
 AliTRDCalibraFit.cxx:527
 AliTRDCalibraFit.cxx:528
 AliTRDCalibraFit.cxx:529
 AliTRDCalibraFit.cxx:530
 AliTRDCalibraFit.cxx:531
 AliTRDCalibraFit.cxx:532
 AliTRDCalibraFit.cxx:533
 AliTRDCalibraFit.cxx:534
 AliTRDCalibraFit.cxx:535
 AliTRDCalibraFit.cxx:536
 AliTRDCalibraFit.cxx:537
 AliTRDCalibraFit.cxx:538
 AliTRDCalibraFit.cxx:539
 AliTRDCalibraFit.cxx:540
 AliTRDCalibraFit.cxx:541
 AliTRDCalibraFit.cxx:542
 AliTRDCalibraFit.cxx:543
 AliTRDCalibraFit.cxx:544
 AliTRDCalibraFit.cxx:545
 AliTRDCalibraFit.cxx:546
 AliTRDCalibraFit.cxx:547
 AliTRDCalibraFit.cxx:548
 AliTRDCalibraFit.cxx:549
 AliTRDCalibraFit.cxx:550
 AliTRDCalibraFit.cxx:551
 AliTRDCalibraFit.cxx:552
 AliTRDCalibraFit.cxx:553
 AliTRDCalibraFit.cxx:554
 AliTRDCalibraFit.cxx:555
 AliTRDCalibraFit.cxx:556
 AliTRDCalibraFit.cxx:557
 AliTRDCalibraFit.cxx:558
 AliTRDCalibraFit.cxx:559
 AliTRDCalibraFit.cxx:560
 AliTRDCalibraFit.cxx:561
 AliTRDCalibraFit.cxx:562
 AliTRDCalibraFit.cxx:563
 AliTRDCalibraFit.cxx:564
 AliTRDCalibraFit.cxx:565
 AliTRDCalibraFit.cxx:566
 AliTRDCalibraFit.cxx:567
 AliTRDCalibraFit.cxx:568
 AliTRDCalibraFit.cxx:569
 AliTRDCalibraFit.cxx:570
 AliTRDCalibraFit.cxx:571
 AliTRDCalibraFit.cxx:572
 AliTRDCalibraFit.cxx:573
 AliTRDCalibraFit.cxx:574
 AliTRDCalibraFit.cxx:575
 AliTRDCalibraFit.cxx:576
 AliTRDCalibraFit.cxx:577
 AliTRDCalibraFit.cxx:578
 AliTRDCalibraFit.cxx:579
 AliTRDCalibraFit.cxx:580
 AliTRDCalibraFit.cxx:581
 AliTRDCalibraFit.cxx:582
 AliTRDCalibraFit.cxx:583
 AliTRDCalibraFit.cxx:584
 AliTRDCalibraFit.cxx:585
 AliTRDCalibraFit.cxx:586
 AliTRDCalibraFit.cxx:587
 AliTRDCalibraFit.cxx:588
 AliTRDCalibraFit.cxx:589
 AliTRDCalibraFit.cxx:590
 AliTRDCalibraFit.cxx:591
 AliTRDCalibraFit.cxx:592
 AliTRDCalibraFit.cxx:593
 AliTRDCalibraFit.cxx:594
 AliTRDCalibraFit.cxx:595
 AliTRDCalibraFit.cxx:596
 AliTRDCalibraFit.cxx:597
 AliTRDCalibraFit.cxx:598
 AliTRDCalibraFit.cxx:599
 AliTRDCalibraFit.cxx:600
 AliTRDCalibraFit.cxx:601
 AliTRDCalibraFit.cxx:602
 AliTRDCalibraFit.cxx:603
 AliTRDCalibraFit.cxx:604
 AliTRDCalibraFit.cxx:605
 AliTRDCalibraFit.cxx:606
 AliTRDCalibraFit.cxx:607
 AliTRDCalibraFit.cxx:608
 AliTRDCalibraFit.cxx:609
 AliTRDCalibraFit.cxx:610
 AliTRDCalibraFit.cxx:611
 AliTRDCalibraFit.cxx:612
 AliTRDCalibraFit.cxx:613
 AliTRDCalibraFit.cxx:614
 AliTRDCalibraFit.cxx:615
 AliTRDCalibraFit.cxx:616
 AliTRDCalibraFit.cxx:617
 AliTRDCalibraFit.cxx:618
 AliTRDCalibraFit.cxx:619
 AliTRDCalibraFit.cxx:620
 AliTRDCalibraFit.cxx:621
 AliTRDCalibraFit.cxx:622
 AliTRDCalibraFit.cxx:623
 AliTRDCalibraFit.cxx:624
 AliTRDCalibraFit.cxx:625
 AliTRDCalibraFit.cxx:626
 AliTRDCalibraFit.cxx:627
 AliTRDCalibraFit.cxx:628
 AliTRDCalibraFit.cxx:629
 AliTRDCalibraFit.cxx:630
 AliTRDCalibraFit.cxx:631
 AliTRDCalibraFit.cxx:632
 AliTRDCalibraFit.cxx:633
 AliTRDCalibraFit.cxx:634
 AliTRDCalibraFit.cxx:635
 AliTRDCalibraFit.cxx:636
 AliTRDCalibraFit.cxx:637
 AliTRDCalibraFit.cxx:638
 AliTRDCalibraFit.cxx:639
 AliTRDCalibraFit.cxx:640
 AliTRDCalibraFit.cxx:641
 AliTRDCalibraFit.cxx:642
 AliTRDCalibraFit.cxx:643
 AliTRDCalibraFit.cxx:644
 AliTRDCalibraFit.cxx:645
 AliTRDCalibraFit.cxx:646
 AliTRDCalibraFit.cxx:647
 AliTRDCalibraFit.cxx:648
 AliTRDCalibraFit.cxx:649
 AliTRDCalibraFit.cxx:650
 AliTRDCalibraFit.cxx:651
 AliTRDCalibraFit.cxx:652
 AliTRDCalibraFit.cxx:653
 AliTRDCalibraFit.cxx:654
 AliTRDCalibraFit.cxx:655
 AliTRDCalibraFit.cxx:656
 AliTRDCalibraFit.cxx:657
 AliTRDCalibraFit.cxx:658
 AliTRDCalibraFit.cxx:659
 AliTRDCalibraFit.cxx:660
 AliTRDCalibraFit.cxx:661
 AliTRDCalibraFit.cxx:662
 AliTRDCalibraFit.cxx:663
 AliTRDCalibraFit.cxx:664
 AliTRDCalibraFit.cxx:665
 AliTRDCalibraFit.cxx:666
 AliTRDCalibraFit.cxx:667
 AliTRDCalibraFit.cxx:668
 AliTRDCalibraFit.cxx:669
 AliTRDCalibraFit.cxx:670
 AliTRDCalibraFit.cxx:671
 AliTRDCalibraFit.cxx:672
 AliTRDCalibraFit.cxx:673
 AliTRDCalibraFit.cxx:674
 AliTRDCalibraFit.cxx:675
 AliTRDCalibraFit.cxx:676
 AliTRDCalibraFit.cxx:677
 AliTRDCalibraFit.cxx:678
 AliTRDCalibraFit.cxx:679
 AliTRDCalibraFit.cxx:680
 AliTRDCalibraFit.cxx:681
 AliTRDCalibraFit.cxx:682
 AliTRDCalibraFit.cxx:683
 AliTRDCalibraFit.cxx:684
 AliTRDCalibraFit.cxx:685
 AliTRDCalibraFit.cxx:686
 AliTRDCalibraFit.cxx:687
 AliTRDCalibraFit.cxx:688
 AliTRDCalibraFit.cxx:689
 AliTRDCalibraFit.cxx:690
 AliTRDCalibraFit.cxx:691
 AliTRDCalibraFit.cxx:692
 AliTRDCalibraFit.cxx:693
 AliTRDCalibraFit.cxx:694
 AliTRDCalibraFit.cxx:695
 AliTRDCalibraFit.cxx:696
 AliTRDCalibraFit.cxx:697
 AliTRDCalibraFit.cxx:698
 AliTRDCalibraFit.cxx:699
 AliTRDCalibraFit.cxx:700
 AliTRDCalibraFit.cxx:701
 AliTRDCalibraFit.cxx:702
 AliTRDCalibraFit.cxx:703
 AliTRDCalibraFit.cxx:704
 AliTRDCalibraFit.cxx:705
 AliTRDCalibraFit.cxx:706
 AliTRDCalibraFit.cxx:707
 AliTRDCalibraFit.cxx:708
 AliTRDCalibraFit.cxx:709
 AliTRDCalibraFit.cxx:710
 AliTRDCalibraFit.cxx:711
 AliTRDCalibraFit.cxx:712
 AliTRDCalibraFit.cxx:713
 AliTRDCalibraFit.cxx:714
 AliTRDCalibraFit.cxx:715
 AliTRDCalibraFit.cxx:716
 AliTRDCalibraFit.cxx:717
 AliTRDCalibraFit.cxx:718
 AliTRDCalibraFit.cxx:719
 AliTRDCalibraFit.cxx:720
 AliTRDCalibraFit.cxx:721
 AliTRDCalibraFit.cxx:722
 AliTRDCalibraFit.cxx:723
 AliTRDCalibraFit.cxx:724
 AliTRDCalibraFit.cxx:725
 AliTRDCalibraFit.cxx:726
 AliTRDCalibraFit.cxx:727
 AliTRDCalibraFit.cxx:728
 AliTRDCalibraFit.cxx:729
 AliTRDCalibraFit.cxx:730
 AliTRDCalibraFit.cxx:731
 AliTRDCalibraFit.cxx:732
 AliTRDCalibraFit.cxx:733
 AliTRDCalibraFit.cxx:734
 AliTRDCalibraFit.cxx:735
 AliTRDCalibraFit.cxx:736
 AliTRDCalibraFit.cxx:737
 AliTRDCalibraFit.cxx:738
 AliTRDCalibraFit.cxx:739
 AliTRDCalibraFit.cxx:740
 AliTRDCalibraFit.cxx:741
 AliTRDCalibraFit.cxx:742
 AliTRDCalibraFit.cxx:743
 AliTRDCalibraFit.cxx:744
 AliTRDCalibraFit.cxx:745
 AliTRDCalibraFit.cxx:746
 AliTRDCalibraFit.cxx:747
 AliTRDCalibraFit.cxx:748
 AliTRDCalibraFit.cxx:749
 AliTRDCalibraFit.cxx:750
 AliTRDCalibraFit.cxx:751
 AliTRDCalibraFit.cxx:752
 AliTRDCalibraFit.cxx:753
 AliTRDCalibraFit.cxx:754
 AliTRDCalibraFit.cxx:755
 AliTRDCalibraFit.cxx:756
 AliTRDCalibraFit.cxx:757
 AliTRDCalibraFit.cxx:758
 AliTRDCalibraFit.cxx:759
 AliTRDCalibraFit.cxx:760
 AliTRDCalibraFit.cxx:761
 AliTRDCalibraFit.cxx:762
 AliTRDCalibraFit.cxx:763
 AliTRDCalibraFit.cxx:764
 AliTRDCalibraFit.cxx:765
 AliTRDCalibraFit.cxx:766
 AliTRDCalibraFit.cxx:767
 AliTRDCalibraFit.cxx:768
 AliTRDCalibraFit.cxx:769
 AliTRDCalibraFit.cxx:770
 AliTRDCalibraFit.cxx:771
 AliTRDCalibraFit.cxx:772
 AliTRDCalibraFit.cxx:773
 AliTRDCalibraFit.cxx:774
 AliTRDCalibraFit.cxx:775
 AliTRDCalibraFit.cxx:776
 AliTRDCalibraFit.cxx:777
 AliTRDCalibraFit.cxx:778
 AliTRDCalibraFit.cxx:779
 AliTRDCalibraFit.cxx:780
 AliTRDCalibraFit.cxx:781
 AliTRDCalibraFit.cxx:782
 AliTRDCalibraFit.cxx:783
 AliTRDCalibraFit.cxx:784
 AliTRDCalibraFit.cxx:785
 AliTRDCalibraFit.cxx:786
 AliTRDCalibraFit.cxx:787
 AliTRDCalibraFit.cxx:788
 AliTRDCalibraFit.cxx:789
 AliTRDCalibraFit.cxx:790
 AliTRDCalibraFit.cxx:791
 AliTRDCalibraFit.cxx:792
 AliTRDCalibraFit.cxx:793
 AliTRDCalibraFit.cxx:794
 AliTRDCalibraFit.cxx:795
 AliTRDCalibraFit.cxx:796
 AliTRDCalibraFit.cxx:797
 AliTRDCalibraFit.cxx:798
 AliTRDCalibraFit.cxx:799
 AliTRDCalibraFit.cxx:800
 AliTRDCalibraFit.cxx:801
 AliTRDCalibraFit.cxx:802
 AliTRDCalibraFit.cxx:803
 AliTRDCalibraFit.cxx:804
 AliTRDCalibraFit.cxx:805
 AliTRDCalibraFit.cxx:806
 AliTRDCalibraFit.cxx:807
 AliTRDCalibraFit.cxx:808
 AliTRDCalibraFit.cxx:809
 AliTRDCalibraFit.cxx:810
 AliTRDCalibraFit.cxx:811
 AliTRDCalibraFit.cxx:812
 AliTRDCalibraFit.cxx:813
 AliTRDCalibraFit.cxx:814
 AliTRDCalibraFit.cxx:815
 AliTRDCalibraFit.cxx:816
 AliTRDCalibraFit.cxx:817
 AliTRDCalibraFit.cxx:818
 AliTRDCalibraFit.cxx:819
 AliTRDCalibraFit.cxx:820
 AliTRDCalibraFit.cxx:821
 AliTRDCalibraFit.cxx:822
 AliTRDCalibraFit.cxx:823
 AliTRDCalibraFit.cxx:824
 AliTRDCalibraFit.cxx:825
 AliTRDCalibraFit.cxx:826
 AliTRDCalibraFit.cxx:827
 AliTRDCalibraFit.cxx:828
 AliTRDCalibraFit.cxx:829
 AliTRDCalibraFit.cxx:830
 AliTRDCalibraFit.cxx:831
 AliTRDCalibraFit.cxx:832
 AliTRDCalibraFit.cxx:833
 AliTRDCalibraFit.cxx:834
 AliTRDCalibraFit.cxx:835
 AliTRDCalibraFit.cxx:836
 AliTRDCalibraFit.cxx:837
 AliTRDCalibraFit.cxx:838
 AliTRDCalibraFit.cxx:839
 AliTRDCalibraFit.cxx:840
 AliTRDCalibraFit.cxx:841
 AliTRDCalibraFit.cxx:842
 AliTRDCalibraFit.cxx:843
 AliTRDCalibraFit.cxx:844
 AliTRDCalibraFit.cxx:845
 AliTRDCalibraFit.cxx:846
 AliTRDCalibraFit.cxx:847
 AliTRDCalibraFit.cxx:848
 AliTRDCalibraFit.cxx:849
 AliTRDCalibraFit.cxx:850
 AliTRDCalibraFit.cxx:851
 AliTRDCalibraFit.cxx:852
 AliTRDCalibraFit.cxx:853
 AliTRDCalibraFit.cxx:854
 AliTRDCalibraFit.cxx:855
 AliTRDCalibraFit.cxx:856
 AliTRDCalibraFit.cxx:857
 AliTRDCalibraFit.cxx:858
 AliTRDCalibraFit.cxx:859
 AliTRDCalibraFit.cxx:860
 AliTRDCalibraFit.cxx:861
 AliTRDCalibraFit.cxx:862
 AliTRDCalibraFit.cxx:863
 AliTRDCalibraFit.cxx:864
 AliTRDCalibraFit.cxx:865
 AliTRDCalibraFit.cxx:866
 AliTRDCalibraFit.cxx:867
 AliTRDCalibraFit.cxx:868
 AliTRDCalibraFit.cxx:869
 AliTRDCalibraFit.cxx:870
 AliTRDCalibraFit.cxx:871
 AliTRDCalibraFit.cxx:872
 AliTRDCalibraFit.cxx:873
 AliTRDCalibraFit.cxx:874
 AliTRDCalibraFit.cxx:875
 AliTRDCalibraFit.cxx:876
 AliTRDCalibraFit.cxx:877
 AliTRDCalibraFit.cxx:878
 AliTRDCalibraFit.cxx:879
 AliTRDCalibraFit.cxx:880
 AliTRDCalibraFit.cxx:881
 AliTRDCalibraFit.cxx:882
 AliTRDCalibraFit.cxx:883
 AliTRDCalibraFit.cxx:884
 AliTRDCalibraFit.cxx:885
 AliTRDCalibraFit.cxx:886
 AliTRDCalibraFit.cxx:887
 AliTRDCalibraFit.cxx:888
 AliTRDCalibraFit.cxx:889
 AliTRDCalibraFit.cxx:890
 AliTRDCalibraFit.cxx:891
 AliTRDCalibraFit.cxx:892
 AliTRDCalibraFit.cxx:893
 AliTRDCalibraFit.cxx:894
 AliTRDCalibraFit.cxx:895
 AliTRDCalibraFit.cxx:896
 AliTRDCalibraFit.cxx:897
 AliTRDCalibraFit.cxx:898
 AliTRDCalibraFit.cxx:899
 AliTRDCalibraFit.cxx:900
 AliTRDCalibraFit.cxx:901
 AliTRDCalibraFit.cxx:902
 AliTRDCalibraFit.cxx:903
 AliTRDCalibraFit.cxx:904
 AliTRDCalibraFit.cxx:905
 AliTRDCalibraFit.cxx:906
 AliTRDCalibraFit.cxx:907
 AliTRDCalibraFit.cxx:908
 AliTRDCalibraFit.cxx:909
 AliTRDCalibraFit.cxx:910
 AliTRDCalibraFit.cxx:911
 AliTRDCalibraFit.cxx:912
 AliTRDCalibraFit.cxx:913
 AliTRDCalibraFit.cxx:914
 AliTRDCalibraFit.cxx:915
 AliTRDCalibraFit.cxx:916
 AliTRDCalibraFit.cxx:917
 AliTRDCalibraFit.cxx:918
 AliTRDCalibraFit.cxx:919
 AliTRDCalibraFit.cxx:920
 AliTRDCalibraFit.cxx:921
 AliTRDCalibraFit.cxx:922
 AliTRDCalibraFit.cxx:923
 AliTRDCalibraFit.cxx:924
 AliTRDCalibraFit.cxx:925
 AliTRDCalibraFit.cxx:926
 AliTRDCalibraFit.cxx:927
 AliTRDCalibraFit.cxx:928
 AliTRDCalibraFit.cxx:929
 AliTRDCalibraFit.cxx:930
 AliTRDCalibraFit.cxx:931
 AliTRDCalibraFit.cxx:932
 AliTRDCalibraFit.cxx:933
 AliTRDCalibraFit.cxx:934
 AliTRDCalibraFit.cxx:935
 AliTRDCalibraFit.cxx:936
 AliTRDCalibraFit.cxx:937
 AliTRDCalibraFit.cxx:938
 AliTRDCalibraFit.cxx:939
 AliTRDCalibraFit.cxx:940
 AliTRDCalibraFit.cxx:941
 AliTRDCalibraFit.cxx:942
 AliTRDCalibraFit.cxx:943
 AliTRDCalibraFit.cxx:944
 AliTRDCalibraFit.cxx:945
 AliTRDCalibraFit.cxx:946
 AliTRDCalibraFit.cxx:947
 AliTRDCalibraFit.cxx:948
 AliTRDCalibraFit.cxx:949
 AliTRDCalibraFit.cxx:950
 AliTRDCalibraFit.cxx:951
 AliTRDCalibraFit.cxx:952
 AliTRDCalibraFit.cxx:953
 AliTRDCalibraFit.cxx:954
 AliTRDCalibraFit.cxx:955
 AliTRDCalibraFit.cxx:956
 AliTRDCalibraFit.cxx:957
 AliTRDCalibraFit.cxx:958
 AliTRDCalibraFit.cxx:959
 AliTRDCalibraFit.cxx:960
 AliTRDCalibraFit.cxx:961
 AliTRDCalibraFit.cxx:962
 AliTRDCalibraFit.cxx:963
 AliTRDCalibraFit.cxx:964
 AliTRDCalibraFit.cxx:965
 AliTRDCalibraFit.cxx:966
 AliTRDCalibraFit.cxx:967
 AliTRDCalibraFit.cxx:968
 AliTRDCalibraFit.cxx:969
 AliTRDCalibraFit.cxx:970
 AliTRDCalibraFit.cxx:971
 AliTRDCalibraFit.cxx:972
 AliTRDCalibraFit.cxx:973
 AliTRDCalibraFit.cxx:974
 AliTRDCalibraFit.cxx:975
 AliTRDCalibraFit.cxx:976
 AliTRDCalibraFit.cxx:977
 AliTRDCalibraFit.cxx:978
 AliTRDCalibraFit.cxx:979
 AliTRDCalibraFit.cxx:980
 AliTRDCalibraFit.cxx:981
 AliTRDCalibraFit.cxx:982
 AliTRDCalibraFit.cxx:983
 AliTRDCalibraFit.cxx:984
 AliTRDCalibraFit.cxx:985
 AliTRDCalibraFit.cxx:986
 AliTRDCalibraFit.cxx:987
 AliTRDCalibraFit.cxx:988
 AliTRDCalibraFit.cxx:989
 AliTRDCalibraFit.cxx:990
 AliTRDCalibraFit.cxx:991
 AliTRDCalibraFit.cxx:992
 AliTRDCalibraFit.cxx:993
 AliTRDCalibraFit.cxx:994
 AliTRDCalibraFit.cxx:995
 AliTRDCalibraFit.cxx:996
 AliTRDCalibraFit.cxx:997
 AliTRDCalibraFit.cxx:998
 AliTRDCalibraFit.cxx:999
 AliTRDCalibraFit.cxx:1000
 AliTRDCalibraFit.cxx:1001
 AliTRDCalibraFit.cxx:1002
 AliTRDCalibraFit.cxx:1003
 AliTRDCalibraFit.cxx:1004
 AliTRDCalibraFit.cxx:1005
 AliTRDCalibraFit.cxx:1006
 AliTRDCalibraFit.cxx:1007
 AliTRDCalibraFit.cxx:1008
 AliTRDCalibraFit.cxx:1009
 AliTRDCalibraFit.cxx:1010
 AliTRDCalibraFit.cxx:1011
 AliTRDCalibraFit.cxx:1012
 AliTRDCalibraFit.cxx:1013
 AliTRDCalibraFit.cxx:1014
 AliTRDCalibraFit.cxx:1015
 AliTRDCalibraFit.cxx:1016
 AliTRDCalibraFit.cxx:1017
 AliTRDCalibraFit.cxx:1018
 AliTRDCalibraFit.cxx:1019
 AliTRDCalibraFit.cxx:1020
 AliTRDCalibraFit.cxx:1021
 AliTRDCalibraFit.cxx:1022
 AliTRDCalibraFit.cxx:1023
 AliTRDCalibraFit.cxx:1024
 AliTRDCalibraFit.cxx:1025
 AliTRDCalibraFit.cxx:1026
 AliTRDCalibraFit.cxx:1027
 AliTRDCalibraFit.cxx:1028
 AliTRDCalibraFit.cxx:1029
 AliTRDCalibraFit.cxx:1030
 AliTRDCalibraFit.cxx:1031
 AliTRDCalibraFit.cxx:1032
 AliTRDCalibraFit.cxx:1033
 AliTRDCalibraFit.cxx:1034
 AliTRDCalibraFit.cxx:1035
 AliTRDCalibraFit.cxx:1036
 AliTRDCalibraFit.cxx:1037
 AliTRDCalibraFit.cxx:1038
 AliTRDCalibraFit.cxx:1039
 AliTRDCalibraFit.cxx:1040
 AliTRDCalibraFit.cxx:1041
 AliTRDCalibraFit.cxx:1042
 AliTRDCalibraFit.cxx:1043
 AliTRDCalibraFit.cxx:1044
 AliTRDCalibraFit.cxx:1045
 AliTRDCalibraFit.cxx:1046
 AliTRDCalibraFit.cxx:1047
 AliTRDCalibraFit.cxx:1048
 AliTRDCalibraFit.cxx:1049
 AliTRDCalibraFit.cxx:1050
 AliTRDCalibraFit.cxx:1051
 AliTRDCalibraFit.cxx:1052
 AliTRDCalibraFit.cxx:1053
 AliTRDCalibraFit.cxx:1054
 AliTRDCalibraFit.cxx:1055
 AliTRDCalibraFit.cxx:1056
 AliTRDCalibraFit.cxx:1057
 AliTRDCalibraFit.cxx:1058
 AliTRDCalibraFit.cxx:1059
 AliTRDCalibraFit.cxx:1060
 AliTRDCalibraFit.cxx:1061
 AliTRDCalibraFit.cxx:1062
 AliTRDCalibraFit.cxx:1063
 AliTRDCalibraFit.cxx:1064
 AliTRDCalibraFit.cxx:1065
 AliTRDCalibraFit.cxx:1066
 AliTRDCalibraFit.cxx:1067
 AliTRDCalibraFit.cxx:1068
 AliTRDCalibraFit.cxx:1069
 AliTRDCalibraFit.cxx:1070
 AliTRDCalibraFit.cxx:1071
 AliTRDCalibraFit.cxx:1072
 AliTRDCalibraFit.cxx:1073
 AliTRDCalibraFit.cxx:1074
 AliTRDCalibraFit.cxx:1075
 AliTRDCalibraFit.cxx:1076
 AliTRDCalibraFit.cxx:1077
 AliTRDCalibraFit.cxx:1078
 AliTRDCalibraFit.cxx:1079
 AliTRDCalibraFit.cxx:1080
 AliTRDCalibraFit.cxx:1081
 AliTRDCalibraFit.cxx:1082
 AliTRDCalibraFit.cxx:1083
 AliTRDCalibraFit.cxx:1084
 AliTRDCalibraFit.cxx:1085
 AliTRDCalibraFit.cxx:1086
 AliTRDCalibraFit.cxx:1087
 AliTRDCalibraFit.cxx:1088
 AliTRDCalibraFit.cxx:1089
 AliTRDCalibraFit.cxx:1090
 AliTRDCalibraFit.cxx:1091
 AliTRDCalibraFit.cxx:1092
 AliTRDCalibraFit.cxx:1093
 AliTRDCalibraFit.cxx:1094
 AliTRDCalibraFit.cxx:1095
 AliTRDCalibraFit.cxx:1096
 AliTRDCalibraFit.cxx:1097
 AliTRDCalibraFit.cxx:1098
 AliTRDCalibraFit.cxx:1099
 AliTRDCalibraFit.cxx:1100
 AliTRDCalibraFit.cxx:1101
 AliTRDCalibraFit.cxx:1102
 AliTRDCalibraFit.cxx:1103
 AliTRDCalibraFit.cxx:1104
 AliTRDCalibraFit.cxx:1105
 AliTRDCalibraFit.cxx:1106
 AliTRDCalibraFit.cxx:1107
 AliTRDCalibraFit.cxx:1108
 AliTRDCalibraFit.cxx:1109
 AliTRDCalibraFit.cxx:1110
 AliTRDCalibraFit.cxx:1111
 AliTRDCalibraFit.cxx:1112
 AliTRDCalibraFit.cxx:1113
 AliTRDCalibraFit.cxx:1114
 AliTRDCalibraFit.cxx:1115
 AliTRDCalibraFit.cxx:1116
 AliTRDCalibraFit.cxx:1117
 AliTRDCalibraFit.cxx:1118
 AliTRDCalibraFit.cxx:1119
 AliTRDCalibraFit.cxx:1120
 AliTRDCalibraFit.cxx:1121
 AliTRDCalibraFit.cxx:1122
 AliTRDCalibraFit.cxx:1123
 AliTRDCalibraFit.cxx:1124
 AliTRDCalibraFit.cxx:1125
 AliTRDCalibraFit.cxx:1126
 AliTRDCalibraFit.cxx:1127
 AliTRDCalibraFit.cxx:1128
 AliTRDCalibraFit.cxx:1129
 AliTRDCalibraFit.cxx:1130
 AliTRDCalibraFit.cxx:1131
 AliTRDCalibraFit.cxx:1132
 AliTRDCalibraFit.cxx:1133
 AliTRDCalibraFit.cxx:1134
 AliTRDCalibraFit.cxx:1135
 AliTRDCalibraFit.cxx:1136
 AliTRDCalibraFit.cxx:1137
 AliTRDCalibraFit.cxx:1138
 AliTRDCalibraFit.cxx:1139
 AliTRDCalibraFit.cxx:1140
 AliTRDCalibraFit.cxx:1141
 AliTRDCalibraFit.cxx:1142
 AliTRDCalibraFit.cxx:1143
 AliTRDCalibraFit.cxx:1144
 AliTRDCalibraFit.cxx:1145
 AliTRDCalibraFit.cxx:1146
 AliTRDCalibraFit.cxx:1147
 AliTRDCalibraFit.cxx:1148
 AliTRDCalibraFit.cxx:1149
 AliTRDCalibraFit.cxx:1150
 AliTRDCalibraFit.cxx:1151
 AliTRDCalibraFit.cxx:1152
 AliTRDCalibraFit.cxx:1153
 AliTRDCalibraFit.cxx:1154
 AliTRDCalibraFit.cxx:1155
 AliTRDCalibraFit.cxx:1156
 AliTRDCalibraFit.cxx:1157
 AliTRDCalibraFit.cxx:1158
 AliTRDCalibraFit.cxx:1159
 AliTRDCalibraFit.cxx:1160
 AliTRDCalibraFit.cxx:1161
 AliTRDCalibraFit.cxx:1162
 AliTRDCalibraFit.cxx:1163
 AliTRDCalibraFit.cxx:1164
 AliTRDCalibraFit.cxx:1165
 AliTRDCalibraFit.cxx:1166
 AliTRDCalibraFit.cxx:1167
 AliTRDCalibraFit.cxx:1168
 AliTRDCalibraFit.cxx:1169
 AliTRDCalibraFit.cxx:1170
 AliTRDCalibraFit.cxx:1171
 AliTRDCalibraFit.cxx:1172
 AliTRDCalibraFit.cxx:1173
 AliTRDCalibraFit.cxx:1174
 AliTRDCalibraFit.cxx:1175
 AliTRDCalibraFit.cxx:1176
 AliTRDCalibraFit.cxx:1177
 AliTRDCalibraFit.cxx:1178
 AliTRDCalibraFit.cxx:1179
 AliTRDCalibraFit.cxx:1180
 AliTRDCalibraFit.cxx:1181
 AliTRDCalibraFit.cxx:1182
 AliTRDCalibraFit.cxx:1183
 AliTRDCalibraFit.cxx:1184
 AliTRDCalibraFit.cxx:1185
 AliTRDCalibraFit.cxx:1186
 AliTRDCalibraFit.cxx:1187
 AliTRDCalibraFit.cxx:1188
 AliTRDCalibraFit.cxx:1189
 AliTRDCalibraFit.cxx:1190
 AliTRDCalibraFit.cxx:1191
 AliTRDCalibraFit.cxx:1192
 AliTRDCalibraFit.cxx:1193
 AliTRDCalibraFit.cxx:1194
 AliTRDCalibraFit.cxx:1195
 AliTRDCalibraFit.cxx:1196
 AliTRDCalibraFit.cxx:1197
 AliTRDCalibraFit.cxx:1198
 AliTRDCalibraFit.cxx:1199
 AliTRDCalibraFit.cxx:1200
 AliTRDCalibraFit.cxx:1201
 AliTRDCalibraFit.cxx:1202
 AliTRDCalibraFit.cxx:1203
 AliTRDCalibraFit.cxx:1204
 AliTRDCalibraFit.cxx:1205
 AliTRDCalibraFit.cxx:1206
 AliTRDCalibraFit.cxx:1207
 AliTRDCalibraFit.cxx:1208
 AliTRDCalibraFit.cxx:1209
 AliTRDCalibraFit.cxx:1210
 AliTRDCalibraFit.cxx:1211
 AliTRDCalibraFit.cxx:1212
 AliTRDCalibraFit.cxx:1213
 AliTRDCalibraFit.cxx:1214
 AliTRDCalibraFit.cxx:1215
 AliTRDCalibraFit.cxx:1216
 AliTRDCalibraFit.cxx:1217
 AliTRDCalibraFit.cxx:1218
 AliTRDCalibraFit.cxx:1219
 AliTRDCalibraFit.cxx:1220
 AliTRDCalibraFit.cxx:1221
 AliTRDCalibraFit.cxx:1222
 AliTRDCalibraFit.cxx:1223
 AliTRDCalibraFit.cxx:1224
 AliTRDCalibraFit.cxx:1225
 AliTRDCalibraFit.cxx:1226
 AliTRDCalibraFit.cxx:1227
 AliTRDCalibraFit.cxx:1228
 AliTRDCalibraFit.cxx:1229
 AliTRDCalibraFit.cxx:1230
 AliTRDCalibraFit.cxx:1231
 AliTRDCalibraFit.cxx:1232
 AliTRDCalibraFit.cxx:1233
 AliTRDCalibraFit.cxx:1234
 AliTRDCalibraFit.cxx:1235
 AliTRDCalibraFit.cxx:1236
 AliTRDCalibraFit.cxx:1237
 AliTRDCalibraFit.cxx:1238
 AliTRDCalibraFit.cxx:1239
 AliTRDCalibraFit.cxx:1240
 AliTRDCalibraFit.cxx:1241
 AliTRDCalibraFit.cxx:1242
 AliTRDCalibraFit.cxx:1243
 AliTRDCalibraFit.cxx:1244
 AliTRDCalibraFit.cxx:1245
 AliTRDCalibraFit.cxx:1246
 AliTRDCalibraFit.cxx:1247
 AliTRDCalibraFit.cxx:1248
 AliTRDCalibraFit.cxx:1249
 AliTRDCalibraFit.cxx:1250
 AliTRDCalibraFit.cxx:1251
 AliTRDCalibraFit.cxx:1252
 AliTRDCalibraFit.cxx:1253
 AliTRDCalibraFit.cxx:1254
 AliTRDCalibraFit.cxx:1255
 AliTRDCalibraFit.cxx:1256
 AliTRDCalibraFit.cxx:1257
 AliTRDCalibraFit.cxx:1258
 AliTRDCalibraFit.cxx:1259
 AliTRDCalibraFit.cxx:1260
 AliTRDCalibraFit.cxx:1261
 AliTRDCalibraFit.cxx:1262
 AliTRDCalibraFit.cxx:1263
 AliTRDCalibraFit.cxx:1264
 AliTRDCalibraFit.cxx:1265
 AliTRDCalibraFit.cxx:1266
 AliTRDCalibraFit.cxx:1267
 AliTRDCalibraFit.cxx:1268
 AliTRDCalibraFit.cxx:1269
 AliTRDCalibraFit.cxx:1270
 AliTRDCalibraFit.cxx:1271
 AliTRDCalibraFit.cxx:1272
 AliTRDCalibraFit.cxx:1273
 AliTRDCalibraFit.cxx:1274
 AliTRDCalibraFit.cxx:1275
 AliTRDCalibraFit.cxx:1276
 AliTRDCalibraFit.cxx:1277
 AliTRDCalibraFit.cxx:1278
 AliTRDCalibraFit.cxx:1279
 AliTRDCalibraFit.cxx:1280
 AliTRDCalibraFit.cxx:1281
 AliTRDCalibraFit.cxx:1282
 AliTRDCalibraFit.cxx:1283
 AliTRDCalibraFit.cxx:1284
 AliTRDCalibraFit.cxx:1285
 AliTRDCalibraFit.cxx:1286
 AliTRDCalibraFit.cxx:1287
 AliTRDCalibraFit.cxx:1288
 AliTRDCalibraFit.cxx:1289
 AliTRDCalibraFit.cxx:1290
 AliTRDCalibraFit.cxx:1291
 AliTRDCalibraFit.cxx:1292
 AliTRDCalibraFit.cxx:1293
 AliTRDCalibraFit.cxx:1294
 AliTRDCalibraFit.cxx:1295
 AliTRDCalibraFit.cxx:1296
 AliTRDCalibraFit.cxx:1297
 AliTRDCalibraFit.cxx:1298
 AliTRDCalibraFit.cxx:1299
 AliTRDCalibraFit.cxx:1300
 AliTRDCalibraFit.cxx:1301
 AliTRDCalibraFit.cxx:1302
 AliTRDCalibraFit.cxx:1303
 AliTRDCalibraFit.cxx:1304
 AliTRDCalibraFit.cxx:1305
 AliTRDCalibraFit.cxx:1306
 AliTRDCalibraFit.cxx:1307
 AliTRDCalibraFit.cxx:1308
 AliTRDCalibraFit.cxx:1309
 AliTRDCalibraFit.cxx:1310
 AliTRDCalibraFit.cxx:1311
 AliTRDCalibraFit.cxx:1312
 AliTRDCalibraFit.cxx:1313
 AliTRDCalibraFit.cxx:1314
 AliTRDCalibraFit.cxx:1315
 AliTRDCalibraFit.cxx:1316
 AliTRDCalibraFit.cxx:1317
 AliTRDCalibraFit.cxx:1318
 AliTRDCalibraFit.cxx:1319
 AliTRDCalibraFit.cxx:1320
 AliTRDCalibraFit.cxx:1321
 AliTRDCalibraFit.cxx:1322
 AliTRDCalibraFit.cxx:1323
 AliTRDCalibraFit.cxx:1324
 AliTRDCalibraFit.cxx:1325
 AliTRDCalibraFit.cxx:1326
 AliTRDCalibraFit.cxx:1327
 AliTRDCalibraFit.cxx:1328
 AliTRDCalibraFit.cxx:1329
 AliTRDCalibraFit.cxx:1330
 AliTRDCalibraFit.cxx:1331
 AliTRDCalibraFit.cxx:1332
 AliTRDCalibraFit.cxx:1333
 AliTRDCalibraFit.cxx:1334
 AliTRDCalibraFit.cxx:1335
 AliTRDCalibraFit.cxx:1336
 AliTRDCalibraFit.cxx:1337
 AliTRDCalibraFit.cxx:1338
 AliTRDCalibraFit.cxx:1339
 AliTRDCalibraFit.cxx:1340
 AliTRDCalibraFit.cxx:1341
 AliTRDCalibraFit.cxx:1342
 AliTRDCalibraFit.cxx:1343
 AliTRDCalibraFit.cxx:1344
 AliTRDCalibraFit.cxx:1345
 AliTRDCalibraFit.cxx:1346
 AliTRDCalibraFit.cxx:1347
 AliTRDCalibraFit.cxx:1348
 AliTRDCalibraFit.cxx:1349
 AliTRDCalibraFit.cxx:1350
 AliTRDCalibraFit.cxx:1351
 AliTRDCalibraFit.cxx:1352
 AliTRDCalibraFit.cxx:1353
 AliTRDCalibraFit.cxx:1354
 AliTRDCalibraFit.cxx:1355
 AliTRDCalibraFit.cxx:1356
 AliTRDCalibraFit.cxx:1357
 AliTRDCalibraFit.cxx:1358
 AliTRDCalibraFit.cxx:1359
 AliTRDCalibraFit.cxx:1360
 AliTRDCalibraFit.cxx:1361
 AliTRDCalibraFit.cxx:1362
 AliTRDCalibraFit.cxx:1363
 AliTRDCalibraFit.cxx:1364
 AliTRDCalibraFit.cxx:1365
 AliTRDCalibraFit.cxx:1366
 AliTRDCalibraFit.cxx:1367
 AliTRDCalibraFit.cxx:1368
 AliTRDCalibraFit.cxx:1369
 AliTRDCalibraFit.cxx:1370
 AliTRDCalibraFit.cxx:1371
 AliTRDCalibraFit.cxx:1372
 AliTRDCalibraFit.cxx:1373
 AliTRDCalibraFit.cxx:1374
 AliTRDCalibraFit.cxx:1375
 AliTRDCalibraFit.cxx:1376
 AliTRDCalibraFit.cxx:1377
 AliTRDCalibraFit.cxx:1378
 AliTRDCalibraFit.cxx:1379
 AliTRDCalibraFit.cxx:1380
 AliTRDCalibraFit.cxx:1381
 AliTRDCalibraFit.cxx:1382
 AliTRDCalibraFit.cxx:1383
 AliTRDCalibraFit.cxx:1384
 AliTRDCalibraFit.cxx:1385
 AliTRDCalibraFit.cxx:1386
 AliTRDCalibraFit.cxx:1387
 AliTRDCalibraFit.cxx:1388
 AliTRDCalibraFit.cxx:1389
 AliTRDCalibraFit.cxx:1390
 AliTRDCalibraFit.cxx:1391
 AliTRDCalibraFit.cxx:1392
 AliTRDCalibraFit.cxx:1393
 AliTRDCalibraFit.cxx:1394
 AliTRDCalibraFit.cxx:1395
 AliTRDCalibraFit.cxx:1396
 AliTRDCalibraFit.cxx:1397
 AliTRDCalibraFit.cxx:1398
 AliTRDCalibraFit.cxx:1399
 AliTRDCalibraFit.cxx:1400
 AliTRDCalibraFit.cxx:1401
 AliTRDCalibraFit.cxx:1402
 AliTRDCalibraFit.cxx:1403
 AliTRDCalibraFit.cxx:1404
 AliTRDCalibraFit.cxx:1405
 AliTRDCalibraFit.cxx:1406
 AliTRDCalibraFit.cxx:1407
 AliTRDCalibraFit.cxx:1408
 AliTRDCalibraFit.cxx:1409
 AliTRDCalibraFit.cxx:1410
 AliTRDCalibraFit.cxx:1411
 AliTRDCalibraFit.cxx:1412
 AliTRDCalibraFit.cxx:1413
 AliTRDCalibraFit.cxx:1414
 AliTRDCalibraFit.cxx:1415
 AliTRDCalibraFit.cxx:1416
 AliTRDCalibraFit.cxx:1417
 AliTRDCalibraFit.cxx:1418
 AliTRDCalibraFit.cxx:1419
 AliTRDCalibraFit.cxx:1420
 AliTRDCalibraFit.cxx:1421
 AliTRDCalibraFit.cxx:1422
 AliTRDCalibraFit.cxx:1423
 AliTRDCalibraFit.cxx:1424
 AliTRDCalibraFit.cxx:1425
 AliTRDCalibraFit.cxx:1426
 AliTRDCalibraFit.cxx:1427
 AliTRDCalibraFit.cxx:1428
 AliTRDCalibraFit.cxx:1429
 AliTRDCalibraFit.cxx:1430
 AliTRDCalibraFit.cxx:1431
 AliTRDCalibraFit.cxx:1432
 AliTRDCalibraFit.cxx:1433
 AliTRDCalibraFit.cxx:1434
 AliTRDCalibraFit.cxx:1435
 AliTRDCalibraFit.cxx:1436
 AliTRDCalibraFit.cxx:1437
 AliTRDCalibraFit.cxx:1438
 AliTRDCalibraFit.cxx:1439
 AliTRDCalibraFit.cxx:1440
 AliTRDCalibraFit.cxx:1441
 AliTRDCalibraFit.cxx:1442
 AliTRDCalibraFit.cxx:1443
 AliTRDCalibraFit.cxx:1444
 AliTRDCalibraFit.cxx:1445
 AliTRDCalibraFit.cxx:1446
 AliTRDCalibraFit.cxx:1447
 AliTRDCalibraFit.cxx:1448
 AliTRDCalibraFit.cxx:1449
 AliTRDCalibraFit.cxx:1450
 AliTRDCalibraFit.cxx:1451
 AliTRDCalibraFit.cxx:1452
 AliTRDCalibraFit.cxx:1453
 AliTRDCalibraFit.cxx:1454
 AliTRDCalibraFit.cxx:1455
 AliTRDCalibraFit.cxx:1456
 AliTRDCalibraFit.cxx:1457
 AliTRDCalibraFit.cxx:1458
 AliTRDCalibraFit.cxx:1459
 AliTRDCalibraFit.cxx:1460
 AliTRDCalibraFit.cxx:1461
 AliTRDCalibraFit.cxx:1462
 AliTRDCalibraFit.cxx:1463
 AliTRDCalibraFit.cxx:1464
 AliTRDCalibraFit.cxx:1465
 AliTRDCalibraFit.cxx:1466
 AliTRDCalibraFit.cxx:1467
 AliTRDCalibraFit.cxx:1468
 AliTRDCalibraFit.cxx:1469
 AliTRDCalibraFit.cxx:1470
 AliTRDCalibraFit.cxx:1471
 AliTRDCalibraFit.cxx:1472
 AliTRDCalibraFit.cxx:1473
 AliTRDCalibraFit.cxx:1474
 AliTRDCalibraFit.cxx:1475
 AliTRDCalibraFit.cxx:1476
 AliTRDCalibraFit.cxx:1477
 AliTRDCalibraFit.cxx:1478
 AliTRDCalibraFit.cxx:1479
 AliTRDCalibraFit.cxx:1480
 AliTRDCalibraFit.cxx:1481
 AliTRDCalibraFit.cxx:1482
 AliTRDCalibraFit.cxx:1483
 AliTRDCalibraFit.cxx:1484
 AliTRDCalibraFit.cxx:1485
 AliTRDCalibraFit.cxx:1486
 AliTRDCalibraFit.cxx:1487
 AliTRDCalibraFit.cxx:1488
 AliTRDCalibraFit.cxx:1489
 AliTRDCalibraFit.cxx:1490
 AliTRDCalibraFit.cxx:1491
 AliTRDCalibraFit.cxx:1492
 AliTRDCalibraFit.cxx:1493
 AliTRDCalibraFit.cxx:1494
 AliTRDCalibraFit.cxx:1495
 AliTRDCalibraFit.cxx:1496
 AliTRDCalibraFit.cxx:1497
 AliTRDCalibraFit.cxx:1498
 AliTRDCalibraFit.cxx:1499
 AliTRDCalibraFit.cxx:1500
 AliTRDCalibraFit.cxx:1501
 AliTRDCalibraFit.cxx:1502
 AliTRDCalibraFit.cxx:1503
 AliTRDCalibraFit.cxx:1504
 AliTRDCalibraFit.cxx:1505
 AliTRDCalibraFit.cxx:1506
 AliTRDCalibraFit.cxx:1507
 AliTRDCalibraFit.cxx:1508
 AliTRDCalibraFit.cxx:1509
 AliTRDCalibraFit.cxx:1510
 AliTRDCalibraFit.cxx:1511
 AliTRDCalibraFit.cxx:1512
 AliTRDCalibraFit.cxx:1513
 AliTRDCalibraFit.cxx:1514
 AliTRDCalibraFit.cxx:1515
 AliTRDCalibraFit.cxx:1516
 AliTRDCalibraFit.cxx:1517
 AliTRDCalibraFit.cxx:1518
 AliTRDCalibraFit.cxx:1519
 AliTRDCalibraFit.cxx:1520
 AliTRDCalibraFit.cxx:1521
 AliTRDCalibraFit.cxx:1522
 AliTRDCalibraFit.cxx:1523
 AliTRDCalibraFit.cxx:1524
 AliTRDCalibraFit.cxx:1525
 AliTRDCalibraFit.cxx:1526
 AliTRDCalibraFit.cxx:1527
 AliTRDCalibraFit.cxx:1528
 AliTRDCalibraFit.cxx:1529
 AliTRDCalibraFit.cxx:1530
 AliTRDCalibraFit.cxx:1531
 AliTRDCalibraFit.cxx:1532
 AliTRDCalibraFit.cxx:1533
 AliTRDCalibraFit.cxx:1534
 AliTRDCalibraFit.cxx:1535
 AliTRDCalibraFit.cxx:1536
 AliTRDCalibraFit.cxx:1537
 AliTRDCalibraFit.cxx:1538
 AliTRDCalibraFit.cxx:1539
 AliTRDCalibraFit.cxx:1540
 AliTRDCalibraFit.cxx:1541
 AliTRDCalibraFit.cxx:1542
 AliTRDCalibraFit.cxx:1543
 AliTRDCalibraFit.cxx:1544
 AliTRDCalibraFit.cxx:1545
 AliTRDCalibraFit.cxx:1546
 AliTRDCalibraFit.cxx:1547
 AliTRDCalibraFit.cxx:1548
 AliTRDCalibraFit.cxx:1549
 AliTRDCalibraFit.cxx:1550
 AliTRDCalibraFit.cxx:1551
 AliTRDCalibraFit.cxx:1552
 AliTRDCalibraFit.cxx:1553
 AliTRDCalibraFit.cxx:1554
 AliTRDCalibraFit.cxx:1555
 AliTRDCalibraFit.cxx:1556
 AliTRDCalibraFit.cxx:1557
 AliTRDCalibraFit.cxx:1558
 AliTRDCalibraFit.cxx:1559
 AliTRDCalibraFit.cxx:1560
 AliTRDCalibraFit.cxx:1561
 AliTRDCalibraFit.cxx:1562
 AliTRDCalibraFit.cxx:1563
 AliTRDCalibraFit.cxx:1564
 AliTRDCalibraFit.cxx:1565
 AliTRDCalibraFit.cxx:1566
 AliTRDCalibraFit.cxx:1567
 AliTRDCalibraFit.cxx:1568
 AliTRDCalibraFit.cxx:1569
 AliTRDCalibraFit.cxx:1570
 AliTRDCalibraFit.cxx:1571
 AliTRDCalibraFit.cxx:1572
 AliTRDCalibraFit.cxx:1573
 AliTRDCalibraFit.cxx:1574
 AliTRDCalibraFit.cxx:1575
 AliTRDCalibraFit.cxx:1576
 AliTRDCalibraFit.cxx:1577
 AliTRDCalibraFit.cxx:1578
 AliTRDCalibraFit.cxx:1579
 AliTRDCalibraFit.cxx:1580
 AliTRDCalibraFit.cxx:1581
 AliTRDCalibraFit.cxx:1582
 AliTRDCalibraFit.cxx:1583
 AliTRDCalibraFit.cxx:1584
 AliTRDCalibraFit.cxx:1585
 AliTRDCalibraFit.cxx:1586
 AliTRDCalibraFit.cxx:1587
 AliTRDCalibraFit.cxx:1588
 AliTRDCalibraFit.cxx:1589
 AliTRDCalibraFit.cxx:1590
 AliTRDCalibraFit.cxx:1591
 AliTRDCalibraFit.cxx:1592
 AliTRDCalibraFit.cxx:1593
 AliTRDCalibraFit.cxx:1594
 AliTRDCalibraFit.cxx:1595
 AliTRDCalibraFit.cxx:1596
 AliTRDCalibraFit.cxx:1597
 AliTRDCalibraFit.cxx:1598
 AliTRDCalibraFit.cxx:1599
 AliTRDCalibraFit.cxx:1600
 AliTRDCalibraFit.cxx:1601
 AliTRDCalibraFit.cxx:1602
 AliTRDCalibraFit.cxx:1603
 AliTRDCalibraFit.cxx:1604
 AliTRDCalibraFit.cxx:1605
 AliTRDCalibraFit.cxx:1606
 AliTRDCalibraFit.cxx:1607
 AliTRDCalibraFit.cxx:1608
 AliTRDCalibraFit.cxx:1609
 AliTRDCalibraFit.cxx:1610
 AliTRDCalibraFit.cxx:1611
 AliTRDCalibraFit.cxx:1612
 AliTRDCalibraFit.cxx:1613
 AliTRDCalibraFit.cxx:1614
 AliTRDCalibraFit.cxx:1615
 AliTRDCalibraFit.cxx:1616
 AliTRDCalibraFit.cxx:1617
 AliTRDCalibraFit.cxx:1618
 AliTRDCalibraFit.cxx:1619
 AliTRDCalibraFit.cxx:1620
 AliTRDCalibraFit.cxx:1621
 AliTRDCalibraFit.cxx:1622
 AliTRDCalibraFit.cxx:1623
 AliTRDCalibraFit.cxx:1624
 AliTRDCalibraFit.cxx:1625
 AliTRDCalibraFit.cxx:1626
 AliTRDCalibraFit.cxx:1627
 AliTRDCalibraFit.cxx:1628
 AliTRDCalibraFit.cxx:1629
 AliTRDCalibraFit.cxx:1630
 AliTRDCalibraFit.cxx:1631
 AliTRDCalibraFit.cxx:1632
 AliTRDCalibraFit.cxx:1633
 AliTRDCalibraFit.cxx:1634
 AliTRDCalibraFit.cxx:1635
 AliTRDCalibraFit.cxx:1636
 AliTRDCalibraFit.cxx:1637
 AliTRDCalibraFit.cxx:1638
 AliTRDCalibraFit.cxx:1639
 AliTRDCalibraFit.cxx:1640
 AliTRDCalibraFit.cxx:1641
 AliTRDCalibraFit.cxx:1642
 AliTRDCalibraFit.cxx:1643
 AliTRDCalibraFit.cxx:1644
 AliTRDCalibraFit.cxx:1645
 AliTRDCalibraFit.cxx:1646
 AliTRDCalibraFit.cxx:1647
 AliTRDCalibraFit.cxx:1648
 AliTRDCalibraFit.cxx:1649
 AliTRDCalibraFit.cxx:1650
 AliTRDCalibraFit.cxx:1651
 AliTRDCalibraFit.cxx:1652
 AliTRDCalibraFit.cxx:1653
 AliTRDCalibraFit.cxx:1654
 AliTRDCalibraFit.cxx:1655
 AliTRDCalibraFit.cxx:1656
 AliTRDCalibraFit.cxx:1657
 AliTRDCalibraFit.cxx:1658
 AliTRDCalibraFit.cxx:1659
 AliTRDCalibraFit.cxx:1660
 AliTRDCalibraFit.cxx:1661
 AliTRDCalibraFit.cxx:1662
 AliTRDCalibraFit.cxx:1663
 AliTRDCalibraFit.cxx:1664
 AliTRDCalibraFit.cxx:1665
 AliTRDCalibraFit.cxx:1666
 AliTRDCalibraFit.cxx:1667
 AliTRDCalibraFit.cxx:1668
 AliTRDCalibraFit.cxx:1669
 AliTRDCalibraFit.cxx:1670
 AliTRDCalibraFit.cxx:1671
 AliTRDCalibraFit.cxx:1672
 AliTRDCalibraFit.cxx:1673
 AliTRDCalibraFit.cxx:1674
 AliTRDCalibraFit.cxx:1675
 AliTRDCalibraFit.cxx:1676
 AliTRDCalibraFit.cxx:1677
 AliTRDCalibraFit.cxx:1678
 AliTRDCalibraFit.cxx:1679
 AliTRDCalibraFit.cxx:1680
 AliTRDCalibraFit.cxx:1681
 AliTRDCalibraFit.cxx:1682
 AliTRDCalibraFit.cxx:1683
 AliTRDCalibraFit.cxx:1684
 AliTRDCalibraFit.cxx:1685
 AliTRDCalibraFit.cxx:1686
 AliTRDCalibraFit.cxx:1687
 AliTRDCalibraFit.cxx:1688
 AliTRDCalibraFit.cxx:1689
 AliTRDCalibraFit.cxx:1690
 AliTRDCalibraFit.cxx:1691
 AliTRDCalibraFit.cxx:1692
 AliTRDCalibraFit.cxx:1693
 AliTRDCalibraFit.cxx:1694
 AliTRDCalibraFit.cxx:1695
 AliTRDCalibraFit.cxx:1696
 AliTRDCalibraFit.cxx:1697
 AliTRDCalibraFit.cxx:1698
 AliTRDCalibraFit.cxx:1699
 AliTRDCalibraFit.cxx:1700
 AliTRDCalibraFit.cxx:1701
 AliTRDCalibraFit.cxx:1702
 AliTRDCalibraFit.cxx:1703
 AliTRDCalibraFit.cxx:1704
 AliTRDCalibraFit.cxx:1705
 AliTRDCalibraFit.cxx:1706
 AliTRDCalibraFit.cxx:1707
 AliTRDCalibraFit.cxx:1708
 AliTRDCalibraFit.cxx:1709
 AliTRDCalibraFit.cxx:1710
 AliTRDCalibraFit.cxx:1711
 AliTRDCalibraFit.cxx:1712
 AliTRDCalibraFit.cxx:1713
 AliTRDCalibraFit.cxx:1714
 AliTRDCalibraFit.cxx:1715
 AliTRDCalibraFit.cxx:1716
 AliTRDCalibraFit.cxx:1717
 AliTRDCalibraFit.cxx:1718
 AliTRDCalibraFit.cxx:1719
 AliTRDCalibraFit.cxx:1720
 AliTRDCalibraFit.cxx:1721
 AliTRDCalibraFit.cxx:1722
 AliTRDCalibraFit.cxx:1723
 AliTRDCalibraFit.cxx:1724
 AliTRDCalibraFit.cxx:1725
 AliTRDCalibraFit.cxx:1726
 AliTRDCalibraFit.cxx:1727
 AliTRDCalibraFit.cxx:1728
 AliTRDCalibraFit.cxx:1729
 AliTRDCalibraFit.cxx:1730
 AliTRDCalibraFit.cxx:1731
 AliTRDCalibraFit.cxx:1732
 AliTRDCalibraFit.cxx:1733
 AliTRDCalibraFit.cxx:1734
 AliTRDCalibraFit.cxx:1735
 AliTRDCalibraFit.cxx:1736
 AliTRDCalibraFit.cxx:1737
 AliTRDCalibraFit.cxx:1738
 AliTRDCalibraFit.cxx:1739
 AliTRDCalibraFit.cxx:1740
 AliTRDCalibraFit.cxx:1741
 AliTRDCalibraFit.cxx:1742
 AliTRDCalibraFit.cxx:1743
 AliTRDCalibraFit.cxx:1744
 AliTRDCalibraFit.cxx:1745
 AliTRDCalibraFit.cxx:1746
 AliTRDCalibraFit.cxx:1747
 AliTRDCalibraFit.cxx:1748
 AliTRDCalibraFit.cxx:1749
 AliTRDCalibraFit.cxx:1750
 AliTRDCalibraFit.cxx:1751
 AliTRDCalibraFit.cxx:1752
 AliTRDCalibraFit.cxx:1753
 AliTRDCalibraFit.cxx:1754
 AliTRDCalibraFit.cxx:1755
 AliTRDCalibraFit.cxx:1756
 AliTRDCalibraFit.cxx:1757
 AliTRDCalibraFit.cxx:1758
 AliTRDCalibraFit.cxx:1759
 AliTRDCalibraFit.cxx:1760
 AliTRDCalibraFit.cxx:1761
 AliTRDCalibraFit.cxx:1762
 AliTRDCalibraFit.cxx:1763
 AliTRDCalibraFit.cxx:1764
 AliTRDCalibraFit.cxx:1765
 AliTRDCalibraFit.cxx:1766
 AliTRDCalibraFit.cxx:1767
 AliTRDCalibraFit.cxx:1768
 AliTRDCalibraFit.cxx:1769
 AliTRDCalibraFit.cxx:1770
 AliTRDCalibraFit.cxx:1771
 AliTRDCalibraFit.cxx:1772
 AliTRDCalibraFit.cxx:1773
 AliTRDCalibraFit.cxx:1774
 AliTRDCalibraFit.cxx:1775
 AliTRDCalibraFit.cxx:1776
 AliTRDCalibraFit.cxx:1777
 AliTRDCalibraFit.cxx:1778
 AliTRDCalibraFit.cxx:1779
 AliTRDCalibraFit.cxx:1780
 AliTRDCalibraFit.cxx:1781
 AliTRDCalibraFit.cxx:1782
 AliTRDCalibraFit.cxx:1783
 AliTRDCalibraFit.cxx:1784
 AliTRDCalibraFit.cxx:1785
 AliTRDCalibraFit.cxx:1786
 AliTRDCalibraFit.cxx:1787
 AliTRDCalibraFit.cxx:1788
 AliTRDCalibraFit.cxx:1789
 AliTRDCalibraFit.cxx:1790
 AliTRDCalibraFit.cxx:1791
 AliTRDCalibraFit.cxx:1792
 AliTRDCalibraFit.cxx:1793
 AliTRDCalibraFit.cxx:1794
 AliTRDCalibraFit.cxx:1795
 AliTRDCalibraFit.cxx:1796
 AliTRDCalibraFit.cxx:1797
 AliTRDCalibraFit.cxx:1798
 AliTRDCalibraFit.cxx:1799
 AliTRDCalibraFit.cxx:1800
 AliTRDCalibraFit.cxx:1801
 AliTRDCalibraFit.cxx:1802
 AliTRDCalibraFit.cxx:1803
 AliTRDCalibraFit.cxx:1804
 AliTRDCalibraFit.cxx:1805
 AliTRDCalibraFit.cxx:1806
 AliTRDCalibraFit.cxx:1807
 AliTRDCalibraFit.cxx:1808
 AliTRDCalibraFit.cxx:1809
 AliTRDCalibraFit.cxx:1810
 AliTRDCalibraFit.cxx:1811
 AliTRDCalibraFit.cxx:1812
 AliTRDCalibraFit.cxx:1813
 AliTRDCalibraFit.cxx:1814
 AliTRDCalibraFit.cxx:1815
 AliTRDCalibraFit.cxx:1816
 AliTRDCalibraFit.cxx:1817
 AliTRDCalibraFit.cxx:1818
 AliTRDCalibraFit.cxx:1819
 AliTRDCalibraFit.cxx:1820
 AliTRDCalibraFit.cxx:1821
 AliTRDCalibraFit.cxx:1822
 AliTRDCalibraFit.cxx:1823
 AliTRDCalibraFit.cxx:1824
 AliTRDCalibraFit.cxx:1825
 AliTRDCalibraFit.cxx:1826
 AliTRDCalibraFit.cxx:1827
 AliTRDCalibraFit.cxx:1828
 AliTRDCalibraFit.cxx:1829
 AliTRDCalibraFit.cxx:1830
 AliTRDCalibraFit.cxx:1831
 AliTRDCalibraFit.cxx:1832
 AliTRDCalibraFit.cxx:1833
 AliTRDCalibraFit.cxx:1834
 AliTRDCalibraFit.cxx:1835
 AliTRDCalibraFit.cxx:1836
 AliTRDCalibraFit.cxx:1837
 AliTRDCalibraFit.cxx:1838
 AliTRDCalibraFit.cxx:1839
 AliTRDCalibraFit.cxx:1840
 AliTRDCalibraFit.cxx:1841
 AliTRDCalibraFit.cxx:1842
 AliTRDCalibraFit.cxx:1843
 AliTRDCalibraFit.cxx:1844
 AliTRDCalibraFit.cxx:1845
 AliTRDCalibraFit.cxx:1846
 AliTRDCalibraFit.cxx:1847
 AliTRDCalibraFit.cxx:1848
 AliTRDCalibraFit.cxx:1849
 AliTRDCalibraFit.cxx:1850
 AliTRDCalibraFit.cxx:1851
 AliTRDCalibraFit.cxx:1852
 AliTRDCalibraFit.cxx:1853
 AliTRDCalibraFit.cxx:1854
 AliTRDCalibraFit.cxx:1855
 AliTRDCalibraFit.cxx:1856
 AliTRDCalibraFit.cxx:1857
 AliTRDCalibraFit.cxx:1858
 AliTRDCalibraFit.cxx:1859
 AliTRDCalibraFit.cxx:1860
 AliTRDCalibraFit.cxx:1861
 AliTRDCalibraFit.cxx:1862
 AliTRDCalibraFit.cxx:1863
 AliTRDCalibraFit.cxx:1864
 AliTRDCalibraFit.cxx:1865
 AliTRDCalibraFit.cxx:1866
 AliTRDCalibraFit.cxx:1867
 AliTRDCalibraFit.cxx:1868
 AliTRDCalibraFit.cxx:1869
 AliTRDCalibraFit.cxx:1870
 AliTRDCalibraFit.cxx:1871
 AliTRDCalibraFit.cxx:1872
 AliTRDCalibraFit.cxx:1873
 AliTRDCalibraFit.cxx:1874
 AliTRDCalibraFit.cxx:1875
 AliTRDCalibraFit.cxx:1876
 AliTRDCalibraFit.cxx:1877
 AliTRDCalibraFit.cxx:1878
 AliTRDCalibraFit.cxx:1879
 AliTRDCalibraFit.cxx:1880
 AliTRDCalibraFit.cxx:1881
 AliTRDCalibraFit.cxx:1882
 AliTRDCalibraFit.cxx:1883
 AliTRDCalibraFit.cxx:1884
 AliTRDCalibraFit.cxx:1885
 AliTRDCalibraFit.cxx:1886
 AliTRDCalibraFit.cxx:1887
 AliTRDCalibraFit.cxx:1888
 AliTRDCalibraFit.cxx:1889
 AliTRDCalibraFit.cxx:1890
 AliTRDCalibraFit.cxx:1891
 AliTRDCalibraFit.cxx:1892
 AliTRDCalibraFit.cxx:1893
 AliTRDCalibraFit.cxx:1894
 AliTRDCalibraFit.cxx:1895
 AliTRDCalibraFit.cxx:1896
 AliTRDCalibraFit.cxx:1897
 AliTRDCalibraFit.cxx:1898
 AliTRDCalibraFit.cxx:1899
 AliTRDCalibraFit.cxx:1900
 AliTRDCalibraFit.cxx:1901
 AliTRDCalibraFit.cxx:1902
 AliTRDCalibraFit.cxx:1903
 AliTRDCalibraFit.cxx:1904
 AliTRDCalibraFit.cxx:1905
 AliTRDCalibraFit.cxx:1906
 AliTRDCalibraFit.cxx:1907
 AliTRDCalibraFit.cxx:1908
 AliTRDCalibraFit.cxx:1909
 AliTRDCalibraFit.cxx:1910
 AliTRDCalibraFit.cxx:1911
 AliTRDCalibraFit.cxx:1912
 AliTRDCalibraFit.cxx:1913
 AliTRDCalibraFit.cxx:1914
 AliTRDCalibraFit.cxx:1915
 AliTRDCalibraFit.cxx:1916
 AliTRDCalibraFit.cxx:1917
 AliTRDCalibraFit.cxx:1918
 AliTRDCalibraFit.cxx:1919
 AliTRDCalibraFit.cxx:1920
 AliTRDCalibraFit.cxx:1921
 AliTRDCalibraFit.cxx:1922
 AliTRDCalibraFit.cxx:1923
 AliTRDCalibraFit.cxx:1924
 AliTRDCalibraFit.cxx:1925
 AliTRDCalibraFit.cxx:1926
 AliTRDCalibraFit.cxx:1927
 AliTRDCalibraFit.cxx:1928
 AliTRDCalibraFit.cxx:1929
 AliTRDCalibraFit.cxx:1930
 AliTRDCalibraFit.cxx:1931
 AliTRDCalibraFit.cxx:1932
 AliTRDCalibraFit.cxx:1933
 AliTRDCalibraFit.cxx:1934
 AliTRDCalibraFit.cxx:1935
 AliTRDCalibraFit.cxx:1936
 AliTRDCalibraFit.cxx:1937
 AliTRDCalibraFit.cxx:1938
 AliTRDCalibraFit.cxx:1939
 AliTRDCalibraFit.cxx:1940
 AliTRDCalibraFit.cxx:1941
 AliTRDCalibraFit.cxx:1942
 AliTRDCalibraFit.cxx:1943
 AliTRDCalibraFit.cxx:1944
 AliTRDCalibraFit.cxx:1945
 AliTRDCalibraFit.cxx:1946
 AliTRDCalibraFit.cxx:1947
 AliTRDCalibraFit.cxx:1948
 AliTRDCalibraFit.cxx:1949
 AliTRDCalibraFit.cxx:1950
 AliTRDCalibraFit.cxx:1951
 AliTRDCalibraFit.cxx:1952
 AliTRDCalibraFit.cxx:1953
 AliTRDCalibraFit.cxx:1954
 AliTRDCalibraFit.cxx:1955
 AliTRDCalibraFit.cxx:1956
 AliTRDCalibraFit.cxx:1957
 AliTRDCalibraFit.cxx:1958
 AliTRDCalibraFit.cxx:1959
 AliTRDCalibraFit.cxx:1960
 AliTRDCalibraFit.cxx:1961
 AliTRDCalibraFit.cxx:1962
 AliTRDCalibraFit.cxx:1963
 AliTRDCalibraFit.cxx:1964
 AliTRDCalibraFit.cxx:1965
 AliTRDCalibraFit.cxx:1966
 AliTRDCalibraFit.cxx:1967
 AliTRDCalibraFit.cxx:1968
 AliTRDCalibraFit.cxx:1969
 AliTRDCalibraFit.cxx:1970
 AliTRDCalibraFit.cxx:1971
 AliTRDCalibraFit.cxx:1972
 AliTRDCalibraFit.cxx:1973
 AliTRDCalibraFit.cxx:1974
 AliTRDCalibraFit.cxx:1975
 AliTRDCalibraFit.cxx:1976
 AliTRDCalibraFit.cxx:1977
 AliTRDCalibraFit.cxx:1978
 AliTRDCalibraFit.cxx:1979
 AliTRDCalibraFit.cxx:1980
 AliTRDCalibraFit.cxx:1981
 AliTRDCalibraFit.cxx:1982
 AliTRDCalibraFit.cxx:1983
 AliTRDCalibraFit.cxx:1984
 AliTRDCalibraFit.cxx:1985
 AliTRDCalibraFit.cxx:1986
 AliTRDCalibraFit.cxx:1987
 AliTRDCalibraFit.cxx:1988
 AliTRDCalibraFit.cxx:1989
 AliTRDCalibraFit.cxx:1990
 AliTRDCalibraFit.cxx:1991
 AliTRDCalibraFit.cxx:1992
 AliTRDCalibraFit.cxx:1993
 AliTRDCalibraFit.cxx:1994
 AliTRDCalibraFit.cxx:1995
 AliTRDCalibraFit.cxx:1996
 AliTRDCalibraFit.cxx:1997
 AliTRDCalibraFit.cxx:1998
 AliTRDCalibraFit.cxx:1999
 AliTRDCalibraFit.cxx:2000
 AliTRDCalibraFit.cxx:2001
 AliTRDCalibraFit.cxx:2002
 AliTRDCalibraFit.cxx:2003
 AliTRDCalibraFit.cxx:2004
 AliTRDCalibraFit.cxx:2005
 AliTRDCalibraFit.cxx:2006
 AliTRDCalibraFit.cxx:2007
 AliTRDCalibraFit.cxx:2008
 AliTRDCalibraFit.cxx:2009
 AliTRDCalibraFit.cxx:2010
 AliTRDCalibraFit.cxx:2011
 AliTRDCalibraFit.cxx:2012
 AliTRDCalibraFit.cxx:2013
 AliTRDCalibraFit.cxx:2014
 AliTRDCalibraFit.cxx:2015
 AliTRDCalibraFit.cxx:2016
 AliTRDCalibraFit.cxx:2017
 AliTRDCalibraFit.cxx:2018
 AliTRDCalibraFit.cxx:2019
 AliTRDCalibraFit.cxx:2020
 AliTRDCalibraFit.cxx:2021
 AliTRDCalibraFit.cxx:2022
 AliTRDCalibraFit.cxx:2023
 AliTRDCalibraFit.cxx:2024
 AliTRDCalibraFit.cxx:2025
 AliTRDCalibraFit.cxx:2026
 AliTRDCalibraFit.cxx:2027
 AliTRDCalibraFit.cxx:2028
 AliTRDCalibraFit.cxx:2029
 AliTRDCalibraFit.cxx:2030
 AliTRDCalibraFit.cxx:2031
 AliTRDCalibraFit.cxx:2032
 AliTRDCalibraFit.cxx:2033
 AliTRDCalibraFit.cxx:2034
 AliTRDCalibraFit.cxx:2035
 AliTRDCalibraFit.cxx:2036
 AliTRDCalibraFit.cxx:2037
 AliTRDCalibraFit.cxx:2038
 AliTRDCalibraFit.cxx:2039
 AliTRDCalibraFit.cxx:2040
 AliTRDCalibraFit.cxx:2041
 AliTRDCalibraFit.cxx:2042
 AliTRDCalibraFit.cxx:2043
 AliTRDCalibraFit.cxx:2044
 AliTRDCalibraFit.cxx:2045
 AliTRDCalibraFit.cxx:2046
 AliTRDCalibraFit.cxx:2047
 AliTRDCalibraFit.cxx:2048
 AliTRDCalibraFit.cxx:2049
 AliTRDCalibraFit.cxx:2050
 AliTRDCalibraFit.cxx:2051
 AliTRDCalibraFit.cxx:2052
 AliTRDCalibraFit.cxx:2053
 AliTRDCalibraFit.cxx:2054
 AliTRDCalibraFit.cxx:2055
 AliTRDCalibraFit.cxx:2056
 AliTRDCalibraFit.cxx:2057
 AliTRDCalibraFit.cxx:2058
 AliTRDCalibraFit.cxx:2059
 AliTRDCalibraFit.cxx:2060
 AliTRDCalibraFit.cxx:2061
 AliTRDCalibraFit.cxx:2062
 AliTRDCalibraFit.cxx:2063
 AliTRDCalibraFit.cxx:2064
 AliTRDCalibraFit.cxx:2065
 AliTRDCalibraFit.cxx:2066
 AliTRDCalibraFit.cxx:2067
 AliTRDCalibraFit.cxx:2068
 AliTRDCalibraFit.cxx:2069
 AliTRDCalibraFit.cxx:2070
 AliTRDCalibraFit.cxx:2071
 AliTRDCalibraFit.cxx:2072
 AliTRDCalibraFit.cxx:2073
 AliTRDCalibraFit.cxx:2074
 AliTRDCalibraFit.cxx:2075
 AliTRDCalibraFit.cxx:2076
 AliTRDCalibraFit.cxx:2077
 AliTRDCalibraFit.cxx:2078
 AliTRDCalibraFit.cxx:2079
 AliTRDCalibraFit.cxx:2080
 AliTRDCalibraFit.cxx:2081
 AliTRDCalibraFit.cxx:2082
 AliTRDCalibraFit.cxx:2083
 AliTRDCalibraFit.cxx:2084
 AliTRDCalibraFit.cxx:2085
 AliTRDCalibraFit.cxx:2086
 AliTRDCalibraFit.cxx:2087
 AliTRDCalibraFit.cxx:2088
 AliTRDCalibraFit.cxx:2089
 AliTRDCalibraFit.cxx:2090
 AliTRDCalibraFit.cxx:2091
 AliTRDCalibraFit.cxx:2092
 AliTRDCalibraFit.cxx:2093
 AliTRDCalibraFit.cxx:2094
 AliTRDCalibraFit.cxx:2095
 AliTRDCalibraFit.cxx:2096
 AliTRDCalibraFit.cxx:2097
 AliTRDCalibraFit.cxx:2098
 AliTRDCalibraFit.cxx:2099
 AliTRDCalibraFit.cxx:2100
 AliTRDCalibraFit.cxx:2101
 AliTRDCalibraFit.cxx:2102
 AliTRDCalibraFit.cxx:2103
 AliTRDCalibraFit.cxx:2104
 AliTRDCalibraFit.cxx:2105
 AliTRDCalibraFit.cxx:2106
 AliTRDCalibraFit.cxx:2107
 AliTRDCalibraFit.cxx:2108
 AliTRDCalibraFit.cxx:2109
 AliTRDCalibraFit.cxx:2110
 AliTRDCalibraFit.cxx:2111
 AliTRDCalibraFit.cxx:2112
 AliTRDCalibraFit.cxx:2113
 AliTRDCalibraFit.cxx:2114
 AliTRDCalibraFit.cxx:2115
 AliTRDCalibraFit.cxx:2116
 AliTRDCalibraFit.cxx:2117
 AliTRDCalibraFit.cxx:2118
 AliTRDCalibraFit.cxx:2119
 AliTRDCalibraFit.cxx:2120
 AliTRDCalibraFit.cxx:2121
 AliTRDCalibraFit.cxx:2122
 AliTRDCalibraFit.cxx:2123
 AliTRDCalibraFit.cxx:2124
 AliTRDCalibraFit.cxx:2125
 AliTRDCalibraFit.cxx:2126
 AliTRDCalibraFit.cxx:2127
 AliTRDCalibraFit.cxx:2128
 AliTRDCalibraFit.cxx:2129
 AliTRDCalibraFit.cxx:2130
 AliTRDCalibraFit.cxx:2131
 AliTRDCalibraFit.cxx:2132
 AliTRDCalibraFit.cxx:2133
 AliTRDCalibraFit.cxx:2134
 AliTRDCalibraFit.cxx:2135
 AliTRDCalibraFit.cxx:2136
 AliTRDCalibraFit.cxx:2137
 AliTRDCalibraFit.cxx:2138
 AliTRDCalibraFit.cxx:2139
 AliTRDCalibraFit.cxx:2140
 AliTRDCalibraFit.cxx:2141
 AliTRDCalibraFit.cxx:2142
 AliTRDCalibraFit.cxx:2143
 AliTRDCalibraFit.cxx:2144
 AliTRDCalibraFit.cxx:2145
 AliTRDCalibraFit.cxx:2146
 AliTRDCalibraFit.cxx:2147
 AliTRDCalibraFit.cxx:2148
 AliTRDCalibraFit.cxx:2149
 AliTRDCalibraFit.cxx:2150
 AliTRDCalibraFit.cxx:2151
 AliTRDCalibraFit.cxx:2152
 AliTRDCalibraFit.cxx:2153
 AliTRDCalibraFit.cxx:2154
 AliTRDCalibraFit.cxx:2155
 AliTRDCalibraFit.cxx:2156
 AliTRDCalibraFit.cxx:2157
 AliTRDCalibraFit.cxx:2158
 AliTRDCalibraFit.cxx:2159
 AliTRDCalibraFit.cxx:2160
 AliTRDCalibraFit.cxx:2161
 AliTRDCalibraFit.cxx:2162
 AliTRDCalibraFit.cxx:2163
 AliTRDCalibraFit.cxx:2164
 AliTRDCalibraFit.cxx:2165
 AliTRDCalibraFit.cxx:2166
 AliTRDCalibraFit.cxx:2167
 AliTRDCalibraFit.cxx:2168
 AliTRDCalibraFit.cxx:2169
 AliTRDCalibraFit.cxx:2170
 AliTRDCalibraFit.cxx:2171
 AliTRDCalibraFit.cxx:2172
 AliTRDCalibraFit.cxx:2173
 AliTRDCalibraFit.cxx:2174
 AliTRDCalibraFit.cxx:2175
 AliTRDCalibraFit.cxx:2176
 AliTRDCalibraFit.cxx:2177
 AliTRDCalibraFit.cxx:2178
 AliTRDCalibraFit.cxx:2179
 AliTRDCalibraFit.cxx:2180
 AliTRDCalibraFit.cxx:2181
 AliTRDCalibraFit.cxx:2182
 AliTRDCalibraFit.cxx:2183
 AliTRDCalibraFit.cxx:2184
 AliTRDCalibraFit.cxx:2185
 AliTRDCalibraFit.cxx:2186
 AliTRDCalibraFit.cxx:2187
 AliTRDCalibraFit.cxx:2188
 AliTRDCalibraFit.cxx:2189
 AliTRDCalibraFit.cxx:2190
 AliTRDCalibraFit.cxx:2191
 AliTRDCalibraFit.cxx:2192
 AliTRDCalibraFit.cxx:2193
 AliTRDCalibraFit.cxx:2194
 AliTRDCalibraFit.cxx:2195
 AliTRDCalibraFit.cxx:2196
 AliTRDCalibraFit.cxx:2197
 AliTRDCalibraFit.cxx:2198
 AliTRDCalibraFit.cxx:2199
 AliTRDCalibraFit.cxx:2200
 AliTRDCalibraFit.cxx:2201
 AliTRDCalibraFit.cxx:2202
 AliTRDCalibraFit.cxx:2203
 AliTRDCalibraFit.cxx:2204
 AliTRDCalibraFit.cxx:2205
 AliTRDCalibraFit.cxx:2206
 AliTRDCalibraFit.cxx:2207
 AliTRDCalibraFit.cxx:2208
 AliTRDCalibraFit.cxx:2209
 AliTRDCalibraFit.cxx:2210
 AliTRDCalibraFit.cxx:2211
 AliTRDCalibraFit.cxx:2212
 AliTRDCalibraFit.cxx:2213
 AliTRDCalibraFit.cxx:2214
 AliTRDCalibraFit.cxx:2215
 AliTRDCalibraFit.cxx:2216
 AliTRDCalibraFit.cxx:2217
 AliTRDCalibraFit.cxx:2218
 AliTRDCalibraFit.cxx:2219
 AliTRDCalibraFit.cxx:2220
 AliTRDCalibraFit.cxx:2221
 AliTRDCalibraFit.cxx:2222
 AliTRDCalibraFit.cxx:2223
 AliTRDCalibraFit.cxx:2224
 AliTRDCalibraFit.cxx:2225
 AliTRDCalibraFit.cxx:2226
 AliTRDCalibraFit.cxx:2227
 AliTRDCalibraFit.cxx:2228
 AliTRDCalibraFit.cxx:2229
 AliTRDCalibraFit.cxx:2230
 AliTRDCalibraFit.cxx:2231
 AliTRDCalibraFit.cxx:2232
 AliTRDCalibraFit.cxx:2233
 AliTRDCalibraFit.cxx:2234
 AliTRDCalibraFit.cxx:2235
 AliTRDCalibraFit.cxx:2236
 AliTRDCalibraFit.cxx:2237
 AliTRDCalibraFit.cxx:2238
 AliTRDCalibraFit.cxx:2239
 AliTRDCalibraFit.cxx:2240
 AliTRDCalibraFit.cxx:2241
 AliTRDCalibraFit.cxx:2242
 AliTRDCalibraFit.cxx:2243
 AliTRDCalibraFit.cxx:2244
 AliTRDCalibraFit.cxx:2245
 AliTRDCalibraFit.cxx:2246
 AliTRDCalibraFit.cxx:2247
 AliTRDCalibraFit.cxx:2248
 AliTRDCalibraFit.cxx:2249
 AliTRDCalibraFit.cxx:2250
 AliTRDCalibraFit.cxx:2251
 AliTRDCalibraFit.cxx:2252
 AliTRDCalibraFit.cxx:2253
 AliTRDCalibraFit.cxx:2254
 AliTRDCalibraFit.cxx:2255
 AliTRDCalibraFit.cxx:2256
 AliTRDCalibraFit.cxx:2257
 AliTRDCalibraFit.cxx:2258
 AliTRDCalibraFit.cxx:2259
 AliTRDCalibraFit.cxx:2260
 AliTRDCalibraFit.cxx:2261
 AliTRDCalibraFit.cxx:2262
 AliTRDCalibraFit.cxx:2263
 AliTRDCalibraFit.cxx:2264
 AliTRDCalibraFit.cxx:2265
 AliTRDCalibraFit.cxx:2266
 AliTRDCalibraFit.cxx:2267
 AliTRDCalibraFit.cxx:2268
 AliTRDCalibraFit.cxx:2269
 AliTRDCalibraFit.cxx:2270
 AliTRDCalibraFit.cxx:2271
 AliTRDCalibraFit.cxx:2272
 AliTRDCalibraFit.cxx:2273
 AliTRDCalibraFit.cxx:2274
 AliTRDCalibraFit.cxx:2275
 AliTRDCalibraFit.cxx:2276
 AliTRDCalibraFit.cxx:2277
 AliTRDCalibraFit.cxx:2278
 AliTRDCalibraFit.cxx:2279
 AliTRDCalibraFit.cxx:2280
 AliTRDCalibraFit.cxx:2281
 AliTRDCalibraFit.cxx:2282
 AliTRDCalibraFit.cxx:2283
 AliTRDCalibraFit.cxx:2284
 AliTRDCalibraFit.cxx:2285
 AliTRDCalibraFit.cxx:2286
 AliTRDCalibraFit.cxx:2287
 AliTRDCalibraFit.cxx:2288
 AliTRDCalibraFit.cxx:2289
 AliTRDCalibraFit.cxx:2290
 AliTRDCalibraFit.cxx:2291
 AliTRDCalibraFit.cxx:2292
 AliTRDCalibraFit.cxx:2293
 AliTRDCalibraFit.cxx:2294
 AliTRDCalibraFit.cxx:2295
 AliTRDCalibraFit.cxx:2296
 AliTRDCalibraFit.cxx:2297
 AliTRDCalibraFit.cxx:2298
 AliTRDCalibraFit.cxx:2299
 AliTRDCalibraFit.cxx:2300
 AliTRDCalibraFit.cxx:2301
 AliTRDCalibraFit.cxx:2302
 AliTRDCalibraFit.cxx:2303
 AliTRDCalibraFit.cxx:2304
 AliTRDCalibraFit.cxx:2305
 AliTRDCalibraFit.cxx:2306
 AliTRDCalibraFit.cxx:2307
 AliTRDCalibraFit.cxx:2308
 AliTRDCalibraFit.cxx:2309
 AliTRDCalibraFit.cxx:2310
 AliTRDCalibraFit.cxx:2311
 AliTRDCalibraFit.cxx:2312
 AliTRDCalibraFit.cxx:2313
 AliTRDCalibraFit.cxx:2314
 AliTRDCalibraFit.cxx:2315
 AliTRDCalibraFit.cxx:2316
 AliTRDCalibraFit.cxx:2317
 AliTRDCalibraFit.cxx:2318
 AliTRDCalibraFit.cxx:2319
 AliTRDCalibraFit.cxx:2320
 AliTRDCalibraFit.cxx:2321
 AliTRDCalibraFit.cxx:2322
 AliTRDCalibraFit.cxx:2323
 AliTRDCalibraFit.cxx:2324
 AliTRDCalibraFit.cxx:2325
 AliTRDCalibraFit.cxx:2326
 AliTRDCalibraFit.cxx:2327
 AliTRDCalibraFit.cxx:2328
 AliTRDCalibraFit.cxx:2329
 AliTRDCalibraFit.cxx:2330
 AliTRDCalibraFit.cxx:2331
 AliTRDCalibraFit.cxx:2332
 AliTRDCalibraFit.cxx:2333
 AliTRDCalibraFit.cxx:2334
 AliTRDCalibraFit.cxx:2335
 AliTRDCalibraFit.cxx:2336
 AliTRDCalibraFit.cxx:2337
 AliTRDCalibraFit.cxx:2338
 AliTRDCalibraFit.cxx:2339
 AliTRDCalibraFit.cxx:2340
 AliTRDCalibraFit.cxx:2341
 AliTRDCalibraFit.cxx:2342
 AliTRDCalibraFit.cxx:2343
 AliTRDCalibraFit.cxx:2344
 AliTRDCalibraFit.cxx:2345
 AliTRDCalibraFit.cxx:2346
 AliTRDCalibraFit.cxx:2347
 AliTRDCalibraFit.cxx:2348
 AliTRDCalibraFit.cxx:2349
 AliTRDCalibraFit.cxx:2350
 AliTRDCalibraFit.cxx:2351
 AliTRDCalibraFit.cxx:2352
 AliTRDCalibraFit.cxx:2353
 AliTRDCalibraFit.cxx:2354
 AliTRDCalibraFit.cxx:2355
 AliTRDCalibraFit.cxx:2356
 AliTRDCalibraFit.cxx:2357
 AliTRDCalibraFit.cxx:2358
 AliTRDCalibraFit.cxx:2359
 AliTRDCalibraFit.cxx:2360
 AliTRDCalibraFit.cxx:2361
 AliTRDCalibraFit.cxx:2362
 AliTRDCalibraFit.cxx:2363
 AliTRDCalibraFit.cxx:2364
 AliTRDCalibraFit.cxx:2365
 AliTRDCalibraFit.cxx:2366
 AliTRDCalibraFit.cxx:2367
 AliTRDCalibraFit.cxx:2368
 AliTRDCalibraFit.cxx:2369
 AliTRDCalibraFit.cxx:2370
 AliTRDCalibraFit.cxx:2371
 AliTRDCalibraFit.cxx:2372
 AliTRDCalibraFit.cxx:2373
 AliTRDCalibraFit.cxx:2374
 AliTRDCalibraFit.cxx:2375
 AliTRDCalibraFit.cxx:2376
 AliTRDCalibraFit.cxx:2377
 AliTRDCalibraFit.cxx:2378
 AliTRDCalibraFit.cxx:2379
 AliTRDCalibraFit.cxx:2380
 AliTRDCalibraFit.cxx:2381
 AliTRDCalibraFit.cxx:2382
 AliTRDCalibraFit.cxx:2383
 AliTRDCalibraFit.cxx:2384
 AliTRDCalibraFit.cxx:2385
 AliTRDCalibraFit.cxx:2386
 AliTRDCalibraFit.cxx:2387
 AliTRDCalibraFit.cxx:2388
 AliTRDCalibraFit.cxx:2389
 AliTRDCalibraFit.cxx:2390
 AliTRDCalibraFit.cxx:2391
 AliTRDCalibraFit.cxx:2392
 AliTRDCalibraFit.cxx:2393
 AliTRDCalibraFit.cxx:2394
 AliTRDCalibraFit.cxx:2395
 AliTRDCalibraFit.cxx:2396
 AliTRDCalibraFit.cxx:2397
 AliTRDCalibraFit.cxx:2398
 AliTRDCalibraFit.cxx:2399
 AliTRDCalibraFit.cxx:2400
 AliTRDCalibraFit.cxx:2401
 AliTRDCalibraFit.cxx:2402
 AliTRDCalibraFit.cxx:2403
 AliTRDCalibraFit.cxx:2404
 AliTRDCalibraFit.cxx:2405
 AliTRDCalibraFit.cxx:2406
 AliTRDCalibraFit.cxx:2407
 AliTRDCalibraFit.cxx:2408
 AliTRDCalibraFit.cxx:2409
 AliTRDCalibraFit.cxx:2410
 AliTRDCalibraFit.cxx:2411
 AliTRDCalibraFit.cxx:2412
 AliTRDCalibraFit.cxx:2413
 AliTRDCalibraFit.cxx:2414
 AliTRDCalibraFit.cxx:2415
 AliTRDCalibraFit.cxx:2416
 AliTRDCalibraFit.cxx:2417
 AliTRDCalibraFit.cxx:2418
 AliTRDCalibraFit.cxx:2419
 AliTRDCalibraFit.cxx:2420
 AliTRDCalibraFit.cxx:2421
 AliTRDCalibraFit.cxx:2422
 AliTRDCalibraFit.cxx:2423
 AliTRDCalibraFit.cxx:2424
 AliTRDCalibraFit.cxx:2425
 AliTRDCalibraFit.cxx:2426
 AliTRDCalibraFit.cxx:2427
 AliTRDCalibraFit.cxx:2428
 AliTRDCalibraFit.cxx:2429
 AliTRDCalibraFit.cxx:2430
 AliTRDCalibraFit.cxx:2431
 AliTRDCalibraFit.cxx:2432
 AliTRDCalibraFit.cxx:2433
 AliTRDCalibraFit.cxx:2434
 AliTRDCalibraFit.cxx:2435
 AliTRDCalibraFit.cxx:2436
 AliTRDCalibraFit.cxx:2437
 AliTRDCalibraFit.cxx:2438
 AliTRDCalibraFit.cxx:2439
 AliTRDCalibraFit.cxx:2440
 AliTRDCalibraFit.cxx:2441
 AliTRDCalibraFit.cxx:2442
 AliTRDCalibraFit.cxx:2443
 AliTRDCalibraFit.cxx:2444
 AliTRDCalibraFit.cxx:2445
 AliTRDCalibraFit.cxx:2446
 AliTRDCalibraFit.cxx:2447
 AliTRDCalibraFit.cxx:2448
 AliTRDCalibraFit.cxx:2449
 AliTRDCalibraFit.cxx:2450
 AliTRDCalibraFit.cxx:2451
 AliTRDCalibraFit.cxx:2452
 AliTRDCalibraFit.cxx:2453
 AliTRDCalibraFit.cxx:2454
 AliTRDCalibraFit.cxx:2455
 AliTRDCalibraFit.cxx:2456
 AliTRDCalibraFit.cxx:2457
 AliTRDCalibraFit.cxx:2458
 AliTRDCalibraFit.cxx:2459
 AliTRDCalibraFit.cxx:2460
 AliTRDCalibraFit.cxx:2461
 AliTRDCalibraFit.cxx:2462
 AliTRDCalibraFit.cxx:2463
 AliTRDCalibraFit.cxx:2464
 AliTRDCalibraFit.cxx:2465
 AliTRDCalibraFit.cxx:2466
 AliTRDCalibraFit.cxx:2467
 AliTRDCalibraFit.cxx:2468
 AliTRDCalibraFit.cxx:2469
 AliTRDCalibraFit.cxx:2470
 AliTRDCalibraFit.cxx:2471
 AliTRDCalibraFit.cxx:2472
 AliTRDCalibraFit.cxx:2473
 AliTRDCalibraFit.cxx:2474
 AliTRDCalibraFit.cxx:2475
 AliTRDCalibraFit.cxx:2476
 AliTRDCalibraFit.cxx:2477
 AliTRDCalibraFit.cxx:2478
 AliTRDCalibraFit.cxx:2479
 AliTRDCalibraFit.cxx:2480
 AliTRDCalibraFit.cxx:2481
 AliTRDCalibraFit.cxx:2482
 AliTRDCalibraFit.cxx:2483
 AliTRDCalibraFit.cxx:2484
 AliTRDCalibraFit.cxx:2485
 AliTRDCalibraFit.cxx:2486
 AliTRDCalibraFit.cxx:2487
 AliTRDCalibraFit.cxx:2488
 AliTRDCalibraFit.cxx:2489
 AliTRDCalibraFit.cxx:2490
 AliTRDCalibraFit.cxx:2491
 AliTRDCalibraFit.cxx:2492
 AliTRDCalibraFit.cxx:2493
 AliTRDCalibraFit.cxx:2494
 AliTRDCalibraFit.cxx:2495
 AliTRDCalibraFit.cxx:2496
 AliTRDCalibraFit.cxx:2497
 AliTRDCalibraFit.cxx:2498
 AliTRDCalibraFit.cxx:2499
 AliTRDCalibraFit.cxx:2500
 AliTRDCalibraFit.cxx:2501
 AliTRDCalibraFit.cxx:2502
 AliTRDCalibraFit.cxx:2503
 AliTRDCalibraFit.cxx:2504
 AliTRDCalibraFit.cxx:2505
 AliTRDCalibraFit.cxx:2506
 AliTRDCalibraFit.cxx:2507
 AliTRDCalibraFit.cxx:2508
 AliTRDCalibraFit.cxx:2509
 AliTRDCalibraFit.cxx:2510
 AliTRDCalibraFit.cxx:2511
 AliTRDCalibraFit.cxx:2512
 AliTRDCalibraFit.cxx:2513
 AliTRDCalibraFit.cxx:2514
 AliTRDCalibraFit.cxx:2515
 AliTRDCalibraFit.cxx:2516
 AliTRDCalibraFit.cxx:2517
 AliTRDCalibraFit.cxx:2518
 AliTRDCalibraFit.cxx:2519
 AliTRDCalibraFit.cxx:2520
 AliTRDCalibraFit.cxx:2521
 AliTRDCalibraFit.cxx:2522
 AliTRDCalibraFit.cxx:2523
 AliTRDCalibraFit.cxx:2524
 AliTRDCalibraFit.cxx:2525
 AliTRDCalibraFit.cxx:2526
 AliTRDCalibraFit.cxx:2527
 AliTRDCalibraFit.cxx:2528
 AliTRDCalibraFit.cxx:2529
 AliTRDCalibraFit.cxx:2530
 AliTRDCalibraFit.cxx:2531
 AliTRDCalibraFit.cxx:2532
 AliTRDCalibraFit.cxx:2533
 AliTRDCalibraFit.cxx:2534
 AliTRDCalibraFit.cxx:2535
 AliTRDCalibraFit.cxx:2536
 AliTRDCalibraFit.cxx:2537
 AliTRDCalibraFit.cxx:2538
 AliTRDCalibraFit.cxx:2539
 AliTRDCalibraFit.cxx:2540
 AliTRDCalibraFit.cxx:2541
 AliTRDCalibraFit.cxx:2542
 AliTRDCalibraFit.cxx:2543
 AliTRDCalibraFit.cxx:2544
 AliTRDCalibraFit.cxx:2545
 AliTRDCalibraFit.cxx:2546
 AliTRDCalibraFit.cxx:2547
 AliTRDCalibraFit.cxx:2548
 AliTRDCalibraFit.cxx:2549
 AliTRDCalibraFit.cxx:2550
 AliTRDCalibraFit.cxx:2551
 AliTRDCalibraFit.cxx:2552
 AliTRDCalibraFit.cxx:2553
 AliTRDCalibraFit.cxx:2554
 AliTRDCalibraFit.cxx:2555
 AliTRDCalibraFit.cxx:2556
 AliTRDCalibraFit.cxx:2557
 AliTRDCalibraFit.cxx:2558
 AliTRDCalibraFit.cxx:2559
 AliTRDCalibraFit.cxx:2560
 AliTRDCalibraFit.cxx:2561
 AliTRDCalibraFit.cxx:2562
 AliTRDCalibraFit.cxx:2563
 AliTRDCalibraFit.cxx:2564
 AliTRDCalibraFit.cxx:2565
 AliTRDCalibraFit.cxx:2566
 AliTRDCalibraFit.cxx:2567
 AliTRDCalibraFit.cxx:2568
 AliTRDCalibraFit.cxx:2569
 AliTRDCalibraFit.cxx:2570
 AliTRDCalibraFit.cxx:2571
 AliTRDCalibraFit.cxx:2572
 AliTRDCalibraFit.cxx:2573
 AliTRDCalibraFit.cxx:2574
 AliTRDCalibraFit.cxx:2575
 AliTRDCalibraFit.cxx:2576
 AliTRDCalibraFit.cxx:2577
 AliTRDCalibraFit.cxx:2578
 AliTRDCalibraFit.cxx:2579
 AliTRDCalibraFit.cxx:2580
 AliTRDCalibraFit.cxx:2581
 AliTRDCalibraFit.cxx:2582
 AliTRDCalibraFit.cxx:2583
 AliTRDCalibraFit.cxx:2584
 AliTRDCalibraFit.cxx:2585
 AliTRDCalibraFit.cxx:2586
 AliTRDCalibraFit.cxx:2587
 AliTRDCalibraFit.cxx:2588
 AliTRDCalibraFit.cxx:2589
 AliTRDCalibraFit.cxx:2590
 AliTRDCalibraFit.cxx:2591
 AliTRDCalibraFit.cxx:2592
 AliTRDCalibraFit.cxx:2593
 AliTRDCalibraFit.cxx:2594
 AliTRDCalibraFit.cxx:2595
 AliTRDCalibraFit.cxx:2596
 AliTRDCalibraFit.cxx:2597
 AliTRDCalibraFit.cxx:2598
 AliTRDCalibraFit.cxx:2599
 AliTRDCalibraFit.cxx:2600
 AliTRDCalibraFit.cxx:2601
 AliTRDCalibraFit.cxx:2602
 AliTRDCalibraFit.cxx:2603
 AliTRDCalibraFit.cxx:2604
 AliTRDCalibraFit.cxx:2605
 AliTRDCalibraFit.cxx:2606
 AliTRDCalibraFit.cxx:2607
 AliTRDCalibraFit.cxx:2608
 AliTRDCalibraFit.cxx:2609
 AliTRDCalibraFit.cxx:2610
 AliTRDCalibraFit.cxx:2611
 AliTRDCalibraFit.cxx:2612
 AliTRDCalibraFit.cxx:2613
 AliTRDCalibraFit.cxx:2614
 AliTRDCalibraFit.cxx:2615
 AliTRDCalibraFit.cxx:2616
 AliTRDCalibraFit.cxx:2617
 AliTRDCalibraFit.cxx:2618
 AliTRDCalibraFit.cxx:2619
 AliTRDCalibraFit.cxx:2620
 AliTRDCalibraFit.cxx:2621
 AliTRDCalibraFit.cxx:2622
 AliTRDCalibraFit.cxx:2623
 AliTRDCalibraFit.cxx:2624
 AliTRDCalibraFit.cxx:2625
 AliTRDCalibraFit.cxx:2626
 AliTRDCalibraFit.cxx:2627
 AliTRDCalibraFit.cxx:2628
 AliTRDCalibraFit.cxx:2629
 AliTRDCalibraFit.cxx:2630
 AliTRDCalibraFit.cxx:2631
 AliTRDCalibraFit.cxx:2632
 AliTRDCalibraFit.cxx:2633
 AliTRDCalibraFit.cxx:2634
 AliTRDCalibraFit.cxx:2635
 AliTRDCalibraFit.cxx:2636
 AliTRDCalibraFit.cxx:2637
 AliTRDCalibraFit.cxx:2638
 AliTRDCalibraFit.cxx:2639
 AliTRDCalibraFit.cxx:2640
 AliTRDCalibraFit.cxx:2641
 AliTRDCalibraFit.cxx:2642
 AliTRDCalibraFit.cxx:2643
 AliTRDCalibraFit.cxx:2644
 AliTRDCalibraFit.cxx:2645
 AliTRDCalibraFit.cxx:2646
 AliTRDCalibraFit.cxx:2647
 AliTRDCalibraFit.cxx:2648
 AliTRDCalibraFit.cxx:2649
 AliTRDCalibraFit.cxx:2650
 AliTRDCalibraFit.cxx:2651
 AliTRDCalibraFit.cxx:2652
 AliTRDCalibraFit.cxx:2653
 AliTRDCalibraFit.cxx:2654
 AliTRDCalibraFit.cxx:2655
 AliTRDCalibraFit.cxx:2656
 AliTRDCalibraFit.cxx:2657
 AliTRDCalibraFit.cxx:2658
 AliTRDCalibraFit.cxx:2659
 AliTRDCalibraFit.cxx:2660
 AliTRDCalibraFit.cxx:2661
 AliTRDCalibraFit.cxx:2662
 AliTRDCalibraFit.cxx:2663
 AliTRDCalibraFit.cxx:2664
 AliTRDCalibraFit.cxx:2665
 AliTRDCalibraFit.cxx:2666
 AliTRDCalibraFit.cxx:2667
 AliTRDCalibraFit.cxx:2668
 AliTRDCalibraFit.cxx:2669
 AliTRDCalibraFit.cxx:2670
 AliTRDCalibraFit.cxx:2671
 AliTRDCalibraFit.cxx:2672
 AliTRDCalibraFit.cxx:2673
 AliTRDCalibraFit.cxx:2674
 AliTRDCalibraFit.cxx:2675
 AliTRDCalibraFit.cxx:2676
 AliTRDCalibraFit.cxx:2677
 AliTRDCalibraFit.cxx:2678
 AliTRDCalibraFit.cxx:2679
 AliTRDCalibraFit.cxx:2680
 AliTRDCalibraFit.cxx:2681
 AliTRDCalibraFit.cxx:2682
 AliTRDCalibraFit.cxx:2683
 AliTRDCalibraFit.cxx:2684
 AliTRDCalibraFit.cxx:2685
 AliTRDCalibraFit.cxx:2686
 AliTRDCalibraFit.cxx:2687
 AliTRDCalibraFit.cxx:2688
 AliTRDCalibraFit.cxx:2689
 AliTRDCalibraFit.cxx:2690
 AliTRDCalibraFit.cxx:2691
 AliTRDCalibraFit.cxx:2692
 AliTRDCalibraFit.cxx:2693
 AliTRDCalibraFit.cxx:2694
 AliTRDCalibraFit.cxx:2695
 AliTRDCalibraFit.cxx:2696
 AliTRDCalibraFit.cxx:2697
 AliTRDCalibraFit.cxx:2698
 AliTRDCalibraFit.cxx:2699
 AliTRDCalibraFit.cxx:2700
 AliTRDCalibraFit.cxx:2701
 AliTRDCalibraFit.cxx:2702
 AliTRDCalibraFit.cxx:2703
 AliTRDCalibraFit.cxx:2704
 AliTRDCalibraFit.cxx:2705
 AliTRDCalibraFit.cxx:2706
 AliTRDCalibraFit.cxx:2707
 AliTRDCalibraFit.cxx:2708
 AliTRDCalibraFit.cxx:2709
 AliTRDCalibraFit.cxx:2710
 AliTRDCalibraFit.cxx:2711
 AliTRDCalibraFit.cxx:2712
 AliTRDCalibraFit.cxx:2713
 AliTRDCalibraFit.cxx:2714
 AliTRDCalibraFit.cxx:2715
 AliTRDCalibraFit.cxx:2716
 AliTRDCalibraFit.cxx:2717
 AliTRDCalibraFit.cxx:2718
 AliTRDCalibraFit.cxx:2719
 AliTRDCalibraFit.cxx:2720
 AliTRDCalibraFit.cxx:2721
 AliTRDCalibraFit.cxx:2722
 AliTRDCalibraFit.cxx:2723
 AliTRDCalibraFit.cxx:2724
 AliTRDCalibraFit.cxx:2725
 AliTRDCalibraFit.cxx:2726
 AliTRDCalibraFit.cxx:2727
 AliTRDCalibraFit.cxx:2728
 AliTRDCalibraFit.cxx:2729
 AliTRDCalibraFit.cxx:2730
 AliTRDCalibraFit.cxx:2731
 AliTRDCalibraFit.cxx:2732
 AliTRDCalibraFit.cxx:2733
 AliTRDCalibraFit.cxx:2734
 AliTRDCalibraFit.cxx:2735
 AliTRDCalibraFit.cxx:2736
 AliTRDCalibraFit.cxx:2737
 AliTRDCalibraFit.cxx:2738
 AliTRDCalibraFit.cxx:2739
 AliTRDCalibraFit.cxx:2740
 AliTRDCalibraFit.cxx:2741
 AliTRDCalibraFit.cxx:2742
 AliTRDCalibraFit.cxx:2743
 AliTRDCalibraFit.cxx:2744
 AliTRDCalibraFit.cxx:2745
 AliTRDCalibraFit.cxx:2746
 AliTRDCalibraFit.cxx:2747
 AliTRDCalibraFit.cxx:2748
 AliTRDCalibraFit.cxx:2749
 AliTRDCalibraFit.cxx:2750
 AliTRDCalibraFit.cxx:2751
 AliTRDCalibraFit.cxx:2752
 AliTRDCalibraFit.cxx:2753
 AliTRDCalibraFit.cxx:2754
 AliTRDCalibraFit.cxx:2755
 AliTRDCalibraFit.cxx:2756
 AliTRDCalibraFit.cxx:2757
 AliTRDCalibraFit.cxx:2758
 AliTRDCalibraFit.cxx:2759
 AliTRDCalibraFit.cxx:2760
 AliTRDCalibraFit.cxx:2761
 AliTRDCalibraFit.cxx:2762
 AliTRDCalibraFit.cxx:2763
 AliTRDCalibraFit.cxx:2764
 AliTRDCalibraFit.cxx:2765
 AliTRDCalibraFit.cxx:2766
 AliTRDCalibraFit.cxx:2767
 AliTRDCalibraFit.cxx:2768
 AliTRDCalibraFit.cxx:2769
 AliTRDCalibraFit.cxx:2770
 AliTRDCalibraFit.cxx:2771
 AliTRDCalibraFit.cxx:2772
 AliTRDCalibraFit.cxx:2773
 AliTRDCalibraFit.cxx:2774
 AliTRDCalibraFit.cxx:2775
 AliTRDCalibraFit.cxx:2776
 AliTRDCalibraFit.cxx:2777
 AliTRDCalibraFit.cxx:2778
 AliTRDCalibraFit.cxx:2779
 AliTRDCalibraFit.cxx:2780
 AliTRDCalibraFit.cxx:2781
 AliTRDCalibraFit.cxx:2782
 AliTRDCalibraFit.cxx:2783
 AliTRDCalibraFit.cxx:2784
 AliTRDCalibraFit.cxx:2785
 AliTRDCalibraFit.cxx:2786
 AliTRDCalibraFit.cxx:2787
 AliTRDCalibraFit.cxx:2788
 AliTRDCalibraFit.cxx:2789
 AliTRDCalibraFit.cxx:2790
 AliTRDCalibraFit.cxx:2791
 AliTRDCalibraFit.cxx:2792
 AliTRDCalibraFit.cxx:2793
 AliTRDCalibraFit.cxx:2794
 AliTRDCalibraFit.cxx:2795
 AliTRDCalibraFit.cxx:2796
 AliTRDCalibraFit.cxx:2797
 AliTRDCalibraFit.cxx:2798
 AliTRDCalibraFit.cxx:2799
 AliTRDCalibraFit.cxx:2800
 AliTRDCalibraFit.cxx:2801
 AliTRDCalibraFit.cxx:2802
 AliTRDCalibraFit.cxx:2803
 AliTRDCalibraFit.cxx:2804
 AliTRDCalibraFit.cxx:2805
 AliTRDCalibraFit.cxx:2806
 AliTRDCalibraFit.cxx:2807
 AliTRDCalibraFit.cxx:2808
 AliTRDCalibraFit.cxx:2809
 AliTRDCalibraFit.cxx:2810
 AliTRDCalibraFit.cxx:2811
 AliTRDCalibraFit.cxx:2812
 AliTRDCalibraFit.cxx:2813
 AliTRDCalibraFit.cxx:2814
 AliTRDCalibraFit.cxx:2815
 AliTRDCalibraFit.cxx:2816
 AliTRDCalibraFit.cxx:2817
 AliTRDCalibraFit.cxx:2818
 AliTRDCalibraFit.cxx:2819
 AliTRDCalibraFit.cxx:2820
 AliTRDCalibraFit.cxx:2821
 AliTRDCalibraFit.cxx:2822
 AliTRDCalibraFit.cxx:2823
 AliTRDCalibraFit.cxx:2824
 AliTRDCalibraFit.cxx:2825
 AliTRDCalibraFit.cxx:2826
 AliTRDCalibraFit.cxx:2827
 AliTRDCalibraFit.cxx:2828
 AliTRDCalibraFit.cxx:2829
 AliTRDCalibraFit.cxx:2830
 AliTRDCalibraFit.cxx:2831
 AliTRDCalibraFit.cxx:2832
 AliTRDCalibraFit.cxx:2833
 AliTRDCalibraFit.cxx:2834
 AliTRDCalibraFit.cxx:2835
 AliTRDCalibraFit.cxx:2836
 AliTRDCalibraFit.cxx:2837
 AliTRDCalibraFit.cxx:2838
 AliTRDCalibraFit.cxx:2839
 AliTRDCalibraFit.cxx:2840
 AliTRDCalibraFit.cxx:2841
 AliTRDCalibraFit.cxx:2842
 AliTRDCalibraFit.cxx:2843
 AliTRDCalibraFit.cxx:2844
 AliTRDCalibraFit.cxx:2845
 AliTRDCalibraFit.cxx:2846
 AliTRDCalibraFit.cxx:2847
 AliTRDCalibraFit.cxx:2848
 AliTRDCalibraFit.cxx:2849
 AliTRDCalibraFit.cxx:2850
 AliTRDCalibraFit.cxx:2851
 AliTRDCalibraFit.cxx:2852
 AliTRDCalibraFit.cxx:2853
 AliTRDCalibraFit.cxx:2854
 AliTRDCalibraFit.cxx:2855
 AliTRDCalibraFit.cxx:2856
 AliTRDCalibraFit.cxx:2857
 AliTRDCalibraFit.cxx:2858
 AliTRDCalibraFit.cxx:2859
 AliTRDCalibraFit.cxx:2860
 AliTRDCalibraFit.cxx:2861
 AliTRDCalibraFit.cxx:2862
 AliTRDCalibraFit.cxx:2863
 AliTRDCalibraFit.cxx:2864
 AliTRDCalibraFit.cxx:2865
 AliTRDCalibraFit.cxx:2866
 AliTRDCalibraFit.cxx:2867
 AliTRDCalibraFit.cxx:2868
 AliTRDCalibraFit.cxx:2869
 AliTRDCalibraFit.cxx:2870
 AliTRDCalibraFit.cxx:2871
 AliTRDCalibraFit.cxx:2872
 AliTRDCalibraFit.cxx:2873
 AliTRDCalibraFit.cxx:2874
 AliTRDCalibraFit.cxx:2875
 AliTRDCalibraFit.cxx:2876
 AliTRDCalibraFit.cxx:2877
 AliTRDCalibraFit.cxx:2878
 AliTRDCalibraFit.cxx:2879
 AliTRDCalibraFit.cxx:2880
 AliTRDCalibraFit.cxx:2881
 AliTRDCalibraFit.cxx:2882
 AliTRDCalibraFit.cxx:2883
 AliTRDCalibraFit.cxx:2884
 AliTRDCalibraFit.cxx:2885
 AliTRDCalibraFit.cxx:2886
 AliTRDCalibraFit.cxx:2887
 AliTRDCalibraFit.cxx:2888
 AliTRDCalibraFit.cxx:2889
 AliTRDCalibraFit.cxx:2890
 AliTRDCalibraFit.cxx:2891
 AliTRDCalibraFit.cxx:2892
 AliTRDCalibraFit.cxx:2893
 AliTRDCalibraFit.cxx:2894
 AliTRDCalibraFit.cxx:2895
 AliTRDCalibraFit.cxx:2896
 AliTRDCalibraFit.cxx:2897
 AliTRDCalibraFit.cxx:2898
 AliTRDCalibraFit.cxx:2899
 AliTRDCalibraFit.cxx:2900
 AliTRDCalibraFit.cxx:2901
 AliTRDCalibraFit.cxx:2902
 AliTRDCalibraFit.cxx:2903
 AliTRDCalibraFit.cxx:2904
 AliTRDCalibraFit.cxx:2905
 AliTRDCalibraFit.cxx:2906
 AliTRDCalibraFit.cxx:2907
 AliTRDCalibraFit.cxx:2908
 AliTRDCalibraFit.cxx:2909
 AliTRDCalibraFit.cxx:2910
 AliTRDCalibraFit.cxx:2911
 AliTRDCalibraFit.cxx:2912
 AliTRDCalibraFit.cxx:2913
 AliTRDCalibraFit.cxx:2914
 AliTRDCalibraFit.cxx:2915
 AliTRDCalibraFit.cxx:2916
 AliTRDCalibraFit.cxx:2917
 AliTRDCalibraFit.cxx:2918
 AliTRDCalibraFit.cxx:2919
 AliTRDCalibraFit.cxx:2920
 AliTRDCalibraFit.cxx:2921
 AliTRDCalibraFit.cxx:2922
 AliTRDCalibraFit.cxx:2923
 AliTRDCalibraFit.cxx:2924
 AliTRDCalibraFit.cxx:2925
 AliTRDCalibraFit.cxx:2926
 AliTRDCalibraFit.cxx:2927
 AliTRDCalibraFit.cxx:2928
 AliTRDCalibraFit.cxx:2929
 AliTRDCalibraFit.cxx:2930
 AliTRDCalibraFit.cxx:2931
 AliTRDCalibraFit.cxx:2932
 AliTRDCalibraFit.cxx:2933
 AliTRDCalibraFit.cxx:2934
 AliTRDCalibraFit.cxx:2935
 AliTRDCalibraFit.cxx:2936
 AliTRDCalibraFit.cxx:2937
 AliTRDCalibraFit.cxx:2938
 AliTRDCalibraFit.cxx:2939
 AliTRDCalibraFit.cxx:2940
 AliTRDCalibraFit.cxx:2941
 AliTRDCalibraFit.cxx:2942
 AliTRDCalibraFit.cxx:2943
 AliTRDCalibraFit.cxx:2944
 AliTRDCalibraFit.cxx:2945
 AliTRDCalibraFit.cxx:2946
 AliTRDCalibraFit.cxx:2947
 AliTRDCalibraFit.cxx:2948
 AliTRDCalibraFit.cxx:2949
 AliTRDCalibraFit.cxx:2950
 AliTRDCalibraFit.cxx:2951
 AliTRDCalibraFit.cxx:2952
 AliTRDCalibraFit.cxx:2953
 AliTRDCalibraFit.cxx:2954
 AliTRDCalibraFit.cxx:2955
 AliTRDCalibraFit.cxx:2956
 AliTRDCalibraFit.cxx:2957
 AliTRDCalibraFit.cxx:2958
 AliTRDCalibraFit.cxx:2959
 AliTRDCalibraFit.cxx:2960
 AliTRDCalibraFit.cxx:2961
 AliTRDCalibraFit.cxx:2962
 AliTRDCalibraFit.cxx:2963
 AliTRDCalibraFit.cxx:2964
 AliTRDCalibraFit.cxx:2965
 AliTRDCalibraFit.cxx:2966
 AliTRDCalibraFit.cxx:2967
 AliTRDCalibraFit.cxx:2968
 AliTRDCalibraFit.cxx:2969
 AliTRDCalibraFit.cxx:2970
 AliTRDCalibraFit.cxx:2971
 AliTRDCalibraFit.cxx:2972
 AliTRDCalibraFit.cxx:2973
 AliTRDCalibraFit.cxx:2974
 AliTRDCalibraFit.cxx:2975
 AliTRDCalibraFit.cxx:2976
 AliTRDCalibraFit.cxx:2977
 AliTRDCalibraFit.cxx:2978
 AliTRDCalibraFit.cxx:2979
 AliTRDCalibraFit.cxx:2980
 AliTRDCalibraFit.cxx:2981
 AliTRDCalibraFit.cxx:2982
 AliTRDCalibraFit.cxx:2983
 AliTRDCalibraFit.cxx:2984
 AliTRDCalibraFit.cxx:2985
 AliTRDCalibraFit.cxx:2986
 AliTRDCalibraFit.cxx:2987
 AliTRDCalibraFit.cxx:2988
 AliTRDCalibraFit.cxx:2989
 AliTRDCalibraFit.cxx:2990
 AliTRDCalibraFit.cxx:2991
 AliTRDCalibraFit.cxx:2992
 AliTRDCalibraFit.cxx:2993
 AliTRDCalibraFit.cxx:2994
 AliTRDCalibraFit.cxx:2995
 AliTRDCalibraFit.cxx:2996
 AliTRDCalibraFit.cxx:2997
 AliTRDCalibraFit.cxx:2998
 AliTRDCalibraFit.cxx:2999
 AliTRDCalibraFit.cxx:3000
 AliTRDCalibraFit.cxx:3001
 AliTRDCalibraFit.cxx:3002
 AliTRDCalibraFit.cxx:3003
 AliTRDCalibraFit.cxx:3004
 AliTRDCalibraFit.cxx:3005
 AliTRDCalibraFit.cxx:3006
 AliTRDCalibraFit.cxx:3007
 AliTRDCalibraFit.cxx:3008
 AliTRDCalibraFit.cxx:3009
 AliTRDCalibraFit.cxx:3010
 AliTRDCalibraFit.cxx:3011
 AliTRDCalibraFit.cxx:3012
 AliTRDCalibraFit.cxx:3013
 AliTRDCalibraFit.cxx:3014
 AliTRDCalibraFit.cxx:3015
 AliTRDCalibraFit.cxx:3016
 AliTRDCalibraFit.cxx:3017
 AliTRDCalibraFit.cxx:3018
 AliTRDCalibraFit.cxx:3019
 AliTRDCalibraFit.cxx:3020
 AliTRDCalibraFit.cxx:3021
 AliTRDCalibraFit.cxx:3022
 AliTRDCalibraFit.cxx:3023
 AliTRDCalibraFit.cxx:3024
 AliTRDCalibraFit.cxx:3025
 AliTRDCalibraFit.cxx:3026
 AliTRDCalibraFit.cxx:3027
 AliTRDCalibraFit.cxx:3028
 AliTRDCalibraFit.cxx:3029
 AliTRDCalibraFit.cxx:3030
 AliTRDCalibraFit.cxx:3031
 AliTRDCalibraFit.cxx:3032
 AliTRDCalibraFit.cxx:3033
 AliTRDCalibraFit.cxx:3034
 AliTRDCalibraFit.cxx:3035
 AliTRDCalibraFit.cxx:3036
 AliTRDCalibraFit.cxx:3037
 AliTRDCalibraFit.cxx:3038
 AliTRDCalibraFit.cxx:3039
 AliTRDCalibraFit.cxx:3040
 AliTRDCalibraFit.cxx:3041
 AliTRDCalibraFit.cxx:3042
 AliTRDCalibraFit.cxx:3043
 AliTRDCalibraFit.cxx:3044
 AliTRDCalibraFit.cxx:3045
 AliTRDCalibraFit.cxx:3046
 AliTRDCalibraFit.cxx:3047
 AliTRDCalibraFit.cxx:3048
 AliTRDCalibraFit.cxx:3049
 AliTRDCalibraFit.cxx:3050
 AliTRDCalibraFit.cxx:3051
 AliTRDCalibraFit.cxx:3052
 AliTRDCalibraFit.cxx:3053
 AliTRDCalibraFit.cxx:3054
 AliTRDCalibraFit.cxx:3055
 AliTRDCalibraFit.cxx:3056
 AliTRDCalibraFit.cxx:3057
 AliTRDCalibraFit.cxx:3058
 AliTRDCalibraFit.cxx:3059
 AliTRDCalibraFit.cxx:3060
 AliTRDCalibraFit.cxx:3061
 AliTRDCalibraFit.cxx:3062
 AliTRDCalibraFit.cxx:3063
 AliTRDCalibraFit.cxx:3064
 AliTRDCalibraFit.cxx:3065
 AliTRDCalibraFit.cxx:3066
 AliTRDCalibraFit.cxx:3067
 AliTRDCalibraFit.cxx:3068
 AliTRDCalibraFit.cxx:3069
 AliTRDCalibraFit.cxx:3070
 AliTRDCalibraFit.cxx:3071
 AliTRDCalibraFit.cxx:3072
 AliTRDCalibraFit.cxx:3073
 AliTRDCalibraFit.cxx:3074
 AliTRDCalibraFit.cxx:3075
 AliTRDCalibraFit.cxx:3076
 AliTRDCalibraFit.cxx:3077
 AliTRDCalibraFit.cxx:3078
 AliTRDCalibraFit.cxx:3079
 AliTRDCalibraFit.cxx:3080
 AliTRDCalibraFit.cxx:3081
 AliTRDCalibraFit.cxx:3082
 AliTRDCalibraFit.cxx:3083
 AliTRDCalibraFit.cxx:3084
 AliTRDCalibraFit.cxx:3085
 AliTRDCalibraFit.cxx:3086
 AliTRDCalibraFit.cxx:3087
 AliTRDCalibraFit.cxx:3088
 AliTRDCalibraFit.cxx:3089
 AliTRDCalibraFit.cxx:3090
 AliTRDCalibraFit.cxx:3091
 AliTRDCalibraFit.cxx:3092
 AliTRDCalibraFit.cxx:3093
 AliTRDCalibraFit.cxx:3094
 AliTRDCalibraFit.cxx:3095
 AliTRDCalibraFit.cxx:3096
 AliTRDCalibraFit.cxx:3097
 AliTRDCalibraFit.cxx:3098
 AliTRDCalibraFit.cxx:3099
 AliTRDCalibraFit.cxx:3100
 AliTRDCalibraFit.cxx:3101
 AliTRDCalibraFit.cxx:3102
 AliTRDCalibraFit.cxx:3103
 AliTRDCalibraFit.cxx:3104
 AliTRDCalibraFit.cxx:3105
 AliTRDCalibraFit.cxx:3106
 AliTRDCalibraFit.cxx:3107
 AliTRDCalibraFit.cxx:3108
 AliTRDCalibraFit.cxx:3109
 AliTRDCalibraFit.cxx:3110
 AliTRDCalibraFit.cxx:3111
 AliTRDCalibraFit.cxx:3112
 AliTRDCalibraFit.cxx:3113
 AliTRDCalibraFit.cxx:3114
 AliTRDCalibraFit.cxx:3115
 AliTRDCalibraFit.cxx:3116
 AliTRDCalibraFit.cxx:3117
 AliTRDCalibraFit.cxx:3118
 AliTRDCalibraFit.cxx:3119
 AliTRDCalibraFit.cxx:3120
 AliTRDCalibraFit.cxx:3121
 AliTRDCalibraFit.cxx:3122
 AliTRDCalibraFit.cxx:3123
 AliTRDCalibraFit.cxx:3124
 AliTRDCalibraFit.cxx:3125
 AliTRDCalibraFit.cxx:3126
 AliTRDCalibraFit.cxx:3127
 AliTRDCalibraFit.cxx:3128
 AliTRDCalibraFit.cxx:3129
 AliTRDCalibraFit.cxx:3130
 AliTRDCalibraFit.cxx:3131
 AliTRDCalibraFit.cxx:3132
 AliTRDCalibraFit.cxx:3133
 AliTRDCalibraFit.cxx:3134
 AliTRDCalibraFit.cxx:3135
 AliTRDCalibraFit.cxx:3136
 AliTRDCalibraFit.cxx:3137
 AliTRDCalibraFit.cxx:3138
 AliTRDCalibraFit.cxx:3139
 AliTRDCalibraFit.cxx:3140
 AliTRDCalibraFit.cxx:3141
 AliTRDCalibraFit.cxx:3142
 AliTRDCalibraFit.cxx:3143
 AliTRDCalibraFit.cxx:3144
 AliTRDCalibraFit.cxx:3145
 AliTRDCalibraFit.cxx:3146
 AliTRDCalibraFit.cxx:3147
 AliTRDCalibraFit.cxx:3148
 AliTRDCalibraFit.cxx:3149
 AliTRDCalibraFit.cxx:3150
 AliTRDCalibraFit.cxx:3151
 AliTRDCalibraFit.cxx:3152
 AliTRDCalibraFit.cxx:3153
 AliTRDCalibraFit.cxx:3154
 AliTRDCalibraFit.cxx:3155
 AliTRDCalibraFit.cxx:3156
 AliTRDCalibraFit.cxx:3157
 AliTRDCalibraFit.cxx:3158
 AliTRDCalibraFit.cxx:3159
 AliTRDCalibraFit.cxx:3160
 AliTRDCalibraFit.cxx:3161
 AliTRDCalibraFit.cxx:3162
 AliTRDCalibraFit.cxx:3163
 AliTRDCalibraFit.cxx:3164
 AliTRDCalibraFit.cxx:3165
 AliTRDCalibraFit.cxx:3166
 AliTRDCalibraFit.cxx:3167
 AliTRDCalibraFit.cxx:3168
 AliTRDCalibraFit.cxx:3169
 AliTRDCalibraFit.cxx:3170
 AliTRDCalibraFit.cxx:3171
 AliTRDCalibraFit.cxx:3172
 AliTRDCalibraFit.cxx:3173
 AliTRDCalibraFit.cxx:3174
 AliTRDCalibraFit.cxx:3175
 AliTRDCalibraFit.cxx:3176
 AliTRDCalibraFit.cxx:3177
 AliTRDCalibraFit.cxx:3178
 AliTRDCalibraFit.cxx:3179
 AliTRDCalibraFit.cxx:3180
 AliTRDCalibraFit.cxx:3181
 AliTRDCalibraFit.cxx:3182
 AliTRDCalibraFit.cxx:3183
 AliTRDCalibraFit.cxx:3184
 AliTRDCalibraFit.cxx:3185
 AliTRDCalibraFit.cxx:3186
 AliTRDCalibraFit.cxx:3187
 AliTRDCalibraFit.cxx:3188
 AliTRDCalibraFit.cxx:3189
 AliTRDCalibraFit.cxx:3190
 AliTRDCalibraFit.cxx:3191
 AliTRDCalibraFit.cxx:3192
 AliTRDCalibraFit.cxx:3193
 AliTRDCalibraFit.cxx:3194
 AliTRDCalibraFit.cxx:3195
 AliTRDCalibraFit.cxx:3196
 AliTRDCalibraFit.cxx:3197
 AliTRDCalibraFit.cxx:3198
 AliTRDCalibraFit.cxx:3199
 AliTRDCalibraFit.cxx:3200
 AliTRDCalibraFit.cxx:3201
 AliTRDCalibraFit.cxx:3202
 AliTRDCalibraFit.cxx:3203
 AliTRDCalibraFit.cxx:3204
 AliTRDCalibraFit.cxx:3205
 AliTRDCalibraFit.cxx:3206
 AliTRDCalibraFit.cxx:3207
 AliTRDCalibraFit.cxx:3208
 AliTRDCalibraFit.cxx:3209
 AliTRDCalibraFit.cxx:3210
 AliTRDCalibraFit.cxx:3211
 AliTRDCalibraFit.cxx:3212
 AliTRDCalibraFit.cxx:3213
 AliTRDCalibraFit.cxx:3214
 AliTRDCalibraFit.cxx:3215
 AliTRDCalibraFit.cxx:3216
 AliTRDCalibraFit.cxx:3217
 AliTRDCalibraFit.cxx:3218
 AliTRDCalibraFit.cxx:3219
 AliTRDCalibraFit.cxx:3220
 AliTRDCalibraFit.cxx:3221
 AliTRDCalibraFit.cxx:3222
 AliTRDCalibraFit.cxx:3223
 AliTRDCalibraFit.cxx:3224
 AliTRDCalibraFit.cxx:3225
 AliTRDCalibraFit.cxx:3226
 AliTRDCalibraFit.cxx:3227
 AliTRDCalibraFit.cxx:3228
 AliTRDCalibraFit.cxx:3229
 AliTRDCalibraFit.cxx:3230
 AliTRDCalibraFit.cxx:3231
 AliTRDCalibraFit.cxx:3232
 AliTRDCalibraFit.cxx:3233
 AliTRDCalibraFit.cxx:3234
 AliTRDCalibraFit.cxx:3235
 AliTRDCalibraFit.cxx:3236
 AliTRDCalibraFit.cxx:3237
 AliTRDCalibraFit.cxx:3238
 AliTRDCalibraFit.cxx:3239
 AliTRDCalibraFit.cxx:3240
 AliTRDCalibraFit.cxx:3241
 AliTRDCalibraFit.cxx:3242
 AliTRDCalibraFit.cxx:3243
 AliTRDCalibraFit.cxx:3244
 AliTRDCalibraFit.cxx:3245
 AliTRDCalibraFit.cxx:3246
 AliTRDCalibraFit.cxx:3247
 AliTRDCalibraFit.cxx:3248
 AliTRDCalibraFit.cxx:3249
 AliTRDCalibraFit.cxx:3250
 AliTRDCalibraFit.cxx:3251
 AliTRDCalibraFit.cxx:3252
 AliTRDCalibraFit.cxx:3253
 AliTRDCalibraFit.cxx:3254
 AliTRDCalibraFit.cxx:3255
 AliTRDCalibraFit.cxx:3256
 AliTRDCalibraFit.cxx:3257
 AliTRDCalibraFit.cxx:3258
 AliTRDCalibraFit.cxx:3259
 AliTRDCalibraFit.cxx:3260
 AliTRDCalibraFit.cxx:3261
 AliTRDCalibraFit.cxx:3262
 AliTRDCalibraFit.cxx:3263
 AliTRDCalibraFit.cxx:3264
 AliTRDCalibraFit.cxx:3265
 AliTRDCalibraFit.cxx:3266
 AliTRDCalibraFit.cxx:3267
 AliTRDCalibraFit.cxx:3268
 AliTRDCalibraFit.cxx:3269
 AliTRDCalibraFit.cxx:3270
 AliTRDCalibraFit.cxx:3271
 AliTRDCalibraFit.cxx:3272
 AliTRDCalibraFit.cxx:3273
 AliTRDCalibraFit.cxx:3274
 AliTRDCalibraFit.cxx:3275
 AliTRDCalibraFit.cxx:3276
 AliTRDCalibraFit.cxx:3277
 AliTRDCalibraFit.cxx:3278
 AliTRDCalibraFit.cxx:3279
 AliTRDCalibraFit.cxx:3280
 AliTRDCalibraFit.cxx:3281
 AliTRDCalibraFit.cxx:3282
 AliTRDCalibraFit.cxx:3283
 AliTRDCalibraFit.cxx:3284
 AliTRDCalibraFit.cxx:3285
 AliTRDCalibraFit.cxx:3286
 AliTRDCalibraFit.cxx:3287
 AliTRDCalibraFit.cxx:3288
 AliTRDCalibraFit.cxx:3289
 AliTRDCalibraFit.cxx:3290
 AliTRDCalibraFit.cxx:3291
 AliTRDCalibraFit.cxx:3292
 AliTRDCalibraFit.cxx:3293
 AliTRDCalibraFit.cxx:3294
 AliTRDCalibraFit.cxx:3295
 AliTRDCalibraFit.cxx:3296
 AliTRDCalibraFit.cxx:3297
 AliTRDCalibraFit.cxx:3298
 AliTRDCalibraFit.cxx:3299
 AliTRDCalibraFit.cxx:3300
 AliTRDCalibraFit.cxx:3301
 AliTRDCalibraFit.cxx:3302
 AliTRDCalibraFit.cxx:3303
 AliTRDCalibraFit.cxx:3304
 AliTRDCalibraFit.cxx:3305
 AliTRDCalibraFit.cxx:3306
 AliTRDCalibraFit.cxx:3307
 AliTRDCalibraFit.cxx:3308
 AliTRDCalibraFit.cxx:3309
 AliTRDCalibraFit.cxx:3310
 AliTRDCalibraFit.cxx:3311
 AliTRDCalibraFit.cxx:3312
 AliTRDCalibraFit.cxx:3313
 AliTRDCalibraFit.cxx:3314
 AliTRDCalibraFit.cxx:3315
 AliTRDCalibraFit.cxx:3316
 AliTRDCalibraFit.cxx:3317
 AliTRDCalibraFit.cxx:3318
 AliTRDCalibraFit.cxx:3319
 AliTRDCalibraFit.cxx:3320
 AliTRDCalibraFit.cxx:3321
 AliTRDCalibraFit.cxx:3322
 AliTRDCalibraFit.cxx:3323
 AliTRDCalibraFit.cxx:3324
 AliTRDCalibraFit.cxx:3325
 AliTRDCalibraFit.cxx:3326
 AliTRDCalibraFit.cxx:3327
 AliTRDCalibraFit.cxx:3328
 AliTRDCalibraFit.cxx:3329
 AliTRDCalibraFit.cxx:3330
 AliTRDCalibraFit.cxx:3331
 AliTRDCalibraFit.cxx:3332
 AliTRDCalibraFit.cxx:3333
 AliTRDCalibraFit.cxx:3334
 AliTRDCalibraFit.cxx:3335
 AliTRDCalibraFit.cxx:3336
 AliTRDCalibraFit.cxx:3337
 AliTRDCalibraFit.cxx:3338
 AliTRDCalibraFit.cxx:3339
 AliTRDCalibraFit.cxx:3340
 AliTRDCalibraFit.cxx:3341
 AliTRDCalibraFit.cxx:3342
 AliTRDCalibraFit.cxx:3343
 AliTRDCalibraFit.cxx:3344
 AliTRDCalibraFit.cxx:3345
 AliTRDCalibraFit.cxx:3346
 AliTRDCalibraFit.cxx:3347
 AliTRDCalibraFit.cxx:3348
 AliTRDCalibraFit.cxx:3349
 AliTRDCalibraFit.cxx:3350
 AliTRDCalibraFit.cxx:3351
 AliTRDCalibraFit.cxx:3352
 AliTRDCalibraFit.cxx:3353
 AliTRDCalibraFit.cxx:3354
 AliTRDCalibraFit.cxx:3355
 AliTRDCalibraFit.cxx:3356
 AliTRDCalibraFit.cxx:3357
 AliTRDCalibraFit.cxx:3358
 AliTRDCalibraFit.cxx:3359
 AliTRDCalibraFit.cxx:3360
 AliTRDCalibraFit.cxx:3361
 AliTRDCalibraFit.cxx:3362
 AliTRDCalibraFit.cxx:3363
 AliTRDCalibraFit.cxx:3364
 AliTRDCalibraFit.cxx:3365
 AliTRDCalibraFit.cxx:3366
 AliTRDCalibraFit.cxx:3367
 AliTRDCalibraFit.cxx:3368
 AliTRDCalibraFit.cxx:3369
 AliTRDCalibraFit.cxx:3370
 AliTRDCalibraFit.cxx:3371
 AliTRDCalibraFit.cxx:3372
 AliTRDCalibraFit.cxx:3373
 AliTRDCalibraFit.cxx:3374
 AliTRDCalibraFit.cxx:3375
 AliTRDCalibraFit.cxx:3376
 AliTRDCalibraFit.cxx:3377
 AliTRDCalibraFit.cxx:3378
 AliTRDCalibraFit.cxx:3379
 AliTRDCalibraFit.cxx:3380
 AliTRDCalibraFit.cxx:3381
 AliTRDCalibraFit.cxx:3382
 AliTRDCalibraFit.cxx:3383
 AliTRDCalibraFit.cxx:3384
 AliTRDCalibraFit.cxx:3385
 AliTRDCalibraFit.cxx:3386
 AliTRDCalibraFit.cxx:3387
 AliTRDCalibraFit.cxx:3388
 AliTRDCalibraFit.cxx:3389
 AliTRDCalibraFit.cxx:3390
 AliTRDCalibraFit.cxx:3391
 AliTRDCalibraFit.cxx:3392
 AliTRDCalibraFit.cxx:3393
 AliTRDCalibraFit.cxx:3394
 AliTRDCalibraFit.cxx:3395
 AliTRDCalibraFit.cxx:3396
 AliTRDCalibraFit.cxx:3397
 AliTRDCalibraFit.cxx:3398
 AliTRDCalibraFit.cxx:3399
 AliTRDCalibraFit.cxx:3400
 AliTRDCalibraFit.cxx:3401
 AliTRDCalibraFit.cxx:3402
 AliTRDCalibraFit.cxx:3403
 AliTRDCalibraFit.cxx:3404
 AliTRDCalibraFit.cxx:3405
 AliTRDCalibraFit.cxx:3406
 AliTRDCalibraFit.cxx:3407
 AliTRDCalibraFit.cxx:3408
 AliTRDCalibraFit.cxx:3409
 AliTRDCalibraFit.cxx:3410
 AliTRDCalibraFit.cxx:3411
 AliTRDCalibraFit.cxx:3412
 AliTRDCalibraFit.cxx:3413
 AliTRDCalibraFit.cxx:3414
 AliTRDCalibraFit.cxx:3415
 AliTRDCalibraFit.cxx:3416
 AliTRDCalibraFit.cxx:3417
 AliTRDCalibraFit.cxx:3418
 AliTRDCalibraFit.cxx:3419
 AliTRDCalibraFit.cxx:3420
 AliTRDCalibraFit.cxx:3421
 AliTRDCalibraFit.cxx:3422
 AliTRDCalibraFit.cxx:3423
 AliTRDCalibraFit.cxx:3424
 AliTRDCalibraFit.cxx:3425
 AliTRDCalibraFit.cxx:3426
 AliTRDCalibraFit.cxx:3427
 AliTRDCalibraFit.cxx:3428
 AliTRDCalibraFit.cxx:3429
 AliTRDCalibraFit.cxx:3430
 AliTRDCalibraFit.cxx:3431
 AliTRDCalibraFit.cxx:3432
 AliTRDCalibraFit.cxx:3433
 AliTRDCalibraFit.cxx:3434
 AliTRDCalibraFit.cxx:3435
 AliTRDCalibraFit.cxx:3436
 AliTRDCalibraFit.cxx:3437
 AliTRDCalibraFit.cxx:3438
 AliTRDCalibraFit.cxx:3439
 AliTRDCalibraFit.cxx:3440
 AliTRDCalibraFit.cxx:3441
 AliTRDCalibraFit.cxx:3442
 AliTRDCalibraFit.cxx:3443
 AliTRDCalibraFit.cxx:3444
 AliTRDCalibraFit.cxx:3445
 AliTRDCalibraFit.cxx:3446
 AliTRDCalibraFit.cxx:3447
 AliTRDCalibraFit.cxx:3448
 AliTRDCalibraFit.cxx:3449
 AliTRDCalibraFit.cxx:3450
 AliTRDCalibraFit.cxx:3451
 AliTRDCalibraFit.cxx:3452
 AliTRDCalibraFit.cxx:3453
 AliTRDCalibraFit.cxx:3454
 AliTRDCalibraFit.cxx:3455
 AliTRDCalibraFit.cxx:3456
 AliTRDCalibraFit.cxx:3457
 AliTRDCalibraFit.cxx:3458
 AliTRDCalibraFit.cxx:3459
 AliTRDCalibraFit.cxx:3460
 AliTRDCalibraFit.cxx:3461
 AliTRDCalibraFit.cxx:3462
 AliTRDCalibraFit.cxx:3463
 AliTRDCalibraFit.cxx:3464
 AliTRDCalibraFit.cxx:3465
 AliTRDCalibraFit.cxx:3466
 AliTRDCalibraFit.cxx:3467
 AliTRDCalibraFit.cxx:3468
 AliTRDCalibraFit.cxx:3469
 AliTRDCalibraFit.cxx:3470
 AliTRDCalibraFit.cxx:3471
 AliTRDCalibraFit.cxx:3472
 AliTRDCalibraFit.cxx:3473
 AliTRDCalibraFit.cxx:3474
 AliTRDCalibraFit.cxx:3475
 AliTRDCalibraFit.cxx:3476
 AliTRDCalibraFit.cxx:3477
 AliTRDCalibraFit.cxx:3478
 AliTRDCalibraFit.cxx:3479
 AliTRDCalibraFit.cxx:3480
 AliTRDCalibraFit.cxx:3481
 AliTRDCalibraFit.cxx:3482
 AliTRDCalibraFit.cxx:3483
 AliTRDCalibraFit.cxx:3484
 AliTRDCalibraFit.cxx:3485
 AliTRDCalibraFit.cxx:3486
 AliTRDCalibraFit.cxx:3487
 AliTRDCalibraFit.cxx:3488
 AliTRDCalibraFit.cxx:3489
 AliTRDCalibraFit.cxx:3490
 AliTRDCalibraFit.cxx:3491
 AliTRDCalibraFit.cxx:3492
 AliTRDCalibraFit.cxx:3493
 AliTRDCalibraFit.cxx:3494
 AliTRDCalibraFit.cxx:3495
 AliTRDCalibraFit.cxx:3496
 AliTRDCalibraFit.cxx:3497
 AliTRDCalibraFit.cxx:3498
 AliTRDCalibraFit.cxx:3499
 AliTRDCalibraFit.cxx:3500
 AliTRDCalibraFit.cxx:3501
 AliTRDCalibraFit.cxx:3502
 AliTRDCalibraFit.cxx:3503
 AliTRDCalibraFit.cxx:3504
 AliTRDCalibraFit.cxx:3505
 AliTRDCalibraFit.cxx:3506
 AliTRDCalibraFit.cxx:3507
 AliTRDCalibraFit.cxx:3508
 AliTRDCalibraFit.cxx:3509
 AliTRDCalibraFit.cxx:3510
 AliTRDCalibraFit.cxx:3511
 AliTRDCalibraFit.cxx:3512
 AliTRDCalibraFit.cxx:3513
 AliTRDCalibraFit.cxx:3514
 AliTRDCalibraFit.cxx:3515
 AliTRDCalibraFit.cxx:3516
 AliTRDCalibraFit.cxx:3517
 AliTRDCalibraFit.cxx:3518
 AliTRDCalibraFit.cxx:3519
 AliTRDCalibraFit.cxx:3520
 AliTRDCalibraFit.cxx:3521
 AliTRDCalibraFit.cxx:3522
 AliTRDCalibraFit.cxx:3523
 AliTRDCalibraFit.cxx:3524
 AliTRDCalibraFit.cxx:3525
 AliTRDCalibraFit.cxx:3526
 AliTRDCalibraFit.cxx:3527
 AliTRDCalibraFit.cxx:3528
 AliTRDCalibraFit.cxx:3529
 AliTRDCalibraFit.cxx:3530
 AliTRDCalibraFit.cxx:3531
 AliTRDCalibraFit.cxx:3532
 AliTRDCalibraFit.cxx:3533
 AliTRDCalibraFit.cxx:3534
 AliTRDCalibraFit.cxx:3535
 AliTRDCalibraFit.cxx:3536
 AliTRDCalibraFit.cxx:3537
 AliTRDCalibraFit.cxx:3538
 AliTRDCalibraFit.cxx:3539
 AliTRDCalibraFit.cxx:3540
 AliTRDCalibraFit.cxx:3541
 AliTRDCalibraFit.cxx:3542
 AliTRDCalibraFit.cxx:3543
 AliTRDCalibraFit.cxx:3544
 AliTRDCalibraFit.cxx:3545
 AliTRDCalibraFit.cxx:3546
 AliTRDCalibraFit.cxx:3547
 AliTRDCalibraFit.cxx:3548
 AliTRDCalibraFit.cxx:3549
 AliTRDCalibraFit.cxx:3550
 AliTRDCalibraFit.cxx:3551
 AliTRDCalibraFit.cxx:3552
 AliTRDCalibraFit.cxx:3553
 AliTRDCalibraFit.cxx:3554
 AliTRDCalibraFit.cxx:3555
 AliTRDCalibraFit.cxx:3556
 AliTRDCalibraFit.cxx:3557
 AliTRDCalibraFit.cxx:3558
 AliTRDCalibraFit.cxx:3559
 AliTRDCalibraFit.cxx:3560
 AliTRDCalibraFit.cxx:3561
 AliTRDCalibraFit.cxx:3562
 AliTRDCalibraFit.cxx:3563
 AliTRDCalibraFit.cxx:3564
 AliTRDCalibraFit.cxx:3565
 AliTRDCalibraFit.cxx:3566
 AliTRDCalibraFit.cxx:3567
 AliTRDCalibraFit.cxx:3568
 AliTRDCalibraFit.cxx:3569
 AliTRDCalibraFit.cxx:3570
 AliTRDCalibraFit.cxx:3571
 AliTRDCalibraFit.cxx:3572
 AliTRDCalibraFit.cxx:3573
 AliTRDCalibraFit.cxx:3574
 AliTRDCalibraFit.cxx:3575
 AliTRDCalibraFit.cxx:3576
 AliTRDCalibraFit.cxx:3577
 AliTRDCalibraFit.cxx:3578
 AliTRDCalibraFit.cxx:3579
 AliTRDCalibraFit.cxx:3580
 AliTRDCalibraFit.cxx:3581
 AliTRDCalibraFit.cxx:3582
 AliTRDCalibraFit.cxx:3583
 AliTRDCalibraFit.cxx:3584
 AliTRDCalibraFit.cxx:3585
 AliTRDCalibraFit.cxx:3586
 AliTRDCalibraFit.cxx:3587
 AliTRDCalibraFit.cxx:3588
 AliTRDCalibraFit.cxx:3589
 AliTRDCalibraFit.cxx:3590
 AliTRDCalibraFit.cxx:3591
 AliTRDCalibraFit.cxx:3592
 AliTRDCalibraFit.cxx:3593
 AliTRDCalibraFit.cxx:3594
 AliTRDCalibraFit.cxx:3595
 AliTRDCalibraFit.cxx:3596
 AliTRDCalibraFit.cxx:3597
 AliTRDCalibraFit.cxx:3598
 AliTRDCalibraFit.cxx:3599
 AliTRDCalibraFit.cxx:3600
 AliTRDCalibraFit.cxx:3601
 AliTRDCalibraFit.cxx:3602
 AliTRDCalibraFit.cxx:3603
 AliTRDCalibraFit.cxx:3604
 AliTRDCalibraFit.cxx:3605
 AliTRDCalibraFit.cxx:3606
 AliTRDCalibraFit.cxx:3607
 AliTRDCalibraFit.cxx:3608
 AliTRDCalibraFit.cxx:3609
 AliTRDCalibraFit.cxx:3610
 AliTRDCalibraFit.cxx:3611
 AliTRDCalibraFit.cxx:3612
 AliTRDCalibraFit.cxx:3613
 AliTRDCalibraFit.cxx:3614
 AliTRDCalibraFit.cxx:3615
 AliTRDCalibraFit.cxx:3616
 AliTRDCalibraFit.cxx:3617
 AliTRDCalibraFit.cxx:3618
 AliTRDCalibraFit.cxx:3619
 AliTRDCalibraFit.cxx:3620
 AliTRDCalibraFit.cxx:3621
 AliTRDCalibraFit.cxx:3622
 AliTRDCalibraFit.cxx:3623
 AliTRDCalibraFit.cxx:3624
 AliTRDCalibraFit.cxx:3625
 AliTRDCalibraFit.cxx:3626
 AliTRDCalibraFit.cxx:3627
 AliTRDCalibraFit.cxx:3628
 AliTRDCalibraFit.cxx:3629
 AliTRDCalibraFit.cxx:3630
 AliTRDCalibraFit.cxx:3631
 AliTRDCalibraFit.cxx:3632
 AliTRDCalibraFit.cxx:3633
 AliTRDCalibraFit.cxx:3634
 AliTRDCalibraFit.cxx:3635
 AliTRDCalibraFit.cxx:3636
 AliTRDCalibraFit.cxx:3637
 AliTRDCalibraFit.cxx:3638
 AliTRDCalibraFit.cxx:3639
 AliTRDCalibraFit.cxx:3640
 AliTRDCalibraFit.cxx:3641
 AliTRDCalibraFit.cxx:3642
 AliTRDCalibraFit.cxx:3643
 AliTRDCalibraFit.cxx:3644
 AliTRDCalibraFit.cxx:3645
 AliTRDCalibraFit.cxx:3646
 AliTRDCalibraFit.cxx:3647
 AliTRDCalibraFit.cxx:3648
 AliTRDCalibraFit.cxx:3649
 AliTRDCalibraFit.cxx:3650
 AliTRDCalibraFit.cxx:3651
 AliTRDCalibraFit.cxx:3652
 AliTRDCalibraFit.cxx:3653
 AliTRDCalibraFit.cxx:3654
 AliTRDCalibraFit.cxx:3655
 AliTRDCalibraFit.cxx:3656
 AliTRDCalibraFit.cxx:3657
 AliTRDCalibraFit.cxx:3658
 AliTRDCalibraFit.cxx:3659
 AliTRDCalibraFit.cxx:3660
 AliTRDCalibraFit.cxx:3661
 AliTRDCalibraFit.cxx:3662
 AliTRDCalibraFit.cxx:3663
 AliTRDCalibraFit.cxx:3664
 AliTRDCalibraFit.cxx:3665
 AliTRDCalibraFit.cxx:3666
 AliTRDCalibraFit.cxx:3667
 AliTRDCalibraFit.cxx:3668
 AliTRDCalibraFit.cxx:3669
 AliTRDCalibraFit.cxx:3670
 AliTRDCalibraFit.cxx:3671
 AliTRDCalibraFit.cxx:3672
 AliTRDCalibraFit.cxx:3673
 AliTRDCalibraFit.cxx:3674
 AliTRDCalibraFit.cxx:3675
 AliTRDCalibraFit.cxx:3676
 AliTRDCalibraFit.cxx:3677
 AliTRDCalibraFit.cxx:3678
 AliTRDCalibraFit.cxx:3679
 AliTRDCalibraFit.cxx:3680
 AliTRDCalibraFit.cxx:3681
 AliTRDCalibraFit.cxx:3682
 AliTRDCalibraFit.cxx:3683
 AliTRDCalibraFit.cxx:3684
 AliTRDCalibraFit.cxx:3685
 AliTRDCalibraFit.cxx:3686
 AliTRDCalibraFit.cxx:3687
 AliTRDCalibraFit.cxx:3688
 AliTRDCalibraFit.cxx:3689
 AliTRDCalibraFit.cxx:3690
 AliTRDCalibraFit.cxx:3691
 AliTRDCalibraFit.cxx:3692
 AliTRDCalibraFit.cxx:3693
 AliTRDCalibraFit.cxx:3694
 AliTRDCalibraFit.cxx:3695
 AliTRDCalibraFit.cxx:3696
 AliTRDCalibraFit.cxx:3697
 AliTRDCalibraFit.cxx:3698
 AliTRDCalibraFit.cxx:3699
 AliTRDCalibraFit.cxx:3700
 AliTRDCalibraFit.cxx:3701
 AliTRDCalibraFit.cxx:3702
 AliTRDCalibraFit.cxx:3703
 AliTRDCalibraFit.cxx:3704
 AliTRDCalibraFit.cxx:3705
 AliTRDCalibraFit.cxx:3706
 AliTRDCalibraFit.cxx:3707
 AliTRDCalibraFit.cxx:3708
 AliTRDCalibraFit.cxx:3709
 AliTRDCalibraFit.cxx:3710
 AliTRDCalibraFit.cxx:3711
 AliTRDCalibraFit.cxx:3712
 AliTRDCalibraFit.cxx:3713
 AliTRDCalibraFit.cxx:3714
 AliTRDCalibraFit.cxx:3715
 AliTRDCalibraFit.cxx:3716
 AliTRDCalibraFit.cxx:3717
 AliTRDCalibraFit.cxx:3718
 AliTRDCalibraFit.cxx:3719
 AliTRDCalibraFit.cxx:3720
 AliTRDCalibraFit.cxx:3721
 AliTRDCalibraFit.cxx:3722
 AliTRDCalibraFit.cxx:3723
 AliTRDCalibraFit.cxx:3724
 AliTRDCalibraFit.cxx:3725
 AliTRDCalibraFit.cxx:3726
 AliTRDCalibraFit.cxx:3727
 AliTRDCalibraFit.cxx:3728
 AliTRDCalibraFit.cxx:3729
 AliTRDCalibraFit.cxx:3730
 AliTRDCalibraFit.cxx:3731
 AliTRDCalibraFit.cxx:3732
 AliTRDCalibraFit.cxx:3733
 AliTRDCalibraFit.cxx:3734
 AliTRDCalibraFit.cxx:3735
 AliTRDCalibraFit.cxx:3736
 AliTRDCalibraFit.cxx:3737
 AliTRDCalibraFit.cxx:3738
 AliTRDCalibraFit.cxx:3739
 AliTRDCalibraFit.cxx:3740
 AliTRDCalibraFit.cxx:3741
 AliTRDCalibraFit.cxx:3742
 AliTRDCalibraFit.cxx:3743
 AliTRDCalibraFit.cxx:3744
 AliTRDCalibraFit.cxx:3745
 AliTRDCalibraFit.cxx:3746
 AliTRDCalibraFit.cxx:3747
 AliTRDCalibraFit.cxx:3748
 AliTRDCalibraFit.cxx:3749
 AliTRDCalibraFit.cxx:3750
 AliTRDCalibraFit.cxx:3751
 AliTRDCalibraFit.cxx:3752
 AliTRDCalibraFit.cxx:3753
 AliTRDCalibraFit.cxx:3754
 AliTRDCalibraFit.cxx:3755
 AliTRDCalibraFit.cxx:3756
 AliTRDCalibraFit.cxx:3757
 AliTRDCalibraFit.cxx:3758
 AliTRDCalibraFit.cxx:3759
 AliTRDCalibraFit.cxx:3760
 AliTRDCalibraFit.cxx:3761
 AliTRDCalibraFit.cxx:3762
 AliTRDCalibraFit.cxx:3763
 AliTRDCalibraFit.cxx:3764
 AliTRDCalibraFit.cxx:3765
 AliTRDCalibraFit.cxx:3766
 AliTRDCalibraFit.cxx:3767
 AliTRDCalibraFit.cxx:3768
 AliTRDCalibraFit.cxx:3769
 AliTRDCalibraFit.cxx:3770
 AliTRDCalibraFit.cxx:3771
 AliTRDCalibraFit.cxx:3772
 AliTRDCalibraFit.cxx:3773
 AliTRDCalibraFit.cxx:3774
 AliTRDCalibraFit.cxx:3775
 AliTRDCalibraFit.cxx:3776
 AliTRDCalibraFit.cxx:3777
 AliTRDCalibraFit.cxx:3778
 AliTRDCalibraFit.cxx:3779
 AliTRDCalibraFit.cxx:3780
 AliTRDCalibraFit.cxx:3781
 AliTRDCalibraFit.cxx:3782
 AliTRDCalibraFit.cxx:3783
 AliTRDCalibraFit.cxx:3784
 AliTRDCalibraFit.cxx:3785
 AliTRDCalibraFit.cxx:3786
 AliTRDCalibraFit.cxx:3787
 AliTRDCalibraFit.cxx:3788
 AliTRDCalibraFit.cxx:3789
 AliTRDCalibraFit.cxx:3790
 AliTRDCalibraFit.cxx:3791
 AliTRDCalibraFit.cxx:3792
 AliTRDCalibraFit.cxx:3793
 AliTRDCalibraFit.cxx:3794
 AliTRDCalibraFit.cxx:3795
 AliTRDCalibraFit.cxx:3796
 AliTRDCalibraFit.cxx:3797
 AliTRDCalibraFit.cxx:3798
 AliTRDCalibraFit.cxx:3799
 AliTRDCalibraFit.cxx:3800
 AliTRDCalibraFit.cxx:3801
 AliTRDCalibraFit.cxx:3802
 AliTRDCalibraFit.cxx:3803
 AliTRDCalibraFit.cxx:3804
 AliTRDCalibraFit.cxx:3805
 AliTRDCalibraFit.cxx:3806
 AliTRDCalibraFit.cxx:3807
 AliTRDCalibraFit.cxx:3808
 AliTRDCalibraFit.cxx:3809
 AliTRDCalibraFit.cxx:3810
 AliTRDCalibraFit.cxx:3811
 AliTRDCalibraFit.cxx:3812
 AliTRDCalibraFit.cxx:3813
 AliTRDCalibraFit.cxx:3814
 AliTRDCalibraFit.cxx:3815
 AliTRDCalibraFit.cxx:3816
 AliTRDCalibraFit.cxx:3817
 AliTRDCalibraFit.cxx:3818
 AliTRDCalibraFit.cxx:3819
 AliTRDCalibraFit.cxx:3820
 AliTRDCalibraFit.cxx:3821
 AliTRDCalibraFit.cxx:3822
 AliTRDCalibraFit.cxx:3823
 AliTRDCalibraFit.cxx:3824
 AliTRDCalibraFit.cxx:3825
 AliTRDCalibraFit.cxx:3826
 AliTRDCalibraFit.cxx:3827
 AliTRDCalibraFit.cxx:3828
 AliTRDCalibraFit.cxx:3829
 AliTRDCalibraFit.cxx:3830
 AliTRDCalibraFit.cxx:3831
 AliTRDCalibraFit.cxx:3832
 AliTRDCalibraFit.cxx:3833
 AliTRDCalibraFit.cxx:3834
 AliTRDCalibraFit.cxx:3835
 AliTRDCalibraFit.cxx:3836
 AliTRDCalibraFit.cxx:3837
 AliTRDCalibraFit.cxx:3838
 AliTRDCalibraFit.cxx:3839
 AliTRDCalibraFit.cxx:3840
 AliTRDCalibraFit.cxx:3841
 AliTRDCalibraFit.cxx:3842
 AliTRDCalibraFit.cxx:3843
 AliTRDCalibraFit.cxx:3844
 AliTRDCalibraFit.cxx:3845
 AliTRDCalibraFit.cxx:3846
 AliTRDCalibraFit.cxx:3847
 AliTRDCalibraFit.cxx:3848
 AliTRDCalibraFit.cxx:3849
 AliTRDCalibraFit.cxx:3850
 AliTRDCalibraFit.cxx:3851
 AliTRDCalibraFit.cxx:3852
 AliTRDCalibraFit.cxx:3853
 AliTRDCalibraFit.cxx:3854
 AliTRDCalibraFit.cxx:3855
 AliTRDCalibraFit.cxx:3856
 AliTRDCalibraFit.cxx:3857
 AliTRDCalibraFit.cxx:3858
 AliTRDCalibraFit.cxx:3859
 AliTRDCalibraFit.cxx:3860
 AliTRDCalibraFit.cxx:3861
 AliTRDCalibraFit.cxx:3862
 AliTRDCalibraFit.cxx:3863
 AliTRDCalibraFit.cxx:3864
 AliTRDCalibraFit.cxx:3865
 AliTRDCalibraFit.cxx:3866
 AliTRDCalibraFit.cxx:3867
 AliTRDCalibraFit.cxx:3868
 AliTRDCalibraFit.cxx:3869
 AliTRDCalibraFit.cxx:3870
 AliTRDCalibraFit.cxx:3871
 AliTRDCalibraFit.cxx:3872
 AliTRDCalibraFit.cxx:3873
 AliTRDCalibraFit.cxx:3874
 AliTRDCalibraFit.cxx:3875
 AliTRDCalibraFit.cxx:3876
 AliTRDCalibraFit.cxx:3877
 AliTRDCalibraFit.cxx:3878
 AliTRDCalibraFit.cxx:3879
 AliTRDCalibraFit.cxx:3880
 AliTRDCalibraFit.cxx:3881
 AliTRDCalibraFit.cxx:3882
 AliTRDCalibraFit.cxx:3883
 AliTRDCalibraFit.cxx:3884
 AliTRDCalibraFit.cxx:3885
 AliTRDCalibraFit.cxx:3886
 AliTRDCalibraFit.cxx:3887
 AliTRDCalibraFit.cxx:3888
 AliTRDCalibraFit.cxx:3889
 AliTRDCalibraFit.cxx:3890
 AliTRDCalibraFit.cxx:3891
 AliTRDCalibraFit.cxx:3892
 AliTRDCalibraFit.cxx:3893
 AliTRDCalibraFit.cxx:3894
 AliTRDCalibraFit.cxx:3895
 AliTRDCalibraFit.cxx:3896
 AliTRDCalibraFit.cxx:3897
 AliTRDCalibraFit.cxx:3898
 AliTRDCalibraFit.cxx:3899
 AliTRDCalibraFit.cxx:3900
 AliTRDCalibraFit.cxx:3901
 AliTRDCalibraFit.cxx:3902
 AliTRDCalibraFit.cxx:3903
 AliTRDCalibraFit.cxx:3904
 AliTRDCalibraFit.cxx:3905
 AliTRDCalibraFit.cxx:3906
 AliTRDCalibraFit.cxx:3907
 AliTRDCalibraFit.cxx:3908
 AliTRDCalibraFit.cxx:3909
 AliTRDCalibraFit.cxx:3910
 AliTRDCalibraFit.cxx:3911
 AliTRDCalibraFit.cxx:3912
 AliTRDCalibraFit.cxx:3913
 AliTRDCalibraFit.cxx:3914
 AliTRDCalibraFit.cxx:3915
 AliTRDCalibraFit.cxx:3916
 AliTRDCalibraFit.cxx:3917
 AliTRDCalibraFit.cxx:3918
 AliTRDCalibraFit.cxx:3919
 AliTRDCalibraFit.cxx:3920
 AliTRDCalibraFit.cxx:3921
 AliTRDCalibraFit.cxx:3922
 AliTRDCalibraFit.cxx:3923
 AliTRDCalibraFit.cxx:3924
 AliTRDCalibraFit.cxx:3925
 AliTRDCalibraFit.cxx:3926
 AliTRDCalibraFit.cxx:3927
 AliTRDCalibraFit.cxx:3928
 AliTRDCalibraFit.cxx:3929
 AliTRDCalibraFit.cxx:3930
 AliTRDCalibraFit.cxx:3931
 AliTRDCalibraFit.cxx:3932
 AliTRDCalibraFit.cxx:3933
 AliTRDCalibraFit.cxx:3934
 AliTRDCalibraFit.cxx:3935
 AliTRDCalibraFit.cxx:3936
 AliTRDCalibraFit.cxx:3937
 AliTRDCalibraFit.cxx:3938
 AliTRDCalibraFit.cxx:3939
 AliTRDCalibraFit.cxx:3940
 AliTRDCalibraFit.cxx:3941
 AliTRDCalibraFit.cxx:3942
 AliTRDCalibraFit.cxx:3943
 AliTRDCalibraFit.cxx:3944
 AliTRDCalibraFit.cxx:3945
 AliTRDCalibraFit.cxx:3946
 AliTRDCalibraFit.cxx:3947
 AliTRDCalibraFit.cxx:3948
 AliTRDCalibraFit.cxx:3949
 AliTRDCalibraFit.cxx:3950
 AliTRDCalibraFit.cxx:3951
 AliTRDCalibraFit.cxx:3952
 AliTRDCalibraFit.cxx:3953
 AliTRDCalibraFit.cxx:3954
 AliTRDCalibraFit.cxx:3955
 AliTRDCalibraFit.cxx:3956
 AliTRDCalibraFit.cxx:3957
 AliTRDCalibraFit.cxx:3958
 AliTRDCalibraFit.cxx:3959
 AliTRDCalibraFit.cxx:3960
 AliTRDCalibraFit.cxx:3961
 AliTRDCalibraFit.cxx:3962
 AliTRDCalibraFit.cxx:3963
 AliTRDCalibraFit.cxx:3964
 AliTRDCalibraFit.cxx:3965
 AliTRDCalibraFit.cxx:3966
 AliTRDCalibraFit.cxx:3967
 AliTRDCalibraFit.cxx:3968
 AliTRDCalibraFit.cxx:3969
 AliTRDCalibraFit.cxx:3970
 AliTRDCalibraFit.cxx:3971
 AliTRDCalibraFit.cxx:3972
 AliTRDCalibraFit.cxx:3973
 AliTRDCalibraFit.cxx:3974
 AliTRDCalibraFit.cxx:3975
 AliTRDCalibraFit.cxx:3976
 AliTRDCalibraFit.cxx:3977
 AliTRDCalibraFit.cxx:3978
 AliTRDCalibraFit.cxx:3979
 AliTRDCalibraFit.cxx:3980
 AliTRDCalibraFit.cxx:3981
 AliTRDCalibraFit.cxx:3982
 AliTRDCalibraFit.cxx:3983
 AliTRDCalibraFit.cxx:3984
 AliTRDCalibraFit.cxx:3985
 AliTRDCalibraFit.cxx:3986
 AliTRDCalibraFit.cxx:3987
 AliTRDCalibraFit.cxx:3988
 AliTRDCalibraFit.cxx:3989
 AliTRDCalibraFit.cxx:3990
 AliTRDCalibraFit.cxx:3991
 AliTRDCalibraFit.cxx:3992
 AliTRDCalibraFit.cxx:3993
 AliTRDCalibraFit.cxx:3994
 AliTRDCalibraFit.cxx:3995
 AliTRDCalibraFit.cxx:3996
 AliTRDCalibraFit.cxx:3997
 AliTRDCalibraFit.cxx:3998
 AliTRDCalibraFit.cxx:3999
 AliTRDCalibraFit.cxx:4000
 AliTRDCalibraFit.cxx:4001
 AliTRDCalibraFit.cxx:4002
 AliTRDCalibraFit.cxx:4003
 AliTRDCalibraFit.cxx:4004
 AliTRDCalibraFit.cxx:4005
 AliTRDCalibraFit.cxx:4006
 AliTRDCalibraFit.cxx:4007
 AliTRDCalibraFit.cxx:4008
 AliTRDCalibraFit.cxx:4009
 AliTRDCalibraFit.cxx:4010
 AliTRDCalibraFit.cxx:4011
 AliTRDCalibraFit.cxx:4012
 AliTRDCalibraFit.cxx:4013
 AliTRDCalibraFit.cxx:4014
 AliTRDCalibraFit.cxx:4015
 AliTRDCalibraFit.cxx:4016
 AliTRDCalibraFit.cxx:4017
 AliTRDCalibraFit.cxx:4018
 AliTRDCalibraFit.cxx:4019
 AliTRDCalibraFit.cxx:4020
 AliTRDCalibraFit.cxx:4021
 AliTRDCalibraFit.cxx:4022
 AliTRDCalibraFit.cxx:4023
 AliTRDCalibraFit.cxx:4024
 AliTRDCalibraFit.cxx:4025
 AliTRDCalibraFit.cxx:4026
 AliTRDCalibraFit.cxx:4027
 AliTRDCalibraFit.cxx:4028
 AliTRDCalibraFit.cxx:4029
 AliTRDCalibraFit.cxx:4030
 AliTRDCalibraFit.cxx:4031
 AliTRDCalibraFit.cxx:4032
 AliTRDCalibraFit.cxx:4033
 AliTRDCalibraFit.cxx:4034
 AliTRDCalibraFit.cxx:4035
 AliTRDCalibraFit.cxx:4036
 AliTRDCalibraFit.cxx:4037
 AliTRDCalibraFit.cxx:4038
 AliTRDCalibraFit.cxx:4039
 AliTRDCalibraFit.cxx:4040
 AliTRDCalibraFit.cxx:4041
 AliTRDCalibraFit.cxx:4042
 AliTRDCalibraFit.cxx:4043
 AliTRDCalibraFit.cxx:4044
 AliTRDCalibraFit.cxx:4045
 AliTRDCalibraFit.cxx:4046
 AliTRDCalibraFit.cxx:4047
 AliTRDCalibraFit.cxx:4048
 AliTRDCalibraFit.cxx:4049
 AliTRDCalibraFit.cxx:4050
 AliTRDCalibraFit.cxx:4051
 AliTRDCalibraFit.cxx:4052
 AliTRDCalibraFit.cxx:4053
 AliTRDCalibraFit.cxx:4054
 AliTRDCalibraFit.cxx:4055
 AliTRDCalibraFit.cxx:4056
 AliTRDCalibraFit.cxx:4057
 AliTRDCalibraFit.cxx:4058
 AliTRDCalibraFit.cxx:4059
 AliTRDCalibraFit.cxx:4060
 AliTRDCalibraFit.cxx:4061
 AliTRDCalibraFit.cxx:4062
 AliTRDCalibraFit.cxx:4063
 AliTRDCalibraFit.cxx:4064
 AliTRDCalibraFit.cxx:4065
 AliTRDCalibraFit.cxx:4066
 AliTRDCalibraFit.cxx:4067
 AliTRDCalibraFit.cxx:4068
 AliTRDCalibraFit.cxx:4069
 AliTRDCalibraFit.cxx:4070
 AliTRDCalibraFit.cxx:4071
 AliTRDCalibraFit.cxx:4072
 AliTRDCalibraFit.cxx:4073
 AliTRDCalibraFit.cxx:4074
 AliTRDCalibraFit.cxx:4075
 AliTRDCalibraFit.cxx:4076
 AliTRDCalibraFit.cxx:4077
 AliTRDCalibraFit.cxx:4078
 AliTRDCalibraFit.cxx:4079
 AliTRDCalibraFit.cxx:4080
 AliTRDCalibraFit.cxx:4081
 AliTRDCalibraFit.cxx:4082
 AliTRDCalibraFit.cxx:4083
 AliTRDCalibraFit.cxx:4084
 AliTRDCalibraFit.cxx:4085
 AliTRDCalibraFit.cxx:4086
 AliTRDCalibraFit.cxx:4087
 AliTRDCalibraFit.cxx:4088
 AliTRDCalibraFit.cxx:4089
 AliTRDCalibraFit.cxx:4090
 AliTRDCalibraFit.cxx:4091
 AliTRDCalibraFit.cxx:4092
 AliTRDCalibraFit.cxx:4093
 AliTRDCalibraFit.cxx:4094
 AliTRDCalibraFit.cxx:4095
 AliTRDCalibraFit.cxx:4096
 AliTRDCalibraFit.cxx:4097
 AliTRDCalibraFit.cxx:4098
 AliTRDCalibraFit.cxx:4099
 AliTRDCalibraFit.cxx:4100
 AliTRDCalibraFit.cxx:4101
 AliTRDCalibraFit.cxx:4102
 AliTRDCalibraFit.cxx:4103
 AliTRDCalibraFit.cxx:4104
 AliTRDCalibraFit.cxx:4105
 AliTRDCalibraFit.cxx:4106
 AliTRDCalibraFit.cxx:4107
 AliTRDCalibraFit.cxx:4108
 AliTRDCalibraFit.cxx:4109
 AliTRDCalibraFit.cxx:4110
 AliTRDCalibraFit.cxx:4111
 AliTRDCalibraFit.cxx:4112
 AliTRDCalibraFit.cxx:4113
 AliTRDCalibraFit.cxx:4114
 AliTRDCalibraFit.cxx:4115
 AliTRDCalibraFit.cxx:4116
 AliTRDCalibraFit.cxx:4117
 AliTRDCalibraFit.cxx:4118
 AliTRDCalibraFit.cxx:4119
 AliTRDCalibraFit.cxx:4120
 AliTRDCalibraFit.cxx:4121
 AliTRDCalibraFit.cxx:4122
 AliTRDCalibraFit.cxx:4123
 AliTRDCalibraFit.cxx:4124
 AliTRDCalibraFit.cxx:4125
 AliTRDCalibraFit.cxx:4126
 AliTRDCalibraFit.cxx:4127
 AliTRDCalibraFit.cxx:4128
 AliTRDCalibraFit.cxx:4129
 AliTRDCalibraFit.cxx:4130
 AliTRDCalibraFit.cxx:4131
 AliTRDCalibraFit.cxx:4132
 AliTRDCalibraFit.cxx:4133
 AliTRDCalibraFit.cxx:4134
 AliTRDCalibraFit.cxx:4135
 AliTRDCalibraFit.cxx:4136
 AliTRDCalibraFit.cxx:4137
 AliTRDCalibraFit.cxx:4138
 AliTRDCalibraFit.cxx:4139
 AliTRDCalibraFit.cxx:4140
 AliTRDCalibraFit.cxx:4141
 AliTRDCalibraFit.cxx:4142
 AliTRDCalibraFit.cxx:4143
 AliTRDCalibraFit.cxx:4144
 AliTRDCalibraFit.cxx:4145
 AliTRDCalibraFit.cxx:4146
 AliTRDCalibraFit.cxx:4147
 AliTRDCalibraFit.cxx:4148
 AliTRDCalibraFit.cxx:4149
 AliTRDCalibraFit.cxx:4150
 AliTRDCalibraFit.cxx:4151
 AliTRDCalibraFit.cxx:4152
 AliTRDCalibraFit.cxx:4153
 AliTRDCalibraFit.cxx:4154
 AliTRDCalibraFit.cxx:4155
 AliTRDCalibraFit.cxx:4156
 AliTRDCalibraFit.cxx:4157
 AliTRDCalibraFit.cxx:4158
 AliTRDCalibraFit.cxx:4159
 AliTRDCalibraFit.cxx:4160
 AliTRDCalibraFit.cxx:4161
 AliTRDCalibraFit.cxx:4162
 AliTRDCalibraFit.cxx:4163
 AliTRDCalibraFit.cxx:4164
 AliTRDCalibraFit.cxx:4165
 AliTRDCalibraFit.cxx:4166
 AliTRDCalibraFit.cxx:4167
 AliTRDCalibraFit.cxx:4168
 AliTRDCalibraFit.cxx:4169
 AliTRDCalibraFit.cxx:4170
 AliTRDCalibraFit.cxx:4171
 AliTRDCalibraFit.cxx:4172
 AliTRDCalibraFit.cxx:4173
 AliTRDCalibraFit.cxx:4174
 AliTRDCalibraFit.cxx:4175
 AliTRDCalibraFit.cxx:4176
 AliTRDCalibraFit.cxx:4177
 AliTRDCalibraFit.cxx:4178
 AliTRDCalibraFit.cxx:4179
 AliTRDCalibraFit.cxx:4180
 AliTRDCalibraFit.cxx:4181
 AliTRDCalibraFit.cxx:4182
 AliTRDCalibraFit.cxx:4183
 AliTRDCalibraFit.cxx:4184
 AliTRDCalibraFit.cxx:4185
 AliTRDCalibraFit.cxx:4186
 AliTRDCalibraFit.cxx:4187
 AliTRDCalibraFit.cxx:4188
 AliTRDCalibraFit.cxx:4189
 AliTRDCalibraFit.cxx:4190
 AliTRDCalibraFit.cxx:4191
 AliTRDCalibraFit.cxx:4192
 AliTRDCalibraFit.cxx:4193
 AliTRDCalibraFit.cxx:4194
 AliTRDCalibraFit.cxx:4195
 AliTRDCalibraFit.cxx:4196
 AliTRDCalibraFit.cxx:4197
 AliTRDCalibraFit.cxx:4198
 AliTRDCalibraFit.cxx:4199
 AliTRDCalibraFit.cxx:4200
 AliTRDCalibraFit.cxx:4201
 AliTRDCalibraFit.cxx:4202
 AliTRDCalibraFit.cxx:4203
 AliTRDCalibraFit.cxx:4204
 AliTRDCalibraFit.cxx:4205
 AliTRDCalibraFit.cxx:4206
 AliTRDCalibraFit.cxx:4207
 AliTRDCalibraFit.cxx:4208
 AliTRDCalibraFit.cxx:4209
 AliTRDCalibraFit.cxx:4210
 AliTRDCalibraFit.cxx:4211
 AliTRDCalibraFit.cxx:4212
 AliTRDCalibraFit.cxx:4213
 AliTRDCalibraFit.cxx:4214
 AliTRDCalibraFit.cxx:4215
 AliTRDCalibraFit.cxx:4216
 AliTRDCalibraFit.cxx:4217
 AliTRDCalibraFit.cxx:4218
 AliTRDCalibraFit.cxx:4219
 AliTRDCalibraFit.cxx:4220
 AliTRDCalibraFit.cxx:4221
 AliTRDCalibraFit.cxx:4222
 AliTRDCalibraFit.cxx:4223
 AliTRDCalibraFit.cxx:4224
 AliTRDCalibraFit.cxx:4225
 AliTRDCalibraFit.cxx:4226
 AliTRDCalibraFit.cxx:4227
 AliTRDCalibraFit.cxx:4228
 AliTRDCalibraFit.cxx:4229
 AliTRDCalibraFit.cxx:4230
 AliTRDCalibraFit.cxx:4231
 AliTRDCalibraFit.cxx:4232
 AliTRDCalibraFit.cxx:4233
 AliTRDCalibraFit.cxx:4234
 AliTRDCalibraFit.cxx:4235
 AliTRDCalibraFit.cxx:4236
 AliTRDCalibraFit.cxx:4237
 AliTRDCalibraFit.cxx:4238
 AliTRDCalibraFit.cxx:4239
 AliTRDCalibraFit.cxx:4240
 AliTRDCalibraFit.cxx:4241
 AliTRDCalibraFit.cxx:4242
 AliTRDCalibraFit.cxx:4243
 AliTRDCalibraFit.cxx:4244
 AliTRDCalibraFit.cxx:4245
 AliTRDCalibraFit.cxx:4246
 AliTRDCalibraFit.cxx:4247
 AliTRDCalibraFit.cxx:4248
 AliTRDCalibraFit.cxx:4249
 AliTRDCalibraFit.cxx:4250
 AliTRDCalibraFit.cxx:4251
 AliTRDCalibraFit.cxx:4252
 AliTRDCalibraFit.cxx:4253
 AliTRDCalibraFit.cxx:4254
 AliTRDCalibraFit.cxx:4255
 AliTRDCalibraFit.cxx:4256
 AliTRDCalibraFit.cxx:4257
 AliTRDCalibraFit.cxx:4258
 AliTRDCalibraFit.cxx:4259
 AliTRDCalibraFit.cxx:4260
 AliTRDCalibraFit.cxx:4261
 AliTRDCalibraFit.cxx:4262
 AliTRDCalibraFit.cxx:4263
 AliTRDCalibraFit.cxx:4264
 AliTRDCalibraFit.cxx:4265
 AliTRDCalibraFit.cxx:4266
 AliTRDCalibraFit.cxx:4267
 AliTRDCalibraFit.cxx:4268
 AliTRDCalibraFit.cxx:4269
 AliTRDCalibraFit.cxx:4270
 AliTRDCalibraFit.cxx:4271
 AliTRDCalibraFit.cxx:4272
 AliTRDCalibraFit.cxx:4273
 AliTRDCalibraFit.cxx:4274
 AliTRDCalibraFit.cxx:4275
 AliTRDCalibraFit.cxx:4276
 AliTRDCalibraFit.cxx:4277
 AliTRDCalibraFit.cxx:4278
 AliTRDCalibraFit.cxx:4279
 AliTRDCalibraFit.cxx:4280
 AliTRDCalibraFit.cxx:4281
 AliTRDCalibraFit.cxx:4282
 AliTRDCalibraFit.cxx:4283
 AliTRDCalibraFit.cxx:4284
 AliTRDCalibraFit.cxx:4285
 AliTRDCalibraFit.cxx:4286
 AliTRDCalibraFit.cxx:4287
 AliTRDCalibraFit.cxx:4288
 AliTRDCalibraFit.cxx:4289
 AliTRDCalibraFit.cxx:4290
 AliTRDCalibraFit.cxx:4291
 AliTRDCalibraFit.cxx:4292
 AliTRDCalibraFit.cxx:4293
 AliTRDCalibraFit.cxx:4294
 AliTRDCalibraFit.cxx:4295
 AliTRDCalibraFit.cxx:4296
 AliTRDCalibraFit.cxx:4297
 AliTRDCalibraFit.cxx:4298
 AliTRDCalibraFit.cxx:4299
 AliTRDCalibraFit.cxx:4300
 AliTRDCalibraFit.cxx:4301
 AliTRDCalibraFit.cxx:4302
 AliTRDCalibraFit.cxx:4303
 AliTRDCalibraFit.cxx:4304
 AliTRDCalibraFit.cxx:4305
 AliTRDCalibraFit.cxx:4306
 AliTRDCalibraFit.cxx:4307
 AliTRDCalibraFit.cxx:4308
 AliTRDCalibraFit.cxx:4309
 AliTRDCalibraFit.cxx:4310
 AliTRDCalibraFit.cxx:4311
 AliTRDCalibraFit.cxx:4312
 AliTRDCalibraFit.cxx:4313
 AliTRDCalibraFit.cxx:4314
 AliTRDCalibraFit.cxx:4315
 AliTRDCalibraFit.cxx:4316
 AliTRDCalibraFit.cxx:4317
 AliTRDCalibraFit.cxx:4318
 AliTRDCalibraFit.cxx:4319
 AliTRDCalibraFit.cxx:4320
 AliTRDCalibraFit.cxx:4321
 AliTRDCalibraFit.cxx:4322
 AliTRDCalibraFit.cxx:4323
 AliTRDCalibraFit.cxx:4324
 AliTRDCalibraFit.cxx:4325
 AliTRDCalibraFit.cxx:4326
 AliTRDCalibraFit.cxx:4327
 AliTRDCalibraFit.cxx:4328
 AliTRDCalibraFit.cxx:4329
 AliTRDCalibraFit.cxx:4330
 AliTRDCalibraFit.cxx:4331
 AliTRDCalibraFit.cxx:4332
 AliTRDCalibraFit.cxx:4333
 AliTRDCalibraFit.cxx:4334
 AliTRDCalibraFit.cxx:4335
 AliTRDCalibraFit.cxx:4336
 AliTRDCalibraFit.cxx:4337
 AliTRDCalibraFit.cxx:4338
 AliTRDCalibraFit.cxx:4339
 AliTRDCalibraFit.cxx:4340
 AliTRDCalibraFit.cxx:4341
 AliTRDCalibraFit.cxx:4342
 AliTRDCalibraFit.cxx:4343
 AliTRDCalibraFit.cxx:4344
 AliTRDCalibraFit.cxx:4345
 AliTRDCalibraFit.cxx:4346
 AliTRDCalibraFit.cxx:4347
 AliTRDCalibraFit.cxx:4348
 AliTRDCalibraFit.cxx:4349
 AliTRDCalibraFit.cxx:4350
 AliTRDCalibraFit.cxx:4351
 AliTRDCalibraFit.cxx:4352
 AliTRDCalibraFit.cxx:4353
 AliTRDCalibraFit.cxx:4354
 AliTRDCalibraFit.cxx:4355
 AliTRDCalibraFit.cxx:4356
 AliTRDCalibraFit.cxx:4357
 AliTRDCalibraFit.cxx:4358
 AliTRDCalibraFit.cxx:4359
 AliTRDCalibraFit.cxx:4360
 AliTRDCalibraFit.cxx:4361
 AliTRDCalibraFit.cxx:4362
 AliTRDCalibraFit.cxx:4363
 AliTRDCalibraFit.cxx:4364
 AliTRDCalibraFit.cxx:4365
 AliTRDCalibraFit.cxx:4366
 AliTRDCalibraFit.cxx:4367
 AliTRDCalibraFit.cxx:4368
 AliTRDCalibraFit.cxx:4369
 AliTRDCalibraFit.cxx:4370
 AliTRDCalibraFit.cxx:4371
 AliTRDCalibraFit.cxx:4372
 AliTRDCalibraFit.cxx:4373
 AliTRDCalibraFit.cxx:4374
 AliTRDCalibraFit.cxx:4375
 AliTRDCalibraFit.cxx:4376
 AliTRDCalibraFit.cxx:4377
 AliTRDCalibraFit.cxx:4378
 AliTRDCalibraFit.cxx:4379
 AliTRDCalibraFit.cxx:4380
 AliTRDCalibraFit.cxx:4381
 AliTRDCalibraFit.cxx:4382
 AliTRDCalibraFit.cxx:4383
 AliTRDCalibraFit.cxx:4384
 AliTRDCalibraFit.cxx:4385
 AliTRDCalibraFit.cxx:4386
 AliTRDCalibraFit.cxx:4387
 AliTRDCalibraFit.cxx:4388
 AliTRDCalibraFit.cxx:4389
 AliTRDCalibraFit.cxx:4390
 AliTRDCalibraFit.cxx:4391
 AliTRDCalibraFit.cxx:4392
 AliTRDCalibraFit.cxx:4393
 AliTRDCalibraFit.cxx:4394
 AliTRDCalibraFit.cxx:4395
 AliTRDCalibraFit.cxx:4396
 AliTRDCalibraFit.cxx:4397
 AliTRDCalibraFit.cxx:4398
 AliTRDCalibraFit.cxx:4399
 AliTRDCalibraFit.cxx:4400
 AliTRDCalibraFit.cxx:4401
 AliTRDCalibraFit.cxx:4402
 AliTRDCalibraFit.cxx:4403
 AliTRDCalibraFit.cxx:4404
 AliTRDCalibraFit.cxx:4405
 AliTRDCalibraFit.cxx:4406
 AliTRDCalibraFit.cxx:4407
 AliTRDCalibraFit.cxx:4408
 AliTRDCalibraFit.cxx:4409
 AliTRDCalibraFit.cxx:4410
 AliTRDCalibraFit.cxx:4411
 AliTRDCalibraFit.cxx:4412
 AliTRDCalibraFit.cxx:4413
 AliTRDCalibraFit.cxx:4414
 AliTRDCalibraFit.cxx:4415
 AliTRDCalibraFit.cxx:4416
 AliTRDCalibraFit.cxx:4417
 AliTRDCalibraFit.cxx:4418
 AliTRDCalibraFit.cxx:4419
 AliTRDCalibraFit.cxx:4420
 AliTRDCalibraFit.cxx:4421
 AliTRDCalibraFit.cxx:4422
 AliTRDCalibraFit.cxx:4423
 AliTRDCalibraFit.cxx:4424
 AliTRDCalibraFit.cxx:4425
 AliTRDCalibraFit.cxx:4426
 AliTRDCalibraFit.cxx:4427
 AliTRDCalibraFit.cxx:4428
 AliTRDCalibraFit.cxx:4429
 AliTRDCalibraFit.cxx:4430
 AliTRDCalibraFit.cxx:4431
 AliTRDCalibraFit.cxx:4432
 AliTRDCalibraFit.cxx:4433
 AliTRDCalibraFit.cxx:4434
 AliTRDCalibraFit.cxx:4435
 AliTRDCalibraFit.cxx:4436
 AliTRDCalibraFit.cxx:4437
 AliTRDCalibraFit.cxx:4438
 AliTRDCalibraFit.cxx:4439
 AliTRDCalibraFit.cxx:4440
 AliTRDCalibraFit.cxx:4441
 AliTRDCalibraFit.cxx:4442
 AliTRDCalibraFit.cxx:4443
 AliTRDCalibraFit.cxx:4444
 AliTRDCalibraFit.cxx:4445
 AliTRDCalibraFit.cxx:4446
 AliTRDCalibraFit.cxx:4447
 AliTRDCalibraFit.cxx:4448
 AliTRDCalibraFit.cxx:4449
 AliTRDCalibraFit.cxx:4450
 AliTRDCalibraFit.cxx:4451
 AliTRDCalibraFit.cxx:4452
 AliTRDCalibraFit.cxx:4453
 AliTRDCalibraFit.cxx:4454
 AliTRDCalibraFit.cxx:4455
 AliTRDCalibraFit.cxx:4456
 AliTRDCalibraFit.cxx:4457
 AliTRDCalibraFit.cxx:4458
 AliTRDCalibraFit.cxx:4459
 AliTRDCalibraFit.cxx:4460
 AliTRDCalibraFit.cxx:4461
 AliTRDCalibraFit.cxx:4462
 AliTRDCalibraFit.cxx:4463
 AliTRDCalibraFit.cxx:4464
 AliTRDCalibraFit.cxx:4465
 AliTRDCalibraFit.cxx:4466
 AliTRDCalibraFit.cxx:4467
 AliTRDCalibraFit.cxx:4468
 AliTRDCalibraFit.cxx:4469
 AliTRDCalibraFit.cxx:4470
 AliTRDCalibraFit.cxx:4471
 AliTRDCalibraFit.cxx:4472
 AliTRDCalibraFit.cxx:4473
 AliTRDCalibraFit.cxx:4474
 AliTRDCalibraFit.cxx:4475
 AliTRDCalibraFit.cxx:4476
 AliTRDCalibraFit.cxx:4477
 AliTRDCalibraFit.cxx:4478
 AliTRDCalibraFit.cxx:4479
 AliTRDCalibraFit.cxx:4480
 AliTRDCalibraFit.cxx:4481
 AliTRDCalibraFit.cxx:4482
 AliTRDCalibraFit.cxx:4483
 AliTRDCalibraFit.cxx:4484
 AliTRDCalibraFit.cxx:4485
 AliTRDCalibraFit.cxx:4486
 AliTRDCalibraFit.cxx:4487
 AliTRDCalibraFit.cxx:4488
 AliTRDCalibraFit.cxx:4489
 AliTRDCalibraFit.cxx:4490
 AliTRDCalibraFit.cxx:4491
 AliTRDCalibraFit.cxx:4492
 AliTRDCalibraFit.cxx:4493
 AliTRDCalibraFit.cxx:4494
 AliTRDCalibraFit.cxx:4495
 AliTRDCalibraFit.cxx:4496
 AliTRDCalibraFit.cxx:4497
 AliTRDCalibraFit.cxx:4498
 AliTRDCalibraFit.cxx:4499
 AliTRDCalibraFit.cxx:4500
 AliTRDCalibraFit.cxx:4501
 AliTRDCalibraFit.cxx:4502
 AliTRDCalibraFit.cxx:4503
 AliTRDCalibraFit.cxx:4504
 AliTRDCalibraFit.cxx:4505
 AliTRDCalibraFit.cxx:4506
 AliTRDCalibraFit.cxx:4507
 AliTRDCalibraFit.cxx:4508
 AliTRDCalibraFit.cxx:4509
 AliTRDCalibraFit.cxx:4510
 AliTRDCalibraFit.cxx:4511
 AliTRDCalibraFit.cxx:4512
 AliTRDCalibraFit.cxx:4513
 AliTRDCalibraFit.cxx:4514
 AliTRDCalibraFit.cxx:4515
 AliTRDCalibraFit.cxx:4516
 AliTRDCalibraFit.cxx:4517
 AliTRDCalibraFit.cxx:4518
 AliTRDCalibraFit.cxx:4519
 AliTRDCalibraFit.cxx:4520
 AliTRDCalibraFit.cxx:4521
 AliTRDCalibraFit.cxx:4522
 AliTRDCalibraFit.cxx:4523
 AliTRDCalibraFit.cxx:4524
 AliTRDCalibraFit.cxx:4525
 AliTRDCalibraFit.cxx:4526
 AliTRDCalibraFit.cxx:4527
 AliTRDCalibraFit.cxx:4528
 AliTRDCalibraFit.cxx:4529
 AliTRDCalibraFit.cxx:4530
 AliTRDCalibraFit.cxx:4531
 AliTRDCalibraFit.cxx:4532
 AliTRDCalibraFit.cxx:4533
 AliTRDCalibraFit.cxx:4534
 AliTRDCalibraFit.cxx:4535
 AliTRDCalibraFit.cxx:4536
 AliTRDCalibraFit.cxx:4537
 AliTRDCalibraFit.cxx:4538
 AliTRDCalibraFit.cxx:4539
 AliTRDCalibraFit.cxx:4540
 AliTRDCalibraFit.cxx:4541
 AliTRDCalibraFit.cxx:4542
 AliTRDCalibraFit.cxx:4543
 AliTRDCalibraFit.cxx:4544
 AliTRDCalibraFit.cxx:4545
 AliTRDCalibraFit.cxx:4546
 AliTRDCalibraFit.cxx:4547
 AliTRDCalibraFit.cxx:4548
 AliTRDCalibraFit.cxx:4549
 AliTRDCalibraFit.cxx:4550
 AliTRDCalibraFit.cxx:4551
 AliTRDCalibraFit.cxx:4552
 AliTRDCalibraFit.cxx:4553
 AliTRDCalibraFit.cxx:4554
 AliTRDCalibraFit.cxx:4555
 AliTRDCalibraFit.cxx:4556
 AliTRDCalibraFit.cxx:4557
 AliTRDCalibraFit.cxx:4558
 AliTRDCalibraFit.cxx:4559
 AliTRDCalibraFit.cxx:4560
 AliTRDCalibraFit.cxx:4561
 AliTRDCalibraFit.cxx:4562
 AliTRDCalibraFit.cxx:4563
 AliTRDCalibraFit.cxx:4564
 AliTRDCalibraFit.cxx:4565
 AliTRDCalibraFit.cxx:4566
 AliTRDCalibraFit.cxx:4567
 AliTRDCalibraFit.cxx:4568
 AliTRDCalibraFit.cxx:4569
 AliTRDCalibraFit.cxx:4570
 AliTRDCalibraFit.cxx:4571
 AliTRDCalibraFit.cxx:4572
 AliTRDCalibraFit.cxx:4573
 AliTRDCalibraFit.cxx:4574
 AliTRDCalibraFit.cxx:4575
 AliTRDCalibraFit.cxx:4576
 AliTRDCalibraFit.cxx:4577
 AliTRDCalibraFit.cxx:4578
 AliTRDCalibraFit.cxx:4579
 AliTRDCalibraFit.cxx:4580
 AliTRDCalibraFit.cxx:4581
 AliTRDCalibraFit.cxx:4582
 AliTRDCalibraFit.cxx:4583
 AliTRDCalibraFit.cxx:4584
 AliTRDCalibraFit.cxx:4585
 AliTRDCalibraFit.cxx:4586
 AliTRDCalibraFit.cxx:4587
 AliTRDCalibraFit.cxx:4588
 AliTRDCalibraFit.cxx:4589
 AliTRDCalibraFit.cxx:4590
 AliTRDCalibraFit.cxx:4591
 AliTRDCalibraFit.cxx:4592
 AliTRDCalibraFit.cxx:4593
 AliTRDCalibraFit.cxx:4594
 AliTRDCalibraFit.cxx:4595
 AliTRDCalibraFit.cxx:4596
 AliTRDCalibraFit.cxx:4597
 AliTRDCalibraFit.cxx:4598
 AliTRDCalibraFit.cxx:4599
 AliTRDCalibraFit.cxx:4600
 AliTRDCalibraFit.cxx:4601
 AliTRDCalibraFit.cxx:4602
 AliTRDCalibraFit.cxx:4603
 AliTRDCalibraFit.cxx:4604
 AliTRDCalibraFit.cxx:4605
 AliTRDCalibraFit.cxx:4606
 AliTRDCalibraFit.cxx:4607
 AliTRDCalibraFit.cxx:4608
 AliTRDCalibraFit.cxx:4609
 AliTRDCalibraFit.cxx:4610
 AliTRDCalibraFit.cxx:4611
 AliTRDCalibraFit.cxx:4612
 AliTRDCalibraFit.cxx:4613
 AliTRDCalibraFit.cxx:4614
 AliTRDCalibraFit.cxx:4615
 AliTRDCalibraFit.cxx:4616
 AliTRDCalibraFit.cxx:4617
 AliTRDCalibraFit.cxx:4618
 AliTRDCalibraFit.cxx:4619
 AliTRDCalibraFit.cxx:4620
 AliTRDCalibraFit.cxx:4621
 AliTRDCalibraFit.cxx:4622
 AliTRDCalibraFit.cxx:4623
 AliTRDCalibraFit.cxx:4624
 AliTRDCalibraFit.cxx:4625
 AliTRDCalibraFit.cxx:4626
 AliTRDCalibraFit.cxx:4627
 AliTRDCalibraFit.cxx:4628
 AliTRDCalibraFit.cxx:4629
 AliTRDCalibraFit.cxx:4630
 AliTRDCalibraFit.cxx:4631
 AliTRDCalibraFit.cxx:4632
 AliTRDCalibraFit.cxx:4633
 AliTRDCalibraFit.cxx:4634
 AliTRDCalibraFit.cxx:4635
 AliTRDCalibraFit.cxx:4636
 AliTRDCalibraFit.cxx:4637
 AliTRDCalibraFit.cxx:4638
 AliTRDCalibraFit.cxx:4639
 AliTRDCalibraFit.cxx:4640
 AliTRDCalibraFit.cxx:4641
 AliTRDCalibraFit.cxx:4642
 AliTRDCalibraFit.cxx:4643
 AliTRDCalibraFit.cxx:4644
 AliTRDCalibraFit.cxx:4645
 AliTRDCalibraFit.cxx:4646
 AliTRDCalibraFit.cxx:4647
 AliTRDCalibraFit.cxx:4648
 AliTRDCalibraFit.cxx:4649
 AliTRDCalibraFit.cxx:4650
 AliTRDCalibraFit.cxx:4651
 AliTRDCalibraFit.cxx:4652
 AliTRDCalibraFit.cxx:4653
 AliTRDCalibraFit.cxx:4654
 AliTRDCalibraFit.cxx:4655
 AliTRDCalibraFit.cxx:4656
 AliTRDCalibraFit.cxx:4657
 AliTRDCalibraFit.cxx:4658
 AliTRDCalibraFit.cxx:4659
 AliTRDCalibraFit.cxx:4660
 AliTRDCalibraFit.cxx:4661
 AliTRDCalibraFit.cxx:4662
 AliTRDCalibraFit.cxx:4663
 AliTRDCalibraFit.cxx:4664
 AliTRDCalibraFit.cxx:4665
 AliTRDCalibraFit.cxx:4666
 AliTRDCalibraFit.cxx:4667
 AliTRDCalibraFit.cxx:4668
 AliTRDCalibraFit.cxx:4669
 AliTRDCalibraFit.cxx:4670
 AliTRDCalibraFit.cxx:4671
 AliTRDCalibraFit.cxx:4672
 AliTRDCalibraFit.cxx:4673
 AliTRDCalibraFit.cxx:4674
 AliTRDCalibraFit.cxx:4675
 AliTRDCalibraFit.cxx:4676
 AliTRDCalibraFit.cxx:4677
 AliTRDCalibraFit.cxx:4678
 AliTRDCalibraFit.cxx:4679
 AliTRDCalibraFit.cxx:4680
 AliTRDCalibraFit.cxx:4681
 AliTRDCalibraFit.cxx:4682
 AliTRDCalibraFit.cxx:4683
 AliTRDCalibraFit.cxx:4684
 AliTRDCalibraFit.cxx:4685
 AliTRDCalibraFit.cxx:4686
 AliTRDCalibraFit.cxx:4687
 AliTRDCalibraFit.cxx:4688
 AliTRDCalibraFit.cxx:4689
 AliTRDCalibraFit.cxx:4690
 AliTRDCalibraFit.cxx:4691
 AliTRDCalibraFit.cxx:4692
 AliTRDCalibraFit.cxx:4693
 AliTRDCalibraFit.cxx:4694
 AliTRDCalibraFit.cxx:4695
 AliTRDCalibraFit.cxx:4696
 AliTRDCalibraFit.cxx:4697
 AliTRDCalibraFit.cxx:4698
 AliTRDCalibraFit.cxx:4699
 AliTRDCalibraFit.cxx:4700
 AliTRDCalibraFit.cxx:4701
 AliTRDCalibraFit.cxx:4702
 AliTRDCalibraFit.cxx:4703
 AliTRDCalibraFit.cxx:4704
 AliTRDCalibraFit.cxx:4705
 AliTRDCalibraFit.cxx:4706
 AliTRDCalibraFit.cxx:4707
 AliTRDCalibraFit.cxx:4708
 AliTRDCalibraFit.cxx:4709
 AliTRDCalibraFit.cxx:4710
 AliTRDCalibraFit.cxx:4711
 AliTRDCalibraFit.cxx:4712
 AliTRDCalibraFit.cxx:4713
 AliTRDCalibraFit.cxx:4714
 AliTRDCalibraFit.cxx:4715
 AliTRDCalibraFit.cxx:4716
 AliTRDCalibraFit.cxx:4717
 AliTRDCalibraFit.cxx:4718
 AliTRDCalibraFit.cxx:4719
 AliTRDCalibraFit.cxx:4720
 AliTRDCalibraFit.cxx:4721
 AliTRDCalibraFit.cxx:4722
 AliTRDCalibraFit.cxx:4723
 AliTRDCalibraFit.cxx:4724
 AliTRDCalibraFit.cxx:4725
 AliTRDCalibraFit.cxx:4726
 AliTRDCalibraFit.cxx:4727
 AliTRDCalibraFit.cxx:4728
 AliTRDCalibraFit.cxx:4729
 AliTRDCalibraFit.cxx:4730
 AliTRDCalibraFit.cxx:4731
 AliTRDCalibraFit.cxx:4732
 AliTRDCalibraFit.cxx:4733
 AliTRDCalibraFit.cxx:4734
 AliTRDCalibraFit.cxx:4735
 AliTRDCalibraFit.cxx:4736
 AliTRDCalibraFit.cxx:4737
 AliTRDCalibraFit.cxx:4738
 AliTRDCalibraFit.cxx:4739
 AliTRDCalibraFit.cxx:4740
 AliTRDCalibraFit.cxx:4741
 AliTRDCalibraFit.cxx:4742
 AliTRDCalibraFit.cxx:4743
 AliTRDCalibraFit.cxx:4744
 AliTRDCalibraFit.cxx:4745
 AliTRDCalibraFit.cxx:4746
 AliTRDCalibraFit.cxx:4747
 AliTRDCalibraFit.cxx:4748
 AliTRDCalibraFit.cxx:4749
 AliTRDCalibraFit.cxx:4750
 AliTRDCalibraFit.cxx:4751
 AliTRDCalibraFit.cxx:4752
 AliTRDCalibraFit.cxx:4753
 AliTRDCalibraFit.cxx:4754
 AliTRDCalibraFit.cxx:4755
 AliTRDCalibraFit.cxx:4756
 AliTRDCalibraFit.cxx:4757
 AliTRDCalibraFit.cxx:4758
 AliTRDCalibraFit.cxx:4759
 AliTRDCalibraFit.cxx:4760
 AliTRDCalibraFit.cxx:4761
 AliTRDCalibraFit.cxx:4762
 AliTRDCalibraFit.cxx:4763
 AliTRDCalibraFit.cxx:4764
 AliTRDCalibraFit.cxx:4765
 AliTRDCalibraFit.cxx:4766
 AliTRDCalibraFit.cxx:4767
 AliTRDCalibraFit.cxx:4768
 AliTRDCalibraFit.cxx:4769
 AliTRDCalibraFit.cxx:4770
 AliTRDCalibraFit.cxx:4771
 AliTRDCalibraFit.cxx:4772
 AliTRDCalibraFit.cxx:4773
 AliTRDCalibraFit.cxx:4774
 AliTRDCalibraFit.cxx:4775
 AliTRDCalibraFit.cxx:4776
 AliTRDCalibraFit.cxx:4777
 AliTRDCalibraFit.cxx:4778
 AliTRDCalibraFit.cxx:4779
 AliTRDCalibraFit.cxx:4780
 AliTRDCalibraFit.cxx:4781
 AliTRDCalibraFit.cxx:4782
 AliTRDCalibraFit.cxx:4783
 AliTRDCalibraFit.cxx:4784
 AliTRDCalibraFit.cxx:4785
 AliTRDCalibraFit.cxx:4786
 AliTRDCalibraFit.cxx:4787
 AliTRDCalibraFit.cxx:4788
 AliTRDCalibraFit.cxx:4789
 AliTRDCalibraFit.cxx:4790
 AliTRDCalibraFit.cxx:4791
 AliTRDCalibraFit.cxx:4792
 AliTRDCalibraFit.cxx:4793
 AliTRDCalibraFit.cxx:4794
 AliTRDCalibraFit.cxx:4795
 AliTRDCalibraFit.cxx:4796
 AliTRDCalibraFit.cxx:4797
 AliTRDCalibraFit.cxx:4798
 AliTRDCalibraFit.cxx:4799
 AliTRDCalibraFit.cxx:4800
 AliTRDCalibraFit.cxx:4801
 AliTRDCalibraFit.cxx:4802
 AliTRDCalibraFit.cxx:4803
 AliTRDCalibraFit.cxx:4804
 AliTRDCalibraFit.cxx:4805
 AliTRDCalibraFit.cxx:4806
 AliTRDCalibraFit.cxx:4807
 AliTRDCalibraFit.cxx:4808
 AliTRDCalibraFit.cxx:4809
 AliTRDCalibraFit.cxx:4810
 AliTRDCalibraFit.cxx:4811
 AliTRDCalibraFit.cxx:4812
 AliTRDCalibraFit.cxx:4813
 AliTRDCalibraFit.cxx:4814
 AliTRDCalibraFit.cxx:4815
 AliTRDCalibraFit.cxx:4816
 AliTRDCalibraFit.cxx:4817
 AliTRDCalibraFit.cxx:4818
 AliTRDCalibraFit.cxx:4819
 AliTRDCalibraFit.cxx:4820
 AliTRDCalibraFit.cxx:4821
 AliTRDCalibraFit.cxx:4822
 AliTRDCalibraFit.cxx:4823
 AliTRDCalibraFit.cxx:4824
 AliTRDCalibraFit.cxx:4825
 AliTRDCalibraFit.cxx:4826
 AliTRDCalibraFit.cxx:4827
 AliTRDCalibraFit.cxx:4828
 AliTRDCalibraFit.cxx:4829
 AliTRDCalibraFit.cxx:4830
 AliTRDCalibraFit.cxx:4831
 AliTRDCalibraFit.cxx:4832
 AliTRDCalibraFit.cxx:4833
 AliTRDCalibraFit.cxx:4834
 AliTRDCalibraFit.cxx:4835
 AliTRDCalibraFit.cxx:4836
 AliTRDCalibraFit.cxx:4837
 AliTRDCalibraFit.cxx:4838
 AliTRDCalibraFit.cxx:4839
 AliTRDCalibraFit.cxx:4840
 AliTRDCalibraFit.cxx:4841
 AliTRDCalibraFit.cxx:4842
 AliTRDCalibraFit.cxx:4843
 AliTRDCalibraFit.cxx:4844
 AliTRDCalibraFit.cxx:4845
 AliTRDCalibraFit.cxx:4846
 AliTRDCalibraFit.cxx:4847
 AliTRDCalibraFit.cxx:4848
 AliTRDCalibraFit.cxx:4849
 AliTRDCalibraFit.cxx:4850
 AliTRDCalibraFit.cxx:4851
 AliTRDCalibraFit.cxx:4852
 AliTRDCalibraFit.cxx:4853
 AliTRDCalibraFit.cxx:4854
 AliTRDCalibraFit.cxx:4855
 AliTRDCalibraFit.cxx:4856
 AliTRDCalibraFit.cxx:4857
 AliTRDCalibraFit.cxx:4858
 AliTRDCalibraFit.cxx:4859
 AliTRDCalibraFit.cxx:4860
 AliTRDCalibraFit.cxx:4861
 AliTRDCalibraFit.cxx:4862
 AliTRDCalibraFit.cxx:4863
 AliTRDCalibraFit.cxx:4864
 AliTRDCalibraFit.cxx:4865
 AliTRDCalibraFit.cxx:4866
 AliTRDCalibraFit.cxx:4867
 AliTRDCalibraFit.cxx:4868
 AliTRDCalibraFit.cxx:4869
 AliTRDCalibraFit.cxx:4870
 AliTRDCalibraFit.cxx:4871
 AliTRDCalibraFit.cxx:4872
 AliTRDCalibraFit.cxx:4873
 AliTRDCalibraFit.cxx:4874
 AliTRDCalibraFit.cxx:4875
 AliTRDCalibraFit.cxx:4876
 AliTRDCalibraFit.cxx:4877
 AliTRDCalibraFit.cxx:4878
 AliTRDCalibraFit.cxx:4879
 AliTRDCalibraFit.cxx:4880
 AliTRDCalibraFit.cxx:4881
 AliTRDCalibraFit.cxx:4882
 AliTRDCalibraFit.cxx:4883
 AliTRDCalibraFit.cxx:4884
 AliTRDCalibraFit.cxx:4885
 AliTRDCalibraFit.cxx:4886
 AliTRDCalibraFit.cxx:4887
 AliTRDCalibraFit.cxx:4888
 AliTRDCalibraFit.cxx:4889
 AliTRDCalibraFit.cxx:4890
 AliTRDCalibraFit.cxx:4891
 AliTRDCalibraFit.cxx:4892
 AliTRDCalibraFit.cxx:4893
 AliTRDCalibraFit.cxx:4894
 AliTRDCalibraFit.cxx:4895
 AliTRDCalibraFit.cxx:4896
 AliTRDCalibraFit.cxx:4897
 AliTRDCalibraFit.cxx:4898
 AliTRDCalibraFit.cxx:4899
 AliTRDCalibraFit.cxx:4900
 AliTRDCalibraFit.cxx:4901
 AliTRDCalibraFit.cxx:4902
 AliTRDCalibraFit.cxx:4903
 AliTRDCalibraFit.cxx:4904
 AliTRDCalibraFit.cxx:4905
 AliTRDCalibraFit.cxx:4906
 AliTRDCalibraFit.cxx:4907
 AliTRDCalibraFit.cxx:4908
 AliTRDCalibraFit.cxx:4909
 AliTRDCalibraFit.cxx:4910
 AliTRDCalibraFit.cxx:4911
 AliTRDCalibraFit.cxx:4912
 AliTRDCalibraFit.cxx:4913
 AliTRDCalibraFit.cxx:4914
 AliTRDCalibraFit.cxx:4915
 AliTRDCalibraFit.cxx:4916
 AliTRDCalibraFit.cxx:4917
 AliTRDCalibraFit.cxx:4918
 AliTRDCalibraFit.cxx:4919
 AliTRDCalibraFit.cxx:4920
 AliTRDCalibraFit.cxx:4921
 AliTRDCalibraFit.cxx:4922
 AliTRDCalibraFit.cxx:4923
 AliTRDCalibraFit.cxx:4924
 AliTRDCalibraFit.cxx:4925
 AliTRDCalibraFit.cxx:4926
 AliTRDCalibraFit.cxx:4927
 AliTRDCalibraFit.cxx:4928
 AliTRDCalibraFit.cxx:4929
 AliTRDCalibraFit.cxx:4930
 AliTRDCalibraFit.cxx:4931
 AliTRDCalibraFit.cxx:4932
 AliTRDCalibraFit.cxx:4933
 AliTRDCalibraFit.cxx:4934
 AliTRDCalibraFit.cxx:4935
 AliTRDCalibraFit.cxx:4936
 AliTRDCalibraFit.cxx:4937
 AliTRDCalibraFit.cxx:4938
 AliTRDCalibraFit.cxx:4939
 AliTRDCalibraFit.cxx:4940
 AliTRDCalibraFit.cxx:4941
 AliTRDCalibraFit.cxx:4942
 AliTRDCalibraFit.cxx:4943
 AliTRDCalibraFit.cxx:4944
 AliTRDCalibraFit.cxx:4945
 AliTRDCalibraFit.cxx:4946
 AliTRDCalibraFit.cxx:4947
 AliTRDCalibraFit.cxx:4948
 AliTRDCalibraFit.cxx:4949
 AliTRDCalibraFit.cxx:4950
 AliTRDCalibraFit.cxx:4951
 AliTRDCalibraFit.cxx:4952
 AliTRDCalibraFit.cxx:4953
 AliTRDCalibraFit.cxx:4954
 AliTRDCalibraFit.cxx:4955
 AliTRDCalibraFit.cxx:4956
 AliTRDCalibraFit.cxx:4957
 AliTRDCalibraFit.cxx:4958
 AliTRDCalibraFit.cxx:4959
 AliTRDCalibraFit.cxx:4960
 AliTRDCalibraFit.cxx:4961
 AliTRDCalibraFit.cxx:4962
 AliTRDCalibraFit.cxx:4963
 AliTRDCalibraFit.cxx:4964
 AliTRDCalibraFit.cxx:4965
 AliTRDCalibraFit.cxx:4966
 AliTRDCalibraFit.cxx:4967
 AliTRDCalibraFit.cxx:4968
 AliTRDCalibraFit.cxx:4969
 AliTRDCalibraFit.cxx:4970
 AliTRDCalibraFit.cxx:4971
 AliTRDCalibraFit.cxx:4972
 AliTRDCalibraFit.cxx:4973
 AliTRDCalibraFit.cxx:4974
 AliTRDCalibraFit.cxx:4975
 AliTRDCalibraFit.cxx:4976
 AliTRDCalibraFit.cxx:4977
 AliTRDCalibraFit.cxx:4978
 AliTRDCalibraFit.cxx:4979
 AliTRDCalibraFit.cxx:4980
 AliTRDCalibraFit.cxx:4981
 AliTRDCalibraFit.cxx:4982
 AliTRDCalibraFit.cxx:4983
 AliTRDCalibraFit.cxx:4984
 AliTRDCalibraFit.cxx:4985
 AliTRDCalibraFit.cxx:4986
 AliTRDCalibraFit.cxx:4987
 AliTRDCalibraFit.cxx:4988
 AliTRDCalibraFit.cxx:4989
 AliTRDCalibraFit.cxx:4990
 AliTRDCalibraFit.cxx:4991
 AliTRDCalibraFit.cxx:4992
 AliTRDCalibraFit.cxx:4993
 AliTRDCalibraFit.cxx:4994
 AliTRDCalibraFit.cxx:4995
 AliTRDCalibraFit.cxx:4996
 AliTRDCalibraFit.cxx:4997
 AliTRDCalibraFit.cxx:4998
 AliTRDCalibraFit.cxx:4999
 AliTRDCalibraFit.cxx:5000
 AliTRDCalibraFit.cxx:5001
 AliTRDCalibraFit.cxx:5002
 AliTRDCalibraFit.cxx:5003
 AliTRDCalibraFit.cxx:5004
 AliTRDCalibraFit.cxx:5005
 AliTRDCalibraFit.cxx:5006
 AliTRDCalibraFit.cxx:5007
 AliTRDCalibraFit.cxx:5008
 AliTRDCalibraFit.cxx:5009
 AliTRDCalibraFit.cxx:5010
 AliTRDCalibraFit.cxx:5011
 AliTRDCalibraFit.cxx:5012
 AliTRDCalibraFit.cxx:5013
 AliTRDCalibraFit.cxx:5014
 AliTRDCalibraFit.cxx:5015
 AliTRDCalibraFit.cxx:5016
 AliTRDCalibraFit.cxx:5017
 AliTRDCalibraFit.cxx:5018
 AliTRDCalibraFit.cxx:5019
 AliTRDCalibraFit.cxx:5020
 AliTRDCalibraFit.cxx:5021
 AliTRDCalibraFit.cxx:5022
 AliTRDCalibraFit.cxx:5023
 AliTRDCalibraFit.cxx:5024
 AliTRDCalibraFit.cxx:5025
 AliTRDCalibraFit.cxx:5026
 AliTRDCalibraFit.cxx:5027
 AliTRDCalibraFit.cxx:5028
 AliTRDCalibraFit.cxx:5029
 AliTRDCalibraFit.cxx:5030
 AliTRDCalibraFit.cxx:5031
 AliTRDCalibraFit.cxx:5032
 AliTRDCalibraFit.cxx:5033
 AliTRDCalibraFit.cxx:5034
 AliTRDCalibraFit.cxx:5035
 AliTRDCalibraFit.cxx:5036
 AliTRDCalibraFit.cxx:5037
 AliTRDCalibraFit.cxx:5038
 AliTRDCalibraFit.cxx:5039
 AliTRDCalibraFit.cxx:5040
 AliTRDCalibraFit.cxx:5041
 AliTRDCalibraFit.cxx:5042
 AliTRDCalibraFit.cxx:5043
 AliTRDCalibraFit.cxx:5044
 AliTRDCalibraFit.cxx:5045
 AliTRDCalibraFit.cxx:5046
 AliTRDCalibraFit.cxx:5047
 AliTRDCalibraFit.cxx:5048
 AliTRDCalibraFit.cxx:5049
 AliTRDCalibraFit.cxx:5050
 AliTRDCalibraFit.cxx:5051
 AliTRDCalibraFit.cxx:5052
 AliTRDCalibraFit.cxx:5053
 AliTRDCalibraFit.cxx:5054
 AliTRDCalibraFit.cxx:5055
 AliTRDCalibraFit.cxx:5056
 AliTRDCalibraFit.cxx:5057
 AliTRDCalibraFit.cxx:5058
 AliTRDCalibraFit.cxx:5059
 AliTRDCalibraFit.cxx:5060
 AliTRDCalibraFit.cxx:5061
 AliTRDCalibraFit.cxx:5062
 AliTRDCalibraFit.cxx:5063
 AliTRDCalibraFit.cxx:5064
 AliTRDCalibraFit.cxx:5065
 AliTRDCalibraFit.cxx:5066
 AliTRDCalibraFit.cxx:5067
 AliTRDCalibraFit.cxx:5068
 AliTRDCalibraFit.cxx:5069
 AliTRDCalibraFit.cxx:5070
 AliTRDCalibraFit.cxx:5071
 AliTRDCalibraFit.cxx:5072
 AliTRDCalibraFit.cxx:5073
 AliTRDCalibraFit.cxx:5074
 AliTRDCalibraFit.cxx:5075
 AliTRDCalibraFit.cxx:5076
 AliTRDCalibraFit.cxx:5077
 AliTRDCalibraFit.cxx:5078
 AliTRDCalibraFit.cxx:5079
 AliTRDCalibraFit.cxx:5080
 AliTRDCalibraFit.cxx:5081
 AliTRDCalibraFit.cxx:5082
 AliTRDCalibraFit.cxx:5083
 AliTRDCalibraFit.cxx:5084
 AliTRDCalibraFit.cxx:5085
 AliTRDCalibraFit.cxx:5086
 AliTRDCalibraFit.cxx:5087
 AliTRDCalibraFit.cxx:5088
 AliTRDCalibraFit.cxx:5089
 AliTRDCalibraFit.cxx:5090
 AliTRDCalibraFit.cxx:5091
 AliTRDCalibraFit.cxx:5092
 AliTRDCalibraFit.cxx:5093
 AliTRDCalibraFit.cxx:5094
 AliTRDCalibraFit.cxx:5095
 AliTRDCalibraFit.cxx:5096
 AliTRDCalibraFit.cxx:5097
 AliTRDCalibraFit.cxx:5098
 AliTRDCalibraFit.cxx:5099
 AliTRDCalibraFit.cxx:5100
 AliTRDCalibraFit.cxx:5101
 AliTRDCalibraFit.cxx:5102
 AliTRDCalibraFit.cxx:5103
 AliTRDCalibraFit.cxx:5104
 AliTRDCalibraFit.cxx:5105
 AliTRDCalibraFit.cxx:5106
 AliTRDCalibraFit.cxx:5107
 AliTRDCalibraFit.cxx:5108
 AliTRDCalibraFit.cxx:5109
 AliTRDCalibraFit.cxx:5110
 AliTRDCalibraFit.cxx:5111
 AliTRDCalibraFit.cxx:5112
 AliTRDCalibraFit.cxx:5113
 AliTRDCalibraFit.cxx:5114
 AliTRDCalibraFit.cxx:5115
 AliTRDCalibraFit.cxx:5116
 AliTRDCalibraFit.cxx:5117
 AliTRDCalibraFit.cxx:5118
 AliTRDCalibraFit.cxx:5119
 AliTRDCalibraFit.cxx:5120
 AliTRDCalibraFit.cxx:5121
 AliTRDCalibraFit.cxx:5122
 AliTRDCalibraFit.cxx:5123
 AliTRDCalibraFit.cxx:5124
 AliTRDCalibraFit.cxx:5125
 AliTRDCalibraFit.cxx:5126
 AliTRDCalibraFit.cxx:5127
 AliTRDCalibraFit.cxx:5128
 AliTRDCalibraFit.cxx:5129
 AliTRDCalibraFit.cxx:5130
 AliTRDCalibraFit.cxx:5131
 AliTRDCalibraFit.cxx:5132
 AliTRDCalibraFit.cxx:5133
 AliTRDCalibraFit.cxx:5134
 AliTRDCalibraFit.cxx:5135
 AliTRDCalibraFit.cxx:5136
 AliTRDCalibraFit.cxx:5137
 AliTRDCalibraFit.cxx:5138
 AliTRDCalibraFit.cxx:5139
 AliTRDCalibraFit.cxx:5140
 AliTRDCalibraFit.cxx:5141
 AliTRDCalibraFit.cxx:5142
 AliTRDCalibraFit.cxx:5143
 AliTRDCalibraFit.cxx:5144
 AliTRDCalibraFit.cxx:5145
 AliTRDCalibraFit.cxx:5146
 AliTRDCalibraFit.cxx:5147
 AliTRDCalibraFit.cxx:5148
 AliTRDCalibraFit.cxx:5149
 AliTRDCalibraFit.cxx:5150
 AliTRDCalibraFit.cxx:5151
 AliTRDCalibraFit.cxx:5152
 AliTRDCalibraFit.cxx:5153
 AliTRDCalibraFit.cxx:5154
 AliTRDCalibraFit.cxx:5155
 AliTRDCalibraFit.cxx:5156
 AliTRDCalibraFit.cxx:5157
 AliTRDCalibraFit.cxx:5158
 AliTRDCalibraFit.cxx:5159
 AliTRDCalibraFit.cxx:5160
 AliTRDCalibraFit.cxx:5161
 AliTRDCalibraFit.cxx:5162
 AliTRDCalibraFit.cxx:5163
 AliTRDCalibraFit.cxx:5164
 AliTRDCalibraFit.cxx:5165
 AliTRDCalibraFit.cxx:5166
 AliTRDCalibraFit.cxx:5167
 AliTRDCalibraFit.cxx:5168
 AliTRDCalibraFit.cxx:5169
 AliTRDCalibraFit.cxx:5170
 AliTRDCalibraFit.cxx:5171
 AliTRDCalibraFit.cxx:5172
 AliTRDCalibraFit.cxx:5173
 AliTRDCalibraFit.cxx:5174
 AliTRDCalibraFit.cxx:5175
 AliTRDCalibraFit.cxx:5176
 AliTRDCalibraFit.cxx:5177
 AliTRDCalibraFit.cxx:5178
 AliTRDCalibraFit.cxx:5179
 AliTRDCalibraFit.cxx:5180
 AliTRDCalibraFit.cxx:5181
 AliTRDCalibraFit.cxx:5182
 AliTRDCalibraFit.cxx:5183
 AliTRDCalibraFit.cxx:5184
 AliTRDCalibraFit.cxx:5185
 AliTRDCalibraFit.cxx:5186
 AliTRDCalibraFit.cxx:5187
 AliTRDCalibraFit.cxx:5188
 AliTRDCalibraFit.cxx:5189
 AliTRDCalibraFit.cxx:5190
 AliTRDCalibraFit.cxx:5191
 AliTRDCalibraFit.cxx:5192
 AliTRDCalibraFit.cxx:5193
 AliTRDCalibraFit.cxx:5194
 AliTRDCalibraFit.cxx:5195
 AliTRDCalibraFit.cxx:5196
 AliTRDCalibraFit.cxx:5197
 AliTRDCalibraFit.cxx:5198
 AliTRDCalibraFit.cxx:5199
 AliTRDCalibraFit.cxx:5200
 AliTRDCalibraFit.cxx:5201
 AliTRDCalibraFit.cxx:5202
 AliTRDCalibraFit.cxx:5203
 AliTRDCalibraFit.cxx:5204
 AliTRDCalibraFit.cxx:5205
 AliTRDCalibraFit.cxx:5206
 AliTRDCalibraFit.cxx:5207
 AliTRDCalibraFit.cxx:5208
 AliTRDCalibraFit.cxx:5209
 AliTRDCalibraFit.cxx:5210
 AliTRDCalibraFit.cxx:5211
 AliTRDCalibraFit.cxx:5212
 AliTRDCalibraFit.cxx:5213
 AliTRDCalibraFit.cxx:5214
 AliTRDCalibraFit.cxx:5215
 AliTRDCalibraFit.cxx:5216
 AliTRDCalibraFit.cxx:5217
 AliTRDCalibraFit.cxx:5218
 AliTRDCalibraFit.cxx:5219
 AliTRDCalibraFit.cxx:5220
 AliTRDCalibraFit.cxx:5221
 AliTRDCalibraFit.cxx:5222
 AliTRDCalibraFit.cxx:5223
 AliTRDCalibraFit.cxx:5224
 AliTRDCalibraFit.cxx:5225
 AliTRDCalibraFit.cxx:5226
 AliTRDCalibraFit.cxx:5227
 AliTRDCalibraFit.cxx:5228
 AliTRDCalibraFit.cxx:5229
 AliTRDCalibraFit.cxx:5230
 AliTRDCalibraFit.cxx:5231
 AliTRDCalibraFit.cxx:5232
 AliTRDCalibraFit.cxx:5233
 AliTRDCalibraFit.cxx:5234
 AliTRDCalibraFit.cxx:5235
 AliTRDCalibraFit.cxx:5236
 AliTRDCalibraFit.cxx:5237
 AliTRDCalibraFit.cxx:5238
 AliTRDCalibraFit.cxx:5239
 AliTRDCalibraFit.cxx:5240
 AliTRDCalibraFit.cxx:5241
 AliTRDCalibraFit.cxx:5242
 AliTRDCalibraFit.cxx:5243
 AliTRDCalibraFit.cxx:5244
 AliTRDCalibraFit.cxx:5245
 AliTRDCalibraFit.cxx:5246
 AliTRDCalibraFit.cxx:5247
 AliTRDCalibraFit.cxx:5248
 AliTRDCalibraFit.cxx:5249
 AliTRDCalibraFit.cxx:5250
 AliTRDCalibraFit.cxx:5251
 AliTRDCalibraFit.cxx:5252
 AliTRDCalibraFit.cxx:5253
 AliTRDCalibraFit.cxx:5254
 AliTRDCalibraFit.cxx:5255
 AliTRDCalibraFit.cxx:5256
 AliTRDCalibraFit.cxx:5257
 AliTRDCalibraFit.cxx:5258
 AliTRDCalibraFit.cxx:5259
 AliTRDCalibraFit.cxx:5260
 AliTRDCalibraFit.cxx:5261
 AliTRDCalibraFit.cxx:5262
 AliTRDCalibraFit.cxx:5263
 AliTRDCalibraFit.cxx:5264
 AliTRDCalibraFit.cxx:5265
 AliTRDCalibraFit.cxx:5266
 AliTRDCalibraFit.cxx:5267
 AliTRDCalibraFit.cxx:5268
 AliTRDCalibraFit.cxx:5269
 AliTRDCalibraFit.cxx:5270
 AliTRDCalibraFit.cxx:5271
 AliTRDCalibraFit.cxx:5272
 AliTRDCalibraFit.cxx:5273
 AliTRDCalibraFit.cxx:5274
 AliTRDCalibraFit.cxx:5275
 AliTRDCalibraFit.cxx:5276
 AliTRDCalibraFit.cxx:5277
 AliTRDCalibraFit.cxx:5278
 AliTRDCalibraFit.cxx:5279
 AliTRDCalibraFit.cxx:5280
 AliTRDCalibraFit.cxx:5281
 AliTRDCalibraFit.cxx:5282
 AliTRDCalibraFit.cxx:5283
 AliTRDCalibraFit.cxx:5284
 AliTRDCalibraFit.cxx:5285
 AliTRDCalibraFit.cxx:5286
 AliTRDCalibraFit.cxx:5287
 AliTRDCalibraFit.cxx:5288
 AliTRDCalibraFit.cxx:5289
 AliTRDCalibraFit.cxx:5290
 AliTRDCalibraFit.cxx:5291
 AliTRDCalibraFit.cxx:5292
 AliTRDCalibraFit.cxx:5293
 AliTRDCalibraFit.cxx:5294
 AliTRDCalibraFit.cxx:5295
 AliTRDCalibraFit.cxx:5296
 AliTRDCalibraFit.cxx:5297
 AliTRDCalibraFit.cxx:5298
 AliTRDCalibraFit.cxx:5299
 AliTRDCalibraFit.cxx:5300
 AliTRDCalibraFit.cxx:5301
 AliTRDCalibraFit.cxx:5302
 AliTRDCalibraFit.cxx:5303
 AliTRDCalibraFit.cxx:5304
 AliTRDCalibraFit.cxx:5305
 AliTRDCalibraFit.cxx:5306
 AliTRDCalibraFit.cxx:5307
 AliTRDCalibraFit.cxx:5308
 AliTRDCalibraFit.cxx:5309
 AliTRDCalibraFit.cxx:5310
 AliTRDCalibraFit.cxx:5311
 AliTRDCalibraFit.cxx:5312
 AliTRDCalibraFit.cxx:5313
 AliTRDCalibraFit.cxx:5314
 AliTRDCalibraFit.cxx:5315
 AliTRDCalibraFit.cxx:5316
 AliTRDCalibraFit.cxx:5317
 AliTRDCalibraFit.cxx:5318
 AliTRDCalibraFit.cxx:5319
 AliTRDCalibraFit.cxx:5320
 AliTRDCalibraFit.cxx:5321
 AliTRDCalibraFit.cxx:5322
 AliTRDCalibraFit.cxx:5323
 AliTRDCalibraFit.cxx:5324
 AliTRDCalibraFit.cxx:5325
 AliTRDCalibraFit.cxx:5326
 AliTRDCalibraFit.cxx:5327
 AliTRDCalibraFit.cxx:5328
 AliTRDCalibraFit.cxx:5329
 AliTRDCalibraFit.cxx:5330
 AliTRDCalibraFit.cxx:5331
 AliTRDCalibraFit.cxx:5332
 AliTRDCalibraFit.cxx:5333
 AliTRDCalibraFit.cxx:5334
 AliTRDCalibraFit.cxx:5335
 AliTRDCalibraFit.cxx:5336
 AliTRDCalibraFit.cxx:5337
 AliTRDCalibraFit.cxx:5338
 AliTRDCalibraFit.cxx:5339
 AliTRDCalibraFit.cxx:5340
 AliTRDCalibraFit.cxx:5341
 AliTRDCalibraFit.cxx:5342
 AliTRDCalibraFit.cxx:5343
 AliTRDCalibraFit.cxx:5344
 AliTRDCalibraFit.cxx:5345
 AliTRDCalibraFit.cxx:5346
 AliTRDCalibraFit.cxx:5347
 AliTRDCalibraFit.cxx:5348
 AliTRDCalibraFit.cxx:5349
 AliTRDCalibraFit.cxx:5350
 AliTRDCalibraFit.cxx:5351
 AliTRDCalibraFit.cxx:5352
 AliTRDCalibraFit.cxx:5353
 AliTRDCalibraFit.cxx:5354
 AliTRDCalibraFit.cxx:5355
 AliTRDCalibraFit.cxx:5356
 AliTRDCalibraFit.cxx:5357
 AliTRDCalibraFit.cxx:5358
 AliTRDCalibraFit.cxx:5359
 AliTRDCalibraFit.cxx:5360
 AliTRDCalibraFit.cxx:5361
 AliTRDCalibraFit.cxx:5362
 AliTRDCalibraFit.cxx:5363
 AliTRDCalibraFit.cxx:5364
 AliTRDCalibraFit.cxx:5365
 AliTRDCalibraFit.cxx:5366
 AliTRDCalibraFit.cxx:5367
 AliTRDCalibraFit.cxx:5368
 AliTRDCalibraFit.cxx:5369
 AliTRDCalibraFit.cxx:5370
 AliTRDCalibraFit.cxx:5371
 AliTRDCalibraFit.cxx:5372
 AliTRDCalibraFit.cxx:5373
 AliTRDCalibraFit.cxx:5374
 AliTRDCalibraFit.cxx:5375
 AliTRDCalibraFit.cxx:5376
 AliTRDCalibraFit.cxx:5377
 AliTRDCalibraFit.cxx:5378
 AliTRDCalibraFit.cxx:5379
 AliTRDCalibraFit.cxx:5380
 AliTRDCalibraFit.cxx:5381
 AliTRDCalibraFit.cxx:5382
 AliTRDCalibraFit.cxx:5383
 AliTRDCalibraFit.cxx:5384
 AliTRDCalibraFit.cxx:5385
 AliTRDCalibraFit.cxx:5386
 AliTRDCalibraFit.cxx:5387
 AliTRDCalibraFit.cxx:5388
 AliTRDCalibraFit.cxx:5389
 AliTRDCalibraFit.cxx:5390
 AliTRDCalibraFit.cxx:5391
 AliTRDCalibraFit.cxx:5392
 AliTRDCalibraFit.cxx:5393
 AliTRDCalibraFit.cxx:5394
 AliTRDCalibraFit.cxx:5395
 AliTRDCalibraFit.cxx:5396
 AliTRDCalibraFit.cxx:5397
 AliTRDCalibraFit.cxx:5398
 AliTRDCalibraFit.cxx:5399
 AliTRDCalibraFit.cxx:5400
 AliTRDCalibraFit.cxx:5401
 AliTRDCalibraFit.cxx:5402
 AliTRDCalibraFit.cxx:5403
 AliTRDCalibraFit.cxx:5404
 AliTRDCalibraFit.cxx:5405
 AliTRDCalibraFit.cxx:5406
 AliTRDCalibraFit.cxx:5407
 AliTRDCalibraFit.cxx:5408
 AliTRDCalibraFit.cxx:5409
 AliTRDCalibraFit.cxx:5410
 AliTRDCalibraFit.cxx:5411
 AliTRDCalibraFit.cxx:5412
 AliTRDCalibraFit.cxx:5413
 AliTRDCalibraFit.cxx:5414
 AliTRDCalibraFit.cxx:5415
 AliTRDCalibraFit.cxx:5416
 AliTRDCalibraFit.cxx:5417
 AliTRDCalibraFit.cxx:5418
 AliTRDCalibraFit.cxx:5419
 AliTRDCalibraFit.cxx:5420
 AliTRDCalibraFit.cxx:5421
 AliTRDCalibraFit.cxx:5422
 AliTRDCalibraFit.cxx:5423
 AliTRDCalibraFit.cxx:5424
 AliTRDCalibraFit.cxx:5425
 AliTRDCalibraFit.cxx:5426
 AliTRDCalibraFit.cxx:5427
 AliTRDCalibraFit.cxx:5428
 AliTRDCalibraFit.cxx:5429
 AliTRDCalibraFit.cxx:5430
 AliTRDCalibraFit.cxx:5431
 AliTRDCalibraFit.cxx:5432
 AliTRDCalibraFit.cxx:5433
 AliTRDCalibraFit.cxx:5434
 AliTRDCalibraFit.cxx:5435
 AliTRDCalibraFit.cxx:5436
 AliTRDCalibraFit.cxx:5437
 AliTRDCalibraFit.cxx:5438
 AliTRDCalibraFit.cxx:5439
 AliTRDCalibraFit.cxx:5440
 AliTRDCalibraFit.cxx:5441
 AliTRDCalibraFit.cxx:5442
 AliTRDCalibraFit.cxx:5443
 AliTRDCalibraFit.cxx:5444
 AliTRDCalibraFit.cxx:5445
 AliTRDCalibraFit.cxx:5446
 AliTRDCalibraFit.cxx:5447
 AliTRDCalibraFit.cxx:5448
 AliTRDCalibraFit.cxx:5449
 AliTRDCalibraFit.cxx:5450
 AliTRDCalibraFit.cxx:5451
 AliTRDCalibraFit.cxx:5452
 AliTRDCalibraFit.cxx:5453
 AliTRDCalibraFit.cxx:5454
 AliTRDCalibraFit.cxx:5455
 AliTRDCalibraFit.cxx:5456
 AliTRDCalibraFit.cxx:5457
 AliTRDCalibraFit.cxx:5458
 AliTRDCalibraFit.cxx:5459
 AliTRDCalibraFit.cxx:5460
 AliTRDCalibraFit.cxx:5461
 AliTRDCalibraFit.cxx:5462
 AliTRDCalibraFit.cxx:5463
 AliTRDCalibraFit.cxx:5464
 AliTRDCalibraFit.cxx:5465
 AliTRDCalibraFit.cxx:5466
 AliTRDCalibraFit.cxx:5467
 AliTRDCalibraFit.cxx:5468
 AliTRDCalibraFit.cxx:5469
 AliTRDCalibraFit.cxx:5470
 AliTRDCalibraFit.cxx:5471
 AliTRDCalibraFit.cxx:5472
 AliTRDCalibraFit.cxx:5473
 AliTRDCalibraFit.cxx:5474
 AliTRDCalibraFit.cxx:5475
 AliTRDCalibraFit.cxx:5476
 AliTRDCalibraFit.cxx:5477
 AliTRDCalibraFit.cxx:5478
 AliTRDCalibraFit.cxx:5479
 AliTRDCalibraFit.cxx:5480
 AliTRDCalibraFit.cxx:5481
 AliTRDCalibraFit.cxx:5482
 AliTRDCalibraFit.cxx:5483
 AliTRDCalibraFit.cxx:5484
 AliTRDCalibraFit.cxx:5485
 AliTRDCalibraFit.cxx:5486
 AliTRDCalibraFit.cxx:5487
 AliTRDCalibraFit.cxx:5488
 AliTRDCalibraFit.cxx:5489
 AliTRDCalibraFit.cxx:5490
 AliTRDCalibraFit.cxx:5491
 AliTRDCalibraFit.cxx:5492
 AliTRDCalibraFit.cxx:5493
 AliTRDCalibraFit.cxx:5494
 AliTRDCalibraFit.cxx:5495
 AliTRDCalibraFit.cxx:5496
 AliTRDCalibraFit.cxx:5497
 AliTRDCalibraFit.cxx:5498
 AliTRDCalibraFit.cxx:5499
 AliTRDCalibraFit.cxx:5500
 AliTRDCalibraFit.cxx:5501
 AliTRDCalibraFit.cxx:5502
 AliTRDCalibraFit.cxx:5503
 AliTRDCalibraFit.cxx:5504
 AliTRDCalibraFit.cxx:5505
 AliTRDCalibraFit.cxx:5506
 AliTRDCalibraFit.cxx:5507
 AliTRDCalibraFit.cxx:5508
 AliTRDCalibraFit.cxx:5509
 AliTRDCalibraFit.cxx:5510
 AliTRDCalibraFit.cxx:5511
 AliTRDCalibraFit.cxx:5512
 AliTRDCalibraFit.cxx:5513
 AliTRDCalibraFit.cxx:5514
 AliTRDCalibraFit.cxx:5515
 AliTRDCalibraFit.cxx:5516
 AliTRDCalibraFit.cxx:5517
 AliTRDCalibraFit.cxx:5518
 AliTRDCalibraFit.cxx:5519
 AliTRDCalibraFit.cxx:5520
 AliTRDCalibraFit.cxx:5521
 AliTRDCalibraFit.cxx:5522
 AliTRDCalibraFit.cxx:5523
 AliTRDCalibraFit.cxx:5524
 AliTRDCalibraFit.cxx:5525
 AliTRDCalibraFit.cxx:5526
 AliTRDCalibraFit.cxx:5527
 AliTRDCalibraFit.cxx:5528
 AliTRDCalibraFit.cxx:5529
 AliTRDCalibraFit.cxx:5530
 AliTRDCalibraFit.cxx:5531
 AliTRDCalibraFit.cxx:5532
 AliTRDCalibraFit.cxx:5533
 AliTRDCalibraFit.cxx:5534
 AliTRDCalibraFit.cxx:5535
 AliTRDCalibraFit.cxx:5536
 AliTRDCalibraFit.cxx:5537
 AliTRDCalibraFit.cxx:5538
 AliTRDCalibraFit.cxx:5539
 AliTRDCalibraFit.cxx:5540
 AliTRDCalibraFit.cxx:5541
 AliTRDCalibraFit.cxx:5542
 AliTRDCalibraFit.cxx:5543
 AliTRDCalibraFit.cxx:5544
 AliTRDCalibraFit.cxx:5545
 AliTRDCalibraFit.cxx:5546
 AliTRDCalibraFit.cxx:5547
 AliTRDCalibraFit.cxx:5548
 AliTRDCalibraFit.cxx:5549
 AliTRDCalibraFit.cxx:5550
 AliTRDCalibraFit.cxx:5551
 AliTRDCalibraFit.cxx:5552
 AliTRDCalibraFit.cxx:5553
 AliTRDCalibraFit.cxx:5554
 AliTRDCalibraFit.cxx:5555
 AliTRDCalibraFit.cxx:5556
 AliTRDCalibraFit.cxx:5557
 AliTRDCalibraFit.cxx:5558
 AliTRDCalibraFit.cxx:5559
 AliTRDCalibraFit.cxx:5560
 AliTRDCalibraFit.cxx:5561
 AliTRDCalibraFit.cxx:5562
 AliTRDCalibraFit.cxx:5563
 AliTRDCalibraFit.cxx:5564
 AliTRDCalibraFit.cxx:5565
 AliTRDCalibraFit.cxx:5566
 AliTRDCalibraFit.cxx:5567
 AliTRDCalibraFit.cxx:5568
 AliTRDCalibraFit.cxx:5569
 AliTRDCalibraFit.cxx:5570
 AliTRDCalibraFit.cxx:5571
 AliTRDCalibraFit.cxx:5572
 AliTRDCalibraFit.cxx:5573
 AliTRDCalibraFit.cxx:5574
 AliTRDCalibraFit.cxx:5575
 AliTRDCalibraFit.cxx:5576
 AliTRDCalibraFit.cxx:5577
 AliTRDCalibraFit.cxx:5578
 AliTRDCalibraFit.cxx:5579
 AliTRDCalibraFit.cxx:5580
 AliTRDCalibraFit.cxx:5581
 AliTRDCalibraFit.cxx:5582
 AliTRDCalibraFit.cxx:5583
 AliTRDCalibraFit.cxx:5584
 AliTRDCalibraFit.cxx:5585
 AliTRDCalibraFit.cxx:5586
 AliTRDCalibraFit.cxx:5587
 AliTRDCalibraFit.cxx:5588
 AliTRDCalibraFit.cxx:5589
 AliTRDCalibraFit.cxx:5590
 AliTRDCalibraFit.cxx:5591
 AliTRDCalibraFit.cxx:5592
 AliTRDCalibraFit.cxx:5593
 AliTRDCalibraFit.cxx:5594
 AliTRDCalibraFit.cxx:5595
 AliTRDCalibraFit.cxx:5596
 AliTRDCalibraFit.cxx:5597
 AliTRDCalibraFit.cxx:5598
 AliTRDCalibraFit.cxx:5599
 AliTRDCalibraFit.cxx:5600
 AliTRDCalibraFit.cxx:5601
 AliTRDCalibraFit.cxx:5602
 AliTRDCalibraFit.cxx:5603
 AliTRDCalibraFit.cxx:5604
 AliTRDCalibraFit.cxx:5605
 AliTRDCalibraFit.cxx:5606
 AliTRDCalibraFit.cxx:5607
 AliTRDCalibraFit.cxx:5608
 AliTRDCalibraFit.cxx:5609
 AliTRDCalibraFit.cxx:5610
 AliTRDCalibraFit.cxx:5611
 AliTRDCalibraFit.cxx:5612
 AliTRDCalibraFit.cxx:5613
 AliTRDCalibraFit.cxx:5614
 AliTRDCalibraFit.cxx:5615
 AliTRDCalibraFit.cxx:5616
 AliTRDCalibraFit.cxx:5617
 AliTRDCalibraFit.cxx:5618
 AliTRDCalibraFit.cxx:5619
 AliTRDCalibraFit.cxx:5620
 AliTRDCalibraFit.cxx:5621
 AliTRDCalibraFit.cxx:5622
 AliTRDCalibraFit.cxx:5623
 AliTRDCalibraFit.cxx:5624
 AliTRDCalibraFit.cxx:5625
 AliTRDCalibraFit.cxx:5626
 AliTRDCalibraFit.cxx:5627
 AliTRDCalibraFit.cxx:5628
 AliTRDCalibraFit.cxx:5629
 AliTRDCalibraFit.cxx:5630
 AliTRDCalibraFit.cxx:5631
 AliTRDCalibraFit.cxx:5632
 AliTRDCalibraFit.cxx:5633
 AliTRDCalibraFit.cxx:5634
 AliTRDCalibraFit.cxx:5635
 AliTRDCalibraFit.cxx:5636
 AliTRDCalibraFit.cxx:5637
 AliTRDCalibraFit.cxx:5638
 AliTRDCalibraFit.cxx:5639
 AliTRDCalibraFit.cxx:5640
 AliTRDCalibraFit.cxx:5641
 AliTRDCalibraFit.cxx:5642
 AliTRDCalibraFit.cxx:5643
 AliTRDCalibraFit.cxx:5644
 AliTRDCalibraFit.cxx:5645
 AliTRDCalibraFit.cxx:5646
 AliTRDCalibraFit.cxx:5647
 AliTRDCalibraFit.cxx:5648
 AliTRDCalibraFit.cxx:5649
 AliTRDCalibraFit.cxx:5650
 AliTRDCalibraFit.cxx:5651
 AliTRDCalibraFit.cxx:5652
 AliTRDCalibraFit.cxx:5653
 AliTRDCalibraFit.cxx:5654
 AliTRDCalibraFit.cxx:5655
 AliTRDCalibraFit.cxx:5656
 AliTRDCalibraFit.cxx:5657
 AliTRDCalibraFit.cxx:5658
 AliTRDCalibraFit.cxx:5659
 AliTRDCalibraFit.cxx:5660
 AliTRDCalibraFit.cxx:5661
 AliTRDCalibraFit.cxx:5662
 AliTRDCalibraFit.cxx:5663
 AliTRDCalibraFit.cxx:5664
 AliTRDCalibraFit.cxx:5665
 AliTRDCalibraFit.cxx:5666
 AliTRDCalibraFit.cxx:5667
 AliTRDCalibraFit.cxx:5668
 AliTRDCalibraFit.cxx:5669
 AliTRDCalibraFit.cxx:5670
 AliTRDCalibraFit.cxx:5671
 AliTRDCalibraFit.cxx:5672
 AliTRDCalibraFit.cxx:5673
 AliTRDCalibraFit.cxx:5674
 AliTRDCalibraFit.cxx:5675
 AliTRDCalibraFit.cxx:5676
 AliTRDCalibraFit.cxx:5677
 AliTRDCalibraFit.cxx:5678
 AliTRDCalibraFit.cxx:5679
 AliTRDCalibraFit.cxx:5680
 AliTRDCalibraFit.cxx:5681
 AliTRDCalibraFit.cxx:5682
 AliTRDCalibraFit.cxx:5683
 AliTRDCalibraFit.cxx:5684
 AliTRDCalibraFit.cxx:5685
 AliTRDCalibraFit.cxx:5686
 AliTRDCalibraFit.cxx:5687
 AliTRDCalibraFit.cxx:5688
 AliTRDCalibraFit.cxx:5689
 AliTRDCalibraFit.cxx:5690
 AliTRDCalibraFit.cxx:5691
 AliTRDCalibraFit.cxx:5692
 AliTRDCalibraFit.cxx:5693
 AliTRDCalibraFit.cxx:5694
 AliTRDCalibraFit.cxx:5695
 AliTRDCalibraFit.cxx:5696
 AliTRDCalibraFit.cxx:5697
 AliTRDCalibraFit.cxx:5698
 AliTRDCalibraFit.cxx:5699
 AliTRDCalibraFit.cxx:5700
 AliTRDCalibraFit.cxx:5701
 AliTRDCalibraFit.cxx:5702
 AliTRDCalibraFit.cxx:5703
 AliTRDCalibraFit.cxx:5704
 AliTRDCalibraFit.cxx:5705
 AliTRDCalibraFit.cxx:5706
 AliTRDCalibraFit.cxx:5707
 AliTRDCalibraFit.cxx:5708
 AliTRDCalibraFit.cxx:5709
 AliTRDCalibraFit.cxx:5710
 AliTRDCalibraFit.cxx:5711
 AliTRDCalibraFit.cxx:5712
 AliTRDCalibraFit.cxx:5713
 AliTRDCalibraFit.cxx:5714
 AliTRDCalibraFit.cxx:5715
 AliTRDCalibraFit.cxx:5716
 AliTRDCalibraFit.cxx:5717
 AliTRDCalibraFit.cxx:5718
 AliTRDCalibraFit.cxx:5719
 AliTRDCalibraFit.cxx:5720
 AliTRDCalibraFit.cxx:5721
 AliTRDCalibraFit.cxx:5722
 AliTRDCalibraFit.cxx:5723
 AliTRDCalibraFit.cxx:5724
 AliTRDCalibraFit.cxx:5725
 AliTRDCalibraFit.cxx:5726
 AliTRDCalibraFit.cxx:5727
 AliTRDCalibraFit.cxx:5728
 AliTRDCalibraFit.cxx:5729
 AliTRDCalibraFit.cxx:5730
 AliTRDCalibraFit.cxx:5731
 AliTRDCalibraFit.cxx:5732
 AliTRDCalibraFit.cxx:5733
 AliTRDCalibraFit.cxx:5734
 AliTRDCalibraFit.cxx:5735
 AliTRDCalibraFit.cxx:5736
 AliTRDCalibraFit.cxx:5737
 AliTRDCalibraFit.cxx:5738
 AliTRDCalibraFit.cxx:5739
 AliTRDCalibraFit.cxx:5740
 AliTRDCalibraFit.cxx:5741
 AliTRDCalibraFit.cxx:5742
 AliTRDCalibraFit.cxx:5743
 AliTRDCalibraFit.cxx:5744
 AliTRDCalibraFit.cxx:5745
 AliTRDCalibraFit.cxx:5746
 AliTRDCalibraFit.cxx:5747
 AliTRDCalibraFit.cxx:5748
 AliTRDCalibraFit.cxx:5749
 AliTRDCalibraFit.cxx:5750
 AliTRDCalibraFit.cxx:5751
 AliTRDCalibraFit.cxx:5752
 AliTRDCalibraFit.cxx:5753
 AliTRDCalibraFit.cxx:5754
 AliTRDCalibraFit.cxx:5755
 AliTRDCalibraFit.cxx:5756
 AliTRDCalibraFit.cxx:5757
 AliTRDCalibraFit.cxx:5758
 AliTRDCalibraFit.cxx:5759
 AliTRDCalibraFit.cxx:5760
 AliTRDCalibraFit.cxx:5761
 AliTRDCalibraFit.cxx:5762
 AliTRDCalibraFit.cxx:5763
 AliTRDCalibraFit.cxx:5764
 AliTRDCalibraFit.cxx:5765
 AliTRDCalibraFit.cxx:5766
 AliTRDCalibraFit.cxx:5767
 AliTRDCalibraFit.cxx:5768
 AliTRDCalibraFit.cxx:5769
 AliTRDCalibraFit.cxx:5770
 AliTRDCalibraFit.cxx:5771
 AliTRDCalibraFit.cxx:5772
 AliTRDCalibraFit.cxx:5773
 AliTRDCalibraFit.cxx:5774
 AliTRDCalibraFit.cxx:5775
 AliTRDCalibraFit.cxx:5776
 AliTRDCalibraFit.cxx:5777
 AliTRDCalibraFit.cxx:5778
 AliTRDCalibraFit.cxx:5779
 AliTRDCalibraFit.cxx:5780
 AliTRDCalibraFit.cxx:5781
 AliTRDCalibraFit.cxx:5782
 AliTRDCalibraFit.cxx:5783
 AliTRDCalibraFit.cxx:5784
 AliTRDCalibraFit.cxx:5785
 AliTRDCalibraFit.cxx:5786
 AliTRDCalibraFit.cxx:5787
 AliTRDCalibraFit.cxx:5788
 AliTRDCalibraFit.cxx:5789
 AliTRDCalibraFit.cxx:5790
 AliTRDCalibraFit.cxx:5791
 AliTRDCalibraFit.cxx:5792
 AliTRDCalibraFit.cxx:5793
 AliTRDCalibraFit.cxx:5794
 AliTRDCalibraFit.cxx:5795
 AliTRDCalibraFit.cxx:5796
 AliTRDCalibraFit.cxx:5797
 AliTRDCalibraFit.cxx:5798
 AliTRDCalibraFit.cxx:5799
 AliTRDCalibraFit.cxx:5800
 AliTRDCalibraFit.cxx:5801
 AliTRDCalibraFit.cxx:5802
 AliTRDCalibraFit.cxx:5803
 AliTRDCalibraFit.cxx:5804
 AliTRDCalibraFit.cxx:5805
 AliTRDCalibraFit.cxx:5806
 AliTRDCalibraFit.cxx:5807
 AliTRDCalibraFit.cxx:5808
 AliTRDCalibraFit.cxx:5809
 AliTRDCalibraFit.cxx:5810
 AliTRDCalibraFit.cxx:5811
 AliTRDCalibraFit.cxx:5812
 AliTRDCalibraFit.cxx:5813
 AliTRDCalibraFit.cxx:5814
 AliTRDCalibraFit.cxx:5815
 AliTRDCalibraFit.cxx:5816
 AliTRDCalibraFit.cxx:5817
 AliTRDCalibraFit.cxx:5818
 AliTRDCalibraFit.cxx:5819
 AliTRDCalibraFit.cxx:5820
 AliTRDCalibraFit.cxx:5821
 AliTRDCalibraFit.cxx:5822
 AliTRDCalibraFit.cxx:5823
 AliTRDCalibraFit.cxx:5824
 AliTRDCalibraFit.cxx:5825
 AliTRDCalibraFit.cxx:5826
 AliTRDCalibraFit.cxx:5827
 AliTRDCalibraFit.cxx:5828
 AliTRDCalibraFit.cxx:5829
 AliTRDCalibraFit.cxx:5830
 AliTRDCalibraFit.cxx:5831
 AliTRDCalibraFit.cxx:5832
 AliTRDCalibraFit.cxx:5833
 AliTRDCalibraFit.cxx:5834
 AliTRDCalibraFit.cxx:5835
 AliTRDCalibraFit.cxx:5836
 AliTRDCalibraFit.cxx:5837
 AliTRDCalibraFit.cxx:5838
 AliTRDCalibraFit.cxx:5839
 AliTRDCalibraFit.cxx:5840
 AliTRDCalibraFit.cxx:5841
 AliTRDCalibraFit.cxx:5842
 AliTRDCalibraFit.cxx:5843
 AliTRDCalibraFit.cxx:5844
 AliTRDCalibraFit.cxx:5845
 AliTRDCalibraFit.cxx:5846
 AliTRDCalibraFit.cxx:5847
 AliTRDCalibraFit.cxx:5848
 AliTRDCalibraFit.cxx:5849
 AliTRDCalibraFit.cxx:5850
 AliTRDCalibraFit.cxx:5851
 AliTRDCalibraFit.cxx:5852
 AliTRDCalibraFit.cxx:5853
 AliTRDCalibraFit.cxx:5854
 AliTRDCalibraFit.cxx:5855
 AliTRDCalibraFit.cxx:5856
 AliTRDCalibraFit.cxx:5857
 AliTRDCalibraFit.cxx:5858
 AliTRDCalibraFit.cxx:5859
 AliTRDCalibraFit.cxx:5860
 AliTRDCalibraFit.cxx:5861
 AliTRDCalibraFit.cxx:5862
 AliTRDCalibraFit.cxx:5863
 AliTRDCalibraFit.cxx:5864
 AliTRDCalibraFit.cxx:5865
 AliTRDCalibraFit.cxx:5866
 AliTRDCalibraFit.cxx:5867
 AliTRDCalibraFit.cxx:5868
 AliTRDCalibraFit.cxx:5869
 AliTRDCalibraFit.cxx:5870
 AliTRDCalibraFit.cxx:5871
 AliTRDCalibraFit.cxx:5872
 AliTRDCalibraFit.cxx:5873
 AliTRDCalibraFit.cxx:5874
 AliTRDCalibraFit.cxx:5875
 AliTRDCalibraFit.cxx:5876
 AliTRDCalibraFit.cxx:5877
 AliTRDCalibraFit.cxx:5878
 AliTRDCalibraFit.cxx:5879
 AliTRDCalibraFit.cxx:5880
 AliTRDCalibraFit.cxx:5881
 AliTRDCalibraFit.cxx:5882
 AliTRDCalibraFit.cxx:5883
 AliTRDCalibraFit.cxx:5884
 AliTRDCalibraFit.cxx:5885
 AliTRDCalibraFit.cxx:5886
 AliTRDCalibraFit.cxx:5887
 AliTRDCalibraFit.cxx:5888
 AliTRDCalibraFit.cxx:5889
 AliTRDCalibraFit.cxx:5890
 AliTRDCalibraFit.cxx:5891
 AliTRDCalibraFit.cxx:5892
 AliTRDCalibraFit.cxx:5893
 AliTRDCalibraFit.cxx:5894
 AliTRDCalibraFit.cxx:5895
 AliTRDCalibraFit.cxx:5896
 AliTRDCalibraFit.cxx:5897
 AliTRDCalibraFit.cxx:5898
 AliTRDCalibraFit.cxx:5899
 AliTRDCalibraFit.cxx:5900
 AliTRDCalibraFit.cxx:5901
 AliTRDCalibraFit.cxx:5902
 AliTRDCalibraFit.cxx:5903
 AliTRDCalibraFit.cxx:5904
 AliTRDCalibraFit.cxx:5905
 AliTRDCalibraFit.cxx:5906
 AliTRDCalibraFit.cxx:5907
 AliTRDCalibraFit.cxx:5908
 AliTRDCalibraFit.cxx:5909
 AliTRDCalibraFit.cxx:5910
 AliTRDCalibraFit.cxx:5911
 AliTRDCalibraFit.cxx:5912
 AliTRDCalibraFit.cxx:5913
 AliTRDCalibraFit.cxx:5914
 AliTRDCalibraFit.cxx:5915
 AliTRDCalibraFit.cxx:5916
 AliTRDCalibraFit.cxx:5917
 AliTRDCalibraFit.cxx:5918
 AliTRDCalibraFit.cxx:5919
 AliTRDCalibraFit.cxx:5920
 AliTRDCalibraFit.cxx:5921
 AliTRDCalibraFit.cxx:5922
 AliTRDCalibraFit.cxx:5923
 AliTRDCalibraFit.cxx:5924
 AliTRDCalibraFit.cxx:5925
 AliTRDCalibraFit.cxx:5926
 AliTRDCalibraFit.cxx:5927
 AliTRDCalibraFit.cxx:5928
 AliTRDCalibraFit.cxx:5929
 AliTRDCalibraFit.cxx:5930
 AliTRDCalibraFit.cxx:5931
 AliTRDCalibraFit.cxx:5932
 AliTRDCalibraFit.cxx:5933
 AliTRDCalibraFit.cxx:5934
 AliTRDCalibraFit.cxx:5935
 AliTRDCalibraFit.cxx:5936
 AliTRDCalibraFit.cxx:5937
 AliTRDCalibraFit.cxx:5938
 AliTRDCalibraFit.cxx:5939
 AliTRDCalibraFit.cxx:5940
 AliTRDCalibraFit.cxx:5941
 AliTRDCalibraFit.cxx:5942
 AliTRDCalibraFit.cxx:5943
 AliTRDCalibraFit.cxx:5944
 AliTRDCalibraFit.cxx:5945
 AliTRDCalibraFit.cxx:5946
 AliTRDCalibraFit.cxx:5947
 AliTRDCalibraFit.cxx:5948
 AliTRDCalibraFit.cxx:5949
 AliTRDCalibraFit.cxx:5950
 AliTRDCalibraFit.cxx:5951
 AliTRDCalibraFit.cxx:5952
 AliTRDCalibraFit.cxx:5953
 AliTRDCalibraFit.cxx:5954
 AliTRDCalibraFit.cxx:5955
 AliTRDCalibraFit.cxx:5956
 AliTRDCalibraFit.cxx:5957
 AliTRDCalibraFit.cxx:5958
 AliTRDCalibraFit.cxx:5959
 AliTRDCalibraFit.cxx:5960
 AliTRDCalibraFit.cxx:5961
 AliTRDCalibraFit.cxx:5962
 AliTRDCalibraFit.cxx:5963
 AliTRDCalibraFit.cxx:5964
 AliTRDCalibraFit.cxx:5965
 AliTRDCalibraFit.cxx:5966
 AliTRDCalibraFit.cxx:5967
 AliTRDCalibraFit.cxx:5968
 AliTRDCalibraFit.cxx:5969
 AliTRDCalibraFit.cxx:5970
 AliTRDCalibraFit.cxx:5971
 AliTRDCalibraFit.cxx:5972
 AliTRDCalibraFit.cxx:5973
 AliTRDCalibraFit.cxx:5974
 AliTRDCalibraFit.cxx:5975
 AliTRDCalibraFit.cxx:5976
 AliTRDCalibraFit.cxx:5977
 AliTRDCalibraFit.cxx:5978
 AliTRDCalibraFit.cxx:5979
 AliTRDCalibraFit.cxx:5980
 AliTRDCalibraFit.cxx:5981
 AliTRDCalibraFit.cxx:5982
 AliTRDCalibraFit.cxx:5983
 AliTRDCalibraFit.cxx:5984
 AliTRDCalibraFit.cxx:5985
 AliTRDCalibraFit.cxx:5986
 AliTRDCalibraFit.cxx:5987
 AliTRDCalibraFit.cxx:5988
 AliTRDCalibraFit.cxx:5989
 AliTRDCalibraFit.cxx:5990
 AliTRDCalibraFit.cxx:5991
 AliTRDCalibraFit.cxx:5992
 AliTRDCalibraFit.cxx:5993
 AliTRDCalibraFit.cxx:5994
 AliTRDCalibraFit.cxx:5995
 AliTRDCalibraFit.cxx:5996
 AliTRDCalibraFit.cxx:5997
 AliTRDCalibraFit.cxx:5998
 AliTRDCalibraFit.cxx:5999
 AliTRDCalibraFit.cxx:6000
 AliTRDCalibraFit.cxx:6001
 AliTRDCalibraFit.cxx:6002
 AliTRDCalibraFit.cxx:6003
 AliTRDCalibraFit.cxx:6004
 AliTRDCalibraFit.cxx:6005
 AliTRDCalibraFit.cxx:6006
 AliTRDCalibraFit.cxx:6007
 AliTRDCalibraFit.cxx:6008
 AliTRDCalibraFit.cxx:6009
 AliTRDCalibraFit.cxx:6010
 AliTRDCalibraFit.cxx:6011
 AliTRDCalibraFit.cxx:6012
 AliTRDCalibraFit.cxx:6013
 AliTRDCalibraFit.cxx:6014
 AliTRDCalibraFit.cxx:6015
 AliTRDCalibraFit.cxx:6016
 AliTRDCalibraFit.cxx:6017
 AliTRDCalibraFit.cxx:6018
 AliTRDCalibraFit.cxx:6019
 AliTRDCalibraFit.cxx:6020
 AliTRDCalibraFit.cxx:6021
 AliTRDCalibraFit.cxx:6022
 AliTRDCalibraFit.cxx:6023
 AliTRDCalibraFit.cxx:6024
 AliTRDCalibraFit.cxx:6025
 AliTRDCalibraFit.cxx:6026
 AliTRDCalibraFit.cxx:6027
 AliTRDCalibraFit.cxx:6028
 AliTRDCalibraFit.cxx:6029
 AliTRDCalibraFit.cxx:6030
 AliTRDCalibraFit.cxx:6031
 AliTRDCalibraFit.cxx:6032
 AliTRDCalibraFit.cxx:6033
 AliTRDCalibraFit.cxx:6034
 AliTRDCalibraFit.cxx:6035
 AliTRDCalibraFit.cxx:6036
 AliTRDCalibraFit.cxx:6037
 AliTRDCalibraFit.cxx:6038
 AliTRDCalibraFit.cxx:6039
 AliTRDCalibraFit.cxx:6040
 AliTRDCalibraFit.cxx:6041
 AliTRDCalibraFit.cxx:6042
 AliTRDCalibraFit.cxx:6043
 AliTRDCalibraFit.cxx:6044
 AliTRDCalibraFit.cxx:6045
 AliTRDCalibraFit.cxx:6046
 AliTRDCalibraFit.cxx:6047
 AliTRDCalibraFit.cxx:6048
 AliTRDCalibraFit.cxx:6049
 AliTRDCalibraFit.cxx:6050
 AliTRDCalibraFit.cxx:6051
 AliTRDCalibraFit.cxx:6052
 AliTRDCalibraFit.cxx:6053
 AliTRDCalibraFit.cxx:6054
 AliTRDCalibraFit.cxx:6055
 AliTRDCalibraFit.cxx:6056
 AliTRDCalibraFit.cxx:6057
 AliTRDCalibraFit.cxx:6058
 AliTRDCalibraFit.cxx:6059
 AliTRDCalibraFit.cxx:6060
 AliTRDCalibraFit.cxx:6061
 AliTRDCalibraFit.cxx:6062
 AliTRDCalibraFit.cxx:6063
 AliTRDCalibraFit.cxx:6064
 AliTRDCalibraFit.cxx:6065
 AliTRDCalibraFit.cxx:6066
 AliTRDCalibraFit.cxx:6067
 AliTRDCalibraFit.cxx:6068
 AliTRDCalibraFit.cxx:6069
 AliTRDCalibraFit.cxx:6070
 AliTRDCalibraFit.cxx:6071
 AliTRDCalibraFit.cxx:6072
 AliTRDCalibraFit.cxx:6073
 AliTRDCalibraFit.cxx:6074
 AliTRDCalibraFit.cxx:6075
 AliTRDCalibraFit.cxx:6076
 AliTRDCalibraFit.cxx:6077
 AliTRDCalibraFit.cxx:6078
 AliTRDCalibraFit.cxx:6079
 AliTRDCalibraFit.cxx:6080
 AliTRDCalibraFit.cxx:6081
 AliTRDCalibraFit.cxx:6082
 AliTRDCalibraFit.cxx:6083
 AliTRDCalibraFit.cxx:6084
 AliTRDCalibraFit.cxx:6085
 AliTRDCalibraFit.cxx:6086
 AliTRDCalibraFit.cxx:6087
 AliTRDCalibraFit.cxx:6088
 AliTRDCalibraFit.cxx:6089
 AliTRDCalibraFit.cxx:6090
 AliTRDCalibraFit.cxx:6091
 AliTRDCalibraFit.cxx:6092
 AliTRDCalibraFit.cxx:6093
 AliTRDCalibraFit.cxx:6094
 AliTRDCalibraFit.cxx:6095
 AliTRDCalibraFit.cxx:6096
 AliTRDCalibraFit.cxx:6097
 AliTRDCalibraFit.cxx:6098
 AliTRDCalibraFit.cxx:6099
 AliTRDCalibraFit.cxx:6100
 AliTRDCalibraFit.cxx:6101
 AliTRDCalibraFit.cxx:6102
 AliTRDCalibraFit.cxx:6103
 AliTRDCalibraFit.cxx:6104
 AliTRDCalibraFit.cxx:6105
 AliTRDCalibraFit.cxx:6106
 AliTRDCalibraFit.cxx:6107
 AliTRDCalibraFit.cxx:6108
 AliTRDCalibraFit.cxx:6109
 AliTRDCalibraFit.cxx:6110
 AliTRDCalibraFit.cxx:6111
 AliTRDCalibraFit.cxx:6112
 AliTRDCalibraFit.cxx:6113
 AliTRDCalibraFit.cxx:6114
 AliTRDCalibraFit.cxx:6115
 AliTRDCalibraFit.cxx:6116
 AliTRDCalibraFit.cxx:6117
 AliTRDCalibraFit.cxx:6118
 AliTRDCalibraFit.cxx:6119
 AliTRDCalibraFit.cxx:6120
 AliTRDCalibraFit.cxx:6121
 AliTRDCalibraFit.cxx:6122
 AliTRDCalibraFit.cxx:6123
 AliTRDCalibraFit.cxx:6124
 AliTRDCalibraFit.cxx:6125
 AliTRDCalibraFit.cxx:6126
 AliTRDCalibraFit.cxx:6127
 AliTRDCalibraFit.cxx:6128
 AliTRDCalibraFit.cxx:6129
 AliTRDCalibraFit.cxx:6130
 AliTRDCalibraFit.cxx:6131
 AliTRDCalibraFit.cxx:6132
 AliTRDCalibraFit.cxx:6133
 AliTRDCalibraFit.cxx:6134
 AliTRDCalibraFit.cxx:6135
 AliTRDCalibraFit.cxx:6136
 AliTRDCalibraFit.cxx:6137
 AliTRDCalibraFit.cxx:6138
 AliTRDCalibraFit.cxx:6139
 AliTRDCalibraFit.cxx:6140
 AliTRDCalibraFit.cxx:6141
 AliTRDCalibraFit.cxx:6142
 AliTRDCalibraFit.cxx:6143
 AliTRDCalibraFit.cxx:6144
 AliTRDCalibraFit.cxx:6145
 AliTRDCalibraFit.cxx:6146
 AliTRDCalibraFit.cxx:6147
 AliTRDCalibraFit.cxx:6148
 AliTRDCalibraFit.cxx:6149
 AliTRDCalibraFit.cxx:6150
 AliTRDCalibraFit.cxx:6151
 AliTRDCalibraFit.cxx:6152
 AliTRDCalibraFit.cxx:6153
 AliTRDCalibraFit.cxx:6154
 AliTRDCalibraFit.cxx:6155
 AliTRDCalibraFit.cxx:6156
 AliTRDCalibraFit.cxx:6157
 AliTRDCalibraFit.cxx:6158
 AliTRDCalibraFit.cxx:6159
 AliTRDCalibraFit.cxx:6160
 AliTRDCalibraFit.cxx:6161
 AliTRDCalibraFit.cxx:6162
 AliTRDCalibraFit.cxx:6163
 AliTRDCalibraFit.cxx:6164
 AliTRDCalibraFit.cxx:6165
 AliTRDCalibraFit.cxx:6166
 AliTRDCalibraFit.cxx:6167
 AliTRDCalibraFit.cxx:6168
 AliTRDCalibraFit.cxx:6169
 AliTRDCalibraFit.cxx:6170
 AliTRDCalibraFit.cxx:6171
 AliTRDCalibraFit.cxx:6172
 AliTRDCalibraFit.cxx:6173
 AliTRDCalibraFit.cxx:6174
 AliTRDCalibraFit.cxx:6175
 AliTRDCalibraFit.cxx:6176
 AliTRDCalibraFit.cxx:6177
 AliTRDCalibraFit.cxx:6178
 AliTRDCalibraFit.cxx:6179
 AliTRDCalibraFit.cxx:6180
 AliTRDCalibraFit.cxx:6181
 AliTRDCalibraFit.cxx:6182
 AliTRDCalibraFit.cxx:6183
 AliTRDCalibraFit.cxx:6184
 AliTRDCalibraFit.cxx:6185
 AliTRDCalibraFit.cxx:6186
 AliTRDCalibraFit.cxx:6187
 AliTRDCalibraFit.cxx:6188
 AliTRDCalibraFit.cxx:6189
 AliTRDCalibraFit.cxx:6190
 AliTRDCalibraFit.cxx:6191
 AliTRDCalibraFit.cxx:6192
 AliTRDCalibraFit.cxx:6193
 AliTRDCalibraFit.cxx:6194
 AliTRDCalibraFit.cxx:6195
 AliTRDCalibraFit.cxx:6196
 AliTRDCalibraFit.cxx:6197
 AliTRDCalibraFit.cxx:6198
 AliTRDCalibraFit.cxx:6199
 AliTRDCalibraFit.cxx:6200
 AliTRDCalibraFit.cxx:6201
 AliTRDCalibraFit.cxx:6202
 AliTRDCalibraFit.cxx:6203
 AliTRDCalibraFit.cxx:6204
 AliTRDCalibraFit.cxx:6205
 AliTRDCalibraFit.cxx:6206
 AliTRDCalibraFit.cxx:6207
 AliTRDCalibraFit.cxx:6208
 AliTRDCalibraFit.cxx:6209
 AliTRDCalibraFit.cxx:6210
 AliTRDCalibraFit.cxx:6211
 AliTRDCalibraFit.cxx:6212
 AliTRDCalibraFit.cxx:6213
 AliTRDCalibraFit.cxx:6214
 AliTRDCalibraFit.cxx:6215
 AliTRDCalibraFit.cxx:6216
 AliTRDCalibraFit.cxx:6217
 AliTRDCalibraFit.cxx:6218
 AliTRDCalibraFit.cxx:6219
 AliTRDCalibraFit.cxx:6220
 AliTRDCalibraFit.cxx:6221
 AliTRDCalibraFit.cxx:6222
 AliTRDCalibraFit.cxx:6223
 AliTRDCalibraFit.cxx:6224
 AliTRDCalibraFit.cxx:6225
 AliTRDCalibraFit.cxx:6226
 AliTRDCalibraFit.cxx:6227
 AliTRDCalibraFit.cxx:6228
 AliTRDCalibraFit.cxx:6229
 AliTRDCalibraFit.cxx:6230
 AliTRDCalibraFit.cxx:6231
 AliTRDCalibraFit.cxx:6232
 AliTRDCalibraFit.cxx:6233
 AliTRDCalibraFit.cxx:6234
 AliTRDCalibraFit.cxx:6235
 AliTRDCalibraFit.cxx:6236
 AliTRDCalibraFit.cxx:6237
 AliTRDCalibraFit.cxx:6238
 AliTRDCalibraFit.cxx:6239
 AliTRDCalibraFit.cxx:6240
 AliTRDCalibraFit.cxx:6241
 AliTRDCalibraFit.cxx:6242
 AliTRDCalibraFit.cxx:6243
 AliTRDCalibraFit.cxx:6244
 AliTRDCalibraFit.cxx:6245
 AliTRDCalibraFit.cxx:6246
 AliTRDCalibraFit.cxx:6247
 AliTRDCalibraFit.cxx:6248
 AliTRDCalibraFit.cxx:6249
 AliTRDCalibraFit.cxx:6250
 AliTRDCalibraFit.cxx:6251
 AliTRDCalibraFit.cxx:6252
 AliTRDCalibraFit.cxx:6253
 AliTRDCalibraFit.cxx:6254
 AliTRDCalibraFit.cxx:6255
 AliTRDCalibraFit.cxx:6256
 AliTRDCalibraFit.cxx:6257
 AliTRDCalibraFit.cxx:6258
 AliTRDCalibraFit.cxx:6259
 AliTRDCalibraFit.cxx:6260
 AliTRDCalibraFit.cxx:6261
 AliTRDCalibraFit.cxx:6262
 AliTRDCalibraFit.cxx:6263
 AliTRDCalibraFit.cxx:6264
 AliTRDCalibraFit.cxx:6265
 AliTRDCalibraFit.cxx:6266
 AliTRDCalibraFit.cxx:6267
 AliTRDCalibraFit.cxx:6268
 AliTRDCalibraFit.cxx:6269
 AliTRDCalibraFit.cxx:6270
 AliTRDCalibraFit.cxx:6271
 AliTRDCalibraFit.cxx:6272
 AliTRDCalibraFit.cxx:6273
 AliTRDCalibraFit.cxx:6274
 AliTRDCalibraFit.cxx:6275
 AliTRDCalibraFit.cxx:6276
 AliTRDCalibraFit.cxx:6277
 AliTRDCalibraFit.cxx:6278
 AliTRDCalibraFit.cxx:6279
 AliTRDCalibraFit.cxx:6280
 AliTRDCalibraFit.cxx:6281
 AliTRDCalibraFit.cxx:6282
 AliTRDCalibraFit.cxx:6283
 AliTRDCalibraFit.cxx:6284
 AliTRDCalibraFit.cxx:6285
 AliTRDCalibraFit.cxx:6286
 AliTRDCalibraFit.cxx:6287
 AliTRDCalibraFit.cxx:6288
 AliTRDCalibraFit.cxx:6289
 AliTRDCalibraFit.cxx:6290
 AliTRDCalibraFit.cxx:6291
 AliTRDCalibraFit.cxx:6292
 AliTRDCalibraFit.cxx:6293
 AliTRDCalibraFit.cxx:6294
 AliTRDCalibraFit.cxx:6295
 AliTRDCalibraFit.cxx:6296
 AliTRDCalibraFit.cxx:6297
 AliTRDCalibraFit.cxx:6298
 AliTRDCalibraFit.cxx:6299
 AliTRDCalibraFit.cxx:6300
 AliTRDCalibraFit.cxx:6301
 AliTRDCalibraFit.cxx:6302
 AliTRDCalibraFit.cxx:6303
 AliTRDCalibraFit.cxx:6304
 AliTRDCalibraFit.cxx:6305
 AliTRDCalibraFit.cxx:6306
 AliTRDCalibraFit.cxx:6307
 AliTRDCalibraFit.cxx:6308
 AliTRDCalibraFit.cxx:6309
 AliTRDCalibraFit.cxx:6310
 AliTRDCalibraFit.cxx:6311
 AliTRDCalibraFit.cxx:6312
 AliTRDCalibraFit.cxx:6313
 AliTRDCalibraFit.cxx:6314
 AliTRDCalibraFit.cxx:6315
 AliTRDCalibraFit.cxx:6316
 AliTRDCalibraFit.cxx:6317
 AliTRDCalibraFit.cxx:6318
 AliTRDCalibraFit.cxx:6319
 AliTRDCalibraFit.cxx:6320
 AliTRDCalibraFit.cxx:6321
 AliTRDCalibraFit.cxx:6322
 AliTRDCalibraFit.cxx:6323
 AliTRDCalibraFit.cxx:6324
 AliTRDCalibraFit.cxx:6325
 AliTRDCalibraFit.cxx:6326
 AliTRDCalibraFit.cxx:6327
 AliTRDCalibraFit.cxx:6328
 AliTRDCalibraFit.cxx:6329
 AliTRDCalibraFit.cxx:6330
 AliTRDCalibraFit.cxx:6331
 AliTRDCalibraFit.cxx:6332
 AliTRDCalibraFit.cxx:6333
 AliTRDCalibraFit.cxx:6334
 AliTRDCalibraFit.cxx:6335
 AliTRDCalibraFit.cxx:6336
 AliTRDCalibraFit.cxx:6337
 AliTRDCalibraFit.cxx:6338
 AliTRDCalibraFit.cxx:6339
 AliTRDCalibraFit.cxx:6340
 AliTRDCalibraFit.cxx:6341
 AliTRDCalibraFit.cxx:6342
 AliTRDCalibraFit.cxx:6343
 AliTRDCalibraFit.cxx:6344
 AliTRDCalibraFit.cxx:6345
 AliTRDCalibraFit.cxx:6346
 AliTRDCalibraFit.cxx:6347
 AliTRDCalibraFit.cxx:6348
 AliTRDCalibraFit.cxx:6349
 AliTRDCalibraFit.cxx:6350
 AliTRDCalibraFit.cxx:6351
 AliTRDCalibraFit.cxx:6352
 AliTRDCalibraFit.cxx:6353
 AliTRDCalibraFit.cxx:6354
 AliTRDCalibraFit.cxx:6355
 AliTRDCalibraFit.cxx:6356
 AliTRDCalibraFit.cxx:6357
 AliTRDCalibraFit.cxx:6358
 AliTRDCalibraFit.cxx:6359
 AliTRDCalibraFit.cxx:6360
 AliTRDCalibraFit.cxx:6361
 AliTRDCalibraFit.cxx:6362
 AliTRDCalibraFit.cxx:6363
 AliTRDCalibraFit.cxx:6364
 AliTRDCalibraFit.cxx:6365
 AliTRDCalibraFit.cxx:6366
 AliTRDCalibraFit.cxx:6367
 AliTRDCalibraFit.cxx:6368
 AliTRDCalibraFit.cxx:6369
 AliTRDCalibraFit.cxx:6370
 AliTRDCalibraFit.cxx:6371
 AliTRDCalibraFit.cxx:6372
 AliTRDCalibraFit.cxx:6373
 AliTRDCalibraFit.cxx:6374
 AliTRDCalibraFit.cxx:6375
 AliTRDCalibraFit.cxx:6376
 AliTRDCalibraFit.cxx:6377
 AliTRDCalibraFit.cxx:6378
 AliTRDCalibraFit.cxx:6379
 AliTRDCalibraFit.cxx:6380
 AliTRDCalibraFit.cxx:6381
 AliTRDCalibraFit.cxx:6382
 AliTRDCalibraFit.cxx:6383
 AliTRDCalibraFit.cxx:6384
 AliTRDCalibraFit.cxx:6385
 AliTRDCalibraFit.cxx:6386
 AliTRDCalibraFit.cxx:6387
 AliTRDCalibraFit.cxx:6388
 AliTRDCalibraFit.cxx:6389
 AliTRDCalibraFit.cxx:6390
 AliTRDCalibraFit.cxx:6391
 AliTRDCalibraFit.cxx:6392
 AliTRDCalibraFit.cxx:6393
 AliTRDCalibraFit.cxx:6394
 AliTRDCalibraFit.cxx:6395
 AliTRDCalibraFit.cxx:6396
 AliTRDCalibraFit.cxx:6397
 AliTRDCalibraFit.cxx:6398
 AliTRDCalibraFit.cxx:6399
 AliTRDCalibraFit.cxx:6400
 AliTRDCalibraFit.cxx:6401
 AliTRDCalibraFit.cxx:6402
 AliTRDCalibraFit.cxx:6403
 AliTRDCalibraFit.cxx:6404
 AliTRDCalibraFit.cxx:6405
 AliTRDCalibraFit.cxx:6406
 AliTRDCalibraFit.cxx:6407
 AliTRDCalibraFit.cxx:6408
 AliTRDCalibraFit.cxx:6409
 AliTRDCalibraFit.cxx:6410
 AliTRDCalibraFit.cxx:6411
 AliTRDCalibraFit.cxx:6412
 AliTRDCalibraFit.cxx:6413
 AliTRDCalibraFit.cxx:6414
 AliTRDCalibraFit.cxx:6415
 AliTRDCalibraFit.cxx:6416
 AliTRDCalibraFit.cxx:6417
 AliTRDCalibraFit.cxx:6418
 AliTRDCalibraFit.cxx:6419
 AliTRDCalibraFit.cxx:6420
 AliTRDCalibraFit.cxx:6421
 AliTRDCalibraFit.cxx:6422
 AliTRDCalibraFit.cxx:6423
 AliTRDCalibraFit.cxx:6424
 AliTRDCalibraFit.cxx:6425
 AliTRDCalibraFit.cxx:6426
 AliTRDCalibraFit.cxx:6427
 AliTRDCalibraFit.cxx:6428
 AliTRDCalibraFit.cxx:6429
 AliTRDCalibraFit.cxx:6430
 AliTRDCalibraFit.cxx:6431
 AliTRDCalibraFit.cxx:6432
 AliTRDCalibraFit.cxx:6433
 AliTRDCalibraFit.cxx:6434
 AliTRDCalibraFit.cxx:6435
 AliTRDCalibraFit.cxx:6436
 AliTRDCalibraFit.cxx:6437
 AliTRDCalibraFit.cxx:6438
 AliTRDCalibraFit.cxx:6439
 AliTRDCalibraFit.cxx:6440
 AliTRDCalibraFit.cxx:6441
 AliTRDCalibraFit.cxx:6442
 AliTRDCalibraFit.cxx:6443
 AliTRDCalibraFit.cxx:6444
 AliTRDCalibraFit.cxx:6445
 AliTRDCalibraFit.cxx:6446
 AliTRDCalibraFit.cxx:6447
 AliTRDCalibraFit.cxx:6448
 AliTRDCalibraFit.cxx:6449
 AliTRDCalibraFit.cxx:6450
 AliTRDCalibraFit.cxx:6451
 AliTRDCalibraFit.cxx:6452
 AliTRDCalibraFit.cxx:6453
 AliTRDCalibraFit.cxx:6454
 AliTRDCalibraFit.cxx:6455
 AliTRDCalibraFit.cxx:6456
 AliTRDCalibraFit.cxx:6457
 AliTRDCalibraFit.cxx:6458
 AliTRDCalibraFit.cxx:6459
 AliTRDCalibraFit.cxx:6460
 AliTRDCalibraFit.cxx:6461
 AliTRDCalibraFit.cxx:6462
 AliTRDCalibraFit.cxx:6463
 AliTRDCalibraFit.cxx:6464
 AliTRDCalibraFit.cxx:6465
 AliTRDCalibraFit.cxx:6466
 AliTRDCalibraFit.cxx:6467
 AliTRDCalibraFit.cxx:6468
 AliTRDCalibraFit.cxx:6469
 AliTRDCalibraFit.cxx:6470
 AliTRDCalibraFit.cxx:6471
 AliTRDCalibraFit.cxx:6472
 AliTRDCalibraFit.cxx:6473
 AliTRDCalibraFit.cxx:6474
 AliTRDCalibraFit.cxx:6475
 AliTRDCalibraFit.cxx:6476
 AliTRDCalibraFit.cxx:6477
 AliTRDCalibraFit.cxx:6478
 AliTRDCalibraFit.cxx:6479
 AliTRDCalibraFit.cxx:6480
 AliTRDCalibraFit.cxx:6481
 AliTRDCalibraFit.cxx:6482
 AliTRDCalibraFit.cxx:6483
 AliTRDCalibraFit.cxx:6484
 AliTRDCalibraFit.cxx:6485
 AliTRDCalibraFit.cxx:6486
 AliTRDCalibraFit.cxx:6487
 AliTRDCalibraFit.cxx:6488
 AliTRDCalibraFit.cxx:6489
 AliTRDCalibraFit.cxx:6490
 AliTRDCalibraFit.cxx:6491
 AliTRDCalibraFit.cxx:6492
 AliTRDCalibraFit.cxx:6493
 AliTRDCalibraFit.cxx:6494
 AliTRDCalibraFit.cxx:6495
 AliTRDCalibraFit.cxx:6496
 AliTRDCalibraFit.cxx:6497
 AliTRDCalibraFit.cxx:6498
 AliTRDCalibraFit.cxx:6499
 AliTRDCalibraFit.cxx:6500
 AliTRDCalibraFit.cxx:6501
 AliTRDCalibraFit.cxx:6502
 AliTRDCalibraFit.cxx:6503
 AliTRDCalibraFit.cxx:6504
 AliTRDCalibraFit.cxx:6505
 AliTRDCalibraFit.cxx:6506
 AliTRDCalibraFit.cxx:6507
 AliTRDCalibraFit.cxx:6508
 AliTRDCalibraFit.cxx:6509
 AliTRDCalibraFit.cxx:6510
 AliTRDCalibraFit.cxx:6511
 AliTRDCalibraFit.cxx:6512
 AliTRDCalibraFit.cxx:6513
 AliTRDCalibraFit.cxx:6514
 AliTRDCalibraFit.cxx:6515
 AliTRDCalibraFit.cxx:6516
 AliTRDCalibraFit.cxx:6517
 AliTRDCalibraFit.cxx:6518
 AliTRDCalibraFit.cxx:6519
 AliTRDCalibraFit.cxx:6520
 AliTRDCalibraFit.cxx:6521
 AliTRDCalibraFit.cxx:6522
 AliTRDCalibraFit.cxx:6523
 AliTRDCalibraFit.cxx:6524
 AliTRDCalibraFit.cxx:6525
 AliTRDCalibraFit.cxx:6526
 AliTRDCalibraFit.cxx:6527
 AliTRDCalibraFit.cxx:6528
 AliTRDCalibraFit.cxx:6529
 AliTRDCalibraFit.cxx:6530
 AliTRDCalibraFit.cxx:6531
 AliTRDCalibraFit.cxx:6532
 AliTRDCalibraFit.cxx:6533
 AliTRDCalibraFit.cxx:6534
 AliTRDCalibraFit.cxx:6535
 AliTRDCalibraFit.cxx:6536
 AliTRDCalibraFit.cxx:6537
 AliTRDCalibraFit.cxx:6538
 AliTRDCalibraFit.cxx:6539
 AliTRDCalibraFit.cxx:6540
 AliTRDCalibraFit.cxx:6541
 AliTRDCalibraFit.cxx:6542
 AliTRDCalibraFit.cxx:6543
 AliTRDCalibraFit.cxx:6544
 AliTRDCalibraFit.cxx:6545
 AliTRDCalibraFit.cxx:6546
 AliTRDCalibraFit.cxx:6547
 AliTRDCalibraFit.cxx:6548
 AliTRDCalibraFit.cxx:6549
 AliTRDCalibraFit.cxx:6550
 AliTRDCalibraFit.cxx:6551
 AliTRDCalibraFit.cxx:6552
 AliTRDCalibraFit.cxx:6553
 AliTRDCalibraFit.cxx:6554
 AliTRDCalibraFit.cxx:6555
 AliTRDCalibraFit.cxx:6556
 AliTRDCalibraFit.cxx:6557
 AliTRDCalibraFit.cxx:6558
 AliTRDCalibraFit.cxx:6559
 AliTRDCalibraFit.cxx:6560
 AliTRDCalibraFit.cxx:6561
 AliTRDCalibraFit.cxx:6562
 AliTRDCalibraFit.cxx:6563
 AliTRDCalibraFit.cxx:6564
 AliTRDCalibraFit.cxx:6565
 AliTRDCalibraFit.cxx:6566
 AliTRDCalibraFit.cxx:6567
 AliTRDCalibraFit.cxx:6568
 AliTRDCalibraFit.cxx:6569
 AliTRDCalibraFit.cxx:6570
 AliTRDCalibraFit.cxx:6571
 AliTRDCalibraFit.cxx:6572
 AliTRDCalibraFit.cxx:6573
 AliTRDCalibraFit.cxx:6574
 AliTRDCalibraFit.cxx:6575
 AliTRDCalibraFit.cxx:6576
 AliTRDCalibraFit.cxx:6577
 AliTRDCalibraFit.cxx:6578
 AliTRDCalibraFit.cxx:6579
 AliTRDCalibraFit.cxx:6580
 AliTRDCalibraFit.cxx:6581
 AliTRDCalibraFit.cxx:6582
 AliTRDCalibraFit.cxx:6583
 AliTRDCalibraFit.cxx:6584
 AliTRDCalibraFit.cxx:6585
 AliTRDCalibraFit.cxx:6586
 AliTRDCalibraFit.cxx:6587
 AliTRDCalibraFit.cxx:6588
 AliTRDCalibraFit.cxx:6589
 AliTRDCalibraFit.cxx:6590
 AliTRDCalibraFit.cxx:6591
 AliTRDCalibraFit.cxx:6592
 AliTRDCalibraFit.cxx:6593
 AliTRDCalibraFit.cxx:6594
 AliTRDCalibraFit.cxx:6595
 AliTRDCalibraFit.cxx:6596
 AliTRDCalibraFit.cxx:6597
 AliTRDCalibraFit.cxx:6598
 AliTRDCalibraFit.cxx:6599
 AliTRDCalibraFit.cxx:6600
 AliTRDCalibraFit.cxx:6601
 AliTRDCalibraFit.cxx:6602
 AliTRDCalibraFit.cxx:6603
 AliTRDCalibraFit.cxx:6604
 AliTRDCalibraFit.cxx:6605
 AliTRDCalibraFit.cxx:6606
 AliTRDCalibraFit.cxx:6607
 AliTRDCalibraFit.cxx:6608
 AliTRDCalibraFit.cxx:6609
 AliTRDCalibraFit.cxx:6610
 AliTRDCalibraFit.cxx:6611
 AliTRDCalibraFit.cxx:6612
 AliTRDCalibraFit.cxx:6613
 AliTRDCalibraFit.cxx:6614
 AliTRDCalibraFit.cxx:6615
 AliTRDCalibraFit.cxx:6616
 AliTRDCalibraFit.cxx:6617
 AliTRDCalibraFit.cxx:6618
 AliTRDCalibraFit.cxx:6619
 AliTRDCalibraFit.cxx:6620
 AliTRDCalibraFit.cxx:6621
 AliTRDCalibraFit.cxx:6622
 AliTRDCalibraFit.cxx:6623
 AliTRDCalibraFit.cxx:6624
 AliTRDCalibraFit.cxx:6625
 AliTRDCalibraFit.cxx:6626
 AliTRDCalibraFit.cxx:6627
 AliTRDCalibraFit.cxx:6628
 AliTRDCalibraFit.cxx:6629
 AliTRDCalibraFit.cxx:6630
 AliTRDCalibraFit.cxx:6631
 AliTRDCalibraFit.cxx:6632
 AliTRDCalibraFit.cxx:6633
 AliTRDCalibraFit.cxx:6634
 AliTRDCalibraFit.cxx:6635
 AliTRDCalibraFit.cxx:6636
 AliTRDCalibraFit.cxx:6637
 AliTRDCalibraFit.cxx:6638
 AliTRDCalibraFit.cxx:6639
 AliTRDCalibraFit.cxx:6640
 AliTRDCalibraFit.cxx:6641
 AliTRDCalibraFit.cxx:6642
 AliTRDCalibraFit.cxx:6643
 AliTRDCalibraFit.cxx:6644
 AliTRDCalibraFit.cxx:6645
 AliTRDCalibraFit.cxx:6646
 AliTRDCalibraFit.cxx:6647
 AliTRDCalibraFit.cxx:6648
 AliTRDCalibraFit.cxx:6649
 AliTRDCalibraFit.cxx:6650
 AliTRDCalibraFit.cxx:6651
 AliTRDCalibraFit.cxx:6652
 AliTRDCalibraFit.cxx:6653
 AliTRDCalibraFit.cxx:6654
 AliTRDCalibraFit.cxx:6655
 AliTRDCalibraFit.cxx:6656
 AliTRDCalibraFit.cxx:6657
 AliTRDCalibraFit.cxx:6658
 AliTRDCalibraFit.cxx:6659
 AliTRDCalibraFit.cxx:6660
 AliTRDCalibraFit.cxx:6661
 AliTRDCalibraFit.cxx:6662
 AliTRDCalibraFit.cxx:6663
 AliTRDCalibraFit.cxx:6664
 AliTRDCalibraFit.cxx:6665
 AliTRDCalibraFit.cxx:6666
 AliTRDCalibraFit.cxx:6667
 AliTRDCalibraFit.cxx:6668
 AliTRDCalibraFit.cxx:6669
 AliTRDCalibraFit.cxx:6670
 AliTRDCalibraFit.cxx:6671
 AliTRDCalibraFit.cxx:6672
 AliTRDCalibraFit.cxx:6673
 AliTRDCalibraFit.cxx:6674
 AliTRDCalibraFit.cxx:6675
 AliTRDCalibraFit.cxx:6676
 AliTRDCalibraFit.cxx:6677
 AliTRDCalibraFit.cxx:6678
 AliTRDCalibraFit.cxx:6679
 AliTRDCalibraFit.cxx:6680
 AliTRDCalibraFit.cxx:6681
 AliTRDCalibraFit.cxx:6682
 AliTRDCalibraFit.cxx:6683
 AliTRDCalibraFit.cxx:6684
 AliTRDCalibraFit.cxx:6685
 AliTRDCalibraFit.cxx:6686
 AliTRDCalibraFit.cxx:6687
 AliTRDCalibraFit.cxx:6688
 AliTRDCalibraFit.cxx:6689
 AliTRDCalibraFit.cxx:6690
 AliTRDCalibraFit.cxx:6691
 AliTRDCalibraFit.cxx:6692
 AliTRDCalibraFit.cxx:6693
 AliTRDCalibraFit.cxx:6694
 AliTRDCalibraFit.cxx:6695
 AliTRDCalibraFit.cxx:6696
 AliTRDCalibraFit.cxx:6697
 AliTRDCalibraFit.cxx:6698
 AliTRDCalibraFit.cxx:6699
 AliTRDCalibraFit.cxx:6700
 AliTRDCalibraFit.cxx:6701
 AliTRDCalibraFit.cxx:6702
 AliTRDCalibraFit.cxx:6703
 AliTRDCalibraFit.cxx:6704
 AliTRDCalibraFit.cxx:6705
 AliTRDCalibraFit.cxx:6706
 AliTRDCalibraFit.cxx:6707
 AliTRDCalibraFit.cxx:6708
 AliTRDCalibraFit.cxx:6709
 AliTRDCalibraFit.cxx:6710
 AliTRDCalibraFit.cxx:6711
 AliTRDCalibraFit.cxx:6712
 AliTRDCalibraFit.cxx:6713
 AliTRDCalibraFit.cxx:6714
 AliTRDCalibraFit.cxx:6715
 AliTRDCalibraFit.cxx:6716
 AliTRDCalibraFit.cxx:6717
 AliTRDCalibraFit.cxx:6718
 AliTRDCalibraFit.cxx:6719
 AliTRDCalibraFit.cxx:6720
 AliTRDCalibraFit.cxx:6721
 AliTRDCalibraFit.cxx:6722
 AliTRDCalibraFit.cxx:6723
 AliTRDCalibraFit.cxx:6724
 AliTRDCalibraFit.cxx:6725
 AliTRDCalibraFit.cxx:6726
 AliTRDCalibraFit.cxx:6727
 AliTRDCalibraFit.cxx:6728
 AliTRDCalibraFit.cxx:6729
 AliTRDCalibraFit.cxx:6730
 AliTRDCalibraFit.cxx:6731
 AliTRDCalibraFit.cxx:6732
 AliTRDCalibraFit.cxx:6733
 AliTRDCalibraFit.cxx:6734
 AliTRDCalibraFit.cxx:6735
 AliTRDCalibraFit.cxx:6736
 AliTRDCalibraFit.cxx:6737
 AliTRDCalibraFit.cxx:6738
 AliTRDCalibraFit.cxx:6739
 AliTRDCalibraFit.cxx:6740
 AliTRDCalibraFit.cxx:6741
 AliTRDCalibraFit.cxx:6742
 AliTRDCalibraFit.cxx:6743
 AliTRDCalibraFit.cxx:6744
 AliTRDCalibraFit.cxx:6745
 AliTRDCalibraFit.cxx:6746
 AliTRDCalibraFit.cxx:6747
 AliTRDCalibraFit.cxx:6748
 AliTRDCalibraFit.cxx:6749
 AliTRDCalibraFit.cxx:6750
 AliTRDCalibraFit.cxx:6751
 AliTRDCalibraFit.cxx:6752
 AliTRDCalibraFit.cxx:6753
 AliTRDCalibraFit.cxx:6754
 AliTRDCalibraFit.cxx:6755
 AliTRDCalibraFit.cxx:6756
 AliTRDCalibraFit.cxx:6757
 AliTRDCalibraFit.cxx:6758
 AliTRDCalibraFit.cxx:6759
 AliTRDCalibraFit.cxx:6760
 AliTRDCalibraFit.cxx:6761
 AliTRDCalibraFit.cxx:6762
 AliTRDCalibraFit.cxx:6763
 AliTRDCalibraFit.cxx:6764
 AliTRDCalibraFit.cxx:6765
 AliTRDCalibraFit.cxx:6766
 AliTRDCalibraFit.cxx:6767
 AliTRDCalibraFit.cxx:6768
 AliTRDCalibraFit.cxx:6769
 AliTRDCalibraFit.cxx:6770
 AliTRDCalibraFit.cxx:6771
 AliTRDCalibraFit.cxx:6772
 AliTRDCalibraFit.cxx:6773
 AliTRDCalibraFit.cxx:6774
 AliTRDCalibraFit.cxx:6775
 AliTRDCalibraFit.cxx:6776
 AliTRDCalibraFit.cxx:6777
 AliTRDCalibraFit.cxx:6778
 AliTRDCalibraFit.cxx:6779
 AliTRDCalibraFit.cxx:6780
 AliTRDCalibraFit.cxx:6781
 AliTRDCalibraFit.cxx:6782
 AliTRDCalibraFit.cxx:6783
 AliTRDCalibraFit.cxx:6784
 AliTRDCalibraFit.cxx:6785
 AliTRDCalibraFit.cxx:6786
 AliTRDCalibraFit.cxx:6787
 AliTRDCalibraFit.cxx:6788
 AliTRDCalibraFit.cxx:6789
 AliTRDCalibraFit.cxx:6790
 AliTRDCalibraFit.cxx:6791
 AliTRDCalibraFit.cxx:6792
 AliTRDCalibraFit.cxx:6793
 AliTRDCalibraFit.cxx:6794
 AliTRDCalibraFit.cxx:6795
 AliTRDCalibraFit.cxx:6796
 AliTRDCalibraFit.cxx:6797
 AliTRDCalibraFit.cxx:6798
 AliTRDCalibraFit.cxx:6799
 AliTRDCalibraFit.cxx:6800
 AliTRDCalibraFit.cxx:6801
 AliTRDCalibraFit.cxx:6802
 AliTRDCalibraFit.cxx:6803
 AliTRDCalibraFit.cxx:6804
 AliTRDCalibraFit.cxx:6805
 AliTRDCalibraFit.cxx:6806
 AliTRDCalibraFit.cxx:6807
 AliTRDCalibraFit.cxx:6808
 AliTRDCalibraFit.cxx:6809
 AliTRDCalibraFit.cxx:6810
 AliTRDCalibraFit.cxx:6811
 AliTRDCalibraFit.cxx:6812
 AliTRDCalibraFit.cxx:6813
 AliTRDCalibraFit.cxx:6814
 AliTRDCalibraFit.cxx:6815
 AliTRDCalibraFit.cxx:6816
 AliTRDCalibraFit.cxx:6817
 AliTRDCalibraFit.cxx:6818
 AliTRDCalibraFit.cxx:6819
 AliTRDCalibraFit.cxx:6820
 AliTRDCalibraFit.cxx:6821
 AliTRDCalibraFit.cxx:6822
 AliTRDCalibraFit.cxx:6823
 AliTRDCalibraFit.cxx:6824
 AliTRDCalibraFit.cxx:6825
 AliTRDCalibraFit.cxx:6826
 AliTRDCalibraFit.cxx:6827
 AliTRDCalibraFit.cxx:6828
 AliTRDCalibraFit.cxx:6829
 AliTRDCalibraFit.cxx:6830
 AliTRDCalibraFit.cxx:6831
 AliTRDCalibraFit.cxx:6832
 AliTRDCalibraFit.cxx:6833
 AliTRDCalibraFit.cxx:6834
 AliTRDCalibraFit.cxx:6835
 AliTRDCalibraFit.cxx:6836
 AliTRDCalibraFit.cxx:6837
 AliTRDCalibraFit.cxx:6838
 AliTRDCalibraFit.cxx:6839
 AliTRDCalibraFit.cxx:6840
 AliTRDCalibraFit.cxx:6841
 AliTRDCalibraFit.cxx:6842
 AliTRDCalibraFit.cxx:6843
 AliTRDCalibraFit.cxx:6844
 AliTRDCalibraFit.cxx:6845
 AliTRDCalibraFit.cxx:6846
 AliTRDCalibraFit.cxx:6847
 AliTRDCalibraFit.cxx:6848
 AliTRDCalibraFit.cxx:6849
 AliTRDCalibraFit.cxx:6850
 AliTRDCalibraFit.cxx:6851
 AliTRDCalibraFit.cxx:6852
 AliTRDCalibraFit.cxx:6853
 AliTRDCalibraFit.cxx:6854
 AliTRDCalibraFit.cxx:6855
 AliTRDCalibraFit.cxx:6856
 AliTRDCalibraFit.cxx:6857
 AliTRDCalibraFit.cxx:6858