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

////////////////////////////////////////////////////////////////////////////////////////
//                                                                                    //
//             Implementation of the TPC Central Electrode calibration                //
//                                                                                    //
//   Origin: Jens Wiechula, Marian Ivanov   J.Wiechula@gsi.de, Marian.Ivanov@cern.ch  //
//                                                                                    //
////////////////////////////////////////////////////////////////////////////////////////
//
//
// *************************************************************************************
// *                                Class Description                                  *
// *************************************************************************************
//
/* BEGIN_HTML
 <h4>The AliTPCCalibCE class is used to get calibration data from the Central Electrode
 using laser runs.</h4>

 The information retrieved is
 <ul style="list-style-type: square;">
   <li>Time arrival from the CE</li>
   <li>Signal width</li>
   <li>Signal sum</li>
 </ul>

<h4>Overview:</h4>
 <ol style="list-style-type: upper-roman;">
   <li><a href="#working">Working principle</a></li>
   <li><a href="#user">User interface for filling data</a></li>
   <li><a href="#info">Stored information</a></li>
 </ol>

 <h3><a name="working">I. Working principle</a></h3>

 <h4>Raw laser data is processed by calling one of the ProcessEvent(...) functions
 (see below). These in the end call the Update(...) function.</h4>

 <ul style="list-style-type: square;">
   <li>the Update(...) function:<br />
       In this function the array fPadSignal is filled with the adc signals between the specified range
       fFirstTimeBin and fLastTimeBin for the current pad.
       before going to the next pad the ProcessPad() function is called, which analyses the data for one pad
       stored in fPadSignal.
   </li>
   <ul style="list-style-type: square;">
   <li>the ProcessPad() function:</li>
   <ol style="list-style-type: decimal;">
     <li>Find Pedestal and Noise information</li>
     <ul style="list-style-type: square;">
       <li>use database information which has to be set by calling<br />
           SetPedestalDatabase(AliTPCCalPad *pedestalTPC, AliTPCCalPad *padNoiseTPC)</li>
       <li>if no information from the pedestal data base
           is available the informaion is calculated on the fly
           ( see FindPedestal() function )</li>
     </ul>
     <li>Find local maxima of the pad signal</li>
     <ul style="list-style-type: square;">
       <li>maxima arise from the laser tracks, the CE and also periodic postpeaks after the CE signal have
       have been observed ( see FindLocalMaxima(...) )</li>
     </ul>
     <li>Find the CE signal information</li>
     <ul style="list-style-type: square;">
       <li>to find the position of the CE signal the Tmean information from the previos event is used
           as the CE signal the local maximum closest to this Tmean is identified</li>
       <li>calculate  mean = T0, RMS = signal width and Q sum in a range of -4+7 timebins around Q max position
           the Q sum is scaled by pad area (see FindPulserSignal(...) function)</li>
     </ul>
     <li>Fill a temprary array for the T0 information (GetPadTimesEvent(fCurrentSector,kTRUE)) (why see below)</li>
     <li>Fill the Q sum and RMS values in the histograms (GetHisto[RMS,Q](ROC,kTRUE))</li>
     </ol>
   </ul>
 </ul>

 <h4>At the end of each event the EndEvent() function is called</h4>

 <ul style="list-style-type: square;">
   <li>the EndEvent() function:</li>
   <ul style="list-style-type: square;">
     <li>calculate the mean T0 for side A and side C. Fill T0 histogram with Time0-<Time0 for side[A,C]>
         This is done to overcome syncronisation problems between the trigger and the fec clock.</li>
     <li>calculate Mean T for each ROC using the COG aroud the median of the LocalMaxima distribution in one sector</li>
     <li>calculate Mean Q</li>
     <li>calculate Global fit parameters for Pol1 and Pol2 fits</li>
   </ul>
 </ul>

 <h4>After accumulating the desired statistics the Analyse() function has to be called.</h4>
  <ul style="list-style-type: square;">
  <li>the Analyse() function:</li>
    <ul style="list-style-type: square;">
      <li>calculate the mean values of T0, RMS, Q for each pad, using
          the AliMathBase::GetCOG(...) function</li>
      <li>fill the calibration storage classes (AliTPCCalROC) for each ROC</li>
         (The calibration information is stored in the TObjArrays fCalRocArrayT0, fCalRocArrayRMS and fCalRocArrayQ</li>
    </ul>
  </ul>

 <h3><a name="user">II. User interface for filling data</a></h3>

 <h4>To Fill information one of the following functions can be used:</h4>

 <ul style="list-style-type: none;">
  <li> Bool_t ProcessEvent(eventHeaderStruct *event);</li>
    <ul style="list-style-type: square;">
      <li>process Date event</li>
      <li>use AliTPCRawReaderDate and call ProcessEvent(AliRawReader *rawReader)</li>
    </ul>
    <br />

  <li> Bool_t ProcessEvent(AliRawReader *rawReader);</li>
    <ul style="list-style-type: square;">
      <li>process AliRawReader event</li>
      <li>use AliTPCRawStream to loop over data and call ProcessEvent(AliTPCRawStream *rawStream)</li>
    </ul>
    <br />

  <li> Bool_t ProcessEvent(AliTPCRawStream *rawStream);</li>
    <ul style="list-style-type: square;">
      <li>process event from AliTPCRawStream</li>
      <li>call Update function for signal filling</li>
    </ul>
    <br />

  <li> Int_t Update(const Int_t isector, const Int_t iRow, const Int_t
              iPad,  const Int_t iTimeBin, const Float_t signal);</li>
    <ul style="list-style-type: square;">
      <li>directly  fill signal information (sector, row, pad, time bin, pad)
          to the reference histograms</li>
    </ul>
 </ul>

 <h4>It is also possible to merge two independently taken calibrations using the function</h4>

 <ul style="list-style-type: none;">
  <li> void Merge(AliTPCCalibSignal *sig)</li>
    <ul style="list-style-type: square;">
      <li>copy histograms in 'sig' if they do not exist in this instance</li>
      <li>Add histograms in 'sig' to the histograms in this instance if the allready exist</li>
      <li>After merging call Analyse again!</li>
    </ul>
 </ul>


 <h4>example: filling data using root raw data:</h4>
 <pre> 
 void fillCE(Char_t *filename)
 {
    rawReader = new AliRawReaderRoot(fileName);
    if ( !rawReader ) return;
    AliTPCCalibCE *calib = new AliTPCCalibCE;
    while (rawReader->NextEvent()){
      calib->ProcessEvent(rawReader);
    }
    calib->Analyse();
    calib->DumpToFile("CEData.root");
    delete rawReader;
    delete calib;
 }
 </pre>

 <h3><a name="info">III. What kind of information is stored and how to retrieve it</a></h4>

 <h4><a name="info:stored">III.1 Stored information</a></h4>
 <ul style="list-style-type: none;">
  <li>Histograms:</li>
  <ul style="list-style-type: none;">
    <li>For each ROC three TH2S histos 'Reference Histograms'  (ROC channel vs. [Time0, signal width, Q sum])
        is created when it is filled for the first time (GetHisto[T0,RMS,Q](ROC,kTRUE)). The histos are
        stored in the TObjArrays fHistoT0Array, fHistoRMSArray and fHistoQArray.</li>
  </ul>
  <br />

 <li>Calibration Data:</li>
 <ul style="list-style-type: none;">
      <li>For each ROC three types of calibration data (AliTPCCalROC) is stored: for the mean arrival Time,
          the signal width and the signal Sum. The AliTPCCalROC objects are stored in the TObjArrays
          fCalRocArrayT0, fCalRocArrayRMS , fCalRocArrayQ. The object for each roc is created the first time it
          is accessed (GetCalRoc[T0,RMS,Q](ROC,kTRUE));</li>
 </ul>
 <br />

 <li>For each event the following information is stored:</li>
   
 <ul style="list-style-type: square;">
   <li>event time ( TVectorD  fVEventTime )</li>
   <li>event id   ( TVectorD  fVEventNumber )</li>
   <br />
   <li>mean arrival time for each ROC                ( TObjArray fTMeanArrayEvent )</li>
   <li>mean Q for each ROC                           ( TObjArray fQMeanArrayEvent )</li>
   <li>parameters of a plane fit for each ROC        ( TObjArray fParamArrayEventPol1 )</li>
   <li>parameters of a 2D parabola fit for each ROC  ( TObjArray fParamArrayEventPol2 )</li>
  </ul>
 </ul>

 <h4><a name="info:retrieve">III.2 Retrieving information</a></h4>
 <ul style="list-style-type: none;">
  <li>Accessing the 'Reference Histograms' (Time0, signal width and Q sum information pad by pad):</li>
    <ul style="list-style-type: square;">
      <li>TH2F *GetHistoT0(Int_t sector);</li>
      <li>TH2F *GetHistoRMS(Int_t sector);</li>
      <li>TH2F *GetHistoQ(Int_t sector);</li>
    </ul>
    <br />
    
  <li>Accessing the calibration storage objects:</li>
    <ul style="list-style-type: square;">
      <li>AliTPCCalROC *GetCalRocT0(Int_t sector);   // for the Time0 values</li>
      <li>AliTPCCalROC *GetCalRocRMS(Int_t sector);  // for the signal width values</li>
      <li>AliTPCCalROC *GetCalRocQ(Int_t sector);    // for the Q sum values</li>
    </ul>
    <br />

  <li>Accessin the event by event information:</li>
    <ul style="list-style-type: square;">
      <li>The event by event information can be displayed using the</li>
      <li>MakeGraphTimeCE(Int_t sector, Int_t xVariable, Int_t fitType, Int_t fitParameter)</li>
      <li>which creates a graph from the specified variables</li>
    </ul>
  </ul>
  
  <h4>example for visualisation:</h4>
  <pre>
  //if the file "CEData.root" was created using the above example one could do the following:
  TFile fileCE("CEData.root")
  AliTPCCalibCE *ce = (AliTPCCalibCE*)fileCE->Get("AliTPCCalibCE");
  ce->GetCalRocT0(0)->Draw("colz");
  ce->GetCalRocRMS(0)->Draw("colz");

  //or use the AliTPCCalPad functionality:
  AliTPCCalPad padT0(ped->GetCalPadT0());
  AliTPCCalPad padSigWidth(ped->GetCalPadRMS());
  padT0->MakeHisto2D()->Draw("colz");       //Draw A-Side Time0 Information
  padSigWidth->MakeHisto2D()->Draw("colz"); //Draw A-Side signal width Information

  //display event by event information:
  //Draw mean arrival time as a function of the event time for oroc sector A00
  ce->MakeGraphTimeCE(36, 0, 2)->Draw("alp");
  //Draw first derivative in local x from a plane fit as a function of the event time for oroc sector A00
  ce->MakeGraphTimeCE(36, 0, 0, 1)->Draw("alp");  
  </pre>
END_HTML */
//////////////////////////////////////////////////////////////////////////////////////


//Root includes
#include <TObjArray.h>
#include <TH1.h>
#include <TH1F.h>
#include <TH2S.h>
#include <TF1.h>
#include <TString.h>
#include <TVectorF.h>
#include <TVectorD.h>
#include <TVector3.h>
#include <TMatrixD.h>
#include <TMath.h>
#include <TGraph.h>
#include <TGraphErrors.h>
#include <TString.h>
#include <TMap.h>
#include <TDirectory.h>
#include <TSystem.h>
#include <TFile.h>
#include <TCollection.h>
#include <TTimeStamp.h>
#include <TList.h>
#include <TKey.h>
#include <TSpectrum.h>

//AliRoot includes
#include "AliLog.h"
#include "AliRawReader.h"
#include "AliRawReaderRoot.h"
#include "AliRawReaderDate.h"
#include "AliRawEventHeaderBase.h"
#include "AliTPCCalROC.h"
#include "AliTPCCalPad.h"
#include "AliTPCROC.h"
#include "AliTPCParam.h"
#include "AliTPCCalibCE.h"
#include "AliMathBase.h"
#include "AliTPCTransform.h"
#include "AliTPCLaserTrack.h"
#include "TTreeStream.h"

#include "AliCDBManager.h"
#include "AliCDBEntry.h"
//date
#include "event.h"
ClassImp(AliTPCCalibCE)


AliTPCCalibCE::AliTPCCalibCE() :
  AliTPCCalibRawBase(),
  fNbinsT0(200),
  fXminT0(-5),
  fXmaxT0(5),
  fNbinsQ(200),
  fXminQ(1),
  fXmaxQ(40),
  fNbinsRMS(100),
  fXminRMS(0.1),
  fXmaxRMS(5.1),
  fPeakDetMinus(2),
  fPeakDetPlus(3),
  fPeakIntMinus(2),
  fPeakIntPlus(2),
  fNoiseThresholdMax(5.),
  fNoiseThresholdSum(8.),
  fIsZeroSuppressed(kFALSE),
  fLastSector(-1),
  fSecRejectRatio(.4),
  fParam(new AliTPCParam),
  fPedestalTPC(0x0),
  fPadNoiseTPC(0x0),
  fPedestalROC(0x0),
  fPadNoiseROC(0x0),
  fCalRocArrayT0(72),
  fCalRocArrayT0Err(72),
  fCalRocArrayQ(72),
  fCalRocArrayRMS(72),
  fCalRocArrayOutliers(72),
  fHistoQArray(72),
  fHistoT0Array(72),
  fHistoRMSArray(72),
  fMeanT0rms(0),
  fMeanQrms(0),
  fMeanRMSrms(0),
  fHistoTmean(72),
  fParamArrayEventPol1(72),
  fParamArrayEventPol2(72),
  fTMeanArrayEvent(72),
  fQMeanArrayEvent(72),
  fVEventTime(1000),
  fVEventNumber(1000),
  fVTime0SideA(1000),
  fVTime0SideC(1000),
  fEventId(-1),
  fOldRunNumber(0),
  fPadTimesArrayEvent(72),
  fPadQArrayEvent(72),
  fPadRMSArrayEvent(72),
  fPadPedestalArrayEvent(72),
  fCurrentChannel(-1),
  fCurrentSector(-1),
  fCurrentRow(-1),
  fMaxPadSignal(-1),
  fMaxTimeBin(-1),
//   fPadSignal(1024),
  fPadPedestal(0),
  fPadNoise(0),
  fVTime0Offset(72),
  fVTime0OffsetCounter(72),
  fVMeanQ(72),
  fVMeanQCounter(72),
  fCurrentCETimeRef(0),
  fProcessOld(kTRUE),
  fProcessNew(kFALSE),
  fAnalyseNew(kTRUE),
  fHnDrift(0x0),
  fArrHnDrift(100),
  fTimeBursts(100),
  fArrFitGraphs(0x0),
  fEventInBunch(0)
{
  //
  // AliTPCSignal default constructor
  //
  SetNameTitle("AliTPCCalibCE","AliTPCCalibCE");
  fFirstTimeBin=650;
  fLastTimeBin=1030;
  fParam->Update();
  for (Int_t i=0;i<1024;++i) fPadSignal[i]=0;
  for (Int_t i=0;i<14;++i){
    fPeaks[i]=0;
    fPeakWidths[i]=0;
  }
  for (Int_t i=0; i<100; ++i) fBinsLastAna[i]=0;
}
//_____________________________________________________________________
AliTPCCalibCE::AliTPCCalibCE(const AliTPCCalibCE &sig) :
  AliTPCCalibRawBase(sig),
  fNbinsT0(sig.fNbinsT0),
  fXminT0(sig.fXminT0),
  fXmaxT0(sig.fXmaxT0),
  fNbinsQ(sig.fNbinsQ),
  fXminQ(sig.fXminQ),
  fXmaxQ(sig.fXmaxQ),
  fNbinsRMS(sig.fNbinsRMS),
  fXminRMS(sig.fXminRMS),
  fXmaxRMS(sig.fXmaxRMS),
  fPeakDetMinus(sig.fPeakDetMinus),
  fPeakDetPlus(sig.fPeakDetPlus),
  fPeakIntMinus(sig.fPeakIntMinus),
  fPeakIntPlus(sig.fPeakIntPlus),
  fNoiseThresholdMax(sig.fNoiseThresholdMax),
  fNoiseThresholdSum(sig.fNoiseThresholdSum),
  fIsZeroSuppressed(sig.fIsZeroSuppressed),
  fLastSector(-1),
  fSecRejectRatio(.4),
  fParam(new AliTPCParam),
  fPedestalTPC(0x0),
  fPadNoiseTPC(0x0),
  fPedestalROC(0x0),
  fPadNoiseROC(0x0),
  fCalRocArrayT0(72),
  fCalRocArrayT0Err(72),
  fCalRocArrayQ(72),
  fCalRocArrayRMS(72),
  fCalRocArrayOutliers(72),
  fHistoQArray(72),
  fHistoT0Array(72),
  fHistoRMSArray(72),
  fMeanT0rms(sig.fMeanT0rms),
  fMeanQrms(sig.fMeanQrms),
  fMeanRMSrms(sig.fMeanRMSrms),
  fHistoTmean(72),
  fParamArrayEventPol1(72),
  fParamArrayEventPol2(72),
  fTMeanArrayEvent(72),
  fQMeanArrayEvent(72),
  fVEventTime(sig.fVEventTime),
  fVEventNumber(sig.fVEventNumber),
  fVTime0SideA(sig.fVTime0SideA),
  fVTime0SideC(sig.fVTime0SideC),
  fEventId(-1),
  fOldRunNumber(0),
  fPadTimesArrayEvent(72),
  fPadQArrayEvent(72),
  fPadRMSArrayEvent(72),
  fPadPedestalArrayEvent(72),
  fCurrentChannel(-1),
  fCurrentSector(-1),
  fCurrentRow(-1),
  fMaxPadSignal(-1),
  fMaxTimeBin(-1),
