Cleaning of the code :
[u/mrichter/AliRoot.git] / MUON / AliMUONTriggerCircuit.cxx
CommitLineData
a9e2aefa 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/*
aac5be80 16$Log$
ecfa008b 17Revision 1.6 2000/07/13 16:19:44 fca
18Mainly coding conventions + some small bug fixes
19
ef42d733 20Revision 1.5 2000/07/03 11:54:57 morsch
21AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
22The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.
23
a30a000f 24Revision 1.4 2000/06/28 15:16:35 morsch
25(1) Client code adapted to new method signatures in AliMUONSegmentation (see comments there)
26to allow development of slat-muon chamber simulation and reconstruction code in the MUON
27framework. The changes should have no side effects (mostly dummy arguments).
28(2) Hit disintegration uses 3-dim hit coordinates to allow simulation
29of chambers with overlapping modules (MakePadHits, Disintegration).
30
802a864d 31Revision 1.3 2000/06/26 10:04:49 pcrochet
32problem with HP compiler solved (PH), static variables removed : now defined in AliMUONTriggerConstants
33
a9e2aefa 34*/
aac5be80 35
a9e2aefa 36#include "AliRun.h"
37#include "AliMUON.h"
38#include "AliMUONPoints.h"
39#include "AliMUONTriggerCircuit.h"
aac5be80 40#include "AliMUONTriggerConstants.h"
a30a000f 41#include "AliSegmentation.h"
a9e2aefa 42#include "AliMUONResponse.h"
43#include "AliMUONChamber.h"
44#include "TMath.h"
45#include "iostream.h"
46
47ClassImp(AliMUONTriggerCircuit)
48
a9e2aefa 49//----------------------------------------------------------------------
50AliMUONTriggerCircuit::AliMUONTriggerCircuit()
51{
52// Constructor
ef42d733 53 fSegmentation=0;
ecfa008b 54 fIdCircuit=0;
55 fX2m=0;
56 fX2ud=0;
a9e2aefa 57 fOrMud[0]=fOrMud[1]=0;
aac5be80 58 Int_t i;
59 for (i=0; i<4; i++) {
a9e2aefa 60 for (Int_t j=0; j<32; j++) {
61 fXcode[i][j]=0;
62 fYcode[i][j]=0;
63 }
64 }
aac5be80 65 for (i=0; i<16; i++) { fXpos11[i]=0.; }
66 for (i=0; i<31; i++) { fYpos11[i]=0.; }
67 for (i=0; i<63; i++) { fYpos21[i]=0.; }
a9e2aefa 68}
69
70//----------------------------------------------------------------------
71AliMUONTriggerCircuit::AliMUONTriggerCircuit(const AliMUONTriggerCircuit& MUONTriggerCircuit)
72{
73// Dummy copy constructor
74}
75
76//----------------------------------------------------------------------
77AliMUONTriggerCircuit & AliMUONTriggerCircuit::operator=(const AliMUONTriggerCircuit& MUONTriggerCircuit)
78{
79// Dummy assignment operator
80 return *this;
81}
82
83//----------------------------------------------------------------------
84void AliMUONTriggerCircuit::Init(Int_t iCircuit) {
85// initialize circuit characteristics
ecfa008b 86 fIdCircuit=AliMUONTriggerConstants::CircuitId(iCircuit);
a9e2aefa 87 LoadX2();
88 LoadXCode();
89 LoadYCode();
90 LoadXPos();
91 LoadYPos();
92}
93
94//----------------------------------------------------------------------
95Int_t AliMUONTriggerCircuit::CircuitNumber(Int_t idCircuit){
96// returns circuit number iCircuit (0-234) corresponding to circuit idCircuit
97 Int_t iCircuit=0;
98 for (Int_t i=0; i<234; i++) {
aac5be80 99 if (AliMUONTriggerConstants::CircuitId(i)==idCircuit) {
a9e2aefa 100 iCircuit=i;
101 break;
102 }
103 }
104 return iCircuit;
105}
106//----------------------------------------------------------------------
107Int_t AliMUONTriggerCircuit::ModuleNumber(Int_t idModule){
108// returns module number imod (from 0 to 63) corresponding to module idmodule
109 Int_t absidModule=TMath::Abs(idModule);
110 Int_t iModule=0;
111 for (Int_t i=0; i<63; i++) {
aac5be80 112 if (AliMUONTriggerConstants::ModuleId(i)==absidModule) {
a9e2aefa 113 iModule=i;
114 break;
115 }
116 }
117 return iModule;
118}
119
120//----------------------------------------------------------------------
121Int_t AliMUONTriggerCircuit::Module(Int_t idCircuit) {
122// returns ModuleId where Circuit idCircuit is sitting
123 return Int_t(idCircuit/10);
124}
125//----------------------------------------------------------------------
126Int_t AliMUONTriggerCircuit::Position(Int_t idCircuit) {
127// returns position of idCircuit in correcponding Module
128 return TMath::Abs(idCircuit)-TMath::Abs(Module(idCircuit))*10;
129}
130
131//----------------------------------------------------------------------
132void AliMUONTriggerCircuit::LoadX2() {
ecfa008b 133// initialize fX2m, fX2ud and fOrMud
a9e2aefa 134
ecfa008b 135 Int_t idModule=Module(fIdCircuit); // corresponding module Id.
aac5be80 136// and its number of X strips
137 Int_t nStrX=AliMUONTriggerConstants::NstripX(ModuleNumber(idModule));
138// and its number of Y strips
139 Int_t nStrY=AliMUONTriggerConstants::NstripY(ModuleNumber(idModule));
ecfa008b 140 Int_t iPosCircuit=Position(fIdCircuit); // position of circuit in module
a9e2aefa 141
142// first step : look at lower part
143 if (iPosCircuit==1) { // need to scan lower module
144 if(idModule<91&&TMath::Abs(idModule)!=41&&idModule>-91) {
145 fOrMud[0]=1;
146 Int_t idModuleD=(TMath::Abs(idModule)+10)*(TMath::Abs(idModule)/idModule);
aac5be80 147 Int_t nStrD=AliMUONTriggerConstants::NstripY(ModuleNumber(idModuleD));
a9e2aefa 148
149 if (nStrY!=nStrD
150 &&TMath::Abs(idModule)!=42&&TMath::Abs(idModule)!=52) {
ecfa008b 151 if (nStrY==8) fX2m=1;
152 if (nStrD==8) fX2ud=1;
a9e2aefa 153 }
154 }
155
156 } else { // lower strips within same module
157 fOrMud[0]=0;
158 }
159
160// second step : look at upper part
161 if ((iPosCircuit==1&&nStrX==16)||(iPosCircuit==2&&nStrX==32)||
162 (iPosCircuit==3&&nStrX==48)||(iPosCircuit==4&&nStrX==64)) {
163 if ((idModule>17||idModule<-17)&&TMath::Abs(idModule)!=61) {
164 fOrMud[1]=1;
165 Int_t idModuleU=(TMath::Abs(idModule)-10)*(TMath::Abs(idModule)/idModule);
aac5be80 166 Int_t nStrU=AliMUONTriggerConstants::NstripY(ModuleNumber(idModuleU));
a9e2aefa 167
168 if (nStrY!=nStrU
169 &&TMath::Abs(idModule)!=62&&TMath::Abs(idModule)!=52) {
ecfa008b 170 if (nStrY==8) fX2m=1;
171 if (nStrU==8) fX2ud=1;
a9e2aefa 172 }
173 }
174
175 } else { // upper strips within same module
176 fOrMud[1]=0;
177 }
178}
179
180//----------------------------------------------------------------------
181void AliMUONTriggerCircuit::LoadXCode(){
182// assign a Id. number to each X strip of current circuit
183// Id.=(corresponding module Id.)*100+(Id. strip of module)
184
185// first part : fill XMC11 XMC12 and strips 8 to 24 (middle) XMC21 XMC22
186 Int_t iStripCircMT1=0, iStripCircMT2=8;
ecfa008b 187 Int_t idModule=Module(fIdCircuit); // corresponding module Id.
aac5be80 188// and its number of strips
189 Int_t nStrX=AliMUONTriggerConstants::NstripX(ModuleNumber(idModule));
ecfa008b 190 Int_t iPosCircuit=Position(fIdCircuit); // position of circuit in module
a9e2aefa 191 Int_t sign=TMath::Abs(idModule)/idModule; // left or right
aac5be80 192 Int_t istrip;
a9e2aefa 193
aac5be80 194 for (istrip=(iPosCircuit-1)*16;
a9e2aefa 195 istrip<(iPosCircuit-1)*16+16; istrip++) {
196
197 fXcode[0][iStripCircMT1]=sign*(TMath::Abs(idModule)*100+istrip);
198 fXcode[1][iStripCircMT1]=sign*(TMath::Abs(idModule)*100+istrip);
199 fXcode[2][iStripCircMT2]=sign*(TMath::Abs(idModule)*100+istrip);
200 fXcode[3][iStripCircMT2]=sign*(TMath::Abs(idModule)*100+istrip);
201 iStripCircMT1++;
202 iStripCircMT2++;
203 }
204
205// second part
206// XMC21 XMC22 strips 0 to 7 and 24 to 31
207 Int_t idModuleD, idModuleU;
208 Int_t nStrD, nStrU;
209
ecfa008b 210 idModule=Module(fIdCircuit); // corresponding module Id.
aac5be80 211// number of X strips
212 nStrX=AliMUONTriggerConstants::NstripX(ModuleNumber(idModule));
a9e2aefa 213 sign=TMath::Abs(idModule)/idModule;
214
215// fill lower part (0 to 7)
216 if (iPosCircuit==1) { // need to scan lower module
217 if(idModule<91&&TMath::Abs(idModule)!=41&&idModule>-91) { // non-existing
218 idModuleD=sign*(TMath::Abs(idModule)+10); // lower module Id
aac5be80 219// and its number of strips
220 nStrD=AliMUONTriggerConstants::NstripX(ModuleNumber(idModuleD));
a9e2aefa 221
222 iStripCircMT2=0;
aac5be80 223 for (istrip=nStrD-8; istrip<nStrD; istrip++) {
a9e2aefa 224 fXcode[2][iStripCircMT2]=sign*(TMath::Abs(idModuleD)*100+istrip);
225 fXcode[3][iStripCircMT2]=sign*(TMath::Abs(idModuleD)*100+istrip);
226 iStripCircMT2++;
227 }
228 }
229
230 } else { // lower strips within same module
231
232 iStripCircMT2=0;
aac5be80 233 for (istrip=(iPosCircuit-1)*16-8;
a9e2aefa 234 istrip<(iPosCircuit-1)*16; istrip++) {
235 fXcode[2][iStripCircMT2]=sign*(TMath::Abs(idModule)*100+istrip);
236 fXcode[3][iStripCircMT2]=sign*(TMath::Abs(idModule)*100+istrip);
237 iStripCircMT2++;
238 }
239 }
240
241// fill upper part (24 to 31)
242 if ((iPosCircuit==1&&nStrX==16)||(iPosCircuit==2&&nStrX==32)||
243 (iPosCircuit==3&&nStrX==48)||(iPosCircuit==4&&nStrX==64)) {
244 if ((idModule>17||idModule<-17)&&TMath::Abs(idModule)!=61) {
245 idModuleU=sign*(TMath::Abs(idModule)-10); // upper module Id
aac5be80 246// and its number of strips
247 nStrU=AliMUONTriggerConstants::NstripX(ModuleNumber(idModuleU));
a9e2aefa 248
249 iStripCircMT2=24;
aac5be80 250 for (istrip=0; istrip<8; istrip++) {
a9e2aefa 251 fXcode[2][iStripCircMT2]=sign*(TMath::Abs(idModuleU)*100+istrip);
252 fXcode[3][iStripCircMT2]=sign*(TMath::Abs(idModuleU)*100+istrip);
253 iStripCircMT2++;
254 }
255 }
256
257 } else if ((iPosCircuit==1&&nStrX>16)||(iPosCircuit==2&&nStrX>32)||
258 (iPosCircuit==3&&nStrX>48)) { // upper strips within same mod.
259
260 iStripCircMT2=24;
aac5be80 261 for (istrip=(iPosCircuit-1)*16+16;
a9e2aefa 262 istrip<(iPosCircuit-1)*16+24; istrip++) {
263 fXcode[2][iStripCircMT2]=sign*(TMath::Abs(idModule)*100+istrip);
264 fXcode[3][iStripCircMT2]=sign*(TMath::Abs(idModule)*100+istrip);
265 iStripCircMT2++;
266 }
267 }
268}
269
270//----------------------------------------------------------------------
271void AliMUONTriggerCircuit::LoadYCode(){
272// assign a Id. number to each Y strip of current circuit
273// Id.=(corresponding module Id.)*100+(Id. strip of module)
274// note : for Y plane fill only "central part" of circuit
275// (upper and lower parts are filled in PreHandlingY of AliMUONTriggerDecision)
276
ecfa008b 277 Int_t idModule=Module(fIdCircuit); // corresponding module Id.
aac5be80 278// and its number of Y strips
279 Int_t nStrY=AliMUONTriggerConstants::NstripY(ModuleNumber(idModule));
a9e2aefa 280 Int_t sign=TMath::Abs(idModule)/idModule; // left or right
281
282 for (Int_t istrip=0; istrip<nStrY; istrip++) {
283 fYcode[0][istrip]=sign*(TMath::Abs(idModule)*100+istrip);
284 fYcode[1][istrip]=sign*(TMath::Abs(idModule)*100+istrip);
285 fYcode[2][istrip]=sign*(TMath::Abs(idModule)*100+istrip);
286 fYcode[3][istrip]=sign*(TMath::Abs(idModule)*100+istrip);
287 }
288}
289
290//----------------------------------------------------------------------
291void AliMUONTriggerCircuit::LoadYPos(){
292// fill fYpos11 and fYpos21 -> y position of X declusterized strips
293
294 Int_t chamber, cathode;
295 Int_t code, idModule, idStrip, idSector;
802a864d 296 Float_t x, y, z, width;
aac5be80 297 Int_t istrip;
a9e2aefa 298
299 AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
300 AliMUONChamber* iChamber;
a30a000f 301 AliSegmentation* segmentation;
a9e2aefa 302
303// first plane (11)
304 chamber=11;
305 cathode=1;
306 iChamber = &(pMUON->Chamber(chamber-1));
307 segmentation=iChamber->SegmentationModel(cathode);
308
aac5be80 309 for (istrip=0; istrip<16; istrip++) {
a9e2aefa 310 code=fXcode[0][istrip]; // decode current strip
311 idModule=Int_t(code/100); // corresponding module Id.
312 idStrip=TMath::Abs(code-idModule*100); // corresp. strip number in module
313 idSector=segmentation->Sector(idModule,idStrip); // corresponding sector
314 width=segmentation->Dpy(idSector); // corresponding strip width
a30a000f 315 segmentation->GetPadC(idModule,idStrip,x,y,z); // get strip real position
a9e2aefa 316
317 fYpos11[2*istrip]=y;
318 if (istrip!=15) fYpos11[2*istrip+1]=y+width/2.;
319 }
320
321// second plane (21)
322 chamber=13;
323 cathode=1;
324 iChamber = &(pMUON->Chamber(chamber-1));
325 segmentation=iChamber->SegmentationModel(cathode);
326
aac5be80 327 for (istrip=0; istrip<32; istrip++) {
a9e2aefa 328 code=fXcode[2][istrip]; // decode current strip
329 idModule=Int_t(code/100); // corresponding module Id.
330 idStrip=TMath::Abs(code-idModule*100); // corresp. strip number in module
331 idSector=segmentation->Sector(idModule,idStrip); // corresponding sector
332 width=segmentation->Dpy(idSector); // corresponding strip width
a30a000f 333 segmentation->GetPadC(idModule,idStrip,x,y,z); // get strip real position
a9e2aefa 334
335// using idModule!=0 prevents to fill garbage in case of circuits
336// in the first and last rows
337 if (idModule!=0) {
338 fYpos21[2*istrip]=y;
339 if (istrip!=31) fYpos21[2*istrip+1]=y+width/2.;
340 }
341 }
342}
343
344//----------------------------------------------------------------------
345void AliMUONTriggerCircuit::LoadXPos(){
346// fill fXpos11 -> x position of Y strips for the first plane only
347// fXpos11 contains the x position of Y strip for the current circuit
348// taking into account whether or nor not part(s) of the circuit
349// (middle, up or down) has(have) 16 strips
350
802a864d 351 Float_t x, y, z;
aac5be80 352 Int_t istrip;
a9e2aefa 353
354 Int_t chamber=11;
355 Int_t cathode=2;
356 AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
357 AliMUONChamber* iChamber;
a30a000f 358 AliSegmentation* segmentation;
a9e2aefa 359 iChamber = &(pMUON->Chamber(chamber-1));
360 segmentation=iChamber->SegmentationModel(cathode);
361
ecfa008b 362 Int_t idModule=Module(fIdCircuit); // corresponding module Id.
aac5be80 363// number of Y strips
364 Int_t nStrY=AliMUONTriggerConstants::NstripY(ModuleNumber(idModule));
a9e2aefa 365 Int_t idSector=segmentation->Sector(idModule,0); // corresp. sector
366 Float_t width=segmentation->Dpx(idSector); // corresponding strip width
367
368// first case : up middle and down parts have all 8 or 16 strip
ecfa008b 369 if ((nStrY==16)||(nStrY==8&&fX2m==0&&fX2ud==0)) {
aac5be80 370 for (istrip=0; istrip<nStrY; istrip++) {
a30a000f 371 segmentation->GetPadC(idModule,istrip,x,y,z);
a9e2aefa 372 fXpos11[istrip]=x;
373 }
374// second case : mixing 8 and 16 strips within same circuit
375 } else {
aac5be80 376 for (istrip=0; istrip<nStrY; istrip++) {
a9e2aefa 377 if (nStrY!=8) { cout << " bug in LoadXpos " << "\n";}
a30a000f 378 segmentation->GetPadC(idModule,istrip,x,y,z);
a9e2aefa 379 fXpos11[2*istrip]=x-width/4.;
380 fXpos11[2*istrip+1]=fXpos11[2*istrip]+width/2.;
381 }
382 }
383}
384
385//----------------------------------------------------------------------
386Float_t AliMUONTriggerCircuit::PtCal(Int_t istripX, Int_t idev, Int_t istripY){
387// returns calculated pt for circuit/istripX/idev/istripY according
388// to the formula of the TRD. Note : idev (input) is in [0+30]
389
390 // Int_t jdev = idev - 15; // jdev in [-15+15]
391 Int_t istripX2=istripX+idev+1; // find istripX2 using istripX and idev
392
393 Float_t yPosX1=fYpos11[istripX];
394 Float_t yPosX2=fYpos21[istripX2];
395 Float_t xPosY1=fXpos11[istripY];
396
397 Float_t zf=975., z1=1603.5, z2=1703.5;
398 Float_t thetaDev=(1./zf)*(yPosX1*z2-yPosX2*z1)/(z2-z1);
399 Float_t xf=xPosY1*zf/z1;
400 Float_t yf=yPosX2-((yPosX2-yPosX1)*(z2-zf))/(z2-z1);
401 return (3.*0.3/TMath::Abs(thetaDev)) * TMath::Sqrt(xf*xf+yf*yf)/zf;
402}
403
404//----------------------------------------------------------------------
405//--- methods which return member data related info
406//----------------------------------------------------------------------
407Int_t AliMUONTriggerCircuit::GetIdCircuit(){
408// returns circuit Id
ecfa008b 409 return fIdCircuit;
a9e2aefa 410}
411//----------------------------------------------------------------------
412Int_t AliMUONTriggerCircuit::GetIdModule(){
413// returns module Id
ecfa008b 414 return Module(fIdCircuit);
a9e2aefa 415}
416//----------------------------------------------------------------------
417Int_t AliMUONTriggerCircuit::GetNstripX() {
418// returns the number of X strips in the module where the circuit is sitting
ecfa008b 419 return AliMUONTriggerConstants::NstripX(ModuleNumber(Module(fIdCircuit)));
a9e2aefa 420}
421//----------------------------------------------------------------------
422Int_t AliMUONTriggerCircuit::GetNstripY() {
423// returns the number of Y strips in the module where the circuit is sitting
ecfa008b 424 return AliMUONTriggerConstants::NstripY(ModuleNumber(Module(fIdCircuit)));
a9e2aefa 425}
426//----------------------------------------------------------------------
427Int_t AliMUONTriggerCircuit::GetPosCircuit() {
428// returns the position of the circuit in its module
ecfa008b 429 return Position(fIdCircuit);
a9e2aefa 430}
431//----------------------------------------------------------------------
432Int_t AliMUONTriggerCircuit::GetIdCircuitD(){
433// returns the Id of the circuit down
ecfa008b 434 Int_t idModule=Module(fIdCircuit);
a9e2aefa 435 Int_t idModuleD=(TMath::Abs(idModule)+10)*(TMath::Abs(idModule)/idModule);
436 return (TMath::Abs(idModuleD)*10+1)*(TMath::Abs(idModule)/idModule);
437}
438//----------------------------------------------------------------------
439Int_t AliMUONTriggerCircuit::GetICircuitD(){
440// returns the number of the circuit down
ecfa008b 441 Int_t idModule=Module(fIdCircuit);
a9e2aefa 442 Int_t idModuleD=(TMath::Abs(idModule)+10)*(TMath::Abs(idModule)/idModule);
443 Int_t idCircuitD=
444 (TMath::Abs(idModuleD)*10+1)*(TMath::Abs(idModule)/idModule);
445 return CircuitNumber(idCircuitD);
446}
447//----------------------------------------------------------------------
448Int_t AliMUONTriggerCircuit::GetIdCircuitU(){
449// returns the Id of the circuit up
ecfa008b 450 Int_t idModule=Module(fIdCircuit);
a9e2aefa 451 Int_t idModuleU=(TMath::Abs(idModule)-10)*(TMath::Abs(idModule)/idModule);
452 return (TMath::Abs(idModuleU)*10+1)*(TMath::Abs(idModule)/idModule);
453}
454//----------------------------------------------------------------------
455Int_t AliMUONTriggerCircuit::GetICircuitU(){
456// returns the number of the circuit up
ecfa008b 457 Int_t idModule=Module(fIdCircuit);
a9e2aefa 458 Int_t idModuleU=(TMath::Abs(idModule)-10)*(TMath::Abs(idModule)/idModule);
459 Int_t idCircuitU=
460 (TMath::Abs(idModuleU)*10+1)*(TMath::Abs(idModule)/idModule);
461 return CircuitNumber(idCircuitU);
462}
463//----------------------------------------------------------------------
464Int_t AliMUONTriggerCircuit::GetX2m(){
ecfa008b 465// returns fX2m
466 return fX2m;
a9e2aefa 467}
468//----------------------------------------------------------------------
469Int_t AliMUONTriggerCircuit::GetX2ud(){
ecfa008b 470// returns fX2ud
471 return fX2ud;
a9e2aefa 472}
473//----------------------------------------------------------------------
474void AliMUONTriggerCircuit::GetOrMud(Int_t orMud[2]){
475// returns fOrMud
476 orMud[0]=fOrMud[0];
477 orMud[1]=fOrMud[1];
478}
479//----------------------------------------------------------------------
480Int_t AliMUONTriggerCircuit::GetXcode(Int_t chamber, Int_t istrip){
481// returns X code of circuit/chamber/istrip (warning : chamber in [0,3])
482 return fXcode[chamber][istrip];
483}
484//----------------------------------------------------------------------
485Int_t AliMUONTriggerCircuit::GetYcode(Int_t chamber, Int_t istrip){
486// returns Y code of circuit/chamber/istrip (warning : chamber in [0,3])
487 return fYcode[chamber][istrip];
488}
489//----------------------------------------------------------------------
490Float_t AliMUONTriggerCircuit::GetY11Pos(Int_t istrip){
491// returns Y position of X strip istrip in MC11
492 return fYpos11[istrip];
493}
494//----------------------------------------------------------------------
495Float_t AliMUONTriggerCircuit::GetY21Pos(Int_t istrip){
496// returns Y position of X strip istrip in MC21
497 return fYpos21[istrip];
498}
499//----------------------------------------------------------------------
500Float_t AliMUONTriggerCircuit::GetX11Pos(Int_t istrip){
501// returns X position of Y strip istrip in MC11
502 return fXpos11[istrip];
503}
504//----------------------------------------------------------------------
505//--- end of methods which return member data related info
506//----------------------------------------------------------------------
507
508
509
510
511
512
513