Initialisation changed
[u/mrichter/AliRoot.git] / HLT / ITS / tracking / AliHLTITSLayer.cxx
CommitLineData
2f399afc 1// **************************************************************************
2// This file is property of and copyright by the ALICE HLT Project *
3// ALICE Experiment at CERN, All rights reserved. *
4// *
5// Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
6// for The ALICE HLT Project. *
7// *
8// Permission to use, copy, modify and distribute this software and its *
9// documentation strictly for non-commercial purposes is hereby granted *
10// without fee, provided that the above copyright notice appears in all *
11// copies and that both the copyright notice and this permission notice *
12// appear in the supporting documentation. The authors make no claims *
13// about the suitability of this software for any purpose. It is *
14// provided "as is" without express or implied warranty. *
15// *
16//***************************************************************************
17
18
19#include "AliHLTITSLayer.h"
20
21//------------------------------------------------------------------------
22AliHLTITSLayer::AliHLTITSLayer():
23fR(0),
24fPhiOffset(0),
25fNladders(0),
26fZOffset(0),
27fNdetectors(0),
28fDetectors(0),
29fN(0),
30fDy5(0),
31fDy10(0),
32fDy20(0),
33fClustersCs(0),
34fClusterIndexCs(0),
35fYcs(0),
36fZcs(0),
37fNcs(0),
38fCurrentSlice(-1),
39fZmax(0),
40fYmin(0),
41fYmax(0),
42fI(0),
43fImax(0),
44fSkip(0),
45fAccepted(0),
46fRoad(0){
47 //--------------------------------------------------------------------
48 //default AliHLTITSLayer constructor
49 //--------------------------------------------------------------------
50 for (Int_t i=0; i<AliITSRecoParam::GetMaxClusterPerLayer(); i++) {
51 fClusterWeight[i]=0;
52 fClusterTracks[0][i]=-1;
53 fClusterTracks[1][i]=-1;
54 fClusterTracks[2][i]=-1;
55 fClusterTracks[3][i]=-1;
56 }
57}
58//------------------------------------------------------------------------
59AliHLTITSLayer::
60AliHLTITSLayer(Double_t r,Double_t p,Double_t z,Int_t nl,Int_t nd):
61fR(r),
62fPhiOffset(p),
63fNladders(nl),
64fZOffset(z),
65fNdetectors(nd),
66fDetectors(0),
67fN(0),
68fDy5(0),
69fDy10(0),
70fDy20(0),
71fClustersCs(0),
72fClusterIndexCs(0),
73fYcs(0),
74fZcs(0),
75fNcs(0),
76fCurrentSlice(-1),
77fZmax(0),
78fYmin(0),
79fYmax(0),
80fI(0),
81fImax(0),
82fSkip(0),
83fAccepted(0),
84fRoad(0) {
85 //--------------------------------------------------------------------
86 //main AliHLTITSLayer constructor
87 //--------------------------------------------------------------------
88 fDetectors=new AliHLTITSDetector[fNladders*fNdetectors];
89 fRoad=2*fR*TMath::Sqrt(TMath::Pi()/1.);//assuming that there's only one cluster
90}
91//------------------------------------------------------------------------
92AliHLTITSLayer::AliHLTITSLayer(const AliHLTITSLayer& layer):
93fR(layer.fR),
94fPhiOffset(layer.fPhiOffset),
95fNladders(layer.fNladders),
96fZOffset(layer.fZOffset),
97fNdetectors(layer.fNdetectors),
98fDetectors(layer.fDetectors),
99fN(layer.fN),
100fDy5(layer.fDy5),
101fDy10(layer.fDy10),
102fDy20(layer.fDy20),
103fClustersCs(layer.fClustersCs),
104fClusterIndexCs(layer.fClusterIndexCs),
105fYcs(layer.fYcs),
106fZcs(layer.fZcs),
107fNcs(layer.fNcs),
108fCurrentSlice(layer.fCurrentSlice),
109fZmax(layer.fZmax),
110fYmin(layer.fYmin),
111fYmax(layer.fYmax),
112fI(layer.fI),
113fImax(layer.fImax),
114fSkip(layer.fSkip),
115fAccepted(layer.fAccepted),
116fRoad(layer.fRoad){
117 //Copy constructor
118}
119//------------------------------------------------------------------------
120AliHLTITSLayer::~AliHLTITSLayer() {
121 //--------------------------------------------------------------------
122 // AliHLTITSLayer destructor
123 //--------------------------------------------------------------------
124 delete [] fDetectors;
125 for (Int_t i=0; i<fN; i++) delete fClusters[i];
126 for (Int_t i=0; i<AliITSRecoParam::GetMaxClusterPerLayer(); i++) {
127 fClusterWeight[i]=0;
128 fClusterTracks[0][i]=-1;
129 fClusterTracks[1][i]=-1;
130 fClusterTracks[2][i]=-1;
131 fClusterTracks[3][i]=-1;
132 }
133}
134//------------------------------------------------------------------------
135void AliHLTITSLayer::ResetClusters() {
136 //--------------------------------------------------------------------
137 // This function removes loaded clusters
138 //--------------------------------------------------------------------
139 for (Int_t i=0; i<fN; i++) delete fClusters[i];
140 for (Int_t i=0; i<AliITSRecoParam::GetMaxClusterPerLayer(); i++){
141 fClusterWeight[i]=0;
142 fClusterTracks[0][i]=-1;
143 fClusterTracks[1][i]=-1;
144 fClusterTracks[2][i]=-1;
145 fClusterTracks[3][i]=-1;
146 }
147
148 fN=0;
149 fI=0;
150}
151//------------------------------------------------------------------------
152void AliHLTITSLayer::ResetWeights() {
153 //--------------------------------------------------------------------
154 // This function reset weights of the clusters
155 //--------------------------------------------------------------------
156 for (Int_t i=0; i<AliITSRecoParam::GetMaxClusterPerLayer(); i++) {
157 fClusterWeight[i]=0;
158 fClusterTracks[0][i]=-1;
159 fClusterTracks[1][i]=-1;
160 fClusterTracks[2][i]=-1;
161 fClusterTracks[3][i]=-1;
162 }
163 for (Int_t i=0; i<fN;i++) {
164 AliITSRecPoint * cl = (AliITSRecPoint*)GetCluster(i);
165 if (cl&&cl->IsUsed()) cl->Use();
166 }
167
168}
169//------------------------------------------------------------------------
170void AliHLTITSLayer::ResetRoad() {
171 //--------------------------------------------------------------------
172 // This function calculates the road defined by the cluster density
173 //--------------------------------------------------------------------
174 Int_t n=0;
175 for (Int_t i=0; i<fN; i++) {
176 if (TMath::Abs(fClusters[i]->GetZ())<fR) n++;
177 }
178 if (n>1) fRoad=2*fR*TMath::Sqrt(TMath::Pi()/n);
179}
180//------------------------------------------------------------------------
181Int_t AliHLTITSLayer::InsertCluster(AliITSRecPoint *cl) {
182 //--------------------------------------------------------------------
183 //This function adds a cluster to this layer
184 //--------------------------------------------------------------------
185 if (fN==AliITSRecoParam::GetMaxClusterPerLayer()) {
186 ::Error("InsertCluster","Too many clusters !\n");
187 return 1;
188 }
189 fCurrentSlice=-1;
190 fClusters[fN]=cl;
191 fN++;
192 AliHLTITSDetector &det=GetDetector(cl->GetDetectorIndex());
193 if (cl->GetY()<det.GetYmin()) det.SetYmin(cl->GetY());
194 if (cl->GetY()>det.GetYmax()) det.SetYmax(cl->GetY());
195 if (cl->GetZ()<det.GetZmin()) det.SetZmin(cl->GetZ());
196 if (cl->GetZ()>det.GetZmax()) det.SetZmax(cl->GetZ());
197
198 return 0;
199}
200//------------------------------------------------------------------------
201void AliHLTITSLayer::SortClusters()
202{
203 //
204 //sort clusters
205 //
206 AliITSRecPoint **clusters = new AliITSRecPoint*[fN];
207 Float_t *z = new Float_t[fN];
208 Int_t * index = new Int_t[fN];
209 //
210 for (Int_t i=0;i<fN;i++){
211 z[i] = fClusters[i]->GetZ();
212 }
213 TMath::Sort(fN,z,index,kFALSE);
214 for (Int_t i=0;i<fN;i++){
215 clusters[i] = fClusters[index[i]];
216 }
217 //
218 for (Int_t i=0;i<fN;i++){
219 fClusters[i] = clusters[i];
220 fZ[i] = fClusters[i]->GetZ();
221 AliHLTITSDetector &det=GetDetector(fClusters[i]->GetDetectorIndex());
222 Double_t y=fR*det.GetPhi() + fClusters[i]->GetY();
223 if (y>2.*fR*TMath::Pi()) y -= 2.*fR*TMath::Pi();
224 fY[i] = y;
225 }
226 delete[] index;
227 delete[] z;
228 delete[] clusters;
229 //
230
231 fYB[0]=10000000;
232 fYB[1]=-10000000;
233 for (Int_t i=0;i<fN;i++){
234 if (fY[i]<fYB[0]) fYB[0]=fY[i];
235 if (fY[i]>fYB[1]) fYB[1]=fY[i];
236 fClusterIndex[i] = i;
237 }
238 //
239 // fill slices
240 fDy5 = (fYB[1]-fYB[0])/5.;
241 fDy10 = (fYB[1]-fYB[0])/10.;
242 fDy20 = (fYB[1]-fYB[0])/20.;
243 for (Int_t i=0;i<6;i++) fN5[i] =0;
244 for (Int_t i=0;i<11;i++) fN10[i]=0;
245 for (Int_t i=0;i<21;i++) fN20[i]=0;
246 //
247 for (Int_t i=0;i<6;i++) {fBy5[i][0] = fYB[0]+(i-0.75)*fDy5; fBy5[i][1] = fYB[0]+(i+0.75)*fDy5;}
248 for (Int_t i=0;i<11;i++) {fBy10[i][0] = fYB[0]+(i-0.75)*fDy10; fBy10[i][1] = fYB[0]+(i+0.75)*fDy10;}
249 for (Int_t i=0;i<21;i++) {fBy20[i][0] = fYB[0]+(i-0.75)*fDy20; fBy20[i][1] = fYB[0]+(i+0.75)*fDy20;}
250 //
251 //
252 for (Int_t i=0;i<fN;i++)
253 for (Int_t irot=-1;irot<=1;irot++){
254 Float_t curY = fY[i]+irot*TMath::TwoPi()*fR;
255 // slice 5
256 for (Int_t slice=0; slice<6;slice++){
257 if (fBy5[slice][0]<curY && curY<fBy5[slice][1]&&fN5[slice]<AliITSRecoParam::GetMaxClusterPerLayer5()){
258 fClusters5[slice][fN5[slice]] = fClusters[i];
259 fY5[slice][fN5[slice]] = curY;
260 fZ5[slice][fN5[slice]] = fZ[i];
261 fClusterIndex5[slice][fN5[slice]]=i;
262 fN5[slice]++;
263 }
264 }
265 // slice 10
266 for (Int_t slice=0; slice<11;slice++){
267 if (fBy10[slice][0]<curY && curY<fBy10[slice][1]&&fN10[slice]<AliITSRecoParam::GetMaxClusterPerLayer10()){
268 fClusters10[slice][fN10[slice]] = fClusters[i];
269 fY10[slice][fN10[slice]] = curY;
270 fZ10[slice][fN10[slice]] = fZ[i];
271 fClusterIndex10[slice][fN10[slice]]=i;
272 fN10[slice]++;
273 }
274 }
275 // slice 20
276 for (Int_t slice=0; slice<21;slice++){
277 if (fBy20[slice][0]<curY && curY<fBy20[slice][1]&&fN20[slice]<AliITSRecoParam::GetMaxClusterPerLayer20()){
278 fClusters20[slice][fN20[slice]] = fClusters[i];
279 fY20[slice][fN20[slice]] = curY;
280 fZ20[slice][fN20[slice]] = fZ[i];
281 fClusterIndex20[slice][fN20[slice]]=i;
282 fN20[slice]++;
283 }
284 }
285 }
286
287 //
288 // consistency check
289 //
290 for (Int_t i=0;i<fN-1;i++){
291 if (fZ[i]>fZ[i+1]){
292 printf("Bug\n");
293 }
294 }
295 //
296 for (Int_t slice=0;slice<21;slice++)
297 for (Int_t i=0;i<fN20[slice]-1;i++){
298 if (fZ20[slice][i]>fZ20[slice][i+1]){
299 printf("Bug\n");
300 }
301 }
302
303
304}
305//------------------------------------------------------------------------
306Int_t AliHLTITSLayer::FindClusterIndex(Float_t z) const {
307 //--------------------------------------------------------------------
308 // This function returns the index of the nearest cluster
309 //--------------------------------------------------------------------
310 Int_t ncl=0;
311 const Float_t *zcl;
312 if (fCurrentSlice<0) {
313 ncl = fN;
314 zcl = fZ;
315 }
316 else{
317 ncl = fNcs;
318 zcl = fZcs;;
319 }
320
321 if (ncl==0) return 0;
322 Int_t b=0, e=ncl-1, m=(b+e)/2;
323 for (; b<e; m=(b+e)/2) {
324 // if (z > fClusters[m]->GetZ()) b=m+1;
325 if (z > zcl[m]) b=m+1;
326 else e=m;
327 }
328 return m;
329}
330
331//------------------------------------------------------------------------
332void AliHLTITSLayer::
333SelectClusters(Double_t zmin,Double_t zmax,Double_t ymin, Double_t ymax) {
334 //--------------------------------------------------------------------
335 // This function sets the "window"
336 //--------------------------------------------------------------------
337
338 Double_t circle=2*TMath::Pi()*fR;
339 fYmin = ymin; fYmax =ymax;
340 Float_t ymiddle = (fYmin+fYmax)*0.5;
341 if (ymiddle<fYB[0]) {
342 fYmin+=circle; fYmax+=circle; ymiddle+=circle;
343 } else if (ymiddle>fYB[1]) {
344 fYmin-=circle; fYmax-=circle; ymiddle-=circle;
345 }
346
347 //
348 fCurrentSlice =-1;
349 // defualt take all
350 fClustersCs = fClusters;
351 fClusterIndexCs = fClusterIndex;
352 fYcs = fY;
353 fZcs = fZ;
354 fNcs = fN;
355 //
356 //is in 20 slice?
357 if (fCurrentSlice<0&&TMath::Abs(fYmax-fYmin)<1.49*fDy20){
358 Int_t slice = int(0.5+(ymiddle-fYB[0])/fDy20);
359 if (slice<0) slice=0;
360 if (slice>20) slice=20;
361 Bool_t isOK = (fYmin>fBy20[slice][0]&&fYmax<fBy20[slice][1]);
362 if (isOK) {
363 fCurrentSlice=slice;
364 fClustersCs = fClusters20[fCurrentSlice];
365 fClusterIndexCs = fClusterIndex20[fCurrentSlice];
366 fYcs = fY20[fCurrentSlice];
367 fZcs = fZ20[fCurrentSlice];
368 fNcs = fN20[fCurrentSlice];
369 }
370 }
371 //
372 //is in 10 slice?
373 if (fCurrentSlice<0&&TMath::Abs(fYmax-fYmin)<1.49*fDy10){
374 Int_t slice = int(0.5+(ymiddle-fYB[0])/fDy10);
375 if (slice<0) slice=0;
376 if (slice>10) slice=10;
377 Bool_t isOK = (fYmin>fBy10[slice][0]&&fYmax<fBy10[slice][1]);
378 if (isOK) {
379 fCurrentSlice=slice;
380 fClustersCs = fClusters10[fCurrentSlice];
381 fClusterIndexCs = fClusterIndex10[fCurrentSlice];
382 fYcs = fY10[fCurrentSlice];
383 fZcs = fZ10[fCurrentSlice];
384 fNcs = fN10[fCurrentSlice];
385 }
386 }
387 //
388 //is in 5 slice?
389 if (fCurrentSlice<0&&TMath::Abs(fYmax-fYmin)<1.49*fDy5){
390 Int_t slice = int(0.5+(ymiddle-fYB[0])/fDy5);
391 if (slice<0) slice=0;
392 if (slice>5) slice=5;
393 Bool_t isOK = (fYmin>fBy5[slice][0]&&fYmax<fBy5[slice][1]);
394 if (isOK) {
395 fCurrentSlice=slice;
396 fClustersCs = fClusters5[fCurrentSlice];
397 fClusterIndexCs = fClusterIndex5[fCurrentSlice];
398 fYcs = fY5[fCurrentSlice];
399 fZcs = fZ5[fCurrentSlice];
400 fNcs = fN5[fCurrentSlice];
401 }
402 }
403 //
404 fI=FindClusterIndex(zmin); fZmax=zmax;
405 fImax = TMath::Min(FindClusterIndex(zmax)+1,fNcs);
406 fSkip = 0;
407 fAccepted =0;
408
409 return;
410}
411//------------------------------------------------------------------------
412Int_t AliHLTITSLayer::
413FindDetectorIndex(Double_t phi, Double_t z) const {
414 //--------------------------------------------------------------------
415 //This function finds the detector crossed by the track
416 //--------------------------------------------------------------------
417 Double_t dphi;
418 if (fZOffset<0) // old geometry
419 dphi = -(phi-fPhiOffset);
420 else // new geometry
421 dphi = phi-fPhiOffset;
422
423
424 if (dphi < 0) dphi += 2*TMath::Pi();
425 else if (dphi >= 2*TMath::Pi()) dphi -= 2*TMath::Pi();
426 Int_t np=Int_t(dphi*fNladders*0.5/TMath::Pi()+0.5);
427 if (np>=fNladders) np-=fNladders;
428 if (np<0) np+=fNladders;
429
430
431 Double_t dz=fZOffset-z;
432 Double_t nnz = dz*(fNdetectors-1)*0.5/fZOffset+0.5;
433 Int_t nz = (nnz<0 ? -1 : (Int_t)nnz);
434 if (nz>=fNdetectors) return -1;
435 if (nz<0) return -1;
436
437 // ad hoc correction for 3rd ladder of SDD inner layer,
438 // which is reversed (rotated by pi around local y)
439 // this correction is OK only from AliITSv11Hybrid onwards
440 if (GetR()>12. && GetR()<20.) { // SDD inner
441 if(np==2) { // 3rd ladder
442 nz = (fNdetectors-1) - nz;
443 }
444 }
445 //printf("ndet %d phi %f z %f np %d nz %d\n",fNdetectors,phi,z,np,nz);
446
447
448 return np*fNdetectors + nz;
449}
450//------------------------------------------------------------------------
451const AliITSRecPoint *AliHLTITSLayer::GetNextCluster(Int_t &ci,Bool_t test)
452{
453 //--------------------------------------------------------------------
454 // This function returns clusters within the "window"
455 //--------------------------------------------------------------------
456
457 if (fCurrentSlice<0) {
458 Double_t rpi2 = 2.*fR*TMath::Pi();
459 for (Int_t i=fI; i<fImax; i++) {
460 Double_t y = fY[i];
461 if (fYmax<y) y -= rpi2;
462 if (fYmin>y) y += rpi2;
463 if (y<fYmin) continue;
464 if (y>fYmax) continue;
465 if (fClusters[i]->GetQ()==0&&fSkip==2) continue;
466 ci=i;
467 if (!test) fI=i+1;
468 return fClusters[i];
469 }
470 } else {
471 for (Int_t i=fI; i<fImax; i++) {
472 if (fYcs[i]<fYmin) continue;
473 if (fYcs[i]>fYmax) continue;
474 if (fClustersCs[i]->GetQ()==0&&fSkip==2) continue;
475 ci=fClusterIndexCs[i];
476 if (!test) fI=i+1;
477 return fClustersCs[i];
478 }
479 }
480 return 0;
481}
482//------------------------------------------------------------------------
483Double_t AliHLTITSLayer::GetThickness(Double_t y,Double_t z,Double_t &x0)
484const {
485 //--------------------------------------------------------------------
486 // This function returns the layer thickness at this point (units X0)
487 //--------------------------------------------------------------------
488 Double_t d=0.0085;
489 x0=AliITSRecoParam::GetX0Air();
490 if (43<fR&&fR<45) { //SSD2
491 Double_t dd=0.0034;
492 d=dd;
493 if (TMath::Abs(y-0.00)>3.40) d+=dd;
494 if (TMath::Abs(y-1.90)<0.45) {d+=(0.013-0.0034);}
495 if (TMath::Abs(y+1.90)<0.45) {d+=(0.013-0.0034);}
496 for (Int_t i=0; i<12; i++) {
497 if (TMath::Abs(z-3.9*(i+0.5))<0.15) {
498 if (TMath::Abs(y-0.00)>3.40) d+=dd;
499 d+=0.0034;
500 break;
501 }
502 if (TMath::Abs(z+3.9*(i+0.5))<0.15) {
503 if (TMath::Abs(y-0.00)>3.40) d+=dd;
504 d+=0.0034;
505 break;
506 }
507 if (TMath::Abs(z-3.4-3.9*i)<0.50) {d+=(0.016-0.0034); break;}
508 if (TMath::Abs(z+0.5+3.9*i)<0.50) {d+=(0.016-0.0034); break;}
509 }
510 } else
511 if (37<fR&&fR<41) { //SSD1
512 Double_t dd=0.0034;
513 d=dd;
514 if (TMath::Abs(y-0.00)>3.40) d+=dd;
515 if (TMath::Abs(y-1.90)<0.45) {d+=(0.013-0.0034);}
516 if (TMath::Abs(y+1.90)<0.45) {d+=(0.013-0.0034);}
517 for (Int_t i=0; i<11; i++) {
518 if (TMath::Abs(z-3.9*i)<0.15) {
519 if (TMath::Abs(y-0.00)>3.40) d+=dd;
520 d+=dd;
521 break;
522 }
523 if (TMath::Abs(z+3.9*i)<0.15) {
524 if (TMath::Abs(y-0.00)>3.40) d+=dd;
525 d+=dd;
526 break;
527 }
528 if (TMath::Abs(z-1.85-3.9*i)<0.50) {d+=(0.016-0.0034); break;}
529 if (TMath::Abs(z+2.05+3.9*i)<0.50) {d+=(0.016-0.0034); break;}
530 }
531 } else
532 if (13<fR&&fR<26) { //SDD
533 Double_t dd=0.0033;
534 d=dd;
535 if (TMath::Abs(y-0.00)>3.30) d+=dd;
536
537 if (TMath::Abs(y-1.80)<0.55) {
538 d+=0.016;
539 for (Int_t j=0; j<20; j++) {
540 if (TMath::Abs(z+0.7+1.47*j)<0.12) {d+=0.08; x0=9.; break;}
541 if (TMath::Abs(z-0.7-1.47*j)<0.12) {d+=0.08; x0=9.; break;}
542 }
543 }
544 if (TMath::Abs(y+1.80)<0.55) {
545 d+=0.016;
546 for (Int_t j=0; j<20; j++) {
547 if (TMath::Abs(z-0.7-1.47*j)<0.12) {d+=0.08; x0=9.; break;}
548 if (TMath::Abs(z+0.7+1.47*j)<0.12) {d+=0.08; x0=9.; break;}
549 }
550 }
551
552 for (Int_t i=0; i<4; i++) {
553 if (TMath::Abs(z-7.3*i)<0.60) {
554 d+=dd;
555 if (TMath::Abs(y-0.00)>3.30) d+=dd;
556 break;
557 }
558 if (TMath::Abs(z+7.3*i)<0.60) {
559 d+=dd;
560 if (TMath::Abs(y-0.00)>3.30) d+=dd;
561 break;
562 }
563 }
564 } else
565 if (6<fR&&fR<8) { //SPD2
566 Double_t dd=0.0063; x0=21.5;
567 d=dd;
568 if (TMath::Abs(y-3.08)>0.5) d+=dd;
569 if (TMath::Abs(y-3.03)<0.10) d+=0.014;
570 } else
571 if (3<fR&&fR<5) { //SPD1
572 Double_t dd=0.0063; x0=21.5;
573 d=dd;
574 if (TMath::Abs(y+0.21)>0.6) d+=dd;
575 if (TMath::Abs(y+0.10)<0.10) d+=0.014;
576 }
577
578 return d;
579}
580
581//------------------------------------------------------------------------
582Int_t AliHLTITSLayer::InRoad() const {
583 //-------------------------------------------------------------------
584 // This function returns number of clusters within the "window"
585 //--------------------------------------------------------------------
586 Int_t ncl=0;
587 for (Int_t i=fI; i<fN; i++) {
588 const AliITSRecPoint *c=fClusters[i];
589 if (c->GetZ() > fZmax) break;
590 if (c->IsUsed()) continue;
591 const AliHLTITSDetector &det=GetDetector(c->GetDetectorIndex());
592 Double_t y=fR*det.GetPhi() + c->GetY();
593
594 if (y>2.*fR*TMath::Pi()) y -= 2*fR*TMath::Pi();
595 if (y>1.*fR*TMath::Pi() && fYmax<y) y -= 2*fR*TMath::Pi();
596
597 if (y<fYmin) continue;
598 if (y>fYmax) continue;
599 ncl++;
600 }
601 return ncl;
602}
603