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

/* History of cvs commits:
 *
 * $Log: AliPHOSClusterizerv1.cxx,v $
 * Revision 1.118  2007/12/11 21:23:26  kharlov
 * Added possibility to swith off unfolding
 *
 * Revision 1.117  2007/10/18 08:42:05  kharlov
 * Bad channels cleaned before clusterization
 *
 * Revision 1.116  2007/10/01 20:24:08  kharlov
 * Memory leaks fixed
 *
 * Revision 1.115  2007/09/26 14:22:17  cvetan
 * Important changes to the reconstructor classes. Complete elimination of the run-loaders, which are now steered only from AliReconstruction. Removal of the corresponding Reconstruct() and FillESD() methods.
 *
 * Revision 1.114  2007/09/06 16:06:44  kharlov
 * Absence of sorting results in loose of all unfolded clusters
 *
 * Revision 1.113  2007/08/28 12:55:07  policheh
 * Loaders removed from the reconstruction code (C.Cheshkov)
 *
 * Revision 1.112  2007/08/22 09:20:50  hristov
 * Updated QA classes (Yves)
 *
 * Revision 1.111  2007/08/08 12:11:28  kharlov
 * Protection against uninitialized fQADM
 *
 * Revision 1.110  2007/08/07 14:16:00  kharlov
 * Quality assurance added (Yves Schutz)
 *
 * Revision 1.109  2007/07/24 17:20:35  policheh
 * Usage of RecoParam objects instead of hardcoded parameters in reconstruction.
 * (See $ALICE_ROOT/PHOS/macros/BeamTest2006/RawReconstruction.C).
 *
 * Revision 1.108  2007/06/18 07:00:51  kharlov
 * Bug fix for attempt to use AliPHOSEmcRecPoint after its deletion
 *
 * Revision 1.107  2007/05/25 14:12:26  policheh
 * Local to tracking CS transformation added for CPV rec. points
 *
 * Revision 1.106  2007/05/24 13:01:22  policheh
 * Local to tracking CS transformation invoked for each EMC rec.point
 *
 * Revision 1.105  2007/05/02 13:41:22  kharlov
 * Mode protection against absence of calib.data from AliPHOSCalibData to AliPHOSClusterizerv1::GetCalibrationParameters()
 *
 * Revision 1.104  2007/04/27 16:55:53  kharlov
 * Calibration stops if PHOS CDB objects do not exist
 *
 * Revision 1.103  2007/04/11 11:55:45  policheh
 * SetDistancesToBadChannels() added.
 *
 * Revision 1.102  2007/03/28 19:18:15  kharlov
 * RecPoints recalculation in TSM removed
 *
 * Revision 1.101  2007/03/06 06:51:27  kharlov
 * Calculation of cluster properties dep. on vertex posponed to TrackSegmentMaker
 *
 * Revision 1.100  2007/01/10 11:07:26  kharlov
 * Raw digits writing to file (B.Polichtchouk)
 *
 * Revision 1.99  2006/11/07 16:49:51  kharlov
 * Corrections for next event switch in case of raw data (B.Polichtchouk)
 *
 * Revision 1.98  2006/10/27 17:14:27  kharlov
 * Introduce AliDebug and AliLog (B.Polichtchouk)
 *
 * Revision 1.97  2006/08/29 11:41:19  kharlov
 * Missing implementation of ctors and = operator are added
 *
 * Revision 1.96  2006/08/25 16:56:30  kharlov
 * Compliance with Effective C++
 *
 * Revision 1.95  2006/08/11 12:36:26  cvetan
 * Update of the PHOS code needed in order to read and reconstruct the beam test raw data (i.e. without an existing galice.root)
 *
 * Revision 1.94  2006/08/07 12:27:49  hristov
 * Removing obsolete code which affected the event numbering scheme
 *
 * Revision 1.93  2006/08/01 12:20:17  cvetan
 * 1. Adding a possibility to read and reconstruct an old rcu formatted raw data. This is controlled by an option of AliReconstruction and AliPHOSReconstructor. 2. In case of raw data processing (without galice.root) create the default AliPHOSGeometry object. Most likely this should be moved to the CDB
 *
 * Revision 1.92  2006/04/29 20:26:46  hristov
 * Separate EMC and CPV calibration (Yu.Kharlov)
 *
 * Revision 1.91  2006/04/22 10:30:17  hristov
 * Add fEnergy to AliPHOSDigit and operate with EMC amplitude in energy units (Yu.Kharlov)
 *
 * Revision 1.90  2006/04/11 15:22:59  hristov
 * run number in query set to -1: forces AliCDBManager to use its run number (A.Colla)
 *
 * Revision 1.89  2006/03/13 14:05:42  kharlov
 * Calibration objects for EMC and CPV
 *
 * Revision 1.88  2006/01/11 08:54:52  hristov
 * Additional protection in case no calibration entry was found
 *
 * Revision 1.87  2005/11/22 08:46:43  kharlov
 * Updated to new CDB (Boris Polichtchouk)
 *
 * Revision 1.86  2005/11/14 21:52:43  hristov
 * Coding conventions
 *
 * Revision 1.85  2005/09/27 16:08:08  hristov
 * New version of CDB storage framework (A.Colla)
 *
 * Revision 1.84  2005/09/21 10:02:47  kharlov
 * Reading calibration from CDB (Boris Polichtchouk)
 *
 * Revision 1.82  2005/09/02 15:43:13  kharlov
 * Add comments in GetCalibrationParameters and Calibrate
 *
 * Revision 1.81  2005/09/02 14:32:07  kharlov
 * Calibration of raw data
 *
 * Revision 1.80  2005/08/24 15:31:36  kharlov
 * Setting raw digits flag
 *
 * Revision 1.79  2005/07/25 15:53:53  kharlov
 * Read raw data
 *
 * Revision 1.78  2005/05/28 14:19:04  schutz
 * Compilation warnings fixed by T.P.
 *
 */

//*-- Author: Yves Schutz (SUBATECH)  & Dmitri Peressounko (SUBATECH & Kurchatov Institute)
//////////////////////////////////////////////////////////////////////////////
//  Clusterization class. Performs clusterization (collects neighbouring active cells) and 
//  unfolds the clusters having several local maxima.  
//  Results are stored in TreeR#, branches PHOSEmcRP (EMC recPoints),
//  PHOSCpvRP (CPV RecPoints) and AliPHOSClusterizer (Clusterizer with all 
//  parameters including input digits branch title, thresholds etc.)
//  This TTask is normally called from Reconstructioner, but can as well be used in 
//  standalone mode.
// Use Case:
//  root [0] AliPHOSClusterizerv1 * cl = new AliPHOSClusterizerv1(<pointer_to_phos_geometry_onject>)  
//  root [1] cl->Digits2Clusters(digitsTree,clusterTree)
//               //finds RecPoints in the current event
//  root [2] cl->SetDigitsBranch("digits2") 
//               //sets another title for Digitis (input) branch
//  root [3] cl->SetRecPointsBranch("recp2")  
//               //sets another title four output branches
//  root [4] cl->SetEmcLocalMaxCut(0.03)  
//               //set clusterization parameters

// --- ROOT system ---

#include "TMath.h" 
#include "TMinuit.h"
#include "TTree.h" 
#include "TBenchmark.h"
#include "TClonesArray.h"

// --- Standard library ---

// --- AliRoot header files ---
#include "AliLog.h"
#include "AliConfig.h"
#include "AliPHOSGeometry.h" 
#include "AliPHOSClusterizerv1.h"
#include "AliPHOSEmcRecPoint.h"
#include "AliPHOSCpvRecPoint.h"
#include "AliPHOSDigit.h"
#include "AliPHOSDigitizer.h"
#include "AliCDBManager.h"
#include "AliCDBStorage.h"
#include "AliCDBEntry.h"
#include "AliPHOSRecoParam.h"
#include "AliPHOSReconstructor.h"
#include "AliPHOSCalibData.h"

ClassImp(AliPHOSClusterizerv1)
  
//____________________________________________________________________________
AliPHOSClusterizerv1::AliPHOSClusterizerv1() :
  AliPHOSClusterizer(),
  fDefaultInit(0),            fEmcCrystals(0),          fToUnfold(0),
  fWrite(0),                  
  fNumberOfEmcClusters(0),    fNumberOfCpvClusters(0),
  fEmcClusteringThreshold(0), fCpvClusteringThreshold(0), 
  fEmcLocMaxCut(0),           fW0(0),                   fCpvLocMaxCut(0),
  fW0CPV(0),                 
  fTimeGateLowAmp(0.),        fTimeGateLow(0.),         fTimeGateHigh(0.),  
  fEcoreRadius(0)
{
  // default ctor (to be used mainly by Streamer)
  
  fDefaultInit = kTRUE ;
  
  for(Int_t i=0; i<53760; i++){
    fDigitsUsed[i]=0 ;
  }
}

//____________________________________________________________________________
AliPHOSClusterizerv1::AliPHOSClusterizerv1(AliPHOSGeometry *geom) :
  AliPHOSClusterizer(geom),
  fDefaultInit(0),            fEmcCrystals(0),          fToUnfold(0),
  fWrite(0),                
  fNumberOfEmcClusters(0),    fNumberOfCpvClusters(0),
  fEmcClusteringThreshold(0), fCpvClusteringThreshold(0), 
  fEmcLocMaxCut(0),           fW0(0),                   fCpvLocMaxCut(0),
  fW0CPV(0),                  
  fTimeGateLowAmp(0.),        fTimeGateLow(0.),         fTimeGateHigh(0.),  
  fEcoreRadius(0) 
{
  // ctor with the indication of the file where header Tree and digits Tree are stored
  
  for(Int_t i=0; i<53760; i++){
    fDigitsUsed[i]=0 ;
  }
  
  Init() ;
  fDefaultInit = kFALSE ; 
}

//____________________________________________________________________________
  AliPHOSClusterizerv1::~AliPHOSClusterizerv1()
{
  // dtor

}
//____________________________________________________________________________
void AliPHOSClusterizerv1::Digits2Clusters(Option_t *option)
{
  // Steering method to perform clusterization for one event
  // The input is the tree with digits.
  // The output is the tree with clusters.

  if(strstr(option,"tim"))
    gBenchmark->Start("PHOSClusterizer"); 
  
  if(strstr(option,"print")) {
    Print() ; 
    return ;
  }

  MakeClusters() ;
    
  AliDebug(2,Form(" ---- Printing clusters (%d)\n",
		  fEMCRecPoints->GetEntries()));
  if(AliLog::GetGlobalDebugLevel()>1)
    fEMCRecPoints->Print();

  if(fToUnfold)             
    MakeUnfolding();

  WriteRecPoints();

  if(strstr(option,"deb"))  
    PrintRecPoints(option) ;

  if(strstr(option,"tim")){
    gBenchmark->Stop("PHOSClusterizer");
    AliInfo(Form("took %f seconds for Clusterizing\n",
		 gBenchmark->GetCpuTime("PHOSClusterizer"))); 
  }
  fEMCRecPoints->Delete();
  fCPVRecPoints->Delete();
}

//____________________________________________________________________________
Bool_t AliPHOSClusterizerv1::FindFit(AliPHOSEmcRecPoint * emcRP, AliPHOSDigit ** maxAt, Float_t * maxAtEnergy,
				    Int_t nPar, Float_t * fitparameters) const
{ 
  // Calls TMinuit to fit the energy distribution of a cluster with several maxima 
  // The initial values for fitting procedure are set equal to the positions of local maxima.
  // Cluster will be fitted as a superposition of nPar/3 electromagnetic showers

  
  if(!gMinuit) //it was deleted by someone else
    gMinuit = new TMinuit(100) ;
  gMinuit->mncler();                     // Reset Minuit's list of paramters
  gMinuit->SetPrintLevel(-1) ;           // No Printout
  gMinuit->SetFCN(AliPHOSClusterizerv1::UnfoldingChiSquare) ;  
                                         // To set the address of the minimization function 

  TList * toMinuit = new TList();
  toMinuit->AddAt(emcRP,0) ;
  toMinuit->AddAt(fDigitsArr,1) ;
  toMinuit->AddAt(fGeom,2) ;
  
  gMinuit->SetObjectFit(toMinuit) ;         // To tranfer pointer to UnfoldingChiSquare

  // filling initial values for fit parameters
  AliPHOSDigit * digit ;

  Int_t ierflg  = 0; 
  Int_t index   = 0 ;
  Int_t nDigits = (Int_t) nPar / 3 ;

  Int_t iDigit ;

  for(iDigit = 0; iDigit < nDigits; iDigit++){
    digit = maxAt[iDigit]; 

    Int_t relid[4] ;
    Float_t x = 0.;
    Float_t z = 0.;
    fGeom->AbsToRelNumbering(digit->GetId(), relid) ;
    fGeom->RelPosInModule(relid, x, z) ;

    Float_t energy = maxAtEnergy[iDigit] ;

    gMinuit->mnparm(index, "x",  x, 0.1, 0, 0, ierflg) ;
    index++ ;   
    if(ierflg != 0){ 
      Warning("FindFit", "PHOS Unfolding unable to set initial value for fit procedure : x = %f\n", x ) ;
      return kFALSE;
    }
    gMinuit->mnparm(index, "z",  z, 0.1, 0, 0, ierflg) ;
    index++ ;   
    if(ierflg != 0){
       Warning("FindFit", "PHOS Unfolding unable to set initial value for fit procedure : z =%f\n", z ) ;
      return kFALSE;
    }
    gMinuit->mnparm(index, "Energy",  energy , 0.05*energy, 0., 4.*energy, ierflg) ;
    index++ ;   
    if(ierflg != 0){
      Warning("FindFit", "PHOS Unfolding unable to set initial value for fit procedure : energy = %f\n", energy ) ;      
      return kFALSE;
    }
  }

  Double_t p0 = 0.1 ; // "Tolerance" Evaluation stops when EDM = 0.0001*p0 ; The number of function call slightly
                      //  depends on it. 
  Double_t p1 = 1.0 ;
  Double_t p2 = 0.0 ;

  gMinuit->mnexcm("SET STR", &p2, 0, ierflg) ;   // force TMinuit to reduce function calls  
  gMinuit->mnexcm("SET GRA", &p1, 1, ierflg) ;   // force TMinuit to use my gradient  
  gMinuit->SetMaxIterations(5);
  gMinuit->mnexcm("SET NOW", &p2 , 0, ierflg) ;  // No Warnings

  gMinuit->mnexcm("MIGRAD", &p0, 0, ierflg) ;    // minimize 

  if(ierflg == 4){  // Minimum not found   
    Warning("FindFit", "PHOS Unfolding fit not converged, cluster abandoned\n" );      
    return kFALSE ;
  }            
  for(index = 0; index < nPar; index++){
    Double_t err ;
    Double_t val ;
    gMinuit->GetParameter(index, val, err) ;    // Returns value and error of parameter index
    fitparameters[index] = val ;
   }

  delete toMinuit ;
  return kTRUE;

}


