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 clusterer
//
//  1. The Input data for reconstruction - Options
//      1.a Simulated data  - TTree - invoked Digits2Clusters()
//      1.b Raw data        - Digits2Clusters(AliRawReader* rawReader); 
//      1.c HLT clusters    - Digits2Clusters and Digits2Clusters(AliRawReader* rawReader)
//                            invoke ReadHLTClusters()
//
//      fUseHLTClusters     - switches between different inputs
//                            1 -> only TPC raw/sim data
//                            2 -> if present TPC raw/sim data, otherwise HLT clusters
//                            3 -> only HLT clusters
//                            4 -> if present HLT clusters, otherwise TPC raw/sim data
//
//  2. The Output data
//      2.a TTree with clusters - if  SetOutput(TTree * tree) invoked
//      2.b TObjArray           - Faster option for HLT
//      2.c TClonesArray        - Faster option for HLT (smaller memory consumption), activate with fBClonesArray flag
//
//  3. Reconstruction setup
//     see AliTPCRecoParam for list of parameters 
//     The reconstruction parameterization taken from the 
//     AliTPCReconstructor::GetRecoParam()
//     Possible to setup it in reconstruction macro  AliTPCReconstructor::SetRecoParam(...)
//     
//
//
//   Origin: Marian Ivanov 
//-------------------------------------------------------

#include "Riostream.h"
#include <TF1.h>
#include <TFile.h>
#include <TGraph.h>
#include <TH1F.h>
#include <TObjArray.h>
#include <TClonesArray.h>
#include <TRandom.h>
#include <TTree.h>
#include <TTreeStream.h>
#include "TSystem.h"
#include "TClass.h"

#include "AliDigits.h"
#include "AliLoader.h"
#include "AliLog.h"
#include "AliMathBase.h"
#include "AliRawEventHeaderBase.h"
#include "AliRawReader.h"
#include "AliRunLoader.h"
#include "AliSimDigits.h"
#include "AliTPCCalPad.h"
#include "AliTPCCalROC.h"
#include "AliTPCClustersRow.h"
#include "AliTPCParam.h"
#include "AliTPCRawStreamV3.h"
#include "AliTPCRecoParam.h"
#include "AliTPCReconstructor.h"
#include "AliTPCcalibDB.h"
#include "AliTPCclusterInfo.h"
#include "AliTPCclusterMI.h"
#include "AliTPCTransform.h"
#include "AliTPCclusterer.h"

using std::cerr;
using std::endl;
ClassImp(AliTPCclusterer)



AliTPCclusterer::AliTPCclusterer(const AliTPCParam* par, const AliTPCRecoParam * recoParam):
  fBins(0),
  fSigBins(0),
  fNSigBins(0),
  fLoop(0),
  fMaxBin(0),
  fMaxTime(1006), // 1000>940 so use 1000, add 3 virtual time bins before and 3 after
  fMaxPad(0),
  fSector(-1),
  fRow(-1),
  fSign(0),
  fRx(0),
  fPadWidth(0),
  fPadLength(0),
  fZWidth(0),
  fPedSubtraction(kFALSE),
  fEventHeader(0),
  fTimeStamp(0),
  fEventType(0),
  fInput(0),
  fOutput(0),
  fOutputArray(0),
  fOutputClonesArray(0),
  fRowCl(0),
  fRowDig(0),
  fParam(0),
  fNcluster(0),
  fNclusters(0),
  fDebugStreamer(0),
  fRecoParam(0),
  fBDumpSignal(kFALSE),
  fBClonesArray(kFALSE),
  fUseHLTClusters(4),
  fAllBins(NULL),
  fAllSigBins(NULL),
  fAllNSigBins(NULL),
  fHLTClusterAccess(NULL)
{
  //
  // COSNTRUCTOR
  // param     - tpc parameters for given file
  // recoparam - reconstruction parameters 
  //
  fInput =0;
  fParam = par;
  if (recoParam) {
    fRecoParam = recoParam;
  }else{
    //set default parameters if not specified
    fRecoParam = AliTPCReconstructor::GetRecoParam();
    if (!fRecoParam)  fRecoParam = AliTPCRecoParam::GetLowFluxParam();
  }
 
  if(AliTPCReconstructor::StreamLevel()>0) {
    fDebugStreamer = new TTreeSRedirector("TPCsignal.root");
  }

  //  Int_t nPoints = fRecoParam->GetLastBin()-fRecoParam->GetFirstBin();
  fRowCl= new AliTPCClustersRow("AliTPCclusterMI");

  // Non-persistent arrays
  //
  //alocate memory for sector - maximal case
  //
  AliTPCROC * roc = AliTPCROC::Instance();
  Int_t nRowsMax = roc->GetNRows(roc->GetNSector()-1);
  Int_t nPadsMax = roc->GetNPads(roc->GetNSector()-1,nRowsMax-1);

  fAllBins = new Float_t*[nRowsMax];
  fAllSigBins = new Int_t*[nRowsMax];
  fAllNSigBins = new Int_t[nRowsMax];
  for (Int_t iRow = 0; iRow < nRowsMax; iRow++) {
    //
    Int_t maxBin = fMaxTime*(nPadsMax+6);  // add 3 virtual pads  before and 3 after
    fAllBins[iRow] = new Float_t[maxBin];
    memset(fAllBins[iRow],0,sizeof(Float_t)*maxBin);
    fAllSigBins[iRow] = new Int_t[maxBin];
    fAllNSigBins[iRow]=0;
  }
}

//______________________________________________________________
AliTPCclusterer::~AliTPCclusterer(){
  //
  //
  //
  if (fDebugStreamer) delete fDebugStreamer;
  if (fOutputArray){
    //fOutputArray->Delete();
    delete fOutputArray;
  }
  if (fOutputClonesArray){
    fOutputClonesArray->Delete();
    delete fOutputClonesArray;
  }

  if (fRowCl) {
    fRowCl->GetArray()->Delete();
    delete fRowCl;
  }

  AliTPCROC * roc = AliTPCROC::Instance();
  Int_t nRowsMax = roc->GetNRows(roc->GetNSector()-1);
  for (Int_t iRow = 0; iRow < nRowsMax; iRow++) {
    delete [] fAllBins[iRow];
    delete [] fAllSigBins[iRow];
  }
  delete [] fAllBins;
  delete [] fAllSigBins;
  delete [] fAllNSigBins;
  if (fHLTClusterAccess) delete fHLTClusterAccess;
}

void AliTPCclusterer::SetInput(TTree * tree)
{
  //
  // set input tree with digits
  //
  fInput = tree;  
  if  (!fInput->GetBranch("Segment")){
    cerr<<"AliTPC::Digits2Clusters(): no porper input tree !\n";
    fInput=0;
    return;
  }
}

void AliTPCclusterer::SetOutput(TTree * tree) 
{
  //
  // Set the output tree
  // If not set the ObjArray used - Option for HLT 
  //
  if (!tree) return;
  fOutput= tree;
  AliTPCClustersRow clrow("AliTPCclusterMI");
  AliTPCClustersRow *pclrow=&clrow;  
  fOutput->Branch("Segment","AliTPCClustersRow",&pclrow,32000,200);    
}


void AliTPCclusterer::FillRow(){
  //
  // fill the output container - 
  // 2 Options possible
  //          Tree       
  //          TObjArray
  //
  if (fOutput) fOutput->Fill();
  if (!fOutput && !fBClonesArray){
    //
    if (!fOutputArray) fOutputArray = new TObjArray(fParam->GetNRowsTotal());
    if (fRowCl && fRowCl->GetArray()->GetEntriesFast()>0) fOutputArray->AddAt(fRowCl->Clone(), fRowCl->GetID());
  }
}

Float_t  AliTPCclusterer::GetSigmaY2(Int_t iz){
  // sigma y2 = in digits  - we don't know the angle
  Float_t z = iz*fParam->GetZWidth()+fParam->GetNTBinsL1()*fParam->GetZWidth();
  Float_t sd2 = (z*fParam->GetDiffL()*fParam->GetDiffL())/
    (fPadWidth*fPadWidth);
  Float_t sres = 0.25;
  Float_t res = sd2+sres;
  return res;
}


Float_t  AliTPCclusterer::GetSigmaZ2(Int_t iz){
  //sigma z2 = in digits - angle estimated supposing vertex constraint
  Float_t z = iz*fZWidth+fParam->GetNTBinsL1()*fParam->GetZWidth();
  Float_t sd2 = (z*fParam->GetDiffL()*fParam->GetDiffL())/(fZWidth*fZWidth);
  Float_t angular = fPadLength*(fParam->GetZLength(fSector)-z)/(fRx*fZWidth);
  angular*=angular;
  angular/=12.;
  Float_t sres = fParam->GetZSigma()/fZWidth;
  sres *=sres;
  Float_t res = angular +sd2+sres;
  return res;
}

void AliTPCclusterer::MakeCluster(Int_t k,Int_t max,Float_t *bins, UInt_t /*m*/,
AliTPCclusterMI &c) 
{
  //
  //  Make cluster: characterized by position ( mean-  COG) , shape (RMS) a charge, QMax and Q tot
  //  Additional correction:
  //  a) To correct for charge below threshold, in the +1 neghborhood to the max charge charge 
  //       is extrapolated using gaussian approximation assuming given cluster width.. 
  //       Additional empirical factor is used to account for the charge fluctuation (kVirtualChargeFactor). 
  //       Actual value of the  kVirtualChargeFactor should obtained minimimizing residuals between the cluster
  //       and track interpolation.
  //  b.) For space points with extended shape (in comparison with expected using parameterization) clusters are 
  //      unfoded     
  //  
  //  NOTE. Actual/Empirical  values for correction are hardwired in the code.
  //
  // Input paramters for function:
  //  k    - Make cluster at position k  
  //  bins - 2 D array of signals mapped to 1 dimensional array - 
  //  max  - the number of time bins er one dimension
  //  c    - reference to cluster to be filled
  //
  Double_t kVirtualChargeFactor=0.5;
  Int_t i0=k/max;  //central pad
  Int_t j0=k%max;  //central time bin

  // set pointers to data
  //Int_t dummy[5] ={0,0,0,0,0};
  Float_t * matrix[5]; //5x5 matrix with digits  - indexing i = 0 ..4  j = -2..2
  for (Int_t di=-2;di<=2;di++){
    matrix[di+2]  =  &bins[k+di*max];
  }
  //build matrix with virtual charge
  Float_t sigmay2= GetSigmaY2(j0);
  Float_t sigmaz2= GetSigmaZ2(j0);

  Float_t vmatrix[5][5];
  vmatrix[2][2] = matrix[2][0];
  c.SetType(0);
  c.SetMax((UShort_t)(vmatrix[2][2])); // write maximal amplitude
  for (Int_t di =-1;di <=1;di++)
    for (Int_t dj =-1;dj <=1;dj++){
      Float_t amp = matrix[di+2][dj];
      if ( (amp<2) && (fLoop<2)){
	// if under threshold  - calculate virtual charge
	Float_t ratio = TMath::Exp(-1.2*TMath::Abs(di)/sigmay2)*TMath::Exp(-1.2*TMath::Abs(dj)/sigmaz2);
	amp = ((matrix[2][0]-2)*(matrix[2][0]-2)/(matrix[-di+2][-dj]+2))*ratio;
	if (amp>2) amp = 2;
	vmatrix[2+di][2+dj]= kVirtualChargeFactor*amp;
	vmatrix[2+2*di][2+2*dj]=0;
	if ( (di*dj)!=0){       
	  //DIAGONAL ELEMENTS
	  vmatrix[2+2*di][2+dj] =0;
	  vmatrix[2+di][2+2*dj] =0;
	}
	continue;
      }
      if (amp<4){
	//if small  amplitude - below  2 x threshold  - don't consider other one	
	vmatrix[2+di][2+dj]=amp;
	vmatrix[2+2*di][2+2*dj]=0;  // don't take to the account next bin
	if ( (di*dj)!=0){       
	  //DIAGONAL ELEMENTS
	  vmatrix[2+2*di][2+dj] =0;
	  vmatrix[2+di][2+2*dj] =0;
	}
	continue;
      }
      //if bigger then take everything
      vmatrix[2+di][2+dj]=amp;
      vmatrix[2+2*di][2+2*dj]= matrix[2*di+2][2*dj] ;      
      if ( (di*dj)!=0){       
	  //DIAGONAL ELEMENTS
	  vmatrix[2+2*di][2+dj] = matrix[2*di+2][dj];
	  vmatrix[2+di][2+2*dj] = matrix[2+di][dj*2];
	}      
    }


  
  Float_t sumw=0;
  Float_t sumiw=0;
  Float_t sumi2w=0;
  Float_t sumjw=0;
  Float_t sumj2w=0;
  //
  for (Int_t i=-2;i<=2;i++)
    for (Int_t j=-2;j<=2;j++){
      Float_t amp = vmatrix[i+2][j+2];

      sumw    += amp;
      sumiw   += i*amp;
      sumi2w  += i*i*amp;
      sumjw   += j*amp;
      sumj2w  += j*j*amp;
    }    
  //   
  Float_t meani = sumiw/sumw;
  Float_t mi2   = sumi2w/sumw-meani*meani;
  Float_t meanj = sumjw/sumw;
  Float_t mj2   = sumj2w/sumw-meanj*meanj;
  //
  Float_t ry = mi2/sigmay2;
  Float_t rz = mj2/sigmaz2;
  
  //
  if ( ( (ry<0.6) || (rz<0.6) ) && fLoop==2) return;
  if ( ((ry <1.2) && (rz<1.2)) || (!fRecoParam->GetDoUnfold())) {
    //
    //if cluster looks like expected or Unfolding not switched on
    //standard COG is used
    //+1.2 deviation from expected sigma accepted
    //    c.fMax = FitMax(vmatrix,meani,meanj,TMath::Sqrt(sigmay2),TMath::Sqrt(sigmaz2));

    meani +=i0;
    meanj +=j0;
    //set cluster parameters
    c.SetQ(sumw);
    c.SetPad(meani-2.5);
    c.SetTimeBin(meanj-3);
    c.SetSigmaY2(mi2);
    c.SetSigmaZ2(mj2);
    c.SetType(0);
    AddCluster(c,(Float_t*)vmatrix,k);
    return;     
  }
  //
  //unfolding when neccessary  
  //
  
  Float_t * matrix2[7]; //7x7 matrix with digits  - indexing i = 0 ..6  j = -3..3
  Float_t dummy[7]={0,0,0,0,0,0};
  for (Int_t di=-3;di<=3;di++){
    matrix2[di+3] =  &bins[k+di*max];
    if ((k+di*max)<3)  matrix2[di+3] = &dummy[3];
    if ((k+di*max)>fMaxBin-3)  matrix2[di+3] = &dummy[3];
  }
  Float_t vmatrix2[5][5];
  Float_t sumu;
  Float_t overlap;
  UnfoldCluster(matrix2,vmatrix2,meani,meanj,sumu,overlap);
  //
  //  c.fMax = FitMax(vmatrix2,meani,meanj,TMath::Sqrt(sigmay2),TMath::Sqrt(sigmaz2));
  meani +=i0;
  meanj +=j0;
  //set cluster parameters
  c.SetQ(sumu);
  c.SetPad(meani-2.5);
  c.SetTimeBin(meanj-3);
  c.SetSigmaY2(mi2);
  c.SetSigmaZ2(mj2);
  c.SetType(Char_t(overlap)+1);
  AddCluster(c,(Float_t*)vmatrix,k);

  //unfolding 2
  meani-=i0;
  meanj-=j0;
}



