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$ */

/////////////////////////////////////////////////////////////////////////////////
//                                                                             
// AliTRDCalibraFillHisto                                                               
//                                                                             
// This class is for the TRD calibration of the relative gain factor, the drift velocity,
// the time 0 and the pad response function. It fills histos or vectors.        
// It can be used for the calibration per chamber but also per group of pads and eventually per pad.
// The user has to choose with the functions SetNz and SetNrphi the precision of the calibration (see AliTRDCalibraMode). 
// 2D Histograms (Histo2d) or vectors (Vector2d), then converted in Trees, will be filled
// from RAW DATA in a run or from reconstructed TRD tracks during the offline tracking 
// in the function "FollowBackProlongation" (AliTRDtracker)
// Per default the functions to fill are off.                                   
//                        
// Authors:
//   R. Bailhache (R.Bailhache@gsi.de, rbailhache@ikf.uni-frankfurt.de)
//   J. Book (jbook@ikf.uni-frankfurt.de)
//                            
//////////////////////////////////////////////////////////////////////////////////////

#include <TProfile2D.h>
#include <TProfile.h>
#include <TFile.h>
#include <TStyle.h>
#include <TCanvas.h>
#include <TObjArray.h>
#include <TObject.h>
#include <TH1F.h>
#include <TH2I.h>
#include <TH2.h>
#include <TStopwatch.h>
#include <TMath.h>
#include <TDirectory.h>
#include <TTreeStream.h>
#include <TVectorD.h>
#include <TLinearFitter.h>

#include "AliLog.h"

#include "AliESDtrack.h"
#include "AliTRDCalibraFillHisto.h"
#include "AliTRDCalibraMode.h"
#include "AliTRDCalibraVector.h"
#include "AliTRDCalibraVdriftLinearFit.h"
#include "AliTRDCalibraExbAltFit.h"
#include "AliTRDcalibDB.h"
#include "AliTRDCommonParam.h"
#include "AliTRDpadPlane.h"
#include "AliTRDcluster.h"
#include "AliTRDtrackV1.h"
#include "AliRawReader.h"
#include "AliRawReaderDate.h"
#include "AliTRDgeometry.h"
#include "AliTRDfeeParam.h"
#include "./Cal/AliTRDCalROC.h"
#include "./Cal/AliTRDCalPad.h"
#include "./Cal/AliTRDCalDet.h"

#include "AliTRDdigitsManager.h"
#include "AliTRDdigitsParam.h"
#include "AliTRDSignalIndex.h"
#include "AliTRDarrayADC.h"

#include "AliTRDrawStream.h"

#include "AliCDBEntry.h"
#include "AliCDBManager.h"

#ifdef ALI_DATE
#include "event.h"
#endif


ClassImp(AliTRDCalibraFillHisto)

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

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

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

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

  return fgInstance;

}

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

  fgTerminated = kTRUE;

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

}

//______________________________________________________________________________________
AliTRDCalibraFillHisto::AliTRDCalibraFillHisto()
  :TObject()
  ,fGeo(0)
  ,fCalibDB(0)
  ,fIsHLT(kFALSE)
  ,fCH2dOn(kFALSE)
  ,fPH2dOn(kFALSE)
  ,fPRF2dOn(kFALSE)
  ,fHisto2d(kFALSE)
  ,fVector2d(kFALSE)
  ,fLinearFitterOn(kFALSE)
  ,fLinearFitterDebugOn(kFALSE)
  ,fExbAltFitOn(kFALSE)
  ,fScaleWithTPCSignal(kFALSE)
  ,fRelativeScale(0)
  ,fThresholdClusterPRF2(15.0)
  ,fLimitChargeIntegration(kFALSE)
  ,fFillWithZero(kFALSE)
  ,fNormalizeNbOfCluster(kFALSE)
  ,fMaxCluster(0)
  ,fNbMaxCluster(0)
  ,fCutWithVdriftCalib(kFALSE)
  ,fMinNbTRDtracklets(0)
  ,fMinTRDMomentum(0.0)
  ,fTakeSnapshot(kTRUE)
  ,fFirstRunGain(0)
  ,fVersionGainUsed(0)
  ,fSubVersionGainUsed(0)
  ,fFirstRunGainLocal(0)
  ,fVersionGainLocalUsed(0)
  ,fSubVersionGainLocalUsed(0)
  ,fFirstRunVdrift(0)
  ,fVersionVdriftUsed(0) 
  ,fSubVersionVdriftUsed(0)
  ,fFirstRunExB(0)
  ,fVersionExBUsed(0) 
  ,fSubVersionExBUsed(0)
  ,fCalibraMode(new AliTRDCalibraMode())
  ,fDebugStreamer(0)
  ,fDebugLevel(0)
  ,fDetectorPreviousTrack(-1)
  ,fMCMPrevious(-1)
  ,fROBPrevious(-1)
  ,fNumberClusters(1)
  ,fNumberClustersf(30)
  ,fNumberClustersProcent(0.5)
  ,fThresholdClustersDAQ(120.0)
  ,fNumberRowDAQ(2)
  ,fNumberColDAQ(4)
  ,fProcent(6.0)
  ,fDifference(17)
  ,fNumberTrack(0)
  ,fTimeMax(0)
  ,fSf(10.0)
  ,fRangeHistoCharge(150)
  ,fNumberBinCharge(50)
  ,fNumberBinPRF(10)
  ,fNgroupprf(3)
  ,fAmpTotal(0x0)
  ,fPHPlace(0x0)
  ,fPHValue(0x0)
  ,fGoodTracklet(kTRUE)
  ,fLinearFitterTracklet(0x0)
  ,fEntriesCH(0x0)
  ,fEntriesLinearFitter(0x0)
  ,fCalibraVector(0x0)
  ,fPH2d(0x0)
  ,fPRF2d(0x0)
  ,fCH2d(0x0)
  ,fLinearFitterArray(540)
  ,fLinearVdriftFit(0x0)
  ,fExbAltFit(0x0)
  ,fCalDetGain(0x0)
  ,fCalROCGain(0x0)
{
  //
  // Default constructor
  //

  //
  // Init some default values
  //

  fNumberUsedCh[0]       = 0;
  fNumberUsedCh[1]       = 0;
  fNumberUsedPh[0]       = 0;
  fNumberUsedPh[1]       = 0;
  
  fGeo = new AliTRDgeometry();
  fCalibDB = AliTRDcalibDB::Instance();
}

//______________________________________________________________________________________
AliTRDCalibraFillHisto::AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c)
  :TObject(c)
  ,fGeo(0)
  ,fCalibDB(0)
  ,fIsHLT(c.fIsHLT)
  ,fCH2dOn(c.fCH2dOn)
  ,fPH2dOn(c.fPH2dOn)
  ,fPRF2dOn(c.fPRF2dOn)
  ,fHisto2d(c.fHisto2d)
  ,fVector2d(c.fVector2d)
  ,fLinearFitterOn(c.fLinearFitterOn)
  ,fLinearFitterDebugOn(c.fLinearFitterDebugOn)
  ,fExbAltFitOn(c.fExbAltFitOn)
  ,fScaleWithTPCSignal(c.fScaleWithTPCSignal)
  ,fRelativeScale(c.fRelativeScale)
  ,fThresholdClusterPRF2(c.fThresholdClusterPRF2)
  ,fLimitChargeIntegration(c.fLimitChargeIntegration)
  ,fFillWithZero(c.fFillWithZero)
  ,fNormalizeNbOfCluster(c.fNormalizeNbOfCluster)
  ,fMaxCluster(c.fMaxCluster)
  ,fNbMaxCluster(c.fNbMaxCluster)
  ,fCutWithVdriftCalib(c.fCutWithVdriftCalib)
  ,fMinNbTRDtracklets(c.fMinNbTRDtracklets)
  ,fMinTRDMomentum(c.fMinTRDMomentum)
  ,fTakeSnapshot(c.fTakeSnapshot)
  ,fFirstRunGain(c.fFirstRunGain)
  ,fVersionGainUsed(c.fVersionGainUsed)
  ,fSubVersionGainUsed(c.fSubVersionGainUsed)
  ,fFirstRunGainLocal(c.fFirstRunGainLocal)
  ,fVersionGainLocalUsed(c.fVersionGainLocalUsed)
  ,fSubVersionGainLocalUsed(c.fSubVersionGainLocalUsed)
  ,fFirstRunVdrift(c.fFirstRunVdrift)
  ,fVersionVdriftUsed(c.fVersionVdriftUsed) 
  ,fSubVersionVdriftUsed(c.fSubVersionVdriftUsed)
  ,fFirstRunExB(c.fFirstRunExB)
  ,fVersionExBUsed(c.fVersionExBUsed) 
  ,fSubVersionExBUsed(c.fSubVersionExBUsed)
  ,fCalibraMode(0x0)
  ,fDebugStreamer(0)
  ,fDebugLevel(c.fDebugLevel)
  ,fDetectorPreviousTrack(c.fDetectorPreviousTrack)
  ,fMCMPrevious(c.fMCMPrevious)
  ,fROBPrevious(c.fROBPrevious)
  ,fNumberClusters(c.fNumberClusters)
  ,fNumberClustersf(c.fNumberClustersf)
  ,fNumberClustersProcent(c.fNumberClustersProcent)
  ,fThresholdClustersDAQ(c.fThresholdClustersDAQ)
  ,fNumberRowDAQ(c.fNumberRowDAQ)
  ,fNumberColDAQ(c.fNumberColDAQ)
  ,fProcent(c.fProcent)
  ,fDifference(c.fDifference)
  ,fNumberTrack(c.fNumberTrack)
  ,fTimeMax(c.fTimeMax)
  ,fSf(c.fSf)
  ,fRangeHistoCharge(c.fRangeHistoCharge)
  ,fNumberBinCharge(c.fNumberBinCharge)
  ,fNumberBinPRF(c.fNumberBinPRF)
  ,fNgroupprf(c.fNgroupprf)
  ,fAmpTotal(0x0)
  ,fPHPlace(0x0)
  ,fPHValue(0x0)
  ,fGoodTracklet(c.fGoodTracklet)
  ,fLinearFitterTracklet(0x0)
  ,fEntriesCH(0x0)
  ,fEntriesLinearFitter(0x0)
  ,fCalibraVector(0x0)
  ,fPH2d(0x0)
  ,fPRF2d(0x0)
  ,fCH2d(0x0)
  ,fLinearFitterArray(540)
  ,fLinearVdriftFit(0x0)
  ,fExbAltFit(0x0)
  ,fCalDetGain(0x0)
  ,fCalROCGain(0x0)
{
  //
  // Copy constructor
  //
  if(c.fCalibraMode)   fCalibraMode = new AliTRDCalibraMode(*c.fCalibraMode);
  if(c.fCalibraVector) fCalibraVector = new AliTRDCalibraVector(*c.fCalibraVector);
  if(c.fPH2d) {
    fPH2d = new TProfile2D(*c.fPH2d);
    fPH2d->SetDirectory(0);
  }
  if(c.fPRF2d) {
    fPRF2d = new TProfile2D(*c.fPRF2d);
    fPRF2d->SetDirectory(0);
  }
  if(c.fCH2d) {
    fCH2d = new TH2I(*c.fCH2d);
    fCH2d->SetDirectory(0);
  }
  if(c.fLinearVdriftFit){
    fLinearVdriftFit = new AliTRDCalibraVdriftLinearFit(*c.fLinearVdriftFit);
  }
  if(c.fExbAltFit){
    fExbAltFit = new AliTRDCalibraExbAltFit(*c.fExbAltFit);
  }

  if(c.fCalDetGain)  fCalDetGain   = new AliTRDCalDet(*c.fCalDetGain);
  if(c.fCalROCGain)  fCalROCGain   = new AliTRDCalROC(*c.fCalROCGain);

  if (fGeo) {
    delete fGeo;
  }
  fGeo = new AliTRDgeometry();
  fCalibDB = AliTRDcalibDB::Instance();

  fNumberUsedCh[0]       = 0;
  fNumberUsedCh[1]       = 0;
  fNumberUsedPh[0]       = 0;
  fNumberUsedPh[1]       = 0;

}