//____________________________________________________________________________
void AliPHOSClusterizerv1::Init()
{
  // Make all memory allocations which can not be done in default constructor.
  // Attach the Clusterizer task to the list of PHOS tasks
 
  fEmcCrystals = fGeom->GetNModules() *  fGeom->GetNCristalsInModule() ;

  if(!gMinuit) 
    gMinuit = new TMinuit(100);

  if (!fgCalibData) 
    fgCalibData = new AliPHOSCalibData(-1); //use AliCDBManager's run number
  if (fgCalibData->GetCalibDataEmc() == 0)
    AliFatal("Calibration parameters for PHOS EMC not found. Stop reconstruction.\n");
  if (fgCalibData->GetCalibDataCpv() == 0)   
    AliFatal("Calibration parameters for PHOS CPV not found. Stop reconstruction.\n");   

}

//____________________________________________________________________________
void AliPHOSClusterizerv1::InitParameters()
{

  fNumberOfCpvClusters     = 0 ; 
  fNumberOfEmcClusters     = 0 ; 

  const AliPHOSRecoParam* recoParam = AliPHOSReconstructor::GetRecoParam();
  if(!recoParam) AliFatal("Reconstruction parameters are not set!");

  recoParam->Print();

  fEmcClusteringThreshold  = recoParam->GetEMCClusteringThreshold();
  fCpvClusteringThreshold  = recoParam->GetCPVClusteringThreshold();
  
  fEmcLocMaxCut            = recoParam->GetEMCLocalMaxCut();
  fCpvLocMaxCut            = recoParam->GetCPVLocalMaxCut();

  fW0                      = recoParam->GetEMCLogWeight();
  fW0CPV                   = recoParam->GetCPVLogWeight();

  fTimeGateLowAmp          = recoParam->GetTimeGateAmpThresh() ;
  fTimeGateLow             = recoParam->GetTimeGateLow() ;
  fTimeGateHigh            = recoParam->GetTimeGateHigh() ;

  fEcoreRadius             = recoParam->GetEMCEcoreRadius();
  
  fToUnfold                = recoParam->EMCToUnfold() ;
    
  fWrite                   = kTRUE ;
}

//____________________________________________________________________________
Int_t AliPHOSClusterizerv1::AreNeighbours(AliPHOSDigit * d1, AliPHOSDigit * d2)const
{
  // Gives the neighbourness of two digits = 0 are not neighbour but continue searching 
  //                                       = 1 are neighbour
  //                                       = 2 are not neighbour but do not continue searching
  //                                       =-1 are not neighbour, continue searching, but do not look before d2 next time
  // neighbours are defined as digits having at least a common vertex 
  // The order of d1 and d2 is important: first (d1) should be a digit already in a cluster 
  //                                      which is compared to a digit (d2)  not yet in a cluster  

  Int_t relid1[4] ; 
  fGeom->AbsToRelNumbering(d1->GetId(), relid1) ; 

  Int_t relid2[4] ; 
  fGeom->AbsToRelNumbering(d2->GetId(), relid2) ; 
 
  if ( (relid1[0] == relid2[0]) && (relid1[1]==relid2[1]) ) { // inside the same PHOS module 
    Int_t rowdiff = TMath::Abs( relid1[2] - relid2[2] ) ;  
    Int_t coldiff = TMath::Abs( relid1[3] - relid2[3] ) ;  
    
    if (( coldiff <= 1 )  && ( rowdiff <= 1 )){   //At least common vertex
      //    if (( relid1[2]==relid2[2] && coldiff <= 1 )  || ( relid1[3]==relid2[3] &&  rowdiff <= 1 )){ //common side
      if((relid1[1] != 0) || CheckTimeGate(d1->GetTime(),d1->GetEnergy(),d2->GetTime(),d2->GetEnergy())) 
      return 1 ; 
    }
    else {
      if((relid2[2] > relid1[2]) && (relid2[3] > relid1[3]+1)) 
        return 2; //  Difference in row numbers is too large to look further 
    }
    return 0 ;

  } 
  else {
    if(relid1[0] > relid2[0] && relid1[1]==relid2[1] ) //we switched to the next module
      return -1 ;
    if(relid1[1] < relid2[1]) //we switched from EMC(0) to CPV(-1)
      return -1 ;
    
    return 2 ;

  }

  return 0 ; 
}
//____________________________________________________________________________
Bool_t AliPHOSClusterizerv1::CheckTimeGate(Float_t t1, Float_t amp1, Float_t t2, Float_t amp2)const{
  //Check if two cells have reasonable time difference
  //Note that at low amplitude time is defined up to 1 tick == 100 ns.
  if(amp1<fTimeGateLowAmp || amp2<fTimeGateLowAmp){
   return (TMath::Abs(t1 - t2 ) < fTimeGateLow) ;
  }
  else{ //Time should be measured with good accuracy
   return (TMath::Abs(t1 - t2 ) < fTimeGateHigh) ;
  }

}
//____________________________________________________________________________
Bool_t AliPHOSClusterizerv1::IsInEmc(AliPHOSDigit * digit) const
{
  // Tells if (true) or not (false) the digit is in a PHOS-EMC module
 
  Bool_t rv = kFALSE ; 

  Int_t nEMC = fGeom->GetNModules()*fGeom->GetNPhi()*fGeom->GetNZ();  

  if(digit->GetId() <= nEMC )   rv = kTRUE; 

  return rv ; 
}

//____________________________________________________________________________
Bool_t AliPHOSClusterizerv1::IsInCpv(AliPHOSDigit * digit) const
{
  // Tells if (true) or not (false) the digit is in a PHOS-CPV module
 
  Bool_t rv = kFALSE ; 
  
  Int_t nEMC = fGeom->GetNModules()*fGeom->GetNPhi()*fGeom->GetNZ();

  if(digit->GetId() > nEMC )   rv = kTRUE;

  return rv ; 
}

//____________________________________________________________________________
void AliPHOSClusterizerv1::WriteRecPoints()
{

  // Creates new branches with given title
  // fills and writes into TreeR.

  Int_t index ;
  //Evaluate position, dispersion and other RecPoint properties..
  Int_t nEmc = fEMCRecPoints->GetEntriesFast();
  Float_t emcMinE= AliPHOSReconstructor::GetRecoParam()->GetEMCMinE(); //Minimal digit energy
  TVector3 fakeVtx(0.,0.,0.) ;
  for(index = 0; index < nEmc; index++){
    AliPHOSEmcRecPoint * rp =
      static_cast<AliPHOSEmcRecPoint *>( fEMCRecPoints->At(index) );
    rp->Purify(emcMinE,fDigitsArr) ;
    if(rp->GetMultiplicity()==0){
      fEMCRecPoints->RemoveAt(index) ;
      delete rp ;
      continue;
    }

    // No vertex is available now, calculate corrections in PID
    rp->EvalAll(fDigitsArr) ;
    rp->EvalCoreEnergy(fW0,fEcoreRadius,fDigitsArr) ;
    rp->EvalAll(fW0,fakeVtx,fDigitsArr) ;
    rp->EvalLocal2TrackingCSTransform();
  }
  fEMCRecPoints->Compress() ;
  fEMCRecPoints->Sort() ; 
  //  fEMCRecPoints->Expand(fEMCRecPoints->GetEntriesFast()) ;
  for(index = 0; index < fEMCRecPoints->GetEntries(); index++){
    static_cast<AliPHOSEmcRecPoint *>( fEMCRecPoints->At(index) )->SetIndexInList(index) ;
  }
  
  //For each rec.point set the distance to the nearest bad crystal (BVP)
  SetDistancesToBadChannels();

  //Now the same for CPV
  for(index = 0; index < fCPVRecPoints->GetEntries(); index++){
    AliPHOSCpvRecPoint * rp = static_cast<AliPHOSCpvRecPoint *>( fCPVRecPoints->At(index) );
    rp->EvalAll(fDigitsArr) ;
    rp->EvalAll(fW0CPV,fakeVtx,fDigitsArr) ;
    rp->EvalLocal2TrackingCSTransform();
  }
  fCPVRecPoints->Sort() ;
  
  for(index = 0; index < fCPVRecPoints->GetEntries(); index++)
    static_cast<AliPHOSCpvRecPoint *>( fCPVRecPoints->At(index) )->SetIndexInList(index) ;
  
  fCPVRecPoints->Expand(fCPVRecPoints->GetEntriesFast()) ;
  
  if(fWrite){ //We write TreeR
    fTreeR->Fill();
  }
}

//____________________________________________________________________________
void AliPHOSClusterizerv1::MakeClusters()
{
  // Steering method to construct the clusters stored in a list of Reconstructed Points
  // A cluster is defined as a list of neighbour digits

  fNumberOfCpvClusters     = 0 ;
  fNumberOfEmcClusters     = 0 ;

  //Mark all digits as unused yet
  const Int_t maxNDigits = 3584; // There is no clusters larger than PHOS module ;)
  Int_t nDigits=fDigitsArr->GetEntriesFast() ;

  for(Int_t i=0; i<nDigits; i++){
    fDigitsUsed[i]=0 ;
  }
  Int_t iFirst = 0 ; //first index of digit which potentially can be a part of cluster
                     //e.g. first digit in this module, first CPV digit etc.
  AliPHOSDigit * digit ; 
  TArrayI clusterdigitslist(maxNDigits) ;   
  AliPHOSRecPoint * clu = 0 ; 
  for(Int_t i=0; i<nDigits; i++){
    if(fDigitsUsed[i])
      continue ;

    digit=static_cast<AliPHOSDigit*>(fDigitsArr->At(i)) ;

    clu=0 ;

    Int_t index ;

    //is this digit so energetic that start cluster?
    if (( IsInEmc(digit) &&  Calibrate(digit->GetEnergy(),digit->GetId()) > fEmcClusteringThreshold ) || 
        ( IsInCpv(digit) &&  Calibrate(digit->GetEnergy(),digit->GetId()) > fCpvClusteringThreshold ) ) {
      Int_t iDigitInCluster = 0 ; 
      if  ( IsInEmc(digit) ) {   
        // start a new EMC RecPoint
        if(fNumberOfEmcClusters >= fEMCRecPoints->GetSize()) 
          fEMCRecPoints->Expand(2*fNumberOfEmcClusters+1) ;
          
        fEMCRecPoints->AddAt(new  AliPHOSEmcRecPoint(""), fNumberOfEmcClusters) ;
        clu = static_cast<AliPHOSEmcRecPoint *>( fEMCRecPoints->At(fNumberOfEmcClusters) ) ; 
	fNumberOfEmcClusters++ ; 
	clu->AddDigit(*digit, Calibrate(digit->GetEnergy(),digit->GetId()),CalibrateT(digit->GetTime(),digit->GetId(),digit->IsLG())) ;
        clusterdigitslist[iDigitInCluster] = digit->GetIndexInList() ;
        iDigitInCluster++ ;
        fDigitsUsed[i]=kTRUE ; 
      } else { 
        // start a new CPV cluster
        if(fNumberOfCpvClusters >= fCPVRecPoints->GetSize()) 
          fCPVRecPoints->Expand(2*fNumberOfCpvClusters+1);

        fCPVRecPoints->AddAt(new AliPHOSCpvRecPoint(""), fNumberOfCpvClusters) ;
        clu =  static_cast<AliPHOSCpvRecPoint *>( fCPVRecPoints->At(fNumberOfCpvClusters) ) ;  
        fNumberOfCpvClusters++ ; 
        clu->AddDigit(*digit,  Calibrate(digit->GetEnergy(),digit->GetId()),0.) ; // no timing information in CPV
        clusterdigitslist[iDigitInCluster] = digit->GetIndexInList()  ;        
        iDigitInCluster++ ; 
        fDigitsUsed[i]=kTRUE ;
      } // else        

      //Now scan remaining digits in list to find neigbours of our seed
 
      AliPHOSDigit * digitN ; 
      index = 0 ;
      while (index < iDigitInCluster){ // scan over digits already in cluster 
        digit =  static_cast<AliPHOSDigit*>( fDigitsArr->At(clusterdigitslist[index]) )  ;      
        index++ ; 
        for(Int_t j=iFirst; j<nDigits; j++){
	  if (iDigitInCluster >= maxNDigits) {
	    AliError(Form("The number of digits in cluster is more than %d, skip the rest of event",
			  maxNDigits));
	    return;
	  }
          if(fDigitsUsed[j]) 
            continue ;        //look through remaining digits
          digitN = static_cast<AliPHOSDigit*>( fDigitsArr->At(j) ) ;
          Int_t ineb = AreNeighbours(digit, digitN);       // call (digit,digitN) in THAT oder !!!!!
          switch (ineb ) {
          case -1:   //too early (e.g. previous module), do not look before j at subsequent passes
            iFirst=j ;
            break ;
          case 0 :   // not a neighbour
            break ;
          case 1 :   // are neighbours 
	    clu->AddDigit(*digitN, Calibrate(digitN->GetEnergy(),digitN->GetId()),CalibrateT(digitN->GetTime(),digitN->GetId(),digit->IsLG())) ;
            clusterdigitslist[iDigitInCluster] = j ; 
            iDigitInCluster++ ; 
            fDigitsUsed[j]=kTRUE ;
            break ;
          case 2 :   // too far from each other
            goto endOfLoop;   
          } // switch
          
        }
        
        endOfLoop: ; //scanned all possible neighbours for this digit
        
      } // loop over cluster     
    } // energy theshold  
  }

}

