]> git.uio.no Git - u/mrichter/AliRoot.git/blame - MUON/AliMUONTriggerSegmentation.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
remove AliMUONTriggerConstants (Philippe)
[u/mrichter/AliRoot.git] / MUON / AliMUONTriggerSegmentation.cxx
CommitLineData
0a11496e 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
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
16/* $Id$ */
17
5398f946 18/// \class AliMUONTriggerSegmentation
19/// \brief Segmentation classe for trigger chambers.
20/// In the present version the method use global strip coordinates except
21/// HasPad. The conversion is made via GetPadLoc2Glo.
22/// To be improved in the future.
0a11496e 23
0a11496e 24#include "AliMUONTriggerSegmentation.h"
25#include "AliLog.h"
70ef378c 26#include "Riostream.h"
0a11496e 27
5398f946 28/// \cond CLASSIMP
0a11496e 29ClassImp(AliMUONTriggerSegmentation)
5398f946 30/// \endcond
0a11496e 31
5398f946 32//___________________________________________
a713db22 33AliMUONTriggerSegmentation::AliMUONTriggerSegmentation()
34 : AliMUONVGeometryDESegmentation(),
35 fBending(0),
79b4ba23 36 fId(0),
38aedc99 37 fNsec(7),
79b4ba23 38 fNpx(999999),
39 fNpy(999999),
1657f946 40 fSector(0),
79b4ba23 41 fXhit(0.),
42 fYhit(0.),
43 fIx(0),
44 fIy(0),
45 fX(0.),
46 fY(0.),
79b4ba23 47// add to St345SlatSegmentation
48 fLineNumber(0),
49 fRpcHalfXsize(0),
50 fRpcHalfYsize(0)
a713db22 51{
5398f946 52/// Default constructor
d19b6003 53
79b4ba23 54// add to St345SlatSegmentation
55 for (Int_t i=0; i<7; i++) {
56 fNstrip[i]=0;
57 fStripYsize[i]=0.;
58 fStripXsize[i]=0.;
59 fModuleXmin[i]=0.;
60 fModuleXmax[i]=0.;
61 fModuleYmin[i]=0.;
62 }
65969290 63
64 AliDebug(1, Form("default (empty) ctor this = %p", this));
a713db22 65}
79b4ba23 66
67
a713db22 68//___________________________________________
0a11496e 69AliMUONTriggerSegmentation::AliMUONTriggerSegmentation(Bool_t bending)
70 : AliMUONVGeometryDESegmentation(),
79b4ba23 71 fBending(bending),
72 fId(0),
1657f946 73 fNsec(7),
79b4ba23 74 fNpx(999999),
75 fNpy(999999),
1657f946 76 fSector(0),
79b4ba23 77 fXhit(0.),
78 fYhit(0.),
79 fIx(0),
80 fIy(0),
81 fX(0.),
82 fY(0.),
79b4ba23 83// add to St345SlatSegmentation
84 fLineNumber(0),
85 fRpcHalfXsize(0),
86 fRpcHalfYsize(0)
0a11496e 87{
5398f946 88/// Standard constructor
89
79b4ba23 90// add to St345SlatSegmentation
91 for (Int_t i=0; i<7; i++) {
92 fNstrip[i]=0;
93 fStripYsize[i]=0.;
94 fStripXsize[i]=0.;
95 fModuleXmin[i]=0.;
96 fModuleXmax[i]=0.;
97 fModuleYmin[i]=0.;
98 }
65969290 99
100 AliDebug(1, Form("ctor this = %p", this) );
0a11496e 101}
79b4ba23 102
0a11496e 103//----------------------------------------------------------------------
104AliMUONTriggerSegmentation::~AliMUONTriggerSegmentation()
105{
5398f946 106/// Destructor
65969290 107
108 AliDebug(1, Form("dtor this = %p", this) );
0a11496e 109}
110//----------------------------------------------------------------------
d173a061 111Int_t AliMUONTriggerSegmentation::ModuleColNum(Int_t ix)
38aedc99 112{
5398f946 113/// returns column number (from 0 to 6) in which the (global) module
114/// ix is sitting (could return 7 if ix=isec)
115
d173a061 116 return TMath::Abs(ix)-Int_t(TMath::Abs(ix)/10)*10-1;
38aedc99 117}
118//----------------------------------------------------------------------
79b4ba23 119Bool_t AliMUONTriggerSegmentation::HasPad(Int_t ix, Int_t iy)
120{
5398f946 121/// check if steping outside the limits (iy=1,2... iy=0,1...)
122
38aedc99 123 Bool_t hasPad = true;
79b4ba23 124 Int_t ixGlo = 0;
38aedc99 125 Int_t iyGlo = 0;
126 GetPadLoc2Glo(ix, iy, ixGlo, iyGlo);
127 if (iyGlo>=fNstrip[ModuleColNum(ixGlo)]) hasPad = false;
79b4ba23 128 return hasPad;
129}
0a11496e 130//____________________________________________________________________________
131Float_t AliMUONTriggerSegmentation::Dpx(Int_t isec) const
132{
5398f946 133/// return x-strip width in sector isec
134
38aedc99 135 Float_t size = (isec<8) ? fStripXsize[isec-1] : fStripXsize[isec-2]/2.;
136 return size;
0a11496e 137}
138//____________________________________________________________________________
139Float_t AliMUONTriggerSegmentation::Dpy(Int_t isec) const
140{
5398f946 141/// return y-strip width in sector isec
142
38aedc99 143 Float_t size = (isec<8) ? fStripYsize[isec-1] : fStripYsize[isec-2];
144 return size;
0a11496e 145}
146//----------------------------------------------------------------------------
147void AliMUONTriggerSegmentation::GetPadLoc2Glo(Int_t ixLoc, Int_t iyLoc,
148 Int_t &ixGlo, Int_t &iyGlo)
149{
5398f946 150/// converts ixLoc & iyLoc into ixGlo & iyGLo (module,strip number)
151
7675593a 152 ixGlo = 0; //
38aedc99 153 iyGlo = 0; // from 0 to (fNtrip-1) in module
0a11496e 154 if (fBending) {
38aedc99 155 ixGlo = 10*fLineNumber + ixLoc;
0a11496e 156 iyGlo = iyLoc - 1;
157 } else if (!fBending) {
158 Int_t iCountStrip = 0;
38aedc99 159 for (Int_t iModule=0; iModule<fNsec; iModule++) {
0a11496e 160 for (Int_t iStrip=0; iStrip<fNstrip[iModule]; iStrip++) {
161 if ((ixLoc-1)==iCountStrip) {
38aedc99 162 ixGlo = 10*fLineNumber + iModule + 1;
0a11496e 163 iyGlo = iStrip;
164 }
165 iCountStrip++;
166 }
167 }
168 }
d173a061 169// printf(" in GetPadLoc2Glo fbending ixLoc iyLoc ixGlo iyGlo %i %i %i %i \n",fBending,ixLoc,iyLoc,ixGlo,iyGlo);
0a11496e 170}
d173a061 171
172//----------------------------------------------------------------------------
173void AliMUONTriggerSegmentation::GetPadGlo2Loc(Int_t ixGlo, Int_t iyGlo,
174 Int_t &ixLoc, Int_t &iyLoc)
175{
5398f946 176/// converts ixGlo & iyGlo into ixLoc & iyLoc
177
d173a061 178 ixLoc = 0;
179 iyLoc = 0;
180 if (fBending) {
181 ixLoc = ModuleColNum(ixGlo) + 1;
182 iyLoc = iyGlo + 1;
183 } else if (!fBending) {
184 Int_t iCountStrip = 1;
185 for (Int_t iModule=0; iModule<fNsec; iModule++) {
186 for (Int_t iStrip=0; iStrip<fNstrip[iModule]; iStrip++) {
187 if ((iModule==ModuleColNum(ixGlo))&&(iStrip==iyGlo)) {
70ef378c 188 iyLoc = 1;
189 ixLoc = iCountStrip;
d173a061 190 }
191 iCountStrip++;
192 }
193 }
194 }
195// printf(" in GetPadGlo2Loc fBending ixGlo iyGlo ixLoc iyLoc %i %i %i %i %i \n",fBending,ixGlo,iyGlo,ixLoc,iyLoc);
196}
197
0a11496e 198//----------------------------------------------------------------------------
199void AliMUONTriggerSegmentation::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
200{
5398f946 201/// Returns local real coordinates (x,y) for local pad coordinates (ix,iy)
d173a061 202
0a11496e 203 x = 0.;
204 y = 0.;
d173a061 205 Int_t iModule = ModuleColNum(ix); // find column number (0-6)
0a11496e 206 if (fBending) {
207 if (iModule==0) {
38aedc99 208 x = fStripXsize[iModule]/ 2.;
0a11496e 209 } else {
38aedc99 210 x = fModuleXmax[iModule-1] + fStripXsize[iModule]/2.;
211 }
79b4ba23 212 y = fModuleYmin[iModule] +
d173a061 213 iy*fStripYsize[iModule] + fStripYsize[iModule]/2.;
0a11496e 214 } else if (!fBending) {
d173a061 215 if (ModuleColNum(ix)==6 && iy>7) {
38aedc99 216 x = fModuleXmin[iModule] + 8*fStripXsize[iModule] +
d173a061 217 (iy-8)*fStripXsize[iModule]/2. + fStripXsize[iModule]/4.;
79b4ba23 218 } else {
219 x = fModuleXmin[iModule] +
d173a061 220 iy*fStripXsize[iModule] + fStripXsize[iModule]/2.;
79b4ba23 221 }
38aedc99 222 y = fModuleYmin[iModule] + fStripYsize[iModule] / 2.;
0a11496e 223 }
224 x = x - fRpcHalfXsize;
225 y = y - fRpcHalfYsize;
226
d173a061 227// printf(" in GetPadC fBending ix iy x y %i %i %i %f %f \n",fBending,ix,iy,x,y);
0a11496e 228}
229
230//_____________________________________________________________________________
231void AliMUONTriggerSegmentation::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
232{
5398f946 233/// Returns global pad coordinates (ix,iy) for local real coordinates (x,y)
234
70ef378c 235 ix = -1;
236 iy = -1;
67e7e5a7 237
0a11496e 238 x = x + fRpcHalfXsize;
239 y = y + fRpcHalfYsize;
240// find module number
241 Int_t modNum=0;
38aedc99 242 for (Int_t iModule=0; iModule<fNsec; iModule++) { // modules
0a11496e 243 if ( x > fModuleXmin[iModule] && x < fModuleXmax[iModule] ) {
8ceced0c 244 ix = 10*fLineNumber + iModule + 1;
0a11496e 245 modNum = iModule;
246 }
247 }
248
249// find strip number
250 Float_t yMin = 0.;
251 Float_t yMax = fModuleYmin[modNum];
252 Float_t xMin = 0.;
253 Float_t xMax = fModuleXmin[modNum];
254 if (ix!=0) {
255 for (Int_t iStrip=0; iStrip<fNstrip[modNum]; iStrip++) {
256 if (fBending) {
257 yMin = yMax;
258 yMax = yMin + fStripYsize[modNum];
259 if (y > yMin && y < yMax) iy = iStrip;
38aedc99 260 } else if (!fBending) {
0a11496e 261 xMin = xMax;
7743b3a9 262 if (modNum==6 && iStrip>7) {
263 xMax = xMin + fStripXsize[modNum]/2.;
264 } else {
265 xMax = xMin + fStripXsize[modNum];
266 }
0a11496e 267 if (x > xMin && x < xMax) iy = iStrip;
7743b3a9 268 } //
0a11496e 269 } // loop on strips
270 } // if ix!=0
d173a061 271// printf("in GetPadI fBending x y ix iy %i %f %f %i %i \n",fBending,x,y,ix,iy);
0a11496e 272}
273//-------------------------------------------------------------------------
274void AliMUONTriggerSegmentation::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy)
275{
5398f946 276/// Returns global pad coordinates (ix,iy) for local real coordinates (x,y)
277
0a11496e 278 GetPadI(x, y, ix, iy);
279}
d173a061 280
0a11496e 281//-------------------------------------------------------------------------
282void AliMUONTriggerSegmentation::SetLineNumber(Int_t iLineNumber){
5398f946 283/// Set line number
284
0a11496e 285 fLineNumber = iLineNumber;
286}
287//-------------------------------------------------------------------------
0a11496e 288void AliMUONTriggerSegmentation::SetPad(Int_t ix, Int_t iy)
289{
5398f946 290/// Sets virtual pad coordinates, needed for evaluating pad response
291/// outside the tracking program
292
0a11496e 293 GetPadC(ix,iy,fX,fY);
d173a061 294 fIx = ix; // used in IntegrationLimits
295 fIy = iy;
0a11496e 296 fSector=Sector(ix,iy);
297}
298//---------------------------------------------------------------------------
299void AliMUONTriggerSegmentation::SetHit(Float_t x, Float_t y)
300{
5398f946 301/// Set current hit
302
0a11496e 303 fXhit = x;
304 fYhit = y;
0a11496e 305}
306//----------------------------------------------------------------------------
307void AliMUONTriggerSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
308{
5398f946 309/// Set current hit
310
0a11496e 311 SetHit(xhit, yhit);
312}
313
314//--------------------------------------------------------------------------
79b4ba23 315Int_t AliMUONTriggerSegmentation::Sector(Int_t ix, Int_t iy)
0a11496e 316{
5398f946 317/// determine segmentation zone from pad coordinates (from 1 to 8)
318
d173a061 319 if (!fBending && ModuleColNum(ix)==6 && iy>7) {
38aedc99 320 return 8; // sector 8: diff. strip width within same module
79b4ba23 321 } else {
d173a061 322 return ModuleColNum(ix)+1;
38aedc99 323 }
0a11496e 324}
79b4ba23 325
0a11496e 326//-----------------------------------------------------------------------------
70ef378c 327void AliMUONTriggerSegmentation::IntegrationLimits(Float_t& x1,Float_t& x2,
328 Float_t& x3, Float_t& x4)
0a11496e 329{
5398f946 330/// need to return (only) x4 = dist. betwwen the hit and the closest border of
331/// the current strip
d173a061 332
38aedc99 333 Int_t ix,iy;
334 Float_t xstrip,ystrip;
d173a061 335 GetPadI(fXhit,fYhit,ix,iy);
336 GetPadC(ix,iy,xstrip,ystrip);
70ef378c 337 AliDebug(1,Form("fXhit,Yhit=%e,%e xstrip,ystrip=%e,%e\n",
338 fXhit,fYhit,xstrip,ystrip));
d173a061 339 x1= (fBending) ? fYhit : fXhit; // hit y (bending) / x (!bending) position
340 x2= (fBending) ? ystrip : xstrip; // y or x coord. of the main strip
341 x3= (fBending) ? fY : fX; // current strip real y or x coord.
342 Int_t modNum = ModuleColNum(fIx);
38aedc99 343
d173a061 344 // find the position of the 2 borders of the current strip
345 Float_t min = 0.;
346 Float_t max = 0.;
347 if (fBending) {
348 min = x3 - fStripYsize[modNum]/2.;
349 max = x3 + fStripYsize[modNum]/2.;
350 } else {
351 if (modNum==6 && fIy>7) { // equivalent to fSector == 8
352 min = x3 - fStripXsize[modNum]/4.;
353 max = x3 + fStripXsize[modNum]/4.;
354 } else
355 min = x3 - fStripXsize[modNum]/2.;
356 max = x3 + fStripXsize[modNum]/2.;
357 }
38aedc99 358 // dist. between the hit and the closest border of the current strip
d173a061 359 x4 = (TMath::Abs(max-x1) > TMath::Abs(min-x1)) ?
70ef378c 360 TMath::Abs(min-x1):TMath::Abs(max-x1);
361
362 AliDebug(1,Form("Bending %d x1=%e x2=%e x3=%e x4=%e xmin,max=%e,%e\n",
363 fBending,x1,x2,x3,x4,min,max));
0a11496e 364}
38aedc99 365
366
0a11496e 367//-----------------------------------------------------------------------------
368void AliMUONTriggerSegmentation::
369Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
370{
5398f946 371/// <pre>
372///-----------------BENDING-----------------------------------------
373/// Returns list of 10 next neighbours for given X strip (ix, iy)
374/// neighbour number 4 in the list -
375/// neighbour number 3 in the list |
376/// neighbour number 2 in the list |_ Upper part
377/// neighbour number 1 in the list |
378/// neighbour number 0 in the list -
379/// X strip (ix, iy)
380/// neighbour number 5 in the list -
381/// neighbour number 6 in the list | _ Lower part
382/// neighbour number 7 in the list |
383/// neighbour number 8 in the list |
384/// neighbour number 9 in the list -
385///
386///-----------------NON-BENDING-------------------------------------
387/// Returns list of 10 next neighbours for given Y strip (ix, iy)
388/// neighbour number 9 8 7 6 5 (Y strip (ix, iy)) 0 1 2 3 4 in the list
389/// \\_______/ \\_______/
390/// left right
d173a061 391
392 Int_t absiX = TMath::Abs(iX);
393 Int_t modNum = ModuleColNum(absiX); // from 0 to 6
394 Int_t nStrip = fNstrip[modNum];
395
396 if (fBending) {
397 Int_t iCandidateUp, iCandidateDo;
398 Int_t j;
399
400 *Nlist = 10;
401 for (Int_t i=0; i<10; i++) Xlist[i]=Ylist[i]=0;
402
403 if (iY < nStrip) {
404 for (Int_t i=0; i<5; i++) {
405 j = i + 5;
406 iCandidateUp = iY + (i + 1);
407 iCandidateDo = iY - (i + 1);
408 if (iCandidateUp < nStrip) {
409 Xlist[i] = iX;
410 Ylist[i] = iCandidateUp;
411 }
412 if (iCandidateDo >= 0) {
413 Xlist[j] = iX;
414 Ylist[j] = iCandidateDo;
415 }
416 }
417 } // iY < nStrip
418
419 } else { // non-bending
420
421 Int_t iCandidateLeft, iCandidateRight;
422 Int_t iNewCandidateRight=0;
423 Int_t iNewCandidateLeft=0;
424// first strip number on the right of the left module
425 if ( modNum!=0 && absiX!=52 )
426 iNewCandidateLeft = fNstrip[modNum-1]-1;
427 Int_t j;
428
429 *Nlist = 10;
430 for (Int_t i=0; i<10; i++) Xlist[i]=Ylist[i]=0;
431
432 if (iY < nStrip) {
433
434 for (Int_t i=0; i<5; i++) {
435 j = i + 5;
436 iCandidateRight = iY + (i + 1);
437 iCandidateLeft = iY - (i + 1);
438 if (iCandidateRight < nStrip) { // strip in same module
439 Xlist[i] = absiX;
440 Ylist[i] = iCandidateRight;
441 } else if (modNum!=6) { // need to scan the module on the right
442 Xlist[i] = absiX+1;
443 Ylist[i] = iNewCandidateRight;
444 iNewCandidateRight++;
445 }
446
447 if (iCandidateLeft >=0 ) { // strip in same module
448 Xlist[j] = absiX;
449 Ylist[j] = iCandidateLeft;
450 } else if ( iNewCandidateLeft !=0) {
451 Xlist[j] = absiX-1;
452 Ylist[j] = iNewCandidateLeft;
453 iNewCandidateLeft--;
454 }
455 }
456
457 if (iX<0) { // left side of chamber
458 for (Int_t i=0; i<10; i++) {
459 if (Xlist[i]!=0) Xlist[i]=-Xlist[i];
460 }
461 }
462
463 } // iY < nStrip
464 } // non-bending
465
466// for (Int_t i=0; i<10; i++) {
467// printf("AliMUONTriggerSegmentation LOC fBending i ix iy = %i %i %i %i \n",fBending,i,Xlist[i],Ylist[i]);
468// }
0a11496e 469}
470
471//--------------------------------------------------------------------------
472void AliMUONTriggerSegmentation::Init(Int_t detectionElementId,
0a11496e 473 Int_t nStrip[7],
474 Float_t stripYsize[7],
475 Float_t stripXsize[7],
476 Float_t offset)
477{
5398f946 478/// Initialize
479
79b4ba23 480// printf(" fBending: %d \n",fBending);
481
482 Int_t nStripMax = 0;
483 if (fBending) nStripMax = nStrip[0];
484
485 for (Int_t i=0; i<7; i++) {
486 fNstrip[i]=nStrip[i];
487 fStripYsize[i]=stripYsize[i];
488 fStripXsize[i]=stripXsize[i];
489 fModuleYmin[0]=0.;
490 }
0a11496e 491// take care of offset in Y in chamber 5, first module
79b4ba23 492 fModuleYmin[0] = offset;
493
494 Float_t tmp = 0.;
495 Int_t npad = 0; // number of pad in x and y
38aedc99 496 for (Int_t iModule=0; iModule<fNsec; iModule++) { // modules
79b4ba23 497 fModuleXmin[iModule] = tmp;
498 npad = npad + fNstrip[iModule];
499 if (fBending) {
500 fModuleXmax[iModule] =
501 fModuleXmin[iModule] + fStripXsize[iModule];
502 } else if (!fBending) {
503 if (iModule<6) {
504 fModuleXmax[iModule] =
38aedc99 505 fModuleXmin[iModule] +
506 fStripXsize[iModule]*fNstrip[iModule];
79b4ba23 507 } else if (iModule==6) {
508 fModuleXmax[iModule] =
509 fModuleXmin[iModule] +
510 (fStripXsize[iModule]*fNstrip[iModule]/2) +
511 (fStripXsize[iModule]/2.*fNstrip[iModule]/2);
512 }
513 }
514 tmp = fModuleXmax[iModule];
515
516// calculate nStripMax in x & y
517 if (fBending) {
518 if (fNstrip[iModule] > nStripMax) nStripMax = fNstrip[iModule];
519 } else if (!fBending) {
520 for (Int_t iStrip=0; iStrip<fNstrip[iModule]; iStrip++) nStripMax++;
521 }
522 } // loop on modules
0a11496e 523
524// associate nStripMax
7743b3a9 525// fNpx = (fBending) ? fNsec : nStripMax;
526// fNpy = (fBending) ? nStripMax : 1;
8ceced0c 527 fNpx = 124; // tot num of modules (like with old segmentation)
528 fNpy = 64; // max number of y strips within one module
529
38aedc99 530// calculate half size in x & y (to shift local coordinate ref. system)
0a11496e 531 fRpcHalfXsize = 0;
532 fRpcHalfYsize = 0;
533 if (fBending) {
38aedc99 534 for (Int_t iModule=0; iModule<fNsec; iModule++)
0a11496e 535 fRpcHalfXsize = fRpcHalfXsize + fStripXsize[iModule];
536 fRpcHalfYsize = fNstrip[1] * fStripYsize[1];
537 } else if (!fBending) {
538 fRpcHalfXsize = fModuleXmax[6];
539 fRpcHalfYsize = fStripYsize[1];
540 }
541 fRpcHalfXsize = fRpcHalfXsize / 2.;
542 fRpcHalfYsize = fRpcHalfYsize / 2.;
543
544/*
545 printf(" fNpx fNpy fRpcHalfXsize fRpcHalfYsize = %i %i %f %f \n",
546 fNpx,fNpy,fRpcHalfXsize,fRpcHalfYsize);
547
38aedc99 548 for (Int_t iModule=0; iModule<fNsec; iModule++) {
79b4ba23 549 printf(" iModule fModuleXmin fModuleXmax fModuleYmin fStripXsize fStripYsize %i %f %f %f %f %f\n",
0a11496e 550 iModule,fModuleXmin[iModule],fModuleXmax[iModule],
79b4ba23 551 fModuleYmin[iModule],
0a11496e 552 fStripXsize[iModule],fStripYsize[iModule]);
553 }
79b4ba23 554
38aedc99 555 for (Int_t iModule=0; iModule<fNsec; iModule++) {
79b4ba23 556 printf(" iModule fNstrip fStripXsize fStripYsize %i %i %f %f \n",
557 iModule,fNstrip[iModule],
558 fStripXsize[iModule],fStripYsize[iModule]);
559 }
560*/
561
0a11496e 562 fId = detectionElementId;
563}
564
70ef378c 565//_____________________________________________________________________________
566void
567AliMUONTriggerSegmentation::Print(Option_t*) const
568{
5398f946 569/// Printing
d19b6003 570
70ef378c 571 cout << "fId=" << fId << " fBending=" << fBending << " fNsec="
572 << fNsec << " Nx,Ny=" << fNpx << "," << fNpy
573 << " LineNumber=" << fLineNumber
574 << " fRpcHalfSize(X,Y)=" << fRpcHalfXsize << "," << fRpcHalfYsize
575 << endl;
576
577 for (Int_t iModule=0; iModule<fNsec; iModule++)
578 {
579 cout << "Module " << iModule
580 << " xmin,xmax=" << fModuleXmin[iModule]
581 << "," << fModuleXmax[iModule]
582 << " ymin=" << fModuleYmin[iModule]
583 << " StripSize(X,Y)=(" << fStripXsize[iModule] << ","
584 << fStripYsize[iModule] << ")"
585 << endl;
586 }
587}
0a11496e 588
589
590
591
592