Implement fixed due to Boris Batyunya. Including a fix for a bug with the
authornilsen <nilsen@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 29 Aug 2000 20:29:59 +0000 (20:29 +0000)
committernilsen <nilsen@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 29 Aug 2000 20:29:59 +0000 (20:29 +0000)
storing of tracks in an overlapping cluster.

ITS/AliITSClusterFinderSPD.cxx
ITS/AliITSClusterFinderSPD.h
ITS/AliITSRawCluster.h
ITS/AliITSsimulationSPD.cxx

index 815c372abd9dededf7e3053dc81ada7a33bf1375..d7cf5fa2c6153fb0a64bd9db985f41a4e3c823c0 100644 (file)
@@ -92,8 +92,9 @@ AliITSClusterFinderSPD&
 void AliITSClusterFinderSPD::SetMap()
 {
   // set map
+
   if(!fMap) fMap=new AliITSMapA1(fSegmentation,fDigits);
-  
+
 }
 
 //_____________________________________________________________________________
@@ -111,6 +112,7 @@ void AliITSClusterFinderSPD::Find1DClusters()
   
   // read in digits -> do not apply threshold 
   // signal in fired pixels is always 1
+
   fMap->FillMap();
   
   Int_t nofFoundClusters = 0;
@@ -263,8 +265,8 @@ void  AliITSClusterFinderSPD::GroupClusters()
     label[i] = 1;
   } // I clusters
   fClusters->Compress();
-  //Int_t totalNofClusters = fClusters->GetEntriesFast();
-  //cout << " Nomber of clusters at the group end ="<< totalNofClusters<<endl;
+  //  Int_t totalNofClusters = fClusters->GetEntriesFast();
+  //  cout << " Nomber of clusters at the group end ="<< totalNofClusters<<endl;
   
   delete [] label;
 
@@ -274,6 +276,96 @@ void  AliITSClusterFinderSPD::GroupClusters()
 }
 //_____________________________________________________________________________
 