//____________________________________________________________________________
void AliPHOSClusterizerv1::MakeUnfolding()
{
  // Unfolds clusters using the shape of an ElectroMagnetic shower
  // Performs unfolding of all EMC/CPV clusters

  // Unfold first EMC clusters 
  if(fNumberOfEmcClusters > 0){

    Int_t nModulesToUnfold = fGeom->GetNModules() ; 

    Int_t numberofNotUnfolded = fNumberOfEmcClusters ; 
    Int_t index ;   
    for(index = 0 ; index < numberofNotUnfolded ; index++){
      
      AliPHOSEmcRecPoint * emcRecPoint = static_cast<AliPHOSEmcRecPoint *>( fEMCRecPoints->At(index) ) ;
      if(emcRecPoint->GetPHOSMod()> nModulesToUnfold)
        break ;
      
      Int_t nMultipl = emcRecPoint->GetMultiplicity() ; 
      AliPHOSDigit ** maxAt = new AliPHOSDigit*[nMultipl] ;
      Float_t * maxAtEnergy = new Float_t[nMultipl] ;
      Int_t nMax = emcRecPoint->GetNumberOfLocalMax(maxAt, maxAtEnergy,fEmcLocMaxCut,fDigitsArr) ;
      
      if( nMax > 1 ) {     // if cluster is very flat (no pronounced maximum) then nMax = 0       
        UnfoldCluster(emcRecPoint, nMax, maxAt, maxAtEnergy) ;

        fEMCRecPoints->Remove(emcRecPoint); 
        fEMCRecPoints->Compress() ;
        index-- ;
        fNumberOfEmcClusters -- ;
        numberofNotUnfolded-- ;
      }
      else{
        emcRecPoint->SetNExMax(1) ; //Only one local maximum
      }
      
      delete[] maxAt ; 
      delete[] maxAtEnergy ; 
    }
  } 
  // Unfolding of EMC clusters finished


  // Unfold now CPV clusters
  if(fNumberOfCpvClusters > 0){
    
    Int_t nModulesToUnfold = fGeom->GetNModules() ;

    Int_t numberofCpvNotUnfolded = fNumberOfCpvClusters ;     
    Int_t index ;   
    for(index = 0 ; index < numberofCpvNotUnfolded ; index++){
      
      AliPHOSRecPoint * recPoint = static_cast<AliPHOSRecPoint *>( fCPVRecPoints->At(index) ) ;

      if(recPoint->GetPHOSMod()> nModulesToUnfold)
        break ;
      
      AliPHOSEmcRecPoint * emcRecPoint = static_cast<AliPHOSEmcRecPoint*>(recPoint) ; 
      
      Int_t nMultipl = emcRecPoint->GetMultiplicity() ; 
      AliPHOSDigit ** maxAt = new AliPHOSDigit*[nMultipl] ;
      Float_t * maxAtEnergy = new Float_t[nMultipl] ;
      Int_t nMax = emcRecPoint->GetNumberOfLocalMax(maxAt, maxAtEnergy,fCpvLocMaxCut,fDigitsArr) ;
      
      if( nMax > 1 ) {     // if cluster is very flat (no pronounced maximum) then nMax = 0       
        UnfoldCluster(emcRecPoint, nMax, maxAt, maxAtEnergy) ;
        fCPVRecPoints->Remove(emcRecPoint); 
        fCPVRecPoints->Compress() ;
        index-- ;
        numberofCpvNotUnfolded-- ;
        fNumberOfCpvClusters-- ;
      }
      
      delete[] maxAt ; 
      delete[] maxAtEnergy ; 
    } 
  }
  //Unfolding of Cpv clusters finished
  
}

//____________________________________________________________________________
Double_t  AliPHOSClusterizerv1::ShowerShape(Double_t x, Double_t z)
{ 
  // Shape of the shower (see PHOS TDR)
  // If you change this function, change also the gradient evaluation in ChiSquare()

  //for the moment we neglect dependence on the incident angle.  

  Double_t r2    = x*x + z*z ;
  Double_t r4    = r2*r2 ;
  Double_t r295  = TMath::Power(r2, 2.95/2.) ;
  Double_t shape = TMath::Exp( -r4 * (1. / (2.32 + 0.26 * r4) + 0.0316 / (1 + 0.0652 * r295) ) ) ;
  return shape ;
}

//____________________________________________________________________________
void  AliPHOSClusterizerv1::UnfoldCluster(AliPHOSEmcRecPoint * iniEmc, 
                                          Int_t nMax, 
                                          AliPHOSDigit ** maxAt, 
                                          Float_t * maxAtEnergy)
{ 
  // Performs the unfolding of a cluster with nMax overlapping showers 

  Int_t nPar = 3 * nMax ;
  Float_t * fitparameters = new Float_t[nPar] ;

  Bool_t rv = FindFit(iniEmc, maxAt, maxAtEnergy, nPar, fitparameters) ;

  if( !rv ) {
    // Fit failed, return and remove cluster
    iniEmc->SetNExMax(-1) ;
    delete[] fitparameters ; 
    return ;
  }

  // create ufolded rec points and fill them with new energy lists
  // First calculate energy deposited in each sell in accordance with fit (without fluctuations): efit[]
  // and later correct this number in acordance with actual energy deposition

  Int_t nDigits = iniEmc->GetMultiplicity() ;  
  Float_t * efit = new Float_t[nDigits] ;
  Float_t xDigit=0.,zDigit=0. ;
  Float_t xpar=0.,zpar=0.,epar=0.  ;
  Int_t relid[4] ;
  AliPHOSDigit * digit = 0 ;
  Int_t * emcDigits = iniEmc->GetDigitsList() ;

  TVector3 vIncid ;

  Int_t iparam ;
  Int_t iDigit ;
  for(iDigit = 0 ; iDigit < nDigits ; iDigit ++){
    digit = static_cast<AliPHOSDigit*>( fDigitsArr->At(emcDigits[iDigit] ) ) ;   
    fGeom->AbsToRelNumbering(digit->GetId(), relid) ;
    fGeom->RelPosInModule(relid, xDigit, zDigit) ;
    efit[iDigit] = 0;

    iparam = 0 ;    
    while(iparam < nPar ){
      xpar = fitparameters[iparam] ;
      zpar = fitparameters[iparam+1] ;
      epar = fitparameters[iparam+2] ;
      iparam += 3 ;
//      fGeom->GetIncidentVector(fVtx,relid[0],xpar,zpar,vIncid) ;
//      efit[iDigit] += epar * ShowerShape(xDigit - xpar,zDigit - zpar,vIncid) ;
      efit[iDigit] += epar * ShowerShape(xDigit - xpar,zDigit - zpar) ;
    }
  }
  
  // Now create new RecPoints and fill energy lists with efit corrected to fluctuations
  // so that energy deposited in each cell is distributed betwin new clusters proportionally
  // to its contribution to efit

  Float_t * emcEnergies = iniEmc->GetEnergiesList() ;
  Float_t ratio ;

  iparam = 0 ;
  while(iparam < nPar ){
    xpar = fitparameters[iparam] ;
    zpar = fitparameters[iparam+1] ;
    epar = fitparameters[iparam+2] ;
    iparam += 3 ;    
//    fGeom->GetIncidentVector(fVtx,iniEmc->GetPHOSMod(),xpar,zpar,vIncid) ;

    AliPHOSEmcRecPoint * emcRP = 0 ;  

    if(iniEmc->IsEmc()){ //create new entries in fEMCRecPoints...
      
      if(fNumberOfEmcClusters >= fEMCRecPoints->GetSize())
        fEMCRecPoints->Expand(2*fNumberOfEmcClusters) ;
      
      (*fEMCRecPoints)[fNumberOfEmcClusters] = new AliPHOSEmcRecPoint("") ;
      emcRP = static_cast<AliPHOSEmcRecPoint *>( fEMCRecPoints->At(fNumberOfEmcClusters) ) ;
      fNumberOfEmcClusters++ ;
      emcRP->SetNExMax((Int_t)nPar/3) ;
    }
    else{//create new entries in fCPVRecPoints
      if(fNumberOfCpvClusters >= fCPVRecPoints->GetSize())
        fCPVRecPoints->Expand(2*fNumberOfCpvClusters) ;
      
      (*fCPVRecPoints)[fNumberOfCpvClusters] = new AliPHOSCpvRecPoint("") ;
      emcRP = static_cast<AliPHOSEmcRecPoint *>( fCPVRecPoints->At(fNumberOfCpvClusters) ) ;
      fNumberOfCpvClusters++ ;
    }
    
    Float_t eDigit ;
    for(iDigit = 0 ; iDigit < nDigits ; iDigit ++){
      digit = static_cast<AliPHOSDigit*>( fDigitsArr->At( emcDigits[iDigit] ) ) ; 
      fGeom->AbsToRelNumbering(digit->GetId(), relid) ;
      fGeom->RelPosInModule(relid, xDigit, zDigit) ;
//      ratio = epar * ShowerShape(xDigit - xpar,zDigit - zpar,vIncid) / efit[iDigit] ; 
      ratio = epar * ShowerShape(xDigit - xpar,zDigit - zpar) / efit[iDigit] ; 
      eDigit = emcEnergies[iDigit] * ratio ;
      emcRP->AddDigit( *digit, eDigit,CalibrateT(digit->GetTime(),digit->GetId(),digit->IsLG()) ) ;
    }        
  }
 
  delete[] fitparameters ; 
  delete[] efit ; 
  
}

//_____________________________________________________________________________
void AliPHOSClusterizerv1::UnfoldingChiSquare(Int_t & nPar, Double_t * Grad, Double_t & fret, Double_t * x, Int_t iflag)
{
  // Calculates the Chi square for the cluster unfolding minimization
  // Number of parameters, Gradient, Chi squared, parameters, what to do

  TList * toMinuit = static_cast<TList*>( gMinuit->GetObjectFit() ) ;

  AliPHOSEmcRecPoint * emcRP = static_cast<AliPHOSEmcRecPoint*>( toMinuit->At(0) )  ;
  TClonesArray * digits = static_cast<TClonesArray*>( toMinuit->At(1) )  ;
  // A bit buggy way to get an access to the geometry
  // To be revised!
  AliPHOSGeometry *geom = static_cast<AliPHOSGeometry *>(toMinuit->At(2));

//  TVector3 * vtx = static_cast<TVector3*>(toMinuit->At(3)) ;  //Vertex position
  
  //  AliPHOSEmcRecPoint * emcRP = static_cast<AliPHOSEmcRecPoint *>( gMinuit->GetObjectFit() ) ; // EmcRecPoint to fit

  Int_t * emcDigits     = emcRP->GetDigitsList() ;

  Int_t nOdigits = emcRP->GetDigitsMultiplicity() ; 

  Float_t * emcEnergies = emcRP->GetEnergiesList() ;
  
//  TVector3 vInc ;
  fret = 0. ;     
  Int_t iparam ;

  if(iflag == 2)
    for(iparam = 0 ; iparam < nPar ; iparam++)    
      Grad[iparam] = 0 ; // Will evaluate gradient
  
  Double_t efit ;    

  AliPHOSDigit * digit ;
  Int_t iDigit ;

  for( iDigit = 0 ; iDigit < nOdigits ; iDigit++) {

    digit = static_cast<AliPHOSDigit*>( digits->At( emcDigits[iDigit] ) ); 

    Int_t relid[4] ;
    Float_t xDigit ;
    Float_t zDigit ;

    geom->AbsToRelNumbering(digit->GetId(), relid) ;

    geom->RelPosInModule(relid, xDigit, zDigit) ;

     if(iflag == 2){  // calculate gradient
       Int_t iParam = 0 ;
       efit = 0 ;
       while(iParam < nPar ){
         Double_t dx = (xDigit - x[iParam]) ;
         iParam++ ; 
         Double_t dz = (zDigit - x[iParam]) ; 
         iParam++ ;          
//         fGeom->GetIncidentVector(*vtx,emcRP->GetPHOSMod(),x[iParam-2],x[iParam-1],vInc) ;
//         efit += x[iParam] * ShowerShape(dx,dz,vInc) ;
         efit += x[iParam] * ShowerShape(dx,dz) ;
         iParam++ ;
       }
       Double_t sum = 2. * (efit - emcEnergies[iDigit]) / emcEnergies[iDigit] ; // Here we assume, that sigma = sqrt(E) 
       iParam = 0 ;
       while(iParam < nPar ){
         Double_t xpar = x[iParam] ;
         Double_t zpar = x[iParam+1] ;
         Double_t epar = x[iParam+2] ;
//         fGeom->GetIncidentVector(*vtx,emcRP->GetPHOSMod(),xpar,zpar,vInc) ;
         Double_t dr = TMath::Sqrt( (xDigit - xpar) * (xDigit - xpar) + (zDigit - zpar) * (zDigit - zpar) );
//         Double_t shape = sum * ShowerShape(xDigit - xpar,zDigit - zpar,vInc) ;
         Double_t shape = sum * ShowerShape(xDigit - xpar,zDigit - zpar) ;
//DP: No incident angle dependence in gradient yet!!!!!!
         Double_t r4 = dr*dr*dr*dr ;
         Double_t r295 = TMath::Power(dr,2.95) ;
         Double_t deriv =-4. * dr*dr * ( 2.32 / ( (2.32 + 0.26 * r4) * (2.32 + 0.26 * r4) ) +
                                         0.0316 * (1. + 0.0171 * r295) / ( ( 1. + 0.0652 * r295) * (1. + 0.0652 * r295) ) ) ;
         
         Grad[iParam] += epar * shape * deriv * (xpar - xDigit) ;  // Derivative over x    
         iParam++ ; 
         Grad[iParam] += epar * shape * deriv * (zpar - zDigit) ;  // Derivative over z         
         iParam++ ; 
         Grad[iParam] += shape ;                                  // Derivative over energy             
         iParam++ ; 
       }
     }
     efit = 0;
     iparam = 0 ;

     while(iparam < nPar ){
       Double_t xpar = x[iparam] ;
       Double_t zpar = x[iparam+1] ;
       Double_t epar = x[iparam+2] ;
       iparam += 3 ;
//       fGeom->GetIncidentVector(*vtx,emcRP->GetPHOSMod(),xpar,zpar,vInc) ;
//       efit += epar * ShowerShape(xDigit - xpar,zDigit - zpar,vInc) ;
       efit += epar * ShowerShape(xDigit - xpar,zDigit - zpar) ;
     }

     fret += (efit-emcEnergies[iDigit])*(efit-emcEnergies[iDigit])/emcEnergies[iDigit] ; 
     // Here we assume, that sigma = sqrt(E)
  }

}

