MUON/AliMUONTriggerCircuit.cxx

   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 $Log$
  17 Revision 1.7  2000/10/02 16:58:29  egangler
  18 Cleaning of the code :
  19 -> coding conventions
  20 -> void Streamers
  21 -> some useless includes removed or replaced by "class" statement
  22
  23 Revision 1.6  2000/07/13 16:19:44  fca
  24 Mainly coding conventions + some small bug fixes
  25
  26 Revision 1.5  2000/07/03 11:54:57  morsch
  27 AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
  28 The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.
  29
  30 Revision 1.4  2000/06/28 15:16:35  morsch
  31 (1) Client code adapted to new method signatures in AliMUONSegmentation (see comments there)
  32 to allow development of slat-muon chamber simulation and reconstruction code in the MUON
  33 framework. The changes should have no side effects (mostly dummy arguments).
  34 (2) Hit disintegration uses 3-dim hit coordinates to allow simulation
  35 of chambers with overlapping modules (MakePadHits, Disintegration).
  36
  37 Revision 1.3  2000/06/26 10:04:49  pcrochet
  38 problem with HP compiler solved (PH), static variables removed : now defined in AliMUONTriggerConstants
  39
  40 */
  41
  42 #include "AliRun.h"
  43 #include "AliMUON.h"
  44 #include "AliMUONTriggerCircuit.h"
  45 #include "AliMUONTriggerConstants.h"
  46 #include "AliSegmentation.h"
  47 #include "AliMUONResponse.h"
  48 #include "AliMUONChamber.h"
  49 #include "TMath.h"
  50 #include "iostream.h"
  51
  52 ClassImp(AliMUONTriggerCircuit)
  53
  54 //----------------------------------------------------------------------
  55 AliMUONTriggerCircuit::AliMUONTriggerCircuit()
  56 {
  57 // Constructor
  58   fSegmentation=0;
  59   fIdCircuit=0;
  60   fX2m=0;
  61   fX2ud=0;
  62   fOrMud[0]=fOrMud[1]=0;
  63   Int_t i;
  64   for (i=0; i<4; i++) {
  65     for (Int_t j=0; j<32; j++) {
  66       fXcode[i][j]=0;
  67       fYcode[i][j]=0;
  68     }
  69   }
  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.; }
  73 }
  74
  75 //----------------------------------------------------------------------
  76 AliMUONTriggerCircuit::AliMUONTriggerCircuit(const AliMUONTriggerCircuit& MUONTriggerCircuit)
  77 {
  78 // Dummy copy constructor
  79 }
  80
  81 //----------------------------------------------------------------------
  82 AliMUONTriggerCircuit & AliMUONTriggerCircuit::operator=(const AliMUONTriggerCircuit& MUONTriggerCircuit)
  83 {
  84 // Dummy assignment operator
  85     return *this;
  86 }
  87
  88 //----------------------------------------------------------------------
  89 void AliMUONTriggerCircuit::Init(Int_t iCircuit) {
  90 // initialize circuit characteristics
  91   fIdCircuit=AliMUONTriggerConstants::CircuitId(iCircuit);
  92   LoadX2();
  93   LoadXCode();
  94   LoadYCode();
  95   LoadXPos();
  96   LoadYPos();
  97 }
  98
  99 //----------------------------------------------------------------------
 100 Int_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++) {
 104     if (AliMUONTriggerConstants::CircuitId(i)==idCircuit) {
 105       iCircuit=i;
 106       break;
 107     }
 108   }
 109   return iCircuit;
 110 }
 111 //----------------------------------------------------------------------
 112 Int_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++) {
 117     if (AliMUONTriggerConstants::ModuleId(i)==absidModule) {
 118       iModule=i;
 119       break;
 120     }
 121   }
 122   return iModule;
 123 }
 124
 125 //----------------------------------------------------------------------
 126 Int_t AliMUONTriggerCircuit::Module(Int_t idCircuit) {
 127 // returns ModuleId where Circuit idCircuit is sitting
 128   return Int_t(idCircuit/10);
 129 }
 130 //----------------------------------------------------------------------
 131 Int_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 //----------------------------------------------------------------------
 137 void AliMUONTriggerCircuit::LoadX2() {
 138 // initialize fX2m, fX2ud and fOrMud
 139
 140   Int_t idModule=Module(fIdCircuit);        // corresponding module Id.
 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));
 145   Int_t iPosCircuit=Position(fIdCircuit); // position of circuit in module
 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);
 152       Int_t nStrD=AliMUONTriggerConstants::NstripY(ModuleNumber(idModuleD));
 153
 154       if (nStrY!=nStrD
 155           &&TMath::Abs(idModule)!=42&&TMath::Abs(idModule)!=52) {
 156         if (nStrY==8) fX2m=1;
 157         if (nStrD==8) fX2ud=1;
 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);
 171       Int_t nStrU=AliMUONTriggerConstants::NstripY(ModuleNumber(idModuleU));
 172
 173       if (nStrY!=nStrU
 174           &&TMath::Abs(idModule)!=62&&TMath::Abs(idModule)!=52) {
 175         if (nStrY==8) fX2m=1;
 176         if (nStrU==8) fX2ud=1;
 177       }
 178     }
 179
 180   } else {                       // upper strips within same module
 181     fOrMud[1]=0;
 182   }
 183 }
 184
 185 //----------------------------------------------------------------------
 186 void 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;
 192   Int_t idModule=Module(fIdCircuit);        // corresponding module Id.
 193 // and its number of strips
 194   Int_t nStrX=AliMUONTriggerConstants::NstripX(ModuleNumber(idModule));
 195   Int_t iPosCircuit=Position(fIdCircuit);   // position of circuit in module
 196   Int_t sign=TMath::Abs(idModule)/idModule; // left or right
 197   Int_t istrip;
 198
 199   for (istrip=(iPosCircuit-1)*16;
 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
 215   idModule=Module(fIdCircuit); // corresponding module Id.
 216 // number of X strips
 217   nStrX=AliMUONTriggerConstants::NstripX(ModuleNumber(idModule));
 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
 224 // and its number of strips
 225       nStrD=AliMUONTriggerConstants::NstripX(ModuleNumber(idModuleD));
 226
 227       iStripCircMT2=0;
 228       for (istrip=nStrD-8; istrip<nStrD; istrip++) {
 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;
 238     for (istrip=(iPosCircuit-1)*16-8;
 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
 251 // and its number of strips
 252       nStrU=AliMUONTriggerConstants::NstripX(ModuleNumber(idModuleU));
 253
 254       iStripCircMT2=24;
 255       for (istrip=0; istrip<8; istrip++) {
 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;
 266     for (istrip=(iPosCircuit-1)*16+16;
 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 //----------------------------------------------------------------------
 276 void 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
 282   Int_t idModule=Module(fIdCircuit);        // corresponding module Id.
 283 // and its number of Y strips
 284   Int_t nStrY=AliMUONTriggerConstants::NstripY(ModuleNumber(idModule));
 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 //----------------------------------------------------------------------
 296 void 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;
 301   Float_t x, y, z, width;
 302   Int_t istrip;
 303
 304   AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
 305   AliMUONChamber*  iChamber;
 306   AliSegmentation*  segmentation;
 307
 308 // first plane (11)
 309   chamber=11;
 310   cathode=1;
 311   iChamber = &(pMUON->Chamber(chamber-1));
 312   segmentation=iChamber->SegmentationModel(cathode);
 313
 314   for (istrip=0; istrip<16; istrip++) {
 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
 320     segmentation->GetPadC(idModule,idStrip,x,y,z); // get strip real position
 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
 332   for (istrip=0; istrip<32; istrip++) {
 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
 338     segmentation->GetPadC(idModule,idStrip,x,y,z); // get strip real position
 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 //----------------------------------------------------------------------
 350 void 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
 356   Float_t x, y, z;
 357   Int_t istrip;
 358
 359   Int_t chamber=11;
 360   Int_t cathode=2;
 361   AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
 362   AliMUONChamber*  iChamber;
 363   AliSegmentation*  segmentation;
 364   iChamber = &(pMUON->Chamber(chamber-1));
 365   segmentation=iChamber->SegmentationModel(cathode);
 366
 367   Int_t idModule=Module(fIdCircuit);        // corresponding module Id.
 368 // number of Y strips
 369   Int_t nStrY=AliMUONTriggerConstants::NstripY(ModuleNumber(idModule));
 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
 374   if ((nStrY==16)||(nStrY==8&&fX2m==0&&fX2ud==0)) {
 375     for (istrip=0; istrip<nStrY; istrip++) {
 376       segmentation->GetPadC(idModule,istrip,x,y,z);
 377       fXpos11[istrip]=x;
 378     }
 379 // second case : mixing 8 and 16 strips within same circuit
 380   } else {
 381     for (istrip=0; istrip<nStrY; istrip++) {
 382       if (nStrY!=8) { cout << " bug in LoadXpos " << "\n";}
 383       segmentation->GetPadC(idModule,istrip,x,y,z);
 384       fXpos11[2*istrip]=x-width/4.;
 385       fXpos11[2*istrip+1]=fXpos11[2*istrip]+width/2.;
 386     }
 387   }
 388 }
 389
 390 //----------------------------------------------------------------------
 391 Float_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 //----------------------------------------------------------------------
 412 Int_t AliMUONTriggerCircuit::GetIdCircuit(){
 413 // returns circuit Id
 414   return fIdCircuit;
 415 }
 416 //----------------------------------------------------------------------
 417 Int_t AliMUONTriggerCircuit::GetIdModule(){
 418 // returns module Id
 419   return Module(fIdCircuit);
 420 }
 421 //----------------------------------------------------------------------
 422 Int_t AliMUONTriggerCircuit::GetNstripX() {
 423 // returns the number of X strips in the module where the circuit is sitting
 424   return AliMUONTriggerConstants::NstripX(ModuleNumber(Module(fIdCircuit)));
 425 }
 426 //----------------------------------------------------------------------
 427 Int_t AliMUONTriggerCircuit::GetNstripY() {
 428 // returns the number of Y strips in the module where the circuit is sitting
 429   return AliMUONTriggerConstants::NstripY(ModuleNumber(Module(fIdCircuit)));
 430 }
 431 //----------------------------------------------------------------------
 432 Int_t AliMUONTriggerCircuit::GetPosCircuit() {
 433 // returns the position of the circuit in its module
 434   return Position(fIdCircuit);
 435 }
 436 //----------------------------------------------------------------------
 437 Int_t AliMUONTriggerCircuit::GetIdCircuitD(){
 438 // returns the Id of the circuit down
 439   Int_t idModule=Module(fIdCircuit);
 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 //----------------------------------------------------------------------
 444 Int_t AliMUONTriggerCircuit::GetICircuitD(){
 445 // returns the number of the circuit down
 446   Int_t idModule=Module(fIdCircuit);
 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 //----------------------------------------------------------------------
 453 Int_t AliMUONTriggerCircuit::GetIdCircuitU(){
 454 // returns the Id of the circuit up
 455   Int_t idModule=Module(fIdCircuit);
 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 //----------------------------------------------------------------------
 460 Int_t AliMUONTriggerCircuit::GetICircuitU(){
 461 // returns the number of the circuit up
 462   Int_t idModule=Module(fIdCircuit);
 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 //----------------------------------------------------------------------
 469 Int_t AliMUONTriggerCircuit::GetX2m(){
 470 // returns fX2m
 471   return fX2m;
 472 }
 473 //----------------------------------------------------------------------
 474 Int_t AliMUONTriggerCircuit::GetX2ud(){
 475 // returns fX2ud
 476   return fX2ud;
 477 }
 478 //----------------------------------------------------------------------
 479 void AliMUONTriggerCircuit::GetOrMud(Int_t orMud[2]){
 480 // returns fOrMud
 481   orMud[0]=fOrMud[0];
 482   orMud[1]=fOrMud[1];
 483 }
 484 //----------------------------------------------------------------------
 485 Int_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 //----------------------------------------------------------------------
 490 Int_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 //----------------------------------------------------------------------
 495 Float_t AliMUONTriggerCircuit::GetY11Pos(Int_t istrip){
 496 // returns Y position of X strip istrip in MC11
 497   return fYpos11[istrip];
 498 }
 499 //----------------------------------------------------------------------
 500 Float_t AliMUONTriggerCircuit::GetY21Pos(Int_t istrip){
 501 // returns Y position of X strip istrip in MC21
 502   return fYpos21[istrip];
 503 }
 504 //----------------------------------------------------------------------
 505 Float_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