+void AliITSClusterFinderSPD::TracksInCluster()
+{
+  
+  // Find tracks creating one cluster
+
+  // get number of clusters for this module
+  Int_t nofClusters = fClusters->GetEntriesFast();
+  nofClusters -= fNclusters;
+
+  Int_t i, ix, iz, jx, jz, xstart, xstop, zstart, zstop, nclx, nclz;
+  //  Int_t signal, track0, track1, track2;
+  Int_t trmax = 100;
+  Int_t cltracks[trmax], itr, tracki, ii, is, js, ie, ntr, tr0, tr1, tr2;
+
+  for(i=0; i<nofClusters; i++) { 
+    ii = 0;
+    memset(cltracks,-1,sizeof(int)*trmax);
+    tr0=tr1=tr2=-1;
+
+    AliITSRawClusterSPD *clusterI = (AliITSRawClusterSPD*) fClusters->At(i);
+
+    nclx = clusterI->NclX();
+    nclz = clusterI->NclZ();
+    xstart = clusterI->XStartf();
+    xstop = clusterI->XStopf();
+    zstart = clusterI->Zend()-nclz+1;
+    zstop = clusterI->Zend();
+
+    Int_t ind; 
+
+     for(iz=0; iz<nclz; iz++) { 
+         jz = zstart + iz;
+       for(ix=0; ix<nclx; ix++) { 
+        jx = xstart + ix;
+        ind = fMap->GetHitIndex(jz,jx);
+        if(ind == 0 && iz >= 0 && ix > 0) {
+          continue;
+         }
+        if(ind == 0 && iz > 0 && ix >= 0) {
+          continue;
+         }
+        if(ind == 0 && iz == 0 && ix == 0 && i > 0) {
+          continue;
+         }
+
+        AliITSdigitSPD *dig = (AliITSdigitSPD*)fMap->GetHit(jz,jx);
+       /*
+         signal=dig->fSignal;
+         track0=dig->fTracks[0];
+         track1=dig->fTracks[1];
+         track2=dig->fTracks[2];
+       */
+          for(itr=0; itr<3; itr++) { 
+           tracki = dig->fTracks[itr];
+            if(tracki >= 0) {
+             ii += 1;
+             cltracks[ii-1] = tracki;
+            }
+         }
+       } // ix pixel
+     }  // iz pixel
+     for(is=0; is<trmax; is++) { 
+         if(cltracks[is]<0) continue;
+       for(js=is+1; js<trmax; js++) { 
+         if(cltracks[js]<0) continue;
+         if(cltracks[js]==cltracks[is]) cltracks[js]=-5;
+       }
+     }
+
+     ntr = 0;
+     for(ie=0; ie<trmax; ie++) { 
+       if(cltracks[ie] >= 0) {
+        ntr=ntr+1;
+        if(ntr==1) tr0=cltracks[ie];
+        if(ntr==2) tr1=cltracks[ie];
+        if(ntr==3) tr2=cltracks[ie];
+       }
+     }
+     // if delta ray only
+     if(ntr == 0) ntr = 1;
+
+     clusterI->SetNTracks(ntr);
+     clusterI->SetTracks(tr0,tr1,tr2);
+
+  } // I cluster
+
+}
+//_____________________________________________________________________________
+
 void AliITSClusterFinderSPD::GetRecPoints()
 {
   // get rec points
@@ -282,8 +374,6 @@ void AliITSClusterFinderSPD::GetRecPoints()
   // get number of clusters for this module
   Int_t nofClusters = fClusters->GetEntriesFast();
   nofClusters -= fNclusters;
-
-  
   const Float_t kconv = 1.0e-4;
   const Float_t kRMSx = 12.0*kconv; // microns -> cm ITS TDR Table 1.3
   const Float_t kRMSz = 70.0*kconv; // microns -> cm ITS TDR Table 1.3
@@ -291,21 +381,24 @@ void AliITSClusterFinderSPD::GetRecPoints()
   Float_t spdLength = fSegmentation->Dz();
   Float_t spdWidth = fSegmentation->Dx();
 
-  Int_t i, ix, iz;
+  Int_t i;
+  Int_t track0, track1, track2;
+
   for(i=0; i<nofClusters; i++) { 
+
     AliITSRawClusterSPD *clusterI = (AliITSRawClusterSPD*) fClusters->At(i);
-    fSegmentation->GetPadIxz(clusterI->X(),clusterI->Z(),ix,iz);
-    AliITSdigitSPD *dig = (AliITSdigitSPD*)fMap->GetHit(iz-1,ix-1);
+    clusterI->GetTracks(track0, track1, track2); 
     AliITSRecPoint rnew;
+
     rnew.SetX((clusterI->X() - spdWidth/2)*kconv);
     rnew.SetZ((clusterI->Z() - spdLength/2)*kconv);
     rnew.SetQ(1.);
     rnew.SetdEdX(0.);
     rnew.SetSigmaX2(kRMSx*kRMSx);
     rnew.SetSigmaZ2(kRMSz*kRMSz);
-    rnew.fTracks[0]=dig->fTracks[0];
-    rnew.fTracks[1]=dig->fTracks[1];
-    rnew.fTracks[2]=dig->fTracks[2];
+    rnew.fTracks[0]=track0;
+    rnew.fTracks[1]=track1;
+    rnew.fTracks[2]=track2;
     iTS->AddRecPoint(rnew);
   } // I clusters
 
@@ -319,6 +412,7 @@ void AliITSClusterFinderSPD::FindRawClusters()
   // find raw clusters
   Find1DClusters();
   GroupClusters();
+  TracksInCluster();
   GetRecPoints();
 
 }
index 23a34591fb074fd1276b2cdb5286242d6b051330..d65e588ed1525949d0a3423fc308990a6ac1befe 100644 (file)
@@ -40,6 +40,7 @@ public:
   virtual void FindRawClusters();
   void  Find1DClusters();
   void  GroupClusters();