//____________________________________________________________________________________
AliTRDCalibraFillHisto::~AliTRDCalibraFillHisto()
{
  //
  // AliTRDCalibraFillHisto destructor
  //

  ClearHistos();
  if ( fDebugStreamer ) delete fDebugStreamer;

  if ( fCalDetGain )  delete fCalDetGain;
  if ( fCalROCGain )  delete fCalROCGain;

  if( fLinearFitterTracklet ) { delete fLinearFitterTracklet; }
  
  delete [] fPHPlace;
  delete [] fPHValue;
  delete [] fEntriesCH;
  delete [] fEntriesLinearFitter;
  delete [] fAmpTotal;
  
  for(Int_t idet=0; idet<AliTRDgeometry::kNdet; idet++){ 
    TLinearFitter *f = (TLinearFitter*)fLinearFitterArray.At(idet);
    if(f) { delete f;}
  }
  if(fLinearVdriftFit) delete fLinearVdriftFit;
  if(fExbAltFit) delete fExbAltFit;
  if (fGeo) {
    delete fGeo;
  }
  
}
//_____________________________________________________________________________
void AliTRDCalibraFillHisto::Destroy() 
{
  //
  // Delete instance 
  //

  if (fgInstance) {
    delete fgInstance;
    fgInstance = 0x0;
  }
}
//_____________________________________________________________________________
void AliTRDCalibraFillHisto::DestroyDebugStreamer() 
{
  //
  // Delete DebugStreamer
  //

  if ( fDebugStreamer ) delete fDebugStreamer;
  fDebugStreamer = 0x0;
 
}
//_____________________________________________________________________________
void AliTRDCalibraFillHisto::ClearHistos() 
{
  //
  // Delete the histos
  //

  if (fPH2d) {
    delete fPH2d;
    fPH2d  = 0x0;
  }
  if (fCH2d) {
    delete fCH2d;
    fCH2d  = 0x0;
  }
  if (fPRF2d) {
    delete fPRF2d;
    fPRF2d = 0x0;
  }
  
}
//////////////////////////////////////////////////////////////////////////////////
// calibration with AliTRDtrackV1: Init, Update 
//////////////////////////////////////////////////////////////////////////////////
//____________Functions for initialising the AliTRDCalibraFillHisto in the code_________
Bool_t AliTRDCalibraFillHisto::Init2Dhistos(Int_t nboftimebin)
{
  //
  // Init the histograms and stuff to be filled 
  //

  // DB Setting
  // Get cal
  AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
  if (!cal) {
    AliInfo("Could not get calibDB");
    return kFALSE;
  }
  AliTRDCommonParam *parCom = AliTRDCommonParam::Instance();
  if (!parCom) {
    AliInfo("Could not get CommonParam");
    return kFALSE;
  }

  // Some parameters
  if(nboftimebin > 0) fTimeMax = nboftimebin;
  else fTimeMax = cal->GetNumberOfTimeBinsDCS();
  if(fTimeMax <= 0) fTimeMax = 30;
  printf("////////////////////////////////////////////\n");
  printf("Number of time bins in calibration component %d\n",fTimeMax);
  printf("////////////////////////////////////////////\n");
  fSf                 = parCom->GetSamplingFrequency();
  if(!fNormalizeNbOfCluster) fRelativeScale = 20.0;
  else fRelativeScale = 1.18;
  fNumberClustersf    = fTimeMax;
  fNumberClusters     = (Int_t)(fNumberClustersProcent*fTimeMax);
 
  // Init linear fitter
  if(!fLinearFitterTracklet) {
    fLinearFitterTracklet = new TLinearFitter(2,"pol1");
    fLinearFitterTracklet->StoreData(kTRUE);
  }

  // Calcul Xbins Chambd0, Chamb2
  Int_t ntotal0 = CalculateTotalNumberOfBins(0);
  Int_t ntotal1 = CalculateTotalNumberOfBins(1);
  Int_t ntotal2 = CalculateTotalNumberOfBins(2);

  // If vector method On initialised all the stuff
  if(fVector2d){   
    fCalibraVector = new AliTRDCalibraVector();
    fCalibraVector->SetNumberBinCharge(fNumberBinCharge);
    fCalibraVector->SetTimeMax(fTimeMax);
    if(fNgroupprf != 0) {
      fCalibraVector->SetNumberBinPRF(2*fNgroupprf*fNumberBinPRF);
      fCalibraVector->SetPRFRange((Float_t)(3.0*fNgroupprf));
    }
    else {
      fCalibraVector->SetNumberBinPRF(fNumberBinPRF);
      fCalibraVector->SetPRFRange(1.5);
    }
    for(Int_t k = 0; k < 3; k++){
      fCalibraVector->SetDetCha0(k,fCalibraMode->GetDetChamb0(k));
      fCalibraVector->SetDetCha2(k,fCalibraMode->GetDetChamb2(k));
    }
    fCalibraVector->SetNzNrphi(0,fCalibraMode->GetNz(0),fCalibraMode->GetNrphi(0));
    fCalibraVector->SetNzNrphi(1,fCalibraMode->GetNz(1),fCalibraMode->GetNrphi(1));
    fCalibraVector->SetNzNrphi(2,fCalibraMode->GetNz(2),fCalibraMode->GetNrphi(2));
    fCalibraVector->SetNbGroupPRF(fNgroupprf);
  }
 
  // Create the 2D histos corresponding to the pad groupCalibration mode
  if (fCH2dOn) {

    AliInfo(Form("The pad calibration mode for the relative gain calibration: Nz %d, and Nrphi %d"
                ,fCalibraMode->GetNz(0)
                ,fCalibraMode->GetNrphi(0)));
    
    // Create the 2D histo
    if (fHisto2d) {
      CreateCH2d(ntotal0);
    }
    // Variable
    fAmpTotal = new Float_t[TMath::Max(fCalibraMode->GetDetChamb2(0),fCalibraMode->GetDetChamb0(0))];
    for (Int_t k = 0; k < TMath::Max(fCalibraMode->GetDetChamb2(0),fCalibraMode->GetDetChamb0(0)); k++) {
      fAmpTotal[k] = 0.0;
    } 
    //Statistics
    fEntriesCH = new Int_t[ntotal0];
    for(Int_t k = 0; k < ntotal0; k++){
      fEntriesCH[k] = 0;
    }
    
  }
  if (fPH2dOn) {

    AliInfo(Form("The pad calibration mode for the drift velocity calibration: Nz %d, and Nrphi %d"
                ,fCalibraMode->GetNz(1)
                ,fCalibraMode->GetNrphi(1)));
    
    // Create the 2D histo
    if (fHisto2d) {
      CreatePH2d(ntotal1);
    }
    // Variable
    fPHPlace = new Short_t[fTimeMax];
    for (Int_t k = 0; k < fTimeMax; k++) {
      fPHPlace[k] = -1;
    } 
    fPHValue = new Float_t[fTimeMax];
    for (Int_t k = 0; k < fTimeMax; k++) {
      fPHValue[k] = 0.0;
    }
  }
  if (fLinearFitterOn) {
    if(fLinearFitterDebugOn) {
      fLinearFitterArray.SetName("ArrayLinearFitters");
      fEntriesLinearFitter = new Int_t[540];
      for(Int_t k = 0; k < 540; k++){
	fEntriesLinearFitter[k] = 0;
      }
    }
    fLinearVdriftFit = new AliTRDCalibraVdriftLinearFit();
    TString nameee("Ver");
    nameee += fVersionExBUsed;
    nameee += "Subver";
    nameee += fSubVersionExBUsed;
    nameee += "FirstRun";
    nameee += fFirstRunExB;
    nameee += "Nz";
    fLinearVdriftFit->SetNameCalibUsed(nameee); 
  }
  if(fExbAltFitOn){
    fExbAltFit = new AliTRDCalibraExbAltFit();
  }

  if (fPRF2dOn) {

    AliInfo(Form("The pad calibration mode for the PRF calibration: Nz %d, and Nrphi %d"
                ,fCalibraMode->GetNz(2)
                ,fCalibraMode->GetNrphi(2)));
    // Create the 2D histo
    if (fHisto2d) {
      CreatePRF2d(ntotal2);
    }
  }

  return kTRUE;

}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
Bool_t AliTRDCalibraFillHisto::InitCalDet()
{
  //
  // Init the Gain Cal Det 
  //

  // DB Setting
  // Get cal
  AliCDBEntry *entry = 0x0;
  if(fTakeSnapshot) { 
    entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberGainFactor");
  }   
  else { 
    entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberGainFactor",fFirstRunGain,fVersionGainUsed,fSubVersionGainUsed); 
  }
  if(!entry) {
    AliError("No gain det calibration entry found");
    return kFALSE;
  }
  AliTRDCalDet *calDet = (AliTRDCalDet *)entry->GetObject();
  if(!calDet) {
    AliError("No calDet gain found");
    return kFALSE;
  }
   

  if( fCalDetGain ){ 
    fCalDetGain->~AliTRDCalDet();
    new(fCalDetGain) AliTRDCalDet(*(calDet));
  }else fCalDetGain = new AliTRDCalDet(*(calDet));
  
  
  // title CH2d
  TString name("Ver");
  name += fVersionGainUsed;
  name += "Subver";
  name += fSubVersionGainUsed;
  name += "FirstRun";
  name += fFirstRunGain;
  name += "Nz";
  name += fCalibraMode->GetNz(0);
  name += "Nrphi";
  name += fCalibraMode->GetNrphi(0);

  fCH2d->SetTitle(name);  
  
  // title PH2d
  TString namee("Ver");
  namee += fVersionVdriftUsed;
  namee += "Subver";
  namee += fSubVersionVdriftUsed;
  namee += "FirstRun";
  namee += fFirstRunVdrift;
  namee += "Nz";
  namee += fCalibraMode->GetNz(1);
  namee += "Nrphi";
  namee += fCalibraMode->GetNrphi(1);
  
  fPH2d->SetTitle(namee);  

  // title AliTRDCalibraVdriftLinearFit
  TString nameee("Ver");
  nameee += fVersionExBUsed;
  nameee += "Subver";
  nameee += fSubVersionExBUsed;
  nameee += "FirstRun";
  nameee += fFirstRunExB;
  nameee += "Nz";

  
  fLinearVdriftFit->SetNameCalibUsed(nameee);  



  return kTRUE;

}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
Bool_t AliTRDCalibraFillHisto::InitCalPad(Int_t detector)
{
  //
  // Init the Gain Cal Pad 
  //

  // DB Setting
  // Get cal
  AliCDBEntry *entry = 0x0;
  if(fTakeSnapshot) { 
    entry = AliCDBManager::Instance()->Get("TRD/Calib/LocalGainFactor");
  }   
  else { 
    entry = AliCDBManager::Instance()->Get("TRD/Calib/LocalGainFactor",fFirstRunGain,fVersionGainUsed,fSubVersionGainUsed); 
  }
  if(!entry) {
    AliError("No gain pad calibration entry found");
    return kFALSE;
  }
  AliTRDCalPad *calPad = (AliTRDCalPad *)entry->GetObject();
  if(!calPad) {
    AliError("No calPad gain found");
    return kFALSE;
  }
  AliTRDCalROC *calRoc = (AliTRDCalROC *)calPad->GetCalROC(detector);
  if(!calRoc) {
    AliError("No calRoc gain found");
    return kFALSE;
  }
  
  if( fCalROCGain ){ 
    fCalROCGain->~AliTRDCalROC();
    new(fCalROCGain) AliTRDCalROC(*(calRoc));
  }else fCalROCGain = new AliTRDCalROC(*(calRoc));
  

  
 
  
  return kTRUE;

}
//____________Offline tracking in the AliTRDtracker____________________________
Bool_t AliTRDCalibraFillHisto::UpdateHistogramsV1(const AliTRDtrackV1 *t,const AliESDtrack *esdtrack)
{
  //
  // Use AliTRDtrackV1 for the calibration
  //

  
  const AliTRDseedV1 *tracklet = 0x0;          // tracklet per plane
  AliTRDcluster *cl      = 0x0;                // cluster attached now to the tracklet
  AliTRDcluster *cls     = 0x0;                // shared cluster attached now to the tracklet
  Bool_t         newtr   = kTRUE;              // new track


  //
  // Cut on the number of TRD tracklets
  //
  Int_t numberoftrdtracklets = t->GetNumberOfTracklets();
  if(numberoftrdtracklets < fMinNbTRDtracklets) return kFALSE;

  Double_t tpcsignal = 1.0;
  if(esdtrack) tpcsignal = esdtrack->GetTPCsignal()/50.0;
  if(fScaleWithTPCSignal && tpcsignal <0.00001) return kFALSE;

  //
  if (!fCalibDB) {
    AliInfo("Could not get calibDB");
    return kFALSE;
  }

  
  ///////////////////////////
  // loop over the tracklet
  ///////////////////////////
  for(Int_t itr = 0; itr < 6; itr++){
    
    if(!(tracklet = t->GetTracklet(itr))) continue;
    if(!tracklet->IsOK()) continue;
    fNumberTrack++; 
    ResetfVariablestracklet();
    Float_t momentum = t->GetMomentum(itr);
    if(TMath::Abs(momentum) < fMinTRDMomentum)  continue;


    //////////////////////////////////////////
    // localisation of the tracklet and dqdl
    //////////////////////////////////////////
    Int_t layer    = tracklet->GetPlane();
    Int_t ic = 0;
    while(!(cl = tracklet->GetClusters(ic++))) continue;
    Int_t detector = cl->GetDetector();
    if (detector != fDetectorPreviousTrack) {
      // if not a new track
      if(!newtr){
	// don't use the rest of this track if in the same plane
	if (layer == GetLayer(fDetectorPreviousTrack)) {
	  //printf("bad tracklet, same layer for detector %d\n",detector);
	  break;
	}
      }
      //Localise the detector bin
      LocalisationDetectorXbins(detector);
      // Get calib objects
      if(!fIsHLT) InitCalPad(detector);	
            
      // reset
      fDetectorPreviousTrack = detector;
    }
    newtr = kFALSE;

    ////////////////////////////
    // loop over the clusters
    ////////////////////////////
    Double_t chargeQ = 0.0;
    Int_t nbclusters = 0;
    for(int jc=0; jc<AliTRDseedV1::kNtb; jc++){
      if(!(cl = tracklet->GetClusters(jc))) continue;
      nbclusters++;
      
      // Store the info bis of the tracklet
      Int_t row = cl->GetPadRow();
      Int_t col = cl->GetPadCol();
      CheckGoodTrackletV1(cl);
      Int_t     group[2] = {0,0};
      if(fCH2dOn)  group[0]  = CalculateCalibrationGroup(0,row,col);
      if(fPH2dOn)  group[1]  = CalculateCalibrationGroup(1,row,col);
      // Add the charge if shared cluster
      cls = tracklet->GetClusters(jc+AliTRDseedV1::kNtb);
      //
      //Scale with TPC signal or not
      if(!fScaleWithTPCSignal) {
	chargeQ += StoreInfoCHPHtrack(cl, tracklet->GetQperTB(jc),group,row,col,cls); //tracklet->GetdQdl(jc)
	//printf("Do not scale now\n");
      }
      else {
	chargeQ += StoreInfoCHPHtrack(cl, tracklet->GetQperTB(jc)/tpcsignal,group,row,col,cls); //tracklet->GetdQdl(jc)
      }
    
    }
    
    ////////////////////////////////////////
    // Fill the stuffs if a good tracklet
    ////////////////////////////////////////
    if (fGoodTracklet) {

      // drift velocity unables to cut bad tracklets 
      Bool_t  pass = FindP1TrackPHtrackletV1(tracklet, nbclusters);
	
      //printf("pass %d and nbclusters %d\n",pass,nbclusters);

      // Gain calibration
      if (fCH2dOn) {
	if(fCutWithVdriftCalib) {
	  if(pass) FillTheInfoOfTheTrackCH(nbclusters);
	} else {
	  FillTheInfoOfTheTrackCH(nbclusters);
	}
      }
	
      // PH calibration
      if (fPH2dOn) {
	if(fCutWithVdriftCalib) {
	  if(pass) FillTheInfoOfTheTrackPH();
	}
	else {
	  FillTheInfoOfTheTrackPH();
	}    
      }
	
      if(pass && fPRF2dOn) HandlePRFtrackletV1(tracklet,nbclusters);
	

      /////////////////////////////////////////////////////////
      // Debug
      ////////////////////////////////////////////////////////
      if(fDebugLevel > 0){
       	//printf("test\n");
	if ( !fDebugStreamer ) {
	  //debug stream
	  TDirectory *backup = gDirectory;
	  fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
	  if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
	}     
	
	Int_t    stacke = AliTRDgeometry::GetStack(detector);
	Int_t    sme    = AliTRDgeometry::GetSector(detector);
	Int_t    layere  = AliTRDgeometry::GetLayer(detector);
	// Some variables
	Float_t b[2] = {0.0,0.0};
	Float_t bCov[3] = {0.0,0.0,0.0};
	if(esdtrack) esdtrack->GetImpactParameters(b,bCov);
	if (bCov[0]<=0 || bCov[2]<=0) {
	  bCov[0]=0; bCov[2]=0;
	}
	Float_t dcaxy = b[0];
	Float_t dcaz = b[1];
	Int_t tpcnbclusters = 0;
	if(esdtrack) tpcnbclusters = esdtrack->GetTPCclusters(0);
	Double_t ttpcsignal = 0.0;
	if(esdtrack) ttpcsignal = esdtrack->GetTPCsignal();
        Int_t    cutvdriftlinear = 0;
	if(!pass) cutvdriftlinear = 1;
	
	(* fDebugStreamer) << "FillCharge"<<
	  "detector="<<detector<<
	  "stack="<<stacke<<
	  "sm="<<sme<<
	  "layere="<<layere<<
	  "dcaxy="<<dcaxy<<
	  "dcaz="<<dcaz<<
	  "nbtpccls="<<tpcnbclusters<<
	  "tpcsignal="<<ttpcsignal<<
	  "cutvdriftlinear="<<cutvdriftlinear<<
	  "ptrd="<<momentum<<
	  "nbtrdtracklet="<<numberoftrdtracklets<<
	  "charge="<<chargeQ<<
	  "\n"; 
      }
      
      
    } // if a good tracklet
  }
  
  return kTRUE;
  
}
///////////////////////////////////////////////////////////////////////////////////
// Routine inside the update with AliTRDtrack
///////////////////////////////////////////////////////////////////////////////////
//____________Offine tracking in the AliTRDtracker_____________________________
Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtrackletV1(const AliTRDseedV1 *tracklet, Int_t nbclusters)
{
  //
  // Drift velocity calibration:
  // Fit the clusters with a straight line
  // From the slope find the drift velocity
  //

  ////////////////////////////////////////////////
  //Number of points: if less than 3 return kFALSE
  /////////////////////////////////////////////////
  if(nbclusters <= 2) return kFALSE;

  ////////////
  //Variables
  ////////////
  // results of the linear fit
  Double_t dydt                       = 0.0;                                // dydt tracklet after straight line fit
  Double_t errorpar                   = 0.0;                                // error after straight line fit on dy/dt
  Double_t pointError                 = 0.0;                                // error after straight line fit 
  // pad row problemes: avoid tracklet that cross pad rows, tilting angle in the constant
  Int_t    crossrow                   = 0;                                  // if it crosses a pad row
  Int_t    rowp                       = -1;                                 // if it crosses a pad row
  Float_t  tnt                        = tracklet->GetTilt();                // tan tiltingangle
  fLinearFitterTracklet->ClearPoints();  
 
  
  ///////////////////////////////////////////
  // Take the parameters of the track
  //////////////////////////////////////////
  // take now the snp, tnp and tgl from the track
  Double_t snp = tracklet->GetSnp();             // sin dy/dx at the end of the chamber
  Double_t tnp = 0.0;                            // dy/dx at the end of the chamber 
  if( TMath::Abs(snp) <  1.){
    tnp = snp / TMath::Sqrt((1.-snp)*(1.+snp));
  } 
  Double_t tgl  = tracklet->GetTgl();           // dz/dl
  Double_t dzdx = tgl*TMath::Sqrt(1+tnp*tnp);   // dz/dx calculated from dz/dl
  // at the entrance
  //Double_t tnp = tracklet->GetYref(1);      // dy/dx at the entrance of the chamber
  //Double_t tgl = tracklet->GetZref(1);      // dz/dl at the entrance of the chamber
  //Double_t dzdx = tgl;                      //*TMath::Sqrt(1+tnp*tnp); // dz/dx from dz/dl
  // at the end with correction due to linear fit
  //Double_t tnp = tracklet->GetYfit(1);      // dy/dx at the end of the chamber after fit correction
  //Double_t tgl = tracklet->GetZfit(1);      // dz/dl at the end of the chamber after fit correction 


  ////////////////////////////
  // loop over the clusters
  ////////////////////////////
  Int_t  nbli = 0;
  AliTRDcluster *cl                   = 0x0;
  //////////////////////////////
  // Check no shared clusters
  //////////////////////////////
  for(int icc=AliTRDseedV1::kNtb; icc<AliTRDseedV1::kNclusters; icc++){
    cl = tracklet->GetClusters(icc);
    if(cl)  crossrow = 1;
  }
  //////////////////////////////////
  // Loop clusters
  //////////////////////////////////

  Float_t sigArr[AliTRDfeeParam::GetNcol()];
  memset(sigArr, 0, AliTRDfeeParam::GetNcol()*sizeof(sigArr[0]));
  Int_t ncl=0, tbf=0, tbl=0;

  for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
    if(!(cl = tracklet->GetClusters(ic))) continue;

    if(!tbf) tbf=ic;
    tbl=ic;
    ncl++;
    Int_t col = cl->GetPadCol();
    for(int ip=-1, jp=2; jp<5; ip++, jp++){
      Int_t idx=col+ip;
      if(idx<0 || idx>=AliTRDfeeParam::GetNcol()) continue;
      sigArr[idx]+=((Float_t)cl->GetSignals()[jp]);
    }

    if((fLimitChargeIntegration) && (!cl->IsInChamber())) continue;
    
    Double_t ycluster                 = cl->GetY();
    Int_t time                        = cl->GetPadTime();
    Double_t timeis                   = time/fSf;
    //See if cross two pad rows
    Int_t    row                      = cl->GetPadRow();
    if(rowp==-1) rowp                 = row;
    if(row != rowp) crossrow          = 1;

    fLinearFitterTracklet->AddPoint(&timeis,ycluster,1);
    nbli++;  

    
  }
  
  ////////////////////////////////////
  // Do the straight line fit now
  ///////////////////////////////////
  if(nbli <= 2){ 
    fLinearFitterTracklet->ClearPoints();  
    return kFALSE; 
  }
  TVectorD pars;
  fLinearFitterTracklet->Eval();
  fLinearFitterTracklet->GetParameters(pars);
  pointError  =  TMath::Sqrt(TMath::Abs(fLinearFitterTracklet->GetChisquare()/(nbli-2)));
  errorpar    =  fLinearFitterTracklet->GetParError(1)*pointError;
  dydt        = pars[1]; 
  //printf("chis %f, nbli %d, pointError %f, parError %f, errorpar %f\n",fLinearFitterTracklet->GetChisquare(),nbli,pointError,fLinearFitterTracklet->GetParError(1),errorpar);
  fLinearFitterTracklet->ClearPoints();  

  ////////////////////////////////////
  // Calc the projection of the clusters on the y direction
  ///////////////////////////////////

  Float_t signalSum(0.);
  Float_t mean = 0.0, rms = 0.0;
  Float_t dydx = tracklet->GetYref(1), tilt = tracklet->GetTilt(); // ,dzdx = tracklet->GetZref(1); (identical to the previous definition!)
  Float_t dz = dzdx*(tbl-tbf)/10;
  if(ncl>10){
    for(Int_t ip(0); ip<AliTRDfeeParam::GetNcol(); ip++){
      signalSum+=sigArr[ip]; 
      mean+=ip*sigArr[ip];
    } 
    if(signalSum > 0.0) mean/=signalSum;
  
    for(Int_t ip = 0; ip<AliTRDfeeParam::GetNcol(); ip++) 
      rms+=sigArr[ip]*(ip-mean)*(ip-mean);
    
    if(signalSum > 0.0) rms = TMath::Sqrt(TMath::Abs(rms/signalSum));
    
    rms -= TMath::Abs(dz*tilt);
    dydx -= dzdx*tilt;
  }
 
  ////////////////////////////////
  // Debug stuff
  /////////////////////////////// 


  if(fDebugLevel > 1){
    if ( !fDebugStreamer ) {
      //debug stream
      TDirectory *backup = gDirectory;
      fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
      if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
    } 
    
    float xcoord = tnp-dzdx*tnt;
    float pt = tracklet->GetPt();
    Int_t layer = GetLayer(fDetectorPreviousTrack);
           
    (* fDebugStreamer) << "FindP1TrackPHtrackletV1"<<
      //"snpright="<<snpright<<
      "nbli="<<nbli<<
      "nbclusters="<<nbclusters<<
      "detector="<<fDetectorPreviousTrack<<
      "layer="<<layer<<
      "snp="<<snp<<
      "tnp="<<tnp<<
      "tgl="<<tgl<<
      "tnt="<<tnt<<
      "dydt="<<dydt<<
      "dzdx="<<dzdx<<
      "crossrow="<<crossrow<<
      "errorpar="<<errorpar<<
      "pointError="<<pointError<<
      "xcoord="<<xcoord<<
      "pt="<<pt<<
      "rms="<<rms<<
      "dydx="<<dydx<<
      "dz="<<dz<<
      "tilt="<<tilt<<
      "ncl="<<ncl<<
      "\n";

  }
  
  /////////////////////////
  // Cuts quality
  ////////////////////////
  
  if(nbclusters < fNumberClusters) return kFALSE;
  if(nbclusters > fNumberClustersf) return kFALSE;
  if(pointError >= 0.3) return kFALSE;
  if(crossrow == 1) return kTRUE;
  
  ///////////////////////
  // Fill
  //////////////////////

  if(fLinearFitterOn){
    //Add to the linear fitter of the detector
    if( TMath::Abs(snp) <  1.){
      Double_t x = tnp-dzdx*tnt; 
      if(fLinearFitterDebugOn) {
	(GetLinearFitter(fDetectorPreviousTrack,kTRUE))->AddPoint(&x,dydt);
	fEntriesLinearFitter[fDetectorPreviousTrack]++;
      }
      fLinearVdriftFit->Update(fDetectorPreviousTrack,x,pars[1]);
    }
  }
  if(fExbAltFitOn){
    fExbAltFit->Update(fDetectorPreviousTrack,dydx,rms);
  }
  
  return kTRUE;
}
//____________Offine tracking in the AliTRDtracker_____________________________
Bool_t AliTRDCalibraFillHisto::HandlePRFtrackletV1(const AliTRDseedV1 *tracklet, Int_t nbclusters)
{
  //
  // PRF width calibration
  // Assume a Gaussian shape: determinate the position of the three pad clusters
  // Fit with a straight line
  // Take the fitted values for all the clusters (3 or 2 pad clusters)
  // Fill the PRF as function of angle of the track
  //
  //

  //printf("begin\n");
  ///////////////////////////////////////////
  // Take the parameters of the track
  //////////////////////////////////////////
  // take now the snp, tnp and tgl from the track
  Double_t snp = tracklet->GetSnp();             // sin dy/dx at the end of the chamber
  Double_t tnp = 0.0;                            // dy/dx at the end of the chamber 
  if( TMath::Abs(snp) <  1.){
    tnp = snp / TMath::Sqrt((1.-snp)*(1.+snp));
  } 
  Double_t tgl  = tracklet->GetTgl();           // dz/dl
  Double_t dzdx = tgl*TMath::Sqrt(1+tnp*tnp);   // dz/dx calculated from dz/dl
  // at the entrance
  //Double_t tnp = tracklet->GetYref(1);      // dy/dx at the entrance of the chamber
  //Double_t tgl = tracklet->GetZref(1);      // dz/dl at the entrance of the chamber
  //Double_t dzdx = tgl;                      //*TMath::Sqrt(1+tnp*tnp); // dz/dx from dz/dl
  // at the end with correction due to linear fit
  //Double_t tnp = tracklet->GetYfit(1);      // dy/dx at the end of the chamber after fit correction
  //Double_t tgl = tracklet->GetZfit(1);      // dz/dl at the end of the chamber after fit correction 

  ///////////////////////////////
  // Calculate tnp group shift
  ///////////////////////////////
  Bool_t echec   = kFALSE;
  Double_t shift = 0.0;
  //Calculate the shift in x coresponding to this tnp
  if(fNgroupprf != 0.0){
    shift      = -3.0*(fNgroupprf-1)-1.5;
    Double_t limithigh  = -0.2*(fNgroupprf-1);
    if((tnp < (-0.2*fNgroupprf)) || (tnp > (0.2*fNgroupprf))) echec = kTRUE;
    else{
      while(tnp > limithigh){
	limithigh += 0.2;
	shift += 3.0;
      }
    }
  }
  // do nothing if out of tnp range
  //printf("echec %d\n",(Int_t)echec);
  if(echec) return kFALSE;

  ///////////////////////
  // Variables
  //////////////////////

  Int_t nb3pc    = 0;              // number of three pads clusters used for fit 
  // to see the difference between the fit and the 3 pad clusters position
  Double_t padPositions[AliTRDseedV1::kNtb];
  memset(padPositions, 0, AliTRDseedV1::kNtb*sizeof(Double_t)); 
  fLinearFitterTracklet->ClearPoints();  
  
  //printf("loop clusters \n");
  ////////////////////////////
  // loop over the clusters
  ////////////////////////////
  AliTRDcluster *cl                   = 0x0;
  for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
    // reject shared clusters on pad row
    if((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) {
      cl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb);
      if(cl) continue;
    }
    cl = tracklet->GetClusters(ic);
    if(!cl) continue;
    Double_t     time  = cl->GetPadTime();
    if((time<=7) || (time>=21)) continue;
    Short_t  *signals  = cl->GetSignals(); 
    Float_t xcenter    = 0.0;    
    Bool_t  echec1      = kTRUE;   

    /////////////////////////////////////////////////////////////
    // Center 3 balanced: position with the center of the pad
    /////////////////////////////////////////////////////////////
    if ((((Float_t) signals[3]) > 0.0) && 
	(((Float_t) signals[2]) > 0.0) && 
	(((Float_t) signals[4]) > 0.0)) {
      echec1 = kFALSE;
      // Security if the denomiateur is 0 
      if ((((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) / 
	   ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))) != 1.0) {
	xcenter = 0.5 * (TMath::Log((Float_t) (((Float_t) signals[4]) / ((Float_t) signals[2]))))
	  / (TMath::Log(((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) 
			/ ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))));
      }
      else {
	echec1 = kTRUE;
      }
    }
    if(TMath::Abs(xcenter) > 0.5) echec1 = kTRUE;
    if(echec1) continue;

    ////////////////////////////////////////////////////////
    //if no echec1: calculate with the position of the pad
    // Position of the cluster
    // fill the linear fitter
    ///////////////////////////////////////////////////////
    Double_t       padPosition = xcenter +  cl->GetPadCol();
    padPositions[ic]            = padPosition;
    nb3pc++;
    fLinearFitterTracklet->AddPoint(&time, padPosition,1);


  }//clusters loop

  //printf("Fin loop clusters \n");
  //////////////////////////////
  // fit with a straight line
  /////////////////////////////
  if(nb3pc < 3){ 
    fLinearFitterTracklet->ClearPoints();  
    return kFALSE;
  }
  fLinearFitterTracklet->Eval();
  TVectorD line(2);
  fLinearFitterTracklet->GetParameters(line);
  Float_t  pointError  = -1.0;
  if( fLinearFitterTracklet->GetChisquare()>=0.0) {
  pointError  =  TMath::Sqrt( fLinearFitterTracklet->GetChisquare()/(nb3pc-2));
  }
  fLinearFitterTracklet->ClearPoints();  
 
  //printf("PRF second loop \n");
  ////////////////////////////////////////////////
  // Fill the PRF: Second loop over clusters
  //////////////////////////////////////////////
  for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
    // reject shared clusters on pad row
    cl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb);
    if(((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) && (cl)) continue;
    //
    cl = tracklet->GetClusters(ic);
    if(!cl) continue;

    Short_t  *signals      = cl->GetSignals();              // signal
    Double_t     time      = cl->GetPadTime();         // time bin
    Float_t padPosTracklet = line[0]+line[1]*time;          // reconstruct position from fit
    Float_t padPos         = cl->GetPadCol();               // middle pad
    Double_t dpad          = padPosTracklet - padPos;       // reconstruct position relative to middle pad from fit 
    Float_t ycenter        = 0.0;                           // relative center charge
    Float_t ymin           = 0.0;                           // relative left charge
    Float_t ymax           = 0.0;                           // relative right charge
  
    ////////////////////////////////////////////////////////////////
    // Calculate ycenter, ymin and ymax even for two pad clusters
    ////////////////////////////////////////////////////////////////
    if(((((Float_t) signals[3]) > 0.0) && (((Float_t) signals[2]) > 0.0)) ||
       ((((Float_t) signals[3]) > 0.0) && (((Float_t) signals[4]) > 0.0))){
      Float_t sum     = ((Float_t) signals[2]) + ((Float_t) signals[3]) + ((Float_t) signals[4]);
      if(sum > 0.0) ycenter = ((Float_t) signals[3])/ sum;
      if(sum > 0.0) ymin    = ((Float_t) signals[2])/ sum;
      if(sum > 0.0) ymax    = ((Float_t) signals[4])/ sum; 
    }
    
    /////////////////////////
    // Calibration group
    ////////////////////////
    Int_t     rowcl        = cl->GetPadRow();                           // row of cluster
    Int_t     colcl        = cl->GetPadCol();                           // col of cluster 
    Int_t     grouplocal   = CalculateCalibrationGroup(2,rowcl,colcl);  // calcul the corresponding group
    Int_t     caligroup    = fCalibraMode->GetXbins(2)+ grouplocal;     // calcul the corresponding group
    Float_t   xcl          = cl->GetY();                                // y cluster
    Float_t   qcl          = cl->GetQ();                                // charge cluster 
    Int_t     layer        = GetLayer(fDetectorPreviousTrack);          // layer 
    Int_t     stack        = GetStack(fDetectorPreviousTrack);          // stack  
    Double_t  xdiff        = dpad;                                      // reconstructed position constant
    Double_t  x            = dpad;                                      // reconstructed position moved
    Float_t   ep           = pointError;                                // error of fit
    Float_t   signal1      = (Float_t)signals[1];                       // signal at the border
    Float_t   signal3      = (Float_t)signals[3];                       // signal
    Float_t   signal2      = (Float_t)signals[2];                       // signal
    Float_t   signal4      = (Float_t)signals[4];                       // signal
    Float_t   signal5      = (Float_t)signals[5];                       // signal at the border
   


    /////////////////////
    // Debug stuff
    ////////////////////

    if(fDebugLevel > 1){
      if ( !fDebugStreamer ) {
	//debug stream
	TDirectory *backup = gDirectory;
	fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
	if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
      }     
     
      x = xdiff;
      Int_t type=0;
      Float_t y = ycenter;
      (* fDebugStreamer) << "HandlePRFtrackletV1"<<
	"caligroup="<<caligroup<<
	"detector="<<fDetectorPreviousTrack<<
	"layer="<<layer<<
	"stack="<<stack<<
	"npoints="<<nbclusters<<
	"Np="<<nb3pc<<
	"ep="<<ep<<
	"type="<<type<<
       	"snp="<<snp<<
       	"tnp="<<tnp<<
	"tgl="<<tgl<<  
	"dzdx="<<dzdx<< 
	"padPos="<<padPos<<
	"padPosition="<<padPositions[ic]<<
	"padPosTracklet="<<padPosTracklet<<
	"x="<<x<<
	"y="<<y<<	    
	"xcl="<<xcl<<
	"qcl="<<qcl<<
	"signal1="<<signal1<<
	"signal2="<<signal2<<
	"signal3="<<signal3<<
	"signal4="<<signal4<<
	"signal5="<<signal5<<
	"time="<<time<<
	"\n";
      x=-(xdiff+1);
      y = ymin;
      type=-1;
      (* fDebugStreamer) << "HandlePRFtrackletV1"<<
	"caligroup="<<caligroup<<
	"detector="<<fDetectorPreviousTrack<<
	"layer="<<layer<<
	"stack="<<stack<<
	"npoints="<<nbclusters<<
	"Np="<<nb3pc<<
	"ep="<<ep<<
	"type="<<type<<
      	"snp="<<snp<<
      	"tnp="<<tnp<<
	"tgl="<<tgl<<  
	"dzdx="<<dzdx<< 
	"padPos="<<padPos<<
	"padPosition="<<padPositions[ic]<<
	"padPosTracklet="<<padPosTracklet<<
	"x="<<x<<
	"y="<<y<<
	"xcl="<<xcl<<
	"qcl="<<qcl<<
	"signal1="<<signal1<<
	"signal2="<<signal2<<
	"signal3="<<signal3<<
	"signal4="<<signal4<<
	"signal5="<<signal5<<
	"time="<<time<<
	"\n";
      x=1-xdiff;
      y = ymax;
      type=1;
      (* fDebugStreamer) << "HandlePRFtrackletV1"<<
	"caligroup="<<caligroup<<
	"detector="<<fDetectorPreviousTrack<<
	"layer="<<layer<<
	"stack="<<stack<<
	"npoints="<<nbclusters<<
	"Np="<<nb3pc<<
	"ep="<<ep<<
	"type="<<type<<
       	"snp="<<snp<<	
       	"tnp="<<tnp<<	
	"tgl="<<tgl<<  
	"dzdx="<<dzdx<< 
	"padPos="<<padPos<<
	"padPosition="<<padPositions[ic]<<
	"padPosTracklet="<<padPosTracklet<<
	"x="<<x<<
	"y="<<y<<
	"xcl="<<xcl<<
	"qcl="<<qcl<<
	"signal1="<<signal1<<
	"signal2="<<signal2<<
	"signal3="<<signal3<<
	"signal4="<<signal4<<
	"signal5="<<signal5<<
	"time="<<time<<
	"\n";
      
    }
    
    /////////////////////
    // Cuts quality
    /////////////////////
    if(nbclusters < fNumberClusters) continue;
    if(nbclusters > fNumberClustersf) continue;
    if(nb3pc <= 5) continue;
    if((time >= 21) || (time < 7)) continue;
    if(TMath::Abs(qcl) < 80) continue; 
    if( TMath::Abs(snp) >  1.) continue;


    ////////////////////////
    // Fill the histos
    ///////////////////////
    if (fHisto2d) {
      if(TMath::Abs(dpad) < 1.5) {
	fPRF2d->Fill(shift+dpad,(caligroup+0.5),ycenter);
	fPRF2d->Fill(shift-dpad,(caligroup+0.5),ycenter);
	//printf("place %f, ycenter %f\n",(shift+dpad),ycenter);
      }
      if((ymin > 0.0) && (TMath::Abs(dpad+1.0) < 1.5)) {
	fPRF2d->Fill(shift-(dpad+1.0),(caligroup+0.5),ymin);
	fPRF2d->Fill(shift+(dpad+1.0),(caligroup+0.5),ymin);
      }
      if((ymax > 0.0) && (TMath::Abs(dpad-1.0) < 1.5)) {
	fPRF2d->Fill(shift+1.0-dpad,(caligroup+0.5),ymax);
	fPRF2d->Fill(shift-1.0+dpad,(caligroup+0.5),ymax);
      }
    }
    // vector method
    if (fVector2d) {
      if(TMath::Abs(dpad) < 1.5) {
	fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+dpad,ycenter);
	fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-dpad,ycenter);
      }
      if((ymin > 0.0) && (TMath::Abs(dpad+1.0) < 1.5)) {
	fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-(dpad+1.0),ymin);
	fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+(dpad+1.0),ymin);
      }
      if((ymax > 0.0)  && (TMath::Abs(dpad-1.0) < 1.5)) {
	fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+1.0-dpad,ymax);
	fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-1.0+dpad,ymax);
      }
    }
  } // second loop over clusters


  return kTRUE;
}
///////////////////////////////////////////////////////////////////////////////////////
// Pad row col stuff: see if masked or not
///////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________________
void AliTRDCalibraFillHisto::CheckGoodTrackletV1(const AliTRDcluster *cl)
{
  //
  // See if we are not near a masked pad
  //

  if(cl->IsMasked()) fGoodTracklet = kFALSE;

  
}
//_____________________________________________________________________________
void AliTRDCalibraFillHisto::CheckGoodTrackletV0(const Int_t detector,const Int_t row,const Int_t col)
{
  //
  // See if we are not near a masked pad
  //

  if (!IsPadOn(detector, col, row)) {
    fGoodTracklet = kFALSE;
  }

  if (col > 0) {
    if (!IsPadOn(detector, col-1, row)) {
      fGoodTracklet = kFALSE;
    }
  }

  if (col < 143) {
    if (!IsPadOn(detector, col+1, row)) {
      fGoodTracklet = kFALSE;
    }
  }
  
}
//_____________________________________________________________________________
Bool_t AliTRDCalibraFillHisto::IsPadOn(Int_t detector, Int_t row, Int_t col) const
{
  //
  // Look in the choosen database if the pad is On.
  // If no the track will be "not good"
  //

  // Get the parameter object
  AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
  if (!cal) {
    AliInfo("Could not get calibDB");
    return kFALSE;
  }
  
  if (!cal->IsChamberGood(detector)     || 
       cal->IsChamberNoData(detector)        ||
       cal->IsPadMasked(detector,col,row)) {
    return kFALSE;
  }
  else {
    return kTRUE;
  }
  
}
///////////////////////////////////////////////////////////////////////////////////////
// Calibration groups: calculate the number of groups, localise...
////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________________
Int_t AliTRDCalibraFillHisto::CalculateCalibrationGroup(Int_t i, Int_t row, Int_t col) const
{
  //
  // Calculate the calibration group number for i
  //
 
  // Row of the cluster and position in the pad groups
  Int_t posr = 0;
  if (fCalibraMode->GetNnZ(i) != 0) {
    posr = (Int_t) row / fCalibraMode->GetNnZ(i);
  }
 
      
  // Col of the cluster and position in the pad groups
  Int_t posc = 0;
  if (fCalibraMode->GetNnRphi(i) != 0) {
    posc = (Int_t) col / fCalibraMode->GetNnRphi(i);
  }
  
  return posc*fCalibraMode->GetNfragZ(i)+posr;
  
}
//____________________________________________________________________________________
Int_t AliTRDCalibraFillHisto::CalculateTotalNumberOfBins(Int_t i)
{
  //
  // Calculate the total number of calibration groups
  //
  
  Int_t ntotal = 0;

  // All together
  if((fCalibraMode->GetNz(i)==100) && (fCalibraMode->GetNrphi(i)==100)){
    ntotal = 1;
    AliInfo(Form("Total number of Xbins: %d for i %d",ntotal,i));
    return ntotal;
  }

  // Per Supermodule
  if((fCalibraMode->GetNz(i)==10) && (fCalibraMode->GetNrphi(i)==10)){
    ntotal = 18;
    AliInfo(Form("Total number of Xbins: %d for i %d",ntotal,i));
    return ntotal;
  }

  // More
  fCalibraMode->ModePadCalibration(2,i);
  fCalibraMode->ModePadFragmentation(0,2,0,i);
  fCalibraMode->SetDetChamb2(i);
  ntotal += 6 * 18 * fCalibraMode->GetDetChamb2(i);
  fCalibraMode->ModePadCalibration(0,i);
  fCalibraMode->ModePadFragmentation(0,0,0,i);
  fCalibraMode->SetDetChamb0(i);
  ntotal += 6 * 4 * 18 * fCalibraMode->GetDetChamb0(i);
  AliInfo(Form("Total number of Xbins: %d for i %d",ntotal,i));
  return ntotal;

}
//_____________________________________________________________________________
void AliTRDCalibraFillHisto::SetNz(Int_t i, Short_t Nz)
{
  //
  // Set the mode of calibration group in the z direction for the parameter i
  // 

  if ((Nz >= 0) && 
      (Nz <  5)) {
    fCalibraMode->SetNz(i, Nz); 
  }
  else { 
    AliInfo("You have to choose between 0 and 4");
  }

}
//_____________________________________________________________________________
void AliTRDCalibraFillHisto::SetNrphi(Int_t i, Short_t Nrphi)
{
  //
  // Set the mode of calibration group in the rphi direction for the parameter i
  //
 
  if ((Nrphi >= 0) && 
      (Nrphi <  7)) {
    fCalibraMode->SetNrphi(i ,Nrphi); 
  }
  else {
    AliInfo("You have to choose between 0 and 6");
  }

}

//_____________________________________________________________________________
void AliTRDCalibraFillHisto::SetAllTogether(Int_t i)
{
  //
  // Set the mode of calibration group all together
  //
  if(fVector2d == kTRUE) {
    AliInfo("Can not work with the vector method");
    return;
  }
  fCalibraMode->SetAllTogether(i);
  
}

//_____________________________________________________________________________
void AliTRDCalibraFillHisto::SetPerSuperModule(Int_t i)
{
  //
  // Set the mode of calibration group per supermodule
  //
  if(fVector2d == kTRUE) {
    AliInfo("Can not work with the vector method");
    return;
  }
  fCalibraMode->SetPerSuperModule(i);
  
}

