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 **************************************************************************/
18 //-----------------------------------------------------//
20 // Source File : PMDClusteringV2.cxx //
22 // clustering code for alice pmd //
24 //-----------------------------------------------------//
26 /* --------------------------------------------------------------------
27 Code developed by S. C. Phatak, Institute of Physics,
28 Bhubaneswar 751 005 ( phatak@iopb.res.in ) Given the energy deposited
29 ( or ADC value ) in each cell of supermodule ( pmd or cpv ), the code
30 builds up superclusters and breaks them into clusters. The input is
31 in TObjarray and cluster information is in TObjArray.
32 integer clno gives total number of clusters in the supermodule.
33 fClusters is the global ( public ) variables.
34 Others are local ( private ) to the code.
35 At the moment, the data is read for whole detector ( all supermodules
36 and pmd as well as cpv. This will have to be modify later )
37 LAST UPDATE : October 23, 2002
38 -----------------------------------------------------------------------*/
40 #include <Riostream.h>
42 #include <TObjArray.h>
45 #include "AliPMDcludata.h"
46 #include "AliPMDcluster.h"
47 #include "AliPMDClustering.h"
48 #include "AliPMDClusteringV2.h"
51 ClassImp(AliPMDClusteringV2)
53 const Double_t AliPMDClusteringV2::fgkSqroot3by2=0.8660254; // sqrt(3.)/2.
55 AliPMDClusteringV2::AliPMDClusteringV2():
56 fPMDclucont(new TObjArray()),
59 for(int i = 0; i < kNDIMX; i++)
61 for(int j = 0; j < kNDIMY; j++)
63 fCoord[0][i][j] = i+j/2.;
64 fCoord[1][i][j] = fgkSqroot3by2*j;
68 // ------------------------------------------------------------------------ //
71 AliPMDClusteringV2::AliPMDClusteringV2(const AliPMDClusteringV2& pmdclv2):
72 AliPMDClustering(pmdclv2),
77 AliError("Copy constructor not allowed ");
80 // ------------------------------------------------------------------------ //
81 AliPMDClusteringV2 &AliPMDClusteringV2::operator=(const AliPMDClusteringV2& /*pmdclv2*/)
84 AliError("Assignment operator not allowed ");
87 // ------------------------------------------------------------------------ //
88 AliPMDClusteringV2::~AliPMDClusteringV2()
92 // ------------------------------------------------------------------------ //
94 void AliPMDClusteringV2::DoClust(Int_t idet, Int_t ismn,
95 Double_t celladc[48][96], TObjArray *pmdcont)
97 // main function to call other necessary functions to do clustering
99 AliPMDcluster *pmdcl = 0;
101 const float ktwobysqrt3 = 1.1547; // 2./sqrt(3.)
103 Int_t i, j, nmx1, incr, id, jd;
106 Int_t celldataX[15], celldataY[15];
108 Double_t cutoff, ave;
109 Double_t edepcell[kNMX];
117 else if (ismn >= 12 && ismn <= 23)
123 for (Int_t i =0; i < kNMX; i++)
128 for (id = 0; id < ndimXr; id++)
130 for (jd = 0; jd < ndimYr; jd++)
133 i = id + (ndimYr/2-1) - (jd/2);
134 Int_t ij = i + j*kNDIMX;
137 edepcell[ij] = celladc[jd][id];
139 else if (ismn >= 12 && ismn <= 23)
141 edepcell[ij] = celladc[id][jd];
148 TMath::Sort((Int_t)kNMX,edepcell,iord1);// order the data
149 cutoff = fCutoff; // cutoff used to discard cells having ener. dep.
153 for(i = 0;i < kNMX; i++)
159 if(edepcell[i] > cutoff )
165 AliDebug(1,Form("Number of cells having energy >= %f are %d",cutoff,nmx1));
173 AliDebug(1,Form("Number of cells in a SuperM = %d and Average = %f",
176 incr = CrClust(ave, cutoff, nmx1,iord1, edepcell);
177 RefClust(incr,edepcell );
179 Int_t nentries1 = fPMDclucont->GetEntries();
180 AliDebug(1,Form("Detector Plane = %d Serial Module No = %d Number of clusters = %d",idet, ismn, nentries1));
181 AliDebug(1,Form("Total number of clusters/module = %d",nentries1));
182 for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
184 AliPMDcludata *pmdcludata =
185 (AliPMDcludata*)fPMDclucont->UncheckedAt(ient1);
186 Float_t cluXC = pmdcludata->GetClusX();
187 Float_t cluYC = pmdcludata->GetClusY();
188 Float_t cluADC = pmdcludata->GetClusADC();
189 Float_t cluCELLS = pmdcludata->GetClusCells();
190 Float_t cluSIGX = pmdcludata->GetClusSigmaX();
191 Float_t cluSIGY = pmdcludata->GetClusSigmaY();
193 Float_t cluY0 = ktwobysqrt3*cluYC;
194 Float_t cluX0 = cluXC - cluY0/2.;
197 // Cluster X centroid is back transformed
201 clusdata[0] = cluX0 - (24-1) + cluY0/2.;
203 else if (ismn >= 12 && ismn <= 23)
205 clusdata[0] = cluX0 - (48-1) + cluY0/2.;
209 clusdata[2] = cluADC;
210 clusdata[3] = cluCELLS;
211 clusdata[4] = cluSIGX;
212 clusdata[5] = cluSIGY;
214 // Cells associated with a cluster
216 for (Int_t ihit = 0; ihit < 15; ihit++)
218 Int_t dummyXY = pmdcludata->GetCellXY(ihit);
220 Int_t celldumY = dummyXY%10000;
221 Int_t celldumX = dummyXY/10000;
222 //Float_t cellY = (Float_t) (ktwobysqrt3*celldumY/10);
223 //Float_t cellX = (Float_t) (celldumX/10 - (celldumY/2.)/10);
225 Float_t cellY = (Float_t) celldumY/10;
226 Float_t cellX = (Float_t) celldumX/10;
230 // Cell X centroid is back transformed
234 celldataX[ihit] = (Int_t) ((cellX - (24-1) + cellY/2.) + 0.5);
236 else if (ismn >= 12 && ismn <= 23)
238 celldataX[ihit] = (Int_t) ((cellX - (48-1) + cellY/2.) + 0.5 );
240 celldataY[ihit] = (Int_t) (cellY + 0.5);
243 pmdcl = new AliPMDcluster(idet, ismn, clusdata, celldataX, celldataY);
246 fPMDclucont->Clear();
248 // ------------------------------------------------------------------------ //
249 Int_t AliPMDClusteringV2::CrClust(Double_t ave, Double_t cutoff, Int_t nmx1,
250 Int_t iord1[], Double_t edepcell[])
252 // Does crude clustering
253 // Finds out only the big patch by just searching the
257 Int_t i,j,k,id1,id2,icl, numcell;
258 Int_t jd1,jd2, icell, cellcount;
259 Int_t clust[2][5000];
260 static Int_t neibx[6] = {1,0,-1,-1,0,1}, neiby[6] = {0,1,1,0,-1,-1};
262 // neibx and neiby define ( incremental ) (i,j) for the neighbours of a
263 // cell. There are six neighbours.
264 // cellcount --- total number of cells having nonzero ener dep
265 // numcell --- number of cells in a given supercluster
267 AliDebug(1,Form("kNMX = %d nmx1 = %d kNDIMX = %d kNDIMY = %d ave = %f cutoff = %f",kNMX,nmx1,kNDIMX,kNDIMY,ave,cutoff));
269 for (j=0; j < kNDIMX; j++)
271 for(k=0; k < kNDIMY; k++)
273 fInfocl[0][j][k] = 0;
274 fInfocl[1][j][k] = 0;
278 for(i=0; i < kNMX; i++)
286 if(edepcell[j] <= cutoff)
288 fInfocl[0][id1][id2] = -1;
291 // ---------------------------------------------------------------
292 // crude clustering begins. Start with cell having largest adc
293 // count and loop over the cells in descending order of adc count
294 // ---------------------------------------------------------------
297 for(icell=0; icell <= nmx1; icell++)
302 if(fInfocl[0][id1][id2] == 0 )
304 // ---------------------------------------------------------------
305 // icl -- cluster #, numcell -- # of cells in it, clust -- stores
306 // coordinates of the cells in a cluster, fInfocl[0][i1][i2] is 1 for
307 // primary and 2 for secondary cells,
308 // fInfocl[1][i1][i2] stores cluster #
309 // ---------------------------------------------------------------
313 fInfocl[0][id1][id2] = 1;
314 fInfocl[1][id1][id2] = icl;
315 fInfcl[0][cellcount] = icl;
316 fInfcl[1][cellcount] = id1;
317 fInfcl[2][cellcount] = id2;
319 clust[0][numcell] = id1;
320 clust[1][numcell] = id2;
321 for(i = 1; i < 5000; i++)
325 // ---------------------------------------------------------------
326 // check for adc count in neib. cells. If ne 0 put it in this clust
327 // ---------------------------------------------------------------
328 for(i = 0; i < 6; i++)
330 jd1 = id1 + neibx[i];
331 jd2 = id2 + neiby[i];
332 if( (jd1 >= 0 && jd1 < kNDIMX) && (jd2 >= 0 && jd2 < kNDIMY) &&
333 fInfocl[0][jd1][jd2] == 0)
336 fInfocl[0][jd1][jd2] = 2;
337 fInfocl[1][jd1][jd2] = icl;
338 clust[0][numcell] = jd1;
339 clust[1][numcell] = jd2;
341 fInfcl[0][cellcount] = icl;
342 fInfcl[1][cellcount] = jd1;
343 fInfcl[2][cellcount] = jd2;
346 // ---------------------------------------------------------------
347 // check adc count for neighbour's neighbours recursively and
348 // if nonzero, add these to the cluster.
349 // ---------------------------------------------------------------
350 for(i = 1;i < 5000; i++)
352 if(clust[0][i] != -1)
356 for(j = 0; j < 6 ; j++)
358 jd1 = id1 + neibx[j];
359 jd2 = id2 + neiby[j];
360 if( (jd1 >= 0 && jd1 < kNDIMX) &&
361 (jd2 >= 0 && jd2 < kNDIMY)
362 && fInfocl[0][jd1][jd2] == 0 )
364 fInfocl[0][jd1][jd2] = 2;
365 fInfocl[1][jd1][jd2] = icl;
367 clust[0][numcell] = jd1;
368 clust[1][numcell] = jd2;
370 fInfcl[0][cellcount] = icl;
371 fInfcl[1][cellcount] = jd1;
372 fInfcl[2][cellcount] = jd2;
381 // ------------------------------------------------------------------------ //
382 void AliPMDClusteringV2::RefClust(Int_t incr, Double_t edepcell[])
384 // Does the refining of clusters
385 // Takes the big patch and does gaussian fitting and
386 // finds out the more refined clusters
388 const Float_t ktwobysqrt3 = 1.1547;
389 AliPMDcludata *pmdcludata = 0;
392 Int_t i, j, k, i1, i2, id, icl, itest, ihld;
393 Int_t ig, nsupcl, clno, clX,clY;
397 Double_t x1, y1, z1, x2, y2, z2, rr;
399 Int_t kndim = incr + 1;
406 Double_t *x, *y, *z, *xc, *yc, *zc, *cells, *rcl, *rcs;
408 ncl = new Int_t [kndim];
409 iord = new Int_t [kndim];
410 x = new Double_t [kndim];
411 y = new Double_t [kndim];
412 z = new Double_t [kndim];
413 xc = new Double_t [kndim];
414 yc = new Double_t [kndim];
415 zc = new Double_t [kndim];
416 cells = new Double_t [kndim];
417 rcl = new Double_t [kndim];
418 rcs = new Double_t [kndim];
420 for(Int_t kk = 0; kk < 15; kk++)
422 if( kk < 6 )clusdata[kk] = 0.;
425 // nsupcl = # of superclusters; ncl[i]= # of cells in supercluster i
426 // x, y and z store (x,y) coordinates of and energy deposited in a cell
427 // xc, yc store (x,y) coordinates of the cluster center
428 // zc stores the energy deposited in a cluster, rc is cluster radius
433 for(i = 0; i < kndim; i++)
437 for(i = 0; i <= incr; i++)
439 if(fInfcl[0][i] != nsupcl)
445 AliWarning("RefClust: Too many superclusters!");
452 AliDebug(1,Form("Number of cells = %d Number of Superclusters = %d",
457 for(i = 0; i <= nsupcl; i++)
463 // one cell super-clusters --> single cluster
464 // cluster center at the centyer of the cell
465 // cluster radius = half cell dimension
468 AliWarning("RefClust: Too many clusters! more than 5000");
474 Int_t i12 = i1 + i2*kNDIMX;
475 clusdata[0] = fCoord[0][i1][i2];
476 clusdata[1] = fCoord[1][i1][i2];
477 clusdata[2] = edepcell[i12];
483 //Float_t cellY = (Float_t) (ktwobysqrt3*celldumY/10);
484 //Float_t cellX = (Float_t) (celldumX/10 - (celldumY/2.)/10);
486 clY = (Int_t)((ktwobysqrt3*fCoord[1][i1][i2])*10);
487 clX = (Int_t)((fCoord[0][i1][i2] - clY/20.)*10);
488 clxy[0] = clX*10000 + clY ;
490 //clX = (Int_t) fCoord[0][i1][i2]*10;
491 //clY = (Int_t) fCoord[1][i1][i2]*10;
492 //clxy[0] = clX*10000 + clY;
495 for(Int_t icltr = 1; icltr < 15; icltr++)
499 pmdcludata = new AliPMDcludata(clusdata,clxy);
500 fPMDclucont->Add(pmdcludata);
506 // two cell super-cluster --> single cluster
507 // cluster center is at ener. dep.-weighted mean of two cells
508 // cluster radius == half cell dimension
513 AliWarning("RefClust: Too many clusters! more than 5000");
519 Int_t i12 = i1 + i2*kNDIMX;
521 x1 = fCoord[0][i1][i2];
522 y1 = fCoord[1][i1][i2];
528 i12 = i1 + i2*kNDIMX;
530 x2 = fCoord[0][i1][i2];
531 y2 = fCoord[1][i1][i2];
534 clusdata[0] = (x1*z1+x2*z2)/(z1+z2);
535 clusdata[1] = (y1*z1+y2*z2)/(z1+z2);
538 clusdata[4] = (TMath::Sqrt(z1*z2))/(z1+z2);
541 clY = (Int_t)((ktwobysqrt3*y1)*10);
542 clX = (Int_t)((x1 - clY/20.)*10);
543 clxy[0] = clX*10000 + clY ;
545 //clX = (Int_t) x1*10;
546 //clY = (Int_t) y1*10;
547 //clxy[0] = clX*10000 + clY;
549 clY = (Int_t)((ktwobysqrt3*y2)*10);
550 clX = (Int_t)((x2 - clY/20.)*10);
551 clxy[1] = clX*10000 + clY ;
553 //clX = (Int_t) x2*10;
554 //clY = (Int_t) y2*10;
555 //clxy[1] = clX*10000 + clY;
557 for(Int_t icltr = 2; icltr < 15; icltr++)
561 pmdcludata = new AliPMDcludata(clusdata, clxy);
562 fPMDclucont->Add(pmdcludata);
567 // super-cluster of more than two cells - broken up into smaller
568 // clusters gaussian centers computed. (peaks separated by > 1 cell)
569 // Begin from cell having largest energy deposited This is first
571 // *****************************************************************
572 // NOTE --- POSSIBLE MODIFICATION: ONE MAY NOT BREAKING SUPERCLUSTERS
573 // IF NO. OF CELLS IS NOT TOO LARGE ( SAY 5 OR 6 )
574 // SINCE WE EXPECT THE SUPERCLUSTER
575 // TO BE A SINGLE CLUSTER
576 //*******************************************************************
580 Int_t i12 = i1 + i2*kNDIMX;
582 x[0] = fCoord[0][i1][i2];
583 y[0] = fCoord[1][i1][i2];
584 z[0] = edepcell[i12];
587 for(j = 1; j <= ncl[i]; j++)
593 Int_t i12 = i1 + i2*kNDIMX;
595 x[j] = fCoord[0][i1][i2];
596 y[j] = fCoord[1][i1][i2];
597 z[j] = edepcell[i12];
600 // arranging cells within supercluster in decreasing order
601 for(j = 1; j <= ncl[i];j++)
605 for(i1 = 0; i1 < j; i1++)
607 if(itest == 0 && z[iord[i1]] < z[ihld])
610 for(i2 = j-1;i2 >= i1;i2--)
612 iord[i2+1] = iord[i2];
620 // compute the number of clusters and their centers ( first
622 // centers must be separated by cells having smaller ener. dep.
623 // neighbouring centers should be either strong or well-separated
628 for(j = 1; j <= ncl[i]; j++)
633 for(k = 0; k <= ig; k++)
637 rr = Distance(x1,y1,x2,y2);
638 //************************************************************
639 // finetuning cluster splitting
640 // the numbers zc/4 and zc/10 may need to be changed.
641 // Also one may need to add one more layer because our
642 // cells are smaller in absolute scale
643 //************************************************************
646 if( rr >= 1.1 && rr < 1.8 && z[iord[j]] > zc[k]/4.) itest++;
647 if( rr >= 1.8 && rr < 2.1 && z[iord[j]] > zc[k]/10.) itest++;
648 if( rr >= 2.1)itest++;
659 ClustDetails(ncl[i], ig, x, y ,z, xc, yc, zc, rcl, rcs, cells,
663 for(j = 0; j <= ig; j++)
668 AliWarning("RefClust: Too many clusters! more than 5000");
674 clusdata[4] = rcl[j];
675 clusdata[5] = rcs[j];
678 clusdata[3] = ncl[i] + 1;//ajay
679 //clusdata[3] = ncl[i] ;
683 clusdata[3] = cells[j];
686 Int_t ncellcls = testncl[j];
689 for(Int_t kk = 1; kk <= ncellcls; kk++)
691 Int_t ll = testindex[pp];
692 clY = (Int_t)((ktwobysqrt3*y[ll])*10);
693 clX = (Int_t)((x[ll] - clY/20.)*10);
694 clxy[kk-1] = clX*10000 + clY ;
697 //clX = (Int_t) x[ll]*10;
698 //clY = (Int_t) y[ll]*10;
699 //clxy[kk-1] = (Int_t) clX*10000 + clY ;
702 for(Int_t icltr = ncellcls ; icltr < 15; icltr++)
707 pmdcludata = new AliPMDcludata(clusdata, clxy);
708 fPMDclucont->Add(pmdcludata);
726 // ------------------------------------------------------------------------ //
727 void AliPMDClusteringV2::ClustDetails(Int_t ncell, Int_t nclust, Double_t x[],
728 Double_t y[], Double_t z[],Double_t xc[],
729 Double_t yc[], Double_t zc[],
730 Double_t rcl[], Double_t rcs[],
731 Double_t cells[], TArrayI &testncl,
737 Int_t kndim1 = ncell + 1;//ncell
739 Int_t kndim3 = nclust + 1;//nclust
741 Int_t i, j, k, i1, i2;
742 Double_t x1, y1, x2, y2, rr, b, c, r1, r2;
743 Double_t sumx, sumy, sumxy, sumxx, sum, sum1, sumyy;
745 Double_t *str, *str1, *xcl, *ycl, *cln;
748 Double_t **clustcell;
749 str = new Double_t [kndim3];
750 str1 = new Double_t [kndim3];
751 xcl = new Double_t [kndim3];
752 ycl = new Double_t [kndim3];
753 cln = new Double_t [kndim3];
755 clustcell = new Double_t *[kndim3];
756 cell = new Int_t *[kndim3];
757 cluster = new Int_t *[kndim1];
758 for(i = 0; i < kndim1; i++)
760 cluster[i] = new Int_t [kndim2];
763 for(i = 0; i < kndim3; i++)
771 cell[i] = new Int_t [kndim2];
772 clustcell[i] = new Double_t [kndim1];
773 for(j = 0; j < kndim1; j++)
777 for(j = 0; j < kndim2; j++)
786 // more than one cluster
787 // checking cells shared between several clusters.
788 // First check if the cell is within
789 // one cell unit ( nearest neighbour). Else,
790 // if it is within 1.74 cell units ( next nearest )
791 // Else if it is upto 2 cell units etc.
793 for (i = 0; i <= ncell; i++)
798 // distance <= 1 cell unit
799 for(j = 0; j <= nclust; j++)
803 rr = Distance(x1, y1, x2, y2);
811 // next nearest neighbour
812 if(cluster[i][0] == 0)
814 for(j=0; j<=nclust; j++)
818 rr = Distance(x1, y1, x2, y2);
819 if(rr <= TMath::Sqrt(3.))
827 // next-to-next nearest neighbour
828 if(cluster[i][0] == 0)
830 for(j=0; j<=nclust; j++)
834 rr = Distance(x1, y1, x2, y2);
844 if(cluster[i][0] == 0)
846 for(j = 0; j <= nclust; j++)
850 rr = Distance(x1, y1, x2, y2);
861 // computing cluster strength. Some cells are shared.
862 for(i = 0; i <= ncell; i++)
864 if(cluster[i][0] != 0)
867 for(j = 1; j <= i1; j++)
875 for(k = 0; k < 5; k++)
877 for(i = 0; i <= ncell; i++)
879 if(cluster[i][0] != 0)
883 for(j = 1; j <= i1; j++)
885 sum += str[cluster[i][j]];
888 for(j = 1; j <= i1; j++)
891 str1[i2] += z[i]*str[i2]/sum;
892 clustcell[i2][i] = z[i]*str[i2]/sum;
898 for(j = 0; j <= nclust; j++)
905 for(i = 0; i <= nclust; i++)
911 for(j = 0; j <= ncell; j++)
913 if(clustcell[i][j] != 0)
915 sumx += clustcell[i][j]*x[j];
916 sumy += clustcell[i][j]*y[j];
917 sum += clustcell[i][j];
918 sum1 += clustcell[i][j]/z[j];
921 //** xcl and ycl are cluster centroid positions ( center of gravity )
929 for(j = 0; j <= ncell; j++)
931 sumxx += clustcell[i][j]*(x[j]-xcl[i])*(x[j]-xcl[i])/sum;
932 sumyy += clustcell[i][j]*(y[j]-ycl[i])*(y[j]-ycl[i])/sum;
933 sumxy += clustcell[i][j]*(x[j]-xcl[i])*(y[j]-ycl[i])/sum;
936 c = sumxx*sumyy-sumxy*sumxy;
937 // ******************r1 and r2 are major and minor axes ( r1 > r2 ).
938 r1 = b/2.+TMath::Sqrt(b*b/4.-c);
939 r2 = b/2.-TMath::Sqrt(b*b/4.-c);
940 // final assignments to proper external variables
950 //To get the cell position in a cluster
952 for(Int_t ii=0; ii<= ncell; ii++)
954 Int_t jj = cluster[ii][0];
955 for(Int_t kk=1; kk<= jj; kk++)
957 Int_t ll = cluster[ii][kk];
959 cell[ll][cell[ll][0]] = ii;
963 testncl.Set(nclust+1);
966 for(Int_t ii=0; ii <= nclust; ii++)
968 testncl[ii] = cell[ii][0];
969 counter += testncl[ii];
971 testindex.Set(counter);
973 for(Int_t ii=0; ii<= nclust; ii++)
975 for(Int_t jj = 1; jj<= testncl[ii]; jj++)
977 Int_t kk = cell[ii][jj];
991 for(j = 0; j <= ncell; j++)
1004 for(j = 0; j <= ncell; j++)
1006 sumxx += clustcell[i][j]*(x[j]-xcl[i])*(x[j]-xcl[i])/sum;
1007 sumyy += clustcell[i][j]*(y[j]-ycl[i])*(y[j]-ycl[i])/sum;
1008 sumxy += clustcell[i][j]*(x[j]-xcl[i])*(y[j]-ycl[i])/sum;
1011 c = sumxx*sumyy-sumxy*sumxy;
1012 r1 = b/2.+ TMath::Sqrt(b*b/4.-c);
1013 r2 = b/2.- TMath::Sqrt(b*b/4.-c);
1015 // To get the cell position in a cluster
1016 testncl.Set(nclust+1);
1017 //testindex.Set(ncell);
1018 testindex.Set(ncell+1);
1019 cell[0][0] = ncell + 1;//ajay
1020 //cell[0][0] = ncell;
1021 testncl[0] = cell[0][0];
1023 for(Int_t ii = 1; ii <= ncell; ii++)
1026 //clustcell[0][ii]=1.;
1027 Int_t kk = cell[0][ii];
1031 // final assignments
1034 //zc[i] = str[i];//ajay
1040 for(i = 0; i < kndim3; i++)
1042 delete [] clustcell[i];
1045 delete [] clustcell;
1047 for(i = 0; i <kndim1 ; i++)
1049 delete [] cluster[i];
1059 // ------------------------------------------------------------------------ //
1060 Double_t AliPMDClusteringV2::Distance(Double_t x1, Double_t y1,
1061 Double_t x2, Double_t y2)
1063 return TMath::Sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
1065 // ------------------------------------------------------------------------ //
1066 void AliPMDClusteringV2::SetEdepCut(Float_t decut)
1070 // ------------------------------------------------------------------------ //