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