//____________Set the pad calibration variables for the detector_______________
Bool_t AliTRDCalibraFillHisto::LocalisationDetectorXbins(Int_t detector)
{
  //
  // For the detector calcul the first Xbins and set the number of row
  // and col pads per calibration groups, the number of calibration
  // groups in the detector.
  //
  
  // first Xbins of the detector
  if (fCH2dOn) {
    fCalibraMode->CalculXBins(detector,0);
  }
  if (fPH2dOn) {
    fCalibraMode->CalculXBins(detector,1);
  }
  if (fPRF2dOn) {
    fCalibraMode->CalculXBins(detector,2);
  }

  // fragmentation of idect
  for (Int_t i = 0; i < 3; i++) {
    fCalibraMode->ModePadCalibration((Int_t) GetStack(detector),i);
    fCalibraMode->ModePadFragmentation((Int_t) GetLayer(detector)
                       , (Int_t) GetStack(detector)
                       , (Int_t) GetSector(detector),i);
  }
  
  return kTRUE;

}
//_____________________________________________________________________________
void AliTRDCalibraFillHisto::SetNumberGroupsPRF(Short_t numberGroupsPRF)
{
  //
  // Should be between 0 and 6
  //
 
  if ((numberGroupsPRF < 0) || (numberGroupsPRF > 6)) {
    AliInfo("The number of groups must be between 0 and 6!");
  } 
  else {
    fNgroupprf = numberGroupsPRF;
  }

} 
///////////////////////////////////////////////////////////////////////////////////////////
// Per tracklet: store or reset the info, fill the histos with the info
//////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________________
Float_t AliTRDCalibraFillHisto::StoreInfoCHPHtrack(const AliTRDcluster *cl,const Double_t dqdl,const Int_t *group,const Int_t row,const Int_t col,const AliTRDcluster *cls)
{
  //
  // Store the infos in fAmpTotal, fPHPlace and fPHValue
  // Correct from the gain correction before
  // cls is shared cluster if any
  // Return the charge
  // 
  //
  
  //printf("StoreInfoCHPHtrack\n");

  // time bin of the cluster not corrected
  Int_t    time     = cl->GetPadTime();
  Float_t  charge   = TMath::Abs(cl->GetQ());  
  if(cls) {
    charge += TMath::Abs(cls->GetQ());
    //printf("AliTRDCalibraFillHisto::Add the cluster charge");
  }

  //printf("Store::time %d, amplitude %f\n",time,dqdl);
  
  //Correct for the gain coefficient used in the database for reconstruction
  Float_t correctthegain = 1.0;
  if(fIsHLT) correctthegain = fCalDetGain->GetValue(fDetectorPreviousTrack);
  else correctthegain = fCalDetGain->GetValue(fDetectorPreviousTrack)*fCalROCGain->GetValue(col,row);
  Float_t correction    = 1.0;
  Float_t normalisation = 1.13; //org: 6.67; 1st: 1.056; 2nd: 1.13;
  // we divide with gain in AliTRDclusterizer::Transform...
  if( correctthegain > 0 ) normalisation /= correctthegain;


  // take dd/dl corrected from the angle of the track
  correction = dqdl / (normalisation);
  

  // Fill the fAmpTotal with the charge
  if (fCH2dOn) {
    if((!fLimitChargeIntegration) || (cl->IsInChamber())) {
      //printf("Store::group %d, amplitude %f\n",group[0],correction);
      fAmpTotal[(Int_t) group[0]] += correction;
    }
  }

  // Fill the fPHPlace and value
  if (fPH2dOn) {
    if (time>=0 && time<fTimeMax) {
      fPHPlace[time] = group[1];
      fPHValue[time] = charge;
    }
  }

  return correction;
  
}
//____________Offine tracking in the AliTRDtracker_____________________________
void AliTRDCalibraFillHisto::ResetfVariablestracklet()
{
  //
  // Reset values per tracklet
  //

  //Reset good tracklet
  fGoodTracklet = kTRUE;

  // Reset the fPHValue
  if (fPH2dOn) {
    //Reset the fPHValue and fPHPlace
    for (Int_t k = 0; k < fTimeMax; k++) {
      fPHValue[k] = 0.0;
      fPHPlace[k] = -1;
    }
  }

  // Reset the fAmpTotal where we put value
  if (fCH2dOn) {
    for (Int_t k = 0; k < fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0); k++) {
      fAmpTotal[k] = 0.0;
    }
  }
}
//____________Offine tracking in the AliTRDtracker_____________________________
void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackCH(Int_t nbclusters)
{
  //
  // For the offline tracking or mcm tracklets
  // This function will be called in the functions UpdateHistogram... 
  // to fill the info of a track for the relativ gain calibration
  //
	
  Int_t nb            =  0;   // Nombre de zones traversees
  Int_t fd            = -1;   // Premiere zone non nulle
  Float_t totalcharge = 0.0;  // Total charge for the supermodule histo

  //printf("CH2d nbclusters %d, fNumberClusters %d, fNumberClustersf %d\n",nbclusters,fNumberClusters,fNumberClustersf);

  if(nbclusters < fNumberClusters) return;
  if(nbclusters > fNumberClustersf) return;


  // Normalize with the number of clusters
  Double_t normalizeCst = fRelativeScale;
  if(fNormalizeNbOfCluster) normalizeCst = normalizeCst*nbclusters;

  //printf("Number of groups in one detector %d\n",fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0));
  
  // See if the track goes through different zones
  for (Int_t k = 0; k < fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0); k++) {
    //printf("fAmpTotal %f for %d\n",fAmpTotal[k],k);
    if (fAmpTotal[k] > 0.0) {
      totalcharge += fAmpTotal[k];
      nb++;
      if (nb == 1) {
        fd = k;
      }
    }
  }

  //printf("CH2d: nb %d, fd %d, calibration group %d, amplitude %f, detector %d\n",nb,fd,fCalibraMode->GetXbins(0),fAmpTotal[fd]/normalizeCst,fDetectorPreviousTrack);
    
  switch (nb)
    { 
    case 1:
      fNumberUsedCh[0]++;
      fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
      if (fHisto2d) {
	FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/normalizeCst);
	//fCH2d->Fill(fAmpTotal[fd]/normalizeCst,fCalibraMode->GetXbins(0)+fd+0.5);
      }
      if (fVector2d) {
	fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/normalizeCst);
      }
      break;
    case 2:
      if ((fAmpTotal[fd]   > 0.0) && 
	  (fAmpTotal[fd+1] > 0.0)) {
	// One of the two very big
	if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+1]) {
	  if (fHisto2d) {
	    FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/normalizeCst);
	    //fCH2d->Fill(fAmpTotal[fd]/normalizeCst,fCalibraMode->GetXbins(0)+fd+0.5);
	  }
	  if (fVector2d) {
	    fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/normalizeCst);
	  }
	  fNumberUsedCh[1]++;
	  fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
	}
	if (fAmpTotal[fd+1] > fProcent*fAmpTotal[fd]) {
	  if (fHisto2d) {
	    FillCH2d(fCalibraMode->GetXbins(0)+fd+1,fAmpTotal[fd+1]/normalizeCst);
	    //fCH2d->Fill(fAmpTotal[fd+1]/normalizeCst,fCalibraMode->GetXbins(0)+fd+1.5);
	  }
	  if (fVector2d) {
	    fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+1,fAmpTotal[fd+1]/normalizeCst);
	  }
	  fNumberUsedCh[1]++;
	  fEntriesCH[fCalibraMode->GetXbins(0)+fd+1]++;
	}
      }
      if (fCalibraMode->GetNfragZ(0) > 1) {
	if (fAmpTotal[fd] > 0.0) {
	  if ((fd+fCalibraMode->GetNfragZ(0)) < (fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0))) {
	    if (fAmpTotal[fd+fCalibraMode->GetNfragZ(0)] > 0.0) {
	      // One of the two very big
	      if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]) {
		if (fHisto2d) {
		  FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/normalizeCst);
		  //fCH2d->Fill(fAmpTotal[fd]/normalizeCst,fCalibraMode->GetXbins(0)+fd+0.5);
		}
		if (fVector2d) {
		  fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/normalizeCst);
		}
		fNumberUsedCh[1]++;
		fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
	      }
	      if (fAmpTotal[fd+fCalibraMode->GetNfragZ(0)] > fProcent*fAmpTotal[fd]) {
		if (fHisto2d) {
		  FillCH2d(fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/normalizeCst);
		  //fCH2d->Fill(fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/normalizeCst,fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)+0.5);
		}
		fNumberUsedCh[1]++;
		fEntriesCH[fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)]++;
		if (fVector2d) {
		  fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/normalizeCst);
		}
	      }
	    }
	  }
	}
      }
      break;
    default: break;
  }
}
//____________Offine tracking in the AliTRDtracker_____________________________
void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackPH()
{
  //
  // For the offline tracking or mcm tracklets
  // This function will be called in the functions UpdateHistogram... 
  // to fill the info of a track for the drift velocity  calibration
  //
    
  Int_t nb  =  1; // Nombre de zones traversees 1, 2 ou plus de 3
  Int_t fd1 = -1; // Premiere zone non nulle
  Int_t fd2 = -1; // Deuxieme zone non nulle
  Int_t k1  = -1; // Debut de la premiere zone
  Int_t k2  = -1; // Debut de la seconde zone
  Int_t nbclusters = 0; // number of clusters



  // See if the track goes through different zones
  for (Int_t k = 0; k < fTimeMax; k++) {
    if (fPHValue[k] > 0.0) {
      nbclusters++;
      if (fd1 == -1) {
	fd1 = fPHPlace[k];
	k1  = k;	      
      }
      if (fPHPlace[k] != fd1) {
	if (fd2 == -1) {
	  k2  = k;
	  fd2 = fPHPlace[k];
	  nb  = 2;
	}
	if (fPHPlace[k] != fd2) {
          nb = 3;
	}
      }
    }
  }

  // See if noise before and after
  if(fMaxCluster > 0) {
    if(fPHValue[0] > fMaxCluster) return;
    if(fTimeMax > fNbMaxCluster) {
      for(Int_t k = (fTimeMax-fNbMaxCluster); k < fTimeMax; k++){
	if(fPHValue[k] > fMaxCluster) return;
      }
    }
  }

  //printf("nbclusters %d, low limit %d, high limit %d\n",nbclusters,fNumberClusters,fNumberClustersf);

  if(nbclusters < fNumberClusters) return;
  if(nbclusters > fNumberClustersf) return;
  
  switch(nb)
    {
    case 1:
      fNumberUsedPh[0]++;
      for (Int_t i = 0; i < fTimeMax; i++) {
	if (fHisto2d) {
	  if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
	  else {
	    if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
	      }
	  //printf("Fill the time bin %d with %f\n",i,fPHValue[i]);
	}
	if (fVector2d) {
	  if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
	  else {
	    if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);  
	  }
	}
      }
      break;
    case 2:
      if ((fd1 == fd2+1) || 
	  (fd2 == fd1+1)) {
	// One of the two fast all the think
	if (k2 > (k1+fDifference)) {
	  //we choose to fill the fd1 with all the values
	  fNumberUsedPh[1]++;
	  for (Int_t i = 0; i < fTimeMax; i++) {
	    if (fHisto2d) {
	      if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
	      else {
		if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
		  }
	    }
	    if (fVector2d) {
	      if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
	      else {
		if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
		  }
	    }
	  }
	}
	if ((k2+fDifference) < fTimeMax) {
	  //we choose to fill the fd2 with all the values
	  fNumberUsedPh[1]++;
	  for (Int_t i = 0; i < fTimeMax; i++) {
	    if (fHisto2d) {
	      if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
	      else {
		if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
	      }
	    }
	  if (fVector2d) {
	    if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
	    else {
	      if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
	    }
	  }
	  }
	}
      }
      // Two zones voisines sinon rien!
      if (fCalibraMode->GetNfragZ(1) > 1) {
	// Case 2
	if ((fd1+fCalibraMode->GetNfragZ(1)) < (fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1))) {
	  if (fd2 == (fd1+fCalibraMode->GetNfragZ(1))) {
	    // One of the two fast all the think
	    if (k2 > (k1+fDifference)) {
	      //we choose to fill the fd1 with all the values
	      fNumberUsedPh[1]++;
	      for (Int_t i = 0; i < fTimeMax; i++) {
		if (fHisto2d) {
		  if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
		  else {
		    if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
		  }
		}
		if (fVector2d) {
		  if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
		  else {
		    if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
		  }
		}
	      }
	    }
	    if ((k2+fDifference) < fTimeMax) {
	      //we choose to fill the fd2 with all the values
	      fNumberUsedPh[1]++;
	      for (Int_t i = 0; i < fTimeMax; i++) {
		if (fHisto2d) {
		  if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
		  else {
		    if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
		  }
		}
		if (fVector2d) {
		  if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
		  else {
		    if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
		  }
		}
	      }
	    }
	  }
	}
	// Two zones voisines sinon rien!
	// Case 3
	if ((fd1 - fCalibraMode->GetNfragZ(1)) >= 0) {
	  if (fd2 == (fd1 - fCalibraMode->GetNfragZ(1))) {
	    // One of the two fast all the think
	    if (k2 > (k1 + fDifference)) {
	      //we choose to fill the fd1 with all the values
	      fNumberUsedPh[1]++;
	      for (Int_t i = 0; i < fTimeMax; i++) {
		if (fHisto2d) {
		  if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
		  else {
		    if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
		  }
		}
		if (fVector2d) {
		  if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
		  else {
		    if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
		  }
		}
	      }
	    }
	    if ((k2+fDifference) < fTimeMax) {
	      //we choose to fill the fd2 with all the values
	      fNumberUsedPh[1]++;
	      for (Int_t i = 0; i < fTimeMax; i++) {
		if (fHisto2d) {
		  if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
		  else {
		    if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
		  }
		}
		if (fVector2d) {
		  if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
		  else {
		    if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
		  }
		}
	      }
	    }
	  }
	}
      }
      break;
    default: break;
    } 
}
//////////////////////////////////////////////////////////////////////////////////////////
// DAQ process functions
/////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________
Int_t AliTRDCalibraFillHisto::ProcessEventDAQ(AliRawReader *rawReader)
 { //main
  //
  // Event Processing loop - AliTRDrawStream
  // 
  // 0 timebin problem
  // 1 no input
  // 2 input
  // Same algorithm as TestBeam but different reader
  //

  AliTRDrawStream *rawStream = new AliTRDrawStream(rawReader);

  AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager(kTRUE);
  digitsManager->CreateArrays();
    
  Int_t withInput = 1;
  
  Double_t phvalue[16][144][36];
  for(Int_t k = 0; k < 36; k++){
    for(Int_t j = 0; j < 16; j++){
      for(Int_t c = 0; c < 144; c++){
	phvalue[j][c][k] = 0.0;
      }
    }
  }
  
  fDetectorPreviousTrack = -1;
  fMCMPrevious           = -1;
  fROBPrevious           = -1;
  
  Int_t nbtimebin = 0;                                        
  Int_t baseline  = 10;  

  
    fTimeMax = 0;
       
    Int_t det    = 0;
    while ((det = rawStream->NextChamber(digitsManager, NULL, NULL)) >= 0) { //idetector

      if (digitsManager->GetIndexes(det)->HasEntry()) {//QA
	//	printf("there is ADC data on this chamber!\n");

	AliTRDarrayADC *digits = (AliTRDarrayADC *) digitsManager->GetDigits(det); //mod
	if (digits->HasData()) { //array
	  
	  AliTRDSignalIndex   *indexes = digitsManager->GetIndexes(det);
	  if (indexes->IsAllocated() == kFALSE) {
	    AliError("Indexes do not exist!");
	    break;
	  }
	  Int_t iRow  = 0;
	  Int_t iCol  = 0;
	  indexes->ResetCounters();
	  
	  while (indexes->NextRCIndex(iRow, iCol)) { //column,row
	    //printf(" det %d \t row %d \t col %d \t digit\n",det,iRow,iCol);
	    //while (rawStream->Next()) {
	    
	    Int_t idetector = det;                                             //  current detector
	    //Int_t imcm      = rawStream->GetMCM();                            //  current MCM
	    //Int_t irob      = rawStream->GetROB();                            //  current ROB
	    
	  
	    if((fDetectorPreviousTrack != idetector) && (fDetectorPreviousTrack != -1)) {
	      // Fill
	      withInput = TMath::Max(FillDAQ(phvalue),withInput);
	      
	      // reset
	      for(Int_t k = 0; k < 36; k++){
		for(Int_t j = 0; j < 16; j++){
		  for(Int_t c = 0; c < 144; c++){
		    phvalue[j][c][k] = 0.0;
		  }
		}
	      }
	    }
	    
	    fDetectorPreviousTrack = idetector;
	    //fMCMPrevious           = imcm;
	    //fROBPrevious           = irob;
	    
	    //	  nbtimebin              = rawStream->GetNumberOfTimeBins();              //  number of time bins read from data
	    AliTRDdigitsParam *digitParam = (AliTRDdigitsParam *)digitsManager->GetDigitsParam();
	    nbtimebin              = digitParam->GetNTimeBins(det);              //  number of time bins read from data
	    baseline               = digitParam->GetADCbaseline(det);            //  baseline
	    
	    if(nbtimebin == 0) return 0;
	    if((fTimeMax != 0) && (nbtimebin != fTimeMax)) return 0;
	    fTimeMax          = nbtimebin;
	    
	    fNumberClustersf    = fTimeMax;
	    fNumberClusters     = (Int_t)(fNumberClustersProcent*fTimeMax);
	  	  
	    
	    for(Int_t itime = 0; itime < nbtimebin; itime++) {
	      //	    phvalue[row][col][itime] = signal[itime]-baseline;
	      phvalue[iRow][iCol][itime] = (Short_t)(digits->GetData(iRow,iCol,itime) - baseline);
	      /*if(phvalue[iRow][iCol][itime] >= 20) {
		 printf("----------> phvalue[%d][%d][%d] %d  baseline %d \n",
		       iRow,
		       iCol,
		       itime,
		       (Short_t)(digits->GetData(iRow,iCol,itime)),
		       baseline);
		       }*/
	    }
	    
	  }//column,row
	  
	  // fill the last one
	  if(fDetectorPreviousTrack != -1){
	    
	    // Fill
	    withInput = TMath::Max(FillDAQ(phvalue),withInput);
	    //	    printf("\n ---> withinput %d\n\n",withInput);
	    // reset
	    for(Int_t k = 0; k < 36; k++){
	      for(Int_t j = 0; j < 16; j++){
		for(Int_t c = 0; c < 144; c++){
		  phvalue[j][c][k] = 0.0;
		}
	      }
	    }
	  }
	  
	}//array
      }//QA
      digitsManager->ClearArrays(det);
    }//idetector
    delete digitsManager;

    delete rawStream;
    return withInput;
 }//main