void AliTPCclusterer::UnfoldCluster(Float_t * matrix2[7], Float_t recmatrix[5][5], Float_t & meani, Float_t & meanj, 
				      Float_t & sumu, Float_t & overlap )
{
  //
  //unfold cluster from input matrix
  //data corresponding to cluster writen in recmatrix
  //output meani and meanj

  //take separatelly y and z

  Float_t sum3i[7] = {0,0,0,0,0,0,0};
  Float_t sum3j[7] = {0,0,0,0,0,0,0};

  for (Int_t k =0;k<7;k++)
    for (Int_t l = -1; l<=1;l++){
      sum3i[k]+=matrix2[k][l];
      sum3j[k]+=matrix2[l+3][k-3];
    }
  Float_t mratio[3][3]={{1,1,1},{1,1,1},{1,1,1}};
  //
  //unfold  y 
  Float_t sum3wi    = 0;  //charge minus overlap
  Float_t sum3wio   = 0;  //full charge
  Float_t sum3iw    = 0;  //sum for mean value
  for (Int_t dk=-1;dk<=1;dk++){
    sum3wio+=sum3i[dk+3];
    if (dk==0){
      sum3wi+=sum3i[dk+3];     
    }
    else{
      Float_t ratio =1;
      if (  ( ((sum3i[dk+3]+3)/(sum3i[3]-3))+1 < (sum3i[2*dk+3]-3)/(sum3i[dk+3]+3))||
	    (sum3i[dk+3]<=sum3i[2*dk+3] && sum3i[dk+3]>2 )){
	Float_t xm2 = sum3i[-dk+3];
	Float_t xm1 = sum3i[+3];
	Float_t x1  = sum3i[2*dk+3];
	Float_t x2  = sum3i[3*dk+3]; 	
	Float_t w11   = TMath::Max((Float_t)(4.*xm1-xm2),(Float_t)0.000001);	  
	Float_t w12   = TMath::Max((Float_t)(4 *x1 -x2),(Float_t)0.);
	ratio = w11/(w11+w12);	 
	for (Int_t dl=-1;dl<=1;dl++)
	  mratio[dk+1][dl+1] *= ratio;
      }
      Float_t amp = sum3i[dk+3]*ratio;
      sum3wi+=amp;
      sum3iw+= dk*amp;      
    }
  }
  meani = sum3iw/sum3wi;
  Float_t overlapi = (sum3wio-sum3wi)/sum3wio;



  //unfold  z 
  Float_t sum3wj    = 0;  //charge minus overlap
  Float_t sum3wjo   = 0;  //full charge
  Float_t sum3jw    = 0;  //sum for mean value
  for (Int_t dk=-1;dk<=1;dk++){
    sum3wjo+=sum3j[dk+3];
    if (dk==0){
      sum3wj+=sum3j[dk+3];     
    }
    else{
      Float_t ratio =1;
      if ( ( ((sum3j[dk+3]+3)/(sum3j[3]-3))+1 < (sum3j[2*dk+3]-3)/(sum3j[dk+3]+3)) ||
	   (sum3j[dk+3]<=sum3j[2*dk+3] && sum3j[dk+3]>2)){
	Float_t xm2 = sum3j[-dk+3];
	Float_t xm1 = sum3j[+3];
	Float_t x1  = sum3j[2*dk+3];
	Float_t x2  = sum3j[3*dk+3]; 	
	Float_t w11   = TMath::Max((Float_t)(4.*xm1-xm2),(Float_t)0.000001);	  
	Float_t w12   = TMath::Max((Float_t)(4 *x1 -x2),(Float_t)0.);
	ratio = w11/(w11+w12);	 
	for (Int_t dl=-1;dl<=1;dl++)
	  mratio[dl+1][dk+1] *= ratio;
      }
      Float_t amp = sum3j[dk+3]*ratio;
      sum3wj+=amp;
      sum3jw+= dk*amp;      
    }
  }
  meanj = sum3jw/sum3wj;
  Float_t overlapj = (sum3wjo-sum3wj)/sum3wjo;  
  overlap = Int_t(100*TMath::Max(overlapi,overlapj)+3);  
  sumu = (sum3wj+sum3wi)/2.;
  
  if (overlap ==3) {
    //if not overlap detected remove everything
    for (Int_t di =-2; di<=2;di++)
      for (Int_t dj =-2; dj<=2;dj++){
	recmatrix[di+2][dj+2] = matrix2[3+di][dj];
      }
  }
  else{
    for (Int_t di =-1; di<=1;di++)
      for (Int_t dj =-1; dj<=1;dj++){
	Float_t ratio =1;
	if (mratio[di+1][dj+1]==1){
	  recmatrix[di+2][dj+2]     = matrix2[3+di][dj];
	  if (TMath::Abs(di)+TMath::Abs(dj)>1){
	    recmatrix[2*di+2][dj+2] = matrix2[3+2*di][dj];
	    recmatrix[di+2][2*dj+2] = matrix2[3+di][2*dj];
	  }	  
	  recmatrix[2*di+2][2*dj+2] = matrix2[3+2*di][2*dj];
	}
	else
	  {
	    //if we have overlap in direction
	    recmatrix[di+2][dj+2] = mratio[di+1][dj+1]* matrix2[3+di][dj];    
	    if (TMath::Abs(di)+TMath::Abs(dj)>1){
	      ratio =  TMath::Min((Float_t)(recmatrix[di+2][dj+2]/(matrix2[3+0*di][1*dj]+1)),(Float_t)1.);
	      recmatrix[2*di+2][dj+2] = ratio*recmatrix[di+2][dj+2];
	      //
	      ratio =  TMath::Min((Float_t)(recmatrix[di+2][dj+2]/(matrix2[3+1*di][0*dj]+1)),(Float_t)1.);
	      recmatrix[di+2][2*dj+2] = ratio*recmatrix[di+2][dj+2];
	    }
	    else{
	      ratio =  recmatrix[di+2][dj+2]/matrix2[3][0];
	      recmatrix[2*di+2][2*dj+2] = ratio*recmatrix[di+2][dj+2];
	    }
	  }
      }
  }
  
}

Float_t AliTPCclusterer::FitMax(Float_t vmatrix[5][5], Float_t y, Float_t z, Float_t sigmay, Float_t sigmaz)
{
  //
  // estimate max
  Float_t sumteor= 0;
  Float_t sumamp = 0;

  for (Int_t di = -1;di<=1;di++)
    for (Int_t dj = -1;dj<=1;dj++){
      if (vmatrix[2+di][2+dj]>2){
	Float_t teor = TMath::Gaus(di,y,sigmay*1.2)*TMath::Gaus(dj,z,sigmaz*1.2);
	sumteor += teor*vmatrix[2+di][2+dj];
	sumamp  += vmatrix[2+di][2+dj]*vmatrix[2+di][2+dj];
      }
    }    
  Float_t max = sumamp/sumteor;
  return max;
}

void AliTPCclusterer::AddCluster(AliTPCclusterMI &c, Float_t * /*matrix*/, Int_t /*pos*/){
  //
  //
  // Transform cluster to the rotated global coordinata
  // Assign labels to the cluster
  // add the cluster to the array
  // for more details - See  AliTPCTranform::Transform(x,i,0,1) 
  Float_t meani = c.GetPad();
  Float_t meanj = c.GetTimeBin();

  Int_t ki = TMath::Nint(meani);
  if (ki<0) ki=0;
  if (ki>=fMaxPad) ki = fMaxPad-1;
  Int_t kj = TMath::Nint(meanj);
  if (kj<0) kj=0;
  if (kj>=fMaxTime-3) kj=fMaxTime-4;
  // ki and kj shifted as integers coordinata
  if (fRowDig) {
    c.SetLabel(fRowDig->GetTrackIDFast(kj,ki,0)-2,0);
    c.SetLabel(fRowDig->GetTrackIDFast(kj,ki,1)-2,1);
    c.SetLabel(fRowDig->GetTrackIDFast(kj,ki,2)-2,2);
  }
  
  c.SetRow(fRow);
  c.SetDetector(fSector);
  Float_t s2 = c.GetSigmaY2();
  Float_t w=fParam->GetPadPitchWidth(fSector);
  c.SetSigmaY2(s2*w*w);
  s2 = c.GetSigmaZ2(); 
  c.SetSigmaZ2(s2*fZWidth*fZWidth);
  //
  //
  //
  
  AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
  if (!transform) {
    AliFatal("Tranformations not in calibDB");    
    return;
  }
  transform->SetCurrentRecoParam((AliTPCRecoParam*)fRecoParam);
  Double_t x[3]={static_cast<Double_t>(c.GetRow()),static_cast<Double_t>(c.GetPad()),static_cast<Double_t>(c.GetTimeBin())};
  Int_t i[1]={fSector};
  transform->Transform(x,i,0,1);
  c.SetX(x[0]);
  c.SetY(x[1]);
  c.SetZ(x[2]);
  //
  //
  if (ki<=1 || ki>=fMaxPad-1 || kj==1 || kj==fMaxTime-2) {
    c.SetType(-(c.GetType()+3));  //edge clusters
  }
  if (fLoop==2) c.SetType(100);

  // select output 
  TClonesArray * arr = 0;
  AliTPCclusterMI * cl = 0;

  if(fBClonesArray==kFALSE) {
     arr = fRowCl->GetArray();
     cl = new ((*arr)[fNcluster]) AliTPCclusterMI(c);
  } else {
     cl = new ((*fOutputClonesArray)[fNclusters+fNcluster]) AliTPCclusterMI(c);
  }

  // if (fRecoParam->DumpSignal() &&matrix ) {
//     Int_t nbins=0;
//     Float_t *graph =0;
//     if (fRecoParam->GetCalcPedestal() && cl->GetMax()>fRecoParam->GetDumpAmplitudeMin() &&fBDumpSignal){
//       nbins = fMaxTime;
//       graph = &(fBins[fMaxTime*(pos/fMaxTime)]);
//     }
//     AliTPCclusterInfo * info = new AliTPCclusterInfo(matrix,nbins,graph);
//     cl->SetInfo(info);
//   }
  if (!fRecoParam->DumpSignal()) {
    cl->SetInfo(0);
  }
  const Int_t kClusterStream=128; // stream level should be per action - to be added to the AliTPCReconstructor
  if ( (AliTPCReconstructor::StreamLevel()&kClusterStream)==kClusterStream) {
    Float_t xyz[3];
    cl->GetGlobalXYZ(xyz);
     (*fDebugStreamer)<<"Clusters"<<
       "Cl.="<<cl<<
       "gx="<<xyz[0]<<
       "gy="<<xyz[1]<<
       "gz="<<xyz[2]<<
       "\n";
  }

  fNcluster++;
}


//_____________________________________________________________________________
void AliTPCclusterer::Digits2Clusters()
{
  //-----------------------------------------------------------------
  // This is a simple cluster finder.
  //-----------------------------------------------------------------

  if (!fInput) { 
    Error("Digits2Clusters", "input tree not initialised");
    return;
  }
  fRecoParam = AliTPCReconstructor::GetRecoParam();
  if (!fRecoParam){
    AliFatal("Can not get the reconstruction parameters");
  }
  if(AliTPCReconstructor::StreamLevel()>5) {
    AliInfo("Parameter Dumps");
    fParam->Dump();
    fRecoParam->Dump();
  }
  fRowDig = NULL;

  //-----------------------------------------------------------------
  // Use HLT clusters
  //-----------------------------------------------------------------
  if (fUseHLTClusters == 3 || fUseHLTClusters == 4) {
    AliInfo("Using HLT clusters for TPC off-line reconstruction");
    fZWidth = fParam->GetZWidth();
    Int_t iResult = ReadHLTClusters();

    // HLT clusters present
    if (iResult >= 0 && fNclusters > 0)
      return; 

    // HLT clusters not present
    if (iResult < 0 || fNclusters == 0) {
      if (fUseHLTClusters == 3) { 
	AliError("No HLT clusters present, but requested.");
	return;
      }
      else {
	AliInfo("Now trying to read from TPC RAW");
      }
    }
    // Some other problem during cluster reading
    else {
      AliWarning("Some problem while unpacking of HLT clusters.");
      return;
    }
  } // if (fUseHLTClusters == 3 || fUseHLTClusters == 4) {

  //-----------------------------------------------------------------
  // Run TPC off-line clusterer
  //-----------------------------------------------------------------
  AliTPCCalPad * gainTPC = AliTPCcalibDB::Instance()->GetPadGainFactor();
  AliTPCCalPad * noiseTPC = AliTPCcalibDB::Instance()->GetPadNoise();
  AliSimDigits digarr, *dummy=&digarr;
  fRowDig = dummy;
  fInput->GetBranch("Segment")->SetAddress(&dummy);
  Stat_t nentries = fInput->GetEntries();
  
  fMaxTime=fRecoParam->GetLastBin()+6; // add 3 virtual time bins before and 3   after
    
  Int_t nclusters  = 0;

  for (Int_t n=0; n<nentries; n++) {
    fInput->GetEvent(n);
    if (!fParam->AdjustSectorRow(digarr.GetID(),fSector,fRow)) {
      cerr<<"AliTPC warning: invalid segment ID ! "<<digarr.GetID()<<endl;
      continue;
    }
    Int_t row = fRow;
    AliTPCCalROC * gainROC = gainTPC->GetCalROC(fSector);  // pad gains per given sector
    AliTPCCalROC * noiseROC   = noiseTPC->GetCalROC(fSector); // noise per given sector
    //

    fRowCl->SetID(digarr.GetID());
    if (fOutput) fOutput->GetBranch("Segment")->SetAddress(&fRowCl);
    fRx=fParam->GetPadRowRadii(fSector,row);
    
    
    const Int_t kNIS=fParam->GetNInnerSector(), kNOS=fParam->GetNOuterSector();
    fZWidth = fParam->GetZWidth();
    if (fSector < kNIS) {
      fMaxPad = fParam->GetNPadsLow(row);
      fSign =  (fSector < kNIS/2) ? 1 : -1;
      fPadLength = fParam->GetPadPitchLength(fSector,row);
      fPadWidth = fParam->GetPadPitchWidth();
    } else {
      fMaxPad = fParam->GetNPadsUp(row);
      fSign = ((fSector-kNIS) < kNOS/2) ? 1 : -1;
      fPadLength = fParam->GetPadPitchLength(fSector,row);
      fPadWidth  = fParam->GetPadPitchWidth();
    }
    
    
    fMaxBin=fMaxTime*(fMaxPad+6);  // add 3 virtual pads  before and 3 after
    fBins    =new Float_t[fMaxBin];
    fSigBins =new Int_t[fMaxBin];
    fNSigBins = 0;
    memset(fBins,0,sizeof(Float_t)*fMaxBin);
    
    if (digarr.First()) //MI change
      do {
	Float_t dig=digarr.CurrentDigit();
	if (dig<=fParam->GetZeroSup()) continue;
	Int_t j=digarr.CurrentRow()+3, i=digarr.CurrentColumn()+3;
        Float_t gain = gainROC->GetValue(row,digarr.CurrentColumn());
	Int_t bin = i*fMaxTime+j;
	if (gain>0){
	  fBins[bin]=dig/gain;
	}else{
	  fBins[bin]=0;
	}
	fSigBins[fNSigBins++]=bin;
      } while (digarr.Next());
    digarr.ExpandTrackBuffer();

    FindClusters(noiseROC);
    FillRow();
    fRowCl->GetArray()->Clear("C");    
    nclusters+=fNcluster;    

    delete[] fBins;
    delete[] fSigBins;
  }  
 
  Info("Digits2Clusters", "Number of found clusters : %d", nclusters);

  if (fUseHLTClusters == 2 && nclusters == 0) {
    AliInfo("No clusters from TPC Raw data, now trying to read HLT clusters.");

    fZWidth = fParam->GetZWidth();
    ReadHLTClusters();
  }
}

