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