+  void  TracksInCluster();
   void  SelectClusters() {
     // selects clusters
   }
index 4e09bc94105d76cb564674b594ca4e9196089e79..a7fdd0d7010ecebc044cbf780d5fb80d351fa29e 100644 (file)
@@ -57,12 +57,10 @@ public:
     // constructor
     fX=fZ=fQ;
     fZStart=fZStop;
-    fNClZ=fNClX=fXStart=fXStop=fXStartf=fXStopf=fZend;
+    fNClZ=fNClX=fXStart=fXStop=fXStartf=fXStopf=fZend=fNTracks;
        }
   
-  AliITSRawClusterSPD(Float_t clz,Float_t clx,Float_t Charge,
-                     Int_t ClusterSizeZ,Int_t ClusterSizeX,Int_t xstart,Int_t xstop,
-                     Int_t xstartf,Int_t xstopf,Float_t zstart,Float_t zstop,Int_t zend);
+  AliITSRawClusterSPD(Float_t clz,Float_t clx,Float_t Charge,Int_t ClusterSizeZ,Int_t ClusterSizeX,Int_t xstart,Int_t xstop,Int_t xstartf,Int_t xstopf,Float_t zstart,Float_t zstop,Int_t zend);
   virtual ~AliITSRawClusterSPD() {
     // destructor
   }
@@ -83,11 +81,13 @@ public:
     // X
     return fX ;
   }