//   fPadSignal(1024),
  fPadPedestal(0),
  fPadNoise(0),
  fVTime0Offset(72),
  fVTime0OffsetCounter(72),
  fVMeanQ(72),
  fVMeanQCounter(72),
  fCurrentCETimeRef(0),
  fProcessOld(sig.fProcessOld),
  fProcessNew(sig.fProcessNew),
  fAnalyseNew(sig.fAnalyseNew),
  fHnDrift(0x0),
  fArrHnDrift(100),
  fTimeBursts(100),
  fArrFitGraphs(0x0),
  fEventInBunch(0)
{
  //
  // AliTPCSignal copy constructor
  //
  for (Int_t i=0;i<1024;++i) fPadSignal[i]=0;
  
  for (Int_t iSec = 0; iSec < 72; ++iSec){
    const AliTPCCalROC *calQ   = (AliTPCCalROC*)sig.fCalRocArrayQ.UncheckedAt(iSec);
    const AliTPCCalROC *calT0  = (AliTPCCalROC*)sig.fCalRocArrayT0.UncheckedAt(iSec);
    const AliTPCCalROC *calRMS = (AliTPCCalROC*)sig.fCalRocArrayRMS.UncheckedAt(iSec);
    const AliTPCCalROC *calOut = (AliTPCCalROC*)sig.fCalRocArrayOutliers.UncheckedAt(iSec);

    const TH2S *hQ   = (TH2S*)sig.fHistoQArray.UncheckedAt(iSec);
    const TH2S *hT0  = (TH2S*)sig.fHistoT0Array.UncheckedAt(iSec);
    const TH2S *hRMS = (TH2S*)sig.fHistoRMSArray.UncheckedAt(iSec);

    if ( calQ   != 0x0 ) fCalRocArrayQ.AddAt(new AliTPCCalROC(*calQ), iSec);
    if ( calT0  != 0x0 ) fCalRocArrayT0.AddAt(new AliTPCCalROC(*calT0), iSec);
    if ( calRMS != 0x0 ) fCalRocArrayRMS.AddAt(new AliTPCCalROC(*calRMS), iSec);
    if ( calOut != 0x0 ) fCalRocArrayOutliers.AddAt(new AliTPCCalROC(*calOut), iSec);

    if ( hQ != 0x0 ){
      TH2S *hNew = new TH2S(*hQ);
      hNew->SetDirectory(0);
      fHistoQArray.AddAt(hNew,iSec);
    }
    if ( hT0 != 0x0 ){
      TH2S *hNew = new TH2S(*hT0);
      hNew->SetDirectory(0);
      fHistoT0Array.AddAt(hNew,iSec);
    }
    if ( hRMS != 0x0 ){
      TH2S *hNew = new TH2S(*hRMS);
      hNew->SetDirectory(0);
      fHistoRMSArray.AddAt(hNew,iSec);
    }
  }

  //copy fit parameters event by event
  TObjArray *arr=0x0;
  for (Int_t iSec=0; iSec<72; ++iSec){
    arr = (TObjArray*)sig.fParamArrayEventPol1.UncheckedAt(iSec);
    if ( arr ){
      TObjArray *arrEvents = new TObjArray(arr->GetSize());
      fParamArrayEventPol1.AddAt(arrEvents, iSec);
      for (Int_t iEvent=0; iEvent<arr->GetSize(); ++iEvent)
        if ( TVectorD *vec=(TVectorD*)arr->UncheckedAt(iEvent) )
          arrEvents->AddAt(new TVectorD(*vec),iEvent);
    }

    arr = (TObjArray*)sig.fParamArrayEventPol2.UncheckedAt(iSec);
    if ( arr ){
      TObjArray *arrEvents = new TObjArray(arr->GetSize());
      fParamArrayEventPol2.AddAt(arrEvents, iSec);
      for (Int_t iEvent=0; iEvent<arr->GetSize(); ++iEvent)
        if ( TVectorD *vec=(TVectorD*)arr->UncheckedAt(iEvent) )
          arrEvents->AddAt(new TVectorD(*vec),iEvent);
    }

    TVectorF *vMeanTime = (TVectorF*)sig.fTMeanArrayEvent.UncheckedAt(iSec);
    TVectorF *vMeanQ    = (TVectorF*)sig.fQMeanArrayEvent.UncheckedAt(iSec);
    if ( vMeanTime )
      fTMeanArrayEvent.AddAt(new TVectorF(*vMeanTime), iSec);
    if ( vMeanQ )
      fQMeanArrayEvent.AddAt(new TVectorF(*vMeanQ), iSec);
  }


  fVEventTime.ResizeTo(sig.fVEventTime);
  fVEventNumber.ResizeTo(sig.fVEventNumber);
  fVEventTime.SetElements(sig.fVEventTime.GetMatrixArray());
  fVEventNumber.SetElements(sig.fVEventNumber.GetMatrixArray());

  fParam->Update();

  for (Int_t i=0; i<sig.fArrHnDrift.GetEntries();++i){
    TObject *o=sig.fArrHnDrift.UncheckedAt(i);
    if (o){
      TObject *newo=o->Clone("fHnDrift");
      fArrHnDrift.AddAt(newo,i);
      if (sig.fHnDrift && o==sig.fHnDrift) fHnDrift=(THnSparseI*)newo;
    }
  }

  for (Int_t i=0;i<sig.fTimeBursts.GetNrows();++i){
    fTimeBursts[i]=sig.fTimeBursts[i];
  }
  
  for (Int_t i=0;i<14;++i){
    fPeaks[i]=sig.fPeaks[i];
    fPeakWidths[i]=sig.fPeakWidths[i];
  }
  if (sig.fArrFitGraphs) {
    fArrFitGraphs=(TObjArray*)sig.fArrFitGraphs->Clone();
    fArrFitGraphs->SetOwner();
  }

  for (Int_t i=0; i<100; ++i) fBinsLastAna[i]=sig.fBinsLastAna[i];
  
}
//_____________________________________________________________________
AliTPCCalibCE::AliTPCCalibCE(const TMap *config) :
  AliTPCCalibRawBase(),
  fNbinsT0(200),
  fXminT0(-5),
  fXmaxT0(5),
  fNbinsQ(200),
  fXminQ(1),
  fXmaxQ(40),
  fNbinsRMS(100),
  fXminRMS(0.1),
  fXmaxRMS(5.1),
  fPeakDetMinus(2),
  fPeakDetPlus(3),
  fPeakIntMinus(2),
  fPeakIntPlus(2),
  fNoiseThresholdMax(5.),
  fNoiseThresholdSum(8.),
  fIsZeroSuppressed(kFALSE),
  fLastSector(-1),
  fSecRejectRatio(.4),
  fParam(new  AliTPCParam),
  fPedestalTPC(0x0),
  fPadNoiseTPC(0x0),
  fPedestalROC(0x0),
  fPadNoiseROC(0x0),
  fCalRocArrayT0(72),
  fCalRocArrayT0Err(72),
  fCalRocArrayQ(72),
  fCalRocArrayRMS(72),
  fCalRocArrayOutliers(72),
  fHistoQArray(72),
  fHistoT0Array(72),
  fHistoRMSArray(72),
  fMeanT0rms(0),
  fMeanQrms(0),
  fMeanRMSrms(0),
  fHistoTmean(72),
  fParamArrayEventPol1(72),
  fParamArrayEventPol2(72),
  fTMeanArrayEvent(72),
  fQMeanArrayEvent(72),
  fVEventTime(1000),
  fVEventNumber(1000),
  fVTime0SideA(1000),
  fVTime0SideC(1000),
  fEventId(-1),
  fOldRunNumber(0),
  fPadTimesArrayEvent(72),
  fPadQArrayEvent(72),
  fPadRMSArrayEvent(72),
  fPadPedestalArrayEvent(72),
  fCurrentChannel(-1),
  fCurrentSector(-1),
  fCurrentRow(-1),
  fMaxPadSignal(-1),
  fMaxTimeBin(-1),
//   fPadSignal(1024),
  fPadPedestal(0),
  fPadNoise(0),
  fVTime0Offset(72),
  fVTime0OffsetCounter(72),
  fVMeanQ(72),
  fVMeanQCounter(72),
  fCurrentCETimeRef(0),
  fProcessOld(kTRUE),
  fProcessNew(kFALSE),
  fAnalyseNew(kTRUE),
  fHnDrift(0x0),
  fArrHnDrift(100),
  fTimeBursts(100),
  fArrFitGraphs(0x0),
  fEventInBunch(0)
{
  //
  // constructor which uses a tmap as input to set some specific parameters
  //
  SetNameTitle("AliTPCCalibCE","AliTPCCalibCE");
  fFirstTimeBin=650;
  fLastTimeBin=1030;
  if (config->GetValue("FirstTimeBin")) fFirstTimeBin = ((TObjString*)config->GetValue("FirstTimeBin"))->GetString().Atoi();
  if (config->GetValue("LastTimeBin")) fLastTimeBin = ((TObjString*)config->GetValue("LastTimeBin"))->GetString().Atoi();
  if (config->GetValue("NbinsT0")) fNbinsT0 = ((TObjString*)config->GetValue("NbinsT0"))->GetString().Atoi();
  if (config->GetValue("XminT0")) fXminT0 = ((TObjString*)config->GetValue("XminT0"))->GetString().Atof();
  if (config->GetValue("XmaxT0")) fXmaxT0 = ((TObjString*)config->GetValue("XmaxT0"))->GetString().Atof();
  if (config->GetValue("NbinsQ")) fNbinsQ = ((TObjString*)config->GetValue("NbinsQ"))->GetString().Atoi();
  if (config->GetValue("XminQ")) fXminQ = ((TObjString*)config->GetValue("XminQ"))->GetString().Atof();
  if (config->GetValue("XmaxQ")) fXmaxQ = ((TObjString*)config->GetValue("XmaxQ"))->GetString().Atof();
  if (config->GetValue("NbinsRMS")) fNbinsRMS = ((TObjString*)config->GetValue("NbinsRMS"))->GetString().Atoi();
  if (config->GetValue("XminRMS")) fXminRMS = ((TObjString*)config->GetValue("XminRMS"))->GetString().Atof();
  if (config->GetValue("XmaxRMS")) fXmaxRMS = ((TObjString*)config->GetValue("XmaxRMS"))->GetString().Atof();
  if (config->GetValue("PeakDetMinus")) fPeakDetMinus = ((TObjString*)config->GetValue("PeakDetMinus"))->GetString().Atoi();
  if (config->GetValue("PeakDetPlus")) fPeakDetPlus = ((TObjString*)config->GetValue("PeakDetPlus"))->GetString().Atoi();
  if (config->GetValue("PeakIntMinus")) fPeakIntMinus = ((TObjString*)config->GetValue("PeakIntMinus"))->GetString().Atoi();
  if (config->GetValue("PeakIntPlus")) fPeakIntPlus = ((TObjString*)config->GetValue("PeakIntPlus"))->GetString().Atoi();
  if (config->GetValue("NoiseThresholdMax")) fNoiseThresholdMax = ((TObjString*)config->GetValue("NoiseThresholdMax"))->GetString().Atof();
  if (config->GetValue("NoiseThresholdSum")) fNoiseThresholdSum = ((TObjString*)config->GetValue("NoiseThresholdSum"))->GetString().Atof();
  if (config->GetValue("IsZeroSuppressed")) fIsZeroSuppressed = (Bool_t)((TObjString*)config->GetValue("IsZeroSuppressed"))->GetString().Atoi();
  if (config->GetValue("UseL1Phase")) fUseL1Phase = (Bool_t)((TObjString*)config->GetValue("UseL1Phase"))->GetString().Atoi();
  if (config->GetValue("SecRejectRatio")) fSecRejectRatio = ((TObjString*)config->GetValue("SecRejectRatio"))->GetString().Atof();

  if (config->GetValue("ProcessOld")) fProcessOld = (Bool_t)((TObjString*)config->GetValue("ProcessOld"))->GetString().Atoi();
  if (config->GetValue("ProcessNew")) fProcessNew = (Bool_t)((TObjString*)config->GetValue("ProcessNew"))->GetString().Atoi();
  if (config->GetValue("AnalyseNew")) fAnalyseNew = (Bool_t)((TObjString*)config->GetValue("AnalyseNew"))->GetString().Atoi();
  
  for (Int_t i=0;i<1024;++i) fPadSignal[i]=0;
  for (Int_t i=0;i<14;++i){
    fPeaks[i]=0;
    fPeakWidths[i]=0;
  }
  
  fParam->Update();
  for (Int_t i=0; i<100; ++i) fBinsLastAna[i]=0;
}

//_____________________________________________________________________
AliTPCCalibCE& AliTPCCalibCE::operator = (const  AliTPCCalibCE &source)
{
  //
  // assignment operator
  //
  if (&source == this) return *this;
  new (this) AliTPCCalibCE(source);

  return *this;
}
//_____________________________________________________________________
AliTPCCalibCE::~AliTPCCalibCE()
{
  //
  // destructor
  //
  
  fCalRocArrayT0.Delete();
  fCalRocArrayT0Err.Delete();
  fCalRocArrayQ.Delete();
  fCalRocArrayRMS.Delete();
  fCalRocArrayOutliers.Delete();
  
  fHistoQArray.Delete();
  fHistoT0Array.Delete();
  fHistoRMSArray.Delete();
  
  fHistoTmean.Delete();
  
  fParamArrayEventPol1.Delete();
  fParamArrayEventPol2.Delete();
  fTMeanArrayEvent.Delete();
  fQMeanArrayEvent.Delete();
  
  fPadTimesArrayEvent.Delete();
  fPadQArrayEvent.Delete();
  fPadRMSArrayEvent.Delete();
  fPadPedestalArrayEvent.Delete();
  
  fArrHnDrift.SetOwner();
  fArrHnDrift.Delete();
  
  if (fArrFitGraphs){
    fArrFitGraphs->SetOwner();
    delete fArrFitGraphs;
  }
}
//_____________________________________________________________________
Int_t AliTPCCalibCE::Update(const Int_t icsector,
				const Int_t icRow,
				const Int_t icPad,
				const Int_t icTimeBin,
				const Float_t csignal)
{
  //
  // Signal filling methode on the fly pedestal and Time offset correction if necessary.
  // no extra analysis necessary. Assumes knowledge of the signal shape!
  // assumes that it is looped over consecutive time bins of one pad
  //

  if (!fProcessOld) return 0;
  //temp

  if (icRow<0) return 0;
  if (icPad<0) return 0;
  if (icTimeBin<0) return 0;
  if ( (icTimeBin>fLastTimeBin) || (icTimeBin<fFirstTimeBin)   ) return 0;

  Int_t iChannel  = fROC->GetRowIndexes(icsector)[icRow]+icPad; //  global pad position in sector

  //init first pad and sector in this event
  if ( fCurrentChannel == -1 ) {
    fLastSector=-1;
    fCurrentChannel = iChannel;
    fCurrentSector  = icsector;
    fCurrentRow     = icRow;
  }

  //process last pad if we change to a new one
  if ( iChannel != fCurrentChannel ){
    ProcessPad();
    fLastSector=fCurrentSector;
    fCurrentChannel = iChannel;
    fCurrentSector  = icsector;
    fCurrentRow     = icRow;
  }

  //fill signals for current pad
  fPadSignal[icTimeBin]=csignal;
  if ( csignal > fMaxPadSignal ){
    fMaxPadSignal = csignal;
    fMaxTimeBin   = icTimeBin;
  }
  return 0;
}