void AliTPCclusterer::ProcessSectorData(){
  //
  // Process the data for the current sector
  //

  AliTPCCalPad * pedestalTPC = AliTPCcalibDB::Instance()->GetPedestals();
  AliTPCCalPad * noiseTPC = AliTPCcalibDB::Instance()->GetPadNoise();
  AliTPCCalROC * pedestalROC = pedestalTPC->GetCalROC(fSector);  // pedestal per given sector
  AliTPCCalROC * noiseROC   = noiseTPC->GetCalROC(fSector);  // noise per given sector
  //check the presence of the calibration
  if (!noiseROC ||!pedestalROC ) {
    AliError(Form("Missing calibration per sector\t%d\n",fSector));
    return;
  }
  Int_t  nRows=fParam->GetNRow(fSector);
  Bool_t calcPedestal = fRecoParam->GetCalcPedestal();
  Int_t zeroSup = fParam->GetZeroSup();
  //    if (calcPedestal) {
  if (kFALSE ) {
    for (Int_t iRow = 0; iRow < nRows; iRow++) {
      Int_t maxPad = fParam->GetNPads(fSector, iRow);
      
      for (Int_t iPad = 3; iPad < maxPad + 3; iPad++) {
    //
    // Temporary fix for data production - !!!! MARIAN
    // The noise calibration should take mean and RMS - currently the Gaussian fit used
    // In case of double peak  - the pad should be rejected
    //
    // Line mean - if more than given digits over threshold - make a noise calculation
    // and pedestal substration
        if (!calcPedestal && fAllBins[iRow][iPad*fMaxTime+0]<50) continue;
    //
        if (fAllBins[iRow][iPad*fMaxTime+0] <1 ) continue;  // no data
        Float_t *p = &fAllBins[iRow][iPad*fMaxTime+3];
    //Float_t pedestal = TMath::Median(fMaxTime, p);
        Int_t id[3] = {fSector, iRow, iPad-3};
    // calib values
        Double_t rmsCalib=  noiseROC->GetValue(iRow,iPad-3);
        Double_t pedestalCalib = pedestalROC->GetValue(iRow,iPad-3);
        Double_t rmsEvent       = rmsCalib;
        Double_t pedestalEvent  = pedestalCalib;
        ProcesSignal(p, fMaxTime, id, rmsEvent, pedestalEvent);
        if (rmsEvent<rmsCalib) rmsEvent = rmsCalib;   // take worst scenario
        if (TMath::Abs(pedestalEvent-pedestalCalib)<1.0) pedestalEvent = pedestalCalib;
        
    //
        for (Int_t iTimeBin = 0; iTimeBin < fMaxTime; iTimeBin++) {
          Int_t bin = iPad*fMaxTime+iTimeBin;
          fAllBins[iRow][bin] -= pedestalEvent;
          if (iTimeBin < fRecoParam->GetFirstBin())
            fAllBins[iRow][bin] = 0;
          if (iTimeBin > fRecoParam->GetLastBin())
            fAllBins[iRow][bin] = 0;
          if (fAllBins[iRow][iPad*fMaxTime+iTimeBin] < zeroSup)
            fAllBins[iRow][bin] = 0;
          if (fAllBins[iRow][bin] < 3.0*rmsEvent)   // 3 sigma cut on RMS
            fAllBins[iRow][bin] = 0;
          if (fAllBins[iRow][bin]) fAllSigBins[iRow][fAllNSigBins[iRow]++] = bin;
        }
      }
    }
  }
  
  if (AliTPCReconstructor::StreamLevel()>5) {
    for (Int_t iRow = 0; iRow < nRows; iRow++) {
      Int_t maxPad = fParam->GetNPads(fSector,iRow);
      
      for (Int_t iPad = 3; iPad < maxPad + 3; iPad++) {
        for (Int_t iTimeBin = 0; iTimeBin < fMaxTime; iTimeBin++) {
          Int_t bin = iPad*fMaxTime+iTimeBin;
          Float_t signal = fAllBins[iRow][bin];
          if (AliTPCReconstructor::StreamLevel()>3 && signal>3) {
            Double_t x[]={static_cast<Double_t>(iRow),static_cast<Double_t>(iPad-3),static_cast<Double_t>(iTimeBin-3)};
            Int_t i[]={fSector};
            AliTPCTransform trafo;
            trafo.Transform(x,i,0,1);
            Double_t gx[3]={x[0],x[1],x[2]};
            trafo.RotatedGlobal2Global(fSector,gx);
        //        fAllSigBins[iRow][fAllNSigBins[iRow]++]
            Int_t rowsigBins = fAllNSigBins[iRow];
            Int_t first=fAllSigBins[iRow][0];
            Int_t last= 0;
        //        if (rowsigBins>0) fAllSigBins[iRow][fAllNSigBins[iRow]-1];
            
            if (AliTPCReconstructor::StreamLevel()>5) {
              (*fDebugStreamer)<<"Digits"<<
                "sec="<<fSector<<
                "row="<<iRow<<
                "pad="<<iPad<<
                "time="<<iTimeBin<<
                "sig="<<signal<<
                "x="<<x[0]<<
                "y="<<x[1]<<
                "z="<<x[2]<<
                "gx="<<gx[0]<<
                "gy="<<gx[1]<<
                "gz="<<gx[2]<<
    //
                "rowsigBins="<<rowsigBins<<
                "first="<<first<<
                "last="<<last<<
                "\n";
            }
          }
        }
      }
    }
  }
  
    // Now loop over rows and find clusters
  for (fRow = 0; fRow < nRows; fRow++) {
    fRowCl->SetID(fParam->GetIndex(fSector, fRow));
    if (fOutput) fOutput->GetBranch("Segment")->SetAddress(&fRowCl);
    
    fRx = fParam->GetPadRowRadii(fSector, fRow);
    fPadLength = fParam->GetPadPitchLength(fSector, fRow);
    fPadWidth  = fParam->GetPadPitchWidth();
    fMaxPad = fParam->GetNPads(fSector,fRow);
    fMaxBin = fMaxTime*(fMaxPad+6);  // add 3 virtual pads  before and 3 after
    
    fBins = fAllBins[fRow];
    fSigBins = fAllSigBins[fRow];
    fNSigBins = fAllNSigBins[fRow];
    
    FindClusters(noiseROC);
    
    FillRow();
    if(fBClonesArray == kFALSE) fRowCl->GetArray()->Clear("C");
    fNclusters += fNcluster;
    
  } // End of loop to find clusters
}


void AliTPCclusterer::Digits2Clusters(AliRawReader* rawReader)
{
//-----------------------------------------------------------------
// This is a cluster finder for the TPC raw data.
// The method assumes NO ordering of the altro channels.
// The pedestal subtraction can be switched on and off
// using an option of the TPC reconstructor
//-----------------------------------------------------------------
  fRecoParam = AliTPCReconstructor::GetRecoParam();
  if (!fRecoParam){
    AliFatal("Can not get the reconstruction parameters");
  }
  if(AliTPCReconstructor::StreamLevel()>5) {
    AliInfo("Parameter Dumps");
    fParam->Dump();
    fRecoParam->Dump();
  }
  fRowDig = NULL;

  fEventHeader = (AliRawEventHeaderBase*)rawReader->GetEventHeader();
  if (fEventHeader){
    fTimeStamp = fEventHeader->Get("Timestamp");
    fEventType = fEventHeader->Get("Type");
    AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
    transform->SetCurrentTimeStamp(fTimeStamp);
    transform->SetCurrentRun(rawReader->GetRunNumber());
  }

  //-----------------------------------------------------------------
  // Use HLT clusters
  //-----------------------------------------------------------------
  if (fUseHLTClusters == 3 || fUseHLTClusters == 4) {
    AliInfo("Using HLT clusters for TPC off-line reconstruction");
    fZWidth = fParam->GetZWidth();
    Int_t iResult = ReadHLTClusters();

    // HLT clusters present
    if (iResult >= 0 && fNclusters > 0)
      return;

    // HLT clusters not present
    if (iResult < 0 || fNclusters == 0) {
      if (fUseHLTClusters == 3) { 
	AliError("No HLT clusters present, but requested.");
	return;
      }
      else {
	AliInfo("Now trying to read TPC RAW");
      }
    }
    // Some other problem during cluster reading
    else {
      AliWarning("Some problem while unpacking of HLT clusters.");
      return;
    }
  } // if (fUseHLTClusters == 3 || fUseHLTClusters == 4) {
   
  //-----------------------------------------------------------------
  // Run TPC off-line clusterer
  //-----------------------------------------------------------------
  AliTPCCalPad * gainTPC = AliTPCcalibDB::Instance()->GetPadGainFactor();
  AliTPCAltroMapping** mapping =AliTPCcalibDB::Instance()->GetMapping();
  //
  AliTPCRawStreamV3 input(rawReader,(AliAltroMapping**)mapping);
  
  // creaate one TClonesArray for all clusters
  if(fBClonesArray && !fOutputClonesArray) fOutputClonesArray = new TClonesArray("AliTPCclusterMI",1000);
  // reset counter
  fNclusters  = 0;
  
  fMaxTime = fRecoParam->GetLastBin() + 6; // add 3 virtual time bins before and 3 after
//   const Int_t kNIS = fParam->GetNInnerSector();
//   const Int_t kNOS = fParam->GetNOuterSector();
//   const Int_t kNS = kNIS + kNOS;
  fZWidth = fParam->GetZWidth();
  Int_t zeroSup = fParam->GetZeroSup();
  //
  // Clean-up
  //
  AliTPCROC * roc = AliTPCROC::Instance();
  Int_t nRowsMax = roc->GetNRows(roc->GetNSector()-1);
  Int_t nPadsMax = roc->GetNPads(roc->GetNSector()-1,nRowsMax-1);
  for (Int_t iRow = 0; iRow < nRowsMax; iRow++) {
    //
    Int_t maxBin = fMaxTime*(nPadsMax+6);  // add 3 virtual pads  before and 3 after
    memset(fAllBins[iRow],0,sizeof(Float_t)*maxBin);
    fAllNSigBins[iRow]=0;
  }

  rawReader->Reset();
  Int_t digCounter=0;
  //
  // Loop over DDLs
  //
  const Int_t kNIS = fParam->GetNInnerSector();
  const Int_t kNOS = fParam->GetNOuterSector();
  const Int_t kNS = kNIS + kNOS;
  
  for(fSector = 0; fSector < kNS; fSector++) {
    
    Int_t nRows = 0;
    Int_t nDDLs = 0, indexDDL = 0;
    if (fSector < kNIS) {
      nRows = fParam->GetNRowLow();
      fSign = (fSector < kNIS/2) ? 1 : -1;
      nDDLs = 2;
      indexDDL = fSector * 2;
    }
    else {
      nRows = fParam->GetNRowUp();
      fSign = ((fSector-kNIS) < kNOS/2) ? 1 : -1;
      nDDLs = 4;
      indexDDL = (fSector-kNIS) * 4 + kNIS * 2;
    }
    
    // load the raw data for corresponding DDLs
    rawReader->Reset();
    rawReader->Select("TPC",indexDDL,indexDDL+nDDLs-1);
    
  while (input.NextDDL()){
    if (input.GetSector() != fSector)
      AliFatal(Form("Sector index mismatch ! Expected (%d), but got (%d) !",fSector,input.GetSector()));
    
    //Int_t nRows = fParam->GetNRow(fSector);
    
    AliTPCCalROC * gainROC    = gainTPC->GetCalROC(fSector);  // pad gains per given sector
    // Begin loop over altro data
    Bool_t calcPedestal = fRecoParam->GetCalcPedestal();
    Float_t gain =1;
    
    //loop over pads
    while ( input.NextChannel() ) {
      Int_t iRow = input.GetRow();
      if (iRow < 0){
        continue;
      }
      if (iRow >= nRows){
        AliError(Form("Pad-row index (%d) outside the range (%d -> %d) !",
                      iRow, 0, nRows -1));
        continue;
      }
      //pad
      Int_t iPad = input.GetPad();
      if (iPad < 0 || iPad >= nPadsMax) {
        AliError(Form("Pad index (%d) outside the range (%d -> %d) !",
                      iPad, 0, nPadsMax-1));
        continue;
      }
      gain    = gainROC->GetValue(iRow,iPad);
      iPad+=3;

      //loop over bunches
      while ( input.NextBunch() ){
        Int_t  startTbin    = (Int_t)input.GetStartTimeBin();
        Int_t  bunchlength  = (Int_t)input.GetBunchLength();
        const UShort_t *sig = input.GetSignals();
        for (Int_t iTime = 0; iTime<bunchlength; iTime++){
          Int_t iTimeBin=startTbin-iTime;
          if ( iTimeBin < fRecoParam->GetFirstBin() || iTimeBin >= fRecoParam->GetLastBin()){
            continue;
            AliFatal(Form("Timebin index (%d) outside the range (%d -> %d) !",
                          iTimeBin, 0, iTimeBin -1));
          }
          iTimeBin+=3;
          //signal
          Float_t signal=(Float_t)sig[iTime];
          if (!calcPedestal && signal <= zeroSup) continue;
      
          if (!calcPedestal) {
            Int_t bin = iPad*fMaxTime+iTimeBin;
            if (gain>0){
              fAllBins[iRow][bin] = signal/gain;
            }else{
              fAllBins[iRow][bin] =0;
            }
            fAllSigBins[iRow][fAllNSigBins[iRow]++] = bin;
          }else{
            fAllBins[iRow][iPad*fMaxTime+iTimeBin] = signal;
          }
          fAllBins[iRow][iPad*fMaxTime+0]+=1.;  // pad with signal
          
          // Temporary
          digCounter++;
        }// end loop signals in bunch
      }// end loop bunches
    } // end loop pads
    //
    //
    //
    //
    // Now loop over rows and perform pedestal subtraction
    if (digCounter==0) continue;
  } // End of loop over sectors
  //process last sector
  if ( digCounter>0 ){
    ProcessSectorData();
    for (Int_t iRow = 0; iRow < fParam->GetNRow(fSector); iRow++) {
      Int_t maxPad = fParam->GetNPads(fSector,iRow);
      Int_t maxBin = fMaxTime*(maxPad+6);  // add 3 virtual pads  before and 3 after
      memset(fAllBins[iRow],0,sizeof(Float_t)*maxBin);
      fAllNSigBins[iRow] = 0;
    }
    digCounter=0;
  }
  }
  
  if (rawReader->GetEventId() && fOutput ){
    Info("Digits2Clusters", "File  %s Event\t%u\tNumber of found clusters : %d\n", fOutput->GetName(),*(rawReader->GetEventId()), fNclusters);
  }
  
  if(rawReader->GetEventId()) {
    Info("Digits2Clusters", "Event\t%u\tNumber of found clusters : %d\n",*(rawReader->GetEventId()), fNclusters);
  }
  
  if(fBClonesArray) {
    //Info("Digits2Clusters", "Number of found clusters : %d\n",fOutputClonesArray->GetEntriesFast());
  }

  if (fUseHLTClusters == 2 && fNclusters == 0) {
    AliInfo("No clusters from TPC Raw data, now trying to read HLT clusters.");

    fZWidth = fParam->GetZWidth();
    ReadHLTClusters();
  }
}

