X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSClusterFinderV2SDD.cxx;h=70343290db6ad7b36ecc6ffc342bb0d0774c9700;hb=fcd6be2072518ab650e1819867fdc657f7a51d49;hp=7dea7a642fea7207dfcaecb684fcd17f1e8c89bb;hpb=00a7cc50a892d6950eb32c6eb20b2088fed1e164;p=u%2Fmrichter%2FAliRoot.git

diff --git a/ITS/AliITSClusterFinderV2SDD.cxx b/ITS/AliITSClusterFinderV2SDD.cxx
index 7dea7a642fe..70343290db6 100644
--- a/ITS/AliITSClusterFinderV2SDD.cxx
+++ b/ITS/AliITSClusterFinderV2SDD.cxx
@@ -12,6 +12,9 @@
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
+
+/* $Id$*/
+
 ////////////////////////////////////////////////////////////////////////////
 //            Implementation of the ITS clusterer V2 class                //
 //                                                                        //
@@ -21,31 +24,24 @@
 
 
 
+#include <TClonesArray.h>
 #include "AliITSClusterFinderV2SDD.h"
 #include "AliITSRecPoint.h"
 #include "AliITSDetTypeRec.h"
 #include "AliRawReader.h"
 #include "AliITSRawStreamSDD.h"
-
-#include <TClonesArray.h>
+#include "AliITSCalibrationSDD.h"
+#include "AliITSDetTypeRec.h"
+#include "AliITSsegmentationSDD.h"
 #include "AliITSdigitSDD.h"
-
+#include "AliITSgeomTGeo.h"
 ClassImp(AliITSClusterFinderV2SDD)
 
-extern AliRun *gAlice;
-
-AliITSClusterFinderV2SDD::AliITSClusterFinderV2SDD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp){
+AliITSClusterFinderV2SDD::AliITSClusterFinderV2SDD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp)
+{
 
   //Default constructor
 
-  fNySDD=256; fNzSDD=256;
-  fYpitchSDD=0.01825;
-  fZpitchSDD=0.02940;
-  fHwSDD=3.5085; fHlSDD=3.7632;
-  fYoffSDD=0.0425;
-
-
-
 }
  
 
@@ -61,35 +57,57 @@ void AliITSClusterFinderV2SDD::FindClustersSDD(TClonesArray *digits) {
   //------------------------------------------------------------
   // Actual SDD cluster finder
   //------------------------------------------------------------
-  Int_t kNzBins = fNzSDD + 2;
-  const Int_t kMAXBIN=kNzBins*(fNySDD+2);
+  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;
 
   AliBin *bins[2];
-  bins[0]=new AliBin[kMAXBIN];
-  bins[1]=new AliBin[kMAXBIN];
-
+  bins[0]=new AliBin[kMaxBin];
+  bins[1]=new AliBin[kMaxBin];
+  AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)GetResp(fModule);
+  if(cal==0){
+    AliError(Form("Calibration object not present for SDD module %d\n",fModule));
+    return;
+  }
+  AliITSresponseSDD* res  = (AliITSresponseSDD*)cal->GetResponse();
+  const char *option=res->ZeroSuppOption();
   AliITSdigitSDD *d=0;
   Int_t i, ndigits=digits->GetEntriesFast();
   for (i=0; i<ndigits; i++) {
      d=(AliITSdigitSDD*)digits->UncheckedAt(i);
-     Int_t y=d->GetCoord2()+1;   //y
-     Int_t z=d->GetCoord1()+1;   //z
-     Int_t q=d->GetSignal();
-     if (q<3) continue;
-
-     if (z <= fNzSDD) {
-       bins[0][y*kNzBins+z].SetQ(q);
-       bins[0][y*kNzBins+z].SetMask(1);
-       bins[0][y*kNzBins+z].SetIndex(i);
-     } else {
-       z-=fNzSDD; 
-       bins[1][y*kNzBins+z].SetQ(q);
-       bins[1][y*kNzBins+z].SetMask(1);
-       bins[1][y*kNzBins+z].SetIndex(i);
+     Int_t ian=d->GetCoord1();
+     Int_t itb=d->GetCoord2();
+     Int_t iSide=0;
+     if (ian >= nAnodes) iSide=1;    
+     Float_t gain=cal->GetChannelGain(ian);
+     Float_t charge=d->GetSignal();
+     if(strstr(option,"ZS")) charge+=(Float_t)cal->GetZSLowThreshold(iSide);
+     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(charge<cal->GetThresholdAnode(ian)) continue;
+       Int_t q=(Int_t)(charge+0.5);
+       Int_t y=itb+1;   
+       Int_t z=ian+1;   
+       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);
+       }
      }
   }
   