//_____________________________________________________________________
void AliTPCCalibCE::ProcessBunch(const Int_t sector, const Int_t row, const Int_t pad,
                  const Int_t length, const UInt_t startTimeBin, const UShort_t* signal)
{
  //
  // new filling method to fill the THnSparse histogram
  //

  //only in new processing mode
  if (!fProcessNew) return;
    //don't use the IROCs and inner part of OROCs
  if (sector<36) return;
  if (row<40) return;    
  //only bunches with reasonable length
  if (length<3||length>10) return;
  
  UShort_t  timeBin    = (UShort_t)startTimeBin;
  //skip first laser layer
  if (timeBin<280) return;

  Double_t timeBurst=SetBurstHnDrift();
  
  Int_t cePeak=((sector/18)%2)*7+6;
  //after 1 event setup peak ranges
  if (fEventInBunch==1 && fPeaks[cePeak]==0) {
    // set time range
    fHnDrift->GetAxis(4)->SetRangeUser(timeBurst-2*60,timeBurst+2*60);
    FindLaserLayers();
    // set time range
    fHnDrift->GetAxis(4)->SetRangeUser(fHnDrift->GetAxis(4)->GetXmin(),fHnDrift->GetAxis(4)->GetXmax());
    fHnDrift->Reset();
  }
  
  // After the first event only fill every 5th  bin in a row with the CE information
  Int_t padFill=pad;
  if (fEventInBunch==0||(fPeaks[cePeak]>100&&TMath::Abs((Short_t)fPeaks[cePeak]-(Short_t)timeBin)<(Short_t)fPeakWidths[cePeak])){
    Int_t mod=5;
    Int_t n=pad/mod;
    padFill=mod*n+mod/2;
  }

  //noise removal
  if (!IsPeakInRange(timeBin+length/2,sector)) return;
  
  Double_t x[kHnBinsDV]={(Double_t)sector,(Double_t)row,
      (Double_t)padFill,(Double_t)timeBin,timeBurst};
  
  for (Int_t iTimeBin = 0; iTimeBin<length; iTimeBin++){
    Float_t sig=(Float_t)signal[iTimeBin];
     // if (fPeaks[6]>900&&timeBin>(fPeaks[6]-20)&&sig<20) continue;
     // if (fPeaks[6]>900&&timeBin<(fPeaks[6]-fPeakWidth[6])&&sig<5) continue;
    x[3]=timeBin;
    fHnDrift->Fill(x,sig);
    --timeBin;
  }
}
//_____________________________________________________________________
void AliTPCCalibCE::FindLaserLayers()
{
  //
  // Find the laser layer positoins
  //

  //A-side + C-side
  for (Int_t iside=0;iside<2;++iside){
    Int_t add=7*iside;
    //find CE signal position and width
    fHnDrift->GetAxis(0)->SetRangeUser(36+iside*18,53+iside*18);
    TH1D *hproj=fHnDrift->Projection(3);
    hproj->GetXaxis()->SetRangeUser(700,1030);
    Int_t maxbin=hproj->GetMaximumBin();
    Double_t binc=hproj->GetBinCenter(maxbin);
    hproj->GetXaxis()->SetRangeUser(binc-5,binc+5);
  
    fPeaks[add+6]=(UShort_t)TMath::Nint(binc);
  //   fPeakWidths[4]=(UShort_t)TMath::Nint(4*hproj->GetRMS()+.5);
    fPeakWidths[add+6]=7;
  
    hproj->GetXaxis()->SetRangeUser(0,maxbin-10);
    TSpectrum s(6);
    s.Search(hproj,2,"goff");
    Int_t index[6];
    TMath::Sort(6,s.GetPositionX(),index,kFALSE);
    for (Int_t i=0; i<6; ++i){
      fPeaks[i+add]=(UShort_t)TMath::Nint(s.GetPositionX()[index[i]]);
      fPeakWidths[i+add]=5;
    }
    
    //other peaks
    
//    Int_t timepos=fPeaks[4]-2*fPeakWidths[4];
//    Int_t width=100;
   
//    for (Int_t i=3; i>=0; --i){
//      hproj->GetXaxis()->SetRangeUser(timepos-width,timepos);
//      fPeaks[i]=hproj->GetMaximumBin(); 
//      fPeakWidths[i]=(UShort_t)TMath::Nint(10.);
//      width=250;
//      timepos=fPeaks[i]-width/2;
//    }
  
//    for (Int_t i=add; i<add+7; ++i){
//      printf("Peak: %u +- %u\n",fPeaks[i],fPeakWidths[i]);
//    }
    //check width and reset peak if >100
//    for (Int_t i=0; i<5; ++i){
//      if (fPeakWidths[i]>100) {
//        fPeaks[i]=0;
//        fPeakWidths[i]=0;
//      }
//    }

    delete hproj;
  }
}

