X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSClusterFinderV2SDD.cxx;h=a565b63ef064117ff04a0f458dbc8dd6928e0c3b;hb=9325dcb13f4069a5bfa708c1203658d3dc8a7f2a;hp=539c2830a840d0463552dd35ef0fca1491191df9;hpb=979b5a5f346aa4764ee6d0d0f4719832e10250d5;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSClusterFinderV2SDD.cxx b/ITS/AliITSClusterFinderV2SDD.cxx index 539c2830a84..a565b63ef06 100644 --- a/ITS/AliITSClusterFinderV2SDD.cxx +++ b/ITS/AliITSClusterFinderV2SDD.cxx @@ -25,26 +25,58 @@ #include +#include #include "AliITSClusterFinderV2SDD.h" #include "AliITSRecPoint.h" +#include "AliITSRecPointContainer.h" #include "AliITSDetTypeRec.h" #include "AliRawReader.h" #include "AliITSRawStreamSDD.h" +#include "AliITSRawStreamSDDCompressed.h" #include "AliITSCalibrationSDD.h" +#include "AliITSresponseSDD.h" #include "AliITSDetTypeRec.h" +#include "AliITSReconstructor.h" #include "AliITSsegmentationSDD.h" #include "AliITSdigitSDD.h" #include "AliITSgeomTGeo.h" + ClassImp(AliITSClusterFinderV2SDD) -AliITSClusterFinderV2SDD::AliITSClusterFinderV2SDD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp) +AliITSClusterFinderV2SDD::AliITSClusterFinderV2SDD(AliITSDetTypeRec* dettyp):AliITSClusterFinder(dettyp), + fNAnodes(0), + fNTimeBins(0), + fNZbins(0), + fNXbins(0), + fCutOnPeakLoose(0.), + fCutOnPeakTight(0.), + fMaxDrTimeForTightCut(0.) { - //Default constructor + fNAnodes = GetSeg()->NpzHalf(); + fNZbins = fNAnodes+2; + fNTimeBins = GetSeg()->Npx(); + fNXbins = fNTimeBins+2; + AliDebug(2,Form("Cells in SDD cluster finder: Andoes=%d TimeBins=%d",fNAnodes,fNTimeBins)); + const Int_t kMaxBin=fNZbins*fNXbins; + for(Int_t iHyb=0;iHybNpzHalf(); - Int_t nzBins = nAnodes+2; - Int_t nTimeBins = GetSeg()->Npx(); - Int_t nxBins = nTimeBins+2; - const Int_t kMaxBin=nzBins*(nxBins+2); + const Int_t kMaxBin=fNZbins*fNXbins; AliBin *bins[2]; bins[0]=new AliBin[kMaxBin]; bins[1]=new AliBin[kMaxBin]; + TBits *anodeFired[2]; + anodeFired[0]=new TBits(fNAnodes); + anodeFired[1]=new TBits(fNAnodes); + anodeFired[0]->ResetAllBits(); + anodeFired[1]->ResetAllBits(); AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)GetResp(fModule); - AliITSresponseSDD* res = (AliITSresponseSDD*)cal->GetResponse(); - const char *option=res->ZeroSuppOption(); + if(cal==0){ + AliError(Form("Calibration object not present for SDD module %d\n",fModule)); + return; + } + AliITSdigitSDD *d=0; Int_t i, ndigits=digits->GetEntriesFast(); for (i=0; iUncheckedAt(i); - Int_t y=d->GetCoord2()+1; //y - Int_t z=d->GetCoord1()+1; //z - Float_t gain=cal->GetChannelGain(d->GetCoord1()); - Float_t charge=d->GetSignal(); - - if(!((strstr(option,"1D")) || (strstr(option,"2D")))){ - Float_t baseline = cal->GetBaseline(d->GetCoord1()); - if(charge>baseline) charge-=baseline; - else charge=0; - } - - if(gain>0) charge/=gain; - if(chargeGetThresholdAnode(d->GetCoord1())) continue; - Int_t q=(Int_t)(charge+0.5); - if (z <= nAnodes){ - bins[0][y*nzBins+z].SetQ(q); - bins[0][y*nzBins+z].SetMask(1); - bins[0][y*nzBins+z].SetIndex(i); - } else { - z-=nAnodes; - bins[1][y*nzBins+z].SetQ(q); - bins[1][y*nzBins+z].SetMask(1); - bins[1][y*nzBins+z].SetIndex(i); + Int_t ian=d->GetCoord1(); + Int_t itb=d->GetCoord2(); + Int_t iSide=0; + if (ian >= fNAnodes) iSide=1; + Float_t gain=cal->GetChannelGain(ian)/fDetTypeRec->GetAverageGainSDD(); + Float_t charge=d->GetSignal(); // returns expanded signal + // (10 bit, low threshold already added) + Float_t baseline = cal->GetBaseline(ian); + if(charge>baseline) charge-=baseline; + else charge=0; + + if(gain>0.){ // Bad channels have gain=0. + charge/=gain; + if(chargeGetThresholdAnode(ian)) continue; + Int_t q=(Int_t)(charge+0.5); + Int_t y=itb+1; + Int_t z=ian+1; + if (z <= fNAnodes){ + bins[0][y*fNZbins+z].SetQ(q); + bins[0][y*fNZbins+z].SetMask(1); + bins[0][y*fNZbins+z].SetIndex(i); + anodeFired[0]->SetBitNumber(ian); + } else { + z-=fNAnodes; + bins[1][y*fNZbins+z].SetQ(q); + bins[1][y*fNZbins+z].SetMask(1); + bins[1][y*fNZbins+z].SetIndex(i); + anodeFired[1]->SetBitNumber(ian-fNAnodes); + } } } - FindClustersSDD(bins, kMaxBin, nzBins, digits); + FindClustersSDD(bins, anodeFired, digits); delete[] bins[0]; delete[] bins[1]; + delete anodeFired[0]; + delete anodeFired[1]; } +//______________________________________________________________________ void AliITSClusterFinderV2SDD:: -FindClustersSDD(AliBin* bins[2], Int_t nMaxBin, Int_t nzBins, - TClonesArray *digits, TClonesArray *clusters) { +FindClustersSDD(AliBin* bins[2], TBits* anodeFired[2], + TClonesArray *digits, TClonesArray *clusters, Int_t jitter) { //------------------------------------------------------------ // Actual SDD cluster finder //------------------------------------------------------------ + 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(fModule); AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)GetResp(fModule); + if(cal==0){ + AliError(Form("Calibration object not present for SDD module %d\n",fModule)); + return; + } + const Int_t kMaxBin=fNZbins*fNXbins; Int_t ncl=0; TClonesArray &cl=*clusters; - for (Int_t s=0; s<2; s++) - for (Int_t i=0; i30) continue; - if (npeaks==0) continue; - - Int_t k,l; - for (k=0; k1 || dj>1) continue; - if (bins[s][idx[k]].GetQ() > bins[s][idx[l]].GetQ()) { - msk[l]=msk[k]; - idx[l]*=-1; - } else { - msk[k]=msk[l]; - idx[k]*=-1; - break; - } - } - } - - for (k=0; kGetQ())/5.,3.); - - for (Int_t di=-2; di<=2;di++){ - for (Int_t dj=-3;dj<=3;dj++){ - Int_t index = idx[k]+di+dj*nzBins; - if (index<0) continue; - if (index>=nMaxBin) continue; - AliBin *b=&bins[s][index]; - Int_t nAnode=index%nzBins-1; - Int_t adcSignal=b->GetQ(); - if(adcSignal>cal->GetThresholdAnode(nAnode)){ - if (di>maxi) maxi=di; - if (dimaxj) maxj=dj; - if (djUncheckedAt(b->GetIndex()); - for (Int_t itrack=0;itrack<10;itrack++){ - Int_t track = (d->GetTracks())[itrack]; - if (track>=0) { - AddLabel(milab, track); - } - } - } - } - } - } - - - Float_t y=c.GetY(),z=c.GetZ(), q=c.GetQ(); - y/=q; z/=q; - - - const Double_t kMicronTocm = 1.0e-4; - Float_t timeBinCenter = y-0.5; - Float_t zAnode=z-0.5; - Float_t zdet = (zAnode*GetSeg()->Dpz(0)-GetSeg()->Dz()/2.)*kMicronTocm; - Float_t driftTime = timeBinCenter*GetSeg()->Dpx(0) - cal->GetTimeOffset(); - Float_t xdet = cal->GetDriftPath(driftTime,zAnode); - xdet=(xdet-GetSeg()->Dx())*kMicronTocm; - if (s) xdet=-xdet; - - - CorrectPosition(zdet,xdet); - - Double_t loc[3]={xdet,0.,zdet},trk[3]={0.,0.,0.}; - mT2L->MasterToLocal(loc,trk); - y=trk[1]; - z=trk[2]; - - q/=cal->GetADC2keV(); //to have MPV 1 MIP = 86.4 KeV - Float_t hit[5] = {y, z, 0.0030*0.0030, 0.0020*0.0020, q}; - Int_t info[3] = {maxj-minj+1, maxi-mini+1, fNlayer[fModule]}; - if (digits) { - // AliBin *b=&bins[s][idx[k]]; - // AliITSdigitSDD* d=(AliITSdigitSDD*)digits->UncheckedAt(b->GetIndex()); - { - //Int_t lab[3]; - //lab[0]=(d->GetTracks())[0]; - //lab[1]=(d->GetTracks())[1]; - //lab[2]=(d->GetTracks())[2]; - //CheckLabels(lab); - CheckLabels2(milab); - } - } - milab[3]=fNdet[fModule]; - - AliITSRecPoint cc(milab,hit,info); - cc.SetType(npeaks); - - if(clusters) new (cl[ncl]) AliITSRecPoint(cc); - else { - fDetTypeRec->AddRecPoint(cc); - } - ncl++; + for (Int_t s=0; s<2; s++){ + for(Int_t iAnode=0; iAnodeNpzHalf(); iAnode++){ + if(anodeFired[s]->TestBitNumber(iAnode)==kFALSE) continue; + for(Int_t iTimeBin=0; iTimeBinNpx(); iTimeBin++){ + Int_t index=(iTimeBin+1)*fNZbins+(iAnode+1); + if (bins[s][index].IsUsed()) continue; + if(NoiseSuppress(index,s,bins[s],cal)) continue; + Int_t idx[32]; UInt_t msk[32]; Int_t npeaks=0; + FindPeaks(index, fNZbins, bins[s], idx, msk, npeaks); + + if (npeaks>30) continue; + if (npeaks==0) continue; + + Int_t k,l; + Int_t nClust; + if(repa->GetUseUnfoldingInClusterFinderSDD()){ + for (k=0; k1 || dj>1) continue; + if (bins[s][idx[k]].GetQ() > bins[s][idx[l]].GetQ()) { + msk[l]=msk[k]; + idx[l]*=-1; + } else { + msk[k]=msk[l]; + idx[k]*=-1; + break; + } + } + } + nClust=npeaks; + }else{ + for (k=1; k0. && bins[s][idx[k]].GetQ() > maxADC) maxADC=bins[s][idx[k]].GetQ(); + MarkPeak(TMath::Abs(idx[k]), fNZbins, bins[s], msk[k]); + } + if(maxADC=kMaxBin) continue; + AliBin *b=&bins[s][index]; + if(b->GetQ()<0.1) continue; + AliITSdigitSDD* d=(AliITSdigitSDD*)digits->UncheckedAt(b->GetIndex()); + for (Int_t itrack=0;itrack<10;itrack++){ + Int_t track = (d->GetTracks())[itrack]; + if (track>=0) { + AddLabel(milab, track); + } + } + } + } + } + else { // raw data + if (fRawID2ClusID) milab[0] = fNClusters+1; // RS: store clID+1 as a reference to the cluster + } + + + Int_t clSizAnode=fZmax-fZmin+1; + Int_t clSizTb=fXmax-fXmin+1; + if(repa->GetUseSDDClusterSizeSelection()){ + if(clSizTb==1) continue; // cut common mode noise spikes + if(clSizAnode>5) continue; // cut common mode noise spikes + if(clSizTb>10) continue; // cut clusters on noisy anodes + if(cal-> IsAMAt20MHz() && clSizTb>8) continue; // cut clusters on noisy anodes + } + + AliITSresponseSDD* rsdd = fDetTypeRec->GetResponseSDD(); + Float_t y=c.GetY(),z=c.GetZ(), q=c.GetQ(); + y/=q; z/=q; + Float_t zAnode=z-0.5; // to have anode in range 0.-255. and centered on the mid of the pitch + Float_t timebin=y-0.5; // to have time bin in range 0.-255. amd centered on the mid of the bin + if(s==1) zAnode += GetSeg()->NpzHalf(); // right side has anodes from 256. to 511. + Float_t zdet = GetSeg()->GetLocalZFromAnode(zAnode); + Float_t driftTimeUncorr = GetSeg()->GetDriftTimeFromTb(timebin)+jitter*rsdd->GetCarlosRXClockPeriod(); + Float_t driftTime=driftTimeUncorr-rsdd->GetTimeZero(fModule); + if(driftTimeGetDriftSpeedAtAnode(zAnode) + rsdd->GetDeltaVDrift(fModule,zAnode>255); + Float_t driftPathMicron = driftTime*driftSpeed; + const Double_t kMicronTocm = 1.0e-4; + Float_t xdet=(driftPathMicron-GetSeg()->Dx())*kMicronTocm; // xdet is negative + if (s==0) xdet=-xdet; // left side has positive local x + + if(repa->GetUseSDDCorrectionMaps()){ + Float_t corrx=0, corrz=0; + cal->GetCorrections(zdet,xdet,corrz,corrx,GetSeg()); + zdet+=corrz; + xdet+=corrx; + } + + Double_t loc[3]={xdet,0.,zdet},trk[3]={0.,0.,0.}; + mT2L->MasterToLocal(loc,trk); + y=trk[1]; + z=trk[2]; + + q+=(driftTime*rsdd->GetADCvsDriftTime(fModule)); // correction for zero supp. + q/=rsdd->GetADCtokeV(fModule); + if(cal-> IsAMAt20MHz()) q*=2.; // account for 1/2 sampling freq. + if(qGetMinClusterChargeSDD()) continue; // remove noise clusters + + Float_t hit[6] = {y, z, 0.0030*0.0030, 0.0020*0.0020, q, 0.}; + Int_t info[3] = {clSizTb, clSizAnode, fNlayer[fModule]}; + if (digits) CheckLabels2(milab); + milab[3]=fNdet[fModule]; + AliITSRecPoint cc(milab,hit,info); + cc.SetType(nClust*100+npeaks); + cc.SetDriftTime(driftTimeUncorr); + cc.SetDriftSide(s); + cc.SetChargeRatio(maxADC); + if(clusters) new (cl[ncl]) AliITSRecPoint(cc); + else { + fDetTypeRec->AddRecPoint(cc); + } + fNClusters++; // RS + ncl++; + } } } - -} - - + } + AliDebug(2,Form("Clusters found on SDD module %d (unfolding %d) = %d\n",fModule,repa->GetUseUnfoldingInClusterFinderSDD(),ncl)); -void AliITSClusterFinderV2SDD::RawdataToClusters(AliRawReader* rawReader,TClonesArray** clusters){ +} +//______________________________________________________________________ +void AliITSClusterFinderV2SDD::RawdataToClusters(AliRawReader* rawReader){ //------------------------------------------------------------ // This function creates ITS clusters from raw data //------------------------------------------------------------ - rawReader->Reset(); - AliITSRawStreamSDD inputSDD(rawReader); - AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)GetResp(240); - /* - printf("gain anode 10=%f\n",cal->GetDriftSpeedAtAnode(10)); - printf("drift speed anode 10=%f\n",cal->GetChannelGain(10)); - */ - AliITSDDLModuleMapSDD *ddlmap=(AliITSDDLModuleMapSDD*)fDetTypeRec->GetDDLModuleMapSDD(); - inputSDD.SetDDLModuleMap(ddlmap); - FindClustersSDD(&inputSDD,clusters); + fNClusters = 0; //RS + AliITSRawStream* inputSDD=AliITSRawStreamSDD::CreateRawStreamSDD(rawReader); + AliDebug(1,Form("%s is used",inputSDD->ClassName())); + AliITSDDLModuleMapSDD *ddlmap=(AliITSDDLModuleMapSDD*)fDetTypeRec->GetDDLModuleMapSDD(); + inputSDD->SetDDLModuleMap(ddlmap); + for(Int_t iddl=0; iddlGetModuleNumber(iddl,icar); + if(iMod==-1) continue; + AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)GetResp(iMod); + if(cal==0){ + AliError(Form("Calibration object not present for SDD module %d\n",iMod)); + continue; + } + Bool_t isZeroSupp=cal->GetZeroSupp(); + if(isZeroSupp){ + for(Int_t iSid=0; iSid<2; iSid++) inputSDD->SetZeroSuppLowThreshold(iMod-240,iSid,cal->GetZSLowThreshold(iSid)); + }else{ + for(Int_t iSid=0; iSid<2; iSid++) inputSDD->SetZeroSuppLowThreshold(iMod-240,iSid,0); + } + } + } + FindClustersSDD(inputSDD); + delete inputSDD; } -void AliITSClusterFinderV2SDD::FindClustersSDD(AliITSRawStream* input, - TClonesArray** clusters) +void AliITSClusterFinderV2SDD::FindClustersSDD(AliITSRawStream* input) { //------------------------------------------------------------ // Actual SDD cluster finder for raw data //------------------------------------------------------------ + AliITSRecPointContainer* rpc = AliITSRecPointContainer::Instance(); Int_t nClustersSDD = 0; - Int_t nAnodes = GetSeg()->NpzHalf(); - Int_t nzBins = nAnodes+2; - Int_t nTimeBins = GetSeg()->Npx(); - Int_t nxBins = nTimeBins+2; - const Int_t kMaxBin=nzBins*(nxBins+2); AliBin *bins[2]; - AliBin *ddlbins[kHybridsPerDDL]; // 12 modules (=24 hybrids) of 1 DDL read "in parallel" - for(Int_t iHyb=0;iHybResetAllBits(); + } + Int_t vectModId[kModulesPerDDL]; + for(Int_t iMod=0; iModReset(); //RS if array was provided, we shall store the rawID -> ClusterID + // while (input->Next()) { Int_t iModule = input->GetModuleID(); if(iModule<0){ AliWarning(Form("Invalid SDD module number %d\n", iModule)); continue; } - - Int_t iCarlos =((AliITSRawStreamSDD*)input)->GetCarlosId(); - Int_t iSide = ((AliITSRawStreamSDD*)input)->GetChannel(); + Int_t iCarlos =input->GetCarlosId(); + Int_t iSide = input->GetChannel(); Int_t iHybrid=iCarlos*2+iSide; + if (input->IsCompletedModule()) { - // when all data from a module was read, search for clusters - if(iCarlos<0){ - AliWarning(Form("Invalid SDD carlos number %d on module %d\n", iCarlos,iModule)); - continue; - } - clusters[iModule] = new TClonesArray("AliITSRecPoint"); - fModule = iModule; - bins[0]=ddlbins[iCarlos*2]; // first hybrid of the completed module - bins[1]=ddlbins[iCarlos*2+1]; // second hybrid of the completed module - FindClustersSDD(bins, kMaxBin, nzBins, NULL, clusters[iModule]); - Int_t nClusters = clusters[iModule]->GetEntriesFast(); - nClustersSDD += nClusters; - for(Int_t iBin=0;iBinIsCompletedDDL()) { + // when all data from a DDL was read, search for clusters + Int_t jitter=input->GetJitter(); + for(Int_t iMod=0; iMod=0){ + fModule = vectModId[iMod]; + TClonesArray* clusters = rpc->UncheckedGetClusters(fModule); + bins[0]=fDDLBins[iMod*2]; // first hybrid of the module + bins[1]=fDDLBins[iMod*2+1]; // second hybrid of the module + anodeFired[0]=ddlAnodeFired[iMod*2]; + anodeFired[1]=ddlAnodeFired[iMod*2+1]; + FindClustersSDD(bins, anodeFired, NULL, clusters,jitter); + Int_t nClusters = clusters->GetEntriesFast(); + nClustersSDD += nClusters; + vectModId[iMod]=-1; + } + for (Int_t s=0; s<2; s++){ + Int_t indexHyb=iMod*2+s; + for(Int_t iAnode=0; iAnodeNpzHalf(); iAnode++){ + if(ddlAnodeFired[indexHyb]->TestBitNumber(iAnode)==kFALSE) continue; + for(Int_t iTimeBin=0; iTimeBinNpx(); iTimeBin++){ + Int_t index=(iTimeBin+1)*fNZbins+(iAnode+1); + fDDLBins[indexHyb][index].Reset(); + } + } + } + ddlAnodeFired[iMod*2]->ResetAllBits(); + ddlAnodeFired[iMod*2+1]->ResetAllBits(); } }else{ // fill the current digit into the bins array @@ -314,62 +424,90 @@ void AliITSClusterFinderV2SDD::FindClustersSDD(AliITSRawStream* input, continue; } AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)GetResp(iModule); - AliITSresponseSDD* res = (AliITSresponseSDD*)cal->GetResponse(); - const char *option=res->ZeroSuppOption(); - Float_t charge=input->GetSignal(); - Int_t chan=input->GetCoord1()+nAnodes*iSide; - Float_t gain=cal->GetChannelGain(chan); - if(!((strstr(option,"1D")) || (strstr(option,"2D")))){ - Float_t baseline = cal->GetBaseline(chan); - if(charge>baseline) charge-=baseline; - else charge=0; + if(cal==0){ + AliError(Form("Calibration object not present for SDD module %d\n",iModule)); + continue; } - if(gain>0) charge/=gain; - if(charge>=cal->GetThresholdAnode(chan)) { - Int_t q=(Int_t)(charge+0.5); - Int_t iz = input->GetCoord1(); - Int_t itb = input->GetCoord2(); - Int_t index = (itb+1) * nzBins + (iz+1); - if(indexGetSignal(); + Int_t chan=input->GetCoord1()+fNAnodes*iSide; + Float_t gain=cal->GetChannelGain(chan)/fDetTypeRec->GetAverageGainSDD();; + Float_t baseline = cal->GetBaseline(chan); + if(charge>baseline) charge-=baseline; + else charge=0; + if(gain>0.){ // Bad channels have gain=0 + charge/=gain; + if(charge>=cal->GetThresholdAnode(chan)) { + Int_t q=(Int_t)(charge+0.5); + Int_t iz = input->GetCoord1(); + Int_t itb = input->GetCoord2(); + Int_t index = (itb+1) * fNZbins + (iz+1); + if((itb < fNTimeBins) && (iz < fNAnodes)) { + fDDLBins[iHybrid][index].SetQ(q); + fDDLBins[iHybrid][index].SetMask(1); + fDDLBins[iHybrid][index].SetIndex(index); + fDDLBins[iHybrid][index].SetRawID(countRW); //RS register raw id + ddlAnodeFired[iHybrid]->SetBitNumber(iz); + }else{ + AliWarning(Form("Invalid SDD cell: Anode=%d TimeBin=%d",iz,itb)); + } } } } + countRW++; //RS } - for(Int_t iHyb=0;iHyb255) return kTRUE; + if(sid==1) iAn+=256; + Int_t nLow=0, nHigh=0; + Float_t noise=cal->GetNoiseAfterElectronics(iAn); + Float_t noisem1=noise; + if(iAn>1) noisem1=cal->GetNoiseAfterElectronics(iAn-1); + Float_t noisep1=noise; + if(iAn<511) noisep1=cal->GetNoiseAfterElectronics(iAn+1); + Float_t tL=noise*xfactL; + Float_t tH=noise*xfactH; + Float_t tLp1=noisep1*xfactL; + Float_t tHp1=noisep1*xfactH; + Float_t tLm1=noisem1*xfactL; + Float_t tHm1=noisem1*xfactH; + Int_t cC=bins[k].GetQ(); + if(cC<=tL){ + bins[k].SetQ(0); + bins[k].SetMask(0xFFFFFFFE); + return kTRUE;; + } + nLow++; // cC is greater than tL + if(cC>tH) nHigh++; + Int_t sS=bins[k-1].GetQ(); + if(sS>tLm1) nLow++; + if(sS>tHm1) nHigh++; + Int_t nN=bins[k+1].GetQ(); + if(nN>tLp1) nLow++; + if(nN>tHp1) nHigh++; + Int_t eE=bins[k-fNZbins].GetQ(); + if(eE>tL) nLow++; + if(eE>tH) nHigh++; + Int_t wW=bins[k+fNZbins].GetQ(); + if(wW>tL) nLow++; + if(wW>tH) nHigh++; + if(nLow<2 || nHigh<1) return kTRUE; + else return kFALSE; +} -//_________________________________________________________________________ -void AliITSClusterFinderV2SDD::CorrectPosition(Float_t &z, Float_t&y){ - - //correction of coordinates using the maps stored in the DB - - AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)GetResp(fModule); - static const Int_t knbint = cal->GetMapTimeNBin(); - static const Int_t knbina = cal->Chips()*cal->Channels(); - const Double_t kMicronTocm = 1.0e-4; - Float_t stepa = (GetSeg()->Dpz(0))*kMicronTocm; //anode pitch in cm - Float_t stept = (GetSeg()->Dx()/cal->GetMapTimeNBin()/2.)/10.; - - Int_t bint = TMath::Abs((Int_t)(y/stept)); - if(y>=0) bint+=(Int_t)(knbint/2.); - if(bint>knbint) AliError("Wrong bin number!"); - - Int_t bina = TMath::Abs((Int_t)(z/stepa)); - if(z>=0) bina+=(Int_t)(knbina/2.); - if(bina>knbina) AliError("Wrong bin number!"); - - Float_t devz = cal->GetMapACell(bina,bint)*kMicronTocm; - Float_t devx = cal->GetMapTCell(bina,bint)*kMicronTocm; - z+=devz; - y+=devx; -}