1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 ////////////////////////////////////////////////////////////////////////////
17 // for Silicon pixels //
19 ////////////////////////////////////////////////////////////////////////////
21 #include "AliITSClusterFinderSPD.h"
22 #include "AliITSDetTypeRec.h"
23 #include "AliITSRawClusterSPD.h"
24 #include "AliITSRecPoint.h"
25 #include "AliITSdigitSPD.h"
26 #include "AliITSsegmentationSPD.h"
31 ClassImp(AliITSClusterFinderSPD)
33 //______________________________________________________________________
34 AliITSClusterFinderSPD::AliITSClusterFinderSPD():AliITSClusterFinder(),
40 //----------------------------------------------------------
41 AliITSClusterFinderSPD::AliITSClusterFinderSPD(AliITSDetTypeRec* dettyp):
42 AliITSClusterFinder(dettyp),
51 //----------------------------------------------------------
52 AliITSClusterFinderSPD::AliITSClusterFinderSPD(AliITSDetTypeRec* dettyp,
55 AliITSClusterFinder(dettyp,digits),
67 //______________________________________________________________________
68 AliITSClusterFinderSPD::AliITSClusterFinderSPD(const AliITSClusterFinderSPD &source) : AliITSClusterFinder(source) {
70 // Copies are not allowed. The method is protected to avoid misuse.
71 Fatal("AliITSClusterFinderSPD","Copy constructor not allowed\n");
74 //______________________________________________________________________
75 //AliITSClusterFinderSPD& AliITSClusterFinderSPD::operator=(const AliITSClusterFinderSPD& /* source */){
76 // Assignment operator
77 // Assignment is not allowed. The method is protected to avoid misuse.
78 //Fatal("= operator","Assignment operator not allowed\n");
81 //______________________________________________________________________
82 void AliITSClusterFinderSPD::FindRawClusters(Int_t module){
83 // input of Cluster Finder
85 Int_t numberd = 100000;
86 Int_t *digx = new Int_t[numberd];
87 Int_t *digz = new Int_t[numberd];
88 Int_t *digtr1 = new Int_t[numberd];
89 Int_t *digtr2 = new Int_t[numberd];
90 Int_t *digtr3 = new Int_t[numberd];
91 Int_t *digtr4 = new Int_t[numberd];
92 // output of Cluster Finder
93 Int_t numberc = 10000;
94 Double_t *xcenterl = new Double_t[numberc];
95 Double_t *zcenterl = new Double_t[numberc];
96 Double_t *errxcenter = new Double_t[numberc];
97 Double_t *errzcenter = new Double_t[numberc];
98 Int_t *tr1clus = new Int_t[numberc];
99 Int_t *tr2clus = new Int_t[numberc];
100 Int_t *tr3clus = new Int_t[numberc];
105 Int_t ndigits = Digits()->GetEntriesFast();
106 if (!ndigits) return;
114 for(ndig=0; ndig<ndigits; ndig++) {
115 dig= (AliITSdigitSPD*)GetDigit(ndig);
116 digx[digitcount] = dig->GetCoord2()+1; //starts at 1
117 digz[digitcount] = dig->GetCoord1()+1; //starts at 1
118 digtr1[digitcount] = dig->GetTrack(0);
119 digtr2[digitcount] = -3;
120 digtr3[digitcount] = -3;
121 AliDebug(5,Form("digtr1[%d]=%d fTracks[%d]=%d: ",
122 digitcount,digtr1[digitcount],0,dig->GetTrack(0)));
124 while(digtr1[digitcount]==dig->GetTrack(i) && i<dig->GetNTracks()) i++;
125 AliDebug(5,Form(" fTracks[%d]=%d",i,dig->GetTrack(i)));
126 if(i<dig->GetNTracks()){
127 digtr2[digitcount] = dig->GetTrack(i);
128 AliDebug(5,Form("digtr2[%d]=%d: ",digitcount,digtr2[digitcount]));
129 while((digtr1[digitcount]==dig->GetTrack(i) ||
130 digtr2[digitcount]==dig->GetTrack(i))&&
131 i<=dig->GetNTracks()) i++;
132 if(i<dig->GetNTracks()) digtr3[digitcount] = dig->GetTrack(i);
133 AliDebug(5,Form(" fTracks[%d]=%d digtr3[%d]=%d",
134 i,i<dig->GetNTracks()?dig->GetTrack(i):-1,digitcount,digtr3[digitcount]));
136 // if(GetDebug(4)) cout<<endl;
137 digtr4[digitcount] = dig->GetSignal();
140 ClusterFinder(digitcount,digx,digz,digtr1,digtr2,digtr3,digtr4,
141 nclus,xcenterl,zcenterl,errxcenter,errzcenter,
142 tr1clus, tr2clus, tr3clus);
143 DigitToPoint(nclus,xcenterl,zcenterl,errxcenter,errzcenter,
144 tr1clus, tr2clus, tr3clus);
159 //----------------------------------------------------------------------
160 void AliITSClusterFinderSPD::ClusterFinder(Int_t ndigits,Int_t digx[],
161 Int_t digz[],Int_t digtr1[],
162 Int_t digtr2[],Int_t digtr3[],
163 Int_t digtr4[],Int_t &nclus,
164 Double_t xcenter[],Double_t zcenter[],
165 Double_t errxcenter[],
166 Double_t errzcenter[],
167 Int_t tr1clus[],Int_t tr2clus[],
169 // Search for clusters of fired pixels (digits). Two digits are linked
170 // inside a cluster if they are countiguous both in row or column
171 // direction. Diagonal digits are not linked.
172 // xcenter, ycenter, zcenter are the coordinates of the center
173 // of each found cluster, calculated from the averaging the corresponding
174 // coordinate of the center of the linked digits. The coordinates are
175 // given in the local reference sistem.
176 // errxcenter, errycenter, errzcenter are the errors associated to
177 // the corresponding average.
178 Int_t if1, min, max, nd;
179 Int_t x1, z1, t1, t2, t3, t4;
180 Int_t ndx, ndz, ndxmin=0, ndxmax=0, ndzmin=0, ndzmax=0;
185 Double_t deltax, deltaz;
187 Int_t numberd = 10000;
188 Int_t *ifpad = new Int_t[numberd];
189 Int_t *xpad = new Int_t[numberd];
190 Int_t *zpad = new Int_t[numberd];
191 Int_t *tr1pad = new Int_t[numberd];
192 Int_t *tr2pad = new Int_t[numberd];
193 Int_t *tr3pad = new Int_t[numberd];
194 Int_t *tr4pad = new Int_t[numberd];
195 Int_t *iclus = new Int_t[numberd];
198 for (i=0; i < ndigits ; i++){
204 for (i=0; i < ndigits-1 ; i++) {
205 if ( ifpad[i] == -1 ) {
210 for (Int_t j=i+1 ; j < ndigits ; j++) {
211 if (ifpad[j]== -1 ) {
212 dx = TMath::Abs(digx[i]-digx[j]);
213 dz = TMath::Abs(digz[i]-digz[j]);
214 // if ( ( dx+dz )==1 ) //clusters are not diagonal
215 if(( dx+dz )==1 || (dx==1 && dz==1)){
216 //diagonal clusters allowed
222 digx[j] = digx[ipos];
223 digz[j] = digz[ipos];
231 digtr1[j] = digtr1[ipos];
232 digtr2[j] = digtr2[ipos];
233 digtr3[j] = digtr3[ipos];
234 digtr4[j] = digtr4[ipos];
241 ifpad[j] = ifpad[ipos];
244 }// end if ifpad[j]== -1
246 }//end loop on digits
247 if ( ifpad[ndigits-1] == -1 ) {
249 ifpad[ndigits-1]=nclus-1;
250 } // end if ifpad[ndigits-1] == -1
252 for (i=0 ; i < ndigits ; i++) iclus[ifpad[i]]++;
256 // loop on found clusters
257 for (i=0 ; i < nclus ; i++){
260 deltax = GetSeg()->Dpx(0);
262 //cluster with more than one digit
266 for (k=min;k<min+nd;k++){
267 xpad[count] = digx[k];
268 zpad[count] = digz[k];
270 tr1pad[count] = digtr1[k];
271 tr2pad[count] = digtr2[k];
272 tr3pad[count] = digtr3[k];
273 tr4pad[count] = digtr4[k];
277 ndxmin = xpad[TMath::LocMin(nd,xpad)];
278 ndxmax = xpad[TMath::LocMax(nd,xpad)];
279 ndzmin = zpad[TMath::LocMin(nd,zpad)];
280 ndzmax = zpad[TMath::LocMax(nd,zpad)];
281 ndx = ndxmax - ndxmin+1;
282 ndz = ndzmax - ndzmin+1;
284 // calculate x and z coordinates of the center of the cluster
285 GetSeg()->GetPadCxz(digx[min],digz[min]-1,xdum, zdum);
292 GetSeg()->GetPadCxz(xpad[k],zpad[k]-1,xdum,zdum);
293 xcenter[i] += (xdum / nd);
302 GetSeg()->GetPadCxz(xpad[k],zpad[k]-1,xdum,zdum);
303 zcenter[i] += (zdum / nd);
307 // error on points in x and z directions
310 errxcenter[i] = deltax / TMath::Sqrt(12.);
314 GetSeg()->GetPadCxz(xpad[k],zpad[k]-1,xdum,zdum);
315 errxcenter[i] += ((xdum-xcenter[i])*(xdum-xcenter[i]))/
318 errxcenter[i] = TMath::Sqrt(errxcenter[i]);
321 deltaz = GetSeg()->Dpz(digz[min]);
322 errzcenter[i] = deltaz / TMath::Sqrt(12.);
326 GetSeg()->GetPadCxz(xpad[k],zpad[k]-1,xdum,zdum);
327 errzcenter[i] += ((zdum-zcenter[i])*(zdum-zcenter[i]))/
330 errzcenter[i] = TMath::Sqrt(errzcenter[i]);
332 // take three track numbers for the cluster
333 // choose the track numbers of the digit with higher signal
337 if(tr4pad[k] > sigmax){
340 } // end if tr4pad[k]
343 tr1clus[i]= tr1pad[kmax];
344 tr2clus[i]= tr2pad[kmax];
345 tr3clus[i]= tr3pad[kmax];
352 // cluster with single digit
356 GetSeg()->GetPadCxz(digx[min],digz[min]-1,xdum,zdum);
359 tr1clus[i]=digtr1[min];
360 tr2clus[i]=digtr2[min];
361 tr3clus[i]=digtr3[min];
362 deltaz = GetSeg()->Dpz(digz[min]);
363 errxcenter[i] = deltax / TMath::Sqrt(12.);
364 errzcenter[i] = deltaz / TMath::Sqrt(12.);
367 // store the cluster information to the AliITSRawCLusterSPD object
370 //put the cluster center in local reference frame of the detector
372 xcenter[i] = xcenter[i] - GetSeg()->Dx()/2.;
373 zcenter[i] = zcenter[i] - GetSeg()->Dz()/2.;
375 AliITSRawClusterSPD *clust = new AliITSRawClusterSPD(zcenter[i], //f
383 fDetTypeRec->AddCluster(0,clust);
385 }//end loop on clusters
395 //______________________________________________________----------------
396 void AliITSClusterFinderSPD::DigitToPoint(Int_t nclus,
397 Double_t *xcenter,Double_t *zcenter,
398 Double_t *errxcenter,
399 Double_t *errzcenter,
400 Int_t *tr1clus, Int_t *tr2clus,
402 // A point is associated to each cluster of SPD digits. The points
403 // and their associated errors are stored in the file galiceSP.root.
405 const Double_t kconv = 1.0e-4; // micron -> cm
408 fDetTypeRec->GetITSgeom()->GetModuleId(fModule,lay,lad,det);
409 Int_t ind=(lad-1)*fDetTypeRec->GetITSgeom()->GetNdetectors(lay)+(det-1);
412 for (Int_t i=0; i<nclus; i++){
413 l[0] = kconv*xcenter[i];
414 l[1] = kconv*GetSeg()->Dy()/2.;
415 l[2] = kconv*zcenter[i];
420 Double_t sigma2x = (kconv*errxcenter[i]) * (kconv*errxcenter[i]);
421 Double_t sigma2z = (kconv*errzcenter[i]) * (kconv*errzcenter[i]);
422 AliITSRecPoint rnew(fDetTypeRec->GetITSgeom());
423 rnew.SetXZ(fModule,xg,zg);
426 rnew.SetSigmaDetLocX2(sigma2x);
427 rnew.SetSigmaZ2(sigma2z);
428 rnew.SetLabel(tr1clus[i],0);
429 rnew.SetLabel(tr2clus[i],1);
430 rnew.SetLabel(tr3clus[i],2);
431 rnew.SetDetectorIndex(ind);
433 fDetTypeRec->AddRecPoint(rnew);