//_____________________________________________________________________
void AliTPCCalibCE::FindPedestal(Float_t part)
{
  //
    // find pedestal and noise for the current pad. Use either database or
    // truncated mean with part*100%
  //
  Bool_t noPedestal = kTRUE;

    //use pedestal database if set
  if (fPedestalTPC&&fPadNoiseTPC){
        //only load new pedestals if the sector has changed
    if ( fCurrentSector!=fLastSector ){
      fPedestalROC = fPedestalTPC->GetCalROC(fCurrentSector);
      fPadNoiseROC = fPadNoiseTPC->GetCalROC(fCurrentSector);
    }

    if ( fPedestalROC&&fPadNoiseROC ){
      fPadPedestal = fPedestalROC->GetValue(fCurrentChannel)*(Float_t)(!fIsZeroSuppressed);
      fPadNoise    = fPadNoiseROC->GetValue(fCurrentChannel);
      noPedestal   = kFALSE;
    }

  }

    //if we are not running with pedestal database, or for the current sector there is no information
    //available, calculate the pedestal and noise on the fly
  if ( noPedestal ) {
    fPadPedestal = 0;
    fPadNoise    = 0;
    if ( fIsZeroSuppressed ) return;
    const Int_t kPedMax = 100;  //maximum pedestal value
    Float_t  max    =  0;
    Float_t  maxPos =  0;
    Int_t    median =  -1;
    Int_t    count0 =  0;
    Int_t    count1 =  0;
    //
    Float_t padSignal=0;
    //
    UShort_t histo[kPedMax];
    memset(histo,0,kPedMax*sizeof(UShort_t));

        //fill pedestal histogram
    for (Int_t i=fFirstTimeBin; i<=fLastTimeBin; ++i){
      padSignal = fPadSignal[i];
      if (padSignal<=0) continue;
      if (padSignal>max && i>10) {
        max = padSignal;
        maxPos = i;
      }
      if (padSignal>kPedMax-1) continue;
      histo[int(padSignal+0.5)]++;
      count0++;
    }
	//find median
    for (Int_t i=1; i<kPedMax; ++i){
      if (count1<count0*0.5) median=i;
      count1+=histo[i];
    }
	// truncated mean
    //
    Float_t count=histo[median] ,mean=histo[median]*median,  rms=histo[median]*median*median ;
    //
    for (Int_t idelta=1; idelta<10; ++idelta){
      if (median-idelta<=0) continue;
      if (median+idelta>kPedMax) continue;
      if (count<part*count1){
        count+=histo[median-idelta];
        mean +=histo[median-idelta]*(median-idelta);
        rms  +=histo[median-idelta]*(median-idelta)*(median-idelta);
        count+=histo[median+idelta];
        mean +=histo[median+idelta]*(median+idelta);
        rms  +=histo[median+idelta]*(median+idelta)*(median+idelta);
      }
    }
    if ( count > 0 ) {
      mean/=count;
      rms    = TMath::Sqrt(TMath::Abs(rms/count-mean*mean));
      fPadPedestal = mean;
      fPadNoise    = rms;
    }
  }
}
//_____________________________________________________________________
void AliTPCCalibCE::UpdateCETimeRef()
{
  // Find the time reference of the last valid CE signal in sector
  // for irocs of the A-Side the reference of the corresponging OROC is returned
  // the reason are the non reflective bands on the A-Side, which make the reference very uncertain
  if ( fLastSector == fCurrentSector ) return;
  Int_t sector=fCurrentSector; 
  if ( sector < 18 ) sector+=36;
  fCurrentCETimeRef=0;
  TVectorF *vtRef = GetTMeanEvents(sector);
  if ( !vtRef ) return; 
  Int_t vtRefSize= vtRef->GetNrows();
  if ( vtRefSize < fNevents+1 ) vtRef->ResizeTo(vtRefSize+100);
  else vtRefSize=fNevents; 
  while ( (*vtRef)[vtRefSize]==0 && vtRefSize>=0 ) --vtRefSize;
  fCurrentCETimeRef=(*vtRef)[vtRefSize];
  AliDebug(3,Form("Sector: %02d - T0 ref: %.2f",fCurrentSector,fCurrentCETimeRef)); 
} 
//_____________________________________________________________________
void AliTPCCalibCE::FindCESignal(TVectorD &param, Float_t &qSum, const TVectorF maxima)
{
  //
    //  Find position, signal width and height of the CE signal (last signal)
    //  param[0] = Qmax, param[1] = mean time, param[2] = rms;
    //  maxima: array of local maxima of the pad signal use the one closest to the mean CE position
  //

  Float_t ceQmax  =0, ceQsum=0, ceTime=0, ceRMS=0;
  Int_t   cemaxpos       = 0;
  Float_t ceSumThreshold = fNoiseThresholdSum*fPadNoise;  // threshold for the signal sum
  const Int_t    kCemin  = fPeakIntMinus;             // range for the analysis of the ce signal +- channels from the peak
  const Int_t    kCemax  = fPeakIntPlus;

  Float_t minDist  = 25;  //initial minimum distance betweek roc mean ce signal and pad ce signal

    // find maximum closest to the sector mean from the last event
  for ( Int_t imax=0; imax<maxima.GetNrows(); ++imax){
        // get sector mean of last event
    Float_t tmean = fCurrentCETimeRef;
    if ( TMath::Abs( tmean-maxima[imax] ) < minDist ) {
      minDist  = tmean-maxima[imax];
      cemaxpos = (Int_t)maxima[imax];
    }
  }
//   printf("L1 phase TB: %f\n",GetL1PhaseTB());
  if (cemaxpos!=0){
    ceQmax = fPadSignal[cemaxpos]-fPadPedestal;
    for (Int_t i=cemaxpos-kCemin; i<=cemaxpos+kCemax; ++i){
      if ( (i>fFirstTimeBin) && (i<fLastTimeBin) ){
        Float_t signal = fPadSignal[i]-fPadPedestal;
        if (signal>0) {
          ceTime+=signal*(i+0.5);
          ceRMS +=signal*(i+0.5)*(i+0.5);
          ceQsum+=signal;
        }
      }
    }
  }
  if (ceQmax&&ceQsum>ceSumThreshold) {
    ceTime/=ceQsum;
    ceRMS  = TMath::Sqrt(TMath::Abs(ceRMS/ceQsum-ceTime*ceTime));
    ceTime-=GetL1PhaseTB();
    fVTime0Offset.GetMatrixArray()[fCurrentSector]+=ceTime;   // mean time for each sector
    fVTime0OffsetCounter.GetMatrixArray()[fCurrentSector]++;

  //Normalise Q to the 'cell-size': The wire density is the same in the IROC and OROC, therefore the
  //                                the pick-up signal should scale with the pad area. In addition
  //                                the signal should decrease with the wire distance (4mm in IROC, 6mm in OROC),
  //                                ratio 2/3. The pad area we express in cm2. We normalise the signal
  //                                to the OROC signal (factor 2/3 for the IROCs).  
    Float_t norm = fParam->GetPadPitchWidth(fCurrentSector)*fParam->GetPadPitchLength(fCurrentSector,fCurrentRow);
    if ( fCurrentSector<fParam->GetNInnerSector() ) norm*=3./2.;

    ceQsum/=norm;
    fVMeanQ.GetMatrixArray()[fCurrentSector]+=ceQsum;
    fVMeanQCounter.GetMatrixArray()[fCurrentSector]++;
  } else {
    ceQmax=0;
    ceTime=0;
    ceRMS =0;
    ceQsum=0;
  }
  param[0] = ceQmax;
  param[1] = ceTime; 
  param[2] = ceRMS;
  qSum     = ceQsum;
}
//_____________________________________________________________________
Bool_t AliTPCCalibCE::IsPeak(Int_t pos, Int_t tminus, Int_t tplus) const
{
  //
  // Check if 'pos' is a Maximum. Consider 'tminus' timebins before
  // and 'tplus' timebins after 'pos'
  //
  if ( (pos-tminus)<fFirstTimeBin || (pos+tplus)>fLastTimeBin ) return kFALSE;
  for (Int_t iTime = pos; iTime>pos-tminus; --iTime)
    if ( fPadSignal[iTime-1] >= fPadSignal[iTime] ) return kFALSE;
  for (Int_t iTime = pos, iTime2=pos; iTime<pos+tplus; ++iTime, ++iTime2){
    if ( (iTime==pos) && (fPadSignal[iTime+1]==fPadSignal[iTime]) ) // allow two timebins with same adc value
      ++iTime2;
    if ( fPadSignal[iTime2+1] >= fPadSignal[iTime2] ) return kFALSE;
  }
  return kTRUE;
}
//_____________________________________________________________________
void AliTPCCalibCE::FindLocalMaxima(TVectorF &maxima)
{
  //
    // Find local maxima on the pad signal and Histogram them
  //
  Float_t ceThreshold = fNoiseThresholdMax*TMath::Max(fPadNoise,Float_t(1.));  // threshold for the signal
  Int_t   count       = 0;
  
  for (Int_t i=fLastTimeBin-fPeakDetPlus+1; i>=fFirstTimeBin+fPeakDetMinus; --i){
    if ( (fPadSignal[i]-fPadPedestal)<ceThreshold ) continue;
    if (IsPeak(i,fPeakDetMinus,fPeakDetPlus) ){
      if (count<maxima.GetNrows()){
        maxima.GetMatrixArray()[count++]=i;
        GetHistoTmean(fCurrentSector,kTRUE)->Fill(i);
        i-=(fPeakDetMinus+fPeakDetPlus-1); // next peak cannot be at bin  fPeakDetMinus+fPeakDetPlus-1
      }
    }
  }
}
//_____________________________________________________________________
void AliTPCCalibCE::ProcessPad()
{
  //
  //  Process data of current pad
  //
  FindPedestal();
  
  TVectorF maxima(15);     // the expected maximum number of maxima in the complete TPC should be 8 laser beam layers
                             // + central electrode and possibly post peaks from the CE signal
                             // however if we are on a high noise pad a lot more peaks due to the noise might occur
  FindLocalMaxima(maxima);
  if ( (fNevents == 0) || (fOldRunNumber!=fRunNumber) ) return;  // return because we don't have Time0 info for the CE yet
  
  UpdateCETimeRef();                       // update the time refenrence for the current sector
  if ( fCurrentCETimeRef<1e-30 ) return;      //return if we don't have time 0 info, eg if only one side has laser
  TVectorD param(3);
  Float_t  qSum;
  FindCESignal(param, qSum, maxima);
  
  Double_t meanT  = param[1];
  Double_t sigmaT = param[2];
  
    //Fill Event T0 counter
  (*GetPadTimesEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel] = meanT;
  
    //Fill Q histogram
  GetHistoQ(fCurrentSector,kTRUE)->Fill( TMath::Sqrt(qSum), fCurrentChannel );
  
    //Fill RMS histogram
  GetHistoRMS(fCurrentSector,kTRUE)->Fill( sigmaT, fCurrentChannel );
  
  
    //Fill debugging info
  if ( GetStreamLevel()>0 ){
    (*GetPadPedestalEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel]=fPadPedestal;
    (*GetPadRMSEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel]=sigmaT;
    (*GetPadQEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel]=qSum;
  }
  
  ResetPad();
}
//_____________________________________________________________________
void AliTPCCalibCE::EndEvent()
{
  //  Process data of current pad
  //  The Functions 'SetTimeStamp' and 'SetRunNumber'  should be called
  //  before the EndEvent function to set the event timestamp and number!!!
  //  This is automatically done if the ProcessEvent(AliRawReader *rawReader)
  //  function was called
  if (!fProcessOld) {
    if (fProcessNew){
      ++fNevents;
      ++fEventInBunch;
    }
    return;
  }
  
  //check if last pad has allready been processed, if not do so
  if ( fMaxTimeBin>-1 ) ProcessPad();

  AliDebug(3, Form("EndEvent() - Start; Event: %05d", fNevents));

  TVectorD param(3);
  TMatrixD dummy(3,3);
//    TVectorF vMeanTime(72);
//    TVectorF vMeanQ(72);
  AliTPCCalROC *calIroc=new AliTPCCalROC(0);
  AliTPCCalROC *calOroc=new AliTPCCalROC(36);

  //find mean time0 offset for side A and C
  //use only orocs due to the better statistics
  Double_t time0Side[2];       //time0 for side A:0 and C:1
  Double_t time0SideCount[2];  //time0 counter for side A:0 and C:1
  time0Side[0]=0;time0Side[1]=0;time0SideCount[0]=0;time0SideCount[1]=0;
  for ( Int_t iSec = 36; iSec<72; ++iSec ){
    time0Side[(iSec/18)%2] += fVTime0Offset.GetMatrixArray()[iSec];
    time0SideCount[(iSec/18)%2] += fVTime0OffsetCounter.GetMatrixArray()[iSec];
  }
  if ( time0SideCount[0] >0  )
    time0Side[0]/=time0SideCount[0];
  if ( time0SideCount[1] >0 )
    time0Side[1]/=time0SideCount[1];
    // end find time0 offset
  AliDebug(3,Form("time0Side/time0SideCount: A=%.2f/%.2f, C=%.2f/%.2f",time0Side[0],time0SideCount[0],time0Side[1],time0SideCount[1]));
  Int_t nSecMeanT=0;
  //loop over all ROCs, fill CE Time histogram corrected for the mean Time0 of each ROC
  for ( Int_t iSec = 0; iSec<72; ++iSec ){
    AliDebug(4,Form("Processing sector '%02d'\n",iSec));
    //find median and then calculate the mean around it
    TH1S *hMeanT    = GetHistoTmean(iSec); //histogram with local maxima position information
    if ( !hMeanT ) continue;
    //continue if not enough data is filled in the meanT histogram. This is the case if we do not have a laser event.
    if ( hMeanT->GetEffectiveEntries() < fROC->GetNChannels(iSec)*fSecRejectRatio ){
      hMeanT->Reset();
      AliDebug(3,Form("Skipping sec. '%02d': Not enough statistics\n",iSec));
      continue;
    }
    
    Double_t entries = hMeanT->GetEffectiveEntries();
    Double_t sum     = 0;
    Short_t *arr     = hMeanT->GetArray()+1;
    Int_t ibin=0;
    for ( ibin=0; ibin<hMeanT->GetNbinsX(); ++ibin){
      sum+=arr[ibin];
      if ( sum>=(entries/2.) ) break;
    }
    Int_t delta = 4;
    Int_t firstBin = fFirstTimeBin+ibin-delta;
    Int_t lastBin  = fFirstTimeBin+ibin+delta;
    if ( firstBin<fFirstTimeBin ) firstBin=fFirstTimeBin;
    if ( lastBin>fLastTimeBin   ) lastBin =fLastTimeBin;
    Float_t median =AliMathBase::GetCOG(arr+ibin-delta,2*delta,firstBin,lastBin);
    
	// check boundaries for ebye info of mean time
    TVectorF *vMeanTime=GetTMeanEvents(iSec,kTRUE);
    Int_t vSize=vMeanTime->GetNrows();
    if ( vSize < fNevents+1 ){
      vMeanTime->ResizeTo(vSize+100);
    }

    // store mean time for the readout sides
    vSize=fVTime0SideA.GetNrows();
    if ( vSize < fNevents+1 ){
      fVTime0SideA.ResizeTo(vSize+100);
      fVTime0SideC.ResizeTo(vSize+100);
    }
    fVTime0SideA.GetMatrixArray()[fNevents]=time0Side[0];
    fVTime0SideC.GetMatrixArray()[fNevents]=time0Side[1];
    
    vMeanTime->GetMatrixArray()[fNevents]=median;
    nSecMeanT++;
    // end find median
    
    TVectorF *vTimes = GetPadTimesEvent(iSec);
    if ( !vTimes ) continue;                     //continue if no time information for this sector is available
    
    AliTPCCalROC calIrocOutliers(0);
    AliTPCCalROC calOrocOutliers(36);
    
    // calculate mean Q of the sector
    TVectorF *vMeanQ=GetQMeanEvents(iSec,kTRUE);
    vSize=vMeanQ->GetNrows();
    if ( vSize < fNevents+1 ){
      vMeanQ->ResizeTo(vSize+100);
    }   
    Float_t meanQ = 0;
    if ( fVMeanQCounter.GetMatrixArray()[iSec]>0 ) meanQ=fVMeanQ.GetMatrixArray()[iSec]/fVMeanQCounter.GetMatrixArray()[iSec];
    vMeanQ->GetMatrixArray()[fNevents]=meanQ;
   
    for ( UInt_t iChannel=0; iChannel<fROC->GetNChannels(iSec); ++iChannel ){
      Float_t time  = (*vTimes).GetMatrixArray()[iChannel];

	    //set values for temporary roc calibration class
      if ( iSec < 36 ) {
        calIroc->SetValue(iChannel, time);
        if ( TMath::Abs(time) < 1e-30 ) calIrocOutliers.SetValue(iChannel,1);

      } else {
        calOroc->SetValue(iChannel, time);
        if ( TMath::Abs(time) < 1e-30 ) calOrocOutliers.SetValue(iChannel,1);
      }

      if ( (fNevents>0) && (fOldRunNumber==fRunNumber) )
        // test that we really found the CE signal reliably 
        if ( TMath::Abs(fVTime0SideA.GetMatrixArray()[fNevents-1]-time0Side[0])<.05)
          GetHistoT0(iSec,kTRUE)->Fill( time-time0Side[(iSec/18)%2],iChannel );



	    //-------------------------------  Debug start  ------------------------------
      if ( GetStreamLevel()>0 ){
        TTreeSRedirector *streamer=GetDebugStreamer();
        if (streamer){
          Int_t row=0;
          Int_t pad=0;
          Int_t padc=0;
          
          Float_t q   = (*GetPadQEvent(iSec))[iChannel];
          Float_t rms = (*GetPadRMSEvent(iSec))[iChannel];
          
          UInt_t channel=iChannel;
          Int_t sector=iSec;
          
          while ( channel > (fROC->GetRowIndexes(sector)[row]+fROC->GetNPads(sector,row)-1) ) row++;
          pad = channel-fROC->GetRowIndexes(sector)[row];
          padc = pad-(fROC->GetNPads(sector,row)/2);
          
//		TH1F *h1 = new TH1F(Form("hSignalD%d.%d.%d",sector,row,pad),
//				    Form("hSignalD%d.%d.%d",sector,row,pad),
//				    fLastTimeBin-fFirstTimeBin,
//				    fFirstTimeBin,fLastTimeBin);
//		h1->SetDirectory(0);
        //
//		for (Int_t i=fFirstTimeBin; i<fLastTimeBin+1; ++i)
//		    h1->Fill(i,fPadSignal(i));
          
          Double_t t0Sec = 0;
          if (fVTime0OffsetCounter.GetMatrixArray()[iSec]>0)
            t0Sec = fVTime0Offset.GetMatrixArray()[iSec]/fVTime0OffsetCounter.GetMatrixArray()[iSec];
          Double_t t0Side = time0Side[(iSec/18)%2];
          (*streamer) << "DataPad" <<
            "Event=" << fNevents <<
            "RunNumber=" << fRunNumber <<
            "TimeStamp="   << fTimeStamp <<
            "Sector="<< sector <<
            "Row="   << row<<
            "Pad="   << pad <<
            "PadC="  << padc <<
            "PadSec="<< channel <<
            "Time0Sec="  << t0Sec <<
            "Time0Side=" << t0Side <<
            "Time="  << time <<
            "RMS="   << rms <<
            "Sum="   << q <<
            "MeanQ=" << meanQ <<
        //		    "hist.=" << h1 <<
            "\n";
          
    //		delete h1;
        }
      }
      //-----------------------------  Debug end  ------------------------------
    }// end channel loop


    //do fitting now only in debug mode
    if (GetDebugLevel()>0){
      TVectorD paramPol1(3);
      TVectorD paramPol2(6);
      TMatrixD matPol1(3,3);
      TMatrixD matPol2(6,6);
      Float_t  chi2Pol1=0;
      Float_t  chi2Pol2=0;
      
      if ( (fNevents>0) && (fOldRunNumber==fRunNumber) ){
        if ( iSec < 36 ){
          calIroc->GlobalFit(&calIrocOutliers,0,paramPol1,matPol1,chi2Pol1,0);
          calIroc->GlobalFit(&calIrocOutliers,0,paramPol2,matPol2,chi2Pol2,1);
        } else {
          calOroc->GlobalFit(&calOrocOutliers,0,paramPol1,matPol1,chi2Pol1,0);
          calOroc->GlobalFit(&calOrocOutliers,0,paramPol2,matPol2,chi2Pol2,1);
        }
        
        GetParamArrayPol1(iSec,kTRUE)->AddAtAndExpand(new TVectorD(paramPol1), fNevents);
        GetParamArrayPol2(iSec,kTRUE)->AddAtAndExpand(new TVectorD(paramPol2), fNevents);
      }
      
  //-------------------------------  Debug start  ------------------------------
      if ( GetStreamLevel()>0 ){
        TTreeSRedirector *streamer=GetDebugStreamer();
        if ( streamer ) {
          (*streamer) << "DataRoc" <<
//    "Event=" << fEvent <<
            "RunNumber=" << fRunNumber <<
            "TimeStamp="   << fTimeStamp <<
            "Sector="<< iSec <<
            "hMeanT.=" << hMeanT <<
            "median=" << median <<
            "paramPol1.=" << &paramPol1 <<
            "paramPol2.=" << &paramPol2 <<
            "matPol1.="   << &matPol1 <<
            "matPol2.="   << &matPol2 <<
            "chi2Pol1="   << chi2Pol1 <<
            "chi2Pol2="   << chi2Pol2 <<
            "\n";
        }
      }
    }
	//-------------------------------  Debug end  ------------------------------
    hMeanT->Reset();
  }// end sector loop
    //return if no sector has a valid mean time
  if ( nSecMeanT == 0 ) return;
    
    
//    fTMeanArrayEvent.AddAtAndExpand(new TVectorF(vMeanTime),fNevents);
//    fQMeanArrayEvent.AddAtAndExpand(new TVectorF(vMeanQ),fNevents);
  if ( fVEventTime.GetNrows() < fNevents+1 ) {
    fVEventTime.ResizeTo((Int_t)(fVEventTime.GetNrows()+100));
    fVEventNumber.ResizeTo((Int_t)(fVEventNumber.GetNrows()+100));
  }
  fVEventTime.GetMatrixArray()[fNevents] = fTimeStamp;
  fVEventNumber.GetMatrixArray()[fNevents] = fEventId;

  ++fNevents;
  if (fProcessNew) ++fEventInBunch;
  fOldRunNumber = fRunNumber;

  delete calIroc;
  delete calOroc;
  AliDebug(3, Form("EndEvent() - End; Event: %05d", fNevents));
}
//_____________________________________________________________________
TH2S* AliTPCCalibCE::GetHisto(Int_t sector, TObjArray *arr,
				  Int_t nbinsY, Float_t ymin, Float_t ymax,
				  const Char_t *type, Bool_t force)
{
    //
    // return pointer to TH2S histogram of 'type'
    // if force is true create a new histogram if it doesn't exist allready
    //
    if ( !force || arr->UncheckedAt(sector) )
      return (TH2S*)arr->UncheckedAt(sector);

    // if we are forced and histogram doesn't exist yet create it
    // new histogram with Q calib information. One value for each pad!
    TH2S* hist = new TH2S(Form("hCalib%s%.2d",type,sector),Form("%s calibration histogram sector %.2d",type,sector),
			  nbinsY, ymin, ymax,
			  fROC->GetNChannels(sector),0,fROC->GetNChannels(sector));
    hist->SetDirectory(0);
    arr->AddAt(hist,sector);
    return hist;
}
//_____________________________________________________________________
TH2S* AliTPCCalibCE::GetHistoT0(Int_t sector, Bool_t force)
{
    //
    // return pointer to T0 histogram
    // if force is true create a new histogram if it doesn't exist allready
    //
    TObjArray *arr = &fHistoT0Array;
    return GetHisto(sector, arr, fNbinsT0, fXminT0, fXmaxT0, "T0", force);
}
//_____________________________________________________________________
TH2S* AliTPCCalibCE::GetHistoQ(Int_t sector, Bool_t force)
{
    //
    // return pointer to Q histogram
    // if force is true create a new histogram if it doesn't exist allready
    //
    TObjArray *arr = &fHistoQArray;
    return GetHisto(sector, arr, fNbinsQ, fXminQ, fXmaxQ, "Q", force);
}
//_____________________________________________________________________
TH2S* AliTPCCalibCE::GetHistoRMS(Int_t sector, Bool_t force)
{
    //
    // return pointer to Q histogram
    // if force is true create a new histogram if it doesn't exist allready
    //
    TObjArray *arr = &fHistoRMSArray;
    return GetHisto(sector, arr, fNbinsRMS, fXminRMS, fXmaxRMS, "RMS", force);
}
//_____________________________________________________________________
TH1S* AliTPCCalibCE::GetHisto(Int_t sector, TObjArray *arr,
			      const Char_t *type, Bool_t force)
{
    //
    // return pointer to TH1S histogram
    // if force is true create a new histogram if it doesn't exist allready
    //
    if ( !force || arr->UncheckedAt(sector) )
      return (TH1S*)arr->UncheckedAt(sector);

    // if we are forced and histogram doesn't yes exist create it
    // new histogram with calib information. One value for each pad!
    TH1S* hist = new TH1S(Form("hCalib%s%.2d",type,sector),Form("%s calibration histogram sector %.2d",type,sector),
			  fLastTimeBin-fFirstTimeBin,fFirstTimeBin,fLastTimeBin);
    hist->SetDirectory(0);
    arr->AddAt(hist,sector);
    return hist;
}
//_____________________________________________________________________
TH1S* AliTPCCalibCE::GetHistoTmean(Int_t sector, Bool_t force)
{
    //
    // return pointer to Q histogram
    // if force is true create a new histogram if it doesn't exist allready
    //
    TObjArray *arr = &fHistoTmean;
    return GetHisto(sector, arr, "LastTmean", force);
}
//_____________________________________________________________________
TVectorF* AliTPCCalibCE::GetVectSector(Int_t sector, TObjArray *arr, UInt_t size, Bool_t force) const
{
    //
    // return pointer to Pad Info from 'arr' for the current event and sector
    // if force is true create it if it doesn't exist allready
    //
    if ( !force || arr->UncheckedAt(sector) )
	return (TVectorF*)arr->UncheckedAt(sector);

    TVectorF *vect = new TVectorF(size);
    arr->AddAt(vect,sector);
    return vect;
}
//_____________________________________________________________________
TVectorF* AliTPCCalibCE::GetPadTimesEvent(Int_t sector, Bool_t force)
{
    //
    // return pointer to Pad Times Array for the current event and sector
    // if force is true create it if it doesn't exist allready
    //
    TObjArray *arr = &fPadTimesArrayEvent;
    return GetVectSector(sector,arr,fROC->GetNChannels(sector),force);
}
//_____________________________________________________________________
TVectorF* AliTPCCalibCE::GetPadQEvent(Int_t sector, Bool_t force)
{
    //
    // return pointer to Pad Q Array for the current event and sector
    // if force is true create it if it doesn't exist allready
    // for debugging purposes only
    //

    TObjArray *arr = &fPadQArrayEvent;
    return GetVectSector(sector,arr,fROC->GetNChannels(sector),force);
}
//_____________________________________________________________________
TVectorF* AliTPCCalibCE::GetPadRMSEvent(Int_t sector, Bool_t force)
{
    //
    // return pointer to Pad RMS Array for the current event and sector
    // if force is true create it if it doesn't exist allready
    // for debugging purposes only
    //
    TObjArray *arr = &fPadRMSArrayEvent;
    return GetVectSector(sector,arr,fROC->GetNChannels(sector),force);
}
//_____________________________________________________________________
TVectorF* AliTPCCalibCE::GetPadPedestalEvent(Int_t sector, Bool_t force)
{
    //
    // return pointer to Pad RMS Array for the current event and sector
    // if force is true create it if it doesn't exist allready
    // for debugging purposes only
    //
    TObjArray *arr = &fPadPedestalArrayEvent;
    return GetVectSector(sector,arr,fROC->GetNChannels(sector),force);
}
//_____________________________________________________________________
TVectorF* AliTPCCalibCE::GetTMeanEvents(Int_t sector, Bool_t force)
{
    //
    // return pointer to the EbyE info of the mean arrival time for 'sector'
    // if force is true create it if it doesn't exist allready
    //
    TObjArray *arr = &fTMeanArrayEvent;
    return GetVectSector(sector,arr,100,force);
}
//_____________________________________________________________________
TVectorF* AliTPCCalibCE::GetQMeanEvents(Int_t sector, Bool_t force)
{
    //
    // return pointer to the EbyE info of the mean arrival time for 'sector'
    // if force is true create it if it doesn't exist allready
    //
    TObjArray *arr = &fQMeanArrayEvent;
    return GetVectSector(sector,arr,100,force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibCE::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) const
{
    //
    // return pointer to ROC Calibration
    // if force is true create a new histogram if it doesn't exist allready
    //
    if ( !force || arr->UncheckedAt(sector) )
	return (AliTPCCalROC*)arr->UncheckedAt(sector);

    // if we are forced and histogram doesn't yes exist create it

    // new AliTPCCalROC for T0 information. One value for each pad!
    AliTPCCalROC *croc = new AliTPCCalROC(sector);
    arr->AddAt(croc,sector);
    return croc;
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibCE::GetCalRocT0(Int_t sector, Bool_t force)
{
    //
    // return pointer to Time 0 ROC Calibration
    // if force is true create a new histogram if it doesn't exist allready
    //
    TObjArray *arr = &fCalRocArrayT0;
    return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibCE::GetCalRocT0Err(Int_t sector, Bool_t force)
{
    //
    // return pointer to the error of Time 0 ROC Calibration
    // if force is true create a new histogram if it doesn't exist allready
    //
    TObjArray *arr = &fCalRocArrayT0Err;
    return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibCE::GetCalRocQ(Int_t sector, Bool_t force)
{
    //
    // return pointer to T0 ROC Calibration
    // if force is true create a new histogram if it doesn't exist allready
    //
    TObjArray *arr = &fCalRocArrayQ;
    return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibCE::GetCalRocRMS(Int_t sector, Bool_t force)
{
    //
    // return pointer to signal width ROC Calibration
    // if force is true create a new histogram if it doesn't exist allready
    //
    TObjArray *arr = &fCalRocArrayRMS;
    return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibCE::GetCalRocOutliers(Int_t sector, Bool_t force)
{
    //
    // return pointer to Outliers
    // if force is true create a new histogram if it doesn't exist allready
    //
    TObjArray *arr = &fCalRocArrayOutliers;
    return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
TObjArray* AliTPCCalibCE::GetParamArray(Int_t sector, TObjArray* arr, Bool_t force) const
{
    //
    // return pointer to TObjArray of fit parameters
    // if force is true create a new histogram if it doesn't exist allready
    //
    if ( !force || arr->UncheckedAt(sector) )
	return (TObjArray*)arr->UncheckedAt(sector);

    // if we are forced and array doesn't yes exist create it

    // new TObjArray for parameters
    TObjArray *newArr = new TObjArray;
    arr->AddAt(newArr,sector);
    return newArr;
}
//_____________________________________________________________________
TObjArray* AliTPCCalibCE::GetParamArrayPol1(Int_t sector, Bool_t force)
{
    //
    // return pointer to TObjArray of fit parameters from plane fit
    // if force is true create a new histogram if it doesn't exist allready
    //
    TObjArray *arr = &fParamArrayEventPol1;
    return GetParamArray(sector, arr, force);
}
//_____________________________________________________________________
TObjArray* AliTPCCalibCE::GetParamArrayPol2(Int_t sector, Bool_t force)
{
    //
    // return pointer to TObjArray of fit parameters from parabola fit
    // if force is true create a new histogram if it doesn't exist allready
    //
    TObjArray *arr = &fParamArrayEventPol2;
    return GetParamArray(sector, arr, force);
}

//_____________________________________________________________________
void AliTPCCalibCE::CreateDVhist()
{
  //
  // Setup the THnSparse for the drift velocity determination
  //

  //HnSparse bins
  //roc, row, pad, timebin, timestamp
  TTimeStamp begin(2010,01,01,0,0,0);
  TTimeStamp end(2035,01,01,0,0,0);
  Int_t nbinsTime=(end.GetSec()-begin.GetSec())/60; //Minutes resolution
  
  Int_t    bins[kHnBinsDV] = { 72,  96,  140,  1030, nbinsTime};
  Double_t xmin[kHnBinsDV] = { 0.,  0.,   0.,    0., (Double_t)begin.GetSec()};
  Double_t xmax[kHnBinsDV] = {72., 96., 140., 1030., (Double_t)end.GetSec()};
  
  fHnDrift=new THnSparseI("fHnDrift","Laser digits",kHnBinsDV, bins, xmin, xmax);
  fHnDrift->GetAxis(0)->SetNameTitle("ROC","Read-out chamber number");
  fHnDrift->GetAxis(1)->SetNameTitle("Row","Row number");
  fHnDrift->GetAxis(2)->SetNameTitle("Pad","Pad number");
  fHnDrift->GetAxis(3)->SetNameTitle("Timebin","Time bin [x100ns]");
  fHnDrift->GetAxis(4)->SetNameTitle("EventTime","Event time");
  fHnDrift->Reset();
}

//_____________________________________________________________________
void AliTPCCalibCE::ResetEvent()
{
    //
    //  Reset global counters  -- Should be called before each event is processed
    //
    fLastSector=-1;
    fCurrentSector=-1;
    fCurrentRow=-1;
    fCurrentChannel=-1;

    ResetPad();

    fPadTimesArrayEvent.Delete();
    fPadQArrayEvent.Delete();
    fPadRMSArrayEvent.Delete();
    fPadPedestalArrayEvent.Delete();

    for ( Int_t i=0; i<72; ++i ){
	fVTime0Offset.GetMatrixArray()[i]=0;
	fVTime0OffsetCounter.GetMatrixArray()[i]=0;
	fVMeanQ.GetMatrixArray()[i]=0;
        fVMeanQCounter.GetMatrixArray()[i]=0;
    }
}
//_____________________________________________________________________
void AliTPCCalibCE::ResetPad()
{
    //
    //  Reset pad infos -- Should be called after a pad has been processed
    //
    for (Int_t i=fFirstTimeBin; i<fLastTimeBin+1; ++i)
      fPadSignal[i] = 0;
    fMaxTimeBin   = -1;
    fMaxPadSignal = -1;
    fPadPedestal  = -1;
    fPadNoise     = -1;
}
//_____________________________________________________________________
void AliTPCCalibCE::Merge(AliTPCCalibCE * const ce)
{
  //
  //  Merge ce to the current AliTPCCalibCE
  //
  MergeBase(ce);
  Int_t nCEevents = ce->GetNeventsProcessed();
  
  if (fProcessOld&&ce->fProcessOld){
  //merge histograms
    for (Int_t iSec=0; iSec<72; ++iSec){
      TH2S *hRefQmerge   = ce->GetHistoQ(iSec);
      TH2S *hRefT0merge  = ce->GetHistoT0(iSec);
      TH2S *hRefRMSmerge = ce->GetHistoRMS(iSec);
      
      
      if ( hRefQmerge ){
        TDirectory *dir = hRefQmerge->GetDirectory(); hRefQmerge->SetDirectory(0);
        TH2S *hRefQ   = GetHistoQ(iSec);
        if ( hRefQ ) hRefQ->Add(hRefQmerge);
        else {
          TH2S *hist = new TH2S(*hRefQmerge);
          hist->SetDirectory(0);
          fHistoQArray.AddAt(hist, iSec);
        }
        hRefQmerge->SetDirectory(dir);
      }
      if ( hRefT0merge ){
        TDirectory *dir = hRefT0merge->GetDirectory(); hRefT0merge->SetDirectory(0);
        TH2S *hRefT0  = GetHistoT0(iSec);
        if ( hRefT0 ) hRefT0->Add(hRefT0merge);
        else {
          TH2S *hist = new TH2S(*hRefT0merge);
          hist->SetDirectory(0);
          fHistoT0Array.AddAt(hist, iSec);
        }
        hRefT0merge->SetDirectory(dir);
      }
      if ( hRefRMSmerge ){
        TDirectory *dir = hRefRMSmerge->GetDirectory(); hRefRMSmerge->SetDirectory(0);
        TH2S *hRefRMS = GetHistoRMS(iSec);
        if ( hRefRMS ) hRefRMS->Add(hRefRMSmerge);
        else {
          TH2S *hist = new TH2S(*hRefRMSmerge);
          hist->SetDirectory(0);
          fHistoRMSArray.AddAt(hist, iSec);
        }
        hRefRMSmerge->SetDirectory(dir);
      }
      
    }
    
    // merge time information
    
    
    for (Int_t iSec=0; iSec<72; ++iSec){
      TObjArray *arrPol1CE  = ce->GetParamArrayPol1(iSec);
      TObjArray *arrPol2CE  = ce->GetParamArrayPol2(iSec);
      TVectorF *vMeanTimeCE = ce->GetTMeanEvents(iSec);
      TVectorF *vMeanQCE    = ce->GetQMeanEvents(iSec);
      
      TObjArray *arrPol1  = 0x0;
      TObjArray *arrPol2  = 0x0;
      TVectorF *vMeanTime = 0x0;
      TVectorF *vMeanQ    = 0x0;
      
  //resize arrays
      if ( arrPol1CE && arrPol2CE ){
        arrPol1 = GetParamArrayPol1(iSec,kTRUE);
        arrPol2 = GetParamArrayPol2(iSec,kTRUE);
        arrPol1->Expand(fNevents+nCEevents);
        arrPol2->Expand(fNevents+nCEevents);
      }
      if ( vMeanTimeCE && vMeanQCE ){
        vMeanTime = GetTMeanEvents(iSec,kTRUE);
        vMeanQ    = GetQMeanEvents(iSec,kTRUE);
        vMeanTime->ResizeTo(fNevents+nCEevents);
        vMeanQ->ResizeTo(fNevents+nCEevents);
      }
      
      for (Int_t iEvent=0; iEvent<nCEevents; ++iEvent){
        if ( arrPol1CE && arrPol2CE ){
          TVectorD *paramPol1 = (TVectorD*)(arrPol1CE->UncheckedAt(iEvent));
          TVectorD *paramPol2 = (TVectorD*)(arrPol2CE->UncheckedAt(iEvent));
          if ( paramPol1 && paramPol2 ){
            GetParamArrayPol1(iSec,kTRUE)->AddAt(new TVectorD(*paramPol1), fNevents+iEvent);
            GetParamArrayPol2(iSec,kTRUE)->AddAt(new TVectorD(*paramPol2), fNevents+iEvent);
          }
        }
        if ( vMeanTimeCE && vMeanQCE ){
          vMeanTime->GetMatrixArray()[fNevents+iEvent]=vMeanTimeCE->GetMatrixArray()[iEvent];
          vMeanQ->GetMatrixArray()[fNevents+iEvent]=vMeanQCE->GetMatrixArray()[iEvent];
        }
      }
    }
    
    
    
    const TVectorD&  eventTimes  = ce->fVEventTime;
    const TVectorD&  eventIds    = ce->fVEventNumber;
    const TVectorF&  time0SideA  = ce->fVTime0SideA;
    const TVectorF&  time0SideC  = ce->fVTime0SideC;
    fVEventTime.ResizeTo(fNevents+nCEevents);
    fVEventNumber.ResizeTo(fNevents+nCEevents);
    fVTime0SideA.ResizeTo(fNevents+nCEevents);
    fVTime0SideC.ResizeTo(fNevents+nCEevents);

    for (Int_t iEvent=0; iEvent<nCEevents; ++iEvent){
      Double_t evTime     = eventTimes.GetMatrixArray()[iEvent];
      Double_t evId       = eventIds.GetMatrixArray()[iEvent];
      Float_t  t0SideA    = time0SideA.GetMatrixArray()[iEvent];
      Float_t  t0SideC    = time0SideC.GetMatrixArray()[iEvent];
      
      fVEventTime.GetMatrixArray()[fNevents+iEvent]   = evTime;
      fVEventNumber.GetMatrixArray()[fNevents+iEvent] = evId;
      fVTime0SideA.GetMatrixArray()[fNevents+iEvent]  = t0SideA;
      fVTime0SideC.GetMatrixArray()[fNevents+iEvent]  = t0SideC;
    }
  }

  if (fProcessNew&&ce->fProcessNew) {
    if (fArrHnDrift.GetEntries() != ce->fArrHnDrift.GetEntries() ){
      AliError("Number of bursts in the instances to merge are different. No merging done!");
    } else {
      for (Int_t i=0;i<fArrHnDrift.GetEntries();++i){
        THnSparseI *h=(THnSparseI*)fArrHnDrift.UncheckedAt(i);
        THnSparseI *hce=(THnSparseI*)ce->fArrHnDrift.UncheckedAt(i);
        if (h && hce) h->Add(hce);
        else AliError(Form("AliTPCCalibCE::Merge - one THnSparse missing in burst %d",i));
      }
      //TODO: What to do with fTimeBursts???
    }
  }
  
  fNevents+=nCEevents; //increase event counter
}

//_____________________________________________________________________
Long64_t AliTPCCalibCE::Merge(TCollection * const list)
{
  //
  // Merge all objects of this type in list
  //

  Long64_t nmerged=1;

  TIter next(list);
  AliTPCCalibCE *ce=0;
  TObject *o=0;

  while ( (o=next()) ){
    ce=dynamic_cast<AliTPCCalibCE*>(o);
    if (ce){
      Merge(ce);
      ++nmerged;
    }
  }

  return nmerged;
}

//_____________________________________________________________________
TGraph *AliTPCCalibCE::MakeGraphTimeCE(Int_t sector, Int_t xVariable, Int_t fitType, Int_t fitParameter)
{
  //
  // Make graph from fit parameters of pol1 fit, pol2 fit, mean arrival time or mean Q for ROC 'sector'
  // or side (-1: A-Side, -2: C-Side)
  // xVariable:    0-event time, 1-event id, 2-internal event counter
  // fitType:      0-pol1 fit, 1-pol2 fit, 2-mean time, 3-mean Q
  // fitParameter: fit parameter ( 0-2 for pol1 ([0]+[1]*x+[2]*y),
  //                               0-5 for pol2 ([0]+[1]*x+[2]*y+[3]*x*x+[4]*y*y+[5]*x*y),
  //                               not used for mean time and mean Q )
  // for an example see class description at the beginning
  //

  TVectorD *xVar = 0x0;
  TObjArray *aType = 0x0;
  Int_t npoints=0;

  // sanity checks
  if ( (sector<-2)   || (sector>71)   ) return 0x0;  //sector outside valid range
  if ( (xVariable<0) || (xVariable>2) ) return 0x0;  //invalid x-variable
  if ( (fitType<0)   || (fitType>3)   ) return 0x0;  //invalid fit type
  if ( sector>=0 && fitType==2 && !GetTMeanEvents(sector) ) return 0x0; //no mean time information available
  if ( sector>=0 && fitType==3 && !GetQMeanEvents(sector) ) return 0x0; //no mean charge information available
  if ( sector<0 && fitType!=2) return 0x0;  //for side wise information only mean time is available

  if (sector>=0){
    if ( fitType==0 ){
      if ( (fitParameter<0) || (fitParameter>2) ) return 0x0;
      aType = &fParamArrayEventPol1;
      if ( aType->At(sector)==0x0 ) return 0x0;
    }
    else if ( fitType==1 ){
      if ( (fitParameter<0) || (fitParameter>5) ) return 0x0;
      aType = &fParamArrayEventPol2;
      if ( aType->At(sector)==0x0 ) return 0x0;
    }

  }
  if ( xVariable == 0 ) xVar = &fVEventTime;
  if ( xVariable == 1 ) xVar = &fVEventNumber;
  if ( xVariable == 2 ) {
    xVar = new TVectorD(fNevents);
    for ( Int_t i=0;i<fNevents; ++i) (*xVar)[i]=i;
  }
  
  Double_t *x = new Double_t[fNevents];
  Double_t *y = new Double_t[fNevents];
  
  for (Int_t ievent =0; ievent<fNevents; ++ievent){
    if ( fitType<2 ){
      TObjArray *events = (TObjArray*)(aType->At(sector));
      if ( events->GetSize()<=ievent ) break;
      TVectorD *v = (TVectorD*)(events->At(ievent));
      if ( (v!=0x0) && ((*xVar)[ievent]>0) ) { x[npoints]=(*xVar)[ievent]; y[npoints]=(*v)[fitParameter]; npoints++;}
    } else if (fitType == 2) {
      Double_t xValue=(*xVar)[ievent];
      Double_t yValue=0;
      if (sector>=0) yValue = (*GetTMeanEvents(sector))[ievent];
      else if (sector==-1) yValue=fVTime0SideA(ievent);
      else if (sector==-2) yValue=fVTime0SideC(ievent);
      if ( yValue>0 && xValue>0 ) { x[npoints]=xValue; y[npoints]=yValue;npoints++;}
    }else if (fitType == 3) {
      Double_t xValue=(*xVar)[ievent];
      Double_t yValue=(*GetQMeanEvents(sector))[ievent];
      if ( yValue>0 && xValue>0 ) { x[npoints]=xValue; y[npoints]=yValue;npoints++;}
    }
  }

  TGraph *gr = new TGraph(npoints);
    //sort xVariable increasing
  Int_t    *sortIndex = new Int_t[npoints];
  TMath::Sort(npoints,x,sortIndex, kFALSE);
  for (Int_t i=0;i<npoints;++i){
    gr->SetPoint(i,x[sortIndex[i]],y[sortIndex[i]]);
  }


  if ( xVariable == 2 ) delete xVar;
  delete [] x;
  delete [] y;
  delete [] sortIndex;
  return gr;
}
//_____________________________________________________________________
void AliTPCCalibCE::Analyse()
{
  //
  //  Calculate calibration constants
  //

  if (fProcessOld){
    TVectorD paramQ(3);
    TVectorD paramT0(3);
    TVectorD paramRMS(3);
    TMatrixD dummy(3,3);
    
    Float_t channelCounter=0;
    fMeanT0rms=0;
    fMeanQrms=0;
    fMeanRMSrms=0;
    
    for (Int_t iSec=0; iSec<72; ++iSec){
      TH2S *hT0 = GetHistoT0(iSec);
      if (!hT0 ) continue;
      
      AliTPCCalROC *rocQ     = GetCalRocQ  (iSec,kTRUE);
      AliTPCCalROC *rocT0    = GetCalRocT0 (iSec,kTRUE);
      AliTPCCalROC *rocT0Err = GetCalRocT0Err (iSec,kTRUE);
      AliTPCCalROC *rocRMS   = GetCalRocRMS(iSec,kTRUE);
      AliTPCCalROC *rocOut   = GetCalRocOutliers(iSec,kTRUE);
      
      TH2S *hQ   = GetHistoQ(iSec);
      TH2S *hRMS = GetHistoRMS(iSec);
      
      Short_t *arrayhQ   = hQ->GetArray();
      Short_t *arrayhT0  = hT0->GetArray();
      Short_t *arrayhRMS = hRMS->GetArray();
      
      UInt_t nChannels = fROC->GetNChannels(iSec);
      
  //debug
      Int_t row=0;
      Int_t pad=0;
      Int_t padc=0;
  //! debug
      
      for (UInt_t iChannel=0; iChannel<nChannels; ++iChannel){
        
        
        Float_t cogTime0 = -1000;
        Float_t cogQ     = -1000;
        Float_t cogRMS   = -1000;
        Float_t cogOut   = 0;
        Float_t rms      = 0;
        Float_t rmsT0    = 0;
        
        
        Int_t offsetQ = (fNbinsQ+2)*(iChannel+1)+1;
        Int_t offsetT0 = (fNbinsT0+2)*(iChannel+1)+1;
        Int_t offsetRMS = (fNbinsRMS+2)*(iChannel+1)+1;
        
        cogQ     = AliMathBase::GetCOG(arrayhQ+offsetQ,fNbinsQ,fXminQ,fXmaxQ,&rms);
        fMeanQrms+=rms;
        cogTime0 = AliMathBase::GetCOG(arrayhT0+offsetT0,fNbinsT0,fXminT0,fXmaxT0,&rmsT0);
        fMeanT0rms+=rmsT0;
        cogRMS   = AliMathBase::GetCOG(arrayhRMS+offsetRMS,fNbinsRMS,fXminRMS,fXmaxRMS,&rms);
        fMeanRMSrms+=rms;
        channelCounter++;
        
      /*
             //outlier specifications
         if ( (cogQ < ??) && (cogTime0 > ??) && (cogTime0<??) && ( cogRMS>??) ){
         cogOut = 1;
          cogTime0 = 0;
          cogQ     = 0;
          cogRMS   = 0;
      }
      */
        rocQ->SetValue(iChannel, cogQ*cogQ);
        rocT0->SetValue(iChannel, cogTime0);
        rocT0Err->SetValue(iChannel, rmsT0);
        rocRMS->SetValue(iChannel, cogRMS);
        rocOut->SetValue(iChannel, cogOut);
        
        
      //debug
        if ( GetStreamLevel() > 0 ){
          TTreeSRedirector *streamer=GetDebugStreamer();
          if ( streamer ) {
            
            while ( iChannel > (fROC->GetRowIndexes(iSec)[row]+fROC->GetNPads(iSec,row)-1) ) row++;
            pad = iChannel-fROC->GetRowIndexes(iSec)[row];
            padc = pad-(fROC->GetNPads(iSec,row)/2);
            
            (*streamer) << "DataEnd" <<
              "Sector="  << iSec      <<
              "Pad="     << pad       <<
              "PadC="    << padc      <<
              "Row="     << row       <<
              "PadSec="  << iChannel   <<
              "Q="       << cogQ      <<
              "T0="      << cogTime0  <<
              "RMS="     << cogRMS    <<
              "\n";
          }
        }
      //! debug
        
      }
      
    }
    if ( channelCounter>0 ){
      fMeanT0rms/=channelCounter;
      fMeanQrms/=channelCounter;
      fMeanRMSrms/=channelCounter;
    }
    //   if ( fDebugStreamer ) fDebugStreamer->GetFile()->Write();
    //    delete fDebugStreamer;
    //    fDebugStreamer = 0x0;
    fVEventTime.ResizeTo(fNevents);
    fVEventNumber.ResizeTo(fNevents);
    fVTime0SideA.ResizeTo(fNevents);
    fVTime0SideC.ResizeTo(fNevents);
  }

  if (fProcessNew&&fAnalyseNew){
    AnalyseTrack();
    for (Int_t iburst=0; iburst<fArrHnDrift.GetEntries(); ++iburst){
      THnSparseI *h=(THnSparseI*)fArrHnDrift.UncheckedAt(iburst);
      h->GetAxis(4)->SetRangeUser(fTimeBursts[iburst]-60*5,fTimeBursts[iburst]+60*5);
    }
  }
}




//
// New functions that also use the laser tracks
//



//_____________________________________________________________________
void AliTPCCalibCE::FindLocalMaxima(TObjArray * const arrObj, Double_t timestamp, Int_t burst)
{
  //
  //Find the local maximums for the projections to each axis
  //
  
  //find laser layer positoins
  fHnDrift->GetAxis(4)->SetRangeUser(timestamp-2*60,timestamp+2*60);
  FindLaserLayers();
  THnSparse *hProj=fHnDrift;
  Double_t posCE[4]={0.,0.,0.,0.};
  Double_t widthCE[4]={0.,0.,0.,0.};
  
//   if(fPeaks[4]!=0){
  // find central electrode position once more, separately for IROC, OROC, A-, C-Side
  
  for (Int_t i=0; i<4; ++i){
    Int_t ce=(i/2>0)*7+6;
    hProj->GetAxis(0)->SetRangeUser(i*18,(i+1)*18-1);
    TH1 *h=fHnDrift->Projection(3);
    h->GetXaxis()->SetRangeUser(fPeaks[ce]-fPeakWidths[ce],fPeaks[ce]+fPeakWidths[ce]);
    Int_t nbinMax=h->GetMaximumBin();
    Double_t maximum=h->GetMaximum();
//     Double_t maxExpected=fNevents/fArrHnDrift->GetEntries()*556568./5./10.;
//     if (nbinMax<700||maximum<maxExpected) continue;
    Double_t xbinMax=h->GetBinCenter(nbinMax);
    TF1 fgaus("gaus","gaus",xbinMax-5,xbinMax+5);
    fgaus.SetParameters(maximum,xbinMax,2);
    fgaus.SetParLimits(1,xbinMax-5.,xbinMax+5.);
    fgaus.SetParLimits(2,0.2,4.);
    h->Fit(&fgaus,"RQN");
//     Double_t deltaX=4*fgaus.GetParameter(2);
//     xbinMax=fgaus.GetParameter(1);
    delete h;
    posCE[i]=fgaus.GetParameter(1);
    widthCE[i]=4*fgaus.GetParameter(2);
    hProj->GetAxis(0)->SetRangeUser(0,72);
  }
//   }
  //Current drift velocity
  Float_t vdrift=2.61301900000000000e+06;//fParam->GetDriftV();
//   cout<<"vdrift="<<vdrift<<endl;
  
  AliDebug(5,Form("Timestamp %f - default drift velocity %f",timestamp,vdrift));
  //loop over all entries in the histogram
  Int_t coord[5];
  for(Long64_t ichunk=0;ichunk<hProj->GetNbins();ichunk++){
    //get entry position and content
    Double_t adc=hProj->GetBinContent(ichunk,coord);
    
    
    Int_t sector = coord[0]-1;
    Int_t row    = coord[1]-1;
    Int_t pad    = coord[2]-1;
    Int_t timeBin= coord[3]-1;
    Double_t time   = fHnDrift->GetAxis(4)->GetBinCenter(coord[4]);
    Int_t side   = (sector/18)%2;
//     return;
//     fPeaks[4]=(UInt_t)posCE[sector/18];
//     fPeakWidths[4]=(UInt_t)widthCE[sector/18];
    
    //cuts
    if (time<timestamp-120||time>timestamp+120) continue; //window of +- 2min
    if (adc < 5 ) continue;
    if (IsEdgePad(sector,row,pad)) continue;
//     if (!IsPeakInRange(timeBin)) continue;
//     if (isCE&&((row%2)||(row%2)||(sector%2))) continue;
//     if (isCE&&(sector!=0)) continue;
    
    Int_t padmin=-2, padmax=2;
    Int_t timemin=-2, timemax=2;
    Int_t minsumperpad=2;
    //CE or laser tracks
    Bool_t isCE=kFALSE;
    if (TMath::Abs((Short_t)timeBin-(Short_t)posCE[sector/18])<(Short_t)widthCE[sector/18]) {
      isCE=kTRUE;
      padmin=0;
      padmax=0;
      timemin=-3;
      timemax=7;
    }
    
    //
    // Find local maximum and cogs
    //
    Bool_t isMaximum=kTRUE;
    Float_t totalmass=0, tbcm=0, padcm=0, rmstb=0, rmspad=0;
    Double_t cogY=0, rmsY=0;
    Int_t npart=0;
    
    // for position calculation use
    for(Int_t ipad=padmin;ipad<=padmax;++ipad){
      Float_t lxyz[3];
      fROC->GetPositionLocal(sector,row,pad+ipad,lxyz);
      
      for(Int_t itime=timemin;itime<=timemax;++itime){
        
        Int_t a[5]={coord[0],coord[1],coord[2]+ipad,coord[3]+itime,coord[4]};
        Double_t val=hProj->GetBinContent(a);
        totalmass+=val;
        
        tbcm +=(timeBin+itime)*val;
        padcm+=(pad+ipad)*val;
        cogY +=lxyz[1]*val;
        
        rmstb +=(timeBin+itime)*(timeBin+itime)*val;
        rmspad+=(pad+ipad)*(pad+ipad)*val;
        rmsY  +=lxyz[1]*lxyz[1]*val;
        
        if (val>0) ++npart;
        if (val>adc) {
          isMaximum=kFALSE;
          break;
        }
      }
      if (!isMaximum)  break;
    }
    
    if (!isMaximum||!npart)  continue;
    if (totalmass<npart*minsumperpad) continue;
    if (!isCE&&rmspad<.1) continue; //most probably noise, since signal only in one pad,
                                    //for CE we want only one pad by construction
    
    tbcm/=totalmass;
    padcm/=totalmass;
    cogY/=totalmass;
    
    rmstb/=totalmass;
    rmspad/=totalmass;
    rmsY/=totalmass;
    
    rmstb=TMath::Sqrt(TMath::Abs(tbcm*tbcm-rmstb));
    rmspad=TMath::Sqrt(TMath::Abs(padcm*padcm-rmspad));
    rmsY=TMath::Sqrt(TMath::Abs(cogY*cogY-rmsY));
    
    Int_t cog=TMath::Nint(padcm);
    
    // timebin --> z position
    Float_t zlength=fParam->GetZLength(side);
//     Float_t timePos=tbcm+(1000-fPeaks[4])
    // drift velocity is in m/s we would like to have cm/100ns, so 100cm/(10^7*100ns)
    Double_t gz=(zlength-(tbcm*vdrift*1.e-7))*TMath::Power(-1,side);
    
    // local to global transformation--> x and y positions
    Float_t padlxyz[3];
    fROC->GetPositionLocal(sector,row,pad,padlxyz);
    
    Double_t gxyz[3]={padlxyz[0],cogY,gz};
    Double_t lxyz[3]={padlxyz[0],cogY,gz};
    Double_t igxyz[3]={0,0,0};
    AliTPCTransform t1;
    t1.RotatedGlobal2Global(sector,gxyz);
    
    Double_t mindist=0;
    Int_t trackID=-1;
    Int_t trackID2=-1;
    
    //find track id and index of the position in the track (row)
    Int_t index=0;
    if (!isCE){
      index=row+(sector>35)*fROC->GetNRows(0);
      trackID=FindLaserTrackID(sector,index,gxyz,mindist,lxyz,trackID2);
    } else {
      trackID=336+((sector/18)%2);
      index= fROC->GetRowIndexes(sector)[row]+pad; //  global pad position in sector
      if (sector<36) {
        index+=(sector%18)*fROC->GetNChannels(sector);
      } else {
        index+=18*fROC->GetNChannels(0);
        index+=(sector%18)*fROC->GetNChannels(sector);
      }
      //TODO: find out about the multiple peaks in the CE
//       mindist=TMath::Abs(fPeaks[4]-tbcm);
      mindist=1.;
    }
    
    // fill track vectors
    if (trackID>0){
      AliTPCLaserTrack *ltr=(AliTPCLaserTrack*)arrObj->UncheckedAt(trackID);
      Double_t oldMinDist=ltr->fVecPhi->GetMatrixArray()[index];
      
      
//      travel time effect of light includes
      
      Double_t raylength=ltr->GetRayLength();
      Double_t globmir[3]={ltr->Xv(),ltr->Yv(),ltr->Zv()};
      ltr->GetXYZ(globmir);
      if(trackID<336){
        if(side==0){
          gxyz[2]=gxyz[2]-(TMath::Sqrt((gxyz[0]-globmir[0])*(gxyz[0]-globmir[0])
                                       +(gxyz[1]-globmir[1])*(gxyz[1]-globmir[1])
                                       +(gxyz[2]-globmir[2])*(gxyz[2]-globmir[2])+raylength))*vdrift*TMath::Power(10.,-6.)/30000;
        }
        else {
          gxyz[2]=gxyz[2]-(TMath::Sqrt((gxyz[0]-globmir[0])*(gxyz[0]-globmir[0])
                                       +(gxyz[1]-globmir[1])*(gxyz[1]-globmir[1])
                                       +(gxyz[2]-globmir[2])*(gxyz[2]-globmir[2])+raylength))*vdrift*TMath::Power(10.,-6.)/30000;
        }
      }
      
      if (TMath::Abs(oldMinDist)<1.e-20||oldMinDist>mindist){
        ltr->fVecSec->GetMatrixArray()[index]=sector;
        ltr->fVecP2->GetMatrixArray()[index]=0;
        ltr->fVecPhi->GetMatrixArray()[index]=mindist;
        ltr->fVecGX->GetMatrixArray()[index]=gxyz[0];
        ltr->fVecGY->GetMatrixArray()[index]=gxyz[1];
        ltr->fVecGZ->GetMatrixArray()[index]=gxyz[2];
        ltr->fVecLX->GetMatrixArray()[index]=lxyz[0];
        ltr->fVecLY->GetMatrixArray()[index]=lxyz[1];
        ltr->fVecLZ->GetMatrixArray()[index]=lxyz[2];
//         ltr->SetUniqueID((UInt_t)(mindist*10000)); //distance in um
      }
      TObjArray *arr=AliTPCLaserTrack::GetTracks();
      ltr=(AliTPCLaserTrack*)arr->UncheckedAt(trackID);
      igxyz[0]=ltr->fVecGX->GetMatrixArray()[row];
      igxyz[1]=ltr->fVecGY->GetMatrixArray()[row];
      igxyz[2]=ltr->fVecGZ->GetMatrixArray()[row];
    }
    
    
    if (fStreamLevel>4){
      (*GetDebugStreamer()) << "clusters" <<
        "run="   << fRunNumber <<
        "timestamp=" << timestamp <<
        "burst="     << burst     <<
        "side="      << side      <<
        "sec="       << sector    <<
        "row="       << row       <<
        "pad="       << pad       <<
        "padCog="    << cog       <<
        "timebin="   << timeBin   <<
        "cogCE="     << posCE[sector/18] <<
        "withCE="    << widthCE[sector/18] <<
        "index="     << index     <<
        
        "padcm="     << padcm     <<
        "rmspad="    << rmspad    <<
        
        "cogtb="     << tbcm      <<
        "rmstb="     << rmstb     <<
        
        "npad="      << npart     <<
        
        "lx="        << padlxyz[0]<<
        "ly="        << cogY      <<
        "lypad="     << padlxyz[1]<<
        "rmsY="      << rmsY      <<
        
        "gx="        << gxyz[0]   <<
        "gy="        << gxyz[1]   <<
        "gz="        << gxyz[2]   <<
        
        "igx="        << igxyz[0] <<
        "igy="        << igxyz[1] <<
        "igz="        << igxyz[2] <<
        
        "mind="      << mindist   <<
        "max="       << adc       <<
        "trackid="   << trackID   <<
        "trackid2="   << trackID2   <<
        "npart="     << npart     <<
        "\n";
    } // end stream levelmgz.fElements
    
  }
  
}

//_____________________________________________________________________
void AliTPCCalibCE::AnalyseTrack()
{
  //
  //  Analyse the tracks
  //
  
  
  AliTPCLaserTrack::LoadTracks();
//   AliTPCParam *param=0x0;
//   //cdb run number
//   AliCDBManager *man=AliCDBManager::Instance();
//   if (man->GetDefaultStorage()){
//     AliCDBEntry *entry=man->Get("TPC/Calib/Parameters",fRunNumber);
//     if (entry){
//       entry->SetOwner(kTRUE);
//       param = (AliTPCParam*)(entry->GetObject()->Clone());
//     }
//   }
//   if (param){
//     if (fParam) delete fParam;
//     fParam=param;
//   } else {
//     AliError("Could not get updated AliTPCParam from OCDB!!!");
//   }
  
  //Measured and ideal laser tracks
  TObjArray* arrMeasured = SetupMeasured();
  TObjArray* arrIdeal    = AliTPCLaserTrack::GetTracks();
  AddCEtoIdeal(arrIdeal);
  
  //find bursts and loop over them
  for (Int_t iburst=0; iburst<fArrHnDrift.GetEntries();++iburst){
    Double_t timestamp=fTimeBursts[iburst];
    AliDebug(5,Form("Burst: %d (%f)",iburst,timestamp));
    fHnDrift=(THnSparseI*)fArrHnDrift.UncheckedAt(iburst);
    if (!fHnDrift) continue;
    UInt_t entries=(UInt_t)fHnDrift->GetEntries();
    if (fBinsLastAna[iburst]>=entries) continue; //already analysed!!!
    fBinsLastAna[iburst]=entries;
    
    for (Int_t iDim=0; iDim<fHnDrift->GetNdimensions(); ++iDim) fHnDrift->GetAxis(iDim)->SetRange(0,0);
//     if (iburst==0) FindLaserLayers();
    
    //reset laser tracks
    ResetMeasured(arrMeasured);
    
    //find clusters and associate to the tracks
    FindLocalMaxima(arrMeasured, timestamp, iburst);
    
    //calculate drift velocity
    CalculateDV(arrIdeal,arrMeasured,iburst);
    
    //Dump information to file if requested
    if (fStreamLevel>2){
      //printf("make tree\n");
      //laser track information
      
      for (Int_t itrack=0; itrack<338; ++itrack){
        TObject *iltr=arrIdeal->UncheckedAt(itrack);
        TObject *mltr=arrMeasured->UncheckedAt(itrack);
        (*GetDebugStreamer()) << "tracks" <<
          "run="   << fRunNumber <<
          "time=" << timestamp <<
          "burst="<< iburst <<
          "iltr.=" << iltr <<
          "mltr.=" << mltr <<
          "\n";
      }
    }
  }
  if (fStreamLevel>0) GetDebugStreamer()->GetFile()->Write();
}

//_____________________________________________________________________
Int_t AliTPCCalibCE::FindLaserTrackID(Int_t sector,Int_t row, const Double_t *peakpos,Double_t &mindist,
                                      const Double_t *peakposloc, Int_t &itrackMin2)
{
  //
  //  Find the tracks, which are closest to the ideal tracks, from clusters closest to the ideal tracks
  //
  
  
  TObjArray *arr=AliTPCLaserTrack::GetTracks();
  TVector3 vP(peakpos[0],peakpos[1],peakpos[2]);
  TVector3 vDir;
  TVector3 vSt;
  
  Int_t firstbeam=0;
  Int_t lastbeam=336/2;
  if ( (sector/18)%2 ) {
    firstbeam=336/2;
    lastbeam=336;
  }
  
  mindist=1000000;
  Int_t itrackMin=-1;
  for (Int_t itrack=firstbeam; itrack<lastbeam; ++itrack){
    AliTPCLaserTrack *ltr=(AliTPCLaserTrack*)arr->At(itrack);  //get the track
//     if (ltr->GetVecSec()->GetMatrixArray()[row]!=sector) continue;
    vSt.SetXYZ(ltr->GetX(),ltr->GetY(),ltr->GetZ());
    Double_t deltaZ=ltr->GetZ()-peakpos[2];
    if (TMath::Abs(deltaZ)>40) continue;
    vDir.SetMagThetaPhi(1,ltr->Theta(),TMath::ASin(ltr->GetSnp()));
    vSt.RotateZ(ltr->GetAlpha());
    vDir.RotateZ(ltr->GetAlpha());
    
    Double_t dist=(vDir.Cross(vSt-vP)).Mag()/vDir.Mag();
    
    if (dist<mindist){
      mindist=dist;
      itrackMin=itrack;
    }
    
  }
  itrackMin2=-1;
  Float_t mindist2=10;
  for (Int_t itrack=firstbeam; itrack<lastbeam; ++itrack){
    AliTPCLaserTrack *ltr=(AliTPCLaserTrack*)arr->At(itrack);  //get the track
    if ((ltr->fVecSec->GetMatrixArray())[row]!=sector) continue;
    
    Double_t deltaZ=ltr->GetZ()-peakpos[2];
    if (TMath::Abs(deltaZ)>40) continue;
    
    Double_t dist=TMath::Abs((ltr->fVecLY->GetMatrixArray())[row]-peakposloc[1]);
    if (dist>1) continue;
    
    if (dist<mindist2){
      mindist2=dist;
      itrackMin2=itrack;
    }
  }
  mindist=mindist2;
  return itrackMin2;
  
}

//_____________________________________________________________________
Bool_t AliTPCCalibCE::IsEdgePad(Int_t sector, Int_t row, Int_t pad) const
{
  //
  // return true if pad is on the edge of a row
  //
  Int_t edge1   = 0;
  if ( pad == edge1 ) return kTRUE;
  Int_t edge2   = fROC->GetNPads(sector,row)-1;
  if ( pad == edge2 ) return kTRUE;
  
  return kFALSE;
}

//_____________________________________________________________________
TObjArray* AliTPCCalibCE::SetupMeasured()
{
  //
  // setup array of measured laser tracks and CE
  //
  
  TObjArray *arrIdeal    = AliTPCLaserTrack::GetTracks();
  TObjArray *arrMeasured = new TObjArray(338);
  arrMeasured->SetOwner();
  for(Int_t itrack=0;itrack<336;itrack++){
    arrMeasured->AddAt(new AliTPCLaserTrack(*((AliTPCLaserTrack*)arrIdeal->At(itrack))),itrack);
  }
  
  //"tracks" for CE
  AliTPCLaserTrack *ltrce=new AliTPCLaserTrack;
  ltrce->SetId(336);
  ltrce->SetSide(0);
  ltrce->fVecSec=new TVectorD(557568/2);
  ltrce->fVecP2=new TVectorD(557568/2);
  ltrce->fVecPhi=new TVectorD(557568/2);
  ltrce->fVecGX=new TVectorD(557568/2);
  ltrce->fVecGY=new TVectorD(557568/2);
  ltrce->fVecGZ=new TVectorD(557568/2);
  ltrce->fVecLX=new TVectorD(557568/2);
  ltrce->fVecLY=new TVectorD(557568/2);
  ltrce->fVecLZ=new TVectorD(557568/2);
  
  arrMeasured->AddAt(ltrce,336); //CE A-Side
  
  ltrce=new AliTPCLaserTrack;
  ltrce->SetId(337);
  ltrce->SetSide(1);
  ltrce->fVecSec=new TVectorD(557568/2);
  ltrce->fVecP2=new TVectorD(557568/2);
  ltrce->fVecPhi=new TVectorD(557568/2);
  ltrce->fVecGX=new TVectorD(557568/2);
  ltrce->fVecGY=new TVectorD(557568/2);
  ltrce->fVecGZ=new TVectorD(557568/2);
  ltrce->fVecLX=new TVectorD(557568/2);
  ltrce->fVecLY=new TVectorD(557568/2);
  ltrce->fVecLZ=new TVectorD(557568/2);
  arrMeasured->AddAt(ltrce,337); //CE C-Side
  
  return arrMeasured;
}

//_____________________________________________________________________
void AliTPCCalibCE::ResetMeasured(TObjArray * const arr)
{
  //
  // reset array of measured laser tracks and CE
  //
  for(Int_t itrack=0;itrack<338;itrack++){
    AliTPCLaserTrack *ltr=(AliTPCLaserTrack*)arr->UncheckedAt(itrack);
    ltr->fVecSec->Zero();
    ltr->fVecP2->Zero();
    ltr->fVecPhi->Zero();
    ltr->fVecGX->Zero();
    ltr->fVecGY->Zero();
    ltr->fVecGZ->Zero();
    ltr->fVecLX->Zero();
    ltr->fVecLY->Zero();
    ltr->fVecLZ->Zero();
  }
}

//_____________________________________________________________________
void AliTPCCalibCE::AddCEtoIdeal(TObjArray *arr)
{
  //
  // Add ideal CE positions to the ideal track data
  //
  
  arr->Expand(338);
  //"tracks" for CE
  AliTPCLaserTrack *ltrceA=new AliTPCLaserTrack;
  ltrceA->SetId(336);
  ltrceA->SetSide(0);
  ltrceA->fVecSec=new TVectorD(557568/2);
  ltrceA->fVecP2=new TVectorD(557568/2);
  ltrceA->fVecPhi=new TVectorD(557568/2);
  ltrceA->fVecGX=new TVectorD(557568/2);
  ltrceA->fVecGY=new TVectorD(557568/2);
  ltrceA->fVecGZ=new TVectorD(557568/2);
  ltrceA->fVecLX=new TVectorD(557568/2);
  ltrceA->fVecLY=new TVectorD(557568/2);
  ltrceA->fVecLZ=new TVectorD(557568/2);
  arr->AddAt(ltrceA,336); //CE A-Side
  
  AliTPCLaserTrack *ltrceC=new AliTPCLaserTrack;
  ltrceC->SetId(337);
  ltrceC->SetSide(1);
  ltrceC->fVecSec=new TVectorD(557568/2);
  ltrceC->fVecP2=new TVectorD(557568/2);
  ltrceC->fVecPhi=new TVectorD(557568/2);
  ltrceC->fVecGX=new TVectorD(557568/2);
  ltrceC->fVecGY=new TVectorD(557568/2);
  ltrceC->fVecGZ=new TVectorD(557568/2);
  ltrceC->fVecLX=new TVectorD(557568/2);
  ltrceC->fVecLY=new TVectorD(557568/2);
  ltrceC->fVecLZ=new TVectorD(557568/2);
  arr->AddAt(ltrceC,337); //CE C-Side
  
  //Calculate ideal positoins
  Float_t gxyz[3];
  Float_t lxyz[3];
  Int_t channelSideA=0;
  Int_t channelSideC=0;
  Int_t channelSide=0;
  AliTPCLaserTrack *ltrce=0x0;
  
  for (Int_t isector=0; isector<72; ++isector){
    Int_t side=((isector/18)%2);
    for (UInt_t irow=0;irow<fROC->GetNRows(isector);++irow){
      for (UInt_t ipad=0;ipad<fROC->GetNPads(isector,irow);++ipad){
        fROC->GetPositionGlobal(isector,irow,ipad,gxyz);
        fROC->GetPositionLocal(isector,irow,ipad,lxyz);
        if (side==0) {
          ltrce=ltrceA;
          channelSide=channelSideA;
        } else {
          ltrce=ltrceC;
          channelSide=channelSideC;
        }
        
        ltrce->fVecSec->GetMatrixArray()[channelSide]=isector;
        ltrce->fVecP2->GetMatrixArray()[channelSide]=0;
        ltrce->fVecPhi->GetMatrixArray()[channelSide]=0;
        ltrce->fVecGX->GetMatrixArray()[channelSide]=gxyz[0];
        ltrce->fVecGY->GetMatrixArray()[channelSide]=gxyz[1];
//         ltrce->fVecGZ->GetMatrixArray()[channelSide]=-1;
        ltrce->fVecLX->GetMatrixArray()[channelSide]=lxyz[0];
        ltrce->fVecLY->GetMatrixArray()[channelSide]=lxyz[1];
//         ltrce->fVecLZ->GetMatrixArray()[channelSide]=-1;
        
        if (side==0){
          ltrce->fVecGZ->GetMatrixArray()[channelSide]=-0.335;
          ltrce->fVecLZ->GetMatrixArray()[channelSide]=-0.335;
          ++channelSideA;
        }
        else {
          ltrce->fVecGZ->GetMatrixArray()[channelSide]=0.15;
          ltrce->fVecLZ->GetMatrixArray()[channelSide]=0.15;
          ++channelSideC;
        }
      }
    }
  }
  
  
}

//_____________________________________________________________________
void AliTPCCalibCE::CalculateDV(TObjArray * const arrIdeal, TObjArray * const arrMeasured, Int_t burst)
{
  //
  // calculate the drift velocity from the reconstructed clusters associated
  // to the ideal laser tracks
  // use two different fit scenarios: Separate fit for A- and C-Side
  //                                  Common fit for A- and C-Side
  //
  
  if (!fArrFitGraphs){
    fArrFitGraphs=new TObjArray;
  }
  
//   static TLinearFitter fdriftA(5,"hyp4");
//   static TLinearFitter fdriftC(5,"hyp4");
//   static TLinearFitter fdriftAC(6,"hyp5");
  Double_t timestamp=fTimeBursts[burst];
  
  static TLinearFitter fdriftA(4,"hyp3");
  static TLinearFitter fdriftC(4,"hyp3");
  static TLinearFitter fdriftAC(5,"hyp4");
  TVectorD fitA(7),fitC(7),fitAC(8); //fit values+chi2+npoints
  
  Float_t chi2A = 10;
  Float_t chi2C = 10;
  Float_t chi2AC = 10;
  Int_t npointsA=0;
  Int_t npointsC=0;
  Int_t npointsAC=0;
  
  Double_t minres[3]={20.,1,0.8};
  //----
  for(Int_t i=0;i<3;i++){
    
    fdriftA.ClearPoints();
    fdriftC.ClearPoints();
    fdriftAC.ClearPoints();
    
    chi2A = 10;
    chi2C = 10;
    chi2AC = 10;
    npointsA=0;
    npointsC=0;
    npointsAC=0;
    
    for (Int_t itrack=0; itrack<338; ++itrack){
      AliTPCLaserTrack *iltr=(AliTPCLaserTrack*)arrIdeal->UncheckedAt(itrack);
      AliTPCLaserTrack *mltr=(AliTPCLaserTrack*)arrMeasured->UncheckedAt(itrack);

      //-- Exclude the tracks which has the biggest inclanation angle
      if ((itrack%7==0||itrack%7==6)&&itrack<336) continue;
      Int_t clustercounter=0;
      Int_t indexMax=159;
      
      //-- exclude the low intensity tracks
      
      for (Int_t index=0; index<indexMax; ++index){
        
        Double_t mGx=mltr->fVecGX->GetMatrixArray()[index];
        Double_t mGy=mltr->fVecGY->GetMatrixArray()[index];
        Double_t mGz=mltr->fVecGZ->GetMatrixArray()[index];
        
        if (TMath::Abs(mGz)<1e-20 && TMath::Abs(mGy)<1e-20 && TMath::Abs(mGx)<1e-20) clustercounter++;
      }
      if (clustercounter>130&&itrack<336) continue; // don't accept tracks with <= 159-130=29 clusters
      clustercounter=0;

      
      //-- drift length
      Double_t zlength = (iltr->GetSide()==0)? fParam->GetZLength(36): fParam->GetZLength(71);
      
      if (itrack>335) indexMax=557568/2;
      for (Int_t index=0; index<indexMax; ++index){
        Double_t iGx=iltr->fVecGX->GetMatrixArray()[index];
        Double_t iGy=iltr->fVecGY->GetMatrixArray()[index];
        Double_t iGz=iltr->fVecGZ->GetMatrixArray()[index];
        Double_t iR=TMath::Sqrt(iGx*iGx+iGy*iGy);
        
        Double_t mGx=mltr->fVecGX->GetMatrixArray()[index];
        Double_t mGy=mltr->fVecGY->GetMatrixArray()[index];
        Double_t mGz=mltr->fVecGZ->GetMatrixArray()[index];
        Double_t mR=TMath::Sqrt(mGx*mGx+mGy*mGy);
        
      //cut if no track info available
        if (iltr->GetBundle()==0) continue;
        if (iR<133||mR<133) continue;
        if(TMath::Abs(mltr->fVecP2->GetMatrixArray()[index])>minres[i]) continue;
        
        Double_t ldrift  = (iltr->GetSide()==0)?zlength-iGz:iGz+zlength;
        Double_t mdrift  = (iltr->GetSide()==0)?zlength-mGz:mGz+zlength;
        
        //Double_t xxx[4] = {ldrift,iGy*ldrift/(zlength*250.), 250.-mR, iltr->fVecSec->GetMatrixArray()[index]>35};
        Double_t xxx[3] = {ldrift,iGy*ldrift/(zlength*250.), 250.-mR};
        
        if (iltr->GetSide()==0){
          fdriftA.AddPoint(xxx,mdrift,1);
        }else{
          fdriftC.AddPoint(xxx,mdrift,1);
        }
//         Double_t xxx2[4] = { ldrift,iGy*ldrift/(zlength*250.), 250.-mR, iltr->fVecSec->GetMatrixArray()[index]>35, iltr->GetSide()};
        Double_t xxx2[4] = { ldrift,iGy*ldrift/(zlength*250.), 250.-mR, static_cast<Double_t>(iltr->GetSide())};
        fdriftAC.AddPoint(xxx2,mdrift,1);
        
      }//end index loop
    }//end laser track loop
    
  //perform fit
    fdriftA.Eval();
    fdriftC.Eval();
    fdriftAC.Eval();
    
    
    
  //get fit values
    fdriftA.GetParameters(fitA);
    fdriftC.GetParameters(fitC);
    fdriftAC.GetParameters(fitAC);
    
  //Parameters:  0 linear offset
  //             1 mean drift velocity correction factor
  //             2 relative global y gradient
  //             3 radial deformation
  //             4 IROC/OROC offset
    
//      FindResiduals(arrMeasured,arrIdeal,fitA,fitC);
    
    for (Int_t itrack=0; itrack<338; ++itrack){
      AliTPCLaserTrack *iltr=(AliTPCLaserTrack*)arrIdeal->UncheckedAt(itrack);
      AliTPCLaserTrack *mltr=(AliTPCLaserTrack*)arrMeasured->UncheckedAt(itrack);

      //-- Exclude the tracks which has the biggest inclanation angle
      if ((itrack%7==0||itrack%7==6)&&itrack<336) continue;
      Int_t clustercounter=0;
      Int_t indexMax=159;

      //-- exclude the low intensity tracks

      for (Int_t index=0; index<indexMax; ++index){
        Double_t mGx=mltr->fVecGX->GetMatrixArray()[index];
        Double_t mGy=mltr->fVecGY->GetMatrixArray()[index];
        Double_t mGz=mltr->fVecGZ->GetMatrixArray()[index];
        if (TMath::Abs(mGz)<1e-20 && TMath::Abs(mGy)<1e-20 && TMath::Abs(mGx)<1e-20) clustercounter++;
      }
      if (clustercounter>130&&itrack<336) continue; // don't accept tracks with <= 159-130=29 clusters
      clustercounter=0;

      //-- drift length
      Double_t zlength = (iltr->GetSide()==0)? fParam->GetZLength(36): fParam->GetZLength(71);

      if (itrack>335) indexMax=557568/2;
      for (Int_t index=0; index<indexMax; ++index){
        Double_t iGx=iltr->fVecGX->GetMatrixArray()[index];
        Double_t iGy=iltr->fVecGY->GetMatrixArray()[index];
        Double_t iGz=iltr->fVecGZ->GetMatrixArray()[index];
        Double_t iR=TMath::Sqrt(iGx*iGx+iGy*iGy);
        
        Double_t mGx=mltr->fVecGX->GetMatrixArray()[index];
        Double_t mGy=mltr->fVecGY->GetMatrixArray()[index];
        Double_t mGz=mltr->fVecGZ->GetMatrixArray()[index];
        Double_t mR=TMath::Sqrt(mGx*mGx+mGy*mGy);
        
      //cut if no track info available
        if (iR<60||mR<60) continue;
        
        Double_t ldrift  = (iltr->GetSide()==0)?zlength-iGz:iGz+zlength;
        Double_t mdrift  = (iltr->GetSide()==0)?zlength-mGz:mGz+zlength;
        
        TVectorD *v=&fitA;
        if (iltr->GetSide()==1) v=&fitC;
//         Double_t iCorr=(*v)[0]+(*v)[1]*ldrift+(*v)[2]*iGy*ldrift/(zlength*250.)+(*v)[3]*(250.-mR)+(*v)[4]*( iltr->fVecSec->GetMatrixArray()[index]>35);
        Double_t iCorr=(*v)[0]+(*v)[1]*ldrift+(*v)[2]*iGy*ldrift/(zlength*250.)+(*v)[3]*(250.-mR);
        
        mltr->fVecP2->GetMatrixArray()[index]=mdrift-iCorr;
        
      }
    }
    
    fitA.ResizeTo(7);
    fitC.ResizeTo(7);
    fitAC.ResizeTo(8);
    
//set statistics values

    npointsA= fdriftA.GetNpoints();
    if (npointsA>0) chi2A = fdriftA.GetChisquare()/fdriftA.GetNpoints();
    fitA[5]=npointsA;
    fitA[6]=chi2A;
    
    npointsC= fdriftC.GetNpoints();
    if (npointsC>0) chi2C = fdriftC.GetChisquare()/fdriftC.GetNpoints();
    fitC[5]=npointsC;
    fitC[6]=chi2C;
    
    npointsAC= fdriftAC.GetNpoints();
    if (npointsAC>0) chi2AC = fdriftAC.GetChisquare()/fdriftAC.GetNpoints();
    fitAC[5]=npointsAC;
    fitAC[6]=chi2AC;
    
    if (fStreamLevel>2){
    //laser track information
      (*GetDebugStreamer()) << "DriftV" <<
        "iter="   << i <<
        "run="    << fRunNumber <<
        "time="   << timestamp <<
        "fitA.="  << &fitA <<
        "fitC.="  << &fitC <<
        "fitAC.=" << &fitAC <<
        "\n";
      
      
    }
    
  }
//-----
  
  
  //Parameters:  0 linear offset (global)
  //             1 mean drift velocity correction factor
  //             2 relative global y gradient
  //             3 radial deformation
  //             4 IROC/OROC offset
  //             5 linear offset relative A-C
  
  //get graphs
  TGraphErrors *grA[7];
  TGraphErrors *grC[7];
  TGraphErrors *grAC[8];
  TString names("GRAPH_MEAN_DELAY_LASER_ALL_;GRAPH_MEAN_DRIFT_LASER_ALL_;GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_;GRAPH_MEAN_RGRADIENT_LASER_ALL_;GRAPH_MEAN_IROCOROCOFFSET_LASER_ALL_;GRAPH_MEAN_NPOINTS_LASER_ALL_;GRAPH_MEAN_CHI2_LASER_ALL_");
  TString namesAC("GRAPH_MEAN_DELAY_LASER_ALL_;GRAPH_MEAN_DRIFT_LASER_ALL_;GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_;GRAPH_MEAN_RGRADIENT_LASER_ALL_;GRAPH_MEAN_IROCOROCOFFSET_LASER_ALL_;GRAPH_MEAN_NPOINTS_LASER_ALL_;GRAPH_MEAN_CHI2_LASER_ALL_;GRAPH_MEAN_DELAYC_LASER_ALL_");
  
  TObjArray *arrNames=names.Tokenize(";");
  TObjArray *arrNamesAC=namesAC.Tokenize(";");
  
  //A-Side graphs
  for (Int_t i=0; i<7; ++i){
    TString grName=arrNames->UncheckedAt(i)->GetName();
    grName+="A";
    grA[i]=(TGraphErrors*)fArrFitGraphs->FindObject(grName.Data());
    if (!grA[i]){
      grA[i]=new TGraphErrors;
      grA[i]->SetName(grName.Data());
      grA[i]->SetTitle(grName.ReplaceAll("_"," ").Data());
      fArrFitGraphs->Add(grA[i]);
    }
//     Int_t ipoint=grA[i]->GetN();
    Int_t ipoint=burst;
    grA[i]->SetPoint(ipoint,timestamp,fitA(i));
    grA[i]->SetPointError(ipoint,60,.0001);
    if (i<4) grA[i]->SetPointError(ipoint,60,fdriftA.GetCovarianceMatrixElement(i,i));
  }
  
  //C-Side graphs
  for (Int_t i=0; i<7; ++i){
    TString grName=arrNames->UncheckedAt(i)->GetName();
    grName+="C";
    grC[i]=(TGraphErrors*)fArrFitGraphs->FindObject(grName.Data());
    if (!grC[i]){
      grC[i]=new TGraphErrors;
      grC[i]->SetName(grName.Data());
      grC[i]->SetTitle(grName.ReplaceAll("_"," ").Data());
      fArrFitGraphs->Add(grC[i]);
    }
//     Int_t ipoint=grC[i]->GetN();
    Int_t ipoint=burst;
    grC[i]->SetPoint(ipoint,timestamp,fitC(i));
    grC[i]->SetPointError(ipoint,60,.0001);
    if (i<4) grC[i]->SetPointError(ipoint,60,fdriftC.GetCovarianceMatrixElement(i,i));
  }
  
  //AC-Side graphs
  for (Int_t i=0; i<8; ++i){
    TString grName=arrNamesAC->UncheckedAt(i)->GetName();
    grName+="AC";
    grAC[i]=(TGraphErrors*)fArrFitGraphs->FindObject(grName.Data());
    if (!grAC[i]){
      grAC[i]=new TGraphErrors;
      grAC[i]->SetName(grName.Data());
      grAC[i]->SetTitle(grName.ReplaceAll("_"," ").Data());
      fArrFitGraphs->Add(grAC[i]);
    }
//     Int_t ipoint=grAC[i]->GetN();
    Int_t ipoint=burst;
    grAC[i]->SetPoint(ipoint,timestamp,fitAC(i));
    grAC[i]->SetPointError(ipoint,60,.0001);
    if (i<5) grAC[i]->SetPointError(ipoint,60,fdriftAC.GetCovarianceMatrixElement(i,i));
  }
  
  if (fDebugLevel>10){
    printf("A side fit parameters:\n");
    fitA.Print();
    printf("\nC side fit parameters:\n");
    fitC.Print();
    printf("\nAC side fit parameters:\n");
    fitAC.Print();
  }
  delete arrNames;
  delete arrNamesAC;
}

//_____________________________________________________________________
Double_t AliTPCCalibCE::SetBurstHnDrift()
{
  //
  // Create a new THnSparse for the current burst
  // return the time of the current burst
  //
  Int_t i=0;
  for(i=0; i<fTimeBursts.GetNrows(); ++i){
    if(fTimeBursts.GetMatrixArray()[i]<1.e-20) break;
    if(TMath::Abs(fTimeBursts.GetMatrixArray()[i]-fTimeStamp)<300){
      fHnDrift=(THnSparseI*)fArrHnDrift.UncheckedAt(i);
      return fTimeBursts(i);
    }
  }
  
  CreateDVhist();
  fArrHnDrift.AddAt(fHnDrift,i);
  fTimeBursts.GetMatrixArray()[i]=fTimeStamp;
  for (i=0;i<14;++i){
    fPeaks[i]=0;
    fPeakWidths[i]=0;
  }
  fEventInBunch=0;
  return fTimeStamp;
}

//_____________________________________________________________________
void AliTPCCalibCE::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t /*append*/)
{
  //
  //  Write class to file
  //  option can be specified in the dir option:
  //  options:
  //    name=<objname>: the name of the calibration object in file will be <objname>
  //    type=<type>:    the saving type:
  //                    0 - write the complte object
  //                    1 - Store the histogram arrays separately to make the streamed object smaller, Analyse to be called
  //                    2 - like 2, but in addition delete objects that will most probably not be used for calibration
  //                    3 - store only calibration output, don't store the reference histograms
  //                        and THnSparse (requires Analyse called before)
  //
  //  NOTE: to read the object back, the ReadFromFile function should be used
  //
  
  TString sDir(dir);
  TString objName=GetName();
  Int_t type=0;
  
  //get options
  TObjArray *arr=sDir.Tokenize(",");
  TIter next(arr);
  TObjString *s;
  while ( (s=(TObjString*)next()) ){
    TString optString=s->GetString();
    optString.Remove(TString::kBoth,' ');
    if (optString.BeginsWith("name=")){
      objName=optString.ReplaceAll("name=","");
    }
    if (optString.BeginsWith("type=")){
      optString.ReplaceAll("type=","");
      type=optString.Atoi();
    }
  }
  delete arr;

  if ( type==4 ){
    // only for the new algorithm
    AliTPCCalibCE ce;
    ce.fArrFitGraphs=fArrFitGraphs;
    ce.fNevents=fNevents;
    ce.fTimeBursts.ResizeTo(fTimeBursts.GetNrows());
    ce.fTimeBursts=fTimeBursts;
    ce.fProcessNew=kTRUE;
    TFile f(filename,"recreate");
    ce.Write(objName.Data());
    fArrHnDrift.Write("arrHnDrift",TObject::kSingleKey);
    f.Close();
    ce.fArrFitGraphs=0x0;
    return;
  }


  if (type==1||type==2) {
    //delete most probably not needed stuff
    //This requires Analyse to be called after reading the object from file
    fCalRocArrayT0.Delete();
    fCalRocArrayT0Err.Delete();
    fCalRocArrayQ.Delete();
    fCalRocArrayRMS.Delete();
    fCalRocArrayOutliers.Delete();
  }
  if (type==2||type==3){
    fParamArrayEventPol1.Delete();
    fParamArrayEventPol2.Delete();
  }
  
  TObjArray histoQArray(72);
  TObjArray histoT0Array(72);
  TObjArray histoRMSArray(72);
  TObjArray arrHnDrift(fArrHnDrift.GetEntries());

  //save all large 2D histograms in separte pointers
  //to have a smaller memory print when saving the object
  if (type==1||type==2||type==3){
    for (Int_t i=0; i<72; ++i){
      histoQArray.AddAt(fHistoQArray.UncheckedAt(i),i);
      histoT0Array.AddAt(fHistoT0Array.UncheckedAt(i),i);
      histoRMSArray.AddAt(fHistoRMSArray.UncheckedAt(i),i);
    }
    fHistoQArray.SetOwner(kFALSE);
    fHistoT0Array.SetOwner(kFALSE);
    fHistoRMSArray.SetOwner(kFALSE);
    fHistoQArray.Clear();
    fHistoT0Array.Clear();
    fHistoRMSArray.Clear();
    
    for (Int_t i=0;i<fArrHnDrift.GetEntries();++i){
      arrHnDrift.AddAt(fArrHnDrift.UncheckedAt(i),i);
    }
    fArrHnDrift.SetOwner(kFALSE);
    fArrHnDrift.Clear();
  }
  
  
  TDirectory *backup = gDirectory;
  
  TFile f(filename,"recreate");
  Write(objName.Data());
  if (type==1||type==2) {
    histoQArray.Write("histoQArray",TObject::kSingleKey);
    histoT0Array.Write("histoT0Array",TObject::kSingleKey);
    histoRMSArray.Write("histoRMSArray",TObject::kSingleKey);
    arrHnDrift.Write("arrHnDrift",TObject::kSingleKey);
  }

  f.Save();
  f.Close();

  //move histograms back to the object
  if (type==1||type==2){
    for (Int_t i=0; i<72; ++i){
      fHistoQArray.AddAt(histoQArray.UncheckedAt(i),i);
      fHistoT0Array.AddAt(histoT0Array.UncheckedAt(i),i);
      fHistoRMSArray.AddAt(histoRMSArray.UncheckedAt(i),i);
    }
    fHistoQArray.SetOwner(kTRUE);
    fHistoT0Array.SetOwner(kTRUE);
    fHistoRMSArray.SetOwner(kTRUE);

    for (Int_t i=0;i<arrHnDrift.GetEntries();++i){
      fArrHnDrift.AddAt(arrHnDrift.UncheckedAt(i),i);
    }
    fArrHnDrift.SetOwner(kTRUE);
  }
  
  if ( backup ) backup->cd();
}
//_____________________________________________________________________
AliTPCCalibCE* AliTPCCalibCE::ReadFromFile(const Char_t *filename)
{
  //
  // Read object from file
  // Handle properly if the histogram arrays were stored separately
  // call Analyse to make sure to have the calibration relevant information in the object
  //
  
  TFile f(filename);
  if (!f.IsOpen() || f.IsZombie() ) return 0x0;
  TList *l=f.GetListOfKeys();
  TIter next(l);
  TKey *key=0x0;
  TObject *o=0x0;

  AliTPCCalibCE *ce=0x0;
  TObjArray *histoQArray=0x0;
  TObjArray *histoT0Array=0x0;
  TObjArray *histoRMSArray=0x0;
  TObjArray *arrHnDrift=0x0;
  
  while ( (key=(TKey*)next()) ){
    o=key->ReadObj();
    if ( o->IsA()==AliTPCCalibCE::Class() ){
      ce=(AliTPCCalibCE*)o;
    } else if ( o->IsA()==TObjArray::Class() ){
      TString name=key->GetName();
      if ( name=="histoQArray") histoQArray=(TObjArray*)o;
      if ( name=="histoT0Array") histoT0Array=(TObjArray*)o;
      if ( name=="histoRMSArray") histoRMSArray=(TObjArray*)o;
      if ( name=="arrHnDrift") arrHnDrift=(TObjArray*)o;
    }
  }

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