[u/mrichter/AliRoot.git] / ITS / AliITSClusterFinderV2SPD.cxx

/**************************************************************************
 * 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);
      }
    }
  }
  
}
Commit	Line	Data
04366a57	1	/**************************************************************************
	2	* Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15	////////////////////////////////////////////////////////////////////////////
	16	// Implementation of the ITS clusterer V2 class //
	17	// //
	18	// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch //
d6d232ba	19	// Unfolding switch from AliITSRecoParam: D. Elia, INFN Bari //
04366a57	20	// //
d6d232ba	21	////////////////////////////////////////////////////////////////////////////
04366a57	22
04366a57	23
66b89079	24	#include <TGeoGlobalMagField.h>
8d37cc87	25	#include "AliITSCalibrationSPD.h"
04366a57	26	#include "AliITSClusterFinderV2SPD.h"
00a7cc50	27	#include "AliITSRecPoint.h"
1f3e997f	28	#include "AliITSgeomTGeo.h"
7d62fb64	29	#include "AliITSDetTypeRec.h"
d6d232ba	30	#include "AliITSReconstructor.h"
04366a57	31	#include "AliRawReader.h"
04366a57	32	#include "AliITSRawStreamSPD.h"
04366a57	33	#include <TClonesArray.h>
04366a57	34	#include "AliITSdigitSPD.h"
ad7f2bfa	35	#include "AliITSFOSignalsSPD.h"
01ef1bd4	36	#include "AliITSRecPointContainer.h"
66b89079	37	#include "AliMagF.h"
66b89079	38	#include "AliITSsegmentationSPD.h"
04366a57	39
	40	ClassImp(AliITSClusterFinderV2SPD)
	41
ad7f2bfa	42	//__________________________________________________________________________
5d2c2f86	43	AliITSClusterFinderV2SPD::AliITSClusterFinderV2SPD(AliITSDetTypeRec* dettyp):AliITSClusterFinder(dettyp),
1f3e997f	44	fLastSPD1(AliITSgeomTGeo::GetModuleIndex(2,1,1)-1),
e56160b8	45	fNySPD(256),
	46	fNzSPD(160),
	47	fYpitchSPD(0.0050),
	48	fZ1pitchSPD(0.0425),
	49	fZ2pitchSPD(0.0625),
	50	fHwSPD(0.64),
	51	fHlSPD(3.48){
04366a57	52
04366a57	53	//Default constructor
04366a57	54
04366a57	55	fYSPD[0]=0.5*fYpitchSPD;
	56	for (Int_t m=1; m<fNySPD; m++) fYSPD[m]=fYSPD[m-1]+fYpitchSPD;
	57	fZSPD[0]=fZ1pitchSPD;
	58	for (Int_t m=1; m<fNzSPD; m++) {
	59	Double_t dz=fZ1pitchSPD;
	60	if (m==31 \|\| m==32 \|\| m==63 \|\| m==64 \|\| m==95 \|\| m==96 \|\|
	61	m==127 \|\| m==128) dz=fZ2pitchSPD;
	62	fZSPD[m]=fZSPD[m-1]+dz;
	63	}
	64	for (Int_t m=0; m<fNzSPD; m++) {
	65	Double_t dz=0.5*fZ1pitchSPD;
	66	if (m==31 \|\| m==32 \|\| m==63 \|\| m==64 \|\| m==95 \|\| m==96 \|\|
	67	m==127 \|\| m==128) dz=0.5*fZ2pitchSPD;
	68	fZSPD[m]-=dz;
	69	}
	70
	71	}
ad7f2bfa	72	//__________________________________________________________________________
04366a57	73	void AliITSClusterFinderV2SPD::FindRawClusters(Int_t mod){
04366a57	74	//Find clusters V2
	75	SetModule(mod);
	76	FindClustersSPD(fDigits);
	77
	78	}
ad7f2bfa	79	//__________________________________________________________________________
01ef1bd4	80	void AliITSClusterFinderV2SPD::RawdataToClusters(AliRawReader* rawReader){
ad7f2bfa	81	//------------------------------------------------------------
04366a57	82	// This function creates ITS clusters from raw data
	83	//------------------------------------------------------------
	84	rawReader->Reset();
6c8e94cf	85	fNClusters = 0; //RS
04366a57	86	AliITSRawStreamSPD inputSPD(rawReader);
01ef1bd4	87	FindClustersSPD(&inputSPD);
04366a57	88
04366a57	89	}
ad7f2bfa	90	//__________________________________________________________________________
04366a57	91	Int_t AliITSClusterFinderV2SPD::ClustersSPD(AliBin* bins, TClonesArray* digits,TClonesArray* clusters,Int_t maxBins,Int_t nzbins,Int_t iModule,Bool_t rawdata){
	92
	93	//Cluster finder for SPD (from digits and from rawdata)
66b89079	94	const Double_t kmictocm = 1.0e-4; // convert microns to cm.
66b89079	95	const Double_t defaultField = 5.0; // default Bz value at which Tan(theta_Lorentz) is given in RecoParam
04366a57	96
5c47990a	97	static AliITSRecoParam *repa = NULL;
	98	if(!repa){
	99	repa = (AliITSRecoParam*) AliITSReconstructor::GetRecoParam();
	100	if(!repa){
ed446fa3	101	repa = AliITSRecoParam::GetHighFluxParam();
5c47990a	102	AliWarning("Using default AliITSRecoParam class");
	103	}
	104	}
b4704be3	105	const TGeoHMatrix *mT2L=AliITSgeomTGeo::GetTracking2LocalMatrix(iModule);
8d37cc87	106
66b89079	107	// Lorentz angle correction
	108	Double_t tanLorentzAngle=0;
	109	AliITSsegmentationSPD seg = (AliITSsegmentationSPD)(GetDetTypeRec()->GetSegmentationModel(0));
	110	Double_t thick = 0.5kmictocmseg->Dy(); // Half Thickness in cm
	111	if(repa->GetCorrectLorentzAngleSPD()) { // only if CorrectLorentzAngleSPD required
	112	// here retrieve the value of the field
	113	AliMagF* field = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
045be90c	114	if (field == 0) {
66b89079	115	AliError("Cannot get magnetic field from TGeoGlobalMagField");
045be90c	116	}
	117	else {
	118	Float_t magField = field->SolenoidField();
	119	tanLorentzAngle=repa->GetTanLorentzAngleHolesSPD() * magField / defaultField ;
	120	}
66b89079	121	}
	122	//
	123
ad7f2bfa	124	if (repa->GetSPDRemoveNoisyFlag()) {
	125	// Loop on noisy pixels and reset them
	126	AliITSCalibrationSPD *cal =
	127	(AliITSCalibrationSPD*) fDetTypeRec->GetCalibrationModel(iModule);
	128	for(Int_t ipix = 0; ipix<cal->GetNrBad(); ipix++){
	129	Int_t row, col;
	130	cal->GetBadPixel(ipix,row,col);
190ba77d	131	//PH printf(" module %d row %d col %d \n",iModule,row,col);
ad7f2bfa	132	Int_t index = (row+1) * nzbins + (col+1);
	133
	134	bins[index].SetQ(0);
	135	bins[index].SetMask(0xFFFFFFFE);
	136	}
	137	}
	138
	139	if (repa->GetSPDRemoveDeadFlag()) {
	140	// Loop on dead pixels and reset them
	141	AliITSCalibrationSPD *cal =
	142	(AliITSCalibrationSPD*) fDetTypeRec->GetSPDDeadModel(iModule);
	143	if (cal->IsBad()) return 0; // if all ladder is dead, return to save time
	144	for(Int_t ipix = 0; ipix<cal->GetNrBad(); ipix++){
	145	Int_t row, col;
	146	cal->GetBadPixel(ipix,row,col);
	147	Int_t index = (row+1) * nzbins + (col+1);
	148	bins[index].SetQ(0);
	149	bins[index].SetMask(0xFFFFFFFE);
	150	}
f405602f	151	AliITSCalibrationSPD calSparse = (AliITSCalibrationSPD) fDetTypeRec->GetSPDSparseDeadModel(iModule);
	152	for(Int_t ipix = 0; ipix<calSparse->GetNrBad(); ipix++){
	153	Int_t row, col;
	154	calSparse->GetBadPixel(ipix,row,col);
	155	Int_t index = (row+1) * nzbins + (col+1);
	156	bins[index].SetQ(0);
	157	bins[index].SetMask(0xFFFFFFFE);
	158	}
	159
8d37cc87	160	}
ad7f2bfa	161
04366a57	162	Int_t nclu=0;
	163	for(Int_t iBin =0; iBin < maxBins;iBin++){
	164	if(bins[iBin].IsUsed()) continue;
98a86dff	165	Int_t nBins = 0;
04366a57	166	Int_t idxBins[200];
	167	FindCluster(iBin,nzbins,bins,nBins,idxBins);
	168	if (nBins == 200){
	169	Error("ClustersSPD","SPD Too big cluster !\n");
	170	continue;
	171	}
	172	Int_t milab[10];
	173	for(Int_t ilab=0;ilab<10;ilab++){
	174	milab[ilab]=-2;
	175	}
	176	if(rawdata){
	177	milab[3]=fNdet[iModule];
	178	}
	179	Int_t ymin,ymax,zmin,zmax;
	180	if(rawdata){
	181	ymin = (idxBins[0] / nzbins) - 1;
	182	ymax = ymin;
	183	zmin = (idxBins[0] % nzbins) - 1;
	184	zmax = zmin;
	185	}
	186	else{
	187	AliITSdigitSPD* dig = (AliITSdigitSPD*)digits->UncheckedAt(idxBins[0]);
	188	ymin=dig->GetCoord2();
	189	ymax=ymin;
	190	zmin=dig->GetCoord1();
	191	zmax=zmin;
	192	}
190ba77d	193	//PH if(iModule == 24 \|\| iModule == 25) printf("\n");
04366a57	194	for (Int_t idx = 0; idx < nBins; idx++) {
	195	Int_t iy;
	196	Int_t iz;
	197	if(rawdata){
	198	iy = (idxBins[idx] / nzbins) - 1;
	199	iz = (idxBins[idx] % nzbins) - 1;
	200	}
	201	else{
	202	AliITSdigitSPD* dig = (AliITSdigitSPD*)digits->UncheckedAt(idxBins[idx]);
	203	iy = dig->GetCoord2();
	204	iz = dig->GetCoord1();
ad7f2bfa	205	//if(iModule == 24 \|\| iModule == 25) printf(" \|\| iy %d iz %d in Module %d \n",iy,iz,iModule);
04366a57	206	}
	207	if (ymin > iy) ymin = iy;
	208	if (ymax < iy) ymax = iy;
	209	if (zmin > iz) zmin = iz;
	210	if (zmax < iz) zmax = iz;
	211
	212	}
	213	if(!rawdata){
	214	for(Int_t l=0;l<nBins;l++){
	215	AliITSdigitSPD* dig = (AliITSdigitSPD*)digits->UncheckedAt(idxBins[l]);
	216	for(Int_t dlab=0;dlab<10;dlab++){
	217	Int_t digitlab = (dig->GetTracks())[dlab];
	218	if(digitlab<0) continue;
	219	AddLabel(milab,digitlab);
	220	}
	221	if (milab[9]>0) CheckLabels2(milab);
	222	}
	223	CheckLabels2(milab);
	224	}
	225
	226	Int_t idy =0; //max 2 clusters
	227	if((iModule <= fLastSPD1) &&idy<3) idy=3;
	228	if((iModule > fLastSPD1) &&idy<4) idy=4;
	229	Int_t idz=3;
d6d232ba	230
d6d232ba	231	// Switch the unfolding OFF/ON
5c47990a	232	if(!repa->GetUseUnfoldingInClusterFinderSPD()) {
d6d232ba	233	idy=ymax-ymin+1;
	234	idz=zmax-zmin+1;
	235	}
6c8e94cf	236	//
04366a57	237	for(Int_t iiz=zmin; iiz<=zmax;iiz+=idz){
	238	for(Int_t iiy=ymin;iiy<=ymax;iiy+=idy){
	239
	240	Int_t ndigits=0;
	241	Float_t y=0.,z=0.,q=0.;
	242	for(Int_t idx=0;idx<nBins;idx++){
	243	Int_t iy;
	244	Int_t iz;
	245	if(rawdata){
	246	iy = (idxBins[idx] / nzbins)-1;
	247	iz = (idxBins[idx] % nzbins)-1;
	248	}
	249	else{
	250	AliITSdigitSPD* dig = (AliITSdigitSPD*)digits->UncheckedAt(idxBins[idx]);
	251	iy = dig->GetCoord2();
	252	iz = dig->GetCoord1();
	253	}
	254	if(zmax-zmin>=idz \|\| ymax-ymin>=idy){
	255	if(TMath::Abs(iy-iiy)>0.75*idy) continue;
	256	if(TMath::Abs(iz-iiz)>0.75*idz) continue;
	257	}
	258	ndigits++;
5af4a2d0	259	Float_t qBin=0.;
6c8e94cf	260	if(rawdata) {
	261	qBin = bins[idxBins[idx]].GetQ();
	262	if (fRawID2ClusID) { // RS: Register cluster id in raw words list
	263	int rwid = bins[idxBins[idx]].GetRawID();
	264	if (fRawID2ClusID->GetSize()<=rwid) fRawID2ClusID->Set( (rwid+10)<<1 );
	265	(*fRawID2ClusID)[rwid] = milab[0] = fNClusters+1; // RS: store clID+1 as a reference to the cluster
	266	}
	267	}
04366a57	268	if(!rawdata){
	269	AliITSdigitSPD* dig = (AliITSdigitSPD*)digits->UncheckedAt(idxBins[idx]);
	270	qBin = (Float_t)dig->GetSignal();
	271	}
	272	y+= qBin * fYSPD[iy];
	273	z+= qBin * fZSPD[iz];
	274	q+= qBin;
	275	}// for idx
	276	if(ndigits==0) continue;
98a86dff	277
04366a57	278	y /= q;
	279	z /= q;
	280	y -= fHwSPD;
	281	z -= fHlSPD;
1f3e997f	282
66b89079	283	// Lorentz drift effect in local y
	284	y -= tanLorentzAngle*thick;
	285	//
	286
40f5092a	287	Float_t hit[6]; //y,z,sigma(y)^2, sigma(z)^2, charge
b4704be3	288	{
	289	Double_t loc[3]={y,0.,z},trk[3]={0.,0.,0.};
	290	mT2L->MasterToLocal(loc,trk);
	291	hit[0]=trk[1];
	292	hit[1]=trk[2];
	293	}
04366a57	294	hit[2] = fYpitchSPD*fYpitchSPD/12.;
04366a57	295	hit[3] = fZ1pitchSPD*fZ1pitchSPD/12.;
00a7cc50	296	hit[4] = 1.;
40f5092a	297	hit[5] = 0.;
b4704be3	298
04366a57	299	if(!rawdata) milab[3]=fNdet[iModule];
	300	Int_t info[3] = {ymax-ymin+1,zmax-zmin+1,fNlayer[iModule]};
	301	if(!rawdata){
75fb37cc	302	AliITSRecPoint cl(milab,hit,info);
98a86dff	303	cl.SetType(nBins);
00a7cc50	304	fDetTypeRec->AddRecPoint(cl);
04366a57	305	}
	306	else{
	307	Int_t label[4]={milab[0],milab[1],milab[2],milab[3]};
98a86dff	308	AliITSRecPoint cl(label, hit,info);
98a86dff	309	cl.SetType(nBins);
04366a57	310	new (clusters->AddrAt(nclu))
98a86dff	311	AliITSRecPoint(cl);
04366a57	312	}
04366a57	313	nclu++;
6c8e94cf	314	fNClusters++;
04366a57	315	}// for iiy
	316	}// for iiz
	317	}//end for iBin
	318	return nclu;
	319
	320	}
ad7f2bfa	321	//__________________________________________________________________________
01ef1bd4	322	void AliITSClusterFinderV2SPD::FindClustersSPD(AliITSRawStreamSPD* input)
04366a57	323	{
04366a57	324	//------------------------------------------------------------
ad7f2bfa	325	// SPD cluster finder for raw data (this method is called once per event)
ad7f2bfa	326	// Now also fills fast-or fired map
04366a57	327	//------------------------------------------------------------
01ef1bd4	328
01ef1bd4	329	AliITSRecPointContainer* rpc = AliITSRecPointContainer::Instance();
04366a57	330	Int_t nClustersSPD = 0;
	331	Int_t kNzBins = fNzSPD + 2;
	332	Int_t kNyBins = fNySPD + 2;
	333	Int_t kMaxBin = kNzBins * kNyBins;
d7d9347b	334	AliBin *binsSPD = new AliBin[kMaxBin];
d7d9347b	335	AliBin *binsSPDInit = new AliBin[kMaxBin];
04366a57	336	AliBin* bins = NULL;
	337
	338	// read raw data input stream
6c8e94cf	339	int countRW = 0; //RS
	340	if (fRawID2ClusID) fRawID2ClusID->Reset(); //RS if array was provided, we shall store the rawID -> ClusterID
	341	//
04366a57	342	while (kTRUE) {
	343	Bool_t next = input->Next();
	344	if (!next \|\| input->IsNewModule()) {
	345	Int_t iModule = input->GetPrevModuleID();
	346
	347	// when all data from a module was read, search for clusters
	348	if (bins) {
01ef1bd4	349	TClonesArray* clusters = rpc->UncheckedGetClusters(iModule);
01ef1bd4	350	Int_t nClusters = ClustersSPD(bins,0,clusters,kMaxBin,kNzBins,iModule,kTRUE);
04366a57	351	nClustersSPD += nClusters;
d7d9347b	352	bins = NULL;
04366a57	353	}
	354
	355	if (!next) break;
d7d9347b	356	bins = binsSPD;
d7d9347b	357	memcpy(binsSPD,binsSPDInit,sizeof(AliBin)*kMaxBin);
04366a57	358	}
04366a57	359
6c8e94cf	360	if (next && bins) {
ad7f2bfa	361	// fill the current digit into the bins array
	362	Int_t index = (input->GetCoord2()+1) * kNzBins + (input->GetCoord1()+1);
	363	bins[index].SetIndex(index);
	364	bins[index].SetQ(1);
	365	bins[index].SetMask(1);
6c8e94cf	366	bins[index].SetRawID(countRW); //RS register raw id
ff44c37c	367	}
6c8e94cf	368	countRW++; //RS
ff44c37c	369	}
ff44c37c	370
d7d9347b	371	delete [] binsSPDInit;
	372	delete [] binsSPD;
	373
3b1d8321	374	AliDebug(1,Form("found clusters in ITS SPD: %d", nClustersSPD));
3b1d8321	375
ad7f2bfa	376
	377	// Fill the FastOr fired map
	378	for (UInt_t eq=0; eq<20; eq++) {
	379	for (UInt_t hs=0; hs<6; hs++) {
	380	for (UInt_t chip=0; chip<10; chip++) {
	381	if (input->GetFastOrSignal(eq,hs,chip)) {
	382	fDetTypeRec->SetFastOrFiredMapOnline(eq,hs,chip);
	383	}
	384	}
	385	}
	386	}
	387
04366a57	388	}
ad7f2bfa	389	//__________________________________________________________________________
04366a57	390	void AliITSClusterFinderV2SPD::FindClustersSPD(TClonesArray *digits) {
04366a57	391	//------------------------------------------------------------
ad7f2bfa	392	// SPD cluster finder for digits (this method is called for each module)
ad7f2bfa	393	// Now also fills the fast-or fired map
04366a57	394	//------------------------------------------------------------
	395
	396
	397	Int_t kNzBins = fNzSPD + 2;
	398	const Int_t kMAXBIN=kNzBins*(fNySPD+2);
	399
	400	Int_t ndigits=digits->GetEntriesFast();
	401	AliBin *bins=new AliBin[kMAXBIN];
	402
ad7f2bfa	403	Int_t idig;
	404	AliITSdigitSPD *digit=0;
	405	for (idig=0; idig<ndigits; idig++) {
	406	digit=(AliITSdigitSPD*)digits->UncheckedAt(idig);
	407	Int_t i=digit->GetCoord2()+1; //y
	408	Int_t j=digit->GetCoord1()+1;
	409	Int_t index=i*kNzBins+j;
	410
	411	bins[index].SetIndex(idig);
	412	bins[index].SetQ(1);
	413	bins[index].SetMask(1);
04366a57	414	}
ad7f2bfa	415
04366a57	416
d6d232ba	417	Int_t nClustersSPD = ClustersSPD(bins,digits,0,kMAXBIN,kNzBins,fModule,kFALSE);
04366a57	418	delete [] bins;
d6d232ba	419
813020f4	420	AliDebug(1,Form("found clusters in ITS SPD: %d", nClustersSPD));
ad7f2bfa	421
	422	// Fill the FastOr fired map
	423	AliITSFOSignalsSPD* foSignals = fDetTypeRec->GetFOSignals();
	424	if (foSignals) {
	425	UInt_t eq = AliITSRawStreamSPD::GetOnlineEqIdFromOffline(fModule);
	426	UInt_t hs = AliITSRawStreamSPD::GetOnlineHSFromOffline(fModule);
	427	for(UInt_t ch=0; ch<5; ch++) {
	428	UInt_t chip = AliITSRawStreamSPD::GetOnlineChipFromOffline(fModule,ch*32);
	429	if (foSignals->GetSignal(eq,hs,chip)) {
	430	fDetTypeRec->SetFastOrFiredMapOnline(eq,hs,chip);
	431	}
	432	}
	433	}
	434
04366a57	435	}