//_____________________________________________________________________
//////////////////////////////////////////////////////////////////////////////
// Routine inside the DAQ process
/////////////////////////////////////////////////////////////////////////////
//_______________________________________________________________________
Int_t AliTRDCalibraFillHisto::FillDAQ(Double_t phvalue[16][144][36]){

  //
  // Look for the maximum by collapsing over the time
  // Sum over four pad col and two pad row
  //

  Int_t used = 0;


  Int_t idect = fDetectorPreviousTrack;      
  //printf("Enter Detector %d\n",fDetectorPreviousTrack);
  Double_t sum[36];
  for(Int_t tb = 0; tb < 36; tb++){
    sum[tb] = 0.0;
  }

  //fGoodTracklet = kTRUE;
  //fDetectorPreviousTrack = 0;  


  ///////////////////////////
  // look for maximum
  /////////////////////////

  Int_t imaxRow = 0;
  Int_t imaxCol = 0;
  Double_t integralMax = -1;
  
  for (Int_t ir = 1; ir <= 15; ir++)
    {
      for (Int_t ic = 2; ic <= 142; ic++)
	{
	  Double_t integral = 0;		  
	  for (Int_t ishiftR = 0; ishiftR < fNumberRowDAQ; ishiftR++)
	    {
	      for (Int_t ishiftC = -fNumberColDAQ; ishiftC < fNumberColDAQ; ishiftC++)
		{
		  if (ir + ishiftR >= 1 && ir + ishiftR <= 16 &&
		      ic + ishiftC >= 1 && ic + ishiftC <= 144)
		    {

		      for(Int_t tb = 0; tb< fTimeMax; tb++){
			integral += phvalue[ir + ishiftR-1][ic + ishiftC-1][tb];
		      }// addtb
		    } //addsignal
		} //shiftC
	    } // shiftR
	  if (integralMax < integral)
	    {
	      imaxRow = ir;
	      imaxCol = ic;
	      integralMax = integral;
	      
	    } // check max integral
	} //ic
    } // ir

  //  printf("imaxRow %d, imaxCol %d, fTimeMax %d, integralMax %f\n",imaxRow,imaxCol,fTimeMax, integralMax);
  //if((imaxRow == 0) || (imaxRow >= 15) || (imaxCol <= 3) || (imaxCol >= 140)) {
  //  used=1;
  //  return used;
  // }

  if(((imaxRow + fNumberRowDAQ) > 16) || (imaxRow == 0) || ((imaxCol - fNumberColDAQ) <= 1) || ((imaxCol + fNumberColDAQ) >= 144)) {
    used=1;
    return used;
  }
  //CheckGoodTrackletV0(fDetectorPreviousTrack,imaxRow,imaxCol);
  //if(!fGoodTracklet) used = 1;;
  
  //  /////////////////////////////////////////////////////
  // sum ober 2 row and 4 pad cols for each time bins
  //  ////////////////////////////////////////////////////	  
  
  
  
  for (Int_t ishiftR = 0; ishiftR < fNumberRowDAQ; ishiftR++)
    {
      for (Int_t ishiftC = -fNumberColDAQ; ishiftC < fNumberColDAQ; ishiftC++)
	{
	  if (imaxRow + ishiftR >= 1 && imaxRow + ishiftR <= 16 &&
	      imaxCol + ishiftC >= 1 && imaxCol + ishiftC <= 144)
	    { 
	      for(Int_t it = 0; it < fTimeMax; it++){
		sum[it] += phvalue[imaxRow + ishiftR-1][imaxCol + ishiftC-1][it];
	      } 
	    }
	} // col shift
    }// row shift

  Int_t nbcl = 0;
  Double_t sumcharge = 0.0;
  for(Int_t it = 0; it < fTimeMax; it++){
    sumcharge += sum[it];
    if(sum[it] > fThresholdClustersDAQ)  nbcl++;
  }


  /////////////////////////////////////////////////////////
  // Debug
  ////////////////////////////////////////////////////////
  if(fDebugLevel > 1){
    if ( !fDebugStreamer ) {
      //debug stream
      TDirectory *backup = gDirectory;
      fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
      if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
    }     

    Double_t amph0 = sum[0];
    Double_t amphlast = sum[fTimeMax-1];
    Double_t rms      = TMath::RMS(fTimeMax,sum);
    Int_t    goodtracklet = (Int_t) fGoodTracklet;
    for(Int_t it = 0; it < fTimeMax; it++){
      Double_t clustera = sum[it]; 

    (* fDebugStreamer) << "FillDAQa"<<
      "ampTotal="<<sumcharge<<
      "row="<<imaxRow<<
      "col="<<imaxCol<<
      "detector="<<idect<<
      "amph0="<<amph0<<
      "amphlast="<<amphlast<<
      "goodtracklet="<<goodtracklet<<
      "clustera="<<clustera<<
      "it="<<it<<
      "rms="<<rms<<
      "nbcl="<<nbcl<<
      "\n"; 
    }
  }

  ////////////////////////////////////////////////////////
  // fill
  ///////////////////////////////////////////////////////
  //printf("fNumberClusters %d, fNumberClustersf %d\n",fNumberClusters,fNumberClustersf);
  if(sum[0] > 100.0) used = 1; 
  if(nbcl < fNumberClusters) used = 1;
  if(nbcl > fNumberClustersf) used = 1;

  //if(fDetectorPreviousTrack == 15){
  //  printf("rms %f and first time bin %f\n",TMath::RMS(fTimeMax,sum),sum[0]);
  //}
  //if((TMath::RMS(fTimeMax,sum) <= 10.0) && (sum[0] > 200.0)) return 1;
  if(used == 0){
    for(Int_t it = 0; it < fTimeMax; it++){
      if(fFillWithZero) UpdateDAQ(fDetectorPreviousTrack,0,0,it,sum[it],fTimeMax); 
      else{
	if(sum[it] > 0.0) UpdateDAQ(fDetectorPreviousTrack,0,0,it,sum[it],fTimeMax); 
      } 
      //if(fFillWithZero) UpdateDAQ(0,0,0,it,sum[it],fTimeMax);
      //else{
      // if(sum[it] > 0.0) UpdateDAQ(0,0,0,it,sum[it],fTimeMax);
      //}
    }
    
   
    //((TH2I *)GetCH2d()->Fill(sumcharge/30.0,fDetectorPreviousTrack));
    used = 2;
    //printf("Pass Detector %d\n",fDetectorPreviousTrack);

  }
 
  return used;
  
}
//____________Online trackling in AliTRDtrigger________________________________
Bool_t AliTRDCalibraFillHisto::UpdateDAQ(Int_t det, Int_t /*row*/, Int_t /*col*/, Int_t timebin, Float_t signal, Int_t nbtimebins)
{
  //
  // For the DAQ
  // Fill a simple average pulse height
  //

  
  ((TProfile2D *)GetPH2d(nbtimebins,fSf))->Fill((Float_t) timebin/fSf,det+0.5,(Float_t) signal); 

 
  return kTRUE;
  
}
//____________Write_____________________________________________________
//_____________________________________________________________________
void AliTRDCalibraFillHisto::Write2d(const Char_t *filename, Bool_t append)
{
  //
  //  Write infos to file
  //
  
  //For debugging
  if ( fDebugStreamer ) {
    delete fDebugStreamer;
    fDebugStreamer = 0x0;
  }

  AliInfo(Form("Numbertrack: %d Numberusedch[0]: %d, Numberusedch[1]: %d Numberusedph[0]: %d, Numberusedph[1]: %d"
	       ,fNumberTrack
	       ,fNumberUsedCh[0]
	       ,fNumberUsedCh[1]
	       ,fNumberUsedPh[0]
	       ,fNumberUsedPh[1]));
  
  TDirectory *backup = gDirectory;
  TString option;
  
  if ( append )
    option = "update";
  else
    option = "recreate";
  
  TFile f(filename,option.Data());
  
  TStopwatch stopwatch;
  stopwatch.Start();
  if(fVector2d) {
    f.WriteTObject(fCalibraVector);
  }

  if (fCH2dOn ) {
    if (fHisto2d) {
      f.WriteTObject(fCH2d);
    }
  }
  if (fPH2dOn ) {
    if (fHisto2d) {
      f.WriteTObject(fPH2d);
    }
  }
  if (fPRF2dOn) {
    if (fHisto2d) {
	f.WriteTObject(fPRF2d);
    }
  }
  if(fLinearFitterOn){
    if(fLinearFitterDebugOn) AnalyseLinearFitter();
    f.WriteTObject(fLinearVdriftFit);
  }
   
  f.Close();
  
  if ( backup ) backup->cd();
  
  AliInfo(Form("Execution time Write2d: R:%.2fs C:%.2fs"
	       ,stopwatch.RealTime(),stopwatch.CpuTime()));
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Stats stuff
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//___________________________________________probe the histos__________________________________________________
Double_t *AliTRDCalibraFillHisto::StatH(TH2 *h, Int_t i)
{
  //
  // Check the number of stats in h, 0 is TH2I 1 is TProfile2D
  // debug mode with 2 for TH2I and 3 for TProfile2D
  // It gives a pointer to a Double_t[7] with the info following...
  // [0] : number of calibration groups with entries
  // [1] : minimal number of entries found
  // [2] : calibration group number of the min
  // [3] : maximal number of entries found
  // [4] : calibration group number of the max
  // [5] : mean number of entries found
  // [6] : mean relative error
  //

  Double_t *info = new Double_t[7];
   
  // Number of Xbins (detectors or groups of pads)
  Int_t    nbins   = h->GetNbinsY(); //number of calibration groups
  Int_t    nxbins  = h->GetNbinsX(); //number of bins per histo

  // Initialise
  Double_t nbwe = 0; //number of calibration groups with entries
  Double_t minentries = 0; //minimal number of entries found
  Double_t maxentries = 0; //maximal number of entries found
  Double_t placemin = 0; //calibration group number of the min
  Double_t placemax = -1; //calibration group number of the max
  Double_t meanstats = 0.0; //mean number of entries over the calibration group with at least ome entry
  Double_t meanrelativerror = 0.0; //mean relativ error in the TProfile2D

  Double_t counter = 0;

  //Debug
  TH1F *nbEntries = 0x0;//distribution of the number of entries
  TH1F *nbEntriesPerGroup = 0x0;//Number of entries per group
  TProfile *nbEntriesPerSp = 0x0;//Number of entries for one supermodule
    
  // Beginning of the loop over the calibration groups 
  for (Int_t idect = 0; idect < nbins; idect++) {

    TH1I *projch = (TH1I *) h->ProjectionX("projch",idect+1,idect+1,(Option_t *)"e");
    projch->SetDirectory(0);
    
    // Number of entries for this calibration group
    Double_t nentries = 0.0;
    if((i%2) == 0){
      for (Int_t k = 0; k < nxbins; k++) {
	nentries += h->GetBinContent(h->GetBin(k+1,idect+1));
      }
    }
    else{
      for (Int_t k = 0; k < nxbins; k++) {
	nentries += ((TProfile2D *)h)->GetBinEntries(h->GetBin(k+1,idect+1));
	if(h->GetBinContent(h->GetBin(k+1,idect+1)) != 0) {
	  meanrelativerror += (h->GetBinError(h->GetBin(k+1,idect+1))/(TMath::Abs(h->GetBinContent(h->GetBin(k+1,idect+1)))));
	  counter++;
	} 
      }
    }

    //Debug
    if(i > 1){
      if(nentries > 0){
	if(!((Bool_t)nbEntries)) nbEntries = new TH1F("Number of entries","Number of entries",100,(Int_t)nentries/2,nentries*2);
	nbEntries->SetDirectory(0);
	nbEntries->Fill(nentries);
	if(!((Bool_t)nbEntriesPerGroup)) nbEntriesPerGroup = new TH1F("Number of entries per group","Number of entries per group",nbins,0,nbins);
	nbEntriesPerGroup->SetDirectory(0);
	nbEntriesPerGroup->Fill(idect+0.5,nentries);
	if(!((Bool_t)nbEntriesPerSp)) nbEntriesPerSp = new TProfile("Number of entries per supermodule","Number of entries per supermodule",(Int_t)(nbins/18),0,(Int_t)(nbins/18));
	nbEntriesPerSp->SetDirectory(0);
	nbEntriesPerSp->Fill((idect%((Int_t)(nbins/18)))+0.5,nentries);
      }
    }

    //min amd max
    if(nentries > maxentries){
      maxentries = nentries;
      placemax = idect;
    }
    if(idect == 0) {
      minentries = nentries;
    }
    if(nentries < minentries){
      minentries = nentries;
      placemin = idect;
    }
    //nbwe
    if(nentries > 0) {
      nbwe++;
      meanstats += nentries;
    }
  }//calibration groups loop
  
  if(nbwe > 0) meanstats /= nbwe;
  if(counter > 0) meanrelativerror /= counter;

  AliInfo(Form("There are %f calibration groups with entries",nbwe));
  AliInfo(Form("The minimum number of entries is %f for the group %f",minentries,placemin));
  AliInfo(Form("The maximum number of entries is %f for the group %f",maxentries,placemax));
  AliInfo(Form("The mean number of entries is %f",meanstats));
  if((i%2) == 1) AliInfo(Form("The mean relative error is %f",meanrelativerror));

  info[0] = nbwe;
  info[1] = minentries;
  info[2] = placemin;
  info[3] = maxentries;
  info[4] = placemax;
  info[5] = meanstats;
  info[6] = meanrelativerror;

  if(nbEntries && nbEntriesPerSp && nbEntriesPerGroup){
    gStyle->SetPalette(1);
    gStyle->SetOptStat(1111);
    gStyle->SetPadBorderMode(0);
    gStyle->SetCanvasColor(10);
    gStyle->SetPadLeftMargin(0.13);
    gStyle->SetPadRightMargin(0.01);
    TCanvas *stat = new TCanvas("stat","",50,50,600,800);
    stat->Divide(2,1);
    stat->cd(1);
    nbEntries->Draw("");
    stat->cd(2);
    nbEntriesPerSp->SetStats(0);
    nbEntriesPerSp->Draw("");
    TCanvas *stat1 = new TCanvas("stat1","",50,50,600,800);
    stat1->cd();
    nbEntriesPerGroup->SetStats(0);
    nbEntriesPerGroup->Draw("");
  }

  return info;

}
//____________________________________________________________________________
Double_t *AliTRDCalibraFillHisto::GetMeanMedianRMSNumberCH()
{
  //
  // Return a Int_t[4] with:
  // 0 Mean number of entries
  // 1 median of number of entries
  // 2 rms of number of entries
  // 3 number of group with entries
  //

  Double_t *stat = new Double_t[4];
  stat[3]             = 0.0;

  Int_t    nbofgroups = CalculateTotalNumberOfBins(0);
  
  Double_t *weight = new Double_t[nbofgroups];
  Double_t *nonul = new Double_t[nbofgroups];
 
  for(Int_t k = 0; k < nbofgroups; k++){
    if(fEntriesCH[k] > 0) {
      weight[k] = 1.0;
      nonul[(Int_t)stat[3]] = fEntriesCH[k];
      stat[3]++;
    }
    else weight[k] = 0.0;
  }
  stat[0]          = TMath::Mean(nbofgroups,fEntriesCH,weight); 
  stat[1]          = TMath::Median(nbofgroups,fEntriesCH,weight); 
  stat[2]          = TMath::RMS((Int_t)stat[3],nonul); 

  delete [] weight;
  delete [] nonul;

  return stat;

}
//____________________________________________________________________________
Double_t *AliTRDCalibraFillHisto::GetMeanMedianRMSNumberLinearFitter() const
{
  //
  // Return a Int_t[4] with:
  // 0 Mean number of entries
  // 1 median of number of entries
  // 2 rms of number of entries
  // 3 number of group with entries
  //

  Double_t *stat      = new Double_t[4]; 
  stat[3]             = 0.0;

  Int_t    nbofgroups = 540;
  Double_t *weight    = new Double_t[nbofgroups];
  Int_t    *nonul     = new Int_t[nbofgroups]; 

  for(Int_t k = 0; k < nbofgroups; k++){
    if(fEntriesLinearFitter[k] > 0) {
      weight[k] = 1.0;
      nonul[(Int_t) stat[3]] = fEntriesLinearFitter[k];
      stat[3]++;     
    }
    else weight[k] = 0.0;
  }
  stat[0]          = TMath::Mean(nbofgroups,fEntriesLinearFitter,weight); 
  stat[1]          = TMath::Median(nbofgroups,fEntriesLinearFitter,weight); 
  stat[2]          = TMath::RMS((Int_t)stat[3],nonul); 

  delete [] weight;
  delete [] nonul;

  return stat;

}
//////////////////////////////////////////////////////////////////////////////////////
// Create Histos
//////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________________
void AliTRDCalibraFillHisto::CreatePRF2d(Int_t nn)
{
  //
  // Create the 2D histos: here we have 2*fNgroupprf bins in tnp of 0.2 amplitude each
  // If fNgroupprf is zero then no binning in tnp
  //

  TString name("Nz");
  name += fCalibraMode->GetNz(2);
  name += "Nrphi";
  name += fCalibraMode->GetNrphi(2);
  name += "Ngp";
  name += fNgroupprf;

  if(fNgroupprf != 0){
    
    fPRF2d = new TProfile2D("PRF2d",(const Char_t *) name
			    ,2*fNgroupprf*fNumberBinPRF,-3.0*fNgroupprf,3.0*fNgroupprf,nn,0,nn);
    fPRF2d->SetYTitle("Det/pad groups");
    fPRF2d->SetXTitle("Position x/W [pad width units]");
    fPRF2d->SetZTitle("Q_{i}/Q_{total}");
    fPRF2d->SetStats(0);
  }
  else{
    fPRF2d = new TProfile2D("PRF2d",(const Char_t *) name
			    ,fNumberBinPRF,-1.5,1.5,nn,0,nn);
    fPRF2d->SetYTitle("Det/pad groups");
    fPRF2d->SetXTitle("Position x/W [pad width units]");
    fPRF2d->SetZTitle("Q_{i}/Q_{total}");
    fPRF2d->SetStats(0);
  }

}

//_____________________________________________________________________________
void AliTRDCalibraFillHisto::CreatePH2d(Int_t nn)
{
  //
  // Create the 2D histos
  //

  TString name("Ver");
  name += fVersionVdriftUsed;
  name += "Subver";
  name += fSubVersionVdriftUsed;
  name += "FirstRun";
  name += fFirstRunVdrift;
  name += "Nz";
  name += fCalibraMode->GetNz(1);
  name += "Nrphi";
  name += fCalibraMode->GetNrphi(1);
  
  fPH2d = new TProfile2D("PH2d",(const Char_t *) name
			 ,fTimeMax,-0.5/fSf,(Float_t) (fTimeMax-0.5)/fSf
			 ,nn,0,nn);
  fPH2d->SetYTitle("Det/pad groups");
  fPH2d->SetXTitle("time [#mus]");
  fPH2d->SetZTitle("<PH> [a.u.]");
  fPH2d->SetStats(0);

}
//_____________________________________________________________________________
void AliTRDCalibraFillHisto::CreateCH2d(Int_t nn)
{
  //
  // Create the 2D histos
  //

  TString name("Ver");
  name += fVersionGainUsed;
  name += "Subver";
  name += fSubVersionGainUsed;
  name += "FirstRun";
  name += fFirstRunGain;
  name += "Nz";
  name += fCalibraMode->GetNz(0);
  name += "Nrphi";
  name += fCalibraMode->GetNrphi(0);
  
  fCH2d = new TH2I("CH2d",(const Char_t *) name
		   ,(Int_t)fNumberBinCharge,0,fRangeHistoCharge,nn,0,nn);
  fCH2d->SetYTitle("Det/pad groups");
  fCH2d->SetXTitle("charge deposit [a.u]");
  fCH2d->SetZTitle("counts");
  fCH2d->SetStats(0);
  fCH2d->Sumw2();

}
//////////////////////////////////////////////////////////////////////////////////
// Set relative scale
/////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________________
void AliTRDCalibraFillHisto::SetRelativeScale(Float_t RelativeScale)
{
  //
  // Set the factor that will divide the deposited charge
  // to fit in the histo range [0,fRangeHistoCharge]
  //
 
  if (RelativeScale > 0.0) {
    fRelativeScale = RelativeScale;
  } 
  else {
    AliInfo("RelativeScale must be strict positif!");
  }

}
//////////////////////////////////////////////////////////////////////////////////
// Quick way to fill a histo
//////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________
void  AliTRDCalibraFillHisto::FillCH2d(Int_t x, Float_t y)
{
  //
  // FillCH2d: Marian style
  // 
  
  //skip simply the value out of range
  if((y>=fRangeHistoCharge) || (y<0.0)) return;
  if(fRangeHistoCharge < 0.0) return;
  
  //Calcul the y place
  Int_t yplace = (Int_t) (fNumberBinCharge*y/fRangeHistoCharge)+1;
  Int_t place = (fNumberBinCharge+2)*(x+1)+yplace;
  
  //Fill
  fCH2d->GetArray()[place]++;

}
 
//////////////////////////////////////////////////////////////////////////////////
// Geometrical functions
///////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________________
Int_t AliTRDCalibraFillHisto::GetLayer(Int_t d) const
{
  //
  // Reconstruct the layer number from the detector number
  //

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

}

//_____________________________________________________________________________
Int_t AliTRDCalibraFillHisto::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 AliTRDCalibraFillHisto::GetSector(Int_t d) const
{
  //
  // Reconstruct the sector number from the detector number
  //
  Int_t fg = 30;

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

}
///////////////////////////////////////////////////////////////////////////////////
// Getter functions for DAQ of the CH2d and the PH2d
//////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________
TProfile2D* AliTRDCalibraFillHisto::GetPH2d(Int_t nbtimebin, Float_t samplefrequency)
{
    //
    // return pointer to fPH2d TProfile2D
    // create a new TProfile2D if it doesn't exist allready
    //
    if ( fPH2d )
	return fPH2d;

    // Some parameters
    fTimeMax = nbtimebin;
    fSf      = samplefrequency;
  
    CreatePH2d(540);

    return fPH2d;
}
//_____________________________________________________________________
TH2I* AliTRDCalibraFillHisto::GetCH2d()
{
    //
    // return pointer to fCH2d TH2I
    // create a new TH2I if it doesn't exist allready
    //
    if ( fCH2d )
        return fCH2d;

    CreateCH2d(540);

    return fCH2d;
}
////////////////////////////////////////////////////////////////////////////////////////////
// Drift velocity calibration
///////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________
TLinearFitter* AliTRDCalibraFillHisto::GetLinearFitter(Int_t detector, Bool_t force)
{
    //
    // return pointer to TLinearFitter Calibration
    // if force is true create a new TLinearFitter if it doesn't exist allready
    //

  if ((!force) || (fLinearFitterArray.UncheckedAt(detector))){
    return (TLinearFitter*)fLinearFitterArray.UncheckedAt(detector);
  }

  // if we are forced and TLinearFitter doesn't yet exist create it

  // new TLinearFitter
  TLinearFitter *linearfitter = new TLinearFitter(2,"pol1");
  fLinearFitterArray.AddAt(linearfitter,detector);
  return linearfitter;
}

//____________________________________________________________________________
void AliTRDCalibraFillHisto::AnalyseLinearFitter()
{
  //
  // Analyse array of linear fitter because can not be written
  // Store two arrays: one with the param the other one with the error param + number of entries
  //

  for(Int_t k = 0; k < 540; k++){
    TLinearFitter *linearfitter = GetLinearFitter(k);
    if((linearfitter!=0) && (fEntriesLinearFitter[k]>10)){
      TVectorD  *par  = new TVectorD(2);
      TVectorD   pare = TVectorD(2);
      TVectorD  *parE = new TVectorD(3);
      if((linearfitter->EvalRobust(0.8)==0)) {
	//linearfitter->Eval();
	linearfitter->GetParameters(*par);
	//linearfitter->GetErrors(pare);
	//Float_t  ppointError =  TMath::Sqrt(TMath::Abs(linearfitter->GetChisquare())/fEntriesLinearFitter[k]);
	//(*parE)[0] = pare[0]*ppointError;
	//(*parE)[1] = pare[1]*ppointError;

	(*parE)[0] = 0.0;
	(*parE)[1] = 0.0;
	(*parE)[2] = (Double_t) fEntriesLinearFitter[k];
	((TObjArray *)fLinearVdriftFit->GetPArray())->AddAt(par,k);
	((TObjArray *)fLinearVdriftFit->GetEArray())->AddAt(parE,k);
      }
    }
  }
}



 AliTRDCalibraFillHisto.cxx:1
 AliTRDCalibraFillHisto.cxx:2
 AliTRDCalibraFillHisto.cxx:3
 AliTRDCalibraFillHisto.cxx:4
 AliTRDCalibraFillHisto.cxx:5
 AliTRDCalibraFillHisto.cxx:6
 AliTRDCalibraFillHisto.cxx:7
 AliTRDCalibraFillHisto.cxx:8
 AliTRDCalibraFillHisto.cxx:9
 AliTRDCalibraFillHisto.cxx:10
 AliTRDCalibraFillHisto.cxx:11
 AliTRDCalibraFillHisto.cxx:12
 AliTRDCalibraFillHisto.cxx:13
 AliTRDCalibraFillHisto.cxx:14
 AliTRDCalibraFillHisto.cxx:15
 AliTRDCalibraFillHisto.cxx:16
 AliTRDCalibraFillHisto.cxx:17
 AliTRDCalibraFillHisto.cxx:18
 AliTRDCalibraFillHisto.cxx:19
 AliTRDCalibraFillHisto.cxx:20
 AliTRDCalibraFillHisto.cxx:21
 AliTRDCalibraFillHisto.cxx:22
 AliTRDCalibraFillHisto.cxx:23
 AliTRDCalibraFillHisto.cxx:24
 AliTRDCalibraFillHisto.cxx:25
 AliTRDCalibraFillHisto.cxx:26
 AliTRDCalibraFillHisto.cxx:27
 AliTRDCalibraFillHisto.cxx:28
 AliTRDCalibraFillHisto.cxx:29
 AliTRDCalibraFillHisto.cxx:30
 AliTRDCalibraFillHisto.cxx:31
 AliTRDCalibraFillHisto.cxx:32
 AliTRDCalibraFillHisto.cxx:33
 AliTRDCalibraFillHisto.cxx:34
 AliTRDCalibraFillHisto.cxx:35
 AliTRDCalibraFillHisto.cxx:36
 AliTRDCalibraFillHisto.cxx:37
 AliTRDCalibraFillHisto.cxx:38
 AliTRDCalibraFillHisto.cxx:39
 AliTRDCalibraFillHisto.cxx:40
 AliTRDCalibraFillHisto.cxx:41
 AliTRDCalibraFillHisto.cxx:42
 AliTRDCalibraFillHisto.cxx:43
 AliTRDCalibraFillHisto.cxx:44
 AliTRDCalibraFillHisto.cxx:45
 AliTRDCalibraFillHisto.cxx:46
 AliTRDCalibraFillHisto.cxx:47
 AliTRDCalibraFillHisto.cxx:48
 AliTRDCalibraFillHisto.cxx:49
 AliTRDCalibraFillHisto.cxx:50
 AliTRDCalibraFillHisto.cxx:51
 AliTRDCalibraFillHisto.cxx:52
 AliTRDCalibraFillHisto.cxx:53
 AliTRDCalibraFillHisto.cxx:54
 AliTRDCalibraFillHisto.cxx:55
 AliTRDCalibraFillHisto.cxx:56
 AliTRDCalibraFillHisto.cxx:57
 AliTRDCalibraFillHisto.cxx:58
 AliTRDCalibraFillHisto.cxx:59
 AliTRDCalibraFillHisto.cxx:60
 AliTRDCalibraFillHisto.cxx:61
 AliTRDCalibraFillHisto.cxx:62
 AliTRDCalibraFillHisto.cxx:63
 AliTRDCalibraFillHisto.cxx:64
 AliTRDCalibraFillHisto.cxx:65
 AliTRDCalibraFillHisto.cxx:66
 AliTRDCalibraFillHisto.cxx:67
 AliTRDCalibraFillHisto.cxx:68
 AliTRDCalibraFillHisto.cxx:69
 AliTRDCalibraFillHisto.cxx:70
 AliTRDCalibraFillHisto.cxx:71
 AliTRDCalibraFillHisto.cxx:72
 AliTRDCalibraFillHisto.cxx:73
 AliTRDCalibraFillHisto.cxx:74
 AliTRDCalibraFillHisto.cxx:75
 AliTRDCalibraFillHisto.cxx:76
 AliTRDCalibraFillHisto.cxx:77
 AliTRDCalibraFillHisto.cxx:78
 AliTRDCalibraFillHisto.cxx:79
 AliTRDCalibraFillHisto.cxx:80
 AliTRDCalibraFillHisto.cxx:81
 AliTRDCalibraFillHisto.cxx:82
 AliTRDCalibraFillHisto.cxx:83
 AliTRDCalibraFillHisto.cxx:84
 AliTRDCalibraFillHisto.cxx:85
 AliTRDCalibraFillHisto.cxx:86
 AliTRDCalibraFillHisto.cxx:87
 AliTRDCalibraFillHisto.cxx:88
 AliTRDCalibraFillHisto.cxx:89
 AliTRDCalibraFillHisto.cxx:90
 AliTRDCalibraFillHisto.cxx:91
 AliTRDCalibraFillHisto.cxx:92
 AliTRDCalibraFillHisto.cxx:93
 AliTRDCalibraFillHisto.cxx:94
 AliTRDCalibraFillHisto.cxx:95
 AliTRDCalibraFillHisto.cxx:96
 AliTRDCalibraFillHisto.cxx:97
 AliTRDCalibraFillHisto.cxx:98
 AliTRDCalibraFillHisto.cxx:99
 AliTRDCalibraFillHisto.cxx:100
 AliTRDCalibraFillHisto.cxx:101
 AliTRDCalibraFillHisto.cxx:102
 AliTRDCalibraFillHisto.cxx:103
 AliTRDCalibraFillHisto.cxx:104
 AliTRDCalibraFillHisto.cxx:105
 AliTRDCalibraFillHisto.cxx:106
 AliTRDCalibraFillHisto.cxx:107
 AliTRDCalibraFillHisto.cxx:108
 AliTRDCalibraFillHisto.cxx:109
 AliTRDCalibraFillHisto.cxx:110
 AliTRDCalibraFillHisto.cxx:111
 AliTRDCalibraFillHisto.cxx:112
 AliTRDCalibraFillHisto.cxx:113
 AliTRDCalibraFillHisto.cxx:114
 AliTRDCalibraFillHisto.cxx:115
 AliTRDCalibraFillHisto.cxx:116
 AliTRDCalibraFillHisto.cxx:117
 AliTRDCalibraFillHisto.cxx:118
 AliTRDCalibraFillHisto.cxx:119
 AliTRDCalibraFillHisto.cxx:120
 AliTRDCalibraFillHisto.cxx:121
 AliTRDCalibraFillHisto.cxx:122
 AliTRDCalibraFillHisto.cxx:123
 AliTRDCalibraFillHisto.cxx:124
 AliTRDCalibraFillHisto.cxx:125
 AliTRDCalibraFillHisto.cxx:126
 AliTRDCalibraFillHisto.cxx:127
 AliTRDCalibraFillHisto.cxx:128
 AliTRDCalibraFillHisto.cxx:129
 AliTRDCalibraFillHisto.cxx:130
 AliTRDCalibraFillHisto.cxx:131
 AliTRDCalibraFillHisto.cxx:132
 AliTRDCalibraFillHisto.cxx:133
 AliTRDCalibraFillHisto.cxx:134
 AliTRDCalibraFillHisto.cxx:135
 AliTRDCalibraFillHisto.cxx:136
 AliTRDCalibraFillHisto.cxx:137
 AliTRDCalibraFillHisto.cxx:138
 AliTRDCalibraFillHisto.cxx:139
 AliTRDCalibraFillHisto.cxx:140
 AliTRDCalibraFillHisto.cxx:141
 AliTRDCalibraFillHisto.cxx:142
 AliTRDCalibraFillHisto.cxx:143
 AliTRDCalibraFillHisto.cxx:144
 AliTRDCalibraFillHisto.cxx:145
 AliTRDCalibraFillHisto.cxx:146
 AliTRDCalibraFillHisto.cxx:147
 AliTRDCalibraFillHisto.cxx:148
 AliTRDCalibraFillHisto.cxx:149
 AliTRDCalibraFillHisto.cxx:150
 AliTRDCalibraFillHisto.cxx:151
 AliTRDCalibraFillHisto.cxx:152
 AliTRDCalibraFillHisto.cxx:153
 AliTRDCalibraFillHisto.cxx:154
 AliTRDCalibraFillHisto.cxx:155
 AliTRDCalibraFillHisto.cxx:156
 AliTRDCalibraFillHisto.cxx:157
 AliTRDCalibraFillHisto.cxx:158
 AliTRDCalibraFillHisto.cxx:159
 AliTRDCalibraFillHisto.cxx:160
 AliTRDCalibraFillHisto.cxx:161
 AliTRDCalibraFillHisto.cxx:162
 AliTRDCalibraFillHisto.cxx:163
 AliTRDCalibraFillHisto.cxx:164
 AliTRDCalibraFillHisto.cxx:165
 AliTRDCalibraFillHisto.cxx:166
 AliTRDCalibraFillHisto.cxx:167
 AliTRDCalibraFillHisto.cxx:168
 AliTRDCalibraFillHisto.cxx:169
 AliTRDCalibraFillHisto.cxx:170
 AliTRDCalibraFillHisto.cxx:171
 AliTRDCalibraFillHisto.cxx:172
 AliTRDCalibraFillHisto.cxx:173
 AliTRDCalibraFillHisto.cxx:174
 AliTRDCalibraFillHisto.cxx:175
 AliTRDCalibraFillHisto.cxx:176
 AliTRDCalibraFillHisto.cxx:177
 AliTRDCalibraFillHisto.cxx:178
 AliTRDCalibraFillHisto.cxx:179
 AliTRDCalibraFillHisto.cxx:180
 AliTRDCalibraFillHisto.cxx:181
 AliTRDCalibraFillHisto.cxx:182
 AliTRDCalibraFillHisto.cxx:183
 AliTRDCalibraFillHisto.cxx:184
 AliTRDCalibraFillHisto.cxx:185
 AliTRDCalibraFillHisto.cxx:186
 AliTRDCalibraFillHisto.cxx:187
 AliTRDCalibraFillHisto.cxx:188
 AliTRDCalibraFillHisto.cxx:189
 AliTRDCalibraFillHisto.cxx:190
 AliTRDCalibraFillHisto.cxx:191
 AliTRDCalibraFillHisto.cxx:192
 AliTRDCalibraFillHisto.cxx:193
 AliTRDCalibraFillHisto.cxx:194
 AliTRDCalibraFillHisto.cxx:195
 AliTRDCalibraFillHisto.cxx:196
 AliTRDCalibraFillHisto.cxx:197
 AliTRDCalibraFillHisto.cxx:198
 AliTRDCalibraFillHisto.cxx:199
 AliTRDCalibraFillHisto.cxx:200
 AliTRDCalibraFillHisto.cxx:201
 AliTRDCalibraFillHisto.cxx:202
 AliTRDCalibraFillHisto.cxx:203
 AliTRDCalibraFillHisto.cxx:204
 AliTRDCalibraFillHisto.cxx:205
 AliTRDCalibraFillHisto.cxx:206
 AliTRDCalibraFillHisto.cxx:207
 AliTRDCalibraFillHisto.cxx:208
 AliTRDCalibraFillHisto.cxx:209
 AliTRDCalibraFillHisto.cxx:210
 AliTRDCalibraFillHisto.cxx:211
 AliTRDCalibraFillHisto.cxx:212
 AliTRDCalibraFillHisto.cxx:213
 AliTRDCalibraFillHisto.cxx:214
 AliTRDCalibraFillHisto.cxx:215
 AliTRDCalibraFillHisto.cxx:216
 AliTRDCalibraFillHisto.cxx:217
 AliTRDCalibraFillHisto.cxx:218
 AliTRDCalibraFillHisto.cxx:219
 AliTRDCalibraFillHisto.cxx:220
 AliTRDCalibraFillHisto.cxx:221
 AliTRDCalibraFillHisto.cxx:222
 AliTRDCalibraFillHisto.cxx:223
 AliTRDCalibraFillHisto.cxx:224
 AliTRDCalibraFillHisto.cxx:225
 AliTRDCalibraFillHisto.cxx:226
 AliTRDCalibraFillHisto.cxx:227
 AliTRDCalibraFillHisto.cxx:228
 AliTRDCalibraFillHisto.cxx:229
 AliTRDCalibraFillHisto.cxx:230
 AliTRDCalibraFillHisto.cxx:231
 AliTRDCalibraFillHisto.cxx:232
 AliTRDCalibraFillHisto.cxx:233
 AliTRDCalibraFillHisto.cxx:234
 AliTRDCalibraFillHisto.cxx:235
 AliTRDCalibraFillHisto.cxx:236
 AliTRDCalibraFillHisto.cxx:237
 AliTRDCalibraFillHisto.cxx:238
 AliTRDCalibraFillHisto.cxx:239
 AliTRDCalibraFillHisto.cxx:240
 AliTRDCalibraFillHisto.cxx:241
 AliTRDCalibraFillHisto.cxx:242
 AliTRDCalibraFillHisto.cxx:243
 AliTRDCalibraFillHisto.cxx:244
 AliTRDCalibraFillHisto.cxx:245
 AliTRDCalibraFillHisto.cxx:246
 AliTRDCalibraFillHisto.cxx:247
 AliTRDCalibraFillHisto.cxx:248
 AliTRDCalibraFillHisto.cxx:249
 AliTRDCalibraFillHisto.cxx:250
 AliTRDCalibraFillHisto.cxx:251
 AliTRDCalibraFillHisto.cxx:252
 AliTRDCalibraFillHisto.cxx:253
 AliTRDCalibraFillHisto.cxx:254
 AliTRDCalibraFillHisto.cxx:255
 AliTRDCalibraFillHisto.cxx:256
 AliTRDCalibraFillHisto.cxx:257
 AliTRDCalibraFillHisto.cxx:258
 AliTRDCalibraFillHisto.cxx:259
 AliTRDCalibraFillHisto.cxx:260
 AliTRDCalibraFillHisto.cxx:261
 AliTRDCalibraFillHisto.cxx:262
 AliTRDCalibraFillHisto.cxx:263
 AliTRDCalibraFillHisto.cxx:264
 AliTRDCalibraFillHisto.cxx:265
 AliTRDCalibraFillHisto.cxx:266
 AliTRDCalibraFillHisto.cxx:267
 AliTRDCalibraFillHisto.cxx:268
 AliTRDCalibraFillHisto.cxx:269
 AliTRDCalibraFillHisto.cxx:270
 AliTRDCalibraFillHisto.cxx:271
 AliTRDCalibraFillHisto.cxx:272
 AliTRDCalibraFillHisto.cxx:273
 AliTRDCalibraFillHisto.cxx:274
 AliTRDCalibraFillHisto.cxx:275
 AliTRDCalibraFillHisto.cxx:276
 AliTRDCalibraFillHisto.cxx:277
 AliTRDCalibraFillHisto.cxx:278
 AliTRDCalibraFillHisto.cxx:279
 AliTRDCalibraFillHisto.cxx:280
 AliTRDCalibraFillHisto.cxx:281
 AliTRDCalibraFillHisto.cxx:282
 AliTRDCalibraFillHisto.cxx:283
 AliTRDCalibraFillHisto.cxx:284
 AliTRDCalibraFillHisto.cxx:285
 AliTRDCalibraFillHisto.cxx:286
 AliTRDCalibraFillHisto.cxx:287
 AliTRDCalibraFillHisto.cxx:288
 AliTRDCalibraFillHisto.cxx:289
 AliTRDCalibraFillHisto.cxx:290
 AliTRDCalibraFillHisto.cxx:291
 AliTRDCalibraFillHisto.cxx:292
 AliTRDCalibraFillHisto.cxx:293
 AliTRDCalibraFillHisto.cxx:294
 AliTRDCalibraFillHisto.cxx:295
 AliTRDCalibraFillHisto.cxx:296
 AliTRDCalibraFillHisto.cxx:297
 AliTRDCalibraFillHisto.cxx:298
 AliTRDCalibraFillHisto.cxx:299
 AliTRDCalibraFillHisto.cxx:300
 AliTRDCalibraFillHisto.cxx:301
 AliTRDCalibraFillHisto.cxx:302
 AliTRDCalibraFillHisto.cxx:303
 AliTRDCalibraFillHisto.cxx:304
 AliTRDCalibraFillHisto.cxx:305
 AliTRDCalibraFillHisto.cxx:306
 AliTRDCalibraFillHisto.cxx:307
 AliTRDCalibraFillHisto.cxx:308
 AliTRDCalibraFillHisto.cxx:309
 AliTRDCalibraFillHisto.cxx:310
 AliTRDCalibraFillHisto.cxx:311
 AliTRDCalibraFillHisto.cxx:312
 AliTRDCalibraFillHisto.cxx:313
 AliTRDCalibraFillHisto.cxx:314
 AliTRDCalibraFillHisto.cxx:315
 AliTRDCalibraFillHisto.cxx:316
 AliTRDCalibraFillHisto.cxx:317
 AliTRDCalibraFillHisto.cxx:318
 AliTRDCalibraFillHisto.cxx:319
 AliTRDCalibraFillHisto.cxx:320
 AliTRDCalibraFillHisto.cxx:321
 AliTRDCalibraFillHisto.cxx:322
 AliTRDCalibraFillHisto.cxx:323
 AliTRDCalibraFillHisto.cxx:324
 AliTRDCalibraFillHisto.cxx:325
 AliTRDCalibraFillHisto.cxx:326
 AliTRDCalibraFillHisto.cxx:327
 AliTRDCalibraFillHisto.cxx:328
 AliTRDCalibraFillHisto.cxx:329
 AliTRDCalibraFillHisto.cxx:330
 AliTRDCalibraFillHisto.cxx:331
 AliTRDCalibraFillHisto.cxx:332
 AliTRDCalibraFillHisto.cxx:333
 AliTRDCalibraFillHisto.cxx:334
 AliTRDCalibraFillHisto.cxx:335
 AliTRDCalibraFillHisto.cxx:336
 AliTRDCalibraFillHisto.cxx:337
 AliTRDCalibraFillHisto.cxx:338
 AliTRDCalibraFillHisto.cxx:339
 AliTRDCalibraFillHisto.cxx:340
 AliTRDCalibraFillHisto.cxx:341
 AliTRDCalibraFillHisto.cxx:342
 AliTRDCalibraFillHisto.cxx:343
 AliTRDCalibraFillHisto.cxx:344
 AliTRDCalibraFillHisto.cxx:345
 AliTRDCalibraFillHisto.cxx:346
 AliTRDCalibraFillHisto.cxx:347
 AliTRDCalibraFillHisto.cxx:348
 AliTRDCalibraFillHisto.cxx:349
 AliTRDCalibraFillHisto.cxx:350
 AliTRDCalibraFillHisto.cxx:351
 AliTRDCalibraFillHisto.cxx:352
 AliTRDCalibraFillHisto.cxx:353
 AliTRDCalibraFillHisto.cxx:354
 AliTRDCalibraFillHisto.cxx:355
 AliTRDCalibraFillHisto.cxx:356
 AliTRDCalibraFillHisto.cxx:357
 AliTRDCalibraFillHisto.cxx:358
 AliTRDCalibraFillHisto.cxx:359
 AliTRDCalibraFillHisto.cxx:360
 AliTRDCalibraFillHisto.cxx:361
 AliTRDCalibraFillHisto.cxx:362
 AliTRDCalibraFillHisto.cxx:363
 AliTRDCalibraFillHisto.cxx:364
 AliTRDCalibraFillHisto.cxx:365
 AliTRDCalibraFillHisto.cxx:366
 AliTRDCalibraFillHisto.cxx:367
 AliTRDCalibraFillHisto.cxx:368
 AliTRDCalibraFillHisto.cxx:369
 AliTRDCalibraFillHisto.cxx:370
 AliTRDCalibraFillHisto.cxx:371
 AliTRDCalibraFillHisto.cxx:372
 AliTRDCalibraFillHisto.cxx:373
 AliTRDCalibraFillHisto.cxx:374
 AliTRDCalibraFillHisto.cxx:375
 AliTRDCalibraFillHisto.cxx:376
 AliTRDCalibraFillHisto.cxx:377
 AliTRDCalibraFillHisto.cxx:378
 AliTRDCalibraFillHisto.cxx:379
 AliTRDCalibraFillHisto.cxx:380
 AliTRDCalibraFillHisto.cxx:381
 AliTRDCalibraFillHisto.cxx:382
 AliTRDCalibraFillHisto.cxx:383
 AliTRDCalibraFillHisto.cxx:384
 AliTRDCalibraFillHisto.cxx:385
 AliTRDCalibraFillHisto.cxx:386
 AliTRDCalibraFillHisto.cxx:387
 AliTRDCalibraFillHisto.cxx:388
 AliTRDCalibraFillHisto.cxx:389
 AliTRDCalibraFillHisto.cxx:390
 AliTRDCalibraFillHisto.cxx:391
 AliTRDCalibraFillHisto.cxx:392
 AliTRDCalibraFillHisto.cxx:393
 AliTRDCalibraFillHisto.cxx:394
 AliTRDCalibraFillHisto.cxx:395
 AliTRDCalibraFillHisto.cxx:396
 AliTRDCalibraFillHisto.cxx:397
 AliTRDCalibraFillHisto.cxx:398
 AliTRDCalibraFillHisto.cxx:399
 AliTRDCalibraFillHisto.cxx:400
 AliTRDCalibraFillHisto.cxx:401
 AliTRDCalibraFillHisto.cxx:402
 AliTRDCalibraFillHisto.cxx:403
 AliTRDCalibraFillHisto.cxx:404
 AliTRDCalibraFillHisto.cxx:405
 AliTRDCalibraFillHisto.cxx:406
 AliTRDCalibraFillHisto.cxx:407
 AliTRDCalibraFillHisto.cxx:408
 AliTRDCalibraFillHisto.cxx:409
 AliTRDCalibraFillHisto.cxx:410
 AliTRDCalibraFillHisto.cxx:411
 AliTRDCalibraFillHisto.cxx:412
 AliTRDCalibraFillHisto.cxx:413
 AliTRDCalibraFillHisto.cxx:414
 AliTRDCalibraFillHisto.cxx:415
 AliTRDCalibraFillHisto.cxx:416
 AliTRDCalibraFillHisto.cxx:417
 AliTRDCalibraFillHisto.cxx:418
 AliTRDCalibraFillHisto.cxx:419
 AliTRDCalibraFillHisto.cxx:420
 AliTRDCalibraFillHisto.cxx:421
 AliTRDCalibraFillHisto.cxx:422
 AliTRDCalibraFillHisto.cxx:423
 AliTRDCalibraFillHisto.cxx:424
 AliTRDCalibraFillHisto.cxx:425
 AliTRDCalibraFillHisto.cxx:426
 AliTRDCalibraFillHisto.cxx:427
 AliTRDCalibraFillHisto.cxx:428
 AliTRDCalibraFillHisto.cxx:429
 AliTRDCalibraFillHisto.cxx:430
 AliTRDCalibraFillHisto.cxx:431
 AliTRDCalibraFillHisto.cxx:432
 AliTRDCalibraFillHisto.cxx:433
 AliTRDCalibraFillHisto.cxx:434
 AliTRDCalibraFillHisto.cxx:435
 AliTRDCalibraFillHisto.cxx:436
 AliTRDCalibraFillHisto.cxx:437
 AliTRDCalibraFillHisto.cxx:438
 AliTRDCalibraFillHisto.cxx:439
 AliTRDCalibraFillHisto.cxx:440
 AliTRDCalibraFillHisto.cxx:441
 AliTRDCalibraFillHisto.cxx:442
 AliTRDCalibraFillHisto.cxx:443
 AliTRDCalibraFillHisto.cxx:444
 AliTRDCalibraFillHisto.cxx:445
 AliTRDCalibraFillHisto.cxx:446
 AliTRDCalibraFillHisto.cxx:447
 AliTRDCalibraFillHisto.cxx:448
 AliTRDCalibraFillHisto.cxx:449
 AliTRDCalibraFillHisto.cxx:450
 AliTRDCalibraFillHisto.cxx:451
 AliTRDCalibraFillHisto.cxx:452
 AliTRDCalibraFillHisto.cxx:453
 AliTRDCalibraFillHisto.cxx:454
 AliTRDCalibraFillHisto.cxx:455
 AliTRDCalibraFillHisto.cxx:456
 AliTRDCalibraFillHisto.cxx:457
 AliTRDCalibraFillHisto.cxx:458
 AliTRDCalibraFillHisto.cxx:459
 AliTRDCalibraFillHisto.cxx:460
 AliTRDCalibraFillHisto.cxx:461
 AliTRDCalibraFillHisto.cxx:462
 AliTRDCalibraFillHisto.cxx:463
 AliTRDCalibraFillHisto.cxx:464
 AliTRDCalibraFillHisto.cxx:465
 AliTRDCalibraFillHisto.cxx:466
 AliTRDCalibraFillHisto.cxx:467
 AliTRDCalibraFillHisto.cxx:468
 AliTRDCalibraFillHisto.cxx:469
 AliTRDCalibraFillHisto.cxx:470
 AliTRDCalibraFillHisto.cxx:471
 AliTRDCalibraFillHisto.cxx:472
 AliTRDCalibraFillHisto.cxx:473
 AliTRDCalibraFillHisto.cxx:474
 AliTRDCalibraFillHisto.cxx:475
 AliTRDCalibraFillHisto.cxx:476
 AliTRDCalibraFillHisto.cxx:477
 AliTRDCalibraFillHisto.cxx:478
 AliTRDCalibraFillHisto.cxx:479
 AliTRDCalibraFillHisto.cxx:480
 AliTRDCalibraFillHisto.cxx:481
 AliTRDCalibraFillHisto.cxx:482
 AliTRDCalibraFillHisto.cxx:483
 AliTRDCalibraFillHisto.cxx:484
 AliTRDCalibraFillHisto.cxx:485
 AliTRDCalibraFillHisto.cxx:486
 AliTRDCalibraFillHisto.cxx:487
 AliTRDCalibraFillHisto.cxx:488
 AliTRDCalibraFillHisto.cxx:489
 AliTRDCalibraFillHisto.cxx:490
 AliTRDCalibraFillHisto.cxx:491
 AliTRDCalibraFillHisto.cxx:492
 AliTRDCalibraFillHisto.cxx:493
 AliTRDCalibraFillHisto.cxx:494
 AliTRDCalibraFillHisto.cxx:495
 AliTRDCalibraFillHisto.cxx:496
 AliTRDCalibraFillHisto.cxx:497
 AliTRDCalibraFillHisto.cxx:498
 AliTRDCalibraFillHisto.cxx:499
 AliTRDCalibraFillHisto.cxx:500
 AliTRDCalibraFillHisto.cxx:501
 AliTRDCalibraFillHisto.cxx:502
 AliTRDCalibraFillHisto.cxx:503
 AliTRDCalibraFillHisto.cxx:504
 AliTRDCalibraFillHisto.cxx:505
 AliTRDCalibraFillHisto.cxx:506
 AliTRDCalibraFillHisto.cxx:507
 AliTRDCalibraFillHisto.cxx:508
 AliTRDCalibraFillHisto.cxx:509
 AliTRDCalibraFillHisto.cxx:510
 AliTRDCalibraFillHisto.cxx:511
 AliTRDCalibraFillHisto.cxx:512
 AliTRDCalibraFillHisto.cxx:513
 AliTRDCalibraFillHisto.cxx:514
 AliTRDCalibraFillHisto.cxx:515
 AliTRDCalibraFillHisto.cxx:516
 AliTRDCalibraFillHisto.cxx:517
 AliTRDCalibraFillHisto.cxx:518
 AliTRDCalibraFillHisto.cxx:519
 AliTRDCalibraFillHisto.cxx:520
 AliTRDCalibraFillHisto.cxx:521
 AliTRDCalibraFillHisto.cxx:522
 AliTRDCalibraFillHisto.cxx:523
 AliTRDCalibraFillHisto.cxx:524
 AliTRDCalibraFillHisto.cxx:525
 AliTRDCalibraFillHisto.cxx:526
 AliTRDCalibraFillHisto.cxx:527
 AliTRDCalibraFillHisto.cxx:528
 AliTRDCalibraFillHisto.cxx:529
 AliTRDCalibraFillHisto.cxx:530
 AliTRDCalibraFillHisto.cxx:531
 AliTRDCalibraFillHisto.cxx:532
 AliTRDCalibraFillHisto.cxx:533
 AliTRDCalibraFillHisto.cxx:534
 AliTRDCalibraFillHisto.cxx:535
 AliTRDCalibraFillHisto.cxx:536
 AliTRDCalibraFillHisto.cxx:537
 AliTRDCalibraFillHisto.cxx:538
 AliTRDCalibraFillHisto.cxx:539
 AliTRDCalibraFillHisto.cxx:540
 AliTRDCalibraFillHisto.cxx:541
 AliTRDCalibraFillHisto.cxx:542
 AliTRDCalibraFillHisto.cxx:543
 AliTRDCalibraFillHisto.cxx:544
 AliTRDCalibraFillHisto.cxx:545
 AliTRDCalibraFillHisto.cxx:546
 AliTRDCalibraFillHisto.cxx:547
 AliTRDCalibraFillHisto.cxx:548
 AliTRDCalibraFillHisto.cxx:549
 AliTRDCalibraFillHisto.cxx:550
 AliTRDCalibraFillHisto.cxx:551
 AliTRDCalibraFillHisto.cxx:552
 AliTRDCalibraFillHisto.cxx:553
 AliTRDCalibraFillHisto.cxx:554
 AliTRDCalibraFillHisto.cxx:555
 AliTRDCalibraFillHisto.cxx:556
 AliTRDCalibraFillHisto.cxx:557
 AliTRDCalibraFillHisto.cxx:558
 AliTRDCalibraFillHisto.cxx:559
 AliTRDCalibraFillHisto.cxx:560
 AliTRDCalibraFillHisto.cxx:561
 AliTRDCalibraFillHisto.cxx:562
 AliTRDCalibraFillHisto.cxx:563
 AliTRDCalibraFillHisto.cxx:564
 AliTRDCalibraFillHisto.cxx:565
 AliTRDCalibraFillHisto.cxx:566
 AliTRDCalibraFillHisto.cxx:567
 AliTRDCalibraFillHisto.cxx:568
 AliTRDCalibraFillHisto.cxx:569
 AliTRDCalibraFillHisto.cxx:570
 AliTRDCalibraFillHisto.cxx:571
 AliTRDCalibraFillHisto.cxx:572
 AliTRDCalibraFillHisto.cxx:573
 AliTRDCalibraFillHisto.cxx:574
 AliTRDCalibraFillHisto.cxx:575
 AliTRDCalibraFillHisto.cxx:576
 AliTRDCalibraFillHisto.cxx:577
 AliTRDCalibraFillHisto.cxx:578
 AliTRDCalibraFillHisto.cxx:579
 AliTRDCalibraFillHisto.cxx:580
 AliTRDCalibraFillHisto.cxx:581
 AliTRDCalibraFillHisto.cxx:582
 AliTRDCalibraFillHisto.cxx:583
 AliTRDCalibraFillHisto.cxx:584
 AliTRDCalibraFillHisto.cxx:585
 AliTRDCalibraFillHisto.cxx:586
 AliTRDCalibraFillHisto.cxx:587
 AliTRDCalibraFillHisto.cxx:588
 AliTRDCalibraFillHisto.cxx:589
 AliTRDCalibraFillHisto.cxx:590
 AliTRDCalibraFillHisto.cxx:591
 AliTRDCalibraFillHisto.cxx:592
 AliTRDCalibraFillHisto.cxx:593
 AliTRDCalibraFillHisto.cxx:594
 AliTRDCalibraFillHisto.cxx:595
 AliTRDCalibraFillHisto.cxx:596
 AliTRDCalibraFillHisto.cxx:597
 AliTRDCalibraFillHisto.cxx:598
 AliTRDCalibraFillHisto.cxx:599
 AliTRDCalibraFillHisto.cxx:600
 AliTRDCalibraFillHisto.cxx:601
 AliTRDCalibraFillHisto.cxx:602
 AliTRDCalibraFillHisto.cxx:603
 AliTRDCalibraFillHisto.cxx:604
 AliTRDCalibraFillHisto.cxx:605
 AliTRDCalibraFillHisto.cxx:606
 AliTRDCalibraFillHisto.cxx:607
 AliTRDCalibraFillHisto.cxx:608
 AliTRDCalibraFillHisto.cxx:609
 AliTRDCalibraFillHisto.cxx:610
 AliTRDCalibraFillHisto.cxx:611
 AliTRDCalibraFillHisto.cxx:612
 AliTRDCalibraFillHisto.cxx:613
 AliTRDCalibraFillHisto.cxx:614
 AliTRDCalibraFillHisto.cxx:615
 AliTRDCalibraFillHisto.cxx:616
 AliTRDCalibraFillHisto.cxx:617
 AliTRDCalibraFillHisto.cxx:618
 AliTRDCalibraFillHisto.cxx:619
 AliTRDCalibraFillHisto.cxx:620
 AliTRDCalibraFillHisto.cxx:621
 AliTRDCalibraFillHisto.cxx:622
 AliTRDCalibraFillHisto.cxx:623
 AliTRDCalibraFillHisto.cxx:624
 AliTRDCalibraFillHisto.cxx:625
 AliTRDCalibraFillHisto.cxx:626
 AliTRDCalibraFillHisto.cxx:627
 AliTRDCalibraFillHisto.cxx:628
 AliTRDCalibraFillHisto.cxx:629
 AliTRDCalibraFillHisto.cxx:630
 AliTRDCalibraFillHisto.cxx:631
 AliTRDCalibraFillHisto.cxx:632
 AliTRDCalibraFillHisto.cxx:633
 AliTRDCalibraFillHisto.cxx:634
 AliTRDCalibraFillHisto.cxx:635
 AliTRDCalibraFillHisto.cxx:636
 AliTRDCalibraFillHisto.cxx:637
 AliTRDCalibraFillHisto.cxx:638
 AliTRDCalibraFillHisto.cxx:639
 AliTRDCalibraFillHisto.cxx:640
 AliTRDCalibraFillHisto.cxx:641
 AliTRDCalibraFillHisto.cxx:642
 AliTRDCalibraFillHisto.cxx:643
 AliTRDCalibraFillHisto.cxx:644
 AliTRDCalibraFillHisto.cxx:645
 AliTRDCalibraFillHisto.cxx:646
 AliTRDCalibraFillHisto.cxx:647
 AliTRDCalibraFillHisto.cxx:648
 AliTRDCalibraFillHisto.cxx:649
 AliTRDCalibraFillHisto.cxx:650
 AliTRDCalibraFillHisto.cxx:651
 AliTRDCalibraFillHisto.cxx:652
 AliTRDCalibraFillHisto.cxx:653
 AliTRDCalibraFillHisto.cxx:654
 AliTRDCalibraFillHisto.cxx:655
 AliTRDCalibraFillHisto.cxx:656
 AliTRDCalibraFillHisto.cxx:657
 AliTRDCalibraFillHisto.cxx:658
 AliTRDCalibraFillHisto.cxx:659
 AliTRDCalibraFillHisto.cxx:660
 AliTRDCalibraFillHisto.cxx:661
 AliTRDCalibraFillHisto.cxx:662
 AliTRDCalibraFillHisto.cxx:663
 AliTRDCalibraFillHisto.cxx:664
 AliTRDCalibraFillHisto.cxx:665
 AliTRDCalibraFillHisto.cxx:666
 AliTRDCalibraFillHisto.cxx:667
 AliTRDCalibraFillHisto.cxx:668
 AliTRDCalibraFillHisto.cxx:669
 AliTRDCalibraFillHisto.cxx:670
 AliTRDCalibraFillHisto.cxx:671
 AliTRDCalibraFillHisto.cxx:672
 AliTRDCalibraFillHisto.cxx:673
 AliTRDCalibraFillHisto.cxx:674
 AliTRDCalibraFillHisto.cxx:675
 AliTRDCalibraFillHisto.cxx:676
 AliTRDCalibraFillHisto.cxx:677
 AliTRDCalibraFillHisto.cxx:678
 AliTRDCalibraFillHisto.cxx:679
 AliTRDCalibraFillHisto.cxx:680
 AliTRDCalibraFillHisto.cxx:681
 AliTRDCalibraFillHisto.cxx:682
 AliTRDCalibraFillHisto.cxx:683
 AliTRDCalibraFillHisto.cxx:684
 AliTRDCalibraFillHisto.cxx:685
 AliTRDCalibraFillHisto.cxx:686
 AliTRDCalibraFillHisto.cxx:687
 AliTRDCalibraFillHisto.cxx:688
 AliTRDCalibraFillHisto.cxx:689
 AliTRDCalibraFillHisto.cxx:690
 AliTRDCalibraFillHisto.cxx:691
 AliTRDCalibraFillHisto.cxx:692
 AliTRDCalibraFillHisto.cxx:693
 AliTRDCalibraFillHisto.cxx:694
 AliTRDCalibraFillHisto.cxx:695
 AliTRDCalibraFillHisto.cxx:696
 AliTRDCalibraFillHisto.cxx:697
 AliTRDCalibraFillHisto.cxx:698
 AliTRDCalibraFillHisto.cxx:699
 AliTRDCalibraFillHisto.cxx:700
 AliTRDCalibraFillHisto.cxx:701
 AliTRDCalibraFillHisto.cxx:702
 AliTRDCalibraFillHisto.cxx:703
 AliTRDCalibraFillHisto.cxx:704
 AliTRDCalibraFillHisto.cxx:705
 AliTRDCalibraFillHisto.cxx:706
 AliTRDCalibraFillHisto.cxx:707
 AliTRDCalibraFillHisto.cxx:708
 AliTRDCalibraFillHisto.cxx:709
 AliTRDCalibraFillHisto.cxx:710
 AliTRDCalibraFillHisto.cxx:711
 AliTRDCalibraFillHisto.cxx:712
 AliTRDCalibraFillHisto.cxx:713
 AliTRDCalibraFillHisto.cxx:714
 AliTRDCalibraFillHisto.cxx:715
 AliTRDCalibraFillHisto.cxx:716
 AliTRDCalibraFillHisto.cxx:717
 AliTRDCalibraFillHisto.cxx:718
 AliTRDCalibraFillHisto.cxx:719
 AliTRDCalibraFillHisto.cxx:720
 AliTRDCalibraFillHisto.cxx:721
 AliTRDCalibraFillHisto.cxx:722
 AliTRDCalibraFillHisto.cxx:723
 AliTRDCalibraFillHisto.cxx:724
 AliTRDCalibraFillHisto.cxx:725
 AliTRDCalibraFillHisto.cxx:726
 AliTRDCalibraFillHisto.cxx:727
 AliTRDCalibraFillHisto.cxx:728
 AliTRDCalibraFillHisto.cxx:729
 AliTRDCalibraFillHisto.cxx:730
 AliTRDCalibraFillHisto.cxx:731
 AliTRDCalibraFillHisto.cxx:732
 AliTRDCalibraFillHisto.cxx:733
 AliTRDCalibraFillHisto.cxx:734
 AliTRDCalibraFillHisto.cxx:735
 AliTRDCalibraFillHisto.cxx:736
 AliTRDCalibraFillHisto.cxx:737
 AliTRDCalibraFillHisto.cxx:738
 AliTRDCalibraFillHisto.cxx:739
 AliTRDCalibraFillHisto.cxx:740
 AliTRDCalibraFillHisto.cxx:741
 AliTRDCalibraFillHisto.cxx:742
 AliTRDCalibraFillHisto.cxx:743
 AliTRDCalibraFillHisto.cxx:744
 AliTRDCalibraFillHisto.cxx:745
 AliTRDCalibraFillHisto.cxx:746
 AliTRDCalibraFillHisto.cxx:747
 AliTRDCalibraFillHisto.cxx:748
 AliTRDCalibraFillHisto.cxx:749
 AliTRDCalibraFillHisto.cxx:750
 AliTRDCalibraFillHisto.cxx:751
 AliTRDCalibraFillHisto.cxx:752
 AliTRDCalibraFillHisto.cxx:753
 AliTRDCalibraFillHisto.cxx:754
 AliTRDCalibraFillHisto.cxx:755
 AliTRDCalibraFillHisto.cxx:756
 AliTRDCalibraFillHisto.cxx:757
 AliTRDCalibraFillHisto.cxx:758
 AliTRDCalibraFillHisto.cxx:759
 AliTRDCalibraFillHisto.cxx:760
 AliTRDCalibraFillHisto.cxx:761
 AliTRDCalibraFillHisto.cxx:762
 AliTRDCalibraFillHisto.cxx:763
 AliTRDCalibraFillHisto.cxx:764
 AliTRDCalibraFillHisto.cxx:765
 AliTRDCalibraFillHisto.cxx:766
 AliTRDCalibraFillHisto.cxx:767
 AliTRDCalibraFillHisto.cxx:768
 AliTRDCalibraFillHisto.cxx:769
 AliTRDCalibraFillHisto.cxx:770
 AliTRDCalibraFillHisto.cxx:771
 AliTRDCalibraFillHisto.cxx:772
 AliTRDCalibraFillHisto.cxx:773
 AliTRDCalibraFillHisto.cxx:774
 AliTRDCalibraFillHisto.cxx:775
 AliTRDCalibraFillHisto.cxx:776
 AliTRDCalibraFillHisto.cxx:777
 AliTRDCalibraFillHisto.cxx:778
 AliTRDCalibraFillHisto.cxx:779
 AliTRDCalibraFillHisto.cxx:780
 AliTRDCalibraFillHisto.cxx:781
 AliTRDCalibraFillHisto.cxx:782
 AliTRDCalibraFillHisto.cxx:783
 AliTRDCalibraFillHisto.cxx:784
 AliTRDCalibraFillHisto.cxx:785
 AliTRDCalibraFillHisto.cxx:786
 AliTRDCalibraFillHisto.cxx:787
 AliTRDCalibraFillHisto.cxx:788
 AliTRDCalibraFillHisto.cxx:789
 AliTRDCalibraFillHisto.cxx:790
 AliTRDCalibraFillHisto.cxx:791
 AliTRDCalibraFillHisto.cxx:792
 AliTRDCalibraFillHisto.cxx:793
 AliTRDCalibraFillHisto.cxx:794
 AliTRDCalibraFillHisto.cxx:795
 AliTRDCalibraFillHisto.cxx:796
 AliTRDCalibraFillHisto.cxx:797
 AliTRDCalibraFillHisto.cxx:798
 AliTRDCalibraFillHisto.cxx:799
 AliTRDCalibraFillHisto.cxx:800
 AliTRDCalibraFillHisto.cxx:801
 AliTRDCalibraFillHisto.cxx:802
 AliTRDCalibraFillHisto.cxx:803
 AliTRDCalibraFillHisto.cxx:804
 AliTRDCalibraFillHisto.cxx:805
 AliTRDCalibraFillHisto.cxx:806
 AliTRDCalibraFillHisto.cxx:807
 AliTRDCalibraFillHisto.cxx:808
 AliTRDCalibraFillHisto.cxx:809
 AliTRDCalibraFillHisto.cxx:810
 AliTRDCalibraFillHisto.cxx:811
 AliTRDCalibraFillHisto.cxx:812
 AliTRDCalibraFillHisto.cxx:813
 AliTRDCalibraFillHisto.cxx:814
 AliTRDCalibraFillHisto.cxx:815
 AliTRDCalibraFillHisto.cxx:816
 AliTRDCalibraFillHisto.cxx:817
 AliTRDCalibraFillHisto.cxx:818
 AliTRDCalibraFillHisto.cxx:819
 AliTRDCalibraFillHisto.cxx:820
 AliTRDCalibraFillHisto.cxx:821
 AliTRDCalibraFillHisto.cxx:822
 AliTRDCalibraFillHisto.cxx:823
 AliTRDCalibraFillHisto.cxx:824
 AliTRDCalibraFillHisto.cxx:825
 AliTRDCalibraFillHisto.cxx:826
 AliTRDCalibraFillHisto.cxx:827
 AliTRDCalibraFillHisto.cxx:828
 AliTRDCalibraFillHisto.cxx:829
 AliTRDCalibraFillHisto.cxx:830
 AliTRDCalibraFillHisto.cxx:831
 AliTRDCalibraFillHisto.cxx:832
 AliTRDCalibraFillHisto.cxx:833
 AliTRDCalibraFillHisto.cxx:834
 AliTRDCalibraFillHisto.cxx:835
 AliTRDCalibraFillHisto.cxx:836
 AliTRDCalibraFillHisto.cxx:837
 AliTRDCalibraFillHisto.cxx:838
 AliTRDCalibraFillHisto.cxx:839
 AliTRDCalibraFillHisto.cxx:840
 AliTRDCalibraFillHisto.cxx:841
 AliTRDCalibraFillHisto.cxx:842
 AliTRDCalibraFillHisto.cxx:843
 AliTRDCalibraFillHisto.cxx:844
 AliTRDCalibraFillHisto.cxx:845
 AliTRDCalibraFillHisto.cxx:846
 AliTRDCalibraFillHisto.cxx:847
 AliTRDCalibraFillHisto.cxx:848
 AliTRDCalibraFillHisto.cxx:849
 AliTRDCalibraFillHisto.cxx:850
 AliTRDCalibraFillHisto.cxx:851
 AliTRDCalibraFillHisto.cxx:852
 AliTRDCalibraFillHisto.cxx:853
 AliTRDCalibraFillHisto.cxx:854
 AliTRDCalibraFillHisto.cxx:855
 AliTRDCalibraFillHisto.cxx:856
 AliTRDCalibraFillHisto.cxx:857
 AliTRDCalibraFillHisto.cxx:858
 AliTRDCalibraFillHisto.cxx:859
 AliTRDCalibraFillHisto.cxx:860
 AliTRDCalibraFillHisto.cxx:861
 AliTRDCalibraFillHisto.cxx:862
 AliTRDCalibraFillHisto.cxx:863
 AliTRDCalibraFillHisto.cxx:864
 AliTRDCalibraFillHisto.cxx:865
 AliTRDCalibraFillHisto.cxx:866
 AliTRDCalibraFillHisto.cxx:867
 AliTRDCalibraFillHisto.cxx:868
 AliTRDCalibraFillHisto.cxx:869
 AliTRDCalibraFillHisto.cxx:870
 AliTRDCalibraFillHisto.cxx:871
 AliTRDCalibraFillHisto.cxx:872
 AliTRDCalibraFillHisto.cxx:873
 AliTRDCalibraFillHisto.cxx:874
 AliTRDCalibraFillHisto.cxx:875
 AliTRDCalibraFillHisto.cxx:876
 AliTRDCalibraFillHisto.cxx:877
 AliTRDCalibraFillHisto.cxx:878
 AliTRDCalibraFillHisto.cxx:879
 AliTRDCalibraFillHisto.cxx:880
 AliTRDCalibraFillHisto.cxx:881
 AliTRDCalibraFillHisto.cxx:882
 AliTRDCalibraFillHisto.cxx:883
 AliTRDCalibraFillHisto.cxx:884
 AliTRDCalibraFillHisto.cxx:885
 AliTRDCalibraFillHisto.cxx:886
 AliTRDCalibraFillHisto.cxx:887
 AliTRDCalibraFillHisto.cxx:888
 AliTRDCalibraFillHisto.cxx:889
 AliTRDCalibraFillHisto.cxx:890
 AliTRDCalibraFillHisto.cxx:891
 AliTRDCalibraFillHisto.cxx:892
 AliTRDCalibraFillHisto.cxx:893
 AliTRDCalibraFillHisto.cxx:894
 AliTRDCalibraFillHisto.cxx:895
 AliTRDCalibraFillHisto.cxx:896
 AliTRDCalibraFillHisto.cxx:897
 AliTRDCalibraFillHisto.cxx:898
 AliTRDCalibraFillHisto.cxx:899
 AliTRDCalibraFillHisto.cxx:900
 AliTRDCalibraFillHisto.cxx:901
 AliTRDCalibraFillHisto.cxx:902
 AliTRDCalibraFillHisto.cxx:903
 AliTRDCalibraFillHisto.cxx:904
 AliTRDCalibraFillHisto.cxx:905
 AliTRDCalibraFillHisto.cxx:906
 AliTRDCalibraFillHisto.cxx:907
 AliTRDCalibraFillHisto.cxx:908
 AliTRDCalibraFillHisto.cxx:909
 AliTRDCalibraFillHisto.cxx:910
 AliTRDCalibraFillHisto.cxx:911
 AliTRDCalibraFillHisto.cxx:912
 AliTRDCalibraFillHisto.cxx:913
 AliTRDCalibraFillHisto.cxx:914
 AliTRDCalibraFillHisto.cxx:915
 AliTRDCalibraFillHisto.cxx:916
 AliTRDCalibraFillHisto.cxx:917
 AliTRDCalibraFillHisto.cxx:918
 AliTRDCalibraFillHisto.cxx:919
 AliTRDCalibraFillHisto.cxx:920
 AliTRDCalibraFillHisto.cxx:921
 AliTRDCalibraFillHisto.cxx:922
 AliTRDCalibraFillHisto.cxx:923
 AliTRDCalibraFillHisto.cxx:924
 AliTRDCalibraFillHisto.cxx:925
 AliTRDCalibraFillHisto.cxx:926
 AliTRDCalibraFillHisto.cxx:927
 AliTRDCalibraFillHisto.cxx:928
 AliTRDCalibraFillHisto.cxx:929
 AliTRDCalibraFillHisto.cxx:930
 AliTRDCalibraFillHisto.cxx:931
 AliTRDCalibraFillHisto.cxx:932
 AliTRDCalibraFillHisto.cxx:933
 AliTRDCalibraFillHisto.cxx:934
 AliTRDCalibraFillHisto.cxx:935
 AliTRDCalibraFillHisto.cxx:936
 AliTRDCalibraFillHisto.cxx:937
 AliTRDCalibraFillHisto.cxx:938
 AliTRDCalibraFillHisto.cxx:939
 AliTRDCalibraFillHisto.cxx:940
 AliTRDCalibraFillHisto.cxx:941
 AliTRDCalibraFillHisto.cxx:942
 AliTRDCalibraFillHisto.cxx:943
 AliTRDCalibraFillHisto.cxx:944
 AliTRDCalibraFillHisto.cxx:945
 AliTRDCalibraFillHisto.cxx:946
 AliTRDCalibraFillHisto.cxx:947
 AliTRDCalibraFillHisto.cxx:948
 AliTRDCalibraFillHisto.cxx:949
 AliTRDCalibraFillHisto.cxx:950
 AliTRDCalibraFillHisto.cxx:951
 AliTRDCalibraFillHisto.cxx:952
 AliTRDCalibraFillHisto.cxx:953
 AliTRDCalibraFillHisto.cxx:954
 AliTRDCalibraFillHisto.cxx:955
 AliTRDCalibraFillHisto.cxx:956
 AliTRDCalibraFillHisto.cxx:957
 AliTRDCalibraFillHisto.cxx:958
 AliTRDCalibraFillHisto.cxx:959
 AliTRDCalibraFillHisto.cxx:960
 AliTRDCalibraFillHisto.cxx:961
 AliTRDCalibraFillHisto.cxx:962
 AliTRDCalibraFillHisto.cxx:963
 AliTRDCalibraFillHisto.cxx:964
 AliTRDCalibraFillHisto.cxx:965
 AliTRDCalibraFillHisto.cxx:966
 AliTRDCalibraFillHisto.cxx:967
 AliTRDCalibraFillHisto.cxx:968
 AliTRDCalibraFillHisto.cxx:969
 AliTRDCalibraFillHisto.cxx:970
 AliTRDCalibraFillHisto.cxx:971
 AliTRDCalibraFillHisto.cxx:972
 AliTRDCalibraFillHisto.cxx:973
 AliTRDCalibraFillHisto.cxx:974
 AliTRDCalibraFillHisto.cxx:975
 AliTRDCalibraFillHisto.cxx:976
 AliTRDCalibraFillHisto.cxx:977
 AliTRDCalibraFillHisto.cxx:978
 AliTRDCalibraFillHisto.cxx:979
 AliTRDCalibraFillHisto.cxx:980
 AliTRDCalibraFillHisto.cxx:981
 AliTRDCalibraFillHisto.cxx:982
 AliTRDCalibraFillHisto.cxx:983
 AliTRDCalibraFillHisto.cxx:984
 AliTRDCalibraFillHisto.cxx:985
 AliTRDCalibraFillHisto.cxx:986
 AliTRDCalibraFillHisto.cxx:987
 AliTRDCalibraFillHisto.cxx:988
 AliTRDCalibraFillHisto.cxx:989
 AliTRDCalibraFillHisto.cxx:990
 AliTRDCalibraFillHisto.cxx:991
 AliTRDCalibraFillHisto.cxx:992
 AliTRDCalibraFillHisto.cxx:993
 AliTRDCalibraFillHisto.cxx:994
 AliTRDCalibraFillHisto.cxx:995
 AliTRDCalibraFillHisto.cxx:996
 AliTRDCalibraFillHisto.cxx:997
 AliTRDCalibraFillHisto.cxx:998
 AliTRDCalibraFillHisto.cxx:999
 AliTRDCalibraFillHisto.cxx:1000
 AliTRDCalibraFillHisto.cxx:1001
 AliTRDCalibraFillHisto.cxx:1002
 AliTRDCalibraFillHisto.cxx:1003
 AliTRDCalibraFillHisto.cxx:1004
 AliTRDCalibraFillHisto.cxx:1005
 AliTRDCalibraFillHisto.cxx:1006
 AliTRDCalibraFillHisto.cxx:1007
 AliTRDCalibraFillHisto.cxx:1008
 AliTRDCalibraFillHisto.cxx:1009
 AliTRDCalibraFillHisto.cxx:1010
 AliTRDCalibraFillHisto.cxx:1011
 AliTRDCalibraFillHisto.cxx:1012
 AliTRDCalibraFillHisto.cxx:1013
 AliTRDCalibraFillHisto.cxx:1014
 AliTRDCalibraFillHisto.cxx:1015
 AliTRDCalibraFillHisto.cxx:1016
 AliTRDCalibraFillHisto.cxx:1017
 AliTRDCalibraFillHisto.cxx:1018
 AliTRDCalibraFillHisto.cxx:1019
 AliTRDCalibraFillHisto.cxx:1020
 AliTRDCalibraFillHisto.cxx:1021
 AliTRDCalibraFillHisto.cxx:1022
 AliTRDCalibraFillHisto.cxx:1023
 AliTRDCalibraFillHisto.cxx:1024
 AliTRDCalibraFillHisto.cxx:1025
 AliTRDCalibraFillHisto.cxx:1026
 AliTRDCalibraFillHisto.cxx:1027
 AliTRDCalibraFillHisto.cxx:1028
 AliTRDCalibraFillHisto.cxx:1029
 AliTRDCalibraFillHisto.cxx:1030
 AliTRDCalibraFillHisto.cxx:1031
 AliTRDCalibraFillHisto.cxx:1032
 AliTRDCalibraFillHisto.cxx:1033
 AliTRDCalibraFillHisto.cxx:1034
 AliTRDCalibraFillHisto.cxx:1035
 AliTRDCalibraFillHisto.cxx:1036
 AliTRDCalibraFillHisto.cxx:1037
 AliTRDCalibraFillHisto.cxx:1038
 AliTRDCalibraFillHisto.cxx:1039
 AliTRDCalibraFillHisto.cxx:1040
 AliTRDCalibraFillHisto.cxx:1041
 AliTRDCalibraFillHisto.cxx:1042
 AliTRDCalibraFillHisto.cxx:1043
 AliTRDCalibraFillHisto.cxx:1044
 AliTRDCalibraFillHisto.cxx:1045
 AliTRDCalibraFillHisto.cxx:1046
 AliTRDCalibraFillHisto.cxx:1047
 AliTRDCalibraFillHisto.cxx:1048
 AliTRDCalibraFillHisto.cxx:1049
 AliTRDCalibraFillHisto.cxx:1050
 AliTRDCalibraFillHisto.cxx:1051
 AliTRDCalibraFillHisto.cxx:1052
 AliTRDCalibraFillHisto.cxx:1053
 AliTRDCalibraFillHisto.cxx:1054
 AliTRDCalibraFillHisto.cxx:1055
 AliTRDCalibraFillHisto.cxx:1056
 AliTRDCalibraFillHisto.cxx:1057
 AliTRDCalibraFillHisto.cxx:1058
 AliTRDCalibraFillHisto.cxx:1059
 AliTRDCalibraFillHisto.cxx:1060
 AliTRDCalibraFillHisto.cxx:1061
 AliTRDCalibraFillHisto.cxx:1062
 AliTRDCalibraFillHisto.cxx:1063
 AliTRDCalibraFillHisto.cxx:1064
 AliTRDCalibraFillHisto.cxx:1065
 AliTRDCalibraFillHisto.cxx:1066
 AliTRDCalibraFillHisto.cxx:1067
 AliTRDCalibraFillHisto.cxx:1068
 AliTRDCalibraFillHisto.cxx:1069
 AliTRDCalibraFillHisto.cxx:1070
 AliTRDCalibraFillHisto.cxx:1071
 AliTRDCalibraFillHisto.cxx:1072
 AliTRDCalibraFillHisto.cxx:1073
 AliTRDCalibraFillHisto.cxx:1074
 AliTRDCalibraFillHisto.cxx:1075
 AliTRDCalibraFillHisto.cxx:1076
 AliTRDCalibraFillHisto.cxx:1077
 AliTRDCalibraFillHisto.cxx:1078
 AliTRDCalibraFillHisto.cxx:1079
 AliTRDCalibraFillHisto.cxx:1080
 AliTRDCalibraFillHisto.cxx:1081
 AliTRDCalibraFillHisto.cxx:1082
 AliTRDCalibraFillHisto.cxx:1083
 AliTRDCalibraFillHisto.cxx:1084
 AliTRDCalibraFillHisto.cxx:1085
 AliTRDCalibraFillHisto.cxx:1086
 AliTRDCalibraFillHisto.cxx:1087
 AliTRDCalibraFillHisto.cxx:1088
 AliTRDCalibraFillHisto.cxx:1089
 AliTRDCalibraFillHisto.cxx:1090
 AliTRDCalibraFillHisto.cxx:1091
 AliTRDCalibraFillHisto.cxx:1092
 AliTRDCalibraFillHisto.cxx:1093
 AliTRDCalibraFillHisto.cxx:1094
 AliTRDCalibraFillHisto.cxx:1095
 AliTRDCalibraFillHisto.cxx:1096
 AliTRDCalibraFillHisto.cxx:1097
 AliTRDCalibraFillHisto.cxx:1098
 AliTRDCalibraFillHisto.cxx:1099
 AliTRDCalibraFillHisto.cxx:1100
 AliTRDCalibraFillHisto.cxx:1101
 AliTRDCalibraFillHisto.cxx:1102
 AliTRDCalibraFillHisto.cxx:1103
 AliTRDCalibraFillHisto.cxx:1104
 AliTRDCalibraFillHisto.cxx:1105
 AliTRDCalibraFillHisto.cxx:1106
 AliTRDCalibraFillHisto.cxx:1107
 AliTRDCalibraFillHisto.cxx:1108
 AliTRDCalibraFillHisto.cxx:1109
 AliTRDCalibraFillHisto.cxx:1110
 AliTRDCalibraFillHisto.cxx:1111
 AliTRDCalibraFillHisto.cxx:1112
 AliTRDCalibraFillHisto.cxx:1113
 AliTRDCalibraFillHisto.cxx:1114
 AliTRDCalibraFillHisto.cxx:1115
 AliTRDCalibraFillHisto.cxx:1116
 AliTRDCalibraFillHisto.cxx:1117
 AliTRDCalibraFillHisto.cxx:1118
 AliTRDCalibraFillHisto.cxx:1119
 AliTRDCalibraFillHisto.cxx:1120
 AliTRDCalibraFillHisto.cxx:1121
 AliTRDCalibraFillHisto.cxx:1122
 AliTRDCalibraFillHisto.cxx:1123
 AliTRDCalibraFillHisto.cxx:1124
 AliTRDCalibraFillHisto.cxx:1125
 AliTRDCalibraFillHisto.cxx:1126
 AliTRDCalibraFillHisto.cxx:1127
 AliTRDCalibraFillHisto.cxx:1128
 AliTRDCalibraFillHisto.cxx:1129
 AliTRDCalibraFillHisto.cxx:1130
 AliTRDCalibraFillHisto.cxx:1131
 AliTRDCalibraFillHisto.cxx:1132
 AliTRDCalibraFillHisto.cxx:1133
 AliTRDCalibraFillHisto.cxx:1134
 AliTRDCalibraFillHisto.cxx:1135
 AliTRDCalibraFillHisto.cxx:1136
 AliTRDCalibraFillHisto.cxx:1137
 AliTRDCalibraFillHisto.cxx:1138
 AliTRDCalibraFillHisto.cxx:1139
 AliTRDCalibraFillHisto.cxx:1140
 AliTRDCalibraFillHisto.cxx:1141
 AliTRDCalibraFillHisto.cxx:1142
 AliTRDCalibraFillHisto.cxx:1143
 AliTRDCalibraFillHisto.cxx:1144
 AliTRDCalibraFillHisto.cxx:1145
 AliTRDCalibraFillHisto.cxx:1146
 AliTRDCalibraFillHisto.cxx:1147
 AliTRDCalibraFillHisto.cxx:1148
 AliTRDCalibraFillHisto.cxx:1149
 AliTRDCalibraFillHisto.cxx:1150
 AliTRDCalibraFillHisto.cxx:1151
 AliTRDCalibraFillHisto.cxx:1152
 AliTRDCalibraFillHisto.cxx:1153
 AliTRDCalibraFillHisto.cxx:1154
 AliTRDCalibraFillHisto.cxx:1155
 AliTRDCalibraFillHisto.cxx:1156
 AliTRDCalibraFillHisto.cxx:1157
 AliTRDCalibraFillHisto.cxx:1158
 AliTRDCalibraFillHisto.cxx:1159
 AliTRDCalibraFillHisto.cxx:1160
 AliTRDCalibraFillHisto.cxx:1161
 AliTRDCalibraFillHisto.cxx:1162
 AliTRDCalibraFillHisto.cxx:1163
 AliTRDCalibraFillHisto.cxx:1164
 AliTRDCalibraFillHisto.cxx:1165
 AliTRDCalibraFillHisto.cxx:1166
 AliTRDCalibraFillHisto.cxx:1167
 AliTRDCalibraFillHisto.cxx:1168
 AliTRDCalibraFillHisto.cxx:1169
 AliTRDCalibraFillHisto.cxx:1170
 AliTRDCalibraFillHisto.cxx:1171
 AliTRDCalibraFillHisto.cxx:1172
 AliTRDCalibraFillHisto.cxx:1173
 AliTRDCalibraFillHisto.cxx:1174
 AliTRDCalibraFillHisto.cxx:1175
 AliTRDCalibraFillHisto.cxx:1176
 AliTRDCalibraFillHisto.cxx:1177
 AliTRDCalibraFillHisto.cxx:1178
 AliTRDCalibraFillHisto.cxx:1179
 AliTRDCalibraFillHisto.cxx:1180
 AliTRDCalibraFillHisto.cxx:1181
 AliTRDCalibraFillHisto.cxx:1182
 AliTRDCalibraFillHisto.cxx:1183
 AliTRDCalibraFillHisto.cxx:1184
 AliTRDCalibraFillHisto.cxx:1185
 AliTRDCalibraFillHisto.cxx:1186
 AliTRDCalibraFillHisto.cxx:1187
 AliTRDCalibraFillHisto.cxx:1188
 AliTRDCalibraFillHisto.cxx:1189
 AliTRDCalibraFillHisto.cxx:1190
 AliTRDCalibraFillHisto.cxx:1191
 AliTRDCalibraFillHisto.cxx:1192
 AliTRDCalibraFillHisto.cxx:1193
 AliTRDCalibraFillHisto.cxx:1194
 AliTRDCalibraFillHisto.cxx:1195
 AliTRDCalibraFillHisto.cxx:1196
 AliTRDCalibraFillHisto.cxx:1197
 AliTRDCalibraFillHisto.cxx:1198
 AliTRDCalibraFillHisto.cxx:1199
 AliTRDCalibraFillHisto.cxx:1200
 AliTRDCalibraFillHisto.cxx:1201
 AliTRDCalibraFillHisto.cxx:1202
 AliTRDCalibraFillHisto.cxx:1203
 AliTRDCalibraFillHisto.cxx:1204
 AliTRDCalibraFillHisto.cxx:1205
 AliTRDCalibraFillHisto.cxx:1206
 AliTRDCalibraFillHisto.cxx:1207
 AliTRDCalibraFillHisto.cxx:1208
 AliTRDCalibraFillHisto.cxx:1209
 AliTRDCalibraFillHisto.cxx:1210
 AliTRDCalibraFillHisto.cxx:1211
 AliTRDCalibraFillHisto.cxx:1212
 AliTRDCalibraFillHisto.cxx:1213
 AliTRDCalibraFillHisto.cxx:1214
 AliTRDCalibraFillHisto.cxx:1215
 AliTRDCalibraFillHisto.cxx:1216
 AliTRDCalibraFillHisto.cxx:1217
 AliTRDCalibraFillHisto.cxx:1218
 AliTRDCalibraFillHisto.cxx:1219
 AliTRDCalibraFillHisto.cxx:1220
 AliTRDCalibraFillHisto.cxx:1221
 AliTRDCalibraFillHisto.cxx:1222
 AliTRDCalibraFillHisto.cxx:1223
 AliTRDCalibraFillHisto.cxx:1224
 AliTRDCalibraFillHisto.cxx:1225
 AliTRDCalibraFillHisto.cxx:1226
 AliTRDCalibraFillHisto.cxx:1227
 AliTRDCalibraFillHisto.cxx:1228
 AliTRDCalibraFillHisto.cxx:1229
 AliTRDCalibraFillHisto.cxx:1230
 AliTRDCalibraFillHisto.cxx:1231
 AliTRDCalibraFillHisto.cxx:1232
 AliTRDCalibraFillHisto.cxx:1233
 AliTRDCalibraFillHisto.cxx:1234
 AliTRDCalibraFillHisto.cxx:1235
 AliTRDCalibraFillHisto.cxx:1236
 AliTRDCalibraFillHisto.cxx:1237
 AliTRDCalibraFillHisto.cxx:1238
 AliTRDCalibraFillHisto.cxx:1239
 AliTRDCalibraFillHisto.cxx:1240
 AliTRDCalibraFillHisto.cxx:1241
 AliTRDCalibraFillHisto.cxx:1242
 AliTRDCalibraFillHisto.cxx:1243
 AliTRDCalibraFillHisto.cxx:1244
 AliTRDCalibraFillHisto.cxx:1245
 AliTRDCalibraFillHisto.cxx:1246
 AliTRDCalibraFillHisto.cxx:1247
 AliTRDCalibraFillHisto.cxx:1248
 AliTRDCalibraFillHisto.cxx:1249
 AliTRDCalibraFillHisto.cxx:1250
 AliTRDCalibraFillHisto.cxx:1251
 AliTRDCalibraFillHisto.cxx:1252
 AliTRDCalibraFillHisto.cxx:1253
 AliTRDCalibraFillHisto.cxx:1254
 AliTRDCalibraFillHisto.cxx:1255
 AliTRDCalibraFillHisto.cxx:1256
 AliTRDCalibraFillHisto.cxx:1257
 AliTRDCalibraFillHisto.cxx:1258
 AliTRDCalibraFillHisto.cxx:1259
 AliTRDCalibraFillHisto.cxx:1260
 AliTRDCalibraFillHisto.cxx:1261
 AliTRDCalibraFillHisto.cxx:1262
 AliTRDCalibraFillHisto.cxx:1263
 AliTRDCalibraFillHisto.cxx:1264
 AliTRDCalibraFillHisto.cxx:1265
 AliTRDCalibraFillHisto.cxx:1266
 AliTRDCalibraFillHisto.cxx:1267
 AliTRDCalibraFillHisto.cxx:1268
 AliTRDCalibraFillHisto.cxx:1269
 AliTRDCalibraFillHisto.cxx:1270
 AliTRDCalibraFillHisto.cxx:1271
 AliTRDCalibraFillHisto.cxx:1272
 AliTRDCalibraFillHisto.cxx:1273
 AliTRDCalibraFillHisto.cxx:1274
 AliTRDCalibraFillHisto.cxx:1275
 AliTRDCalibraFillHisto.cxx:1276
 AliTRDCalibraFillHisto.cxx:1277
 AliTRDCalibraFillHisto.cxx:1278
 AliTRDCalibraFillHisto.cxx:1279
 AliTRDCalibraFillHisto.cxx:1280
 AliTRDCalibraFillHisto.cxx:1281
 AliTRDCalibraFillHisto.cxx:1282
 AliTRDCalibraFillHisto.cxx:1283
 AliTRDCalibraFillHisto.cxx:1284
 AliTRDCalibraFillHisto.cxx:1285
 AliTRDCalibraFillHisto.cxx:1286
 AliTRDCalibraFillHisto.cxx:1287
 AliTRDCalibraFillHisto.cxx:1288
 AliTRDCalibraFillHisto.cxx:1289
 AliTRDCalibraFillHisto.cxx:1290
 AliTRDCalibraFillHisto.cxx:1291
 AliTRDCalibraFillHisto.cxx:1292
 AliTRDCalibraFillHisto.cxx:1293
 AliTRDCalibraFillHisto.cxx:1294
 AliTRDCalibraFillHisto.cxx:1295
 AliTRDCalibraFillHisto.cxx:1296
 AliTRDCalibraFillHisto.cxx:1297
 AliTRDCalibraFillHisto.cxx:1298
 AliTRDCalibraFillHisto.cxx:1299
 AliTRDCalibraFillHisto.cxx:1300
 AliTRDCalibraFillHisto.cxx:1301
 AliTRDCalibraFillHisto.cxx:1302
 AliTRDCalibraFillHisto.cxx:1303
 AliTRDCalibraFillHisto.cxx:1304
 AliTRDCalibraFillHisto.cxx:1305
 AliTRDCalibraFillHisto.cxx:1306
 AliTRDCalibraFillHisto.cxx:1307
 AliTRDCalibraFillHisto.cxx:1308
 AliTRDCalibraFillHisto.cxx:1309
 AliTRDCalibraFillHisto.cxx:1310
 AliTRDCalibraFillHisto.cxx:1311
 AliTRDCalibraFillHisto.cxx:1312
 AliTRDCalibraFillHisto.cxx:1313
 AliTRDCalibraFillHisto.cxx:1314
 AliTRDCalibraFillHisto.cxx:1315
 AliTRDCalibraFillHisto.cxx:1316
 AliTRDCalibraFillHisto.cxx:1317
 AliTRDCalibraFillHisto.cxx:1318
 AliTRDCalibraFillHisto.cxx:1319
 AliTRDCalibraFillHisto.cxx:1320
 AliTRDCalibraFillHisto.cxx:1321
 AliTRDCalibraFillHisto.cxx:1322
 AliTRDCalibraFillHisto.cxx:1323
 AliTRDCalibraFillHisto.cxx:1324
 AliTRDCalibraFillHisto.cxx:1325
 AliTRDCalibraFillHisto.cxx:1326
 AliTRDCalibraFillHisto.cxx:1327
 AliTRDCalibraFillHisto.cxx:1328
 AliTRDCalibraFillHisto.cxx:1329
 AliTRDCalibraFillHisto.cxx:1330
 AliTRDCalibraFillHisto.cxx:1331
 AliTRDCalibraFillHisto.cxx:1332
 AliTRDCalibraFillHisto.cxx:1333
 AliTRDCalibraFillHisto.cxx:1334
 AliTRDCalibraFillHisto.cxx:1335
 AliTRDCalibraFillHisto.cxx:1336
 AliTRDCalibraFillHisto.cxx:1337
 AliTRDCalibraFillHisto.cxx:1338
 AliTRDCalibraFillHisto.cxx:1339
 AliTRDCalibraFillHisto.cxx:1340
 AliTRDCalibraFillHisto.cxx:1341
 AliTRDCalibraFillHisto.cxx:1342
 AliTRDCalibraFillHisto.cxx:1343
 AliTRDCalibraFillHisto.cxx:1344
 AliTRDCalibraFillHisto.cxx:1345
 AliTRDCalibraFillHisto.cxx:1346
 AliTRDCalibraFillHisto.cxx:1347
 AliTRDCalibraFillHisto.cxx:1348
 AliTRDCalibraFillHisto.cxx:1349
 AliTRDCalibraFillHisto.cxx:1350
 AliTRDCalibraFillHisto.cxx:1351
 AliTRDCalibraFillHisto.cxx:1352
 AliTRDCalibraFillHisto.cxx:1353
 AliTRDCalibraFillHisto.cxx:1354
 AliTRDCalibraFillHisto.cxx:1355
 AliTRDCalibraFillHisto.cxx:1356
 AliTRDCalibraFillHisto.cxx:1357
 AliTRDCalibraFillHisto.cxx:1358
 AliTRDCalibraFillHisto.cxx:1359
 AliTRDCalibraFillHisto.cxx:1360
 AliTRDCalibraFillHisto.cxx:1361
 AliTRDCalibraFillHisto.cxx:1362
 AliTRDCalibraFillHisto.cxx:1363
 AliTRDCalibraFillHisto.cxx:1364
 AliTRDCalibraFillHisto.cxx:1365
 AliTRDCalibraFillHisto.cxx:1366
 AliTRDCalibraFillHisto.cxx:1367
 AliTRDCalibraFillHisto.cxx:1368
 AliTRDCalibraFillHisto.cxx:1369
 AliTRDCalibraFillHisto.cxx:1370
 AliTRDCalibraFillHisto.cxx:1371
 AliTRDCalibraFillHisto.cxx:1372
 AliTRDCalibraFillHisto.cxx:1373
 AliTRDCalibraFillHisto.cxx:1374
 AliTRDCalibraFillHisto.cxx:1375
 AliTRDCalibraFillHisto.cxx:1376
 AliTRDCalibraFillHisto.cxx:1377
 AliTRDCalibraFillHisto.cxx:1378
 AliTRDCalibraFillHisto.cxx:1379
 AliTRDCalibraFillHisto.cxx:1380
 AliTRDCalibraFillHisto.cxx:1381
 AliTRDCalibraFillHisto.cxx:1382
 AliTRDCalibraFillHisto.cxx:1383
 AliTRDCalibraFillHisto.cxx:1384
 AliTRDCalibraFillHisto.cxx:1385
 AliTRDCalibraFillHisto.cxx:1386
 AliTRDCalibraFillHisto.cxx:1387
 AliTRDCalibraFillHisto.cxx:1388
 AliTRDCalibraFillHisto.cxx:1389
 AliTRDCalibraFillHisto.cxx:1390
 AliTRDCalibraFillHisto.cxx:1391
 AliTRDCalibraFillHisto.cxx:1392
 AliTRDCalibraFillHisto.cxx:1393
 AliTRDCalibraFillHisto.cxx:1394
 AliTRDCalibraFillHisto.cxx:1395
 AliTRDCalibraFillHisto.cxx:1396
 AliTRDCalibraFillHisto.cxx:1397
 AliTRDCalibraFillHisto.cxx:1398
 AliTRDCalibraFillHisto.cxx:1399
 AliTRDCalibraFillHisto.cxx:1400
 AliTRDCalibraFillHisto.cxx:1401
 AliTRDCalibraFillHisto.cxx:1402
 AliTRDCalibraFillHisto.cxx:1403
 AliTRDCalibraFillHisto.cxx:1404
 AliTRDCalibraFillHisto.cxx:1405
 AliTRDCalibraFillHisto.cxx:1406
 AliTRDCalibraFillHisto.cxx:1407
 AliTRDCalibraFillHisto.cxx:1408
 AliTRDCalibraFillHisto.cxx:1409
 AliTRDCalibraFillHisto.cxx:1410
 AliTRDCalibraFillHisto.cxx:1411
 AliTRDCalibraFillHisto.cxx:1412
 AliTRDCalibraFillHisto.cxx:1413
 AliTRDCalibraFillHisto.cxx:1414
 AliTRDCalibraFillHisto.cxx:1415
 AliTRDCalibraFillHisto.cxx:1416
 AliTRDCalibraFillHisto.cxx:1417
 AliTRDCalibraFillHisto.cxx:1418
 AliTRDCalibraFillHisto.cxx:1419
 AliTRDCalibraFillHisto.cxx:1420
 AliTRDCalibraFillHisto.cxx:1421
 AliTRDCalibraFillHisto.cxx:1422
 AliTRDCalibraFillHisto.cxx:1423
 AliTRDCalibraFillHisto.cxx:1424
 AliTRDCalibraFillHisto.cxx:1425
 AliTRDCalibraFillHisto.cxx:1426
 AliTRDCalibraFillHisto.cxx:1427
 AliTRDCalibraFillHisto.cxx:1428
 AliTRDCalibraFillHisto.cxx:1429
 AliTRDCalibraFillHisto.cxx:1430
 AliTRDCalibraFillHisto.cxx:1431
 AliTRDCalibraFillHisto.cxx:1432
 AliTRDCalibraFillHisto.cxx:1433
 AliTRDCalibraFillHisto.cxx:1434
 AliTRDCalibraFillHisto.cxx:1435
 AliTRDCalibraFillHisto.cxx:1436
 AliTRDCalibraFillHisto.cxx:1437
 AliTRDCalibraFillHisto.cxx:1438
 AliTRDCalibraFillHisto.cxx:1439
 AliTRDCalibraFillHisto.cxx:1440
 AliTRDCalibraFillHisto.cxx:1441
 AliTRDCalibraFillHisto.cxx:1442
 AliTRDCalibraFillHisto.cxx:1443
 AliTRDCalibraFillHisto.cxx:1444
 AliTRDCalibraFillHisto.cxx:1445
 AliTRDCalibraFillHisto.cxx:1446
 AliTRDCalibraFillHisto.cxx:1447
 AliTRDCalibraFillHisto.cxx:1448
 AliTRDCalibraFillHisto.cxx:1449
 AliTRDCalibraFillHisto.cxx:1450
 AliTRDCalibraFillHisto.cxx:1451
 AliTRDCalibraFillHisto.cxx:1452
 AliTRDCalibraFillHisto.cxx:1453
 AliTRDCalibraFillHisto.cxx:1454
 AliTRDCalibraFillHisto.cxx:1455
 AliTRDCalibraFillHisto.cxx:1456
 AliTRDCalibraFillHisto.cxx:1457
 AliTRDCalibraFillHisto.cxx:1458
 AliTRDCalibraFillHisto.cxx:1459
 AliTRDCalibraFillHisto.cxx:1460
 AliTRDCalibraFillHisto.cxx:1461
 AliTRDCalibraFillHisto.cxx:1462
 AliTRDCalibraFillHisto.cxx:1463
 AliTRDCalibraFillHisto.cxx:1464
 AliTRDCalibraFillHisto.cxx:1465
 AliTRDCalibraFillHisto.cxx:1466
 AliTRDCalibraFillHisto.cxx:1467
 AliTRDCalibraFillHisto.cxx:1468
 AliTRDCalibraFillHisto.cxx:1469
 AliTRDCalibraFillHisto.cxx:1470
 AliTRDCalibraFillHisto.cxx:1471
 AliTRDCalibraFillHisto.cxx:1472
 AliTRDCalibraFillHisto.cxx:1473
 AliTRDCalibraFillHisto.cxx:1474
 AliTRDCalibraFillHisto.cxx:1475
 AliTRDCalibraFillHisto.cxx:1476
 AliTRDCalibraFillHisto.cxx:1477
 AliTRDCalibraFillHisto.cxx:1478
 AliTRDCalibraFillHisto.cxx:1479
 AliTRDCalibraFillHisto.cxx:1480
 AliTRDCalibraFillHisto.cxx:1481
 AliTRDCalibraFillHisto.cxx:1482
 AliTRDCalibraFillHisto.cxx:1483
 AliTRDCalibraFillHisto.cxx:1484
 AliTRDCalibraFillHisto.cxx:1485
 AliTRDCalibraFillHisto.cxx:1486
 AliTRDCalibraFillHisto.cxx:1487
 AliTRDCalibraFillHisto.cxx:1488
 AliTRDCalibraFillHisto.cxx:1489
 AliTRDCalibraFillHisto.cxx:1490
 AliTRDCalibraFillHisto.cxx:1491
 AliTRDCalibraFillHisto.cxx:1492
 AliTRDCalibraFillHisto.cxx:1493
 AliTRDCalibraFillHisto.cxx:1494
 AliTRDCalibraFillHisto.cxx:1495
 AliTRDCalibraFillHisto.cxx:1496
 AliTRDCalibraFillHisto.cxx:1497
 AliTRDCalibraFillHisto.cxx:1498
 AliTRDCalibraFillHisto.cxx:1499
 AliTRDCalibraFillHisto.cxx:1500
 AliTRDCalibraFillHisto.cxx:1501
 AliTRDCalibraFillHisto.cxx:1502
 AliTRDCalibraFillHisto.cxx:1503
 AliTRDCalibraFillHisto.cxx:1504
 AliTRDCalibraFillHisto.cxx:1505
 AliTRDCalibraFillHisto.cxx:1506
 AliTRDCalibraFillHisto.cxx:1507
 AliTRDCalibraFillHisto.cxx:1508
 AliTRDCalibraFillHisto.cxx:1509
 AliTRDCalibraFillHisto.cxx:1510
 AliTRDCalibraFillHisto.cxx:1511
 AliTRDCalibraFillHisto.cxx:1512
 AliTRDCalibraFillHisto.cxx:1513
 AliTRDCalibraFillHisto.cxx:1514
 AliTRDCalibraFillHisto.cxx:1515
 AliTRDCalibraFillHisto.cxx:1516
 AliTRDCalibraFillHisto.cxx:1517
 AliTRDCalibraFillHisto.cxx:1518
 AliTRDCalibraFillHisto.cxx:1519
 AliTRDCalibraFillHisto.cxx:1520
 AliTRDCalibraFillHisto.cxx:1521
 AliTRDCalibraFillHisto.cxx:1522
 AliTRDCalibraFillHisto.cxx:1523
 AliTRDCalibraFillHisto.cxx:1524
 AliTRDCalibraFillHisto.cxx:1525
 AliTRDCalibraFillHisto.cxx:1526
 AliTRDCalibraFillHisto.cxx:1527
 AliTRDCalibraFillHisto.cxx:1528
 AliTRDCalibraFillHisto.cxx:1529
 AliTRDCalibraFillHisto.cxx:1530
 AliTRDCalibraFillHisto.cxx:1531
 AliTRDCalibraFillHisto.cxx:1532
 AliTRDCalibraFillHisto.cxx:1533
 AliTRDCalibraFillHisto.cxx:1534
 AliTRDCalibraFillHisto.cxx:1535
 AliTRDCalibraFillHisto.cxx:1536
 AliTRDCalibraFillHisto.cxx:1537
 AliTRDCalibraFillHisto.cxx:1538
 AliTRDCalibraFillHisto.cxx:1539
 AliTRDCalibraFillHisto.cxx:1540
 AliTRDCalibraFillHisto.cxx:1541
 AliTRDCalibraFillHisto.cxx:1542
 AliTRDCalibraFillHisto.cxx:1543
 AliTRDCalibraFillHisto.cxx:1544
 AliTRDCalibraFillHisto.cxx:1545
 AliTRDCalibraFillHisto.cxx:1546
 AliTRDCalibraFillHisto.cxx:1547
 AliTRDCalibraFillHisto.cxx:1548
 AliTRDCalibraFillHisto.cxx:1549
 AliTRDCalibraFillHisto.cxx:1550
 AliTRDCalibraFillHisto.cxx:1551
 AliTRDCalibraFillHisto.cxx:1552
 AliTRDCalibraFillHisto.cxx:1553
 AliTRDCalibraFillHisto.cxx:1554
 AliTRDCalibraFillHisto.cxx:1555
 AliTRDCalibraFillHisto.cxx:1556
 AliTRDCalibraFillHisto.cxx:1557
 AliTRDCalibraFillHisto.cxx:1558
 AliTRDCalibraFillHisto.cxx:1559
 AliTRDCalibraFillHisto.cxx:1560
 AliTRDCalibraFillHisto.cxx:1561
 AliTRDCalibraFillHisto.cxx:1562
 AliTRDCalibraFillHisto.cxx:1563
 AliTRDCalibraFillHisto.cxx:1564
 AliTRDCalibraFillHisto.cxx:1565
 AliTRDCalibraFillHisto.cxx:1566
 AliTRDCalibraFillHisto.cxx:1567
 AliTRDCalibraFillHisto.cxx:1568
 AliTRDCalibraFillHisto.cxx:1569
 AliTRDCalibraFillHisto.cxx:1570
 AliTRDCalibraFillHisto.cxx:1571
 AliTRDCalibraFillHisto.cxx:1572
 AliTRDCalibraFillHisto.cxx:1573
 AliTRDCalibraFillHisto.cxx:1574
 AliTRDCalibraFillHisto.cxx:1575
 AliTRDCalibraFillHisto.cxx:1576
 AliTRDCalibraFillHisto.cxx:1577
 AliTRDCalibraFillHisto.cxx:1578
 AliTRDCalibraFillHisto.cxx:1579
 AliTRDCalibraFillHisto.cxx:1580
 AliTRDCalibraFillHisto.cxx:1581
 AliTRDCalibraFillHisto.cxx:1582
 AliTRDCalibraFillHisto.cxx:1583
 AliTRDCalibraFillHisto.cxx:1584
 AliTRDCalibraFillHisto.cxx:1585
 AliTRDCalibraFillHisto.cxx:1586
 AliTRDCalibraFillHisto.cxx:1587
 AliTRDCalibraFillHisto.cxx:1588
 AliTRDCalibraFillHisto.cxx:1589
 AliTRDCalibraFillHisto.cxx:1590
 AliTRDCalibraFillHisto.cxx:1591
 AliTRDCalibraFillHisto.cxx:1592
 AliTRDCalibraFillHisto.cxx:1593
 AliTRDCalibraFillHisto.cxx:1594
 AliTRDCalibraFillHisto.cxx:1595
 AliTRDCalibraFillHisto.cxx:1596
 AliTRDCalibraFillHisto.cxx:1597
 AliTRDCalibraFillHisto.cxx:1598
 AliTRDCalibraFillHisto.cxx:1599
 AliTRDCalibraFillHisto.cxx:1600
 AliTRDCalibraFillHisto.cxx:1601
 AliTRDCalibraFillHisto.cxx:1602
 AliTRDCalibraFillHisto.cxx:1603
 AliTRDCalibraFillHisto.cxx:1604
 AliTRDCalibraFillHisto.cxx:1605
 AliTRDCalibraFillHisto.cxx:1606
 AliTRDCalibraFillHisto.cxx:1607
 AliTRDCalibraFillHisto.cxx:1608
 AliTRDCalibraFillHisto.cxx:1609
 AliTRDCalibraFillHisto.cxx:1610
 AliTRDCalibraFillHisto.cxx:1611
 AliTRDCalibraFillHisto.cxx:1612
 AliTRDCalibraFillHisto.cxx:1613
 AliTRDCalibraFillHisto.cxx:1614
 AliTRDCalibraFillHisto.cxx:1615
 AliTRDCalibraFillHisto.cxx:1616
 AliTRDCalibraFillHisto.cxx:1617
 AliTRDCalibraFillHisto.cxx:1618
 AliTRDCalibraFillHisto.cxx:1619
 AliTRDCalibraFillHisto.cxx:1620
 AliTRDCalibraFillHisto.cxx:1621
 AliTRDCalibraFillHisto.cxx:1622
 AliTRDCalibraFillHisto.cxx:1623
 AliTRDCalibraFillHisto.cxx:1624
 AliTRDCalibraFillHisto.cxx:1625
 AliTRDCalibraFillHisto.cxx:1626
 AliTRDCalibraFillHisto.cxx:1627
 AliTRDCalibraFillHisto.cxx:1628
 AliTRDCalibraFillHisto.cxx:1629
 AliTRDCalibraFillHisto.cxx:1630
 AliTRDCalibraFillHisto.cxx:1631
 AliTRDCalibraFillHisto.cxx:1632
 AliTRDCalibraFillHisto.cxx:1633
 AliTRDCalibraFillHisto.cxx:1634
 AliTRDCalibraFillHisto.cxx:1635
 AliTRDCalibraFillHisto.cxx:1636
 AliTRDCalibraFillHisto.cxx:1637
 AliTRDCalibraFillHisto.cxx:1638
 AliTRDCalibraFillHisto.cxx:1639
 AliTRDCalibraFillHisto.cxx:1640
 AliTRDCalibraFillHisto.cxx:1641
 AliTRDCalibraFillHisto.cxx:1642
 AliTRDCalibraFillHisto.cxx:1643
 AliTRDCalibraFillHisto.cxx:1644
 AliTRDCalibraFillHisto.cxx:1645
 AliTRDCalibraFillHisto.cxx:1646
 AliTRDCalibraFillHisto.cxx:1647
 AliTRDCalibraFillHisto.cxx:1648
 AliTRDCalibraFillHisto.cxx:1649
 AliTRDCalibraFillHisto.cxx:1650
 AliTRDCalibraFillHisto.cxx:1651
 AliTRDCalibraFillHisto.cxx:1652
 AliTRDCalibraFillHisto.cxx:1653
 AliTRDCalibraFillHisto.cxx:1654
 AliTRDCalibraFillHisto.cxx:1655
 AliTRDCalibraFillHisto.cxx:1656
 AliTRDCalibraFillHisto.cxx:1657
 AliTRDCalibraFillHisto.cxx:1658
 AliTRDCalibraFillHisto.cxx:1659
 AliTRDCalibraFillHisto.cxx:1660
 AliTRDCalibraFillHisto.cxx:1661
 AliTRDCalibraFillHisto.cxx:1662
 AliTRDCalibraFillHisto.cxx:1663
 AliTRDCalibraFillHisto.cxx:1664
 AliTRDCalibraFillHisto.cxx:1665
 AliTRDCalibraFillHisto.cxx:1666
 AliTRDCalibraFillHisto.cxx:1667
 AliTRDCalibraFillHisto.cxx:1668
 AliTRDCalibraFillHisto.cxx:1669
 AliTRDCalibraFillHisto.cxx:1670
 AliTRDCalibraFillHisto.cxx:1671
 AliTRDCalibraFillHisto.cxx:1672
 AliTRDCalibraFillHisto.cxx:1673
 AliTRDCalibraFillHisto.cxx:1674
 AliTRDCalibraFillHisto.cxx:1675
 AliTRDCalibraFillHisto.cxx:1676
 AliTRDCalibraFillHisto.cxx:1677
 AliTRDCalibraFillHisto.cxx:1678
 AliTRDCalibraFillHisto.cxx:1679
 AliTRDCalibraFillHisto.cxx:1680
 AliTRDCalibraFillHisto.cxx:1681
 AliTRDCalibraFillHisto.cxx:1682
 AliTRDCalibraFillHisto.cxx:1683
 AliTRDCalibraFillHisto.cxx:1684
 AliTRDCalibraFillHisto.cxx:1685
 AliTRDCalibraFillHisto.cxx:1686
 AliTRDCalibraFillHisto.cxx:1687
 AliTRDCalibraFillHisto.cxx:1688
 AliTRDCalibraFillHisto.cxx:1689
 AliTRDCalibraFillHisto.cxx:1690
 AliTRDCalibraFillHisto.cxx:1691
 AliTRDCalibraFillHisto.cxx:1692
 AliTRDCalibraFillHisto.cxx:1693
 AliTRDCalibraFillHisto.cxx:1694
 AliTRDCalibraFillHisto.cxx:1695
 AliTRDCalibraFillHisto.cxx:1696
 AliTRDCalibraFillHisto.cxx:1697
 AliTRDCalibraFillHisto.cxx:1698
 AliTRDCalibraFillHisto.cxx:1699
 AliTRDCalibraFillHisto.cxx:1700
 AliTRDCalibraFillHisto.cxx:1701
 AliTRDCalibraFillHisto.cxx:1702
 AliTRDCalibraFillHisto.cxx:1703
 AliTRDCalibraFillHisto.cxx:1704
 AliTRDCalibraFillHisto.cxx:1705
 AliTRDCalibraFillHisto.cxx:1706
 AliTRDCalibraFillHisto.cxx:1707
 AliTRDCalibraFillHisto.cxx:1708
 AliTRDCalibraFillHisto.cxx:1709
 AliTRDCalibraFillHisto.cxx:1710
 AliTRDCalibraFillHisto.cxx:1711
 AliTRDCalibraFillHisto.cxx:1712
 AliTRDCalibraFillHisto.cxx:1713
 AliTRDCalibraFillHisto.cxx:1714
 AliTRDCalibraFillHisto.cxx:1715
 AliTRDCalibraFillHisto.cxx:1716
 AliTRDCalibraFillHisto.cxx:1717
 AliTRDCalibraFillHisto.cxx:1718
 AliTRDCalibraFillHisto.cxx:1719
 AliTRDCalibraFillHisto.cxx:1720
 AliTRDCalibraFillHisto.cxx:1721
 AliTRDCalibraFillHisto.cxx:1722
 AliTRDCalibraFillHisto.cxx:1723
 AliTRDCalibraFillHisto.cxx:1724
 AliTRDCalibraFillHisto.cxx:1725
 AliTRDCalibraFillHisto.cxx:1726
 AliTRDCalibraFillHisto.cxx:1727
 AliTRDCalibraFillHisto.cxx:1728
 AliTRDCalibraFillHisto.cxx:1729
 AliTRDCalibraFillHisto.cxx:1730
 AliTRDCalibraFillHisto.cxx:1731
 AliTRDCalibraFillHisto.cxx:1732
 AliTRDCalibraFillHisto.cxx:1733
 AliTRDCalibraFillHisto.cxx:1734
 AliTRDCalibraFillHisto.cxx:1735
 AliTRDCalibraFillHisto.cxx:1736
 AliTRDCalibraFillHisto.cxx:1737
 AliTRDCalibraFillHisto.cxx:1738
 AliTRDCalibraFillHisto.cxx:1739
 AliTRDCalibraFillHisto.cxx:1740
 AliTRDCalibraFillHisto.cxx:1741
 AliTRDCalibraFillHisto.cxx:1742
 AliTRDCalibraFillHisto.cxx:1743
 AliTRDCalibraFillHisto.cxx:1744
 AliTRDCalibraFillHisto.cxx:1745
 AliTRDCalibraFillHisto.cxx:1746
 AliTRDCalibraFillHisto.cxx:1747
 AliTRDCalibraFillHisto.cxx:1748
 AliTRDCalibraFillHisto.cxx:1749
 AliTRDCalibraFillHisto.cxx:1750
 AliTRDCalibraFillHisto.cxx:1751
 AliTRDCalibraFillHisto.cxx:1752
 AliTRDCalibraFillHisto.cxx:1753
 AliTRDCalibraFillHisto.cxx:1754
 AliTRDCalibraFillHisto.cxx:1755
 AliTRDCalibraFillHisto.cxx:1756
 AliTRDCalibraFillHisto.cxx:1757
 AliTRDCalibraFillHisto.cxx:1758
 AliTRDCalibraFillHisto.cxx:1759
 AliTRDCalibraFillHisto.cxx:1760
 AliTRDCalibraFillHisto.cxx:1761
 AliTRDCalibraFillHisto.cxx:1762
 AliTRDCalibraFillHisto.cxx:1763
 AliTRDCalibraFillHisto.cxx:1764
 AliTRDCalibraFillHisto.cxx:1765
 AliTRDCalibraFillHisto.cxx:1766
 AliTRDCalibraFillHisto.cxx:1767
 AliTRDCalibraFillHisto.cxx:1768
 AliTRDCalibraFillHisto.cxx:1769
 AliTRDCalibraFillHisto.cxx:1770
 AliTRDCalibraFillHisto.cxx:1771
 AliTRDCalibraFillHisto.cxx:1772
 AliTRDCalibraFillHisto.cxx:1773
 AliTRDCalibraFillHisto.cxx:1774
 AliTRDCalibraFillHisto.cxx:1775
 AliTRDCalibraFillHisto.cxx:1776
 AliTRDCalibraFillHisto.cxx:1777
 AliTRDCalibraFillHisto.cxx:1778
 AliTRDCalibraFillHisto.cxx:1779
 AliTRDCalibraFillHisto.cxx:1780
 AliTRDCalibraFillHisto.cxx:1781
 AliTRDCalibraFillHisto.cxx:1782
 AliTRDCalibraFillHisto.cxx:1783
 AliTRDCalibraFillHisto.cxx:1784
 AliTRDCalibraFillHisto.cxx:1785
 AliTRDCalibraFillHisto.cxx:1786
 AliTRDCalibraFillHisto.cxx:1787
 AliTRDCalibraFillHisto.cxx:1788
 AliTRDCalibraFillHisto.cxx:1789
 AliTRDCalibraFillHisto.cxx:1790
 AliTRDCalibraFillHisto.cxx:1791
 AliTRDCalibraFillHisto.cxx:1792
 AliTRDCalibraFillHisto.cxx:1793
 AliTRDCalibraFillHisto.cxx:1794
 AliTRDCalibraFillHisto.cxx:1795
 AliTRDCalibraFillHisto.cxx:1796
 AliTRDCalibraFillHisto.cxx:1797
 AliTRDCalibraFillHisto.cxx:1798
 AliTRDCalibraFillHisto.cxx:1799
 AliTRDCalibraFillHisto.cxx:1800
 AliTRDCalibraFillHisto.cxx:1801
 AliTRDCalibraFillHisto.cxx:1802
 AliTRDCalibraFillHisto.cxx:1803
 AliTRDCalibraFillHisto.cxx:1804
 AliTRDCalibraFillHisto.cxx:1805
 AliTRDCalibraFillHisto.cxx:1806
 AliTRDCalibraFillHisto.cxx:1807
 AliTRDCalibraFillHisto.cxx:1808
 AliTRDCalibraFillHisto.cxx:1809
 AliTRDCalibraFillHisto.cxx:1810
 AliTRDCalibraFillHisto.cxx:1811
 AliTRDCalibraFillHisto.cxx:1812
 AliTRDCalibraFillHisto.cxx:1813
 AliTRDCalibraFillHisto.cxx:1814
 AliTRDCalibraFillHisto.cxx:1815
 AliTRDCalibraFillHisto.cxx:1816
 AliTRDCalibraFillHisto.cxx:1817
 AliTRDCalibraFillHisto.cxx:1818
 AliTRDCalibraFillHisto.cxx:1819
 AliTRDCalibraFillHisto.cxx:1820
 AliTRDCalibraFillHisto.cxx:1821
 AliTRDCalibraFillHisto.cxx:1822
 AliTRDCalibraFillHisto.cxx:1823
 AliTRDCalibraFillHisto.cxx:1824
 AliTRDCalibraFillHisto.cxx:1825
 AliTRDCalibraFillHisto.cxx:1826
 AliTRDCalibraFillHisto.cxx:1827
 AliTRDCalibraFillHisto.cxx:1828
 AliTRDCalibraFillHisto.cxx:1829
 AliTRDCalibraFillHisto.cxx:1830
 AliTRDCalibraFillHisto.cxx:1831
 AliTRDCalibraFillHisto.cxx:1832
 AliTRDCalibraFillHisto.cxx:1833
 AliTRDCalibraFillHisto.cxx:1834
 AliTRDCalibraFillHisto.cxx:1835
 AliTRDCalibraFillHisto.cxx:1836
 AliTRDCalibraFillHisto.cxx:1837
 AliTRDCalibraFillHisto.cxx:1838
 AliTRDCalibraFillHisto.cxx:1839
 AliTRDCalibraFillHisto.cxx:1840
 AliTRDCalibraFillHisto.cxx:1841
 AliTRDCalibraFillHisto.cxx:1842
 AliTRDCalibraFillHisto.cxx:1843
 AliTRDCalibraFillHisto.cxx:1844
 AliTRDCalibraFillHisto.cxx:1845
 AliTRDCalibraFillHisto.cxx:1846
 AliTRDCalibraFillHisto.cxx:1847
 AliTRDCalibraFillHisto.cxx:1848
 AliTRDCalibraFillHisto.cxx:1849
 AliTRDCalibraFillHisto.cxx:1850
 AliTRDCalibraFillHisto.cxx:1851
 AliTRDCalibraFillHisto.cxx:1852
 AliTRDCalibraFillHisto.cxx:1853
 AliTRDCalibraFillHisto.cxx:1854
 AliTRDCalibraFillHisto.cxx:1855
 AliTRDCalibraFillHisto.cxx:1856
 AliTRDCalibraFillHisto.cxx:1857
 AliTRDCalibraFillHisto.cxx:1858
 AliTRDCalibraFillHisto.cxx:1859
 AliTRDCalibraFillHisto.cxx:1860
 AliTRDCalibraFillHisto.cxx:1861
 AliTRDCalibraFillHisto.cxx:1862
 AliTRDCalibraFillHisto.cxx:1863
 AliTRDCalibraFillHisto.cxx:1864
 AliTRDCalibraFillHisto.cxx:1865
 AliTRDCalibraFillHisto.cxx:1866
 AliTRDCalibraFillHisto.cxx:1867
 AliTRDCalibraFillHisto.cxx:1868
 AliTRDCalibraFillHisto.cxx:1869
 AliTRDCalibraFillHisto.cxx:1870
 AliTRDCalibraFillHisto.cxx:1871
 AliTRDCalibraFillHisto.cxx:1872
 AliTRDCalibraFillHisto.cxx:1873
 AliTRDCalibraFillHisto.cxx:1874
 AliTRDCalibraFillHisto.cxx:1875
 AliTRDCalibraFillHisto.cxx:1876
 AliTRDCalibraFillHisto.cxx:1877
 AliTRDCalibraFillHisto.cxx:1878
 AliTRDCalibraFillHisto.cxx:1879
 AliTRDCalibraFillHisto.cxx:1880
 AliTRDCalibraFillHisto.cxx:1881
 AliTRDCalibraFillHisto.cxx:1882
 AliTRDCalibraFillHisto.cxx:1883
 AliTRDCalibraFillHisto.cxx:1884
 AliTRDCalibraFillHisto.cxx:1885
 AliTRDCalibraFillHisto.cxx:1886
 AliTRDCalibraFillHisto.cxx:1887
 AliTRDCalibraFillHisto.cxx:1888
 AliTRDCalibraFillHisto.cxx:1889
 AliTRDCalibraFillHisto.cxx:1890
 AliTRDCalibraFillHisto.cxx:1891
 AliTRDCalibraFillHisto.cxx:1892
 AliTRDCalibraFillHisto.cxx:1893
 AliTRDCalibraFillHisto.cxx:1894
 AliTRDCalibraFillHisto.cxx:1895
 AliTRDCalibraFillHisto.cxx:1896
 AliTRDCalibraFillHisto.cxx:1897
 AliTRDCalibraFillHisto.cxx:1898
 AliTRDCalibraFillHisto.cxx:1899
 AliTRDCalibraFillHisto.cxx:1900
 AliTRDCalibraFillHisto.cxx:1901
 AliTRDCalibraFillHisto.cxx:1902
 AliTRDCalibraFillHisto.cxx:1903
 AliTRDCalibraFillHisto.cxx:1904
 AliTRDCalibraFillHisto.cxx:1905
 AliTRDCalibraFillHisto.cxx:1906
 AliTRDCalibraFillHisto.cxx:1907
 AliTRDCalibraFillHisto.cxx:1908
 AliTRDCalibraFillHisto.cxx:1909
 AliTRDCalibraFillHisto.cxx:1910
 AliTRDCalibraFillHisto.cxx:1911
 AliTRDCalibraFillHisto.cxx:1912
 AliTRDCalibraFillHisto.cxx:1913
 AliTRDCalibraFillHisto.cxx:1914
 AliTRDCalibraFillHisto.cxx:1915
 AliTRDCalibraFillHisto.cxx:1916
 AliTRDCalibraFillHisto.cxx:1917
 AliTRDCalibraFillHisto.cxx:1918
 AliTRDCalibraFillHisto.cxx:1919
 AliTRDCalibraFillHisto.cxx:1920
 AliTRDCalibraFillHisto.cxx:1921
 AliTRDCalibraFillHisto.cxx:1922
 AliTRDCalibraFillHisto.cxx:1923
 AliTRDCalibraFillHisto.cxx:1924
 AliTRDCalibraFillHisto.cxx:1925
 AliTRDCalibraFillHisto.cxx:1926
 AliTRDCalibraFillHisto.cxx:1927
 AliTRDCalibraFillHisto.cxx:1928
 AliTRDCalibraFillHisto.cxx:1929
 AliTRDCalibraFillHisto.cxx:1930
 AliTRDCalibraFillHisto.cxx:1931
 AliTRDCalibraFillHisto.cxx:1932
 AliTRDCalibraFillHisto.cxx:1933
 AliTRDCalibraFillHisto.cxx:1934
 AliTRDCalibraFillHisto.cxx:1935
 AliTRDCalibraFillHisto.cxx:1936
 AliTRDCalibraFillHisto.cxx:1937
 AliTRDCalibraFillHisto.cxx:1938
 AliTRDCalibraFillHisto.cxx:1939
 AliTRDCalibraFillHisto.cxx:1940
 AliTRDCalibraFillHisto.cxx:1941
 AliTRDCalibraFillHisto.cxx:1942
 AliTRDCalibraFillHisto.cxx:1943
 AliTRDCalibraFillHisto.cxx:1944
 AliTRDCalibraFillHisto.cxx:1945
 AliTRDCalibraFillHisto.cxx:1946
 AliTRDCalibraFillHisto.cxx:1947
 AliTRDCalibraFillHisto.cxx:1948
 AliTRDCalibraFillHisto.cxx:1949
 AliTRDCalibraFillHisto.cxx:1950
 AliTRDCalibraFillHisto.cxx:1951
 AliTRDCalibraFillHisto.cxx:1952
 AliTRDCalibraFillHisto.cxx:1953
 AliTRDCalibraFillHisto.cxx:1954
 AliTRDCalibraFillHisto.cxx:1955
 AliTRDCalibraFillHisto.cxx:1956
 AliTRDCalibraFillHisto.cxx:1957
 AliTRDCalibraFillHisto.cxx:1958
 AliTRDCalibraFillHisto.cxx:1959
 AliTRDCalibraFillHisto.cxx:1960
 AliTRDCalibraFillHisto.cxx:1961
 AliTRDCalibraFillHisto.cxx:1962
 AliTRDCalibraFillHisto.cxx:1963
 AliTRDCalibraFillHisto.cxx:1964
 AliTRDCalibraFillHisto.cxx:1965
 AliTRDCalibraFillHisto.cxx:1966
 AliTRDCalibraFillHisto.cxx:1967
 AliTRDCalibraFillHisto.cxx:1968
 AliTRDCalibraFillHisto.cxx:1969
 AliTRDCalibraFillHisto.cxx:1970
 AliTRDCalibraFillHisto.cxx:1971
 AliTRDCalibraFillHisto.cxx:1972
 AliTRDCalibraFillHisto.cxx:1973
 AliTRDCalibraFillHisto.cxx:1974
 AliTRDCalibraFillHisto.cxx:1975
 AliTRDCalibraFillHisto.cxx:1976
 AliTRDCalibraFillHisto.cxx:1977
 AliTRDCalibraFillHisto.cxx:1978
 AliTRDCalibraFillHisto.cxx:1979
 AliTRDCalibraFillHisto.cxx:1980
 AliTRDCalibraFillHisto.cxx:1981
 AliTRDCalibraFillHisto.cxx:1982
 AliTRDCalibraFillHisto.cxx:1983
 AliTRDCalibraFillHisto.cxx:1984
 AliTRDCalibraFillHisto.cxx:1985
 AliTRDCalibraFillHisto.cxx:1986
 AliTRDCalibraFillHisto.cxx:1987
 AliTRDCalibraFillHisto.cxx:1988
 AliTRDCalibraFillHisto.cxx:1989
 AliTRDCalibraFillHisto.cxx:1990
 AliTRDCalibraFillHisto.cxx:1991
 AliTRDCalibraFillHisto.cxx:1992
 AliTRDCalibraFillHisto.cxx:1993
 AliTRDCalibraFillHisto.cxx:1994
 AliTRDCalibraFillHisto.cxx:1995
 AliTRDCalibraFillHisto.cxx:1996
 AliTRDCalibraFillHisto.cxx:1997
 AliTRDCalibraFillHisto.cxx:1998
 AliTRDCalibraFillHisto.cxx:1999
 AliTRDCalibraFillHisto.cxx:2000
 AliTRDCalibraFillHisto.cxx:2001
 AliTRDCalibraFillHisto.cxx:2002
 AliTRDCalibraFillHisto.cxx:2003
 AliTRDCalibraFillHisto.cxx:2004
 AliTRDCalibraFillHisto.cxx:2005
 AliTRDCalibraFillHisto.cxx:2006
 AliTRDCalibraFillHisto.cxx:2007
 AliTRDCalibraFillHisto.cxx:2008
 AliTRDCalibraFillHisto.cxx:2009
 AliTRDCalibraFillHisto.cxx:2010
 AliTRDCalibraFillHisto.cxx:2011
 AliTRDCalibraFillHisto.cxx:2012
 AliTRDCalibraFillHisto.cxx:2013
 AliTRDCalibraFillHisto.cxx:2014
 AliTRDCalibraFillHisto.cxx:2015
 AliTRDCalibraFillHisto.cxx:2016
 AliTRDCalibraFillHisto.cxx:2017
 AliTRDCalibraFillHisto.cxx:2018
 AliTRDCalibraFillHisto.cxx:2019
 AliTRDCalibraFillHisto.cxx:2020
 AliTRDCalibraFillHisto.cxx:2021
 AliTRDCalibraFillHisto.cxx:2022
 AliTRDCalibraFillHisto.cxx:2023
 AliTRDCalibraFillHisto.cxx:2024
 AliTRDCalibraFillHisto.cxx:2025
 AliTRDCalibraFillHisto.cxx:2026
 AliTRDCalibraFillHisto.cxx:2027
 AliTRDCalibraFillHisto.cxx:2028
 AliTRDCalibraFillHisto.cxx:2029
 AliTRDCalibraFillHisto.cxx:2030
 AliTRDCalibraFillHisto.cxx:2031
 AliTRDCalibraFillHisto.cxx:2032
 AliTRDCalibraFillHisto.cxx:2033
 AliTRDCalibraFillHisto.cxx:2034
 AliTRDCalibraFillHisto.cxx:2035
 AliTRDCalibraFillHisto.cxx:2036
 AliTRDCalibraFillHisto.cxx:2037
 AliTRDCalibraFillHisto.cxx:2038
 AliTRDCalibraFillHisto.cxx:2039
 AliTRDCalibraFillHisto.cxx:2040
 AliTRDCalibraFillHisto.cxx:2041
 AliTRDCalibraFillHisto.cxx:2042
 AliTRDCalibraFillHisto.cxx:2043
 AliTRDCalibraFillHisto.cxx:2044
 AliTRDCalibraFillHisto.cxx:2045
 AliTRDCalibraFillHisto.cxx:2046
 AliTRDCalibraFillHisto.cxx:2047
 AliTRDCalibraFillHisto.cxx:2048
 AliTRDCalibraFillHisto.cxx:2049
 AliTRDCalibraFillHisto.cxx:2050
 AliTRDCalibraFillHisto.cxx:2051
 AliTRDCalibraFillHisto.cxx:2052
 AliTRDCalibraFillHisto.cxx:2053
 AliTRDCalibraFillHisto.cxx:2054
 AliTRDCalibraFillHisto.cxx:2055
 AliTRDCalibraFillHisto.cxx:2056
 AliTRDCalibraFillHisto.cxx:2057
 AliTRDCalibraFillHisto.cxx:2058
 AliTRDCalibraFillHisto.cxx:2059
 AliTRDCalibraFillHisto.cxx:2060
 AliTRDCalibraFillHisto.cxx:2061
 AliTRDCalibraFillHisto.cxx:2062
 AliTRDCalibraFillHisto.cxx:2063
 AliTRDCalibraFillHisto.cxx:2064
 AliTRDCalibraFillHisto.cxx:2065
 AliTRDCalibraFillHisto.cxx:2066
 AliTRDCalibraFillHisto.cxx:2067
 AliTRDCalibraFillHisto.cxx:2068
 AliTRDCalibraFillHisto.cxx:2069
 AliTRDCalibraFillHisto.cxx:2070
 AliTRDCalibraFillHisto.cxx:2071
 AliTRDCalibraFillHisto.cxx:2072
 AliTRDCalibraFillHisto.cxx:2073
 AliTRDCalibraFillHisto.cxx:2074
 AliTRDCalibraFillHisto.cxx:2075
 AliTRDCalibraFillHisto.cxx:2076
 AliTRDCalibraFillHisto.cxx:2077
 AliTRDCalibraFillHisto.cxx:2078
 AliTRDCalibraFillHisto.cxx:2079
 AliTRDCalibraFillHisto.cxx:2080
 AliTRDCalibraFillHisto.cxx:2081
 AliTRDCalibraFillHisto.cxx:2082
 AliTRDCalibraFillHisto.cxx:2083
 AliTRDCalibraFillHisto.cxx:2084
 AliTRDCalibraFillHisto.cxx:2085
 AliTRDCalibraFillHisto.cxx:2086
 AliTRDCalibraFillHisto.cxx:2087
 AliTRDCalibraFillHisto.cxx:2088
 AliTRDCalibraFillHisto.cxx:2089
 AliTRDCalibraFillHisto.cxx:2090
 AliTRDCalibraFillHisto.cxx:2091
 AliTRDCalibraFillHisto.cxx:2092
 AliTRDCalibraFillHisto.cxx:2093
 AliTRDCalibraFillHisto.cxx:2094
 AliTRDCalibraFillHisto.cxx:2095
 AliTRDCalibraFillHisto.cxx:2096
 AliTRDCalibraFillHisto.cxx:2097
 AliTRDCalibraFillHisto.cxx:2098
 AliTRDCalibraFillHisto.cxx:2099
 AliTRDCalibraFillHisto.cxx:2100
 AliTRDCalibraFillHisto.cxx:2101
 AliTRDCalibraFillHisto.cxx:2102
 AliTRDCalibraFillHisto.cxx:2103
 AliTRDCalibraFillHisto.cxx:2104
 AliTRDCalibraFillHisto.cxx:2105
 AliTRDCalibraFillHisto.cxx:2106
 AliTRDCalibraFillHisto.cxx:2107
 AliTRDCalibraFillHisto.cxx:2108
 AliTRDCalibraFillHisto.cxx:2109
 AliTRDCalibraFillHisto.cxx:2110
 AliTRDCalibraFillHisto.cxx:2111
 AliTRDCalibraFillHisto.cxx:2112
 AliTRDCalibraFillHisto.cxx:2113
 AliTRDCalibraFillHisto.cxx:2114
 AliTRDCalibraFillHisto.cxx:2115
 AliTRDCalibraFillHisto.cxx:2116
 AliTRDCalibraFillHisto.cxx:2117
 AliTRDCalibraFillHisto.cxx:2118
 AliTRDCalibraFillHisto.cxx:2119
 AliTRDCalibraFillHisto.cxx:2120
 AliTRDCalibraFillHisto.cxx:2121
 AliTRDCalibraFillHisto.cxx:2122
 AliTRDCalibraFillHisto.cxx:2123
 AliTRDCalibraFillHisto.cxx:2124
 AliTRDCalibraFillHisto.cxx:2125
 AliTRDCalibraFillHisto.cxx:2126
 AliTRDCalibraFillHisto.cxx:2127
 AliTRDCalibraFillHisto.cxx:2128
 AliTRDCalibraFillHisto.cxx:2129
 AliTRDCalibraFillHisto.cxx:2130
 AliTRDCalibraFillHisto.cxx:2131
 AliTRDCalibraFillHisto.cxx:2132
 AliTRDCalibraFillHisto.cxx:2133
 AliTRDCalibraFillHisto.cxx:2134
 AliTRDCalibraFillHisto.cxx:2135
 AliTRDCalibraFillHisto.cxx:2136
 AliTRDCalibraFillHisto.cxx:2137
 AliTRDCalibraFillHisto.cxx:2138
 AliTRDCalibraFillHisto.cxx:2139
 AliTRDCalibraFillHisto.cxx:2140
 AliTRDCalibraFillHisto.cxx:2141
 AliTRDCalibraFillHisto.cxx:2142
 AliTRDCalibraFillHisto.cxx:2143
 AliTRDCalibraFillHisto.cxx:2144
 AliTRDCalibraFillHisto.cxx:2145
 AliTRDCalibraFillHisto.cxx:2146
 AliTRDCalibraFillHisto.cxx:2147
 AliTRDCalibraFillHisto.cxx:2148
 AliTRDCalibraFillHisto.cxx:2149
 AliTRDCalibraFillHisto.cxx:2150
 AliTRDCalibraFillHisto.cxx:2151
 AliTRDCalibraFillHisto.cxx:2152
 AliTRDCalibraFillHisto.cxx:2153
 AliTRDCalibraFillHisto.cxx:2154
 AliTRDCalibraFillHisto.cxx:2155
 AliTRDCalibraFillHisto.cxx:2156
 AliTRDCalibraFillHisto.cxx:2157
 AliTRDCalibraFillHisto.cxx:2158
 AliTRDCalibraFillHisto.cxx:2159
 AliTRDCalibraFillHisto.cxx:2160
 AliTRDCalibraFillHisto.cxx:2161
 AliTRDCalibraFillHisto.cxx:2162
 AliTRDCalibraFillHisto.cxx:2163
 AliTRDCalibraFillHisto.cxx:2164
 AliTRDCalibraFillHisto.cxx:2165
 AliTRDCalibraFillHisto.cxx:2166
 AliTRDCalibraFillHisto.cxx:2167
 AliTRDCalibraFillHisto.cxx:2168
 AliTRDCalibraFillHisto.cxx:2169
 AliTRDCalibraFillHisto.cxx:2170
 AliTRDCalibraFillHisto.cxx:2171
 AliTRDCalibraFillHisto.cxx:2172
 AliTRDCalibraFillHisto.cxx:2173
 AliTRDCalibraFillHisto.cxx:2174
 AliTRDCalibraFillHisto.cxx:2175
 AliTRDCalibraFillHisto.cxx:2176
 AliTRDCalibraFillHisto.cxx:2177
 AliTRDCalibraFillHisto.cxx:2178
 AliTRDCalibraFillHisto.cxx:2179
 AliTRDCalibraFillHisto.cxx:2180
 AliTRDCalibraFillHisto.cxx:2181
 AliTRDCalibraFillHisto.cxx:2182
 AliTRDCalibraFillHisto.cxx:2183
 AliTRDCalibraFillHisto.cxx:2184
 AliTRDCalibraFillHisto.cxx:2185
 AliTRDCalibraFillHisto.cxx:2186
 AliTRDCalibraFillHisto.cxx:2187
 AliTRDCalibraFillHisto.cxx:2188
 AliTRDCalibraFillHisto.cxx:2189
 AliTRDCalibraFillHisto.cxx:2190
 AliTRDCalibraFillHisto.cxx:2191
 AliTRDCalibraFillHisto.cxx:2192
 AliTRDCalibraFillHisto.cxx:2193
 AliTRDCalibraFillHisto.cxx:2194
 AliTRDCalibraFillHisto.cxx:2195
 AliTRDCalibraFillHisto.cxx:2196
 AliTRDCalibraFillHisto.cxx:2197
 AliTRDCalibraFillHisto.cxx:2198
 AliTRDCalibraFillHisto.cxx:2199
 AliTRDCalibraFillHisto.cxx:2200
 AliTRDCalibraFillHisto.cxx:2201
 AliTRDCalibraFillHisto.cxx:2202
 AliTRDCalibraFillHisto.cxx:2203
 AliTRDCalibraFillHisto.cxx:2204
 AliTRDCalibraFillHisto.cxx:2205
 AliTRDCalibraFillHisto.cxx:2206
 AliTRDCalibraFillHisto.cxx:2207
 AliTRDCalibraFillHisto.cxx:2208
 AliTRDCalibraFillHisto.cxx:2209
 AliTRDCalibraFillHisto.cxx:2210
 AliTRDCalibraFillHisto.cxx:2211
 AliTRDCalibraFillHisto.cxx:2212
 AliTRDCalibraFillHisto.cxx:2213
 AliTRDCalibraFillHisto.cxx:2214
 AliTRDCalibraFillHisto.cxx:2215
 AliTRDCalibraFillHisto.cxx:2216
 AliTRDCalibraFillHisto.cxx:2217
 AliTRDCalibraFillHisto.cxx:2218
 AliTRDCalibraFillHisto.cxx:2219
 AliTRDCalibraFillHisto.cxx:2220
 AliTRDCalibraFillHisto.cxx:2221
 AliTRDCalibraFillHisto.cxx:2222
 AliTRDCalibraFillHisto.cxx:2223
 AliTRDCalibraFillHisto.cxx:2224
 AliTRDCalibraFillHisto.cxx:2225
 AliTRDCalibraFillHisto.cxx:2226
 AliTRDCalibraFillHisto.cxx:2227
 AliTRDCalibraFillHisto.cxx:2228
 AliTRDCalibraFillHisto.cxx:2229
 AliTRDCalibraFillHisto.cxx:2230
 AliTRDCalibraFillHisto.cxx:2231
 AliTRDCalibraFillHisto.cxx:2232
 AliTRDCalibraFillHisto.cxx:2233
 AliTRDCalibraFillHisto.cxx:2234
 AliTRDCalibraFillHisto.cxx:2235
 AliTRDCalibraFillHisto.cxx:2236
 AliTRDCalibraFillHisto.cxx:2237
 AliTRDCalibraFillHisto.cxx:2238
 AliTRDCalibraFillHisto.cxx:2239
 AliTRDCalibraFillHisto.cxx:2240
 AliTRDCalibraFillHisto.cxx:2241
 AliTRDCalibraFillHisto.cxx:2242
 AliTRDCalibraFillHisto.cxx:2243
 AliTRDCalibraFillHisto.cxx:2244
 AliTRDCalibraFillHisto.cxx:2245
 AliTRDCalibraFillHisto.cxx:2246
 AliTRDCalibraFillHisto.cxx:2247
 AliTRDCalibraFillHisto.cxx:2248
 AliTRDCalibraFillHisto.cxx:2249
 AliTRDCalibraFillHisto.cxx:2250
 AliTRDCalibraFillHisto.cxx:2251
 AliTRDCalibraFillHisto.cxx:2252
 AliTRDCalibraFillHisto.cxx:2253
 AliTRDCalibraFillHisto.cxx:2254
 AliTRDCalibraFillHisto.cxx:2255
 AliTRDCalibraFillHisto.cxx:2256
 AliTRDCalibraFillHisto.cxx:2257
 AliTRDCalibraFillHisto.cxx:2258
 AliTRDCalibraFillHisto.cxx:2259
 AliTRDCalibraFillHisto.cxx:2260
 AliTRDCalibraFillHisto.cxx:2261
 AliTRDCalibraFillHisto.cxx:2262
 AliTRDCalibraFillHisto.cxx:2263
 AliTRDCalibraFillHisto.cxx:2264
 AliTRDCalibraFillHisto.cxx:2265
 AliTRDCalibraFillHisto.cxx:2266
 AliTRDCalibraFillHisto.cxx:2267
 AliTRDCalibraFillHisto.cxx:2268
 AliTRDCalibraFillHisto.cxx:2269
 AliTRDCalibraFillHisto.cxx:2270
 AliTRDCalibraFillHisto.cxx:2271
 AliTRDCalibraFillHisto.cxx:2272
 AliTRDCalibraFillHisto.cxx:2273
 AliTRDCalibraFillHisto.cxx:2274
 AliTRDCalibraFillHisto.cxx:2275
 AliTRDCalibraFillHisto.cxx:2276
 AliTRDCalibraFillHisto.cxx:2277
 AliTRDCalibraFillHisto.cxx:2278
 AliTRDCalibraFillHisto.cxx:2279
 AliTRDCalibraFillHisto.cxx:2280
 AliTRDCalibraFillHisto.cxx:2281
 AliTRDCalibraFillHisto.cxx:2282
 AliTRDCalibraFillHisto.cxx:2283
 AliTRDCalibraFillHisto.cxx:2284
 AliTRDCalibraFillHisto.cxx:2285
 AliTRDCalibraFillHisto.cxx:2286
 AliTRDCalibraFillHisto.cxx:2287
 AliTRDCalibraFillHisto.cxx:2288
 AliTRDCalibraFillHisto.cxx:2289
 AliTRDCalibraFillHisto.cxx:2290
 AliTRDCalibraFillHisto.cxx:2291
 AliTRDCalibraFillHisto.cxx:2292
 AliTRDCalibraFillHisto.cxx:2293
 AliTRDCalibraFillHisto.cxx:2294
 AliTRDCalibraFillHisto.cxx:2295
 AliTRDCalibraFillHisto.cxx:2296
 AliTRDCalibraFillHisto.cxx:2297
 AliTRDCalibraFillHisto.cxx:2298
 AliTRDCalibraFillHisto.cxx:2299
 AliTRDCalibraFillHisto.cxx:2300
 AliTRDCalibraFillHisto.cxx:2301
 AliTRDCalibraFillHisto.cxx:2302
 AliTRDCalibraFillHisto.cxx:2303
 AliTRDCalibraFillHisto.cxx:2304
 AliTRDCalibraFillHisto.cxx:2305
 AliTRDCalibraFillHisto.cxx:2306
 AliTRDCalibraFillHisto.cxx:2307
 AliTRDCalibraFillHisto.cxx:2308
 AliTRDCalibraFillHisto.cxx:2309
 AliTRDCalibraFillHisto.cxx:2310
 AliTRDCalibraFillHisto.cxx:2311
 AliTRDCalibraFillHisto.cxx:2312
 AliTRDCalibraFillHisto.cxx:2313
 AliTRDCalibraFillHisto.cxx:2314
 AliTRDCalibraFillHisto.cxx:2315
 AliTRDCalibraFillHisto.cxx:2316
 AliTRDCalibraFillHisto.cxx:2317
 AliTRDCalibraFillHisto.cxx:2318
 AliTRDCalibraFillHisto.cxx:2319
 AliTRDCalibraFillHisto.cxx:2320
 AliTRDCalibraFillHisto.cxx:2321
 AliTRDCalibraFillHisto.cxx:2322
 AliTRDCalibraFillHisto.cxx:2323
 AliTRDCalibraFillHisto.cxx:2324
 AliTRDCalibraFillHisto.cxx:2325
 AliTRDCalibraFillHisto.cxx:2326
 AliTRDCalibraFillHisto.cxx:2327
 AliTRDCalibraFillHisto.cxx:2328
 AliTRDCalibraFillHisto.cxx:2329
 AliTRDCalibraFillHisto.cxx:2330
 AliTRDCalibraFillHisto.cxx:2331
 AliTRDCalibraFillHisto.cxx:2332
 AliTRDCalibraFillHisto.cxx:2333
 AliTRDCalibraFillHisto.cxx:2334
 AliTRDCalibraFillHisto.cxx:2335
 AliTRDCalibraFillHisto.cxx:2336
 AliTRDCalibraFillHisto.cxx:2337
 AliTRDCalibraFillHisto.cxx:2338
 AliTRDCalibraFillHisto.cxx:2339
 AliTRDCalibraFillHisto.cxx:2340
 AliTRDCalibraFillHisto.cxx:2341
 AliTRDCalibraFillHisto.cxx:2342
 AliTRDCalibraFillHisto.cxx:2343
 AliTRDCalibraFillHisto.cxx:2344
 AliTRDCalibraFillHisto.cxx:2345
 AliTRDCalibraFillHisto.cxx:2346
 AliTRDCalibraFillHisto.cxx:2347
 AliTRDCalibraFillHisto.cxx:2348
 AliTRDCalibraFillHisto.cxx:2349
 AliTRDCalibraFillHisto.cxx:2350
 AliTRDCalibraFillHisto.cxx:2351
 AliTRDCalibraFillHisto.cxx:2352
 AliTRDCalibraFillHisto.cxx:2353
 AliTRDCalibraFillHisto.cxx:2354
 AliTRDCalibraFillHisto.cxx:2355
 AliTRDCalibraFillHisto.cxx:2356
 AliTRDCalibraFillHisto.cxx:2357
 AliTRDCalibraFillHisto.cxx:2358
 AliTRDCalibraFillHisto.cxx:2359
 AliTRDCalibraFillHisto.cxx:2360
 AliTRDCalibraFillHisto.cxx:2361
 AliTRDCalibraFillHisto.cxx:2362
 AliTRDCalibraFillHisto.cxx:2363
 AliTRDCalibraFillHisto.cxx:2364
 AliTRDCalibraFillHisto.cxx:2365
 AliTRDCalibraFillHisto.cxx:2366
 AliTRDCalibraFillHisto.cxx:2367
 AliTRDCalibraFillHisto.cxx:2368
 AliTRDCalibraFillHisto.cxx:2369
 AliTRDCalibraFillHisto.cxx:2370
 AliTRDCalibraFillHisto.cxx:2371
 AliTRDCalibraFillHisto.cxx:2372
 AliTRDCalibraFillHisto.cxx:2373
 AliTRDCalibraFillHisto.cxx:2374
 AliTRDCalibraFillHisto.cxx:2375
 AliTRDCalibraFillHisto.cxx:2376
 AliTRDCalibraFillHisto.cxx:2377
 AliTRDCalibraFillHisto.cxx:2378
 AliTRDCalibraFillHisto.cxx:2379
 AliTRDCalibraFillHisto.cxx:2380
 AliTRDCalibraFillHisto.cxx:2381
 AliTRDCalibraFillHisto.cxx:2382
 AliTRDCalibraFillHisto.cxx:2383
 AliTRDCalibraFillHisto.cxx:2384
 AliTRDCalibraFillHisto.cxx:2385
 AliTRDCalibraFillHisto.cxx:2386
 AliTRDCalibraFillHisto.cxx:2387
 AliTRDCalibraFillHisto.cxx:2388
 AliTRDCalibraFillHisto.cxx:2389
 AliTRDCalibraFillHisto.cxx:2390
 AliTRDCalibraFillHisto.cxx:2391
 AliTRDCalibraFillHisto.cxx:2392
 AliTRDCalibraFillHisto.cxx:2393
 AliTRDCalibraFillHisto.cxx:2394
 AliTRDCalibraFillHisto.cxx:2395
 AliTRDCalibraFillHisto.cxx:2396
 AliTRDCalibraFillHisto.cxx:2397
 AliTRDCalibraFillHisto.cxx:2398
 AliTRDCalibraFillHisto.cxx:2399
 AliTRDCalibraFillHisto.cxx:2400
 AliTRDCalibraFillHisto.cxx:2401
 AliTRDCalibraFillHisto.cxx:2402
 AliTRDCalibraFillHisto.cxx:2403
 AliTRDCalibraFillHisto.cxx:2404
 AliTRDCalibraFillHisto.cxx:2405
 AliTRDCalibraFillHisto.cxx:2406
 AliTRDCalibraFillHisto.cxx:2407
 AliTRDCalibraFillHisto.cxx:2408
 AliTRDCalibraFillHisto.cxx:2409
 AliTRDCalibraFillHisto.cxx:2410
 AliTRDCalibraFillHisto.cxx:2411
 AliTRDCalibraFillHisto.cxx:2412
 AliTRDCalibraFillHisto.cxx:2413
 AliTRDCalibraFillHisto.cxx:2414
 AliTRDCalibraFillHisto.cxx:2415
 AliTRDCalibraFillHisto.cxx:2416
 AliTRDCalibraFillHisto.cxx:2417
 AliTRDCalibraFillHisto.cxx:2418
 AliTRDCalibraFillHisto.cxx:2419
 AliTRDCalibraFillHisto.cxx:2420
 AliTRDCalibraFillHisto.cxx:2421
 AliTRDCalibraFillHisto.cxx:2422
 AliTRDCalibraFillHisto.cxx:2423
 AliTRDCalibraFillHisto.cxx:2424
 AliTRDCalibraFillHisto.cxx:2425
 AliTRDCalibraFillHisto.cxx:2426
 AliTRDCalibraFillHisto.cxx:2427
 AliTRDCalibraFillHisto.cxx:2428
 AliTRDCalibraFillHisto.cxx:2429
 AliTRDCalibraFillHisto.cxx:2430
 AliTRDCalibraFillHisto.cxx:2431
 AliTRDCalibraFillHisto.cxx:2432
 AliTRDCalibraFillHisto.cxx:2433
 AliTRDCalibraFillHisto.cxx:2434
 AliTRDCalibraFillHisto.cxx:2435
 AliTRDCalibraFillHisto.cxx:2436
 AliTRDCalibraFillHisto.cxx:2437
 AliTRDCalibraFillHisto.cxx:2438
 AliTRDCalibraFillHisto.cxx:2439
 AliTRDCalibraFillHisto.cxx:2440
 AliTRDCalibraFillHisto.cxx:2441
 AliTRDCalibraFillHisto.cxx:2442
 AliTRDCalibraFillHisto.cxx:2443
 AliTRDCalibraFillHisto.cxx:2444
 AliTRDCalibraFillHisto.cxx:2445
 AliTRDCalibraFillHisto.cxx:2446
 AliTRDCalibraFillHisto.cxx:2447
 AliTRDCalibraFillHisto.cxx:2448
 AliTRDCalibraFillHisto.cxx:2449
 AliTRDCalibraFillHisto.cxx:2450
 AliTRDCalibraFillHisto.cxx:2451
 AliTRDCalibraFillHisto.cxx:2452
 AliTRDCalibraFillHisto.cxx:2453
 AliTRDCalibraFillHisto.cxx:2454
 AliTRDCalibraFillHisto.cxx:2455
 AliTRDCalibraFillHisto.cxx:2456
 AliTRDCalibraFillHisto.cxx:2457
 AliTRDCalibraFillHisto.cxx:2458
 AliTRDCalibraFillHisto.cxx:2459
 AliTRDCalibraFillHisto.cxx:2460
 AliTRDCalibraFillHisto.cxx:2461
 AliTRDCalibraFillHisto.cxx:2462
 AliTRDCalibraFillHisto.cxx:2463
 AliTRDCalibraFillHisto.cxx:2464
 AliTRDCalibraFillHisto.cxx:2465
 AliTRDCalibraFillHisto.cxx:2466
 AliTRDCalibraFillHisto.cxx:2467
 AliTRDCalibraFillHisto.cxx:2468
 AliTRDCalibraFillHisto.cxx:2469
 AliTRDCalibraFillHisto.cxx:2470
 AliTRDCalibraFillHisto.cxx:2471
 AliTRDCalibraFillHisto.cxx:2472
 AliTRDCalibraFillHisto.cxx:2473
 AliTRDCalibraFillHisto.cxx:2474
 AliTRDCalibraFillHisto.cxx:2475
 AliTRDCalibraFillHisto.cxx:2476
 AliTRDCalibraFillHisto.cxx:2477
 AliTRDCalibraFillHisto.cxx:2478
 AliTRDCalibraFillHisto.cxx:2479
 AliTRDCalibraFillHisto.cxx:2480
 AliTRDCalibraFillHisto.cxx:2481
 AliTRDCalibraFillHisto.cxx:2482
 AliTRDCalibraFillHisto.cxx:2483
 AliTRDCalibraFillHisto.cxx:2484
 AliTRDCalibraFillHisto.cxx:2485
 AliTRDCalibraFillHisto.cxx:2486
 AliTRDCalibraFillHisto.cxx:2487
 AliTRDCalibraFillHisto.cxx:2488
 AliTRDCalibraFillHisto.cxx:2489
 AliTRDCalibraFillHisto.cxx:2490
 AliTRDCalibraFillHisto.cxx:2491
 AliTRDCalibraFillHisto.cxx:2492
 AliTRDCalibraFillHisto.cxx:2493
 AliTRDCalibraFillHisto.cxx:2494
 AliTRDCalibraFillHisto.cxx:2495
 AliTRDCalibraFillHisto.cxx:2496
 AliTRDCalibraFillHisto.cxx:2497
 AliTRDCalibraFillHisto.cxx:2498
 AliTRDCalibraFillHisto.cxx:2499
 AliTRDCalibraFillHisto.cxx:2500
 AliTRDCalibraFillHisto.cxx:2501
 AliTRDCalibraFillHisto.cxx:2502
 AliTRDCalibraFillHisto.cxx:2503
 AliTRDCalibraFillHisto.cxx:2504
 AliTRDCalibraFillHisto.cxx:2505
 AliTRDCalibraFillHisto.cxx:2506
 AliTRDCalibraFillHisto.cxx:2507
 AliTRDCalibraFillHisto.cxx:2508
 AliTRDCalibraFillHisto.cxx:2509
 AliTRDCalibraFillHisto.cxx:2510
 AliTRDCalibraFillHisto.cxx:2511
 AliTRDCalibraFillHisto.cxx:2512
 AliTRDCalibraFillHisto.cxx:2513
 AliTRDCalibraFillHisto.cxx:2514
 AliTRDCalibraFillHisto.cxx:2515
 AliTRDCalibraFillHisto.cxx:2516
 AliTRDCalibraFillHisto.cxx:2517
 AliTRDCalibraFillHisto.cxx:2518
 AliTRDCalibraFillHisto.cxx:2519
 AliTRDCalibraFillHisto.cxx:2520
 AliTRDCalibraFillHisto.cxx:2521
 AliTRDCalibraFillHisto.cxx:2522
 AliTRDCalibraFillHisto.cxx:2523
 AliTRDCalibraFillHisto.cxx:2524
 AliTRDCalibraFillHisto.cxx:2525
 AliTRDCalibraFillHisto.cxx:2526
 AliTRDCalibraFillHisto.cxx:2527
 AliTRDCalibraFillHisto.cxx:2528
 AliTRDCalibraFillHisto.cxx:2529
 AliTRDCalibraFillHisto.cxx:2530
 AliTRDCalibraFillHisto.cxx:2531
 AliTRDCalibraFillHisto.cxx:2532
 AliTRDCalibraFillHisto.cxx:2533
 AliTRDCalibraFillHisto.cxx:2534
 AliTRDCalibraFillHisto.cxx:2535
 AliTRDCalibraFillHisto.cxx:2536
 AliTRDCalibraFillHisto.cxx:2537
 AliTRDCalibraFillHisto.cxx:2538
 AliTRDCalibraFillHisto.cxx:2539
 AliTRDCalibraFillHisto.cxx:2540
 AliTRDCalibraFillHisto.cxx:2541
 AliTRDCalibraFillHisto.cxx:2542
 AliTRDCalibraFillHisto.cxx:2543
 AliTRDCalibraFillHisto.cxx:2544
 AliTRDCalibraFillHisto.cxx:2545
 AliTRDCalibraFillHisto.cxx:2546
 AliTRDCalibraFillHisto.cxx:2547
 AliTRDCalibraFillHisto.cxx:2548
 AliTRDCalibraFillHisto.cxx:2549
 AliTRDCalibraFillHisto.cxx:2550
 AliTRDCalibraFillHisto.cxx:2551
 AliTRDCalibraFillHisto.cxx:2552
 AliTRDCalibraFillHisto.cxx:2553
 AliTRDCalibraFillHisto.cxx:2554
 AliTRDCalibraFillHisto.cxx:2555
 AliTRDCalibraFillHisto.cxx:2556
 AliTRDCalibraFillHisto.cxx:2557
 AliTRDCalibraFillHisto.cxx:2558
 AliTRDCalibraFillHisto.cxx:2559
 AliTRDCalibraFillHisto.cxx:2560
 AliTRDCalibraFillHisto.cxx:2561
 AliTRDCalibraFillHisto.cxx:2562
 AliTRDCalibraFillHisto.cxx:2563
 AliTRDCalibraFillHisto.cxx:2564
 AliTRDCalibraFillHisto.cxx:2565
 AliTRDCalibraFillHisto.cxx:2566
 AliTRDCalibraFillHisto.cxx:2567
 AliTRDCalibraFillHisto.cxx:2568
 AliTRDCalibraFillHisto.cxx:2569
 AliTRDCalibraFillHisto.cxx:2570
 AliTRDCalibraFillHisto.cxx:2571
 AliTRDCalibraFillHisto.cxx:2572
 AliTRDCalibraFillHisto.cxx:2573
 AliTRDCalibraFillHisto.cxx:2574
 AliTRDCalibraFillHisto.cxx:2575
 AliTRDCalibraFillHisto.cxx:2576
 AliTRDCalibraFillHisto.cxx:2577
 AliTRDCalibraFillHisto.cxx:2578
 AliTRDCalibraFillHisto.cxx:2579
 AliTRDCalibraFillHisto.cxx:2580
 AliTRDCalibraFillHisto.cxx:2581
 AliTRDCalibraFillHisto.cxx:2582
 AliTRDCalibraFillHisto.cxx:2583
 AliTRDCalibraFillHisto.cxx:2584
 AliTRDCalibraFillHisto.cxx:2585
 AliTRDCalibraFillHisto.cxx:2586
 AliTRDCalibraFillHisto.cxx:2587
 AliTRDCalibraFillHisto.cxx:2588
 AliTRDCalibraFillHisto.cxx:2589
 AliTRDCalibraFillHisto.cxx:2590
 AliTRDCalibraFillHisto.cxx:2591
 AliTRDCalibraFillHisto.cxx:2592
 AliTRDCalibraFillHisto.cxx:2593
 AliTRDCalibraFillHisto.cxx:2594
 AliTRDCalibraFillHisto.cxx:2595
 AliTRDCalibraFillHisto.cxx:2596
 AliTRDCalibraFillHisto.cxx:2597
 AliTRDCalibraFillHisto.cxx:2598
 AliTRDCalibraFillHisto.cxx:2599
 AliTRDCalibraFillHisto.cxx:2600
 AliTRDCalibraFillHisto.cxx:2601
 AliTRDCalibraFillHisto.cxx:2602
 AliTRDCalibraFillHisto.cxx:2603
 AliTRDCalibraFillHisto.cxx:2604
 AliTRDCalibraFillHisto.cxx:2605
 AliTRDCalibraFillHisto.cxx:2606
 AliTRDCalibraFillHisto.cxx:2607
 AliTRDCalibraFillHisto.cxx:2608
 AliTRDCalibraFillHisto.cxx:2609
 AliTRDCalibraFillHisto.cxx:2610
 AliTRDCalibraFillHisto.cxx:2611
 AliTRDCalibraFillHisto.cxx:2612
 AliTRDCalibraFillHisto.cxx:2613
 AliTRDCalibraFillHisto.cxx:2614
 AliTRDCalibraFillHisto.cxx:2615
 AliTRDCalibraFillHisto.cxx:2616
 AliTRDCalibraFillHisto.cxx:2617
 AliTRDCalibraFillHisto.cxx:2618
 AliTRDCalibraFillHisto.cxx:2619
 AliTRDCalibraFillHisto.cxx:2620
 AliTRDCalibraFillHisto.cxx:2621
 AliTRDCalibraFillHisto.cxx:2622
 AliTRDCalibraFillHisto.cxx:2623
 AliTRDCalibraFillHisto.cxx:2624
 AliTRDCalibraFillHisto.cxx:2625
 AliTRDCalibraFillHisto.cxx:2626
 AliTRDCalibraFillHisto.cxx:2627
 AliTRDCalibraFillHisto.cxx:2628
 AliTRDCalibraFillHisto.cxx:2629
 AliTRDCalibraFillHisto.cxx:2630
 AliTRDCalibraFillHisto.cxx:2631
 AliTRDCalibraFillHisto.cxx:2632
 AliTRDCalibraFillHisto.cxx:2633
 AliTRDCalibraFillHisto.cxx:2634
 AliTRDCalibraFillHisto.cxx:2635
 AliTRDCalibraFillHisto.cxx:2636
 AliTRDCalibraFillHisto.cxx:2637
 AliTRDCalibraFillHisto.cxx:2638
 AliTRDCalibraFillHisto.cxx:2639
 AliTRDCalibraFillHisto.cxx:2640
 AliTRDCalibraFillHisto.cxx:2641
 AliTRDCalibraFillHisto.cxx:2642
 AliTRDCalibraFillHisto.cxx:2643
 AliTRDCalibraFillHisto.cxx:2644
 AliTRDCalibraFillHisto.cxx:2645
 AliTRDCalibraFillHisto.cxx:2646
 AliTRDCalibraFillHisto.cxx:2647
 AliTRDCalibraFillHisto.cxx:2648
 AliTRDCalibraFillHisto.cxx:2649
 AliTRDCalibraFillHisto.cxx:2650
 AliTRDCalibraFillHisto.cxx:2651
 AliTRDCalibraFillHisto.cxx:2652
 AliTRDCalibraFillHisto.cxx:2653
 AliTRDCalibraFillHisto.cxx:2654
 AliTRDCalibraFillHisto.cxx:2655
 AliTRDCalibraFillHisto.cxx:2656
 AliTRDCalibraFillHisto.cxx:2657
 AliTRDCalibraFillHisto.cxx:2658
 AliTRDCalibraFillHisto.cxx:2659
 AliTRDCalibraFillHisto.cxx:2660
 AliTRDCalibraFillHisto.cxx:2661
 AliTRDCalibraFillHisto.cxx:2662
 AliTRDCalibraFillHisto.cxx:2663
 AliTRDCalibraFillHisto.cxx:2664
 AliTRDCalibraFillHisto.cxx:2665
 AliTRDCalibraFillHisto.cxx:2666
 AliTRDCalibraFillHisto.cxx:2667
 AliTRDCalibraFillHisto.cxx:2668
 AliTRDCalibraFillHisto.cxx:2669
 AliTRDCalibraFillHisto.cxx:2670
 AliTRDCalibraFillHisto.cxx:2671
 AliTRDCalibraFillHisto.cxx:2672
 AliTRDCalibraFillHisto.cxx:2673
 AliTRDCalibraFillHisto.cxx:2674
 AliTRDCalibraFillHisto.cxx:2675
 AliTRDCalibraFillHisto.cxx:2676
 AliTRDCalibraFillHisto.cxx:2677
 AliTRDCalibraFillHisto.cxx:2678
 AliTRDCalibraFillHisto.cxx:2679
 AliTRDCalibraFillHisto.cxx:2680
 AliTRDCalibraFillHisto.cxx:2681
 AliTRDCalibraFillHisto.cxx:2682
 AliTRDCalibraFillHisto.cxx:2683
 AliTRDCalibraFillHisto.cxx:2684
 AliTRDCalibraFillHisto.cxx:2685
 AliTRDCalibraFillHisto.cxx:2686
 AliTRDCalibraFillHisto.cxx:2687
 AliTRDCalibraFillHisto.cxx:2688
 AliTRDCalibraFillHisto.cxx:2689
 AliTRDCalibraFillHisto.cxx:2690
 AliTRDCalibraFillHisto.cxx:2691
 AliTRDCalibraFillHisto.cxx:2692
 AliTRDCalibraFillHisto.cxx:2693
 AliTRDCalibraFillHisto.cxx:2694
 AliTRDCalibraFillHisto.cxx:2695
 AliTRDCalibraFillHisto.cxx:2696
 AliTRDCalibraFillHisto.cxx:2697
 AliTRDCalibraFillHisto.cxx:2698
 AliTRDCalibraFillHisto.cxx:2699
 AliTRDCalibraFillHisto.cxx:2700
 AliTRDCalibraFillHisto.cxx:2701
 AliTRDCalibraFillHisto.cxx:2702
 AliTRDCalibraFillHisto.cxx:2703
 AliTRDCalibraFillHisto.cxx:2704
 AliTRDCalibraFillHisto.cxx:2705
 AliTRDCalibraFillHisto.cxx:2706
 AliTRDCalibraFillHisto.cxx:2707
 AliTRDCalibraFillHisto.cxx:2708
 AliTRDCalibraFillHisto.cxx:2709
 AliTRDCalibraFillHisto.cxx:2710
 AliTRDCalibraFillHisto.cxx:2711
 AliTRDCalibraFillHisto.cxx:2712
 AliTRDCalibraFillHisto.cxx:2713
 AliTRDCalibraFillHisto.cxx:2714
 AliTRDCalibraFillHisto.cxx:2715
 AliTRDCalibraFillHisto.cxx:2716
 AliTRDCalibraFillHisto.cxx:2717
 AliTRDCalibraFillHisto.cxx:2718
 AliTRDCalibraFillHisto.cxx:2719
 AliTRDCalibraFillHisto.cxx:2720
 AliTRDCalibraFillHisto.cxx:2721
 AliTRDCalibraFillHisto.cxx:2722
 AliTRDCalibraFillHisto.cxx:2723
 AliTRDCalibraFillHisto.cxx:2724
 AliTRDCalibraFillHisto.cxx:2725
 AliTRDCalibraFillHisto.cxx:2726
 AliTRDCalibraFillHisto.cxx:2727
 AliTRDCalibraFillHisto.cxx:2728
 AliTRDCalibraFillHisto.cxx:2729
 AliTRDCalibraFillHisto.cxx:2730
 AliTRDCalibraFillHisto.cxx:2731
 AliTRDCalibraFillHisto.cxx:2732
 AliTRDCalibraFillHisto.cxx:2733
 AliTRDCalibraFillHisto.cxx:2734
 AliTRDCalibraFillHisto.cxx:2735
 AliTRDCalibraFillHisto.cxx:2736
 AliTRDCalibraFillHisto.cxx:2737
 AliTRDCalibraFillHisto.cxx:2738
 AliTRDCalibraFillHisto.cxx:2739
 AliTRDCalibraFillHisto.cxx:2740
 AliTRDCalibraFillHisto.cxx:2741
 AliTRDCalibraFillHisto.cxx:2742
 AliTRDCalibraFillHisto.cxx:2743
 AliTRDCalibraFillHisto.cxx:2744
 AliTRDCalibraFillHisto.cxx:2745
 AliTRDCalibraFillHisto.cxx:2746
 AliTRDCalibraFillHisto.cxx:2747
 AliTRDCalibraFillHisto.cxx:2748
 AliTRDCalibraFillHisto.cxx:2749
 AliTRDCalibraFillHisto.cxx:2750
 AliTRDCalibraFillHisto.cxx:2751
 AliTRDCalibraFillHisto.cxx:2752
 AliTRDCalibraFillHisto.cxx:2753
 AliTRDCalibraFillHisto.cxx:2754
 AliTRDCalibraFillHisto.cxx:2755
 AliTRDCalibraFillHisto.cxx:2756
 AliTRDCalibraFillHisto.cxx:2757
 AliTRDCalibraFillHisto.cxx:2758
 AliTRDCalibraFillHisto.cxx:2759
 AliTRDCalibraFillHisto.cxx:2760
 AliTRDCalibraFillHisto.cxx:2761
 AliTRDCalibraFillHisto.cxx:2762
 AliTRDCalibraFillHisto.cxx:2763
 AliTRDCalibraFillHisto.cxx:2764
 AliTRDCalibraFillHisto.cxx:2765
 AliTRDCalibraFillHisto.cxx:2766
 AliTRDCalibraFillHisto.cxx:2767
 AliTRDCalibraFillHisto.cxx:2768
 AliTRDCalibraFillHisto.cxx:2769
 AliTRDCalibraFillHisto.cxx:2770
 AliTRDCalibraFillHisto.cxx:2771
 AliTRDCalibraFillHisto.cxx:2772
 AliTRDCalibraFillHisto.cxx:2773
 AliTRDCalibraFillHisto.cxx:2774
 AliTRDCalibraFillHisto.cxx:2775
 AliTRDCalibraFillHisto.cxx:2776
 AliTRDCalibraFillHisto.cxx:2777
 AliTRDCalibraFillHisto.cxx:2778
 AliTRDCalibraFillHisto.cxx:2779
 AliTRDCalibraFillHisto.cxx:2780
 AliTRDCalibraFillHisto.cxx:2781
 AliTRDCalibraFillHisto.cxx:2782
 AliTRDCalibraFillHisto.cxx:2783
 AliTRDCalibraFillHisto.cxx:2784
 AliTRDCalibraFillHisto.cxx:2785
 AliTRDCalibraFillHisto.cxx:2786
 AliTRDCalibraFillHisto.cxx:2787
 AliTRDCalibraFillHisto.cxx:2788
 AliTRDCalibraFillHisto.cxx:2789
 AliTRDCalibraFillHisto.cxx:2790
 AliTRDCalibraFillHisto.cxx:2791
 AliTRDCalibraFillHisto.cxx:2792
 AliTRDCalibraFillHisto.cxx:2793
 AliTRDCalibraFillHisto.cxx:2794
 AliTRDCalibraFillHisto.cxx:2795
 AliTRDCalibraFillHisto.cxx:2796
 AliTRDCalibraFillHisto.cxx:2797
 AliTRDCalibraFillHisto.cxx:2798
 AliTRDCalibraFillHisto.cxx:2799
 AliTRDCalibraFillHisto.cxx:2800
 AliTRDCalibraFillHisto.cxx:2801
 AliTRDCalibraFillHisto.cxx:2802
 AliTRDCalibraFillHisto.cxx:2803
 AliTRDCalibraFillHisto.cxx:2804
 AliTRDCalibraFillHisto.cxx:2805
 AliTRDCalibraFillHisto.cxx:2806
 AliTRDCalibraFillHisto.cxx:2807
 AliTRDCalibraFillHisto.cxx:2808
 AliTRDCalibraFillHisto.cxx:2809
 AliTRDCalibraFillHisto.cxx:2810
 AliTRDCalibraFillHisto.cxx:2811
 AliTRDCalibraFillHisto.cxx:2812
 AliTRDCalibraFillHisto.cxx:2813
 AliTRDCalibraFillHisto.cxx:2814
 AliTRDCalibraFillHisto.cxx:2815
 AliTRDCalibraFillHisto.cxx:2816
 AliTRDCalibraFillHisto.cxx:2817
 AliTRDCalibraFillHisto.cxx:2818
 AliTRDCalibraFillHisto.cxx:2819
 AliTRDCalibraFillHisto.cxx:2820
 AliTRDCalibraFillHisto.cxx:2821
 AliTRDCalibraFillHisto.cxx:2822
 AliTRDCalibraFillHisto.cxx:2823
 AliTRDCalibraFillHisto.cxx:2824
 AliTRDCalibraFillHisto.cxx:2825
 AliTRDCalibraFillHisto.cxx:2826
 AliTRDCalibraFillHisto.cxx:2827
 AliTRDCalibraFillHisto.cxx:2828
 AliTRDCalibraFillHisto.cxx:2829
 AliTRDCalibraFillHisto.cxx:2830
 AliTRDCalibraFillHisto.cxx:2831
 AliTRDCalibraFillHisto.cxx:2832
 AliTRDCalibraFillHisto.cxx:2833
 AliTRDCalibraFillHisto.cxx:2834
 AliTRDCalibraFillHisto.cxx:2835
 AliTRDCalibraFillHisto.cxx:2836
 AliTRDCalibraFillHisto.cxx:2837
 AliTRDCalibraFillHisto.cxx:2838
 AliTRDCalibraFillHisto.cxx:2839
 AliTRDCalibraFillHisto.cxx:2840
 AliTRDCalibraFillHisto.cxx:2841
 AliTRDCalibraFillHisto.cxx:2842
 AliTRDCalibraFillHisto.cxx:2843
 AliTRDCalibraFillHisto.cxx:2844
 AliTRDCalibraFillHisto.cxx:2845
 AliTRDCalibraFillHisto.cxx:2846
 AliTRDCalibraFillHisto.cxx:2847
 AliTRDCalibraFillHisto.cxx:2848
 AliTRDCalibraFillHisto.cxx:2849
 AliTRDCalibraFillHisto.cxx:2850
 AliTRDCalibraFillHisto.cxx:2851
 AliTRDCalibraFillHisto.cxx:2852
 AliTRDCalibraFillHisto.cxx:2853
 AliTRDCalibraFillHisto.cxx:2854
 AliTRDCalibraFillHisto.cxx:2855
 AliTRDCalibraFillHisto.cxx:2856
 AliTRDCalibraFillHisto.cxx:2857
 AliTRDCalibraFillHisto.cxx:2858
 AliTRDCalibraFillHisto.cxx:2859
 AliTRDCalibraFillHisto.cxx:2860
 AliTRDCalibraFillHisto.cxx:2861
 AliTRDCalibraFillHisto.cxx:2862
 AliTRDCalibraFillHisto.cxx:2863
 AliTRDCalibraFillHisto.cxx:2864
 AliTRDCalibraFillHisto.cxx:2865
 AliTRDCalibraFillHisto.cxx:2866
 AliTRDCalibraFillHisto.cxx:2867
 AliTRDCalibraFillHisto.cxx:2868
 AliTRDCalibraFillHisto.cxx:2869
 AliTRDCalibraFillHisto.cxx:2870
 AliTRDCalibraFillHisto.cxx:2871
 AliTRDCalibraFillHisto.cxx:2872
 AliTRDCalibraFillHisto.cxx:2873
 AliTRDCalibraFillHisto.cxx:2874
 AliTRDCalibraFillHisto.cxx:2875
 AliTRDCalibraFillHisto.cxx:2876
 AliTRDCalibraFillHisto.cxx:2877
 AliTRDCalibraFillHisto.cxx:2878
 AliTRDCalibraFillHisto.cxx:2879
 AliTRDCalibraFillHisto.cxx:2880
 AliTRDCalibraFillHisto.cxx:2881
 AliTRDCalibraFillHisto.cxx:2882
 AliTRDCalibraFillHisto.cxx:2883
 AliTRDCalibraFillHisto.cxx:2884
 AliTRDCalibraFillHisto.cxx:2885
 AliTRDCalibraFillHisto.cxx:2886
 AliTRDCalibraFillHisto.cxx:2887
 AliTRDCalibraFillHisto.cxx:2888
 AliTRDCalibraFillHisto.cxx:2889
 AliTRDCalibraFillHisto.cxx:2890
 AliTRDCalibraFillHisto.cxx:2891
 AliTRDCalibraFillHisto.cxx:2892
 AliTRDCalibraFillHisto.cxx:2893
 AliTRDCalibraFillHisto.cxx:2894
 AliTRDCalibraFillHisto.cxx:2895
 AliTRDCalibraFillHisto.cxx:2896
 AliTRDCalibraFillHisto.cxx:2897
 AliTRDCalibraFillHisto.cxx:2898
 AliTRDCalibraFillHisto.cxx:2899
 AliTRDCalibraFillHisto.cxx:2900
 AliTRDCalibraFillHisto.cxx:2901
 AliTRDCalibraFillHisto.cxx:2902
 AliTRDCalibraFillHisto.cxx:2903
 AliTRDCalibraFillHisto.cxx:2904
 AliTRDCalibraFillHisto.cxx:2905
 AliTRDCalibraFillHisto.cxx:2906
 AliTRDCalibraFillHisto.cxx:2907
 AliTRDCalibraFillHisto.cxx:2908
 AliTRDCalibraFillHisto.cxx:2909
 AliTRDCalibraFillHisto.cxx:2910
 AliTRDCalibraFillHisto.cxx:2911
 AliTRDCalibraFillHisto.cxx:2912
 AliTRDCalibraFillHisto.cxx:2913
 AliTRDCalibraFillHisto.cxx:2914
 AliTRDCalibraFillHisto.cxx:2915
 AliTRDCalibraFillHisto.cxx:2916
 AliTRDCalibraFillHisto.cxx:2917
 AliTRDCalibraFillHisto.cxx:2918
 AliTRDCalibraFillHisto.cxx:2919
 AliTRDCalibraFillHisto.cxx:2920
 AliTRDCalibraFillHisto.cxx:2921
 AliTRDCalibraFillHisto.cxx:2922
 AliTRDCalibraFillHisto.cxx:2923
 AliTRDCalibraFillHisto.cxx:2924
 AliTRDCalibraFillHisto.cxx:2925
 AliTRDCalibraFillHisto.cxx:2926
 AliTRDCalibraFillHisto.cxx:2927