//____________________________________________________________________________
void AliPHOSClusterizerv1::Print(const Option_t *)const
{
  // Print clusterizer parameters

  TString message ; 
  TString taskName(GetName()) ; 
  taskName.ReplaceAll(Version(), "") ;
  
  if( strcmp(GetName(), "") !=0 ) {  
    // Print parameters
    message  = "\n--------------- %s %s -----------\n" ; 
    message += "Clusterizing digits from the file: %s\n" ;
    message += "                           Branch: %s\n" ; 
    message += "                       EMC Clustering threshold = %f\n" ; 
    message += "                       EMC Local Maximum cut    = %f\n" ; 
    message += "                       EMC Logarothmic weight   = %f\n" ;
    message += "                       CPV Clustering threshold = %f\n" ;
    message += "                       CPV Local Maximum cut    = %f\n" ;
    message += "                       CPV Logarothmic weight   = %f\n" ;
    if(fToUnfold)
      message += " Unfolding on\n" ;
    else
      message += " Unfolding off\n" ;
    
    message += "------------------------------------------------------------------" ;
  }
  else 
    message = " AliPHOSClusterizerv1 not initialized " ;
  
  AliInfo(Form("%s, %s %s %s %s %f %f %f %f %f %f", message.Data(),  
       taskName.Data(), 
       GetTitle(),
       taskName.Data(), 
       GetName(), 
       fEmcClusteringThreshold, 
       fEmcLocMaxCut, 
       fW0, 
       fCpvClusteringThreshold, 
       fCpvLocMaxCut, 
       fW0CPV )) ; 
}
//____________________________________________________________________________
void AliPHOSClusterizerv1::PrintRecPoints(Option_t * option)
{
  // Prints list of RecPoints produced at the current pass of AliPHOSClusterizer

  AliInfo(Form("\nFound %d EMC RecPoints and %d CPV RecPoints", 
	       fEMCRecPoints->GetEntriesFast(),
	       fCPVRecPoints->GetEntriesFast() ))  ;
 
  if(strstr(option,"all")) {
    printf("\n EMC clusters \n") ;
    printf("Index    Ene(MeV) Multi Module     X    Y   Z    Lambdas_1  Lambda_2  # of prim  Primaries list\n") ;      
    Int_t index ;
    for (index = 0 ; index < fEMCRecPoints->GetEntries() ; index++) {
      AliPHOSEmcRecPoint * rp = (AliPHOSEmcRecPoint * )fEMCRecPoints->At(index) ; 
      TVector3  locpos;  
      rp->GetLocalPosition(locpos);
      Float_t lambda[2]; 
      rp->GetElipsAxis(lambda);
      Int_t * primaries; 
      Int_t nprimaries;
      primaries = rp->GetPrimaries(nprimaries);
      printf("\n%6d  %8.2f  %3d     %2d     %4.1f   %4.1f   %4.1f   %4f  %4f    %2d     : ", 
	      rp->GetIndexInList(), rp->GetEnergy(), rp->GetMultiplicity(), rp->GetPHOSMod(), 
	      locpos.X(), locpos.Y(), locpos.Z(), lambda[0], lambda[1], nprimaries) ; 
      
      for (Int_t iprimary=0; iprimary<nprimaries; iprimary++) {
	printf("%d ", primaries[iprimary] ) ; 
      }
      printf("\n") ;
    }

    //Now plot CPV recPoints
    printf("\n CPV clusters \n") ;
    printf("Index    Ene(MeV) Module     X     Y    Z  \n") ;      
    for (index = 0 ; index < fCPVRecPoints->GetEntries() ; index++) {
      AliPHOSCpvRecPoint * rp = (AliPHOSCpvRecPoint * )fCPVRecPoints->At(index) ; 
      
      TVector3  locpos;  
      rp->GetLocalPosition(locpos);
      
      printf("\n%6d  %8.2f  %2d     %4.1f    %4.1f %4.1f \n", 
	     rp->GetIndexInList(), rp->GetEnergy(), rp->GetPHOSMod(), 
	     locpos.X(), locpos.Y(), locpos.Z()) ; 
    }
  }
}


