| 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 |
17 | Revision 1.6 2000/07/13 16:19:44 fca |
| 18 | Mainly coding conventions + some small bug fixes |
| 19 | |
| ef42d733 |
20 | Revision 1.5 2000/07/03 11:54:57 morsch |
| 21 | AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER |
| 22 | The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC. |
| 23 | |
| a30a000f |
24 | Revision 1.4 2000/06/28 15:16:35 morsch |
| 25 | (1) Client code adapted to new method signatures in AliMUONSegmentation (see comments there) |
| 26 | to allow development of slat-muon chamber simulation and reconstruction code in the MUON |
| 27 | framework. The changes should have no side effects (mostly dummy arguments). |
| 28 | (2) Hit disintegration uses 3-dim hit coordinates to allow simulation |
| 29 | of chambers with overlapping modules (MakePadHits, Disintegration). |
| 30 | |
| 802a864d |
31 | Revision 1.3 2000/06/26 10:04:49 pcrochet |
| 32 | problem 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 | |
| 47 | ClassImp(AliMUONTriggerCircuit) |
| 48 | |
| a9e2aefa |
49 | //---------------------------------------------------------------------- |
| 50 | AliMUONTriggerCircuit::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 | //---------------------------------------------------------------------- |
| 71 | AliMUONTriggerCircuit::AliMUONTriggerCircuit(const AliMUONTriggerCircuit& MUONTriggerCircuit) |
| 72 | { |
| 73 | // Dummy copy constructor |
| 74 | } |
| 75 | |
| 76 | //---------------------------------------------------------------------- |
| 77 | AliMUONTriggerCircuit & AliMUONTriggerCircuit::operator=(const AliMUONTriggerCircuit& MUONTriggerCircuit) |
| 78 | { |
| 79 | // Dummy assignment operator |
| 80 | return *this; |
| 81 | } |
| 82 | |
| 83 | //---------------------------------------------------------------------- |
| 84 | void 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 | //---------------------------------------------------------------------- |
| 95 | Int_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 | //---------------------------------------------------------------------- |
| 107 | Int_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 | //---------------------------------------------------------------------- |
| 121 | Int_t AliMUONTriggerCircuit::Module(Int_t idCircuit) { |
| 122 | // returns ModuleId where Circuit idCircuit is sitting |
| 123 | return Int_t(idCircuit/10); |
| 124 | } |
| 125 | //---------------------------------------------------------------------- |
| 126 | Int_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 | //---------------------------------------------------------------------- |
| 132 | void 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 | //---------------------------------------------------------------------- |
| 181 | void 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 | //---------------------------------------------------------------------- |
| 271 | void 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 | //---------------------------------------------------------------------- |
| 291 | void 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 | //---------------------------------------------------------------------- |
| 345 | void 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 | //---------------------------------------------------------------------- |
| 386 | Float_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 | //---------------------------------------------------------------------- |
| 407 | Int_t AliMUONTriggerCircuit::GetIdCircuit(){ |
| 408 | // returns circuit Id |
| ecfa008b |
409 | return fIdCircuit; |
| a9e2aefa |
410 | } |
| 411 | //---------------------------------------------------------------------- |
| 412 | Int_t AliMUONTriggerCircuit::GetIdModule(){ |
| 413 | // returns module Id |
| ecfa008b |
414 | return Module(fIdCircuit); |
| a9e2aefa |
415 | } |
| 416 | //---------------------------------------------------------------------- |
| 417 | Int_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 | //---------------------------------------------------------------------- |
| 422 | Int_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 | //---------------------------------------------------------------------- |
| 427 | Int_t AliMUONTriggerCircuit::GetPosCircuit() { |
| 428 | // returns the position of the circuit in its module |
| ecfa008b |
429 | return Position(fIdCircuit); |
| a9e2aefa |
430 | } |
| 431 | //---------------------------------------------------------------------- |
| 432 | Int_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 | //---------------------------------------------------------------------- |
| 439 | Int_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 | //---------------------------------------------------------------------- |
| 448 | Int_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 | //---------------------------------------------------------------------- |
| 455 | Int_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 | //---------------------------------------------------------------------- |
| 464 | Int_t AliMUONTriggerCircuit::GetX2m(){ |
| ecfa008b |
465 | // returns fX2m |
| 466 | return fX2m; |
| a9e2aefa |
467 | } |
| 468 | //---------------------------------------------------------------------- |
| 469 | Int_t AliMUONTriggerCircuit::GetX2ud(){ |
| ecfa008b |
470 | // returns fX2ud |
| 471 | return fX2ud; |
| a9e2aefa |
472 | } |
| 473 | //---------------------------------------------------------------------- |
| 474 | void AliMUONTriggerCircuit::GetOrMud(Int_t orMud[2]){ |
| 475 | // returns fOrMud |
| 476 | orMud[0]=fOrMud[0]; |
| 477 | orMud[1]=fOrMud[1]; |
| 478 | } |
| 479 | //---------------------------------------------------------------------- |
| 480 | Int_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 | //---------------------------------------------------------------------- |
| 485 | Int_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 | //---------------------------------------------------------------------- |
| 490 | Float_t AliMUONTriggerCircuit::GetY11Pos(Int_t istrip){ |
| 491 | // returns Y position of X strip istrip in MC11 |
| 492 | return fYpos11[istrip]; |
| 493 | } |
| 494 | //---------------------------------------------------------------------- |
| 495 | Float_t AliMUONTriggerCircuit::GetY21Pos(Int_t istrip){ |
| 496 | // returns Y position of X strip istrip in MC21 |
| 497 | return fYpos21[istrip]; |
| 498 | } |
| 499 | //---------------------------------------------------------------------- |
| 500 | Float_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 | |
git://git.uio.no / u / mrichter / AliRoot.git / blame