-  Float_t NclZ() const {
+  //  Float_t NclZ() const {
+  Int_t NclZ() const {
     // NclZ
     return fNClZ ;
   }
-  Float_t NclX() const {
+  //  Float_t NclX() const {
+  Int_t NclX() const {
     // NclX
     return fNClX ;
   }
@@ -119,6 +119,30 @@ public:
     //Zend
     return fZend;
   }
+  Int_t   NTracks() const {
+    //NTracks
+    return fNTracks;
+  }
+
+  void GetTracks(Int_t &track0,Int_t &track1,Int_t &track2) const {
+              // returns tracks created a cluster
+
+             track0=fTracks[0];
+             track1=fTracks[1];
+             track2=fTracks[2];
+             return;
+  };
+  void   SetTracks(Int_t track0, Int_t track1, Int_t track2) {
+    // set tracks in cluster (not more than three ones)
+    fTracks[0]=track0;
+    fTracks[1]=track1;
+    fTracks[2]=track2;
+  }
+  void   SetNTracks(Int_t ntracks) {
+    // set ntracks
+    fNTracks=ntracks;
+  }
   
 protected:
   
@@ -134,6 +158,8 @@ protected:
   Float_t   fZStart;      // number of first pixel in cluster
   Float_t   fZStop;       // number of last pixel in cluster
   Int_t     fZend;        // Zend
+  Int_t     fNTracks;     // number of tracks created a cluster
+  Int_t     fTracks[3];   // tracks created a cluster
   
   ClassDef(AliITSRawClusterSPD,1)  // AliITSRawCluster class for SPD
 
index 2e4e7c6c6b7d566df88a2a9b0b9097437993e398..4d0232c0c8f7a26623b48e17389382a8edc0a282 100644 (file)
@@ -123,8 +123,7 @@ void AliITSsimulationSPD::DigitiseModule(AliITSmodule *mod, Int_t module, Int_t
     TObjArray *fHits = mod->GetHits();
     Int_t nhits = fHits->GetEntriesFast();
     if (!nhits) return;
-
-
+    //    cout << "module, nhits ="<<module<<","<<nhits<< endl;
 
   //  Array of pointers to the label-signal list
 
@@ -135,14 +134,13 @@ void AliITSsimulationSPD::DigitiseModule(AliITSmodule *mod, Int_t module, Int_t
 
     // Fill detector maps with GEANT hits
     // loop over hits in the module
-    static Bool_t first=kTRUE;
+    static Bool_t first;
     Int_t lasttrack=-2;
     Int_t hit, iZi, jz, jx;
     for (hit=0;hit<nhits;hit++) {
         AliITShit *iHit = (AliITShit*) fHits->At(hit);
        Int_t layer = iHit->GetLayer();
 
-
        // work with the idtrack=entry number in the TreeH
        Int_t idhit,idtrack;
        mod->GetHitTrackAndHitIndex(hit,idtrack,idhit);    
@@ -150,7 +148,26 @@ void AliITSsimulationSPD::DigitiseModule(AliITSmodule *mod, Int_t module, Int_t
         // or store straight away the particle position in the array
        // of particles : 
         Int_t itrack = iHit->GetTrack();
+        Int_t dray = 0;
    
+       if (lasttrack != itrack || hit==(nhits-1)) first = kTRUE; 
+
+       //        Int_t parent = iHit->GetParticle()->GetFirstMother();
+        Int_t partcode = iHit->GetParticle()->GetPdgCode();
+
+//  partcode (pdgCode): 11 - e-, 13 - mu-, 22 - gamma, 111 - pi0, 211 - pi+
+//                      310 - K0s, 321 - K+, 2112 - n, 2212 - p, 3122 - lambda
+
+        Float_t px = iHit->GetPXL();
+        Float_t py = iHit->GetPYL();
+        Float_t pz = iHit->GetPZL();
+        Float_t pmod = 1000*sqrt(px*px+py*py+pz*pz);
+
+
+        if(partcode == 11 && pmod < 6) dray = 1; // delta ray is e-
+                                                 // at p < 6 MeV/c
+
+
        //  Get hit z and x(r*phi) cordinates for each module (detector)
        //  in local system.
 
@@ -378,11 +395,10 @@ void AliITSsimulationSPD::DigitiseModule(AliITSmodule *mod, Int_t module, Int_t
           zPix0 = zPix;
           xPix0 = xPix;
         }
-       yPrev = yPix;  //ch
+       yPrev = yPix;  
 
-       if (lasttrack != itrack || hit==(nhits-1)) {
+       if(dray == 0) {
             GetList(itrack,idhit,pList,indexRange);
-            first=kTRUE;
        }
 
        lasttrack=itrack;
@@ -414,11 +430,12 @@ void AliITSsimulationSPD::GetList(Int_t label,Int_t idhit,Float_t **pList,Int_t
     for(Int_t ix=indexRange[2];ix<indexRange[3]+1;ix++){
 
         Float_t signal=fMapA2->GetSignal(iz,ix);
+
        if (!signal) continue;
 
         Int_t globalIndex = iz*fNPixelsX+ix; // GlobalIndex starts from 0!
         if(!pList[globalIndex]){
-        
+
            // 
           // Create new list (9 elements - 3 signals and 3 tracks + 3 hits)
           //
@@ -530,6 +547,26 @@ void AliITSsimulationSPD::ChargeToSignal(Float_t **pList)
           }
           charges[j1] = 0;
         }
+
+        if(tracks[0] == tracks[1] && tracks[0] == tracks[2]) {
+          tracks[1] = -3;
+           hits[1] = -1;
+          tracks[2] = -3;
+           hits[2] = -1;
+         } 
+        if(tracks[0] == tracks[1] && tracks[0] != tracks[2]) {
+          tracks[1] = -3;
+           hits[1] = -1;   
+         } 
+        if(tracks[0] == tracks[2] && tracks[0] != tracks[1]) {
+          tracks[2] = -3;
+           hits[2] = -1;   
+         } 
+        if(tracks[1] == tracks[2] && tracks[0] != tracks[1]) {
+          tracks[2] = -3;
+           hits[2] = -1;   
+         } 
+
          phys=0;
         aliITS->AddSimDigit(0,phys,digits,tracks,hits,charges);
       }