]> git.uio.no Git - u/mrichter/AliRoot.git/blobdiff - ITS/AliITSClusterFinderV2SDD.cxx
Protection in case of no SSD data is found. Some better placement of local variables...
[u/mrichter/AliRoot.git] / ITS / AliITSClusterFinderV2SDD.cxx
index d2379b277c7970a621f83383980db4272f9b6c89..083acb1753dcba7f2c6568d6213ad7288633cfb8 100644 (file)
@@ -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                //
 //                                                                        //
 
 
 
+#include <TClonesArray.h>
 #include "AliITSClusterFinderV2SDD.h"
 #include "AliITSRecPoint.h"
 #include "AliITSDetTypeRec.h"
 #include "AliRawReader.h"
-#include "AliITSRawStreamSDDv3.h"
+#include "AliITSRawStreamSDD.h"
 #include "AliITSCalibrationSDD.h"
 #include "AliITSDetTypeRec.h"
 #include "AliITSsegmentationSDD.h"
-#include <TClonesArray.h>
 #include "AliITSdigitSDD.h"
-#include "AliAlignObj.h"
-
+#include "AliITSgeomTGeo.h"
 ClassImp(AliITSClusterFinderV2SDD)
 
-AliITSClusterFinderV2SDD::AliITSClusterFinderV2SDD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp),
-fNySDD(256),
-fNzSDD(256),
-fYpitchSDD(0.01825),
-fZpitchSDD(0.02940),
-fHwSDD(3.5085),
-fHlSDD(3.7632),
-fYoffSDD(0.0425){
+AliITSClusterFinderV2SDD::AliITSClusterFinderV2SDD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp)
+{
 
   //Default constructor
 
-
 }
  
 
@@ -62,43 +57,49 @@ 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+2);
 
   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);
-  
+  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);
-     Float_t baseline = cal->GetBaseline(d->GetCoord1());
-
      Int_t y=d->GetCoord2()+1;   //y
      Int_t z=d->GetCoord1()+1;   //z
-     Int_t q=d->GetSignal();
+     Float_t gain=cal->GetChannelGain(d->GetCoord1());
+     Float_t charge=d->GetSignal();
 
-     if(q<cal->GetThresholdAnode(d->GetCoord1())) continue;
-     if(q>baseline) q-=(Int_t)baseline;
-     else q=0;
-     //if (q<3) continue;
+     if(!((strstr(option,"1D")) || (strstr(option,"2D")))){
+       Float_t baseline = cal->GetBaseline(d->GetCoord1());
+       if(charge>baseline) charge-=baseline;
+       else charge=0;
+     }
 
-     if (z <= fNzSDD) {
-       bins[0][y*kNzBins+z].SetQ(q);
-       bins[0][y*kNzBins+z].SetMask(1);
-       bins[0][y*kNzBins+z].SetIndex(i);
+     if(gain>0) charge/=gain;
+     if(charge<cal->GetThresholdAnode(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-=fNzSDD; 
-       bins[1][y*kNzBins+z].SetQ(q);
-       bins[1][y*kNzBins+z].SetMask(1);
-       bins[1][y*kNzBins+z].SetIndex(i);
+       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];
@@ -111,6 +112,8 @@ 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);
   Int_t ncl=0; 
   TClonesArray &cl=*clusters;
@@ -160,96 +163,61 @@ FindClustersSDD(AliBin* bins[2], Int_t nMaxBin, Int_t nzBins,
         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 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){
+            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;
-              //
-              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); 
-                    }
+            }
+            //
+            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);
-           }
-        */
-
-         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);
-        //
-
-        Float_t yyyy = y;
-         //y=(y-0.5)*fYpitchSDD;
-         //y-=fHwSDD;
-         //y-=fYoffSDD;  //delay ?
-         //if (s) y=-y;
-
-         z=(z-0.5)*fZpitchSDD;
-         z-=fHlSDD;
-        Float_t zdet = z;
-        //      y=-(-y+fYshift[fModule]);
-        // z=  -z+fZshift[fModule];
-        //      c.SetY(y);
-        //  c.SetZ(z);
-        Float_t xdet = cal->GetDriftPath((yyyy-0.5)*25,0);
-        xdet=xdet/10000.-fHwSDD-fYoffSDD;
+
+
+        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);
 