//____________________________________________________________________________
void AliPHOSClusterizerv1::SetDistancesToBadChannels()
{
  //For each EMC rec. point set the distance to the nearest bad crystal.
  //Author: Boris Polichtchouk 

  if(!fgCalibData->GetNumOfEmcBadChannels()) return;

  Int_t badIds[8000];
  memset(badIds,0,8000*sizeof(Int_t));
  fgCalibData->EmcBadChannelIds(badIds);

  AliPHOSEmcRecPoint* rp;

  TMatrixF gmat;
  TVector3 gposRecPoint; // global (in ALICE frame) position of rec. point
  TVector3 gposBadChannel; // global position of bad crystal
  TVector3 dR;

  Float_t dist,minDist;
  Int_t relid[4]={0,0,0,0} ;
  TVector3 lpos ;
  for(Int_t iRP=0; iRP<fEMCRecPoints->GetEntries(); iRP++){
    rp = (AliPHOSEmcRecPoint*)fEMCRecPoints->At(iRP);
    //evaluate distance to border
    relid[0]=rp->GetPHOSMod() ;
    relid[2]=1 ;
    relid[3]=1 ;
    Float_t xcorner,zcorner;
    fGeom->RelPosInModule(relid,xcorner,zcorner) ; //coordinate of the corner cell
    rp->GetLocalPosition(lpos) ;
    minDist = 2.2+TMath::Min(-xcorner-TMath::Abs(lpos.X()),-zcorner-TMath::Abs(lpos.Z())); //2.2 - crystal size
    for(Int_t iBad=0; iBad<fgCalibData->GetNumOfEmcBadChannels(); iBad++) {
      fGeom->AbsToRelNumbering(badIds[iBad],relid)  ;
      if(relid[0]!=rp->GetPHOSMod()) //We can not evaluate global position directly since 
        continue ;                   //bad channels can be in the module which does not exist in simulations.
      rp->GetGlobalPosition(gposRecPoint,gmat);
      fGeom->RelPosInAlice(badIds[iBad],gposBadChannel);
      AliDebug(2,Form("BC position:[%.3f,%.3f,%.3f], RP position:[%.3f,%.3f,%.3f]. E=%.3f\n",
		      gposBadChannel.X(),gposBadChannel.Y(),gposBadChannel.Z(),
		      gposRecPoint.X(),gposRecPoint.Y(),gposRecPoint.Z(),rp->GetEnergy()));
      dR = gposBadChannel-gposRecPoint;
      dist = dR.Mag();
      if(dist<minDist) minDist = dist;
    }

    rp->SetDistanceToBadCrystal(minDist); 
  }

}
//==================================================================================
Float_t AliPHOSClusterizerv1::Calibrate(Float_t amp, Int_t absId) const{
  // Calibrate EMC digit, i.e. multiply its Amp by a factor read from CDB

  const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;

  //Determine rel.position of the cell absolute ID
  Int_t relId[4];
  geom->AbsToRelNumbering(absId,relId);
  Int_t module=relId[0];
  Int_t row   =relId[2];
  Int_t column=relId[3];
  if(relId[1]){ //CPV
    Float_t calibration = fgCalibData->GetADCchannelCpv(module,column,row);
    return amp*calibration ;
  }   
  else{ //EMC
    Float_t calibration = fgCalibData->GetADCchannelEmc(module,column,row);
    return amp*calibration ;
  }
}
//==================================================================================
Float_t AliPHOSClusterizerv1::CalibrateT(Float_t time, Int_t absId,Bool_t isLG)const{
  // Calibrate time in EMC digit

  const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;

  //Determine rel.position of the cell absolute ID
  Int_t relId[4];
  geom->AbsToRelNumbering(absId,relId);
  Int_t module=relId[0];
  Int_t row   =relId[2];
  Int_t column=relId[3];
  if(relId[1]){ //CPV
    return 0. ;
  }
  else{ //EMC
    if(isLG)
      time += fgCalibData->GetLGTimeShiftEmc(module,column,row);
    else
      time += fgCalibData->GetTimeShiftEmc(module,column,row);
    return time ;
  }
}

 AliPHOSClusterizerv1.cxx:1
 AliPHOSClusterizerv1.cxx:2
 AliPHOSClusterizerv1.cxx:3
 AliPHOSClusterizerv1.cxx:4
 AliPHOSClusterizerv1.cxx:5
 AliPHOSClusterizerv1.cxx:6
 AliPHOSClusterizerv1.cxx:7
 AliPHOSClusterizerv1.cxx:8
 AliPHOSClusterizerv1.cxx:9
 AliPHOSClusterizerv1.cxx:10
 AliPHOSClusterizerv1.cxx:11
 AliPHOSClusterizerv1.cxx:12
 AliPHOSClusterizerv1.cxx:13
 AliPHOSClusterizerv1.cxx:14
 AliPHOSClusterizerv1.cxx:15
 AliPHOSClusterizerv1.cxx:16
 AliPHOSClusterizerv1.cxx:17
 AliPHOSClusterizerv1.cxx:18
 AliPHOSClusterizerv1.cxx:19
 AliPHOSClusterizerv1.cxx:20
 AliPHOSClusterizerv1.cxx:21
 AliPHOSClusterizerv1.cxx:22
 AliPHOSClusterizerv1.cxx:23
 AliPHOSClusterizerv1.cxx:24
 AliPHOSClusterizerv1.cxx:25
 AliPHOSClusterizerv1.cxx:26
 AliPHOSClusterizerv1.cxx:27
 AliPHOSClusterizerv1.cxx:28
 AliPHOSClusterizerv1.cxx:29
 AliPHOSClusterizerv1.cxx:30
 AliPHOSClusterizerv1.cxx:31
 AliPHOSClusterizerv1.cxx:32
 AliPHOSClusterizerv1.cxx:33
 AliPHOSClusterizerv1.cxx:34
 AliPHOSClusterizerv1.cxx:35
 AliPHOSClusterizerv1.cxx:36
 AliPHOSClusterizerv1.cxx:37
 AliPHOSClusterizerv1.cxx:38
 AliPHOSClusterizerv1.cxx:39
 AliPHOSClusterizerv1.cxx:40
 AliPHOSClusterizerv1.cxx:41
 AliPHOSClusterizerv1.cxx:42
 AliPHOSClusterizerv1.cxx:43
 AliPHOSClusterizerv1.cxx:44
 AliPHOSClusterizerv1.cxx:45
 AliPHOSClusterizerv1.cxx:46
 AliPHOSClusterizerv1.cxx:47
 AliPHOSClusterizerv1.cxx:48
 AliPHOSClusterizerv1.cxx:49
 AliPHOSClusterizerv1.cxx:50
 AliPHOSClusterizerv1.cxx:51
 AliPHOSClusterizerv1.cxx:52
 AliPHOSClusterizerv1.cxx:53
 AliPHOSClusterizerv1.cxx:54
 AliPHOSClusterizerv1.cxx:55
 AliPHOSClusterizerv1.cxx:56
 AliPHOSClusterizerv1.cxx:57
 AliPHOSClusterizerv1.cxx:58
 AliPHOSClusterizerv1.cxx:59
 AliPHOSClusterizerv1.cxx:60
 AliPHOSClusterizerv1.cxx:61
 AliPHOSClusterizerv1.cxx:62
 AliPHOSClusterizerv1.cxx:63
 AliPHOSClusterizerv1.cxx:64
 AliPHOSClusterizerv1.cxx:65
 AliPHOSClusterizerv1.cxx:66
 AliPHOSClusterizerv1.cxx:67
 AliPHOSClusterizerv1.cxx:68
 AliPHOSClusterizerv1.cxx:69
 AliPHOSClusterizerv1.cxx:70
 AliPHOSClusterizerv1.cxx:71
 AliPHOSClusterizerv1.cxx:72
 AliPHOSClusterizerv1.cxx:73
 AliPHOSClusterizerv1.cxx:74
 AliPHOSClusterizerv1.cxx:75
 AliPHOSClusterizerv1.cxx:76
 AliPHOSClusterizerv1.cxx:77
 AliPHOSClusterizerv1.cxx:78
 AliPHOSClusterizerv1.cxx:79
 AliPHOSClusterizerv1.cxx:80
 AliPHOSClusterizerv1.cxx:81
 AliPHOSClusterizerv1.cxx:82
 AliPHOSClusterizerv1.cxx:83
 AliPHOSClusterizerv1.cxx:84
 AliPHOSClusterizerv1.cxx:85
 AliPHOSClusterizerv1.cxx:86
 AliPHOSClusterizerv1.cxx:87
 AliPHOSClusterizerv1.cxx:88
 AliPHOSClusterizerv1.cxx:89
 AliPHOSClusterizerv1.cxx:90
 AliPHOSClusterizerv1.cxx:91
 AliPHOSClusterizerv1.cxx:92
 AliPHOSClusterizerv1.cxx:93
 AliPHOSClusterizerv1.cxx:94
 AliPHOSClusterizerv1.cxx:95
 AliPHOSClusterizerv1.cxx:96
 AliPHOSClusterizerv1.cxx:97
 AliPHOSClusterizerv1.cxx:98
 AliPHOSClusterizerv1.cxx:99
 AliPHOSClusterizerv1.cxx:100
 AliPHOSClusterizerv1.cxx:101
 AliPHOSClusterizerv1.cxx:102
 AliPHOSClusterizerv1.cxx:103
 AliPHOSClusterizerv1.cxx:104
 AliPHOSClusterizerv1.cxx:105
 AliPHOSClusterizerv1.cxx:106
 AliPHOSClusterizerv1.cxx:107
 AliPHOSClusterizerv1.cxx:108
 AliPHOSClusterizerv1.cxx:109
 AliPHOSClusterizerv1.cxx:110
 AliPHOSClusterizerv1.cxx:111
 AliPHOSClusterizerv1.cxx:112
 AliPHOSClusterizerv1.cxx:113
 AliPHOSClusterizerv1.cxx:114
 AliPHOSClusterizerv1.cxx:115
 AliPHOSClusterizerv1.cxx:116
 AliPHOSClusterizerv1.cxx:117
 AliPHOSClusterizerv1.cxx:118
 AliPHOSClusterizerv1.cxx:119
 AliPHOSClusterizerv1.cxx:120
 AliPHOSClusterizerv1.cxx:121
 AliPHOSClusterizerv1.cxx:122
 AliPHOSClusterizerv1.cxx:123
 AliPHOSClusterizerv1.cxx:124
 AliPHOSClusterizerv1.cxx:125
 AliPHOSClusterizerv1.cxx:126
 AliPHOSClusterizerv1.cxx:127
 AliPHOSClusterizerv1.cxx:128
 AliPHOSClusterizerv1.cxx:129
 AliPHOSClusterizerv1.cxx:130
 AliPHOSClusterizerv1.cxx:131
 AliPHOSClusterizerv1.cxx:132
 AliPHOSClusterizerv1.cxx:133
 AliPHOSClusterizerv1.cxx:134
 AliPHOSClusterizerv1.cxx:135
 AliPHOSClusterizerv1.cxx:136
 AliPHOSClusterizerv1.cxx:137
 AliPHOSClusterizerv1.cxx:138
 AliPHOSClusterizerv1.cxx:139
 AliPHOSClusterizerv1.cxx:140
 AliPHOSClusterizerv1.cxx:141
 AliPHOSClusterizerv1.cxx:142
 AliPHOSClusterizerv1.cxx:143
 AliPHOSClusterizerv1.cxx:144
 AliPHOSClusterizerv1.cxx:145
 AliPHOSClusterizerv1.cxx:146
 AliPHOSClusterizerv1.cxx:147
 AliPHOSClusterizerv1.cxx:148
 AliPHOSClusterizerv1.cxx:149
 AliPHOSClusterizerv1.cxx:150
 AliPHOSClusterizerv1.cxx:151
 AliPHOSClusterizerv1.cxx:152
 AliPHOSClusterizerv1.cxx:153
 AliPHOSClusterizerv1.cxx:154
 AliPHOSClusterizerv1.cxx:155
 AliPHOSClusterizerv1.cxx:156
 AliPHOSClusterizerv1.cxx:157
 AliPHOSClusterizerv1.cxx:158
 AliPHOSClusterizerv1.cxx:159
 AliPHOSClusterizerv1.cxx:160
 AliPHOSClusterizerv1.cxx:161
 AliPHOSClusterizerv1.cxx:162
 AliPHOSClusterizerv1.cxx:163
 AliPHOSClusterizerv1.cxx:164
 AliPHOSClusterizerv1.cxx:165
 AliPHOSClusterizerv1.cxx:166
 AliPHOSClusterizerv1.cxx:167
 AliPHOSClusterizerv1.cxx:168
 AliPHOSClusterizerv1.cxx:169
 AliPHOSClusterizerv1.cxx:170
 AliPHOSClusterizerv1.cxx:171
 AliPHOSClusterizerv1.cxx:172
 AliPHOSClusterizerv1.cxx:173
 AliPHOSClusterizerv1.cxx:174
 AliPHOSClusterizerv1.cxx:175
 AliPHOSClusterizerv1.cxx:176
 AliPHOSClusterizerv1.cxx:177
 AliPHOSClusterizerv1.cxx:178
 AliPHOSClusterizerv1.cxx:179
 AliPHOSClusterizerv1.cxx:180
 AliPHOSClusterizerv1.cxx:181
 AliPHOSClusterizerv1.cxx:182
 AliPHOSClusterizerv1.cxx:183
 AliPHOSClusterizerv1.cxx:184
 AliPHOSClusterizerv1.cxx:185
 AliPHOSClusterizerv1.cxx:186
 AliPHOSClusterizerv1.cxx:187
 AliPHOSClusterizerv1.cxx:188
 AliPHOSClusterizerv1.cxx:189
 AliPHOSClusterizerv1.cxx:190
 AliPHOSClusterizerv1.cxx:191
 AliPHOSClusterizerv1.cxx:192
 AliPHOSClusterizerv1.cxx:193
 AliPHOSClusterizerv1.cxx:194
 AliPHOSClusterizerv1.cxx:195
 AliPHOSClusterizerv1.cxx:196
 AliPHOSClusterizerv1.cxx:197
 AliPHOSClusterizerv1.cxx:198
 AliPHOSClusterizerv1.cxx:199
 AliPHOSClusterizerv1.cxx:200
 AliPHOSClusterizerv1.cxx:201
 AliPHOSClusterizerv1.cxx:202
 AliPHOSClusterizerv1.cxx:203
 AliPHOSClusterizerv1.cxx:204
 AliPHOSClusterizerv1.cxx:205
 AliPHOSClusterizerv1.cxx:206
 AliPHOSClusterizerv1.cxx:207
 AliPHOSClusterizerv1.cxx:208
 AliPHOSClusterizerv1.cxx:209
 AliPHOSClusterizerv1.cxx:210
 AliPHOSClusterizerv1.cxx:211
 AliPHOSClusterizerv1.cxx:212
 AliPHOSClusterizerv1.cxx:213
 AliPHOSClusterizerv1.cxx:214
 AliPHOSClusterizerv1.cxx:215
 AliPHOSClusterizerv1.cxx:216
 AliPHOSClusterizerv1.cxx:217
 AliPHOSClusterizerv1.cxx:218
 AliPHOSClusterizerv1.cxx:219
 AliPHOSClusterizerv1.cxx:220
 AliPHOSClusterizerv1.cxx:221
 AliPHOSClusterizerv1.cxx:222
 AliPHOSClusterizerv1.cxx:223
 AliPHOSClusterizerv1.cxx:224
 AliPHOSClusterizerv1.cxx:225
 AliPHOSClusterizerv1.cxx:226
 AliPHOSClusterizerv1.cxx:227
 AliPHOSClusterizerv1.cxx:228
 AliPHOSClusterizerv1.cxx:229
 AliPHOSClusterizerv1.cxx:230
 AliPHOSClusterizerv1.cxx:231
 AliPHOSClusterizerv1.cxx:232
 AliPHOSClusterizerv1.cxx:233
 AliPHOSClusterizerv1.cxx:234
 AliPHOSClusterizerv1.cxx:235
 AliPHOSClusterizerv1.cxx:236
 AliPHOSClusterizerv1.cxx:237
 AliPHOSClusterizerv1.cxx:238
 AliPHOSClusterizerv1.cxx:239
 AliPHOSClusterizerv1.cxx:240
 AliPHOSClusterizerv1.cxx:241
 AliPHOSClusterizerv1.cxx:242
 AliPHOSClusterizerv1.cxx:243
 AliPHOSClusterizerv1.cxx:244
 AliPHOSClusterizerv1.cxx:245
 AliPHOSClusterizerv1.cxx:246
 AliPHOSClusterizerv1.cxx:247
 AliPHOSClusterizerv1.cxx:248
 AliPHOSClusterizerv1.cxx:249
 AliPHOSClusterizerv1.cxx:250
 AliPHOSClusterizerv1.cxx:251
 AliPHOSClusterizerv1.cxx:252
 AliPHOSClusterizerv1.cxx:253
 AliPHOSClusterizerv1.cxx:254
 AliPHOSClusterizerv1.cxx:255
 AliPHOSClusterizerv1.cxx:256
 AliPHOSClusterizerv1.cxx:257
 AliPHOSClusterizerv1.cxx:258
 AliPHOSClusterizerv1.cxx:259
 AliPHOSClusterizerv1.cxx:260
 AliPHOSClusterizerv1.cxx:261
 AliPHOSClusterizerv1.cxx:262
 AliPHOSClusterizerv1.cxx:263
 AliPHOSClusterizerv1.cxx:264
 AliPHOSClusterizerv1.cxx:265
 AliPHOSClusterizerv1.cxx:266
 AliPHOSClusterizerv1.cxx:267
 AliPHOSClusterizerv1.cxx:268
 AliPHOSClusterizerv1.cxx:269
 AliPHOSClusterizerv1.cxx:270
 AliPHOSClusterizerv1.cxx:271
 AliPHOSClusterizerv1.cxx:272
 AliPHOSClusterizerv1.cxx:273
 AliPHOSClusterizerv1.cxx:274
 AliPHOSClusterizerv1.cxx:275
 AliPHOSClusterizerv1.cxx:276
 AliPHOSClusterizerv1.cxx:277
 AliPHOSClusterizerv1.cxx:278
 AliPHOSClusterizerv1.cxx:279
 AliPHOSClusterizerv1.cxx:280
 AliPHOSClusterizerv1.cxx:281
 AliPHOSClusterizerv1.cxx:282
 AliPHOSClusterizerv1.cxx:283
 AliPHOSClusterizerv1.cxx:284
 AliPHOSClusterizerv1.cxx:285
 AliPHOSClusterizerv1.cxx:286
 AliPHOSClusterizerv1.cxx:287
 AliPHOSClusterizerv1.cxx:288
 AliPHOSClusterizerv1.cxx:289
 AliPHOSClusterizerv1.cxx:290
 AliPHOSClusterizerv1.cxx:291
 AliPHOSClusterizerv1.cxx:292
 AliPHOSClusterizerv1.cxx:293
 AliPHOSClusterizerv1.cxx:294
 AliPHOSClusterizerv1.cxx:295
 AliPHOSClusterizerv1.cxx:296
 AliPHOSClusterizerv1.cxx:297
 AliPHOSClusterizerv1.cxx:298
 AliPHOSClusterizerv1.cxx:299
 AliPHOSClusterizerv1.cxx:300
 AliPHOSClusterizerv1.cxx:301
 AliPHOSClusterizerv1.cxx:302
 AliPHOSClusterizerv1.cxx:303
 AliPHOSClusterizerv1.cxx:304
 AliPHOSClusterizerv1.cxx:305
 AliPHOSClusterizerv1.cxx:306
 AliPHOSClusterizerv1.cxx:307
 AliPHOSClusterizerv1.cxx:308
 AliPHOSClusterizerv1.cxx:309
 AliPHOSClusterizerv1.cxx:310
 AliPHOSClusterizerv1.cxx:311
 AliPHOSClusterizerv1.cxx:312
 AliPHOSClusterizerv1.cxx:313
 AliPHOSClusterizerv1.cxx:314
 AliPHOSClusterizerv1.cxx:315
 AliPHOSClusterizerv1.cxx:316
 AliPHOSClusterizerv1.cxx:317
 AliPHOSClusterizerv1.cxx:318
 AliPHOSClusterizerv1.cxx:319
 AliPHOSClusterizerv1.cxx:320
 AliPHOSClusterizerv1.cxx:321
 AliPHOSClusterizerv1.cxx:322
 AliPHOSClusterizerv1.cxx:323
 AliPHOSClusterizerv1.cxx:324
 AliPHOSClusterizerv1.cxx:325
 AliPHOSClusterizerv1.cxx:326
 AliPHOSClusterizerv1.cxx:327
 AliPHOSClusterizerv1.cxx:328
 AliPHOSClusterizerv1.cxx:329
 AliPHOSClusterizerv1.cxx:330
 AliPHOSClusterizerv1.cxx:331
 AliPHOSClusterizerv1.cxx:332
 AliPHOSClusterizerv1.cxx:333
 AliPHOSClusterizerv1.cxx:334
 AliPHOSClusterizerv1.cxx:335
 AliPHOSClusterizerv1.cxx:336
 AliPHOSClusterizerv1.cxx:337
 AliPHOSClusterizerv1.cxx:338
 AliPHOSClusterizerv1.cxx:339
 AliPHOSClusterizerv1.cxx:340
 AliPHOSClusterizerv1.cxx:341
 AliPHOSClusterizerv1.cxx:342
 AliPHOSClusterizerv1.cxx:343
 AliPHOSClusterizerv1.cxx:344
 AliPHOSClusterizerv1.cxx:345
 AliPHOSClusterizerv1.cxx:346
 AliPHOSClusterizerv1.cxx:347
 AliPHOSClusterizerv1.cxx:348
 AliPHOSClusterizerv1.cxx:349
 AliPHOSClusterizerv1.cxx:350
 AliPHOSClusterizerv1.cxx:351
 AliPHOSClusterizerv1.cxx:352
 AliPHOSClusterizerv1.cxx:353
 AliPHOSClusterizerv1.cxx:354
 AliPHOSClusterizerv1.cxx:355
 AliPHOSClusterizerv1.cxx:356
 AliPHOSClusterizerv1.cxx:357
 AliPHOSClusterizerv1.cxx:358
 AliPHOSClusterizerv1.cxx:359
 AliPHOSClusterizerv1.cxx:360
 AliPHOSClusterizerv1.cxx:361
 AliPHOSClusterizerv1.cxx:362
 AliPHOSClusterizerv1.cxx:363
 AliPHOSClusterizerv1.cxx:364
 AliPHOSClusterizerv1.cxx:365
 AliPHOSClusterizerv1.cxx:366
 AliPHOSClusterizerv1.cxx:367
 AliPHOSClusterizerv1.cxx:368
 AliPHOSClusterizerv1.cxx:369
 AliPHOSClusterizerv1.cxx:370
 AliPHOSClusterizerv1.cxx:371
 AliPHOSClusterizerv1.cxx:372
 AliPHOSClusterizerv1.cxx:373
 AliPHOSClusterizerv1.cxx:374
 AliPHOSClusterizerv1.cxx:375
 AliPHOSClusterizerv1.cxx:376
 AliPHOSClusterizerv1.cxx:377
 AliPHOSClusterizerv1.cxx:378
 AliPHOSClusterizerv1.cxx:379
 AliPHOSClusterizerv1.cxx:380
 AliPHOSClusterizerv1.cxx:381
 AliPHOSClusterizerv1.cxx:382
 AliPHOSClusterizerv1.cxx:383
 AliPHOSClusterizerv1.cxx:384
 AliPHOSClusterizerv1.cxx:385
 AliPHOSClusterizerv1.cxx:386
 AliPHOSClusterizerv1.cxx:387
 AliPHOSClusterizerv1.cxx:388
 AliPHOSClusterizerv1.cxx:389
 AliPHOSClusterizerv1.cxx:390
 AliPHOSClusterizerv1.cxx:391
 AliPHOSClusterizerv1.cxx:392
 AliPHOSClusterizerv1.cxx:393
 AliPHOSClusterizerv1.cxx:394
 AliPHOSClusterizerv1.cxx:395
 AliPHOSClusterizerv1.cxx:396
 AliPHOSClusterizerv1.cxx:397
 AliPHOSClusterizerv1.cxx:398
 AliPHOSClusterizerv1.cxx:399
 AliPHOSClusterizerv1.cxx:400
 AliPHOSClusterizerv1.cxx:401
 AliPHOSClusterizerv1.cxx:402
 AliPHOSClusterizerv1.cxx:403
 AliPHOSClusterizerv1.cxx:404
 AliPHOSClusterizerv1.cxx:405
 AliPHOSClusterizerv1.cxx:406
 AliPHOSClusterizerv1.cxx:407
 AliPHOSClusterizerv1.cxx:408
 AliPHOSClusterizerv1.cxx:409
 AliPHOSClusterizerv1.cxx:410
 AliPHOSClusterizerv1.cxx:411
 AliPHOSClusterizerv1.cxx:412
 AliPHOSClusterizerv1.cxx:413
 AliPHOSClusterizerv1.cxx:414
 AliPHOSClusterizerv1.cxx:415
 AliPHOSClusterizerv1.cxx:416
 AliPHOSClusterizerv1.cxx:417
 AliPHOSClusterizerv1.cxx:418
 AliPHOSClusterizerv1.cxx:419
 AliPHOSClusterizerv1.cxx:420
 AliPHOSClusterizerv1.cxx:421
 AliPHOSClusterizerv1.cxx:422
 AliPHOSClusterizerv1.cxx:423
 AliPHOSClusterizerv1.cxx:424
 AliPHOSClusterizerv1.cxx:425
 AliPHOSClusterizerv1.cxx:426
 AliPHOSClusterizerv1.cxx:427
 AliPHOSClusterizerv1.cxx:428
 AliPHOSClusterizerv1.cxx:429
 AliPHOSClusterizerv1.cxx:430
 AliPHOSClusterizerv1.cxx:431
 AliPHOSClusterizerv1.cxx:432
 AliPHOSClusterizerv1.cxx:433
 AliPHOSClusterizerv1.cxx:434
 AliPHOSClusterizerv1.cxx:435
 AliPHOSClusterizerv1.cxx:436
 AliPHOSClusterizerv1.cxx:437
 AliPHOSClusterizerv1.cxx:438
 AliPHOSClusterizerv1.cxx:439
 AliPHOSClusterizerv1.cxx:440
 AliPHOSClusterizerv1.cxx:441
 AliPHOSClusterizerv1.cxx:442
 AliPHOSClusterizerv1.cxx:443
 AliPHOSClusterizerv1.cxx:444
 AliPHOSClusterizerv1.cxx:445
 AliPHOSClusterizerv1.cxx:446
 AliPHOSClusterizerv1.cxx:447
 AliPHOSClusterizerv1.cxx:448
 AliPHOSClusterizerv1.cxx:449
 AliPHOSClusterizerv1.cxx:450
 AliPHOSClusterizerv1.cxx:451
 AliPHOSClusterizerv1.cxx:452
 AliPHOSClusterizerv1.cxx:453
 AliPHOSClusterizerv1.cxx:454
 AliPHOSClusterizerv1.cxx:455
 AliPHOSClusterizerv1.cxx:456
 AliPHOSClusterizerv1.cxx:457
 AliPHOSClusterizerv1.cxx:458
 AliPHOSClusterizerv1.cxx:459
 AliPHOSClusterizerv1.cxx:460
 AliPHOSClusterizerv1.cxx:461
 AliPHOSClusterizerv1.cxx:462
 AliPHOSClusterizerv1.cxx:463
 AliPHOSClusterizerv1.cxx:464
 AliPHOSClusterizerv1.cxx:465
 AliPHOSClusterizerv1.cxx:466
 AliPHOSClusterizerv1.cxx:467
 AliPHOSClusterizerv1.cxx:468
 AliPHOSClusterizerv1.cxx:469
 AliPHOSClusterizerv1.cxx:470
 AliPHOSClusterizerv1.cxx:471
 AliPHOSClusterizerv1.cxx:472
 AliPHOSClusterizerv1.cxx:473
 AliPHOSClusterizerv1.cxx:474
 AliPHOSClusterizerv1.cxx:475
 AliPHOSClusterizerv1.cxx:476
 AliPHOSClusterizerv1.cxx:477
 AliPHOSClusterizerv1.cxx:478
 AliPHOSClusterizerv1.cxx:479
 AliPHOSClusterizerv1.cxx:480
 AliPHOSClusterizerv1.cxx:481
 AliPHOSClusterizerv1.cxx:482
 AliPHOSClusterizerv1.cxx:483
 AliPHOSClusterizerv1.cxx:484
 AliPHOSClusterizerv1.cxx:485
 AliPHOSClusterizerv1.cxx:486
 AliPHOSClusterizerv1.cxx:487
 AliPHOSClusterizerv1.cxx:488
 AliPHOSClusterizerv1.cxx:489
 AliPHOSClusterizerv1.cxx:490
 AliPHOSClusterizerv1.cxx:491
 AliPHOSClusterizerv1.cxx:492
 AliPHOSClusterizerv1.cxx:493
 AliPHOSClusterizerv1.cxx:494
 AliPHOSClusterizerv1.cxx:495
 AliPHOSClusterizerv1.cxx:496
 AliPHOSClusterizerv1.cxx:497
 AliPHOSClusterizerv1.cxx:498
 AliPHOSClusterizerv1.cxx:499
 AliPHOSClusterizerv1.cxx:500
 AliPHOSClusterizerv1.cxx:501
 AliPHOSClusterizerv1.cxx:502
 AliPHOSClusterizerv1.cxx:503
 AliPHOSClusterizerv1.cxx:504
 AliPHOSClusterizerv1.cxx:505
 AliPHOSClusterizerv1.cxx:506
 AliPHOSClusterizerv1.cxx:507
 AliPHOSClusterizerv1.cxx:508
 AliPHOSClusterizerv1.cxx:509
 AliPHOSClusterizerv1.cxx:510
 AliPHOSClusterizerv1.cxx:511
 AliPHOSClusterizerv1.cxx:512
 AliPHOSClusterizerv1.cxx:513
 AliPHOSClusterizerv1.cxx:514
 AliPHOSClusterizerv1.cxx:515
 AliPHOSClusterizerv1.cxx:516
 AliPHOSClusterizerv1.cxx:517
 AliPHOSClusterizerv1.cxx:518
 AliPHOSClusterizerv1.cxx:519
 AliPHOSClusterizerv1.cxx:520
 AliPHOSClusterizerv1.cxx:521
 AliPHOSClusterizerv1.cxx:522
 AliPHOSClusterizerv1.cxx:523
 AliPHOSClusterizerv1.cxx:524
 AliPHOSClusterizerv1.cxx:525
 AliPHOSClusterizerv1.cxx:526
 AliPHOSClusterizerv1.cxx:527
 AliPHOSClusterizerv1.cxx:528
 AliPHOSClusterizerv1.cxx:529
 AliPHOSClusterizerv1.cxx:530
 AliPHOSClusterizerv1.cxx:531
 AliPHOSClusterizerv1.cxx:532
 AliPHOSClusterizerv1.cxx:533
 AliPHOSClusterizerv1.cxx:534
 AliPHOSClusterizerv1.cxx:535
 AliPHOSClusterizerv1.cxx:536
 AliPHOSClusterizerv1.cxx:537
 AliPHOSClusterizerv1.cxx:538
 AliPHOSClusterizerv1.cxx:539
 AliPHOSClusterizerv1.cxx:540
 AliPHOSClusterizerv1.cxx:541
 AliPHOSClusterizerv1.cxx:542
 AliPHOSClusterizerv1.cxx:543
 AliPHOSClusterizerv1.cxx:544
 AliPHOSClusterizerv1.cxx:545
 AliPHOSClusterizerv1.cxx:546
 AliPHOSClusterizerv1.cxx:547
 AliPHOSClusterizerv1.cxx:548
 AliPHOSClusterizerv1.cxx:549
 AliPHOSClusterizerv1.cxx:550
 AliPHOSClusterizerv1.cxx:551
 AliPHOSClusterizerv1.cxx:552
 AliPHOSClusterizerv1.cxx:553
 AliPHOSClusterizerv1.cxx:554
 AliPHOSClusterizerv1.cxx:555
 AliPHOSClusterizerv1.cxx:556
 AliPHOSClusterizerv1.cxx:557
 AliPHOSClusterizerv1.cxx:558
 AliPHOSClusterizerv1.cxx:559
 AliPHOSClusterizerv1.cxx:560
 AliPHOSClusterizerv1.cxx:561
 AliPHOSClusterizerv1.cxx:562
 AliPHOSClusterizerv1.cxx:563
 AliPHOSClusterizerv1.cxx:564
 AliPHOSClusterizerv1.cxx:565
 AliPHOSClusterizerv1.cxx:566
 AliPHOSClusterizerv1.cxx:567
 AliPHOSClusterizerv1.cxx:568
 AliPHOSClusterizerv1.cxx:569
 AliPHOSClusterizerv1.cxx:570
 AliPHOSClusterizerv1.cxx:571
 AliPHOSClusterizerv1.cxx:572
 AliPHOSClusterizerv1.cxx:573
 AliPHOSClusterizerv1.cxx:574
 AliPHOSClusterizerv1.cxx:575
 AliPHOSClusterizerv1.cxx:576
 AliPHOSClusterizerv1.cxx:577
 AliPHOSClusterizerv1.cxx:578
 AliPHOSClusterizerv1.cxx:579
 AliPHOSClusterizerv1.cxx:580
 AliPHOSClusterizerv1.cxx:581
 AliPHOSClusterizerv1.cxx:582
 AliPHOSClusterizerv1.cxx:583
 AliPHOSClusterizerv1.cxx:584
 AliPHOSClusterizerv1.cxx:585
 AliPHOSClusterizerv1.cxx:586
 AliPHOSClusterizerv1.cxx:587
 AliPHOSClusterizerv1.cxx:588
 AliPHOSClusterizerv1.cxx:589
 AliPHOSClusterizerv1.cxx:590
 AliPHOSClusterizerv1.cxx:591
 AliPHOSClusterizerv1.cxx:592
 AliPHOSClusterizerv1.cxx:593
 AliPHOSClusterizerv1.cxx:594
 AliPHOSClusterizerv1.cxx:595
 AliPHOSClusterizerv1.cxx:596
 AliPHOSClusterizerv1.cxx:597
 AliPHOSClusterizerv1.cxx:598
 AliPHOSClusterizerv1.cxx:599
 AliPHOSClusterizerv1.cxx:600
 AliPHOSClusterizerv1.cxx:601
 AliPHOSClusterizerv1.cxx:602
 AliPHOSClusterizerv1.cxx:603
 AliPHOSClusterizerv1.cxx:604
 AliPHOSClusterizerv1.cxx:605
 AliPHOSClusterizerv1.cxx:606
 AliPHOSClusterizerv1.cxx:607
 AliPHOSClusterizerv1.cxx:608
 AliPHOSClusterizerv1.cxx:609
 AliPHOSClusterizerv1.cxx:610
 AliPHOSClusterizerv1.cxx:611
 AliPHOSClusterizerv1.cxx:612
 AliPHOSClusterizerv1.cxx:613
 AliPHOSClusterizerv1.cxx:614
 AliPHOSClusterizerv1.cxx:615
 AliPHOSClusterizerv1.cxx:616
 AliPHOSClusterizerv1.cxx:617
 AliPHOSClusterizerv1.cxx:618
 AliPHOSClusterizerv1.cxx:619
 AliPHOSClusterizerv1.cxx:620
 AliPHOSClusterizerv1.cxx:621
 AliPHOSClusterizerv1.cxx:622
 AliPHOSClusterizerv1.cxx:623
 AliPHOSClusterizerv1.cxx:624
 AliPHOSClusterizerv1.cxx:625
 AliPHOSClusterizerv1.cxx:626
 AliPHOSClusterizerv1.cxx:627
 AliPHOSClusterizerv1.cxx:628
 AliPHOSClusterizerv1.cxx:629
 AliPHOSClusterizerv1.cxx:630
 AliPHOSClusterizerv1.cxx:631
 AliPHOSClusterizerv1.cxx:632
 AliPHOSClusterizerv1.cxx:633
 AliPHOSClusterizerv1.cxx:634
 AliPHOSClusterizerv1.cxx:635
 AliPHOSClusterizerv1.cxx:636
 AliPHOSClusterizerv1.cxx:637
 AliPHOSClusterizerv1.cxx:638
 AliPHOSClusterizerv1.cxx:639
 AliPHOSClusterizerv1.cxx:640
 AliPHOSClusterizerv1.cxx:641
 AliPHOSClusterizerv1.cxx:642
 AliPHOSClusterizerv1.cxx:643
 AliPHOSClusterizerv1.cxx:644
 AliPHOSClusterizerv1.cxx:645
 AliPHOSClusterizerv1.cxx:646
 AliPHOSClusterizerv1.cxx:647
 AliPHOSClusterizerv1.cxx:648
 AliPHOSClusterizerv1.cxx:649
 AliPHOSClusterizerv1.cxx:650
 AliPHOSClusterizerv1.cxx:651
 AliPHOSClusterizerv1.cxx:652
 AliPHOSClusterizerv1.cxx:653
 AliPHOSClusterizerv1.cxx:654
 AliPHOSClusterizerv1.cxx:655
 AliPHOSClusterizerv1.cxx:656
 AliPHOSClusterizerv1.cxx:657
 AliPHOSClusterizerv1.cxx:658
 AliPHOSClusterizerv1.cxx:659
 AliPHOSClusterizerv1.cxx:660
 AliPHOSClusterizerv1.cxx:661
 AliPHOSClusterizerv1.cxx:662
 AliPHOSClusterizerv1.cxx:663
 AliPHOSClusterizerv1.cxx:664
 AliPHOSClusterizerv1.cxx:665
 AliPHOSClusterizerv1.cxx:666
 AliPHOSClusterizerv1.cxx:667
 AliPHOSClusterizerv1.cxx:668
 AliPHOSClusterizerv1.cxx:669
 AliPHOSClusterizerv1.cxx:670
 AliPHOSClusterizerv1.cxx:671
 AliPHOSClusterizerv1.cxx:672
 AliPHOSClusterizerv1.cxx:673
 AliPHOSClusterizerv1.cxx:674
 AliPHOSClusterizerv1.cxx:675
 AliPHOSClusterizerv1.cxx:676
 AliPHOSClusterizerv1.cxx:677
 AliPHOSClusterizerv1.cxx:678
 AliPHOSClusterizerv1.cxx:679
 AliPHOSClusterizerv1.cxx:680
 AliPHOSClusterizerv1.cxx:681
 AliPHOSClusterizerv1.cxx:682
 AliPHOSClusterizerv1.cxx:683
 AliPHOSClusterizerv1.cxx:684
 AliPHOSClusterizerv1.cxx:685
 AliPHOSClusterizerv1.cxx:686
 AliPHOSClusterizerv1.cxx:687
 AliPHOSClusterizerv1.cxx:688
 AliPHOSClusterizerv1.cxx:689
 AliPHOSClusterizerv1.cxx:690
 AliPHOSClusterizerv1.cxx:691
 AliPHOSClusterizerv1.cxx:692
 AliPHOSClusterizerv1.cxx:693
 AliPHOSClusterizerv1.cxx:694
 AliPHOSClusterizerv1.cxx:695
 AliPHOSClusterizerv1.cxx:696
 AliPHOSClusterizerv1.cxx:697
 AliPHOSClusterizerv1.cxx:698
 AliPHOSClusterizerv1.cxx:699
 AliPHOSClusterizerv1.cxx:700
 AliPHOSClusterizerv1.cxx:701
 AliPHOSClusterizerv1.cxx:702
 AliPHOSClusterizerv1.cxx:703
 AliPHOSClusterizerv1.cxx:704
 AliPHOSClusterizerv1.cxx:705
 AliPHOSClusterizerv1.cxx:706
 AliPHOSClusterizerv1.cxx:707
 AliPHOSClusterizerv1.cxx:708
 AliPHOSClusterizerv1.cxx:709
 AliPHOSClusterizerv1.cxx:710
 AliPHOSClusterizerv1.cxx:711
 AliPHOSClusterizerv1.cxx:712
 AliPHOSClusterizerv1.cxx:713
 AliPHOSClusterizerv1.cxx:714
 AliPHOSClusterizerv1.cxx:715
 AliPHOSClusterizerv1.cxx:716
 AliPHOSClusterizerv1.cxx:717
 AliPHOSClusterizerv1.cxx:718
 AliPHOSClusterizerv1.cxx:719
 AliPHOSClusterizerv1.cxx:720
 AliPHOSClusterizerv1.cxx:721
 AliPHOSClusterizerv1.cxx:722
 AliPHOSClusterizerv1.cxx:723
 AliPHOSClusterizerv1.cxx:724
 AliPHOSClusterizerv1.cxx:725
 AliPHOSClusterizerv1.cxx:726
 AliPHOSClusterizerv1.cxx:727
 AliPHOSClusterizerv1.cxx:728
 AliPHOSClusterizerv1.cxx:729
 AliPHOSClusterizerv1.cxx:730
 AliPHOSClusterizerv1.cxx:731
 AliPHOSClusterizerv1.cxx:732
 AliPHOSClusterizerv1.cxx:733
 AliPHOSClusterizerv1.cxx:734
 AliPHOSClusterizerv1.cxx:735
 AliPHOSClusterizerv1.cxx:736
 AliPHOSClusterizerv1.cxx:737
 AliPHOSClusterizerv1.cxx:738
 AliPHOSClusterizerv1.cxx:739
 AliPHOSClusterizerv1.cxx:740
 AliPHOSClusterizerv1.cxx:741
 AliPHOSClusterizerv1.cxx:742
 AliPHOSClusterizerv1.cxx:743
 AliPHOSClusterizerv1.cxx:744
 AliPHOSClusterizerv1.cxx:745
 AliPHOSClusterizerv1.cxx:746
 AliPHOSClusterizerv1.cxx:747
 AliPHOSClusterizerv1.cxx:748
 AliPHOSClusterizerv1.cxx:749
 AliPHOSClusterizerv1.cxx:750
 AliPHOSClusterizerv1.cxx:751
 AliPHOSClusterizerv1.cxx:752
 AliPHOSClusterizerv1.cxx:753
 AliPHOSClusterizerv1.cxx:754
 AliPHOSClusterizerv1.cxx:755
 AliPHOSClusterizerv1.cxx:756
 AliPHOSClusterizerv1.cxx:757
 AliPHOSClusterizerv1.cxx:758
 AliPHOSClusterizerv1.cxx:759
 AliPHOSClusterizerv1.cxx:760
 AliPHOSClusterizerv1.cxx:761
 AliPHOSClusterizerv1.cxx:762
 AliPHOSClusterizerv1.cxx:763
 AliPHOSClusterizerv1.cxx:764
 AliPHOSClusterizerv1.cxx:765
 AliPHOSClusterizerv1.cxx:766
 AliPHOSClusterizerv1.cxx:767
 AliPHOSClusterizerv1.cxx:768
 AliPHOSClusterizerv1.cxx:769
 AliPHOSClusterizerv1.cxx:770
 AliPHOSClusterizerv1.cxx:771
 AliPHOSClusterizerv1.cxx:772
 AliPHOSClusterizerv1.cxx:773
 AliPHOSClusterizerv1.cxx:774
 AliPHOSClusterizerv1.cxx:775
 AliPHOSClusterizerv1.cxx:776
 AliPHOSClusterizerv1.cxx:777
 AliPHOSClusterizerv1.cxx:778
 AliPHOSClusterizerv1.cxx:779
 AliPHOSClusterizerv1.cxx:780
 AliPHOSClusterizerv1.cxx:781
 AliPHOSClusterizerv1.cxx:782
 AliPHOSClusterizerv1.cxx:783
 AliPHOSClusterizerv1.cxx:784
 AliPHOSClusterizerv1.cxx:785
 AliPHOSClusterizerv1.cxx:786
 AliPHOSClusterizerv1.cxx:787
 AliPHOSClusterizerv1.cxx:788
 AliPHOSClusterizerv1.cxx:789
 AliPHOSClusterizerv1.cxx:790
 AliPHOSClusterizerv1.cxx:791
 AliPHOSClusterizerv1.cxx:792
 AliPHOSClusterizerv1.cxx:793
 AliPHOSClusterizerv1.cxx:794
 AliPHOSClusterizerv1.cxx:795
 AliPHOSClusterizerv1.cxx:796
 AliPHOSClusterizerv1.cxx:797
 AliPHOSClusterizerv1.cxx:798
 AliPHOSClusterizerv1.cxx:799
 AliPHOSClusterizerv1.cxx:800
 AliPHOSClusterizerv1.cxx:801
 AliPHOSClusterizerv1.cxx:802
 AliPHOSClusterizerv1.cxx:803
 AliPHOSClusterizerv1.cxx:804
 AliPHOSClusterizerv1.cxx:805
 AliPHOSClusterizerv1.cxx:806
 AliPHOSClusterizerv1.cxx:807
 AliPHOSClusterizerv1.cxx:808
 AliPHOSClusterizerv1.cxx:809
 AliPHOSClusterizerv1.cxx:810
 AliPHOSClusterizerv1.cxx:811
 AliPHOSClusterizerv1.cxx:812
 AliPHOSClusterizerv1.cxx:813
 AliPHOSClusterizerv1.cxx:814
 AliPHOSClusterizerv1.cxx:815
 AliPHOSClusterizerv1.cxx:816
 AliPHOSClusterizerv1.cxx:817
 AliPHOSClusterizerv1.cxx:818
 AliPHOSClusterizerv1.cxx:819
 AliPHOSClusterizerv1.cxx:820
 AliPHOSClusterizerv1.cxx:821
 AliPHOSClusterizerv1.cxx:822
 AliPHOSClusterizerv1.cxx:823
 AliPHOSClusterizerv1.cxx:824
 AliPHOSClusterizerv1.cxx:825
 AliPHOSClusterizerv1.cxx:826
 AliPHOSClusterizerv1.cxx:827
 AliPHOSClusterizerv1.cxx:828
 AliPHOSClusterizerv1.cxx:829
 AliPHOSClusterizerv1.cxx:830
 AliPHOSClusterizerv1.cxx:831
 AliPHOSClusterizerv1.cxx:832
 AliPHOSClusterizerv1.cxx:833
 AliPHOSClusterizerv1.cxx:834
 AliPHOSClusterizerv1.cxx:835
 AliPHOSClusterizerv1.cxx:836
 AliPHOSClusterizerv1.cxx:837
 AliPHOSClusterizerv1.cxx:838
 AliPHOSClusterizerv1.cxx:839
 AliPHOSClusterizerv1.cxx:840
 AliPHOSClusterizerv1.cxx:841
 AliPHOSClusterizerv1.cxx:842
 AliPHOSClusterizerv1.cxx:843
 AliPHOSClusterizerv1.cxx:844
 AliPHOSClusterizerv1.cxx:845
 AliPHOSClusterizerv1.cxx:846
 AliPHOSClusterizerv1.cxx:847
 AliPHOSClusterizerv1.cxx:848
 AliPHOSClusterizerv1.cxx:849
 AliPHOSClusterizerv1.cxx:850
 AliPHOSClusterizerv1.cxx:851
 AliPHOSClusterizerv1.cxx:852
 AliPHOSClusterizerv1.cxx:853
 AliPHOSClusterizerv1.cxx:854
 AliPHOSClusterizerv1.cxx:855
 AliPHOSClusterizerv1.cxx:856
 AliPHOSClusterizerv1.cxx:857
 AliPHOSClusterizerv1.cxx:858
 AliPHOSClusterizerv1.cxx:859
 AliPHOSClusterizerv1.cxx:860
 AliPHOSClusterizerv1.cxx:861
 AliPHOSClusterizerv1.cxx:862
 AliPHOSClusterizerv1.cxx:863
 AliPHOSClusterizerv1.cxx:864
 AliPHOSClusterizerv1.cxx:865
 AliPHOSClusterizerv1.cxx:866
 AliPHOSClusterizerv1.cxx:867
 AliPHOSClusterizerv1.cxx:868
 AliPHOSClusterizerv1.cxx:869
 AliPHOSClusterizerv1.cxx:870
 AliPHOSClusterizerv1.cxx:871
 AliPHOSClusterizerv1.cxx:872
 AliPHOSClusterizerv1.cxx:873
 AliPHOSClusterizerv1.cxx:874
 AliPHOSClusterizerv1.cxx:875
 AliPHOSClusterizerv1.cxx:876
 AliPHOSClusterizerv1.cxx:877
 AliPHOSClusterizerv1.cxx:878
 AliPHOSClusterizerv1.cxx:879
 AliPHOSClusterizerv1.cxx:880
 AliPHOSClusterizerv1.cxx:881
 AliPHOSClusterizerv1.cxx:882
 AliPHOSClusterizerv1.cxx:883
 AliPHOSClusterizerv1.cxx:884
 AliPHOSClusterizerv1.cxx:885
 AliPHOSClusterizerv1.cxx:886
 AliPHOSClusterizerv1.cxx:887
 AliPHOSClusterizerv1.cxx:888
 AliPHOSClusterizerv1.cxx:889
 AliPHOSClusterizerv1.cxx:890
 AliPHOSClusterizerv1.cxx:891
 AliPHOSClusterizerv1.cxx:892
 AliPHOSClusterizerv1.cxx:893
 AliPHOSClusterizerv1.cxx:894
 AliPHOSClusterizerv1.cxx:895
 AliPHOSClusterizerv1.cxx:896
 AliPHOSClusterizerv1.cxx:897
 AliPHOSClusterizerv1.cxx:898
 AliPHOSClusterizerv1.cxx:899
 AliPHOSClusterizerv1.cxx:900
 AliPHOSClusterizerv1.cxx:901
 AliPHOSClusterizerv1.cxx:902
 AliPHOSClusterizerv1.cxx:903
 AliPHOSClusterizerv1.cxx:904
 AliPHOSClusterizerv1.cxx:905
 AliPHOSClusterizerv1.cxx:906
 AliPHOSClusterizerv1.cxx:907
 AliPHOSClusterizerv1.cxx:908
 AliPHOSClusterizerv1.cxx:909
 AliPHOSClusterizerv1.cxx:910
 AliPHOSClusterizerv1.cxx:911
 AliPHOSClusterizerv1.cxx:912
 AliPHOSClusterizerv1.cxx:913
 AliPHOSClusterizerv1.cxx:914
 AliPHOSClusterizerv1.cxx:915
 AliPHOSClusterizerv1.cxx:916
 AliPHOSClusterizerv1.cxx:917
 AliPHOSClusterizerv1.cxx:918
 AliPHOSClusterizerv1.cxx:919
 AliPHOSClusterizerv1.cxx:920
 AliPHOSClusterizerv1.cxx:921
 AliPHOSClusterizerv1.cxx:922
 AliPHOSClusterizerv1.cxx:923
 AliPHOSClusterizerv1.cxx:924
 AliPHOSClusterizerv1.cxx:925
 AliPHOSClusterizerv1.cxx:926
 AliPHOSClusterizerv1.cxx:927
 AliPHOSClusterizerv1.cxx:928
 AliPHOSClusterizerv1.cxx:929
 AliPHOSClusterizerv1.cxx:930
 AliPHOSClusterizerv1.cxx:931
 AliPHOSClusterizerv1.cxx:932
 AliPHOSClusterizerv1.cxx:933
 AliPHOSClusterizerv1.cxx:934
 AliPHOSClusterizerv1.cxx:935
 AliPHOSClusterizerv1.cxx:936
 AliPHOSClusterizerv1.cxx:937
 AliPHOSClusterizerv1.cxx:938
 AliPHOSClusterizerv1.cxx:939
 AliPHOSClusterizerv1.cxx:940
 AliPHOSClusterizerv1.cxx:941
 AliPHOSClusterizerv1.cxx:942
 AliPHOSClusterizerv1.cxx:943
 AliPHOSClusterizerv1.cxx:944
 AliPHOSClusterizerv1.cxx:945
 AliPHOSClusterizerv1.cxx:946
 AliPHOSClusterizerv1.cxx:947
 AliPHOSClusterizerv1.cxx:948
 AliPHOSClusterizerv1.cxx:949
 AliPHOSClusterizerv1.cxx:950
 AliPHOSClusterizerv1.cxx:951
 AliPHOSClusterizerv1.cxx:952
 AliPHOSClusterizerv1.cxx:953
 AliPHOSClusterizerv1.cxx:954
 AliPHOSClusterizerv1.cxx:955
 AliPHOSClusterizerv1.cxx:956
 AliPHOSClusterizerv1.cxx:957
 AliPHOSClusterizerv1.cxx:958
 AliPHOSClusterizerv1.cxx:959
 AliPHOSClusterizerv1.cxx:960
 AliPHOSClusterizerv1.cxx:961
 AliPHOSClusterizerv1.cxx:962
 AliPHOSClusterizerv1.cxx:963
 AliPHOSClusterizerv1.cxx:964
 AliPHOSClusterizerv1.cxx:965
 AliPHOSClusterizerv1.cxx:966
 AliPHOSClusterizerv1.cxx:967
 AliPHOSClusterizerv1.cxx:968
 AliPHOSClusterizerv1.cxx:969
 AliPHOSClusterizerv1.cxx:970
 AliPHOSClusterizerv1.cxx:971
 AliPHOSClusterizerv1.cxx:972
 AliPHOSClusterizerv1.cxx:973
 AliPHOSClusterizerv1.cxx:974
 AliPHOSClusterizerv1.cxx:975
 AliPHOSClusterizerv1.cxx:976
 AliPHOSClusterizerv1.cxx:977
 AliPHOSClusterizerv1.cxx:978
 AliPHOSClusterizerv1.cxx:979
 AliPHOSClusterizerv1.cxx:980
 AliPHOSClusterizerv1.cxx:981
 AliPHOSClusterizerv1.cxx:982
 AliPHOSClusterizerv1.cxx:983
 AliPHOSClusterizerv1.cxx:984
 AliPHOSClusterizerv1.cxx:985
 AliPHOSClusterizerv1.cxx:986
 AliPHOSClusterizerv1.cxx:987
 AliPHOSClusterizerv1.cxx:988
 AliPHOSClusterizerv1.cxx:989
 AliPHOSClusterizerv1.cxx:990
 AliPHOSClusterizerv1.cxx:991
 AliPHOSClusterizerv1.cxx:992
 AliPHOSClusterizerv1.cxx:993
 AliPHOSClusterizerv1.cxx:994
 AliPHOSClusterizerv1.cxx:995
 AliPHOSClusterizerv1.cxx:996
 AliPHOSClusterizerv1.cxx:997
 AliPHOSClusterizerv1.cxx:998
 AliPHOSClusterizerv1.cxx:999
 AliPHOSClusterizerv1.cxx:1000
 AliPHOSClusterizerv1.cxx:1001
 AliPHOSClusterizerv1.cxx:1002
 AliPHOSClusterizerv1.cxx:1003
 AliPHOSClusterizerv1.cxx:1004
 AliPHOSClusterizerv1.cxx:1005
 AliPHOSClusterizerv1.cxx:1006
 AliPHOSClusterizerv1.cxx:1007
 AliPHOSClusterizerv1.cxx:1008
 AliPHOSClusterizerv1.cxx:1009
 AliPHOSClusterizerv1.cxx:1010
 AliPHOSClusterizerv1.cxx:1011
 AliPHOSClusterizerv1.cxx:1012
 AliPHOSClusterizerv1.cxx:1013
 AliPHOSClusterizerv1.cxx:1014
 AliPHOSClusterizerv1.cxx:1015
 AliPHOSClusterizerv1.cxx:1016
 AliPHOSClusterizerv1.cxx:1017
 AliPHOSClusterizerv1.cxx:1018
 AliPHOSClusterizerv1.cxx:1019
 AliPHOSClusterizerv1.cxx:1020
 AliPHOSClusterizerv1.cxx:1021
 AliPHOSClusterizerv1.cxx:1022
 AliPHOSClusterizerv1.cxx:1023
 AliPHOSClusterizerv1.cxx:1024
 AliPHOSClusterizerv1.cxx:1025
 AliPHOSClusterizerv1.cxx:1026
 AliPHOSClusterizerv1.cxx:1027
 AliPHOSClusterizerv1.cxx:1028
 AliPHOSClusterizerv1.cxx:1029
 AliPHOSClusterizerv1.cxx:1030
 AliPHOSClusterizerv1.cxx:1031
 AliPHOSClusterizerv1.cxx:1032
 AliPHOSClusterizerv1.cxx:1033
 AliPHOSClusterizerv1.cxx:1034
 AliPHOSClusterizerv1.cxx:1035
 AliPHOSClusterizerv1.cxx:1036
 AliPHOSClusterizerv1.cxx:1037
 AliPHOSClusterizerv1.cxx:1038
 AliPHOSClusterizerv1.cxx:1039
 AliPHOSClusterizerv1.cxx:1040
 AliPHOSClusterizerv1.cxx:1041
 AliPHOSClusterizerv1.cxx:1042
 AliPHOSClusterizerv1.cxx:1043
 AliPHOSClusterizerv1.cxx:1044
 AliPHOSClusterizerv1.cxx:1045
 AliPHOSClusterizerv1.cxx:1046
 AliPHOSClusterizerv1.cxx:1047
 AliPHOSClusterizerv1.cxx:1048
 AliPHOSClusterizerv1.cxx:1049
 AliPHOSClusterizerv1.cxx:1050
 AliPHOSClusterizerv1.cxx:1051
 AliPHOSClusterizerv1.cxx:1052
 AliPHOSClusterizerv1.cxx:1053
 AliPHOSClusterizerv1.cxx:1054
 AliPHOSClusterizerv1.cxx:1055
 AliPHOSClusterizerv1.cxx:1056
 AliPHOSClusterizerv1.cxx:1057
 AliPHOSClusterizerv1.cxx:1058
 AliPHOSClusterizerv1.cxx:1059
 AliPHOSClusterizerv1.cxx:1060
 AliPHOSClusterizerv1.cxx:1061
 AliPHOSClusterizerv1.cxx:1062
 AliPHOSClusterizerv1.cxx:1063
 AliPHOSClusterizerv1.cxx:1064
 AliPHOSClusterizerv1.cxx:1065
 AliPHOSClusterizerv1.cxx:1066
 AliPHOSClusterizerv1.cxx:1067
 AliPHOSClusterizerv1.cxx:1068
 AliPHOSClusterizerv1.cxx:1069
 AliPHOSClusterizerv1.cxx:1070
 AliPHOSClusterizerv1.cxx:1071
 AliPHOSClusterizerv1.cxx:1072
 AliPHOSClusterizerv1.cxx:1073
 AliPHOSClusterizerv1.cxx:1074
 AliPHOSClusterizerv1.cxx:1075
 AliPHOSClusterizerv1.cxx:1076
 AliPHOSClusterizerv1.cxx:1077
 AliPHOSClusterizerv1.cxx:1078
 AliPHOSClusterizerv1.cxx:1079
 AliPHOSClusterizerv1.cxx:1080
 AliPHOSClusterizerv1.cxx:1081
 AliPHOSClusterizerv1.cxx:1082
 AliPHOSClusterizerv1.cxx:1083
 AliPHOSClusterizerv1.cxx:1084
 AliPHOSClusterizerv1.cxx:1085
 AliPHOSClusterizerv1.cxx:1086
 AliPHOSClusterizerv1.cxx:1087
 AliPHOSClusterizerv1.cxx:1088
 AliPHOSClusterizerv1.cxx:1089
 AliPHOSClusterizerv1.cxx:1090
 AliPHOSClusterizerv1.cxx:1091
 AliPHOSClusterizerv1.cxx:1092
 AliPHOSClusterizerv1.cxx:1093
 AliPHOSClusterizerv1.cxx:1094
 AliPHOSClusterizerv1.cxx:1095
 AliPHOSClusterizerv1.cxx:1096
 AliPHOSClusterizerv1.cxx:1097
 AliPHOSClusterizerv1.cxx:1098
 AliPHOSClusterizerv1.cxx:1099
 AliPHOSClusterizerv1.cxx:1100
 AliPHOSClusterizerv1.cxx:1101
 AliPHOSClusterizerv1.cxx:1102
 AliPHOSClusterizerv1.cxx:1103
 AliPHOSClusterizerv1.cxx:1104
 AliPHOSClusterizerv1.cxx:1105
 AliPHOSClusterizerv1.cxx:1106
 AliPHOSClusterizerv1.cxx:1107
 AliPHOSClusterizerv1.cxx:1108
 AliPHOSClusterizerv1.cxx:1109
 AliPHOSClusterizerv1.cxx:1110
 AliPHOSClusterizerv1.cxx:1111
 AliPHOSClusterizerv1.cxx:1112
 AliPHOSClusterizerv1.cxx:1113
 AliPHOSClusterizerv1.cxx:1114
 AliPHOSClusterizerv1.cxx:1115
 AliPHOSClusterizerv1.cxx:1116
 AliPHOSClusterizerv1.cxx:1117
 AliPHOSClusterizerv1.cxx:1118
 AliPHOSClusterizerv1.cxx:1119
 AliPHOSClusterizerv1.cxx:1120
 AliPHOSClusterizerv1.cxx:1121
 AliPHOSClusterizerv1.cxx:1122
 AliPHOSClusterizerv1.cxx:1123
 AliPHOSClusterizerv1.cxx:1124
 AliPHOSClusterizerv1.cxx:1125
 AliPHOSClusterizerv1.cxx:1126
 AliPHOSClusterizerv1.cxx:1127
 AliPHOSClusterizerv1.cxx:1128
 AliPHOSClusterizerv1.cxx:1129
 AliPHOSClusterizerv1.cxx:1130
 AliPHOSClusterizerv1.cxx:1131
 AliPHOSClusterizerv1.cxx:1132
 AliPHOSClusterizerv1.cxx:1133
 AliPHOSClusterizerv1.cxx:1134
 AliPHOSClusterizerv1.cxx:1135
 AliPHOSClusterizerv1.cxx:1136
 AliPHOSClusterizerv1.cxx:1137
 AliPHOSClusterizerv1.cxx:1138
 AliPHOSClusterizerv1.cxx:1139
 AliPHOSClusterizerv1.cxx:1140
 AliPHOSClusterizerv1.cxx:1141
 AliPHOSClusterizerv1.cxx:1142
 AliPHOSClusterizerv1.cxx:1143
 AliPHOSClusterizerv1.cxx:1144
 AliPHOSClusterizerv1.cxx:1145
 AliPHOSClusterizerv1.cxx:1146
 AliPHOSClusterizerv1.cxx:1147
 AliPHOSClusterizerv1.cxx:1148
 AliPHOSClusterizerv1.cxx:1149
 AliPHOSClusterizerv1.cxx:1150
 AliPHOSClusterizerv1.cxx:1151
 AliPHOSClusterizerv1.cxx:1152
 AliPHOSClusterizerv1.cxx:1153
 AliPHOSClusterizerv1.cxx:1154
 AliPHOSClusterizerv1.cxx:1155
 AliPHOSClusterizerv1.cxx:1156
 AliPHOSClusterizerv1.cxx:1157
 AliPHOSClusterizerv1.cxx:1158
 AliPHOSClusterizerv1.cxx:1159
 AliPHOSClusterizerv1.cxx:1160
 AliPHOSClusterizerv1.cxx:1161
 AliPHOSClusterizerv1.cxx:1162
 AliPHOSClusterizerv1.cxx:1163
 AliPHOSClusterizerv1.cxx:1164