void AliTPCclusterer::FindClusters(AliTPCCalROC * noiseROC)
{
  
  //
  // add virtual charge at the edge   
  //
  Double_t kMaxDumpSize = 500000;
  if (!fOutput) {
    fBDumpSignal =kFALSE;
  }else{
    if (fRecoParam->GetCalcPedestal() && fOutput->GetZipBytes()< kMaxDumpSize) fBDumpSignal =kTRUE;   //dump signal flag
  }
   
  fNcluster=0;
  fLoop=1;
  Int_t crtime = Int_t((fParam->GetZLength(fSector)-fRecoParam->GetCtgRange()*fRx)/fZWidth-fParam->GetNTBinsL1()-5);
  Float_t minMaxCutAbs       = fRecoParam->GetMinMaxCutAbs();
  Float_t minLeftRightCutAbs = fRecoParam->GetMinLeftRightCutAbs();
  Float_t minUpDownCutAbs    = fRecoParam->GetMinUpDownCutAbs();
  Float_t minMaxCutSigma       = fRecoParam->GetMinMaxCutSigma();
  Float_t minLeftRightCutSigma = fRecoParam->GetMinLeftRightCutSigma();
  Float_t minUpDownCutSigma    = fRecoParam->GetMinUpDownCutSigma();
  Int_t   useOnePadCluster     = fRecoParam->GetUseOnePadCluster();
  for (Int_t iSig = 0; iSig < fNSigBins; iSig++) {
    Int_t i = fSigBins[iSig];
    if (i%fMaxTime<=crtime) continue;
    Float_t *b = &fBins[i];
    //absolute custs
    if (b[0]<minMaxCutAbs) continue;   //threshold for maxima  
    //
    if (useOnePadCluster==0){
      if (b[-1]+b[1]+b[-fMaxTime]+b[fMaxTime]<=0) continue;  // cut on isolated clusters 
      if (b[-1]+b[1]<=0) continue;               // cut on isolated clusters
      if (b[-fMaxTime]+b[fMaxTime]<=0) continue; // cut on isolated clusters
    }
    //
    if ((b[0]+b[-1]+b[1])<minUpDownCutAbs) continue;   //threshold for up down  (TRF) 
    if ((b[0]+b[-fMaxTime]+b[fMaxTime])<minLeftRightCutAbs) continue;   //threshold for left right (PRF)    
    if (!IsMaximum(*b,fMaxTime,b)) continue;
    //
    Float_t noise = noiseROC->GetValue(fRow, i/fMaxTime);
    if (noise>fRecoParam->GetMaxNoise()) continue;
    // sigma cuts
    if (b[0]<minMaxCutSigma*noise) continue;   //threshold form maxima  
    if ((b[0]+b[-1]+b[1])<minUpDownCutSigma*noise) continue;   //threshold for up town TRF 
    if ((b[0]+b[-fMaxTime]+b[fMaxTime])<minLeftRightCutSigma*noise) continue;   //threshold for left right (PRF)    
  
    AliTPCclusterMI c;   // default cosntruction  without info
    Int_t dummy=0;
    MakeCluster(i, fMaxTime, fBins, dummy,c);
    
    //}
  }
}

Bool_t AliTPCclusterer::AcceptCluster(AliTPCclusterMI *cl){
  // -- Depricated --
  // Currently hack to filter digital noise (15.06.2008)
  // To be parameterized in the AliTPCrecoParam
  // More inteligent way  to be used in future
  // Acces to the proper pedestal file needed
  //
  if (cl->GetMax()<400) return kTRUE;
  Double_t ratio = cl->GetQ()/cl->GetMax();
  if (cl->GetMax()>700){
    if ((ratio - int(ratio)>0.8)) return kFALSE;
  }
  if ((ratio - int(ratio)<0.95)) return kTRUE;
  return kFALSE;
}


Double_t AliTPCclusterer::ProcesSignal(Float_t *signal, Int_t nchannels, Int_t id[3], Double_t &rmsEvent, Double_t &pedestalEvent){
  //
  // process signal on given pad - + streaming of additional information in special mode
  //
  // id[0] - sector
  // id[1] - row
  // id[2] - pad 

  //
  // ESTIMATE pedestal and the noise
  // 
  const Int_t kPedMax = 100;
  Float_t  max    =  0;
  Float_t  maxPos =  0;
  Int_t    median =  -1;
  Int_t    count0 =  0;
  Int_t    count1 =  0;
  Float_t  rmsCalib   = rmsEvent;       // backup initial value ( from calib)
  Float_t  pedestalCalib = pedestalEvent;// backup initial value ( from calib)
  Int_t    firstBin = fRecoParam->GetFirstBin();
  //
  UShort_t histo[kPedMax];
  //memset(histo,0,kPedMax*sizeof(UShort_t));
  for (Int_t i=0; i<kPedMax; i++) histo[i]=0;
  for (Int_t i=0; i<fMaxTime; i++){
    if (signal[i]<=0) continue;
    if (signal[i]>max && i>firstBin) {
      max = signal[i];
      maxPos = i;
    }
    if (signal[i]>kPedMax-1) continue;
    histo[int(signal[i]+0.5)]++;
    count0++;
  }
  //
  for (Int_t i=1; i<kPedMax; i++){
    if (count1<count0*0.5) median=i;
    count1+=histo[i];
  }
  // truncated mean  
  //
  Float_t count10=histo[median] ,mean=histo[median]*median,  rms=histo[median]*median*median ;
  Float_t count06=histo[median] ,mean06=histo[median]*median,  rms06=histo[median]*median*median ;
  Float_t count09=histo[median] ,mean09=histo[median]*median,  rms09=histo[median]*median*median ;
  //
  for (Int_t idelta=1; idelta<10; idelta++){
    if (median-idelta<=0) continue;
    if (median+idelta>kPedMax) continue;
    if (count06<0.6*count1){
      count06+=histo[median-idelta];
      mean06 +=histo[median-idelta]*(median-idelta);
      rms06  +=histo[median-idelta]*(median-idelta)*(median-idelta);
      count06+=histo[median+idelta];
      mean06 +=histo[median+idelta]*(median+idelta);
      rms06  +=histo[median+idelta]*(median+idelta)*(median+idelta);
    }
    if (count09<0.9*count1){
      count09+=histo[median-idelta];
      mean09 +=histo[median-idelta]*(median-idelta);
      rms09  +=histo[median-idelta]*(median-idelta)*(median-idelta);
      count09+=histo[median+idelta];
      mean09 +=histo[median+idelta]*(median+idelta);
      rms09  +=histo[median+idelta]*(median+idelta)*(median+idelta);
    }
    if (count10<0.95*count1){
      count10+=histo[median-idelta];
      mean +=histo[median-idelta]*(median-idelta);
      rms  +=histo[median-idelta]*(median-idelta)*(median-idelta);
      count10+=histo[median+idelta];
      mean +=histo[median+idelta]*(median+idelta);
      rms  +=histo[median+idelta]*(median+idelta)*(median+idelta);
    }
  }
  if (count10) {
    mean  /=count10;
    rms    = TMath::Sqrt(TMath::Abs(rms/count10-mean*mean));
  }
  if (count06) {
    mean06/=count06;
    rms06    = TMath::Sqrt(TMath::Abs(rms06/count06-mean06*mean06));
  }
  if (count09) {
    mean09/=count09;
    rms09    = TMath::Sqrt(TMath::Abs(rms09/count09-mean09*mean09));
  }
  rmsEvent = rms09;
  //
  pedestalEvent = median;
  if (AliLog::GetDebugLevel("","AliTPCclusterer")==0) return median;
  //
  UInt_t uid[3] = {UInt_t(id[0]),UInt_t(id[1]),UInt_t(id[2])};
  //
  // Dump mean signal info
  //
    if (AliTPCReconstructor::StreamLevel()>0) {
    (*fDebugStreamer)<<"Signal"<<
    "TimeStamp="<<fTimeStamp<<
    "EventType="<<fEventType<<
    "Sector="<<uid[0]<<
    "Row="<<uid[1]<<
    "Pad="<<uid[2]<<
    "Max="<<max<<
    "MaxPos="<<maxPos<<
    //
    "Median="<<median<<
    "Mean="<<mean<<
    "RMS="<<rms<<      
    "Mean06="<<mean06<<
    "RMS06="<<rms06<<
    "Mean09="<<mean09<<
    "RMS09="<<rms09<<
    "RMSCalib="<<rmsCalib<<
    "PedCalib="<<pedestalCalib<<
    "\n";
    }
  //
  // fill pedestal histogram
  //
  //
  //
  //
  Float_t kMin =fRecoParam->GetDumpAmplitudeMin();   // minimal signal to be dumped
  Float_t *dsignal = new Float_t[nchannels];
  Float_t *dtime   = new Float_t[nchannels];
  for (Int_t i=0; i<nchannels; i++){
    dtime[i] = i;
    dsignal[i] = signal[i];
  }

  //
  // Big signals dumping
  //    
  if (AliTPCReconstructor::StreamLevel()>0) {
  if (max-median>kMin &&maxPos>fRecoParam->GetFirstBin()) 
    (*fDebugStreamer)<<"SignalB"<<     // pads with signal
      "TimeStamp="<<fTimeStamp<<
      "EventType="<<fEventType<<
      "Sector="<<uid[0]<<
      "Row="<<uid[1]<<
      "Pad="<<uid[2]<<
      //      "Graph="<<graph<<
      "Max="<<max<<
      "MaxPos="<<maxPos<<	
      //
      "Median="<<median<<
      "Mean="<<mean<<
      "RMS="<<rms<<      
      "Mean06="<<mean06<<
      "RMS06="<<rms06<<
      "Mean09="<<mean09<<
      "RMS09="<<rms09<<
      "\n";
  }

  delete [] dsignal;
  delete [] dtime;
  if (rms06>fRecoParam->GetMaxNoise()) {
    pedestalEvent+=1024.;
    return 1024+median; // sign noisy channel in debug mode
  }
  return median;
}