-  FindClustersSDD(bins, kMAXBIN, kNzBins, digits);
+  FindClustersSDD(bins, kMaxBin, nzBins, digits);
 
   delete[] bins[0];
   delete[] bins[1];
@@ -102,6 +120,13 @@ FindClustersSDD(AliBin* bins[2], Int_t nMaxBin, Int_t nzBins,
   //------------------------------------------------------------
   // Actual SDD cluster finder
   //------------------------------------------------------------
+
+  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;
+  }
   Int_t ncl=0; 
   TClonesArray &cl=*clusters;
   for (Int_t s=0; s<2; s++)
@@ -117,20 +142,20 @@ FindClustersSDD(AliBin* bins[2], Int_t nMaxBin, Int_t nzBins,
       for (k=0; k<npeaks-1; k++){//mark adjacent peaks
         if (idx[k] < 0) continue; //this peak is already removed
         for (l=k+1; l<npeaks; l++) {
-           if (idx[l] < 0) continue; //this peak is already removed
-           Int_t ki=idx[k]/nzBins, kj=idx[k] - ki*nzBins;
-           Int_t li=idx[l]/nzBins, lj=idx[l] - li*nzBins;
-           Int_t di=TMath::Abs(ki - li);
-           Int_t dj=TMath::Abs(kj - lj);
-           if (di>1 || 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;
-           } 
+	  if (idx[l] < 0) continue; //this peak is already removed
+	  Int_t ki=idx[k]/nzBins, kj=idx[k] - ki*nzBins;
+	  Int_t li=idx[l]/nzBins, lj=idx[l] - li*nzBins;
+	  Int_t di=TMath::Abs(ki - li);
+	  Int_t dj=TMath::Abs(kj - lj);
+	  if (di>1 || 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;
+	  } 
         }
       }
 
@@ -139,127 +164,107 @@ FindClustersSDD(AliBin* bins[2], Int_t nMaxBin, Int_t nzBins,
       }
         
       for (k=0; k<npeaks; k++) {
-         if (idx[k] < 0) continue; //removed peak
-         AliITSRecPoint c(fDetTypeRec->GetITSgeom());
-         MakeCluster(idx[k], nzBins, bins[s], msk[k], c);
-	 //mi change
-	 Int_t milab[10];
-	 for (Int_t ilab=0;ilab<10;ilab++){
-	   milab[ilab]=-2;
-	 }
-	 Int_t maxi=0,mini=0,maxj=0,minj=0;
-	 //AliBin *bmax=&bins[s][idx[k]];
-	 //Float_t max = TMath::Max(TMath::Abs(bmax->GetQ())/5.,3.);
-	 Float_t max=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];
-	     if (TMath::Abs(b->GetQ())>max){
-	       if (di>maxi) maxi=di;
-	       if (di<mini) mini=di;
-	       if (dj>maxj) maxj=dj;
-	       if (dj<minj) minj=dj;
-	       //
-	       if(digits) {
-		 if (TMath::Abs(di)<2&&TMath::Abs(dj)<2){
-		   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); 
-		     }
-		   }
-		 }
-	       }
-	     }
-	   }
-	 
-	 /* 
-	    Float_t s2 = c.GetSigmaY2()/c.GetQ() - c.GetY()*c.GetY();
-	    Float_t w=par->GetPadPitchWidth(sec);
-	    c.SetSigmaY2(s2);
-	    if (s2 != 0.) {
-	    c.SetSigmaY2(c.GetSigmaY2()*0.108);
-	    if (sec<par->GetNInnerSector()) c.SetSigmaY2(c.GetSigmaY2()*2.07);
-	    }	 
-	    s2 = c.GetSigmaZ2()/c.GetQ() - c.GetZ()*c.GetZ();
-	    w=par->GetZWidth();
-	    c.SetSigmaZ2(s2);
-	    
-	    if (s2 != 0.) {
-	    c.SetSigmaZ2(c.GetSigmaZ2()*0.169);
-	    if (sec<par->GetNInnerSector()) c.SetSigmaZ2(c.GetSigmaZ2()*1.77);
+	if (idx[k] < 0) continue; //removed peak
+	AliITSRecPoint c;
+	MakeCluster(idx[k], nzBins, bins[s], msk[k], c);
+	//mi change
+	Int_t milab[10];
+	for (Int_t ilab=0;ilab<10;ilab++){
+	  milab[ilab]=-2;
+	}
+	Int_t maxi=0,mini=0,maxj=0,minj=0;
+	//AliBin *bmax=&bins[s][idx[k]];
+	//Float_t max = TMath::Max(TMath::Abs(bmax->GetQ())/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 (di<mini) mini=di;
+	      if (dj>maxj) maxj=dj;
+	      if (dj<minj) minj=dj;
 	    }
-	 */
-
-         c.SetSigmaY2(0.0030*0.0030);
-         c.SetSigmaZ2(0.0020*0.0020);
-         c.SetDetectorIndex(fNdet[fModule]);
-
-         Float_t y=c.GetY(),z=c.GetZ(), q=c.GetQ();
-         y/=q; z/=q;
-	 //
-	 //Float_t s2 = c.GetSigmaY2()/c.GetQ() - y*y;
-	 // c.SetSigmaY2(s2);
-	 //s2 = c.GetSigmaZ2()/c.GetQ() - z*z;
-         //c.SetSigmaZ2(s2);
-	 //
-         y=(y-0.5)*fYpitchSDD;
-         y-=fHwSDD;
-         y-=fYoffSDD;  //delay ?
-         if (s) y=-y;
-
-         z=(z-0.5)*fZpitchSDD;
-         z-=fHlSDD;
-
-         y=-(-y+fYshift[fModule]);
-         z=  -z+fZshift[fModule];
-	 //      c.SetY(y);
-	 //  c.SetZ(z);
-	 c.SetYZ(fModule,y,z);
-	 c.SetNy(maxj-minj+1);
-	 c.SetNz(maxi-mini+1);
-	 c.SetType(npeaks);
-         c.SetQ(q/12.7);  //to be consistent with the SSD charges
-
-         if (c.GetQ() < 20.) continue; //noise cluster
-	 
-	 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); 
-	     c.SetLabel(milab[0],0);
-	     c.SetLabel(milab[1],1);
-	     c.SetLabel(milab[2],2);
-	     c.SetLayer(fNlayer[fModule]);
-	   }
-	 }
-	 if(clusters) new (cl[ncl]) AliITSRecPoint(c); 
-	 else {
-	   fDetTypeRec->AddRecPoint(c);
-	 }
-	 ncl++;
+	    //
+	    if(digits) {
+	      if (TMath::Abs(di)<2&&TMath::Abs(dj)<2){
+		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); 
+		  }
+		}
+	      }
+	    }
+	  }
+	}
+
+
+	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 driftTime = GetSeg()->GetDriftTimeFromTb(timebin) - cal->GetTimeOffset();
+	Float_t driftPathMicron = cal->GetDriftPath(driftTime,zAnode);
+	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
+	
+	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/=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++;
       }
     }
