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