Int_t AliTPCclusterer::ReadHLTClusters()
{
  //
  // read HLT clusters instead of off line custers, 
  // used in Digits2Clusters
  //

  if (!fHLTClusterAccess) {
  TClass* pCl=NULL;
  ROOT::NewFunc_t pNewFunc=NULL;
  do {
    pCl=TClass::GetClass("AliHLTTPCClusterAccessHLTOUT");
  } while (!pCl && gSystem->Load("libAliHLTTPC.so")==0);
  if (!pCl || (pNewFunc=pCl->GetNew())==NULL) {
    AliError("can not load class description of AliHLTTPCClusterAccessHLTOUT, aborting ...");
    return -1;
  }
  
  void* p=(*pNewFunc)(NULL);
  if (!p) {
    AliError("unable to create instance of AliHLTTPCClusterAccessHLTOUT");
    return -2;
  }
  fHLTClusterAccess=reinterpret_cast<TObject*>(p);
  }

  TObject* pClusterAccess=fHLTClusterAccess;

  const Int_t kNIS = fParam->GetNInnerSector();
  const Int_t kNOS = fParam->GetNOuterSector();
  const Int_t kNS = kNIS + kNOS;
  fNclusters  = 0;

  // noise and dead channel treatment -- should be the same as in offline clusterizer
  const AliTPCCalPad * gainTPC  = AliTPCcalibDB::Instance() -> GetPadGainFactor();
  const AliTPCCalPad * noiseTPC = AliTPCcalibDB::Instance() -> GetPadNoise();

  // charge thresholds
  // TODO: In the offline cluster finder there are also cuts in time and pad direction
  //       do they need to be included here? Most probably this is not possible
  //       since we don't have the charge information
  const Float_t minMaxCutAbs       = fRecoParam -> GetMinMaxCutAbs();
  const Float_t minMaxCutSigma     = fRecoParam -> GetMinMaxCutSigma();
  
  
  // make sure that all clusters from the previous event are cleared
  pClusterAccess->Clear("event");
  for(fSector = 0; fSector < kNS; fSector++) {

    Int_t iResult = 1;
    TString param("sector="); param+=fSector;
    // prepare for next sector
    pClusterAccess->Clear("sector");
    pClusterAccess->Execute("read", param, &iResult);
    if (iResult < 0) {
      return iResult;
      AliError("HLT Clusters can not be found");
    }

    TObject* pObj=pClusterAccess->FindObject("clusterarray");
    if (pObj==NULL) {
      AliError("HLT clusters requested, but not cluster array not present");
      return -4;
    }

    TObjArray* clusterArray=dynamic_cast<TClonesArray*>(pObj);
    if (!clusterArray) {
      AliError("HLT cluster array is not of class type TClonesArray");
      return -5;
    }

    AliDebug(4,Form("Reading %d clusters from HLT for sector %d", clusterArray->GetEntriesFast(), fSector));

    Int_t nClusterSector=0;
    Int_t nClusterSectorGood=0;
    Int_t nRows=fParam->GetNRow(fSector);

    // active channel map and noise map for current sector
    const AliTPCCalROC * gainROC  = gainTPC  -> GetCalROC(fSector);  // pad gains per given sector
    const AliTPCCalROC * noiseROC = noiseTPC -> GetCalROC(fSector); // noise per given sector

    for (fRow = 0; fRow < nRows; fRow++) {
      fRowCl->SetID(fParam->GetIndex(fSector, fRow));
      if (fOutput) fOutput->GetBranch("Segment")->SetAddress(&fRowCl);
      fNcluster=0; // reset clusters per row

      fRx = fParam->GetPadRowRadii(fSector, fRow);
      fPadLength = fParam->GetPadPitchLength(fSector, fRow);
      fPadWidth  = fParam->GetPadPitchWidth();
      fMaxPad = fParam->GetNPads(fSector,fRow);
      fMaxBin = fMaxTime*(fMaxPad+6);  // add 3 virtual pads  before and 3 after

      fBins = fAllBins[fRow];
      fSigBins = fAllSigBins[fRow];
      fNSigBins = fAllNSigBins[fRow];

      for (Int_t i=0; i<clusterArray->GetEntriesFast(); i++) {
	if (!clusterArray->At(i)) 
	  continue;
	
	AliTPCclusterMI* cluster=dynamic_cast<AliTPCclusterMI*>(clusterArray->At(i));
	if (!cluster) continue;
	if (cluster->GetRow()!=fRow) continue;
        nClusterSector++;

        const Int_t   currentPad = TMath::Nint(cluster->GetPad());
        const Float_t maxCharge  = cluster->GetMax();

        const Float_t gain       = gainROC  -> GetValue(fRow, currentPad);
        const Float_t noise      = noiseROC -> GetValue(fRow, currentPad);

        // check if cluster is on an active pad
        // TODO: PadGainFactor should only contain 1 or 0. However in Digits2Clusters
        //       this is treated as a real gain factor per pad. Is the implementation
        //       below fine?
        if (!(gain>0)) continue;

        // check if the cluster is on a too noisy pad
        if (noise>fRecoParam->GetMaxNoise()) continue;

        // check if the charge is above the required minimum
        if (maxCharge<minMaxCutAbs)         continue;
        if (maxCharge<minMaxCutSigma*noise) continue;
        
	nClusterSectorGood++;
	AddCluster(*cluster, NULL, 0);
      }
      
      FillRow();
      fRowCl->GetArray()->Clear("c");
      
    } // for (fRow = 0; fRow < nRows; fRow++) {
    if (nClusterSector!=clusterArray->GetEntriesFast()) {
      AliError(Form("Failed to read %d out of %d HLT clusters", 
		    clusterArray->GetEntriesFast()-nClusterSector, 
		    clusterArray->GetEntriesFast()));
    }
    fNclusters+=nClusterSectorGood;
  } // for(fSector = 0; fSector < kNS; fSector++) {

  pClusterAccess->Clear("event");

  Info("Digits2Clusters", "Number of converted HLT clusters : %d", fNclusters);
  
  return 0;
}
 AliTPCclusterer.cxx:1
 AliTPCclusterer.cxx:2
 AliTPCclusterer.cxx:3
 AliTPCclusterer.cxx:4
 AliTPCclusterer.cxx:5
 AliTPCclusterer.cxx:6
 AliTPCclusterer.cxx:7
 AliTPCclusterer.cxx:8
 AliTPCclusterer.cxx:9
 AliTPCclusterer.cxx:10
 AliTPCclusterer.cxx:11
 AliTPCclusterer.cxx:12
 AliTPCclusterer.cxx:13
 AliTPCclusterer.cxx:14
 AliTPCclusterer.cxx:15
 AliTPCclusterer.cxx:16
 AliTPCclusterer.cxx:17
 AliTPCclusterer.cxx:18
 AliTPCclusterer.cxx:19
 AliTPCclusterer.cxx:20
 AliTPCclusterer.cxx:21
 AliTPCclusterer.cxx:22
 AliTPCclusterer.cxx:23
 AliTPCclusterer.cxx:24
 AliTPCclusterer.cxx:25
 AliTPCclusterer.cxx:26
 AliTPCclusterer.cxx:27
 AliTPCclusterer.cxx:28
 AliTPCclusterer.cxx:29
 AliTPCclusterer.cxx:30
 AliTPCclusterer.cxx:31
 AliTPCclusterer.cxx:32
 AliTPCclusterer.cxx:33
 AliTPCclusterer.cxx:34
 AliTPCclusterer.cxx:35
 AliTPCclusterer.cxx:36
 AliTPCclusterer.cxx:37
 AliTPCclusterer.cxx:38
 AliTPCclusterer.cxx:39
 AliTPCclusterer.cxx:40
 AliTPCclusterer.cxx:41
 AliTPCclusterer.cxx:42
 AliTPCclusterer.cxx:43
 AliTPCclusterer.cxx:44
 AliTPCclusterer.cxx:45
 AliTPCclusterer.cxx:46
 AliTPCclusterer.cxx:47
 AliTPCclusterer.cxx:48
 AliTPCclusterer.cxx:49
 AliTPCclusterer.cxx:50
 AliTPCclusterer.cxx:51
 AliTPCclusterer.cxx:52
 AliTPCclusterer.cxx:53
 AliTPCclusterer.cxx:54
 AliTPCclusterer.cxx:55
 AliTPCclusterer.cxx:56
 AliTPCclusterer.cxx:57
 AliTPCclusterer.cxx:58
 AliTPCclusterer.cxx:59
 AliTPCclusterer.cxx:60
 AliTPCclusterer.cxx:61
 AliTPCclusterer.cxx:62
 AliTPCclusterer.cxx:63
 AliTPCclusterer.cxx:64
 AliTPCclusterer.cxx:65
 AliTPCclusterer.cxx:66
 AliTPCclusterer.cxx:67
 AliTPCclusterer.cxx:68
 AliTPCclusterer.cxx:69
 AliTPCclusterer.cxx:70
 AliTPCclusterer.cxx:71
 AliTPCclusterer.cxx:72
 AliTPCclusterer.cxx:73
 AliTPCclusterer.cxx:74
 AliTPCclusterer.cxx:75
 AliTPCclusterer.cxx:76
 AliTPCclusterer.cxx:77
 AliTPCclusterer.cxx:78
 AliTPCclusterer.cxx:79
 AliTPCclusterer.cxx:80
 AliTPCclusterer.cxx:81
 AliTPCclusterer.cxx:82
 AliTPCclusterer.cxx:83
 AliTPCclusterer.cxx:84
 AliTPCclusterer.cxx:85
 AliTPCclusterer.cxx:86
 AliTPCclusterer.cxx:87
 AliTPCclusterer.cxx:88
 AliTPCclusterer.cxx:89
 AliTPCclusterer.cxx:90
 AliTPCclusterer.cxx:91
 AliTPCclusterer.cxx:92
 AliTPCclusterer.cxx:93
 AliTPCclusterer.cxx:94
 AliTPCclusterer.cxx:95
 AliTPCclusterer.cxx:96
 AliTPCclusterer.cxx:97
 AliTPCclusterer.cxx:98
 AliTPCclusterer.cxx:99
 AliTPCclusterer.cxx:100
 AliTPCclusterer.cxx:101
 AliTPCclusterer.cxx:102
 AliTPCclusterer.cxx:103
 AliTPCclusterer.cxx:104
 AliTPCclusterer.cxx:105
 AliTPCclusterer.cxx:106
 AliTPCclusterer.cxx:107
 AliTPCclusterer.cxx:108
 AliTPCclusterer.cxx:109
 AliTPCclusterer.cxx:110
 AliTPCclusterer.cxx:111
 AliTPCclusterer.cxx:112
 AliTPCclusterer.cxx:113
 AliTPCclusterer.cxx:114
 AliTPCclusterer.cxx:115
 AliTPCclusterer.cxx:116
 AliTPCclusterer.cxx:117
 AliTPCclusterer.cxx:118
 AliTPCclusterer.cxx:119
 AliTPCclusterer.cxx:120
 AliTPCclusterer.cxx:121
 AliTPCclusterer.cxx:122
 AliTPCclusterer.cxx:123
 AliTPCclusterer.cxx:124
 AliTPCclusterer.cxx:125
 AliTPCclusterer.cxx:126
 AliTPCclusterer.cxx:127
 AliTPCclusterer.cxx:128
 AliTPCclusterer.cxx:129
 AliTPCclusterer.cxx:130
 AliTPCclusterer.cxx:131
 AliTPCclusterer.cxx:132
 AliTPCclusterer.cxx:133
 AliTPCclusterer.cxx:134
 AliTPCclusterer.cxx:135
 AliTPCclusterer.cxx:136
 AliTPCclusterer.cxx:137
 AliTPCclusterer.cxx:138
 AliTPCclusterer.cxx:139
 AliTPCclusterer.cxx:140
 AliTPCclusterer.cxx:141
 AliTPCclusterer.cxx:142
 AliTPCclusterer.cxx:143
 AliTPCclusterer.cxx:144
 AliTPCclusterer.cxx:145
 AliTPCclusterer.cxx:146
 AliTPCclusterer.cxx:147
 AliTPCclusterer.cxx:148
 AliTPCclusterer.cxx:149
 AliTPCclusterer.cxx:150
 AliTPCclusterer.cxx:151
 AliTPCclusterer.cxx:152
 AliTPCclusterer.cxx:153
 AliTPCclusterer.cxx:154
 AliTPCclusterer.cxx:155
 AliTPCclusterer.cxx:156
 AliTPCclusterer.cxx:157
 AliTPCclusterer.cxx:158
 AliTPCclusterer.cxx:159
 AliTPCclusterer.cxx:160
 AliTPCclusterer.cxx:161
 AliTPCclusterer.cxx:162
 AliTPCclusterer.cxx:163
 AliTPCclusterer.cxx:164
 AliTPCclusterer.cxx:165
 AliTPCclusterer.cxx:166
 AliTPCclusterer.cxx:167
 AliTPCclusterer.cxx:168
 AliTPCclusterer.cxx:169
 AliTPCclusterer.cxx:170
 AliTPCclusterer.cxx:171
 AliTPCclusterer.cxx:172
 AliTPCclusterer.cxx:173
 AliTPCclusterer.cxx:174
 AliTPCclusterer.cxx:175
 AliTPCclusterer.cxx:176
 AliTPCclusterer.cxx:177
 AliTPCclusterer.cxx:178
 AliTPCclusterer.cxx:179
 AliTPCclusterer.cxx:180
 AliTPCclusterer.cxx:181
 AliTPCclusterer.cxx:182
 AliTPCclusterer.cxx:183
 AliTPCclusterer.cxx:184
 AliTPCclusterer.cxx:185
 AliTPCclusterer.cxx:186
 AliTPCclusterer.cxx:187
 AliTPCclusterer.cxx:188
 AliTPCclusterer.cxx:189
 AliTPCclusterer.cxx:190
 AliTPCclusterer.cxx:191
 AliTPCclusterer.cxx:192
 AliTPCclusterer.cxx:193
 AliTPCclusterer.cxx:194
 AliTPCclusterer.cxx:195
 AliTPCclusterer.cxx:196
 AliTPCclusterer.cxx:197
 AliTPCclusterer.cxx:198
 AliTPCclusterer.cxx:199
 AliTPCclusterer.cxx:200
 AliTPCclusterer.cxx:201
 AliTPCclusterer.cxx:202
 AliTPCclusterer.cxx:203
 AliTPCclusterer.cxx:204
 AliTPCclusterer.cxx:205
 AliTPCclusterer.cxx:206
 AliTPCclusterer.cxx:207
 AliTPCclusterer.cxx:208
 AliTPCclusterer.cxx:209
 AliTPCclusterer.cxx:210
 AliTPCclusterer.cxx:211
 AliTPCclusterer.cxx:212
 AliTPCclusterer.cxx:213
 AliTPCclusterer.cxx:214
 AliTPCclusterer.cxx:215
 AliTPCclusterer.cxx:216
 AliTPCclusterer.cxx:217
 AliTPCclusterer.cxx:218
 AliTPCclusterer.cxx:219
 AliTPCclusterer.cxx:220
 AliTPCclusterer.cxx:221
 AliTPCclusterer.cxx:222
 AliTPCclusterer.cxx:223
 AliTPCclusterer.cxx:224
 AliTPCclusterer.cxx:225
 AliTPCclusterer.cxx:226
 AliTPCclusterer.cxx:227
 AliTPCclusterer.cxx:228
 AliTPCclusterer.cxx:229
 AliTPCclusterer.cxx:230
 AliTPCclusterer.cxx:231
 AliTPCclusterer.cxx:232
 AliTPCclusterer.cxx:233
 AliTPCclusterer.cxx:234
 AliTPCclusterer.cxx:235
 AliTPCclusterer.cxx:236
 AliTPCclusterer.cxx:237
 AliTPCclusterer.cxx:238
 AliTPCclusterer.cxx:239
 AliTPCclusterer.cxx:240
 AliTPCclusterer.cxx:241
 AliTPCclusterer.cxx:242
 AliTPCclusterer.cxx:243
 AliTPCclusterer.cxx:244
 AliTPCclusterer.cxx:245
 AliTPCclusterer.cxx:246
 AliTPCclusterer.cxx:247
 AliTPCclusterer.cxx:248
 AliTPCclusterer.cxx:249
 AliTPCclusterer.cxx:250
 AliTPCclusterer.cxx:251
 AliTPCclusterer.cxx:252
 AliTPCclusterer.cxx:253
 AliTPCclusterer.cxx:254
 AliTPCclusterer.cxx:255
 AliTPCclusterer.cxx:256
 AliTPCclusterer.cxx:257
 AliTPCclusterer.cxx:258
 AliTPCclusterer.cxx:259
 AliTPCclusterer.cxx:260
 AliTPCclusterer.cxx:261
 AliTPCclusterer.cxx:262
 AliTPCclusterer.cxx:263
 AliTPCclusterer.cxx:264
 AliTPCclusterer.cxx:265
 AliTPCclusterer.cxx:266
 AliTPCclusterer.cxx:267
 AliTPCclusterer.cxx:268
 AliTPCclusterer.cxx:269
 AliTPCclusterer.cxx:270
 AliTPCclusterer.cxx:271
 AliTPCclusterer.cxx:272
 AliTPCclusterer.cxx:273
 AliTPCclusterer.cxx:274
 AliTPCclusterer.cxx:275
 AliTPCclusterer.cxx:276
 AliTPCclusterer.cxx:277
 AliTPCclusterer.cxx:278
 AliTPCclusterer.cxx:279
 AliTPCclusterer.cxx:280
 AliTPCclusterer.cxx:281
 AliTPCclusterer.cxx:282
 AliTPCclusterer.cxx:283
 AliTPCclusterer.cxx:284
 AliTPCclusterer.cxx:285
 AliTPCclusterer.cxx:286
 AliTPCclusterer.cxx:287
 AliTPCclusterer.cxx:288
 AliTPCclusterer.cxx:289
 AliTPCclusterer.cxx:290
 AliTPCclusterer.cxx:291
 AliTPCclusterer.cxx:292
 AliTPCclusterer.cxx:293
 AliTPCclusterer.cxx:294
 AliTPCclusterer.cxx:295
 AliTPCclusterer.cxx:296
 AliTPCclusterer.cxx:297
 AliTPCclusterer.cxx:298
 AliTPCclusterer.cxx:299
 AliTPCclusterer.cxx:300
 AliTPCclusterer.cxx:301
 AliTPCclusterer.cxx:302
 AliTPCclusterer.cxx:303
 AliTPCclusterer.cxx:304
 AliTPCclusterer.cxx:305
 AliTPCclusterer.cxx:306
 AliTPCclusterer.cxx:307
 AliTPCclusterer.cxx:308
 AliTPCclusterer.cxx:309
 AliTPCclusterer.cxx:310
 AliTPCclusterer.cxx:311
 AliTPCclusterer.cxx:312
 AliTPCclusterer.cxx:313
 AliTPCclusterer.cxx:314
 AliTPCclusterer.cxx:315
 AliTPCclusterer.cxx:316
 AliTPCclusterer.cxx:317
 AliTPCclusterer.cxx:318
 AliTPCclusterer.cxx:319
 AliTPCclusterer.cxx:320
 AliTPCclusterer.cxx:321
 AliTPCclusterer.cxx:322
 AliTPCclusterer.cxx:323
 AliTPCclusterer.cxx:324
 AliTPCclusterer.cxx:325
 AliTPCclusterer.cxx:326
 AliTPCclusterer.cxx:327
 AliTPCclusterer.cxx:328
 AliTPCclusterer.cxx:329
 AliTPCclusterer.cxx:330
 AliTPCclusterer.cxx:331
 AliTPCclusterer.cxx:332
 AliTPCclusterer.cxx:333
 AliTPCclusterer.cxx:334
 AliTPCclusterer.cxx:335
 AliTPCclusterer.cxx:336
 AliTPCclusterer.cxx:337
 AliTPCclusterer.cxx:338
 AliTPCclusterer.cxx:339
 AliTPCclusterer.cxx:340
 AliTPCclusterer.cxx:341
 AliTPCclusterer.cxx:342
 AliTPCclusterer.cxx:343
 AliTPCclusterer.cxx:344
 AliTPCclusterer.cxx:345
 AliTPCclusterer.cxx:346
 AliTPCclusterer.cxx:347
 AliTPCclusterer.cxx:348
 AliTPCclusterer.cxx:349
 AliTPCclusterer.cxx:350
 AliTPCclusterer.cxx:351
 AliTPCclusterer.cxx:352
 AliTPCclusterer.cxx:353
 AliTPCclusterer.cxx:354
 AliTPCclusterer.cxx:355
 AliTPCclusterer.cxx:356
 AliTPCclusterer.cxx:357
 AliTPCclusterer.cxx:358
 AliTPCclusterer.cxx:359
 AliTPCclusterer.cxx:360
 AliTPCclusterer.cxx:361
 AliTPCclusterer.cxx:362
 AliTPCclusterer.cxx:363
 AliTPCclusterer.cxx:364
 AliTPCclusterer.cxx:365
 AliTPCclusterer.cxx:366
 AliTPCclusterer.cxx:367
 AliTPCclusterer.cxx:368
 AliTPCclusterer.cxx:369
 AliTPCclusterer.cxx:370
 AliTPCclusterer.cxx:371
 AliTPCclusterer.cxx:372
 AliTPCclusterer.cxx:373
 AliTPCclusterer.cxx:374
 AliTPCclusterer.cxx:375
 AliTPCclusterer.cxx:376
 AliTPCclusterer.cxx:377
 AliTPCclusterer.cxx:378
 AliTPCclusterer.cxx:379
 AliTPCclusterer.cxx:380
 AliTPCclusterer.cxx:381
 AliTPCclusterer.cxx:382
 AliTPCclusterer.cxx:383
 AliTPCclusterer.cxx:384
 AliTPCclusterer.cxx:385
 AliTPCclusterer.cxx:386
 AliTPCclusterer.cxx:387
 AliTPCclusterer.cxx:388
 AliTPCclusterer.cxx:389
 AliTPCclusterer.cxx:390
 AliTPCclusterer.cxx:391
 AliTPCclusterer.cxx:392
 AliTPCclusterer.cxx:393
 AliTPCclusterer.cxx:394
 AliTPCclusterer.cxx:395
 AliTPCclusterer.cxx:396
 AliTPCclusterer.cxx:397
 AliTPCclusterer.cxx:398
 AliTPCclusterer.cxx:399
 AliTPCclusterer.cxx:400
 AliTPCclusterer.cxx:401
 AliTPCclusterer.cxx:402
 AliTPCclusterer.cxx:403
 AliTPCclusterer.cxx:404
 AliTPCclusterer.cxx:405
 AliTPCclusterer.cxx:406
 AliTPCclusterer.cxx:407
 AliTPCclusterer.cxx:408
 AliTPCclusterer.cxx:409
 AliTPCclusterer.cxx:410
 AliTPCclusterer.cxx:411
 AliTPCclusterer.cxx:412
 AliTPCclusterer.cxx:413
 AliTPCclusterer.cxx:414
 AliTPCclusterer.cxx:415
 AliTPCclusterer.cxx:416
 AliTPCclusterer.cxx:417
 AliTPCclusterer.cxx:418
 AliTPCclusterer.cxx:419
 AliTPCclusterer.cxx:420
 AliTPCclusterer.cxx:421
 AliTPCclusterer.cxx:422
 AliTPCclusterer.cxx:423
 AliTPCclusterer.cxx:424
 AliTPCclusterer.cxx:425
 AliTPCclusterer.cxx:426
 AliTPCclusterer.cxx:427
 AliTPCclusterer.cxx:428
 AliTPCclusterer.cxx:429
 AliTPCclusterer.cxx:430
 AliTPCclusterer.cxx:431
 AliTPCclusterer.cxx:432
 AliTPCclusterer.cxx:433
 AliTPCclusterer.cxx:434
 AliTPCclusterer.cxx:435
 AliTPCclusterer.cxx:436
 AliTPCclusterer.cxx:437
 AliTPCclusterer.cxx:438
 AliTPCclusterer.cxx:439
 AliTPCclusterer.cxx:440
 AliTPCclusterer.cxx:441
 AliTPCclusterer.cxx:442
 AliTPCclusterer.cxx:443
 AliTPCclusterer.cxx:444
 AliTPCclusterer.cxx:445
 AliTPCclusterer.cxx:446
 AliTPCclusterer.cxx:447
 AliTPCclusterer.cxx:448
 AliTPCclusterer.cxx:449
 AliTPCclusterer.cxx:450
 AliTPCclusterer.cxx:451
 AliTPCclusterer.cxx:452
 AliTPCclusterer.cxx:453
 AliTPCclusterer.cxx:454
 AliTPCclusterer.cxx:455
 AliTPCclusterer.cxx:456
 AliTPCclusterer.cxx:457
 AliTPCclusterer.cxx:458
 AliTPCclusterer.cxx:459
 AliTPCclusterer.cxx:460
 AliTPCclusterer.cxx:461
 AliTPCclusterer.cxx:462
 AliTPCclusterer.cxx:463
 AliTPCclusterer.cxx:464
 AliTPCclusterer.cxx:465
 AliTPCclusterer.cxx:466
 AliTPCclusterer.cxx:467
 AliTPCclusterer.cxx:468
 AliTPCclusterer.cxx:469
 AliTPCclusterer.cxx:470
 AliTPCclusterer.cxx:471
 AliTPCclusterer.cxx:472
 AliTPCclusterer.cxx:473
 AliTPCclusterer.cxx:474
 AliTPCclusterer.cxx:475
 AliTPCclusterer.cxx:476
 AliTPCclusterer.cxx:477
 AliTPCclusterer.cxx:478
 AliTPCclusterer.cxx:479
 AliTPCclusterer.cxx:480
 AliTPCclusterer.cxx:481
 AliTPCclusterer.cxx:482
 AliTPCclusterer.cxx:483
 AliTPCclusterer.cxx:484
 AliTPCclusterer.cxx:485
 AliTPCclusterer.cxx:486
 AliTPCclusterer.cxx:487
 AliTPCclusterer.cxx:488
 AliTPCclusterer.cxx:489
 AliTPCclusterer.cxx:490
 AliTPCclusterer.cxx:491
 AliTPCclusterer.cxx:492
 AliTPCclusterer.cxx:493
 AliTPCclusterer.cxx:494
 AliTPCclusterer.cxx:495
 AliTPCclusterer.cxx:496
 AliTPCclusterer.cxx:497
 AliTPCclusterer.cxx:498
 AliTPCclusterer.cxx:499
 AliTPCclusterer.cxx:500
 AliTPCclusterer.cxx:501
 AliTPCclusterer.cxx:502
 AliTPCclusterer.cxx:503
 AliTPCclusterer.cxx:504
 AliTPCclusterer.cxx:505
 AliTPCclusterer.cxx:506
 AliTPCclusterer.cxx:507
 AliTPCclusterer.cxx:508
 AliTPCclusterer.cxx:509
 AliTPCclusterer.cxx:510
 AliTPCclusterer.cxx:511
 AliTPCclusterer.cxx:512
 AliTPCclusterer.cxx:513
 AliTPCclusterer.cxx:514
 AliTPCclusterer.cxx:515
 AliTPCclusterer.cxx:516
 AliTPCclusterer.cxx:517
 AliTPCclusterer.cxx:518
 AliTPCclusterer.cxx:519
 AliTPCclusterer.cxx:520
 AliTPCclusterer.cxx:521
 AliTPCclusterer.cxx:522
 AliTPCclusterer.cxx:523
 AliTPCclusterer.cxx:524
 AliTPCclusterer.cxx:525
 AliTPCclusterer.cxx:526
 AliTPCclusterer.cxx:527
 AliTPCclusterer.cxx:528
 AliTPCclusterer.cxx:529
 AliTPCclusterer.cxx:530
 AliTPCclusterer.cxx:531
 AliTPCclusterer.cxx:532
 AliTPCclusterer.cxx:533
 AliTPCclusterer.cxx:534
 AliTPCclusterer.cxx:535
 AliTPCclusterer.cxx:536
 AliTPCclusterer.cxx:537
 AliTPCclusterer.cxx:538
 AliTPCclusterer.cxx:539
 AliTPCclusterer.cxx:540
 AliTPCclusterer.cxx:541
 AliTPCclusterer.cxx:542
 AliTPCclusterer.cxx:543
 AliTPCclusterer.cxx:544
 AliTPCclusterer.cxx:545
 AliTPCclusterer.cxx:546
 AliTPCclusterer.cxx:547
 AliTPCclusterer.cxx:548
 AliTPCclusterer.cxx:549
 AliTPCclusterer.cxx:550
 AliTPCclusterer.cxx:551
 AliTPCclusterer.cxx:552
 AliTPCclusterer.cxx:553
 AliTPCclusterer.cxx:554
 AliTPCclusterer.cxx:555
 AliTPCclusterer.cxx:556
 AliTPCclusterer.cxx:557
 AliTPCclusterer.cxx:558
 AliTPCclusterer.cxx:559
 AliTPCclusterer.cxx:560
 AliTPCclusterer.cxx:561
 AliTPCclusterer.cxx:562
 AliTPCclusterer.cxx:563
 AliTPCclusterer.cxx:564
 AliTPCclusterer.cxx:565
 AliTPCclusterer.cxx:566
 AliTPCclusterer.cxx:567
 AliTPCclusterer.cxx:568
 AliTPCclusterer.cxx:569
 AliTPCclusterer.cxx:570
 AliTPCclusterer.cxx:571
 AliTPCclusterer.cxx:572
 AliTPCclusterer.cxx:573
 AliTPCclusterer.cxx:574
 AliTPCclusterer.cxx:575
 AliTPCclusterer.cxx:576
 AliTPCclusterer.cxx:577
 AliTPCclusterer.cxx:578
 AliTPCclusterer.cxx:579
 AliTPCclusterer.cxx:580
 AliTPCclusterer.cxx:581
 AliTPCclusterer.cxx:582
 AliTPCclusterer.cxx:583
 AliTPCclusterer.cxx:584
 AliTPCclusterer.cxx:585
 AliTPCclusterer.cxx:586
 AliTPCclusterer.cxx:587
 AliTPCclusterer.cxx:588
 AliTPCclusterer.cxx:589
 AliTPCclusterer.cxx:590
 AliTPCclusterer.cxx:591
 AliTPCclusterer.cxx:592
 AliTPCclusterer.cxx:593
 AliTPCclusterer.cxx:594
 AliTPCclusterer.cxx:595
 AliTPCclusterer.cxx:596
 AliTPCclusterer.cxx:597
 AliTPCclusterer.cxx:598
 AliTPCclusterer.cxx:599
 AliTPCclusterer.cxx:600
 AliTPCclusterer.cxx:601
 AliTPCclusterer.cxx:602
 AliTPCclusterer.cxx:603
 AliTPCclusterer.cxx:604
 AliTPCclusterer.cxx:605
 AliTPCclusterer.cxx:606
 AliTPCclusterer.cxx:607
 AliTPCclusterer.cxx:608
 AliTPCclusterer.cxx:609
 AliTPCclusterer.cxx:610
 AliTPCclusterer.cxx:611
 AliTPCclusterer.cxx:612
 AliTPCclusterer.cxx:613
 AliTPCclusterer.cxx:614
 AliTPCclusterer.cxx:615
 AliTPCclusterer.cxx:616
 AliTPCclusterer.cxx:617
 AliTPCclusterer.cxx:618
 AliTPCclusterer.cxx:619
 AliTPCclusterer.cxx:620
 AliTPCclusterer.cxx:621
 AliTPCclusterer.cxx:622
 AliTPCclusterer.cxx:623
 AliTPCclusterer.cxx:624
 AliTPCclusterer.cxx:625
 AliTPCclusterer.cxx:626
 AliTPCclusterer.cxx:627
 AliTPCclusterer.cxx:628
 AliTPCclusterer.cxx:629
 AliTPCclusterer.cxx:630
 AliTPCclusterer.cxx:631
 AliTPCclusterer.cxx:632
 AliTPCclusterer.cxx:633
 AliTPCclusterer.cxx:634
 AliTPCclusterer.cxx:635
 AliTPCclusterer.cxx:636
 AliTPCclusterer.cxx:637
 AliTPCclusterer.cxx:638
 AliTPCclusterer.cxx:639
 AliTPCclusterer.cxx:640
 AliTPCclusterer.cxx:641
 AliTPCclusterer.cxx:642
 AliTPCclusterer.cxx:643
 AliTPCclusterer.cxx:644
 AliTPCclusterer.cxx:645
 AliTPCclusterer.cxx:646
 AliTPCclusterer.cxx:647
 AliTPCclusterer.cxx:648
 AliTPCclusterer.cxx:649
 AliTPCclusterer.cxx:650
 AliTPCclusterer.cxx:651
 AliTPCclusterer.cxx:652
 AliTPCclusterer.cxx:653
 AliTPCclusterer.cxx:654
 AliTPCclusterer.cxx:655
 AliTPCclusterer.cxx:656
 AliTPCclusterer.cxx:657
 AliTPCclusterer.cxx:658
 AliTPCclusterer.cxx:659
 AliTPCclusterer.cxx:660
 AliTPCclusterer.cxx:661
 AliTPCclusterer.cxx:662
 AliTPCclusterer.cxx:663
 AliTPCclusterer.cxx:664
 AliTPCclusterer.cxx:665
 AliTPCclusterer.cxx:666
 AliTPCclusterer.cxx:667
 AliTPCclusterer.cxx:668
 AliTPCclusterer.cxx:669
 AliTPCclusterer.cxx:670
 AliTPCclusterer.cxx:671
 AliTPCclusterer.cxx:672
 AliTPCclusterer.cxx:673
 AliTPCclusterer.cxx:674
 AliTPCclusterer.cxx:675
 AliTPCclusterer.cxx:676
 AliTPCclusterer.cxx:677
 AliTPCclusterer.cxx:678
 AliTPCclusterer.cxx:679
 AliTPCclusterer.cxx:680
 AliTPCclusterer.cxx:681
 AliTPCclusterer.cxx:682
 AliTPCclusterer.cxx:683
 AliTPCclusterer.cxx:684
 AliTPCclusterer.cxx:685
 AliTPCclusterer.cxx:686
 AliTPCclusterer.cxx:687
 AliTPCclusterer.cxx:688
 AliTPCclusterer.cxx:689
 AliTPCclusterer.cxx:690
 AliTPCclusterer.cxx:691
 AliTPCclusterer.cxx:692
 AliTPCclusterer.cxx:693
 AliTPCclusterer.cxx:694
 AliTPCclusterer.cxx:695
 AliTPCclusterer.cxx:696
 AliTPCclusterer.cxx:697
 AliTPCclusterer.cxx:698
 AliTPCclusterer.cxx:699
 AliTPCclusterer.cxx:700
 AliTPCclusterer.cxx:701
 AliTPCclusterer.cxx:702
 AliTPCclusterer.cxx:703
 AliTPCclusterer.cxx:704
 AliTPCclusterer.cxx:705
 AliTPCclusterer.cxx:706
 AliTPCclusterer.cxx:707
 AliTPCclusterer.cxx:708
 AliTPCclusterer.cxx:709
 AliTPCclusterer.cxx:710
 AliTPCclusterer.cxx:711
 AliTPCclusterer.cxx:712
 AliTPCclusterer.cxx:713
 AliTPCclusterer.cxx:714
 AliTPCclusterer.cxx:715
 AliTPCclusterer.cxx:716
 AliTPCclusterer.cxx:717
 AliTPCclusterer.cxx:718
 AliTPCclusterer.cxx:719
 AliTPCclusterer.cxx:720
 AliTPCclusterer.cxx:721
 AliTPCclusterer.cxx:722
 AliTPCclusterer.cxx:723
 AliTPCclusterer.cxx:724
 AliTPCclusterer.cxx:725
 AliTPCclusterer.cxx:726
 AliTPCclusterer.cxx:727
 AliTPCclusterer.cxx:728
 AliTPCclusterer.cxx:729
 AliTPCclusterer.cxx:730
 AliTPCclusterer.cxx:731
 AliTPCclusterer.cxx:732
 AliTPCclusterer.cxx:733
 AliTPCclusterer.cxx:734
 AliTPCclusterer.cxx:735
 AliTPCclusterer.cxx:736
 AliTPCclusterer.cxx:737
 AliTPCclusterer.cxx:738
 AliTPCclusterer.cxx:739
 AliTPCclusterer.cxx:740
 AliTPCclusterer.cxx:741
 AliTPCclusterer.cxx:742
 AliTPCclusterer.cxx:743
 AliTPCclusterer.cxx:744
 AliTPCclusterer.cxx:745
 AliTPCclusterer.cxx:746
 AliTPCclusterer.cxx:747
 AliTPCclusterer.cxx:748
 AliTPCclusterer.cxx:749
 AliTPCclusterer.cxx:750
 AliTPCclusterer.cxx:751
 AliTPCclusterer.cxx:752
 AliTPCclusterer.cxx:753
 AliTPCclusterer.cxx:754
 AliTPCclusterer.cxx:755
 AliTPCclusterer.cxx:756
 AliTPCclusterer.cxx:757
 AliTPCclusterer.cxx:758
 AliTPCclusterer.cxx:759
 AliTPCclusterer.cxx:760
 AliTPCclusterer.cxx:761
 AliTPCclusterer.cxx:762
 AliTPCclusterer.cxx:763
 AliTPCclusterer.cxx:764
 AliTPCclusterer.cxx:765
 AliTPCclusterer.cxx:766
 AliTPCclusterer.cxx:767
 AliTPCclusterer.cxx:768
 AliTPCclusterer.cxx:769
 AliTPCclusterer.cxx:770
 AliTPCclusterer.cxx:771
 AliTPCclusterer.cxx:772
 AliTPCclusterer.cxx:773
 AliTPCclusterer.cxx:774
 AliTPCclusterer.cxx:775
 AliTPCclusterer.cxx:776
 AliTPCclusterer.cxx:777
 AliTPCclusterer.cxx:778
 AliTPCclusterer.cxx:779
 AliTPCclusterer.cxx:780
 AliTPCclusterer.cxx:781
 AliTPCclusterer.cxx:782
 AliTPCclusterer.cxx:783
 AliTPCclusterer.cxx:784
 AliTPCclusterer.cxx:785
 AliTPCclusterer.cxx:786
 AliTPCclusterer.cxx:787
 AliTPCclusterer.cxx:788
 AliTPCclusterer.cxx:789
 AliTPCclusterer.cxx:790
 AliTPCclusterer.cxx:791
 AliTPCclusterer.cxx:792
 AliTPCclusterer.cxx:793
 AliTPCclusterer.cxx:794
 AliTPCclusterer.cxx:795
 AliTPCclusterer.cxx:796
 AliTPCclusterer.cxx:797
 AliTPCclusterer.cxx:798
 AliTPCclusterer.cxx:799
 AliTPCclusterer.cxx:800
 AliTPCclusterer.cxx:801
 AliTPCclusterer.cxx:802
 AliTPCclusterer.cxx:803
 AliTPCclusterer.cxx:804
 AliTPCclusterer.cxx:805
 AliTPCclusterer.cxx:806
 AliTPCclusterer.cxx:807
 AliTPCclusterer.cxx:808
 AliTPCclusterer.cxx:809
 AliTPCclusterer.cxx:810
 AliTPCclusterer.cxx:811
 AliTPCclusterer.cxx:812
 AliTPCclusterer.cxx:813
 AliTPCclusterer.cxx:814
 AliTPCclusterer.cxx:815
 AliTPCclusterer.cxx:816
 AliTPCclusterer.cxx:817
 AliTPCclusterer.cxx:818
 AliTPCclusterer.cxx:819
 AliTPCclusterer.cxx:820
 AliTPCclusterer.cxx:821
 AliTPCclusterer.cxx:822
 AliTPCclusterer.cxx:823
 AliTPCclusterer.cxx:824
 AliTPCclusterer.cxx:825
 AliTPCclusterer.cxx:826
 AliTPCclusterer.cxx:827
 AliTPCclusterer.cxx:828
 AliTPCclusterer.cxx:829
 AliTPCclusterer.cxx:830
 AliTPCclusterer.cxx:831
 AliTPCclusterer.cxx:832
 AliTPCclusterer.cxx:833
 AliTPCclusterer.cxx:834
 AliTPCclusterer.cxx:835
 AliTPCclusterer.cxx:836
 AliTPCclusterer.cxx:837
 AliTPCclusterer.cxx:838
 AliTPCclusterer.cxx:839
 AliTPCclusterer.cxx:840
 AliTPCclusterer.cxx:841
 AliTPCclusterer.cxx:842
 AliTPCclusterer.cxx:843
 AliTPCclusterer.cxx:844
 AliTPCclusterer.cxx:845
 AliTPCclusterer.cxx:846
 AliTPCclusterer.cxx:847
 AliTPCclusterer.cxx:848
 AliTPCclusterer.cxx:849
 AliTPCclusterer.cxx:850
 AliTPCclusterer.cxx:851
 AliTPCclusterer.cxx:852
 AliTPCclusterer.cxx:853
 AliTPCclusterer.cxx:854
 AliTPCclusterer.cxx:855
 AliTPCclusterer.cxx:856
 AliTPCclusterer.cxx:857
 AliTPCclusterer.cxx:858
 AliTPCclusterer.cxx:859
 AliTPCclusterer.cxx:860
 AliTPCclusterer.cxx:861
 AliTPCclusterer.cxx:862
 AliTPCclusterer.cxx:863
 AliTPCclusterer.cxx:864
 AliTPCclusterer.cxx:865
 AliTPCclusterer.cxx:866
 AliTPCclusterer.cxx:867
 AliTPCclusterer.cxx:868
 AliTPCclusterer.cxx:869
 AliTPCclusterer.cxx:870
 AliTPCclusterer.cxx:871
 AliTPCclusterer.cxx:872
 AliTPCclusterer.cxx:873
 AliTPCclusterer.cxx:874
 AliTPCclusterer.cxx:875
 AliTPCclusterer.cxx:876
 AliTPCclusterer.cxx:877
 AliTPCclusterer.cxx:878
 AliTPCclusterer.cxx:879
 AliTPCclusterer.cxx:880
 AliTPCclusterer.cxx:881
 AliTPCclusterer.cxx:882
 AliTPCclusterer.cxx:883
 AliTPCclusterer.cxx:884
 AliTPCclusterer.cxx:885
 AliTPCclusterer.cxx:886
 AliTPCclusterer.cxx:887
 AliTPCclusterer.cxx:888
 AliTPCclusterer.cxx:889
 AliTPCclusterer.cxx:890
 AliTPCclusterer.cxx:891
 AliTPCclusterer.cxx:892
 AliTPCclusterer.cxx:893
 AliTPCclusterer.cxx:894
 AliTPCclusterer.cxx:895
 AliTPCclusterer.cxx:896
 AliTPCclusterer.cxx:897
 AliTPCclusterer.cxx:898
 AliTPCclusterer.cxx:899
 AliTPCclusterer.cxx:900
 AliTPCclusterer.cxx:901
 AliTPCclusterer.cxx:902
 AliTPCclusterer.cxx:903
 AliTPCclusterer.cxx:904
 AliTPCclusterer.cxx:905
 AliTPCclusterer.cxx:906
 AliTPCclusterer.cxx:907
 AliTPCclusterer.cxx:908
 AliTPCclusterer.cxx:909
 AliTPCclusterer.cxx:910
 AliTPCclusterer.cxx:911
 AliTPCclusterer.cxx:912
 AliTPCclusterer.cxx:913
 AliTPCclusterer.cxx:914
 AliTPCclusterer.cxx:915
 AliTPCclusterer.cxx:916
 AliTPCclusterer.cxx:917
 AliTPCclusterer.cxx:918
 AliTPCclusterer.cxx:919
 AliTPCclusterer.cxx:920
 AliTPCclusterer.cxx:921
 AliTPCclusterer.cxx:922
 AliTPCclusterer.cxx:923
 AliTPCclusterer.cxx:924
 AliTPCclusterer.cxx:925
 AliTPCclusterer.cxx:926
 AliTPCclusterer.cxx:927
 AliTPCclusterer.cxx:928
 AliTPCclusterer.cxx:929
 AliTPCclusterer.cxx:930
 AliTPCclusterer.cxx:931
 AliTPCclusterer.cxx:932
 AliTPCclusterer.cxx:933
 AliTPCclusterer.cxx:934
 AliTPCclusterer.cxx:935
 AliTPCclusterer.cxx:936
 AliTPCclusterer.cxx:937
 AliTPCclusterer.cxx:938
 AliTPCclusterer.cxx:939
 AliTPCclusterer.cxx:940
 AliTPCclusterer.cxx:941
 AliTPCclusterer.cxx:942
 AliTPCclusterer.cxx:943
 AliTPCclusterer.cxx:944
 AliTPCclusterer.cxx:945
 AliTPCclusterer.cxx:946
 AliTPCclusterer.cxx:947
 AliTPCclusterer.cxx:948
 AliTPCclusterer.cxx:949
 AliTPCclusterer.cxx:950
 AliTPCclusterer.cxx:951
 AliTPCclusterer.cxx:952
 AliTPCclusterer.cxx:953
 AliTPCclusterer.cxx:954
 AliTPCclusterer.cxx:955
 AliTPCclusterer.cxx:956
 AliTPCclusterer.cxx:957
 AliTPCclusterer.cxx:958
 AliTPCclusterer.cxx:959
 AliTPCclusterer.cxx:960
 AliTPCclusterer.cxx:961
 AliTPCclusterer.cxx:962
 AliTPCclusterer.cxx:963
 AliTPCclusterer.cxx:964
 AliTPCclusterer.cxx:965
 AliTPCclusterer.cxx:966
 AliTPCclusterer.cxx:967
 AliTPCclusterer.cxx:968
 AliTPCclusterer.cxx:969
 AliTPCclusterer.cxx:970
 AliTPCclusterer.cxx:971
 AliTPCclusterer.cxx:972
 AliTPCclusterer.cxx:973
 AliTPCclusterer.cxx:974
 AliTPCclusterer.cxx:975
 AliTPCclusterer.cxx:976
 AliTPCclusterer.cxx:977
 AliTPCclusterer.cxx:978
 AliTPCclusterer.cxx:979
 AliTPCclusterer.cxx:980
 AliTPCclusterer.cxx:981
 AliTPCclusterer.cxx:982
 AliTPCclusterer.cxx:983
 AliTPCclusterer.cxx:984
 AliTPCclusterer.cxx:985
 AliTPCclusterer.cxx:986
 AliTPCclusterer.cxx:987
 AliTPCclusterer.cxx:988
 AliTPCclusterer.cxx:989
 AliTPCclusterer.cxx:990
 AliTPCclusterer.cxx:991
 AliTPCclusterer.cxx:992
 AliTPCclusterer.cxx:993
 AliTPCclusterer.cxx:994
 AliTPCclusterer.cxx:995
 AliTPCclusterer.cxx:996
 AliTPCclusterer.cxx:997
 AliTPCclusterer.cxx:998
 AliTPCclusterer.cxx:999
 AliTPCclusterer.cxx:1000
 AliTPCclusterer.cxx:1001
 AliTPCclusterer.cxx:1002
 AliTPCclusterer.cxx:1003
 AliTPCclusterer.cxx:1004
 AliTPCclusterer.cxx:1005
 AliTPCclusterer.cxx:1006
 AliTPCclusterer.cxx:1007
 AliTPCclusterer.cxx:1008
 AliTPCclusterer.cxx:1009
 AliTPCclusterer.cxx:1010
 AliTPCclusterer.cxx:1011
 AliTPCclusterer.cxx:1012
 AliTPCclusterer.cxx:1013
 AliTPCclusterer.cxx:1014
 AliTPCclusterer.cxx:1015
 AliTPCclusterer.cxx:1016
 AliTPCclusterer.cxx:1017
 AliTPCclusterer.cxx:1018
 AliTPCclusterer.cxx:1019
 AliTPCclusterer.cxx:1020
 AliTPCclusterer.cxx:1021
 AliTPCclusterer.cxx:1022
 AliTPCclusterer.cxx:1023
 AliTPCclusterer.cxx:1024
 AliTPCclusterer.cxx:1025
 AliTPCclusterer.cxx:1026
 AliTPCclusterer.cxx:1027
 AliTPCclusterer.cxx:1028
 AliTPCclusterer.cxx:1029
 AliTPCclusterer.cxx:1030
 AliTPCclusterer.cxx:1031
 AliTPCclusterer.cxx:1032
 AliTPCclusterer.cxx:1033
 AliTPCclusterer.cxx:1034
 AliTPCclusterer.cxx:1035
 AliTPCclusterer.cxx:1036
 AliTPCclusterer.cxx:1037
 AliTPCclusterer.cxx:1038
 AliTPCclusterer.cxx:1039
 AliTPCclusterer.cxx:1040
 AliTPCclusterer.cxx:1041
 AliTPCclusterer.cxx:1042
 AliTPCclusterer.cxx:1043
 AliTPCclusterer.cxx:1044
 AliTPCclusterer.cxx:1045
 AliTPCclusterer.cxx:1046
 AliTPCclusterer.cxx:1047
 AliTPCclusterer.cxx:1048
 AliTPCclusterer.cxx:1049
 AliTPCclusterer.cxx:1050
 AliTPCclusterer.cxx:1051
 AliTPCclusterer.cxx:1052
 AliTPCclusterer.cxx:1053
 AliTPCclusterer.cxx:1054
 AliTPCclusterer.cxx:1055
 AliTPCclusterer.cxx:1056
 AliTPCclusterer.cxx:1057
 AliTPCclusterer.cxx:1058
 AliTPCclusterer.cxx:1059
 AliTPCclusterer.cxx:1060
 AliTPCclusterer.cxx:1061
 AliTPCclusterer.cxx:1062
 AliTPCclusterer.cxx:1063
 AliTPCclusterer.cxx:1064
 AliTPCclusterer.cxx:1065
 AliTPCclusterer.cxx:1066
 AliTPCclusterer.cxx:1067
 AliTPCclusterer.cxx:1068
 AliTPCclusterer.cxx:1069
 AliTPCclusterer.cxx:1070
 AliTPCclusterer.cxx:1071
 AliTPCclusterer.cxx:1072
 AliTPCclusterer.cxx:1073
 AliTPCclusterer.cxx:1074
 AliTPCclusterer.cxx:1075
 AliTPCclusterer.cxx:1076
 AliTPCclusterer.cxx:1077
 AliTPCclusterer.cxx:1078
 AliTPCclusterer.cxx:1079
 AliTPCclusterer.cxx:1080
 AliTPCclusterer.cxx:1081
 AliTPCclusterer.cxx:1082
 AliTPCclusterer.cxx:1083
 AliTPCclusterer.cxx:1084
 AliTPCclusterer.cxx:1085
 AliTPCclusterer.cxx:1086
 AliTPCclusterer.cxx:1087
 AliTPCclusterer.cxx:1088
 AliTPCclusterer.cxx:1089
 AliTPCclusterer.cxx:1090
 AliTPCclusterer.cxx:1091
 AliTPCclusterer.cxx:1092
 AliTPCclusterer.cxx:1093
 AliTPCclusterer.cxx:1094
 AliTPCclusterer.cxx:1095
 AliTPCclusterer.cxx:1096
 AliTPCclusterer.cxx:1097
 AliTPCclusterer.cxx:1098
 AliTPCclusterer.cxx:1099
 AliTPCclusterer.cxx:1100
 AliTPCclusterer.cxx:1101
 AliTPCclusterer.cxx:1102
 AliTPCclusterer.cxx:1103
 AliTPCclusterer.cxx:1104
 AliTPCclusterer.cxx:1105
 AliTPCclusterer.cxx:1106
 AliTPCclusterer.cxx:1107
 AliTPCclusterer.cxx:1108
 AliTPCclusterer.cxx:1109
 AliTPCclusterer.cxx:1110
 AliTPCclusterer.cxx:1111
 AliTPCclusterer.cxx:1112
 AliTPCclusterer.cxx:1113
 AliTPCclusterer.cxx:1114
 AliTPCclusterer.cxx:1115
 AliTPCclusterer.cxx:1116
 AliTPCclusterer.cxx:1117
 AliTPCclusterer.cxx:1118
 AliTPCclusterer.cxx:1119
 AliTPCclusterer.cxx:1120
 AliTPCclusterer.cxx:1121
 AliTPCclusterer.cxx:1122
 AliTPCclusterer.cxx:1123
 AliTPCclusterer.cxx:1124
 AliTPCclusterer.cxx:1125
 AliTPCclusterer.cxx:1126
 AliTPCclusterer.cxx:1127
 AliTPCclusterer.cxx:1128
 AliTPCclusterer.cxx:1129
 AliTPCclusterer.cxx:1130
 AliTPCclusterer.cxx:1131
 AliTPCclusterer.cxx:1132
 AliTPCclusterer.cxx:1133
 AliTPCclusterer.cxx:1134
 AliTPCclusterer.cxx:1135
 AliTPCclusterer.cxx:1136
 AliTPCclusterer.cxx:1137
 AliTPCclusterer.cxx:1138
 AliTPCclusterer.cxx:1139
 AliTPCclusterer.cxx:1140
 AliTPCclusterer.cxx:1141
 AliTPCclusterer.cxx:1142
 AliTPCclusterer.cxx:1143
 AliTPCclusterer.cxx:1144
 AliTPCclusterer.cxx:1145
 AliTPCclusterer.cxx:1146
 AliTPCclusterer.cxx:1147
 AliTPCclusterer.cxx:1148
 AliTPCclusterer.cxx:1149
 AliTPCclusterer.cxx:1150
 AliTPCclusterer.cxx:1151
 AliTPCclusterer.cxx:1152
 AliTPCclusterer.cxx:1153
 AliTPCclusterer.cxx:1154
 AliTPCclusterer.cxx:1155
 AliTPCclusterer.cxx:1156
 AliTPCclusterer.cxx:1157
 AliTPCclusterer.cxx:1158
 AliTPCclusterer.cxx:1159
 AliTPCclusterer.cxx:1160
 AliTPCclusterer.cxx:1161
 AliTPCclusterer.cxx:1162
 AliTPCclusterer.cxx:1163
 AliTPCclusterer.cxx:1164
 AliTPCclusterer.cxx:1165
 AliTPCclusterer.cxx:1166
 AliTPCclusterer.cxx:1167
 AliTPCclusterer.cxx:1168
 AliTPCclusterer.cxx:1169
 AliTPCclusterer.cxx:1170
 AliTPCclusterer.cxx:1171
 AliTPCclusterer.cxx:1172
 AliTPCclusterer.cxx:1173
 AliTPCclusterer.cxx:1174
 AliTPCclusterer.cxx:1175
 AliTPCclusterer.cxx:1176
 AliTPCclusterer.cxx:1177
 AliTPCclusterer.cxx:1178
 AliTPCclusterer.cxx:1179
 AliTPCclusterer.cxx:1180
 AliTPCclusterer.cxx:1181
 AliTPCclusterer.cxx:1182
 AliTPCclusterer.cxx:1183
 AliTPCclusterer.cxx:1184
 AliTPCclusterer.cxx:1185
 AliTPCclusterer.cxx:1186
 AliTPCclusterer.cxx:1187
 AliTPCclusterer.cxx:1188
 AliTPCclusterer.cxx:1189
 AliTPCclusterer.cxx:1190
 AliTPCclusterer.cxx:1191
 AliTPCclusterer.cxx:1192
 AliTPCclusterer.cxx:1193
 AliTPCclusterer.cxx:1194
 AliTPCclusterer.cxx:1195
 AliTPCclusterer.cxx:1196
 AliTPCclusterer.cxx:1197
 AliTPCclusterer.cxx:1198
 AliTPCclusterer.cxx:1199
 AliTPCclusterer.cxx:1200
 AliTPCclusterer.cxx:1201
 AliTPCclusterer.cxx:1202
 AliTPCclusterer.cxx:1203
 AliTPCclusterer.cxx:1204
 AliTPCclusterer.cxx:1205
 AliTPCclusterer.cxx:1206
 AliTPCclusterer.cxx:1207
 AliTPCclusterer.cxx:1208
 AliTPCclusterer.cxx:1209
 AliTPCclusterer.cxx:1210
 AliTPCclusterer.cxx:1211
 AliTPCclusterer.cxx:1212
 AliTPCclusterer.cxx:1213
 AliTPCclusterer.cxx:1214
 AliTPCclusterer.cxx:1215
 AliTPCclusterer.cxx:1216
 AliTPCclusterer.cxx:1217
 AliTPCclusterer.cxx:1218
 AliTPCclusterer.cxx:1219
 AliTPCclusterer.cxx:1220
 AliTPCclusterer.cxx:1221
 AliTPCclusterer.cxx:1222
 AliTPCclusterer.cxx:1223
 AliTPCclusterer.cxx:1224
 AliTPCclusterer.cxx:1225
 AliTPCclusterer.cxx:1226
 AliTPCclusterer.cxx:1227
 AliTPCclusterer.cxx:1228
 AliTPCclusterer.cxx:1229
 AliTPCclusterer.cxx:1230
 AliTPCclusterer.cxx:1231
 AliTPCclusterer.cxx:1232
 AliTPCclusterer.cxx:1233
 AliTPCclusterer.cxx:1234
 AliTPCclusterer.cxx:1235
 AliTPCclusterer.cxx:1236
 AliTPCclusterer.cxx:1237
 AliTPCclusterer.cxx:1238
 AliTPCclusterer.cxx:1239
 AliTPCclusterer.cxx:1240
 AliTPCclusterer.cxx:1241
 AliTPCclusterer.cxx:1242
 AliTPCclusterer.cxx:1243
 AliTPCclusterer.cxx:1244
 AliTPCclusterer.cxx:1245
 AliTPCclusterer.cxx:1246
 AliTPCclusterer.cxx:1247
 AliTPCclusterer.cxx:1248
 AliTPCclusterer.cxx:1249
 AliTPCclusterer.cxx:1250
 AliTPCclusterer.cxx:1251
 AliTPCclusterer.cxx:1252
 AliTPCclusterer.cxx:1253
 AliTPCclusterer.cxx:1254
 AliTPCclusterer.cxx:1255
 AliTPCclusterer.cxx:1256
 AliTPCclusterer.cxx:1257
 AliTPCclusterer.cxx:1258
 AliTPCclusterer.cxx:1259
 AliTPCclusterer.cxx:1260
 AliTPCclusterer.cxx:1261
 AliTPCclusterer.cxx:1262
 AliTPCclusterer.cxx:1263
 AliTPCclusterer.cxx:1264
 AliTPCclusterer.cxx:1265
 AliTPCclusterer.cxx:1266
 AliTPCclusterer.cxx:1267
 AliTPCclusterer.cxx:1268
 AliTPCclusterer.cxx:1269
 AliTPCclusterer.cxx:1270
 AliTPCclusterer.cxx:1271
 AliTPCclusterer.cxx:1272
 AliTPCclusterer.cxx:1273
 AliTPCclusterer.cxx:1274
 AliTPCclusterer.cxx:1275
 AliTPCclusterer.cxx:1276
 AliTPCclusterer.cxx:1277
 AliTPCclusterer.cxx:1278
 AliTPCclusterer.cxx:1279
 AliTPCclusterer.cxx:1280
 AliTPCclusterer.cxx:1281
 AliTPCclusterer.cxx:1282
 AliTPCclusterer.cxx:1283
 AliTPCclusterer.cxx:1284
 AliTPCclusterer.cxx:1285
 AliTPCclusterer.cxx:1286
 AliTPCclusterer.cxx:1287
 AliTPCclusterer.cxx:1288
 AliTPCclusterer.cxx:1289
 AliTPCclusterer.cxx:1290
 AliTPCclusterer.cxx:1291
 AliTPCclusterer.cxx:1292
 AliTPCclusterer.cxx:1293
 AliTPCclusterer.cxx:1294
 AliTPCclusterer.cxx:1295
 AliTPCclusterer.cxx:1296
 AliTPCclusterer.cxx:1297
 AliTPCclusterer.cxx:1298
 AliTPCclusterer.cxx:1299
 AliTPCclusterer.cxx:1300
 AliTPCclusterer.cxx:1301
 AliTPCclusterer.cxx:1302
 AliTPCclusterer.cxx:1303
 AliTPCclusterer.cxx:1304
 AliTPCclusterer.cxx:1305
 AliTPCclusterer.cxx:1306
 AliTPCclusterer.cxx:1307
 AliTPCclusterer.cxx:1308
 AliTPCclusterer.cxx:1309
 AliTPCclusterer.cxx:1310
 AliTPCclusterer.cxx:1311
 AliTPCclusterer.cxx:1312
 AliTPCclusterer.cxx:1313
 AliTPCclusterer.cxx:1314
 AliTPCclusterer.cxx:1315
 AliTPCclusterer.cxx:1316
 AliTPCclusterer.cxx:1317
 AliTPCclusterer.cxx:1318
 AliTPCclusterer.cxx:1319
 AliTPCclusterer.cxx:1320
 AliTPCclusterer.cxx:1321
 AliTPCclusterer.cxx:1322
 AliTPCclusterer.cxx:1323
 AliTPCclusterer.cxx:1324
 AliTPCclusterer.cxx:1325
 AliTPCclusterer.cxx:1326
 AliTPCclusterer.cxx:1327
 AliTPCclusterer.cxx:1328
 AliTPCclusterer.cxx:1329
 AliTPCclusterer.cxx:1330
 AliTPCclusterer.cxx:1331
 AliTPCclusterer.cxx:1332
 AliTPCclusterer.cxx:1333
 AliTPCclusterer.cxx:1334
 AliTPCclusterer.cxx:1335
 AliTPCclusterer.cxx:1336
 AliTPCclusterer.cxx:1337
 AliTPCclusterer.cxx:1338
 AliTPCclusterer.cxx:1339
 AliTPCclusterer.cxx:1340
 AliTPCclusterer.cxx:1341
 AliTPCclusterer.cxx:1342
 AliTPCclusterer.cxx:1343
 AliTPCclusterer.cxx:1344
 AliTPCclusterer.cxx:1345
 AliTPCclusterer.cxx:1346
 AliTPCclusterer.cxx:1347
 AliTPCclusterer.cxx:1348
 AliTPCclusterer.cxx:1349
 AliTPCclusterer.cxx:1350
 AliTPCclusterer.cxx:1351
 AliTPCclusterer.cxx:1352
 AliTPCclusterer.cxx:1353
 AliTPCclusterer.cxx:1354
 AliTPCclusterer.cxx:1355
 AliTPCclusterer.cxx:1356
 AliTPCclusterer.cxx:1357
 AliTPCclusterer.cxx:1358
 AliTPCclusterer.cxx:1359
 AliTPCclusterer.cxx:1360
 AliTPCclusterer.cxx:1361
 AliTPCclusterer.cxx:1362
 AliTPCclusterer.cxx:1363
 AliTPCclusterer.cxx:1364
 AliTPCclusterer.cxx:1365
 AliTPCclusterer.cxx:1366
 AliTPCclusterer.cxx:1367
 AliTPCclusterer.cxx:1368
 AliTPCclusterer.cxx:1369
 AliTPCclusterer.cxx:1370
 AliTPCclusterer.cxx:1371
 AliTPCclusterer.cxx:1372
 AliTPCclusterer.cxx:1373
 AliTPCclusterer.cxx:1374
 AliTPCclusterer.cxx:1375
 AliTPCclusterer.cxx:1376
 AliTPCclusterer.cxx:1377
 AliTPCclusterer.cxx:1378
 AliTPCclusterer.cxx:1379
 AliTPCclusterer.cxx:1380
 AliTPCclusterer.cxx:1381
 AliTPCclusterer.cxx:1382
 AliTPCclusterer.cxx:1383
 AliTPCclusterer.cxx:1384
 AliTPCclusterer.cxx:1385
 AliTPCclusterer.cxx:1386
 AliTPCclusterer.cxx:1387
 AliTPCclusterer.cxx:1388
 AliTPCclusterer.cxx:1389
 AliTPCclusterer.cxx:1390
 AliTPCclusterer.cxx:1391
 AliTPCclusterer.cxx:1392
 AliTPCclusterer.cxx:1393
 AliTPCclusterer.cxx:1394
 AliTPCclusterer.cxx:1395
 AliTPCclusterer.cxx:1396
 AliTPCclusterer.cxx:1397
 AliTPCclusterer.cxx:1398
 AliTPCclusterer.cxx:1399
 AliTPCclusterer.cxx:1400
 AliTPCclusterer.cxx:1401
 AliTPCclusterer.cxx:1402
 AliTPCclusterer.cxx:1403
 AliTPCclusterer.cxx:1404
 AliTPCclusterer.cxx:1405
 AliTPCclusterer.cxx:1406
 AliTPCclusterer.cxx:1407
 AliTPCclusterer.cxx:1408
 AliTPCclusterer.cxx:1409
 AliTPCclusterer.cxx:1410
 AliTPCclusterer.cxx:1411
 AliTPCclusterer.cxx:1412
 AliTPCclusterer.cxx:1413
 AliTPCclusterer.cxx:1414
 AliTPCclusterer.cxx:1415
 AliTPCclusterer.cxx:1416
 AliTPCclusterer.cxx:1417
 AliTPCclusterer.cxx:1418
 AliTPCclusterer.cxx:1419
 AliTPCclusterer.cxx:1420
 AliTPCclusterer.cxx:1421
 AliTPCclusterer.cxx:1422
 AliTPCclusterer.cxx:1423
 AliTPCclusterer.cxx:1424
 AliTPCclusterer.cxx:1425
 AliTPCclusterer.cxx:1426
 AliTPCclusterer.cxx:1427
 AliTPCclusterer.cxx:1428
 AliTPCclusterer.cxx:1429
 AliTPCclusterer.cxx:1430
 AliTPCclusterer.cxx:1431
 AliTPCclusterer.cxx:1432
 AliTPCclusterer.cxx:1433
 AliTPCclusterer.cxx:1434
 AliTPCclusterer.cxx:1435
 AliTPCclusterer.cxx:1436
 AliTPCclusterer.cxx:1437
 AliTPCclusterer.cxx:1438
 AliTPCclusterer.cxx:1439
 AliTPCclusterer.cxx:1440
 AliTPCclusterer.cxx:1441
 AliTPCclusterer.cxx:1442
 AliTPCclusterer.cxx:1443
 AliTPCclusterer.cxx:1444
 AliTPCclusterer.cxx:1445
 AliTPCclusterer.cxx:1446
 AliTPCclusterer.cxx:1447
 AliTPCclusterer.cxx:1448
 AliTPCclusterer.cxx:1449
 AliTPCclusterer.cxx:1450
 AliTPCclusterer.cxx:1451
 AliTPCclusterer.cxx:1452
 AliTPCclusterer.cxx:1453
 AliTPCclusterer.cxx:1454
 AliTPCclusterer.cxx:1455
 AliTPCclusterer.cxx:1456
 AliTPCclusterer.cxx:1457
 AliTPCclusterer.cxx:1458
 AliTPCclusterer.cxx:1459
 AliTPCclusterer.cxx:1460
 AliTPCclusterer.cxx:1461
 AliTPCclusterer.cxx:1462
 AliTPCclusterer.cxx:1463
 AliTPCclusterer.cxx:1464
 AliTPCclusterer.cxx:1465
 AliTPCclusterer.cxx:1466
 AliTPCclusterer.cxx:1467
 AliTPCclusterer.cxx:1468
 AliTPCclusterer.cxx:1469
 AliTPCclusterer.cxx:1470
 AliTPCclusterer.cxx:1471
 AliTPCclusterer.cxx:1472
 AliTPCclusterer.cxx:1473
 AliTPCclusterer.cxx:1474
 AliTPCclusterer.cxx:1475
 AliTPCclusterer.cxx:1476
 AliTPCclusterer.cxx:1477
 AliTPCclusterer.cxx:1478
 AliTPCclusterer.cxx:1479
 AliTPCclusterer.cxx:1480
 AliTPCclusterer.cxx:1481
 AliTPCclusterer.cxx:1482
 AliTPCclusterer.cxx:1483
 AliTPCclusterer.cxx:1484
 AliTPCclusterer.cxx:1485
 AliTPCclusterer.cxx:1486
 AliTPCclusterer.cxx:1487
 AliTPCclusterer.cxx:1488
 AliTPCclusterer.cxx:1489
 AliTPCclusterer.cxx:1490
 AliTPCclusterer.cxx:1491
 AliTPCclusterer.cxx:1492
 AliTPCclusterer.cxx:1493
 AliTPCclusterer.cxx:1494
 AliTPCclusterer.cxx:1495
 AliTPCclusterer.cxx:1496
 AliTPCclusterer.cxx:1497
 AliTPCclusterer.cxx:1498
 AliTPCclusterer.cxx:1499
 AliTPCclusterer.cxx:1500
 AliTPCclusterer.cxx:1501
 AliTPCclusterer.cxx:1502
 AliTPCclusterer.cxx:1503
 AliTPCclusterer.cxx:1504
 AliTPCclusterer.cxx:1505
 AliTPCclusterer.cxx:1506
 AliTPCclusterer.cxx:1507
 AliTPCclusterer.cxx:1508
 AliTPCclusterer.cxx:1509
 AliTPCclusterer.cxx:1510
 AliTPCclusterer.cxx:1511
 AliTPCclusterer.cxx:1512
 AliTPCclusterer.cxx:1513
 AliTPCclusterer.cxx:1514
 AliTPCclusterer.cxx:1515
 AliTPCclusterer.cxx:1516
 AliTPCclusterer.cxx:1517
 AliTPCclusterer.cxx:1518
 AliTPCclusterer.cxx:1519
 AliTPCclusterer.cxx:1520
 AliTPCclusterer.cxx:1521
 AliTPCclusterer.cxx:1522
 AliTPCclusterer.cxx:1523
 AliTPCclusterer.cxx:1524
 AliTPCclusterer.cxx:1525
 AliTPCclusterer.cxx:1526
 AliTPCclusterer.cxx:1527
 AliTPCclusterer.cxx:1528
 AliTPCclusterer.cxx:1529
 AliTPCclusterer.cxx:1530
 AliTPCclusterer.cxx:1531
 AliTPCclusterer.cxx:1532
 AliTPCclusterer.cxx:1533
 AliTPCclusterer.cxx:1534
 AliTPCclusterer.cxx:1535
 AliTPCclusterer.cxx:1536
 AliTPCclusterer.cxx:1537
 AliTPCclusterer.cxx:1538
 AliTPCclusterer.cxx:1539
 AliTPCclusterer.cxx:1540
 AliTPCclusterer.cxx:1541
 AliTPCclusterer.cxx:1542
 AliTPCclusterer.cxx:1543
 AliTPCclusterer.cxx:1544