+  
 }
-
-
-
+//______________________________________________________________________
 void AliITSClusterFinderV2SDD::RawdataToClusters(AliRawReader* rawReader,TClonesArray** clusters){
     //------------------------------------------------------------
   // This function creates ITS clusters from raw data
   //------------------------------------------------------------
   rawReader->Reset();
   AliITSRawStreamSDD inputSDD(rawReader);
+  AliITSDDLModuleMapSDD *ddlmap=(AliITSDDLModuleMapSDD*)fDetTypeRec->GetDDLModuleMapSDD();
+  inputSDD.SetDDLModuleMap(ddlmap);
   FindClustersSDD(&inputSDD,clusters);
 
 }
@@ -271,55 +276,83 @@ void AliITSClusterFinderV2SDD::FindClustersSDD(AliITSRawStream* input,
   // Actual SDD cluster finder for raw data
   //------------------------------------------------------------
   Int_t nClustersSDD = 0;
-  Int_t kNzBins = fNzSDD + 2;
-  Int_t kMaxBin = kNzBins * (fNySDD+2);
-  AliBin *binsSDDInit = new AliBin[kMaxBin];
-  AliBin *binsSDD1 = new AliBin[kMaxBin];
-  AliBin *binsSDD2 = new AliBin[kMaxBin];
-  AliBin* bins[2] = {NULL, NULL};
-
+  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;
+  AliBin *bins[2];
+  AliBin *ddlbins[kHybridsPerDDL]; // 12 modules (=24 hybrids) of 1 DDL read "in parallel"
+  for(Int_t iHyb=0;iHyb<kHybridsPerDDL;iHyb++) ddlbins[iHyb]=new AliBin[kMaxBin];
   // read raw data input stream
-  while (kTRUE) {
-    Bool_t next = input->Next();
-    if (!next || input->IsNewModule()) {
-      Int_t iModule = input->GetPrevModuleID();
+  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 iHybrid=iCarlos*2+iSide;
+    if (input->IsCompletedModule()) {
       // when all data from a module was read, search for clusters
-      if (bins[0]) { 
-	clusters[iModule] = new TClonesArray("AliITSRecPoint");
-	fModule = iModule;
-	FindClustersSDD(bins, kMaxBin, kNzBins, NULL, clusters[iModule]);
-	Int_t nClusters = clusters[iModule]->GetEntriesFast();
-	nClustersSDD += nClusters;
-	bins[0] = bins[1] = NULL;
-	
+      if(iCarlos<0){
+	AliWarning(Form("Invalid SDD carlos number %d on module %d\n", iCarlos,iModule));
+	continue;
       }
-
-      if (!next) break;
-      bins[0]=binsSDD1;
-      bins[1]=binsSDD2;
-      memcpy(binsSDD1,binsSDDInit,sizeof(AliBin)*kMaxBin);
-      memcpy(binsSDD2,binsSDDInit,sizeof(AliBin)*kMaxBin);
-
-    }
-
+      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;iBin<kMaxBin; iBin++){
+	ddlbins[iCarlos*2][iBin].Reset();
+	ddlbins[iCarlos*2+1][iBin].Reset();
+      }
+    }else{
     // fill the current digit into the bins array
-    if(input->GetSignal()>=3) {
-      Int_t iz = input->GetCoord1()+1;
-      Int_t side = ((iz <= fNzSDD) ? 0 : 1);
-      iz -= side*fNzSDD;
-      Int_t index = (input->GetCoord2()+1) * kNzBins + iz;
-      bins[side][index].SetQ(input->GetSignal());
-      bins[side][index].SetMask(1);
-      bins[side][index].SetIndex(index);
+      if(iHybrid<0 || iHybrid>=kHybridsPerDDL){ 
+	AliWarning(Form("Invalid SDD hybrid number %d on module %d\n", iHybrid,iModule));
+	continue;
+      }
+      AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)GetResp(iModule);    
+      if(cal==0){
+	AliError(Form("Calibration object not present for SDD module %d\n",iModule));
+	continue;
+      }
+      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,"ZS")) charge+=(Float_t)cal->GetZSLowThreshold(iSide);
+      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) * nzBins + (iz+1);
+	  if(index<kMaxBin){
+	    ddlbins[iHybrid][index].SetQ(q);
+	    ddlbins[iHybrid][index].SetMask(1);
+	    ddlbins[iHybrid][index].SetIndex(index);
+	  }else{
+	    AliWarning(Form("Invalid SDD cell: Anode=%d   TimeBin=%d",iz,itb));	  
+	  }
+	}
+      }
     }
   }
-  delete[] binsSDD1;
-  delete[] binsSDD2;
-  delete[] binsSDDInit;
-
+  for(Int_t iHyb=0;iHyb<kHybridsPerDDL;iHyb++) delete [] ddlbins[iHyb];
   Info("FindClustersSDD", "found clusters in ITS SDD: %d", nClustersSDD);
-
 }
 
 
+