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()),
60 for(int i = 0; i < kNDIMX; i++)
62 for(int j = 0; j < kNDIMY; j++)
64 fCoord[0][i][j] = i+j/2.;
65 fCoord[1][i][j] = fgkSqroot3by2*j;
69 // ------------------------------------------------------------------------ //
72 AliPMDClusteringV2::AliPMDClusteringV2(const AliPMDClusteringV2& pmdclv2):
73 AliPMDClustering(pmdclv2),
79 AliError("Copy constructor not allowed ");
82 // ------------------------------------------------------------------------ //
83 AliPMDClusteringV2 &AliPMDClusteringV2::operator=(const AliPMDClusteringV2& /*pmdclv2*/)
86 AliError("Assignment operator not allowed ");
89 // ------------------------------------------------------------------------ //
90 AliPMDClusteringV2::~AliPMDClusteringV2()
94 // ------------------------------------------------------------------------ //
96 void AliPMDClusteringV2::DoClust(Int_t idet, Int_t ismn,
97 Int_t celltrack[48][96],
98 Int_t cellpid[48][96],
99 Double_t celladc[48][96],
102 // main function to call other necessary functions to do clustering
104 AliPMDcluster *pmdcl = 0;
106 const Float_t ktwobysqrt3 = 1.1547; // 2./sqrt(3.)
107 const Int_t kNmaxCell = 19; // # of cells surrounding a cluster center
108 Int_t i, j, nmx1, incr, id, jd;
111 Int_t celldataX[kNmaxCell], celldataY[kNmaxCell];
112 Int_t celldataTr[kNmaxCell], celldataPid[kNmaxCell];
113 Float_t celldataAdc[kNmaxCell];
115 Double_t cutoff, ave;
116 Double_t edepcell[kNMX];
124 else if (ismn >= 12 && ismn <= 23)
130 for (i =0; i < kNMX; i++)
135 for (id = 0; id < ndimXr; id++)
137 for (jd = 0; jd < ndimYr; jd++)
140 i = id + (ndimYr/2-1) - (jd/2);
141 Int_t ij = i + j*kNDIMX;
144 edepcell[ij] = celladc[jd][id];
146 else if (ismn >= 12 && ismn <= 23)
148 edepcell[ij] = celladc[id][jd];
155 TMath::Sort((Int_t)kNMX,edepcell,iord1);// order the data
156 cutoff = fCutoff; // cutoff used to discard cells having ener. dep.
160 for(i = 0;i < kNMX; i++)
166 if(edepcell[i] > cutoff )
172 AliDebug(1,Form("Number of cells having energy >= %f are %d",cutoff,nmx1));
180 AliDebug(1,Form("Number of cells in a SuperM = %d and Average = %f",
183 incr = CrClust(ave, cutoff, nmx1,iord1, edepcell);
184 RefClust(incr,edepcell );
186 Int_t nentries1 = fPMDclucont->GetEntries();
187 AliDebug(1,Form("Detector Plane = %d Serial Module No = %d Number of clusters = %d",idet, ismn, nentries1));
188 AliDebug(1,Form("Total number of clusters/module = %d",nentries1));
189 for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
191 AliPMDcludata *pmdcludata =
192 (AliPMDcludata*)fPMDclucont->UncheckedAt(ient1);
193 Float_t cluXC = pmdcludata->GetClusX();
194 Float_t cluYC = pmdcludata->GetClusY();
195 Float_t cluADC = pmdcludata->GetClusADC();
196 Float_t cluCELLS = pmdcludata->GetClusCells();
197 Float_t cluSIGX = pmdcludata->GetClusSigmaX();
198 Float_t cluSIGY = pmdcludata->GetClusSigmaY();
200 Float_t cluY0 = ktwobysqrt3*cluYC;
201 Float_t cluX0 = cluXC - cluY0/2.;
204 // Cluster X centroid is back transformed
208 clusdata[0] = cluX0 - (24-1) + cluY0/2.;
210 else if (ismn >= 12 && ismn <= 23)
212 clusdata[0] = cluX0 - (48-1) + cluY0/2.;
216 clusdata[2] = cluADC;
217 clusdata[3] = cluCELLS;
218 clusdata[4] = cluSIGX;
219 clusdata[5] = cluSIGY;
221 // Cells associated with a cluster
223 for (Int_t ihit = 0; ihit < kNmaxCell; ihit++)
225 Int_t dummyXY = pmdcludata->GetCellXY(ihit);
227 Int_t celldumY = dummyXY%10000;
228 Int_t celldumX = dummyXY/10000;
229 Float_t cellY = (Float_t) celldumY/10;
230 Float_t cellX = (Float_t) celldumX/10;
233 // Cell X centroid is back transformed
237 celldataX[ihit] = (Int_t) ((cellX - (24-1) + cellY/2.) + 0.5);
239 else if (ismn >= 12 && ismn <= 23)
241 celldataX[ihit] = (Int_t) ((cellX - (48-1) + cellY/2.) + 0.5 );
243 celldataY[ihit] = (Int_t) (cellY + 0.5);
245 Int_t irow = celldataX[ihit];
246 Int_t icol = celldataY[ihit];
248 if ((irow >= 0 && irow < 48) && (icol >= 0 && icol < 96))
250 celldataTr[ihit] = celltrack[irow][icol];
251 celldataPid[ihit] = cellpid[irow][icol];
252 celldataAdc[ihit] = (Float_t) celladc[irow][icol];
256 celldataTr[ihit] = -1;
257 celldataPid[ihit] = -1;
258 celldataAdc[ihit] = -1;
263 pmdcl = new AliPMDcluster(idet, ismn, clusdata, celldataX, celldataY,
264 celldataTr, celldataPid, celldataAdc);
267 fPMDclucont->Delete();
269 // ------------------------------------------------------------------------ //
270 Int_t AliPMDClusteringV2::CrClust(Double_t ave, Double_t cutoff, Int_t nmx1,
271 Int_t iord1[], Double_t edepcell[])
273 // Does crude clustering
274 // Finds out only the big patch by just searching the
278 Int_t i,j,k,id1,id2,icl, numcell;
279 Int_t jd1,jd2, icell, cellcount;
280 Int_t clust[2][5000];
281 static Int_t neibx[6] = {1,0,-1,-1,0,1}, neiby[6] = {0,1,1,0,-1,-1};
283 // neibx and neiby define ( incremental ) (i,j) for the neighbours of a
284 // cell. There are six neighbours.
285 // cellcount --- total number of cells having nonzero ener dep
286 // numcell --- number of cells in a given supercluster
288 AliDebug(1,Form("kNMX = %d nmx1 = %d kNDIMX = %d kNDIMY = %d ave = %f cutoff = %f",kNMX,nmx1,kNDIMX,kNDIMY,ave,cutoff));
290 for (j=0; j < kNDIMX; j++)
292 for(k=0; k < kNDIMY; k++)
294 fInfocl[0][j][k] = 0;
295 fInfocl[1][j][k] = 0;
299 for(i=0; i < kNMX; i++)
307 if(edepcell[j] <= cutoff)
309 fInfocl[0][id1][id2] = -1;
312 // ---------------------------------------------------------------
313 // crude clustering begins. Start with cell having largest adc
314 // count and loop over the cells in descending order of adc count
315 // ---------------------------------------------------------------
318 for(icell=0; icell <= nmx1; icell++)
323 if(fInfocl[0][id1][id2] == 0 )
325 // ---------------------------------------------------------------
326 // icl -- cluster #, numcell -- # of cells in it, clust -- stores
327 // coordinates of the cells in a cluster, fInfocl[0][i1][i2] is 1 for
328 // primary and 2 for secondary cells,
329 // fInfocl[1][i1][i2] stores cluster #
330 // ---------------------------------------------------------------
334 fInfocl[0][id1][id2] = 1;
335 fInfocl[1][id1][id2] = icl;
336 fInfcl[0][cellcount] = icl;
337 fInfcl[1][cellcount] = id1;
338 fInfcl[2][cellcount] = id2;
340 clust[0][numcell] = id1;
341 clust[1][numcell] = id2;
342 for(i = 1; i < 5000; i++)
346 // ---------------------------------------------------------------
347 // check for adc count in neib. cells. If ne 0 put it in this clust
348 // ---------------------------------------------------------------
349 for(i = 0; i < 6; i++)
351 jd1 = id1 + neibx[i];
352 jd2 = id2 + neiby[i];
353 if( (jd1 >= 0 && jd1 < kNDIMX) && (jd2 >= 0 && jd2 < kNDIMY) &&
354 fInfocl[0][jd1][jd2] == 0)
357 fInfocl[0][jd1][jd2] = 2;
358 fInfocl[1][jd1][jd2] = icl;
359 clust[0][numcell] = jd1;
360 clust[1][numcell] = jd2;
362 fInfcl[0][cellcount] = icl;
363 fInfcl[1][cellcount] = jd1;
364 fInfcl[2][cellcount] = jd2;
367 // ---------------------------------------------------------------
368 // check adc count for neighbour's neighbours recursively and
369 // if nonzero, add these to the cluster.
370 // ---------------------------------------------------------------
371 for(i = 1;i < 5000; i++)
373 if(clust[0][i] != -1)
377 for(j = 0; j < 6 ; j++)
379 jd1 = id1 + neibx[j];
380 jd2 = id2 + neiby[j];
381 if( (jd1 >= 0 && jd1 < kNDIMX) &&
382 (jd2 >= 0 && jd2 < kNDIMY)
383 && fInfocl[0][jd1][jd2] == 0 )
385 fInfocl[0][jd1][jd2] = 2;
386 fInfocl[1][jd1][jd2] = icl;
388 clust[0][numcell] = jd1;
389 clust[1][numcell] = jd2;
391 fInfcl[0][cellcount] = icl;
392 fInfcl[1][cellcount] = jd1;
393 fInfcl[2][cellcount] = jd2;
402 // ------------------------------------------------------------------------ //
403 void AliPMDClusteringV2::RefClust(Int_t incr, Double_t edepcell[])
405 // Does the refining of clusters
406 // Takes the big patch and does gaussian fitting and
407 // finds out the more refined clusters
409 const Float_t ktwobysqrt3 = 1.1547;
410 const Int_t kNmaxCell = 19;
412 AliPMDcludata *pmdcludata = 0;
415 Int_t i, j, k, i1, i2, id, icl, itest, ihld;
416 Int_t ig, nsupcl, clno, clX,clY;
417 Int_t clxy[kNmaxCell];
420 Double_t x1, y1, z1, x2, y2, z2, rr;
422 Int_t kndim = incr + 1;
429 Double_t *x, *y, *z, *xc, *yc, *zc, *cells, *rcl, *rcs;
431 ncl = new Int_t [kndim];
432 iord = new Int_t [kndim];
433 x = new Double_t [kndim];
434 y = new Double_t [kndim];
435 z = new Double_t [kndim];
436 xc = new Double_t [kndim];
437 yc = new Double_t [kndim];
438 zc = new Double_t [kndim];
439 cells = new Double_t [kndim];
440 rcl = new Double_t [kndim];
441 rcs = new Double_t [kndim];
443 for(Int_t kk = 0; kk < 15; kk++)
445 if( kk < 6 )clusdata[kk] = 0.;
448 // nsupcl = # of superclusters; ncl[i]= # of cells in supercluster i
449 // x, y and z store (x,y) coordinates of and energy deposited in a cell
450 // xc, yc store (x,y) coordinates of the cluster center
451 // zc stores the energy deposited in a cluster, rc is cluster radius
456 for(i = 0; i < kndim; i++)
460 for(i = 0; i <= incr; i++)
462 if(fInfcl[0][i] != nsupcl)
468 AliWarning("RefClust: Too many superclusters!");
475 AliDebug(1,Form("Number of cells = %d Number of Superclusters = %d",
480 for(i = 0; i <= nsupcl; i++)
486 // one cell super-clusters --> single cluster
487 // cluster center at the centyer of the cell
488 // cluster radius = half cell dimension
491 AliWarning("RefClust: Too many clusters! more than 5000");
497 i12 = i1 + i2*kNDIMX;
498 clusdata[0] = fCoord[0][i1][i2];
499 clusdata[1] = fCoord[1][i1][i2];
500 clusdata[2] = edepcell[i12];
507 clY = (Int_t)((ktwobysqrt3*fCoord[1][i1][i2])*10);
508 clX = (Int_t)((fCoord[0][i1][i2] - clY/20.)*10);
509 clxy[0] = clX*10000 + clY ;
511 for(Int_t icltr = 1; icltr < kNmaxCell; icltr++)
515 pmdcludata = new AliPMDcludata(clusdata,clxy);
516 fPMDclucont->Add(pmdcludata);
522 // two cell super-cluster --> single cluster
523 // cluster center is at ener. dep.-weighted mean of two cells
524 // cluster radius == half cell dimension
529 AliWarning("RefClust: Too many clusters! more than 5000");
535 i12 = i1 + i2*kNDIMX;
537 x1 = fCoord[0][i1][i2];
538 y1 = fCoord[1][i1][i2];
544 i12 = i1 + i2*kNDIMX;
546 x2 = fCoord[0][i1][i2];
547 y2 = fCoord[1][i1][i2];
550 clusdata[0] = (x1*z1+x2*z2)/(z1+z2);
551 clusdata[1] = (y1*z1+y2*z2)/(z1+z2);
554 clusdata[4] = (TMath::Sqrt(z1*z2))/(z1+z2);
557 clY = (Int_t)((ktwobysqrt3*y1)*10);
558 clX = (Int_t)((x1 - clY/20.)*10);
559 clxy[0] = clX*10000 + clY ;
561 clY = (Int_t)((ktwobysqrt3*y2)*10);
562 clX = (Int_t)((x2 - clY/20.)*10);
563 clxy[1] = clX*10000 + clY ;
565 for(Int_t icltr = 2; icltr < kNmaxCell; icltr++)
569 pmdcludata = new AliPMDcludata(clusdata, clxy);
570 fPMDclucont->Add(pmdcludata);
575 // super-cluster of more than two cells - broken up into smaller
576 // clusters gaussian centers computed. (peaks separated by > 1 cell)
577 // Begin from cell having largest energy deposited This is first
579 // *****************************************************************
580 // NOTE --- POSSIBLE MODIFICATION: ONE MAY NOT BREAKING SUPERCLUSTERS
581 // IF NO. OF CELLS IS NOT TOO LARGE ( SAY 5 OR 6 )
582 // SINCE WE EXPECT THE SUPERCLUSTER
583 // TO BE A SINGLE CLUSTER
584 //*******************************************************************
588 i12 = i1 + i2*kNDIMX;
590 x[0] = fCoord[0][i1][i2];
591 y[0] = fCoord[1][i1][i2];
592 z[0] = edepcell[i12];
595 for(j = 1; j <= ncl[i]; j++)
601 i12 = i1 + i2*kNDIMX;
603 x[j] = fCoord[0][i1][i2];
604 y[j] = fCoord[1][i1][i2];
605 z[j] = edepcell[i12];
608 // arranging cells within supercluster in decreasing order
609 for(j = 1; j <= ncl[i];j++)
613 for(i1 = 0; i1 < j; i1++)
615 if(itest == 0 && z[iord[i1]] < z[ihld])
618 for(i2 = j-1;i2 >= i1;i2--)
620 iord[i2+1] = iord[i2];
628 // compute the number of clusters and their centers ( first
630 // centers must be separated by cells having smaller ener. dep.
631 // neighbouring centers should be either strong or well-separated
636 for(j = 1; j <= ncl[i]; j++)
641 for(k = 0; k <= ig; k++)
645 rr = Distance(x1,y1,x2,y2);
646 //************************************************************
647 // finetuning cluster splitting
648 // the numbers zc/4 and zc/10 may need to be changed.
649 // Also one may need to add one more layer because our
650 // cells are smaller in absolute scale
651 //************************************************************
654 if( rr >= 1.1 && rr < 1.8 && z[iord[j]] > zc[k]/4.) itest++;
655 if( rr >= 1.8 && rr < 2.1 && z[iord[j]] > zc[k]/10.) itest++;
656 if( rr >= 2.1)itest++;
667 ClustDetails(ncl[i], ig, x, y ,z, xc, yc, zc, rcl, rcs, cells,
671 for(j = 0; j <= ig; j++)
676 AliWarning("RefClust: Too many clusters! more than 5000");
682 clusdata[4] = rcl[j];
683 clusdata[5] = rcs[j];
686 clusdata[3] = ncl[i] + 1;
690 clusdata[3] = cells[j];
693 Int_t ncellcls = testncl[j];
694 if( ncellcls < kNmaxCell )
696 for(Int_t kk = 1; kk <= ncellcls; kk++)
698 Int_t ll = testindex[pp];
699 clY = (Int_t)((ktwobysqrt3*y[ll])*10);
700 clX = (Int_t)((x[ll] - clY/20.)*10);
701 clxy[kk-1] = clX*10000 + clY ;
705 for(Int_t icltr = ncellcls ; icltr < kNmaxCell; icltr++)
710 pmdcludata = new AliPMDcludata(clusdata, clxy);
711 fPMDclucont->Add(pmdcludata);
729 // ------------------------------------------------------------------------ //
730 void AliPMDClusteringV2::ClustDetails(Int_t ncell, Int_t nclust, Double_t x[],
731 Double_t y[], Double_t z[],Double_t xc[],
732 Double_t yc[], Double_t zc[],
733 Double_t rcl[], Double_t rcs[],
734 Double_t cells[], TArrayI &testncl,
740 Int_t kndim1 = ncell + 1;//ncell
742 Int_t kndim3 = nclust + 1;//nclust
744 Int_t i, j, k, i1, i2;
745 Double_t x1, y1, x2, y2, rr, b, c, r1, r2;
746 Double_t sumx, sumy, sumxy, sumxx, sum, sum1, sumyy;
748 Double_t *str, *str1, *xcl, *ycl, *cln;
751 Double_t **clustcell;
752 str = new Double_t [kndim3];
753 str1 = new Double_t [kndim3];
754 xcl = new Double_t [kndim3];
755 ycl = new Double_t [kndim3];
756 cln = new Double_t [kndim3];
758 clustcell = new Double_t *[kndim3];
759 cell = new Int_t *[kndim3];
760 cluster = new Int_t *[kndim1];
761 for(i = 0; i < kndim1; i++)
763 cluster[i] = new Int_t [kndim2];
766 for(i = 0; i < kndim3; i++)
774 cell[i] = new Int_t [kndim2];
775 clustcell[i] = new Double_t [kndim1];
776 for(j = 0; j < kndim1; j++)
780 for(j = 0; j < kndim2; j++)
789 // more than one cluster
790 // checking cells shared between several clusters.
791 // First check if the cell is within
792 // one cell unit ( nearest neighbour). Else,
793 // if it is within 1.74 cell units ( next nearest )
794 // Else if it is upto 2 cell units etc.
796 for (i = 0; i <= ncell; i++)
802 // distance <= 1 cell unit
804 for(j = 0; j <= nclust; j++)
808 rr = Distance(x1, y1, x2, y2);
816 // next nearest neighbour
817 if(cluster[i][0] == 0)
819 for(j=0; j<=nclust; j++)
823 rr = Distance(x1, y1, x2, y2);
824 if(rr <= TMath::Sqrt(3.))
832 // next-to-next nearest neighbour
833 if(cluster[i][0] == 0)
835 for(j=0; j<=nclust; j++)
839 rr = Distance(x1, y1, x2, y2);
849 if(cluster[i][0] == 0)
851 for(j = 0; j <= nclust; j++)
855 rr = Distance(x1, y1, x2, y2);
866 // computing cluster strength. Some cells are shared.
867 for(i = 0; i <= ncell; i++)
869 if(cluster[i][0] != 0)
872 for(j = 1; j <= i1; j++)
880 for(k = 0; k < 5; k++)
882 for(i = 0; i <= ncell; i++)
884 if(cluster[i][0] != 0)
888 for(j = 1; j <= i1; j++)
890 sum += str[cluster[i][j]];
893 for(j = 1; j <= i1; j++)
896 str1[i2] += z[i]*str[i2]/sum;
897 clustcell[i2][i] = z[i]*str[i2]/sum;
903 for(j = 0; j <= nclust; j++)
910 for(i = 0; i <= nclust; i++)
916 for(j = 0; j <= ncell; j++)
918 if(clustcell[i][j] != 0)
920 sumx += clustcell[i][j]*x[j];
921 sumy += clustcell[i][j]*y[j];
922 sum += clustcell[i][j];
923 sum1 += clustcell[i][j]/z[j];
926 //** xcl and ycl are cluster centroid positions ( center of gravity )
934 for(j = 0; j <= ncell; j++)
936 sumxx += clustcell[i][j]*(x[j]-xcl[i])*(x[j]-xcl[i])/sum;
937 sumyy += clustcell[i][j]*(y[j]-ycl[i])*(y[j]-ycl[i])/sum;
938 sumxy += clustcell[i][j]*(x[j]-xcl[i])*(y[j]-ycl[i])/sum;
941 c = sumxx*sumyy-sumxy*sumxy;
942 // ******************r1 and r2 are major and minor axes ( r1 > r2 ).
943 r1 = b/2.+TMath::Sqrt(b*b/4.-c);
944 r2 = b/2.-TMath::Sqrt(b*b/4.-c);
945 // final assignments to proper external variables
955 //To get the cell position in a cluster
957 for(Int_t ii=0; ii<= ncell; ii++)
959 Int_t jj = cluster[ii][0];
960 for(Int_t kk=1; kk<= jj; kk++)
962 Int_t ll = cluster[ii][kk];
964 cell[ll][cell[ll][0]] = ii;
968 testncl.Set(nclust+1);
971 for(Int_t ii=0; ii <= nclust; ii++)
973 testncl[ii] = cell[ii][0];
974 counter += testncl[ii];
976 testindex.Set(counter);
978 for(Int_t ii=0; ii<= nclust; ii++)
980 for(Int_t jj = 1; jj<= testncl[ii]; jj++)
982 Int_t kk = cell[ii][jj];
996 for(j = 0; j <= ncell; j++)
1009 for(j = 0; j <= ncell; j++)
1011 sumxx += clustcell[i][j]*(x[j]-xcl[i])*(x[j]-xcl[i])/sum;
1012 sumyy += clustcell[i][j]*(y[j]-ycl[i])*(y[j]-ycl[i])/sum;
1013 sumxy += clustcell[i][j]*(x[j]-xcl[i])*(y[j]-ycl[i])/sum;
1016 c = sumxx*sumyy-sumxy*sumxy;
1017 r1 = b/2.+ TMath::Sqrt(b*b/4.-c);
1018 r2 = b/2.- TMath::Sqrt(b*b/4.-c);
1020 // To get the cell position in a cluster
1021 testncl.Set(nclust+1);
1022 testindex.Set(ncell+1);
1023 cell[0][0] = ncell + 1;
1024 testncl[0] = cell[0][0];
1026 for(Int_t ii = 1; ii <= ncell; ii++)
1029 Int_t kk = cell[0][ii];
1033 // final assignments
1041 for(i = 0; i < kndim3; i++)
1043 delete [] clustcell[i];
1046 delete [] clustcell;
1048 for(i = 0; i <kndim1 ; i++)
1050 delete [] cluster[i];
1060 // ------------------------------------------------------------------------ //
1061 Double_t AliPMDClusteringV2::Distance(Double_t x1, Double_t y1,
1062 Double_t x2, Double_t y2)
1064 return TMath::Sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
1066 // ------------------------------------------------------------------------ //
1067 void AliPMDClusteringV2::SetEdepCut(Float_t decut)
1071 // ------------------------------------------------------------------------ //
1072 void AliPMDClusteringV2::SetClusteringParam(Int_t cluspar)
1074 fClusParam = cluspar;
1076 // ------------------------------------------------------------------------ //