-        y=-(-xdet+fYshift[fModule]);
-        z=  -zdet+fZshift[fModule];
-        
-        c.SetY(y);
-        c.SetZ(z);
-        c.SetNy(maxj-minj+1);
-        c.SetNz(maxi-mini+1);
-        c.SetType(npeaks);
-         c.SetQ(q/12.7);  //this WAS consistent with SSD. To be reassessed 
-                          // 23-MAR-2007
-
-         //if (c.GetQ() < 20.) continue; //noise cluster
-        
+        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());
@@ -260,21 +228,21 @@ FindClustersSDD(AliBin* bins[2], Int_t nMaxBin, Int_t nzBins,
             //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]);
-            UShort_t id=AliAlignObj::LayerToVolUID(fNlayer[fModule]+AliAlignObj::kSPD1,fNdet[fModule]);
-            c.SetVolumeId(id);
           }
         }
-        if(clusters) new (cl[ncl]) AliITSRecPoint(c); 
+         milab[3]=fNdet[fModule];
+
+         AliITSRecPoint cc(milab,hit,info);
+        cc.SetType(npeaks);
+
+        if(clusters) new (cl[ncl]) AliITSRecPoint(cc); 
         else {
-          fDetTypeRec->AddRecPoint(c);
+          fDetTypeRec->AddRecPoint(cc);
         }
         ncl++;
       }
     }
+  
 }
 
 
@@ -284,7 +252,7 @@ void AliITSClusterFinderV2SDD::RawdataToClusters(AliRawReader* rawReader,TClones
   // This function creates ITS clusters from raw data
   //------------------------------------------------------------
   rawReader->Reset();
-  AliITSRawStreamSDDv3 inputSDD(rawReader);
+  AliITSRawStreamSDD inputSDD(rawReader);
   FindClustersSDD(&inputSDD,clusters);
 
 }
@@ -296,55 +264,60 @@ 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+2);
+  AliBin *bins[2];
+  AliBin *ddlbins[24]; // 12 modules (=24 hybrids) of 1 DDL read "in parallel"
+  for(Int_t iHyb=0;iHyb<24;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) 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]);
+       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;
-       bins[0] = bins[1] = NULL;
-       
-      }
-
-      if (!next) break;
-      bins[0]=binsSDD1;
-      bins[1]=binsSDD2;
-      memcpy(binsSDD1,binsSDDInit,sizeof(AliBin)*kMaxBin);
-      memcpy(binsSDD2,binsSDDInit,sizeof(AliBin)*kMaxBin);
-
-    }
-
+       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);
+      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(gain>0) charge/=gain;
+      if(charge>=cal->GetThresholdAnode(chan)) {
+       Int_t q=(Int_t)(charge+0.5);
+       Int_t iz = input->GetCoord1()+1;
+       Int_t index = (input->GetCoord2()+1) * nzBins + iz;
+       ddlbins[iHybrid][index].SetQ(q);
+       ddlbins[iHybrid][index].SetMask(1);
+       ddlbins[iHybrid][index].SetIndex(index);
+      }
     }
   }
-  delete[] binsSDD1;
-  delete[] binsSDD2;
-  delete[] binsSDDInit;
-
+  for(Int_t iHyb=0;iHyb<24;iHyb++) delete [] ddlbins[iHyb];
   Info("FindClustersSDD", "found clusters in ITS SDD: %d", nClustersSDD);
-
 }
 
 
@@ -354,21 +327,22 @@ 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 nbint = cal->GetMapTimeNBin();
-  static const Int_t nbina = cal->Chips()*cal->Channels();
-  Float_t stepa = (GetSeg()->Dpz(0))/10000.; //anode pitch in cm
+  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)(nbint/2.);
-  if(bint>nbint) AliError("Wrong bin number!");
+  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)(nbina/2.);
-  if(bina>nbina) AliError("Wrong bin number!");
+  if(z>=0) bina+=(Int_t)(knbina/2.);
+  if(bina>knbina) AliError("Wrong bin number!");
 
-  Float_t devz = cal->GetMapACell(bina,bint)/10000.;
-  Float_t devx = cal->GetMapTCell(bina,bint)/10000.;
+  Float_t devz = cal->GetMapACell(bina,bint)*kMicronTocm;
+  Float_t devx = cal->GetMapTCell(bina,bint)*kMicronTocm;
   z+=devz;
   y+=devx;