ROOT logo
/**************************************************************************
 * Copyright(c) 1998-2003, 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.                  *
 **************************************************************************/
////////////////////////////////////////////////////////////////////////////
//            Implementation of the ITS clusterer V2 class                //
//                                                                        //
//          Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch            //
//          Unfolding switch from AliITSRecoParam: D. Elia, INFN Bari     //
//                                                                        //
////////////////////////////////////////////////////////////////////////////


#include <TGeoGlobalMagField.h>
#include "AliITSCalibrationSPD.h"
#include "AliITSClusterFinderV2SPD.h"
#include "AliITSRecPoint.h"
#include "AliITSgeomTGeo.h"
#include "AliITSDetTypeRec.h"
#include "AliITSReconstructor.h"
#include "AliRawReader.h"
#include "AliITSRawStreamSPD.h"
#include <TClonesArray.h>
#include "AliITSdigitSPD.h"
#include "AliITSFOSignalsSPD.h"
#include "AliITSRecPointContainer.h"
#include "AliMagF.h"
#include "AliITSsegmentationSPD.h"

ClassImp(AliITSClusterFinderV2SPD)

//__________________________________________________________________________
AliITSClusterFinderV2SPD::AliITSClusterFinderV2SPD(AliITSDetTypeRec* dettyp):AliITSClusterFinder(dettyp),
fLastSPD1(AliITSgeomTGeo::GetModuleIndex(2,1,1)-1),
fNySPD(256),
fNzSPD(160),
fYpitchSPD(0.0050),
fZ1pitchSPD(0.0425),
fZ2pitchSPD(0.0625),
fHwSPD(0.64),
fHlSPD(3.48){

  //Default constructor

  fYSPD[0]=0.5*fYpitchSPD;
  for (Int_t m=1; m<fNySPD; m++) fYSPD[m]=fYSPD[m-1]+fYpitchSPD; 
  fZSPD[0]=fZ1pitchSPD;
  for (Int_t m=1; m<fNzSPD; m++) {
    Double_t dz=fZ1pitchSPD;
    if (m==31 || m==32 || m==63  || m==64  || m==95 || m==96 || 
        m==127 || m==128) dz=fZ2pitchSPD; 
    fZSPD[m]=fZSPD[m-1]+dz;
  }
  for (Int_t m=0; m<fNzSPD; m++) {
    Double_t dz=0.5*fZ1pitchSPD;
    if (m==31 || m==32 || m==63  || m==64  || m==95 || m==96 || 
        m==127 || m==128) dz=0.5*fZ2pitchSPD; 
    fZSPD[m]-=dz;
  }

}
//__________________________________________________________________________
void AliITSClusterFinderV2SPD::FindRawClusters(Int_t mod){
  //Find clusters V2
  SetModule(mod);
  FindClustersSPD(fDigits);

}
//__________________________________________________________________________
void AliITSClusterFinderV2SPD::RawdataToClusters(AliRawReader* rawReader){
  //------------------------------------------------------------
  // This function creates ITS clusters from raw data
  //------------------------------------------------------------
  rawReader->Reset();
  fNClusters = 0; //RS
  AliITSRawStreamSPD inputSPD(rawReader);
  FindClustersSPD(&inputSPD);

}
//__________________________________________________________________________
Int_t AliITSClusterFinderV2SPD::ClustersSPD(AliBin* bins, TClonesArray* digits,TClonesArray* clusters,Int_t maxBins,Int_t nzbins,Int_t iModule,Bool_t rawdata){
  
  //Cluster finder for SPD (from digits and from rawdata)
  const Double_t kmictocm = 1.0e-4; // convert microns to cm.
  const Double_t defaultField = 5.0; // default Bz value at which Tan(theta_Lorentz) is given in RecoParam

  static AliITSRecoParam *repa = NULL;
  if(!repa){
    repa = (AliITSRecoParam*) AliITSReconstructor::GetRecoParam();
    if(!repa){
      repa = AliITSRecoParam::GetHighFluxParam();
      AliWarning("Using default AliITSRecoParam class");
    }
  }
  const TGeoHMatrix *mT2L=AliITSgeomTGeo::GetTracking2LocalMatrix(iModule);

  // Lorentz angle correction
  Double_t tanLorentzAngle=0; 
  AliITSsegmentationSPD *seg = (AliITSsegmentationSPD*)(GetDetTypeRec()->GetSegmentationModel(0));
  Double_t thick = 0.5*kmictocm*seg->Dy();  // Half Thickness in cm
  if(repa->GetCorrectLorentzAngleSPD()) { // only if CorrectLorentzAngleSPD required
    // here retrieve the value of the field
    AliMagF* field = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
    if (field == 0) {
      AliError("Cannot get magnetic field from TGeoGlobalMagField");
    }
    else {
      Float_t magField = field->SolenoidField();
      tanLorentzAngle=repa->GetTanLorentzAngleHolesSPD() * magField / defaultField ;
    }
  }
  //

   if (repa->GetSPDRemoveNoisyFlag()) {
    // Loop on noisy pixels and reset them
    AliITSCalibrationSPD *cal =  
      (AliITSCalibrationSPD*) fDetTypeRec->GetCalibrationModel(iModule);
    for(Int_t ipix = 0; ipix<cal->GetNrBad(); ipix++){
      Int_t row, col;
      cal->GetBadPixel(ipix,row,col);
      //PH      printf(" module %d   row %d  col %d \n",iModule,row,col);
      Int_t index = (row+1) * nzbins + (col+1);
      
      bins[index].SetQ(0);
      bins[index].SetMask(0xFFFFFFFE);
    }
  }
  
    if (repa->GetSPDRemoveDeadFlag()) {
    // Loop on dead pixels and reset them
    AliITSCalibrationSPD *cal =  
      (AliITSCalibrationSPD*) fDetTypeRec->GetSPDDeadModel(iModule); 
    if (cal->IsBad()) return 0; // if all ladder is dead, return to save time
    for(Int_t ipix = 0; ipix<cal->GetNrBad(); ipix++){
      Int_t row, col;
      cal->GetBadPixel(ipix,row,col);
      Int_t index = (row+1) * nzbins + (col+1);
      bins[index].SetQ(0);
      bins[index].SetMask(0xFFFFFFFE);
    }
    AliITSCalibrationSPD *calSparse = (AliITSCalibrationSPD*) fDetTypeRec->GetSPDSparseDeadModel(iModule);
    for(Int_t ipix = 0; ipix<calSparse->GetNrBad(); ipix++){
      Int_t row, col;
      calSparse->GetBadPixel(ipix,row,col);
      Int_t index = (row+1) * nzbins + (col+1);
      bins[index].SetQ(0);
      bins[index].SetMask(0xFFFFFFFE);
    }

  }
  
  Int_t nclu=0;
  for(Int_t iBin =0; iBin < maxBins;iBin++){
    if(bins[iBin].IsUsed()) continue;
    Int_t nBins = 0; 
    Int_t idxBins[200];
    FindCluster(iBin,nzbins,bins,nBins,idxBins);
    if (nBins == 200){
      Error("ClustersSPD","SPD Too big cluster !\n"); 
      continue;
    }
    Int_t milab[10];
    for(Int_t ilab=0;ilab<10;ilab++){
      milab[ilab]=-2;
    }
    if(rawdata){
      milab[3]=fNdet[iModule];
    }
    Int_t ymin,ymax,zmin,zmax;
    if(rawdata){
      ymin = (idxBins[0] / nzbins) - 1;
      ymax = ymin;
      zmin = (idxBins[0] % nzbins) - 1;
      zmax = zmin;
    }
    else{
      AliITSdigitSPD* dig = (AliITSdigitSPD*)digits->UncheckedAt(idxBins[0]);
      ymin=dig->GetCoord2();
      ymax=ymin;
      zmin=dig->GetCoord1();
      zmax=zmin;
    }
    //PH     if(iModule == 24 || iModule == 25)  printf("\n");
    for (Int_t idx = 0; idx < nBins; idx++) {
      Int_t iy;
      Int_t iz; 
      if(rawdata){
	iy  = (idxBins[idx] / nzbins) - 1;
	iz  = (idxBins[idx] % nzbins) - 1;
      }
      else{
	AliITSdigitSPD* dig = (AliITSdigitSPD*)digits->UncheckedAt(idxBins[idx]);
	iy = dig->GetCoord2();
	iz = dig->GetCoord1();
        //if(iModule == 24 || iModule == 25) printf(" ||  iy %d   iz %d  in Module %d \n",iy,iz,iModule);
      }
      if (ymin > iy) ymin = iy;
      if (ymax < iy) ymax = iy;
      if (zmin > iz) zmin = iz;
      if (zmax < iz) zmax = iz;

    }
    if(!rawdata){
      for(Int_t l=0;l<nBins;l++){
	AliITSdigitSPD* dig = (AliITSdigitSPD*)digits->UncheckedAt(idxBins[l]);
	for(Int_t dlab=0;dlab<10;dlab++){
	  Int_t digitlab = (dig->GetTracks())[dlab];
	  if(digitlab<0) continue;
	  AddLabel(milab,digitlab);
	}
	if (milab[9]>0) CheckLabels2(milab);
      }
      CheckLabels2(milab);
    }
    
    Int_t idy =0; //max 2 clusters
    if((iModule <= fLastSPD1) &&idy<3) idy=3;
    if((iModule > fLastSPD1) &&idy<4) idy=4;
    Int_t idz=3;

    // Switch the unfolding OFF/ON
    if(!repa->GetUseUnfoldingInClusterFinderSPD()) {
      idy=ymax-ymin+1;
      idz=zmax-zmin+1;
    }
    //
    for(Int_t iiz=zmin; iiz<=zmax;iiz+=idz){
      for(Int_t iiy=ymin;iiy<=ymax;iiy+=idy){

	Int_t ndigits=0;
	Float_t y=0.,z=0.,q=0.;
	for(Int_t idx=0;idx<nBins;idx++){
	  Int_t iy;
	  Int_t iz; 
	  if(rawdata){
	    iy  = (idxBins[idx] / nzbins)-1;
	    iz  = (idxBins[idx] % nzbins)-1;
	  }
	  else{
	    AliITSdigitSPD* dig = (AliITSdigitSPD*)digits->UncheckedAt(idxBins[idx]);
	    iy = dig->GetCoord2();
	    iz = dig->GetCoord1();
	  }
	  if(zmax-zmin>=idz || ymax-ymin>=idy){
	    if(TMath::Abs(iy-iiy)>0.75*idy) continue;
	    if(TMath::Abs(iz-iiz)>0.75*idz) continue;
	  }
	  ndigits++;
	  Float_t qBin=0.;
	  if(rawdata) {
	    qBin = bins[idxBins[idx]].GetQ();
	    if (fRawID2ClusID) { // RS: Register cluster id in raw words list
	      int rwid = bins[idxBins[idx]].GetRawID();
	      if (fRawID2ClusID->GetSize()<=rwid) fRawID2ClusID->Set( (rwid+10)<<1 );	      
	      (*fRawID2ClusID)[rwid] = milab[0] = fNClusters+1; // RS: store clID+1 as a reference to the cluster
	    }
	  }
	  if(!rawdata){
	    AliITSdigitSPD* dig = (AliITSdigitSPD*)digits->UncheckedAt(idxBins[idx]);
	    qBin = (Float_t)dig->GetSignal();
	  }
	  y+= qBin * fYSPD[iy];
	  z+= qBin * fZSPD[iz];
	  q+= qBin;	
	}// for idx
	if(ndigits==0) continue;
         
	y /= q;
	z /= q;
	y -= fHwSPD;
	z -= fHlSPD;

        // Lorentz drift effect in local y
        y -= tanLorentzAngle*thick;
        //

	Float_t hit[6]; //y,z,sigma(y)^2, sigma(z)^2, charge
        {
        Double_t loc[3]={y,0.,z},trk[3]={0.,0.,0.};
        mT2L->MasterToLocal(loc,trk);
        hit[0]=trk[1];
        hit[1]=trk[2];
	}
	hit[2] = fYpitchSPD*fYpitchSPD/12.;
	hit[3] = fZ1pitchSPD*fZ1pitchSPD/12.;
	hit[4] = 1.;
	hit[5] = 0.;

	if(!rawdata) milab[3]=fNdet[iModule];
	Int_t info[3] = {ymax-ymin+1,zmax-zmin+1,fNlayer[iModule]};
	if(!rawdata){
	 AliITSRecPoint cl(milab,hit,info);
         cl.SetType(nBins);
	 fDetTypeRec->AddRecPoint(cl);
	}
        else{
	  Int_t label[4]={milab[0],milab[1],milab[2],milab[3]};
          AliITSRecPoint cl(label, hit,info);
          cl.SetType(nBins);
	  new (clusters->AddrAt(nclu)) 
	  AliITSRecPoint(cl);
	} 
	nclu++;
	fNClusters++;
      }// for iiy
    }// for iiz
  }//end for iBin
  return nclu;
  
}
//__________________________________________________________________________
void AliITSClusterFinderV2SPD::FindClustersSPD(AliITSRawStreamSPD* input) 
{
  //------------------------------------------------------------
  // SPD cluster finder for raw data (this method is called once per event)
  // Now also fills fast-or fired map
  //------------------------------------------------------------

  AliITSRecPointContainer* rpc = AliITSRecPointContainer::Instance();  
  Int_t nClustersSPD = 0;
  Int_t kNzBins = fNzSPD + 2;
  Int_t kNyBins = fNySPD + 2;
  Int_t kMaxBin = kNzBins * kNyBins;
  AliBin *binsSPD = new AliBin[kMaxBin];
  AliBin *binsSPDInit = new AliBin[kMaxBin];  
  AliBin* bins = NULL;

  // read raw data input stream
  int countRW = 0; //RS
  if (fRawID2ClusID) fRawID2ClusID->Reset(); //RS if array was provided, we shall store the rawID -> ClusterID
  //
  while (kTRUE) {
    Bool_t next = input->Next();
    if (!next || input->IsNewModule()) {
      Int_t iModule = input->GetPrevModuleID();

      // when all data from a module was read, search for clusters
      if (bins) { 
	TClonesArray* clusters = rpc->UncheckedGetClusters(iModule);
	Int_t nClusters = ClustersSPD(bins,0,clusters,kMaxBin,kNzBins,iModule,kTRUE);
	nClustersSPD += nClusters;
	bins = NULL;
      }

      if (!next) break;
      bins = binsSPD;
      memcpy(binsSPD,binsSPDInit,sizeof(AliBin)*kMaxBin);
    }

    if (next && bins) {      
      // fill the current digit into the bins array
      Int_t index = (input->GetCoord2()+1) * kNzBins + (input->GetCoord1()+1);
      bins[index].SetIndex(index);
      bins[index].SetQ(1);
      bins[index].SetMask(1);
      bins[index].SetRawID(countRW); //RS register raw id
    }
    countRW++; //RS
  }

  delete [] binsSPDInit;
  delete [] binsSPD;
  
  AliDebug(1,Form("found clusters in ITS SPD: %d", nClustersSPD));
  
 
    // Fill the FastOr fired map
  for (UInt_t eq=0; eq<20; eq++) {
    for (UInt_t hs=0; hs<6; hs++) {
      for (UInt_t chip=0; chip<10; chip++) {
        if (input->GetFastOrSignal(eq,hs,chip)) {
	  fDetTypeRec->SetFastOrFiredMapOnline(eq,hs,chip);
        }
      }
    }
  }
  
}
//__________________________________________________________________________
void AliITSClusterFinderV2SPD::FindClustersSPD(TClonesArray *digits) {
  //------------------------------------------------------------
  // SPD cluster finder for digits (this method is called for each module)
  // Now also fills the fast-or fired map
  //------------------------------------------------------------


  Int_t kNzBins = fNzSPD + 2;
  const Int_t kMAXBIN=kNzBins*(fNySPD+2);

  Int_t ndigits=digits->GetEntriesFast();
  AliBin *bins=new AliBin[kMAXBIN];

  Int_t idig;
  AliITSdigitSPD *digit=0;
  for (idig=0; idig<ndigits; idig++) {
    digit=(AliITSdigitSPD*)digits->UncheckedAt(idig);
    Int_t i=digit->GetCoord2()+1;   //y
    Int_t j=digit->GetCoord1()+1;
    Int_t index=i*kNzBins+j;

    bins[index].SetIndex(idig);
    bins[index].SetQ(1);
    bins[index].SetMask(1);
  }

   
  Int_t nClustersSPD = ClustersSPD(bins,digits,0,kMAXBIN,kNzBins,fModule,kFALSE); 
  delete [] bins;

  AliDebug(1,Form("found clusters in ITS SPD: %d", nClustersSPD));
  
    //  Fill the FastOr fired map
  AliITSFOSignalsSPD* foSignals = fDetTypeRec->GetFOSignals();
  if (foSignals) {
    UInt_t eq = AliITSRawStreamSPD::GetOnlineEqIdFromOffline(fModule);
    UInt_t hs = AliITSRawStreamSPD::GetOnlineHSFromOffline(fModule);
    for(UInt_t ch=0; ch<5; ch++) {
      UInt_t chip = AliITSRawStreamSPD::GetOnlineChipFromOffline(fModule,ch*32);
      if (foSignals->GetSignal(eq,hs,chip)) {
	fDetTypeRec->SetFastOrFiredMapOnline(eq,hs,chip);
      }
    }
  }
  
}
 AliITSClusterFinderV2SPD.cxx:1
 AliITSClusterFinderV2SPD.cxx:2
 AliITSClusterFinderV2SPD.cxx:3
 AliITSClusterFinderV2SPD.cxx:4
 AliITSClusterFinderV2SPD.cxx:5
 AliITSClusterFinderV2SPD.cxx:6
 AliITSClusterFinderV2SPD.cxx:7
 AliITSClusterFinderV2SPD.cxx:8
 AliITSClusterFinderV2SPD.cxx:9
 AliITSClusterFinderV2SPD.cxx:10
 AliITSClusterFinderV2SPD.cxx:11
 AliITSClusterFinderV2SPD.cxx:12
 AliITSClusterFinderV2SPD.cxx:13
 AliITSClusterFinderV2SPD.cxx:14
 AliITSClusterFinderV2SPD.cxx:15
 AliITSClusterFinderV2SPD.cxx:16
 AliITSClusterFinderV2SPD.cxx:17
 AliITSClusterFinderV2SPD.cxx:18
 AliITSClusterFinderV2SPD.cxx:19
 AliITSClusterFinderV2SPD.cxx:20
 AliITSClusterFinderV2SPD.cxx:21
 AliITSClusterFinderV2SPD.cxx:22
 AliITSClusterFinderV2SPD.cxx:23
 AliITSClusterFinderV2SPD.cxx:24
 AliITSClusterFinderV2SPD.cxx:25
 AliITSClusterFinderV2SPD.cxx:26
 AliITSClusterFinderV2SPD.cxx:27
 AliITSClusterFinderV2SPD.cxx:28
 AliITSClusterFinderV2SPD.cxx:29
 AliITSClusterFinderV2SPD.cxx:30
 AliITSClusterFinderV2SPD.cxx:31
 AliITSClusterFinderV2SPD.cxx:32
 AliITSClusterFinderV2SPD.cxx:33
 AliITSClusterFinderV2SPD.cxx:34
 AliITSClusterFinderV2SPD.cxx:35
 AliITSClusterFinderV2SPD.cxx:36
 AliITSClusterFinderV2SPD.cxx:37
 AliITSClusterFinderV2SPD.cxx:38
 AliITSClusterFinderV2SPD.cxx:39
 AliITSClusterFinderV2SPD.cxx:40
 AliITSClusterFinderV2SPD.cxx:41
 AliITSClusterFinderV2SPD.cxx:42
 AliITSClusterFinderV2SPD.cxx:43
 AliITSClusterFinderV2SPD.cxx:44
 AliITSClusterFinderV2SPD.cxx:45
 AliITSClusterFinderV2SPD.cxx:46
 AliITSClusterFinderV2SPD.cxx:47
 AliITSClusterFinderV2SPD.cxx:48
 AliITSClusterFinderV2SPD.cxx:49
 AliITSClusterFinderV2SPD.cxx:50
 AliITSClusterFinderV2SPD.cxx:51
 AliITSClusterFinderV2SPD.cxx:52
 AliITSClusterFinderV2SPD.cxx:53
 AliITSClusterFinderV2SPD.cxx:54
 AliITSClusterFinderV2SPD.cxx:55
 AliITSClusterFinderV2SPD.cxx:56
 AliITSClusterFinderV2SPD.cxx:57
 AliITSClusterFinderV2SPD.cxx:58
 AliITSClusterFinderV2SPD.cxx:59
 AliITSClusterFinderV2SPD.cxx:60
 AliITSClusterFinderV2SPD.cxx:61
 AliITSClusterFinderV2SPD.cxx:62
 AliITSClusterFinderV2SPD.cxx:63
 AliITSClusterFinderV2SPD.cxx:64
 AliITSClusterFinderV2SPD.cxx:65
 AliITSClusterFinderV2SPD.cxx:66
 AliITSClusterFinderV2SPD.cxx:67
 AliITSClusterFinderV2SPD.cxx:68
 AliITSClusterFinderV2SPD.cxx:69
 AliITSClusterFinderV2SPD.cxx:70
 AliITSClusterFinderV2SPD.cxx:71
 AliITSClusterFinderV2SPD.cxx:72
 AliITSClusterFinderV2SPD.cxx:73
 AliITSClusterFinderV2SPD.cxx:74
 AliITSClusterFinderV2SPD.cxx:75
 AliITSClusterFinderV2SPD.cxx:76
 AliITSClusterFinderV2SPD.cxx:77
 AliITSClusterFinderV2SPD.cxx:78
 AliITSClusterFinderV2SPD.cxx:79
 AliITSClusterFinderV2SPD.cxx:80
 AliITSClusterFinderV2SPD.cxx:81
 AliITSClusterFinderV2SPD.cxx:82
 AliITSClusterFinderV2SPD.cxx:83
 AliITSClusterFinderV2SPD.cxx:84
 AliITSClusterFinderV2SPD.cxx:85
 AliITSClusterFinderV2SPD.cxx:86
 AliITSClusterFinderV2SPD.cxx:87
 AliITSClusterFinderV2SPD.cxx:88
 AliITSClusterFinderV2SPD.cxx:89
 AliITSClusterFinderV2SPD.cxx:90
 AliITSClusterFinderV2SPD.cxx:91
 AliITSClusterFinderV2SPD.cxx:92
 AliITSClusterFinderV2SPD.cxx:93
 AliITSClusterFinderV2SPD.cxx:94
 AliITSClusterFinderV2SPD.cxx:95
 AliITSClusterFinderV2SPD.cxx:96
 AliITSClusterFinderV2SPD.cxx:97
 AliITSClusterFinderV2SPD.cxx:98
 AliITSClusterFinderV2SPD.cxx:99
 AliITSClusterFinderV2SPD.cxx:100
 AliITSClusterFinderV2SPD.cxx:101
 AliITSClusterFinderV2SPD.cxx:102
 AliITSClusterFinderV2SPD.cxx:103
 AliITSClusterFinderV2SPD.cxx:104
 AliITSClusterFinderV2SPD.cxx:105
 AliITSClusterFinderV2SPD.cxx:106
 AliITSClusterFinderV2SPD.cxx:107
 AliITSClusterFinderV2SPD.cxx:108
 AliITSClusterFinderV2SPD.cxx:109
 AliITSClusterFinderV2SPD.cxx:110
 AliITSClusterFinderV2SPD.cxx:111
 AliITSClusterFinderV2SPD.cxx:112
 AliITSClusterFinderV2SPD.cxx:113
 AliITSClusterFinderV2SPD.cxx:114
 AliITSClusterFinderV2SPD.cxx:115
 AliITSClusterFinderV2SPD.cxx:116
 AliITSClusterFinderV2SPD.cxx:117
 AliITSClusterFinderV2SPD.cxx:118
 AliITSClusterFinderV2SPD.cxx:119
 AliITSClusterFinderV2SPD.cxx:120
 AliITSClusterFinderV2SPD.cxx:121
 AliITSClusterFinderV2SPD.cxx:122
 AliITSClusterFinderV2SPD.cxx:123
 AliITSClusterFinderV2SPD.cxx:124
 AliITSClusterFinderV2SPD.cxx:125
 AliITSClusterFinderV2SPD.cxx:126
 AliITSClusterFinderV2SPD.cxx:127
 AliITSClusterFinderV2SPD.cxx:128
 AliITSClusterFinderV2SPD.cxx:129
 AliITSClusterFinderV2SPD.cxx:130
 AliITSClusterFinderV2SPD.cxx:131
 AliITSClusterFinderV2SPD.cxx:132
 AliITSClusterFinderV2SPD.cxx:133
 AliITSClusterFinderV2SPD.cxx:134
 AliITSClusterFinderV2SPD.cxx:135
 AliITSClusterFinderV2SPD.cxx:136
 AliITSClusterFinderV2SPD.cxx:137
 AliITSClusterFinderV2SPD.cxx:138
 AliITSClusterFinderV2SPD.cxx:139
 AliITSClusterFinderV2SPD.cxx:140
 AliITSClusterFinderV2SPD.cxx:141
 AliITSClusterFinderV2SPD.cxx:142
 AliITSClusterFinderV2SPD.cxx:143
 AliITSClusterFinderV2SPD.cxx:144
 AliITSClusterFinderV2SPD.cxx:145
 AliITSClusterFinderV2SPD.cxx:146
 AliITSClusterFinderV2SPD.cxx:147
 AliITSClusterFinderV2SPD.cxx:148
 AliITSClusterFinderV2SPD.cxx:149
 AliITSClusterFinderV2SPD.cxx:150
 AliITSClusterFinderV2SPD.cxx:151
 AliITSClusterFinderV2SPD.cxx:152
 AliITSClusterFinderV2SPD.cxx:153
 AliITSClusterFinderV2SPD.cxx:154
 AliITSClusterFinderV2SPD.cxx:155
 AliITSClusterFinderV2SPD.cxx:156
 AliITSClusterFinderV2SPD.cxx:157
 AliITSClusterFinderV2SPD.cxx:158
 AliITSClusterFinderV2SPD.cxx:159
 AliITSClusterFinderV2SPD.cxx:160
 AliITSClusterFinderV2SPD.cxx:161
 AliITSClusterFinderV2SPD.cxx:162
 AliITSClusterFinderV2SPD.cxx:163
 AliITSClusterFinderV2SPD.cxx:164
 AliITSClusterFinderV2SPD.cxx:165
 AliITSClusterFinderV2SPD.cxx:166
 AliITSClusterFinderV2SPD.cxx:167
 AliITSClusterFinderV2SPD.cxx:168
 AliITSClusterFinderV2SPD.cxx:169
 AliITSClusterFinderV2SPD.cxx:170
 AliITSClusterFinderV2SPD.cxx:171
 AliITSClusterFinderV2SPD.cxx:172
 AliITSClusterFinderV2SPD.cxx:173
 AliITSClusterFinderV2SPD.cxx:174
 AliITSClusterFinderV2SPD.cxx:175
 AliITSClusterFinderV2SPD.cxx:176
 AliITSClusterFinderV2SPD.cxx:177
 AliITSClusterFinderV2SPD.cxx:178
 AliITSClusterFinderV2SPD.cxx:179
 AliITSClusterFinderV2SPD.cxx:180
 AliITSClusterFinderV2SPD.cxx:181
 AliITSClusterFinderV2SPD.cxx:182
 AliITSClusterFinderV2SPD.cxx:183
 AliITSClusterFinderV2SPD.cxx:184
 AliITSClusterFinderV2SPD.cxx:185
 AliITSClusterFinderV2SPD.cxx:186
 AliITSClusterFinderV2SPD.cxx:187
 AliITSClusterFinderV2SPD.cxx:188
 AliITSClusterFinderV2SPD.cxx:189
 AliITSClusterFinderV2SPD.cxx:190
 AliITSClusterFinderV2SPD.cxx:191
 AliITSClusterFinderV2SPD.cxx:192
 AliITSClusterFinderV2SPD.cxx:193
 AliITSClusterFinderV2SPD.cxx:194
 AliITSClusterFinderV2SPD.cxx:195
 AliITSClusterFinderV2SPD.cxx:196
 AliITSClusterFinderV2SPD.cxx:197
 AliITSClusterFinderV2SPD.cxx:198
 AliITSClusterFinderV2SPD.cxx:199
 AliITSClusterFinderV2SPD.cxx:200
 AliITSClusterFinderV2SPD.cxx:201
 AliITSClusterFinderV2SPD.cxx:202
 AliITSClusterFinderV2SPD.cxx:203
 AliITSClusterFinderV2SPD.cxx:204
 AliITSClusterFinderV2SPD.cxx:205
 AliITSClusterFinderV2SPD.cxx:206
 AliITSClusterFinderV2SPD.cxx:207
 AliITSClusterFinderV2SPD.cxx:208
 AliITSClusterFinderV2SPD.cxx:209
 AliITSClusterFinderV2SPD.cxx:210
 AliITSClusterFinderV2SPD.cxx:211
 AliITSClusterFinderV2SPD.cxx:212
 AliITSClusterFinderV2SPD.cxx:213
 AliITSClusterFinderV2SPD.cxx:214
 AliITSClusterFinderV2SPD.cxx:215
 AliITSClusterFinderV2SPD.cxx:216
 AliITSClusterFinderV2SPD.cxx:217
 AliITSClusterFinderV2SPD.cxx:218
 AliITSClusterFinderV2SPD.cxx:219
 AliITSClusterFinderV2SPD.cxx:220
 AliITSClusterFinderV2SPD.cxx:221
 AliITSClusterFinderV2SPD.cxx:222
 AliITSClusterFinderV2SPD.cxx:223
 AliITSClusterFinderV2SPD.cxx:224
 AliITSClusterFinderV2SPD.cxx:225
 AliITSClusterFinderV2SPD.cxx:226
 AliITSClusterFinderV2SPD.cxx:227
 AliITSClusterFinderV2SPD.cxx:228
 AliITSClusterFinderV2SPD.cxx:229
 AliITSClusterFinderV2SPD.cxx:230
 AliITSClusterFinderV2SPD.cxx:231
 AliITSClusterFinderV2SPD.cxx:232
 AliITSClusterFinderV2SPD.cxx:233
 AliITSClusterFinderV2SPD.cxx:234
 AliITSClusterFinderV2SPD.cxx:235
 AliITSClusterFinderV2SPD.cxx:236
 AliITSClusterFinderV2SPD.cxx:237
 AliITSClusterFinderV2SPD.cxx:238
 AliITSClusterFinderV2SPD.cxx:239
 AliITSClusterFinderV2SPD.cxx:240
 AliITSClusterFinderV2SPD.cxx:241
 AliITSClusterFinderV2SPD.cxx:242
 AliITSClusterFinderV2SPD.cxx:243
 AliITSClusterFinderV2SPD.cxx:244
 AliITSClusterFinderV2SPD.cxx:245
 AliITSClusterFinderV2SPD.cxx:246
 AliITSClusterFinderV2SPD.cxx:247
 AliITSClusterFinderV2SPD.cxx:248
 AliITSClusterFinderV2SPD.cxx:249
 AliITSClusterFinderV2SPD.cxx:250
 AliITSClusterFinderV2SPD.cxx:251
 AliITSClusterFinderV2SPD.cxx:252
 AliITSClusterFinderV2SPD.cxx:253
 AliITSClusterFinderV2SPD.cxx:254
 AliITSClusterFinderV2SPD.cxx:255
 AliITSClusterFinderV2SPD.cxx:256
 AliITSClusterFinderV2SPD.cxx:257
 AliITSClusterFinderV2SPD.cxx:258
 AliITSClusterFinderV2SPD.cxx:259
 AliITSClusterFinderV2SPD.cxx:260
 AliITSClusterFinderV2SPD.cxx:261
 AliITSClusterFinderV2SPD.cxx:262
 AliITSClusterFinderV2SPD.cxx:263
 AliITSClusterFinderV2SPD.cxx:264
 AliITSClusterFinderV2SPD.cxx:265
 AliITSClusterFinderV2SPD.cxx:266
 AliITSClusterFinderV2SPD.cxx:267
 AliITSClusterFinderV2SPD.cxx:268
 AliITSClusterFinderV2SPD.cxx:269
 AliITSClusterFinderV2SPD.cxx:270
 AliITSClusterFinderV2SPD.cxx:271
 AliITSClusterFinderV2SPD.cxx:272
 AliITSClusterFinderV2SPD.cxx:273
 AliITSClusterFinderV2SPD.cxx:274
 AliITSClusterFinderV2SPD.cxx:275
 AliITSClusterFinderV2SPD.cxx:276
 AliITSClusterFinderV2SPD.cxx:277
 AliITSClusterFinderV2SPD.cxx:278
 AliITSClusterFinderV2SPD.cxx:279
 AliITSClusterFinderV2SPD.cxx:280
 AliITSClusterFinderV2SPD.cxx:281
 AliITSClusterFinderV2SPD.cxx:282
 AliITSClusterFinderV2SPD.cxx:283
 AliITSClusterFinderV2SPD.cxx:284
 AliITSClusterFinderV2SPD.cxx:285
 AliITSClusterFinderV2SPD.cxx:286
 AliITSClusterFinderV2SPD.cxx:287
 AliITSClusterFinderV2SPD.cxx:288
 AliITSClusterFinderV2SPD.cxx:289
 AliITSClusterFinderV2SPD.cxx:290
 AliITSClusterFinderV2SPD.cxx:291
 AliITSClusterFinderV2SPD.cxx:292
 AliITSClusterFinderV2SPD.cxx:293
 AliITSClusterFinderV2SPD.cxx:294
 AliITSClusterFinderV2SPD.cxx:295
 AliITSClusterFinderV2SPD.cxx:296
 AliITSClusterFinderV2SPD.cxx:297
 AliITSClusterFinderV2SPD.cxx:298
 AliITSClusterFinderV2SPD.cxx:299
 AliITSClusterFinderV2SPD.cxx:300
 AliITSClusterFinderV2SPD.cxx:301
 AliITSClusterFinderV2SPD.cxx:302
 AliITSClusterFinderV2SPD.cxx:303
 AliITSClusterFinderV2SPD.cxx:304
 AliITSClusterFinderV2SPD.cxx:305
 AliITSClusterFinderV2SPD.cxx:306
 AliITSClusterFinderV2SPD.cxx:307
 AliITSClusterFinderV2SPD.cxx:308
 AliITSClusterFinderV2SPD.cxx:309
 AliITSClusterFinderV2SPD.cxx:310
 AliITSClusterFinderV2SPD.cxx:311
 AliITSClusterFinderV2SPD.cxx:312
 AliITSClusterFinderV2SPD.cxx:313
 AliITSClusterFinderV2SPD.cxx:314
 AliITSClusterFinderV2SPD.cxx:315
 AliITSClusterFinderV2SPD.cxx:316
 AliITSClusterFinderV2SPD.cxx:317
 AliITSClusterFinderV2SPD.cxx:318
 AliITSClusterFinderV2SPD.cxx:319
 AliITSClusterFinderV2SPD.cxx:320
 AliITSClusterFinderV2SPD.cxx:321
 AliITSClusterFinderV2SPD.cxx:322
 AliITSClusterFinderV2SPD.cxx:323
 AliITSClusterFinderV2SPD.cxx:324
 AliITSClusterFinderV2SPD.cxx:325
 AliITSClusterFinderV2SPD.cxx:326
 AliITSClusterFinderV2SPD.cxx:327
 AliITSClusterFinderV2SPD.cxx:328
 AliITSClusterFinderV2SPD.cxx:329
 AliITSClusterFinderV2SPD.cxx:330
 AliITSClusterFinderV2SPD.cxx:331
 AliITSClusterFinderV2SPD.cxx:332
 AliITSClusterFinderV2SPD.cxx:333
 AliITSClusterFinderV2SPD.cxx:334
 AliITSClusterFinderV2SPD.cxx:335
 AliITSClusterFinderV2SPD.cxx:336
 AliITSClusterFinderV2SPD.cxx:337
 AliITSClusterFinderV2SPD.cxx:338
 AliITSClusterFinderV2SPD.cxx:339
 AliITSClusterFinderV2SPD.cxx:340
 AliITSClusterFinderV2SPD.cxx:341
 AliITSClusterFinderV2SPD.cxx:342
 AliITSClusterFinderV2SPD.cxx:343
 AliITSClusterFinderV2SPD.cxx:344
 AliITSClusterFinderV2SPD.cxx:345
 AliITSClusterFinderV2SPD.cxx:346
 AliITSClusterFinderV2SPD.cxx:347
 AliITSClusterFinderV2SPD.cxx:348
 AliITSClusterFinderV2SPD.cxx:349
 AliITSClusterFinderV2SPD.cxx:350
 AliITSClusterFinderV2SPD.cxx:351
 AliITSClusterFinderV2SPD.cxx:352
 AliITSClusterFinderV2SPD.cxx:353
 AliITSClusterFinderV2SPD.cxx:354
 AliITSClusterFinderV2SPD.cxx:355
 AliITSClusterFinderV2SPD.cxx:356
 AliITSClusterFinderV2SPD.cxx:357
 AliITSClusterFinderV2SPD.cxx:358
 AliITSClusterFinderV2SPD.cxx:359
 AliITSClusterFinderV2SPD.cxx:360
 AliITSClusterFinderV2SPD.cxx:361
 AliITSClusterFinderV2SPD.cxx:362
 AliITSClusterFinderV2SPD.cxx:363
 AliITSClusterFinderV2SPD.cxx:364
 AliITSClusterFinderV2SPD.cxx:365
 AliITSClusterFinderV2SPD.cxx:366
 AliITSClusterFinderV2SPD.cxx:367
 AliITSClusterFinderV2SPD.cxx:368
 AliITSClusterFinderV2SPD.cxx:369
 AliITSClusterFinderV2SPD.cxx:370
 AliITSClusterFinderV2SPD.cxx:371
 AliITSClusterFinderV2SPD.cxx:372
 AliITSClusterFinderV2SPD.cxx:373
 AliITSClusterFinderV2SPD.cxx:374
 AliITSClusterFinderV2SPD.cxx:375
 AliITSClusterFinderV2SPD.cxx:376
 AliITSClusterFinderV2SPD.cxx:377
 AliITSClusterFinderV2SPD.cxx:378
 AliITSClusterFinderV2SPD.cxx:379
 AliITSClusterFinderV2SPD.cxx:380
 AliITSClusterFinderV2SPD.cxx:381
 AliITSClusterFinderV2SPD.cxx:382
 AliITSClusterFinderV2SPD.cxx:383
 AliITSClusterFinderV2SPD.cxx:384
 AliITSClusterFinderV2SPD.cxx:385
 AliITSClusterFinderV2SPD.cxx:386
 AliITSClusterFinderV2SPD.cxx:387
 AliITSClusterFinderV2SPD.cxx:388
 AliITSClusterFinderV2SPD.cxx:389
 AliITSClusterFinderV2SPD.cxx:390
 AliITSClusterFinderV2SPD.cxx:391
 AliITSClusterFinderV2SPD.cxx:392
 AliITSClusterFinderV2SPD.cxx:393
 AliITSClusterFinderV2SPD.cxx:394
 AliITSClusterFinderV2SPD.cxx:395
 AliITSClusterFinderV2SPD.cxx:396
 AliITSClusterFinderV2SPD.cxx:397
 AliITSClusterFinderV2SPD.cxx:398
 AliITSClusterFinderV2SPD.cxx:399
 AliITSClusterFinderV2SPD.cxx:400
 AliITSClusterFinderV2SPD.cxx:401
 AliITSClusterFinderV2SPD.cxx:402
 AliITSClusterFinderV2SPD.cxx:403
 AliITSClusterFinderV2SPD.cxx:404
 AliITSClusterFinderV2SPD.cxx:405
 AliITSClusterFinderV2SPD.cxx:406
 AliITSClusterFinderV2SPD.cxx:407
 AliITSClusterFinderV2SPD.cxx:408
 AliITSClusterFinderV2SPD.cxx:409
 AliITSClusterFinderV2SPD.cxx:410
 AliITSClusterFinderV2SPD.cxx:411
 AliITSClusterFinderV2SPD.cxx:412
 AliITSClusterFinderV2SPD.cxx:413
 AliITSClusterFinderV2SPD.cxx:414
 AliITSClusterFinderV2SPD.cxx:415
 AliITSClusterFinderV2SPD.cxx:416
 AliITSClusterFinderV2SPD.cxx:417
 AliITSClusterFinderV2SPD.cxx:418
 AliITSClusterFinderV2SPD.cxx:419
 AliITSClusterFinderV2SPD.cxx:420
 AliITSClusterFinderV2SPD.cxx:421
 AliITSClusterFinderV2SPD.cxx:422
 AliITSClusterFinderV2SPD.cxx:423
 AliITSClusterFinderV2SPD.cxx:424
 AliITSClusterFinderV2SPD.cxx:425
 AliITSClusterFinderV2SPD.cxx:426
 AliITSClusterFinderV2SPD.cxx:427
 AliITSClusterFinderV2SPD.cxx:428
 AliITSClusterFinderV2SPD.cxx:429
 AliITSClusterFinderV2SPD.cxx:430
 AliITSClusterFinderV2SPD.cxx:431
 AliITSClusterFinderV2SPD.cxx:432
 AliITSClusterFinderV2SPD.cxx:433
 AliITSClusterFinderV2SPD.cxx:434
 AliITSClusterFinderV2SPD.cxx:435