]> 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
properly take care of chamber edges in GetPadI
[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"
331dcacd 25#include "AliMUONGeometrySegmentation.h"
a9e2aefa 26#include "AliMUONChamber.h"
3f434b6f 27#include "AliMUONConstants.h"
8c343c7c 28#include "AliLog.h"
a9e2aefa 29
30ClassImp(AliMUONTriggerCircuit)
31
a9e2aefa 32//----------------------------------------------------------------------
30178c30 33AliMUONTriggerCircuit::AliMUONTriggerCircuit()
331dcacd 34 : TObject(),
35 fIdCircuit(0),
36 fX2m(0),
37 fX2ud(0)
38 // fSegmentationType(1)
a9e2aefa 39{
40// Constructor
331dcacd 41
a9e2aefa 42 fOrMud[0]=fOrMud[1]=0;
aac5be80 43 Int_t i;
44 for (i=0; i<4; i++) {
a9e2aefa 45 for (Int_t j=0; j<32; j++) {
46 fXcode[i][j]=0;
47 fYcode[i][j]=0;
48 }
49 }
aac5be80 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.; }
a9e2aefa 53}
54
55//----------------------------------------------------------------------
30178c30 56AliMUONTriggerCircuit::AliMUONTriggerCircuit(const AliMUONTriggerCircuit& theMUONTriggerCircuit)
57 : TObject(theMUONTriggerCircuit)
a9e2aefa 58{
30178c30 59// Protected copy constructor
60
8c343c7c 61 AliFatal("Not implemented.");
a9e2aefa 62}
63
64//----------------------------------------------------------------------
30178c30 65AliMUONTriggerCircuit &
66AliMUONTriggerCircuit::operator=(const AliMUONTriggerCircuit& rhs)
a9e2aefa 67{
30178c30 68// Protected assignement operator
69
70 if (this == &rhs) return *this;
71
8c343c7c 72 AliFatal("Not implemented.");
30178c30 73
74 return *this;
a9e2aefa 75}
76
77//----------------------------------------------------------------------
78void AliMUONTriggerCircuit::Init(Int_t iCircuit) {
79// initialize circuit characteristics
ecfa008b 80 fIdCircuit=AliMUONTriggerConstants::CircuitId(iCircuit);
331dcacd 81 AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
82
a9e2aefa 83 LoadX2();
84 LoadXCode();
85 LoadYCode();
331dcacd 86
87 if (pMUON->WhichSegmentation() == 1) {
88 LoadXPos();
89 LoadYPos();
90 } else {
91 LoadXPos2();
92 LoadYPos2();
93 }
a9e2aefa 94}
95
96//----------------------------------------------------------------------
30178c30 97Int_t AliMUONTriggerCircuit::CircuitNumber(Int_t idCircuit) const {
a9e2aefa 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++) {
aac5be80 101 if (AliMUONTriggerConstants::CircuitId(i)==idCircuit) {
a9e2aefa 102 iCircuit=i;
103 break;
104 }
105 }
106 return iCircuit;
107}
108//----------------------------------------------------------------------
30178c30 109Int_t AliMUONTriggerCircuit::ModuleNumber(Int_t idModule) const {
a9e2aefa 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++) {
aac5be80 114 if (AliMUONTriggerConstants::ModuleId(i)==absidModule) {
a9e2aefa 115 iModule=i;
116 break;
117 }
118 }
119 return iModule;
120}
121
122//----------------------------------------------------------------------
30178c30 123Int_t AliMUONTriggerCircuit::Module(Int_t idCircuit) const {
a9e2aefa 124// returns ModuleId where Circuit idCircuit is sitting
125 return Int_t(idCircuit/10);
126}
127//----------------------------------------------------------------------
30178c30 128Int_t AliMUONTriggerCircuit::Position(Int_t idCircuit) const {
a9e2aefa 129// returns position of idCircuit in correcponding Module
130 return TMath::Abs(idCircuit)-TMath::Abs(Module(idCircuit))*10;
131}
132
133//----------------------------------------------------------------------
134void AliMUONTriggerCircuit::LoadX2() {
ecfa008b 135// initialize fX2m, fX2ud and fOrMud
a9e2aefa 136
ecfa008b 137 Int_t idModule=Module(fIdCircuit); // corresponding module Id.
aac5be80 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));
ecfa008b 142 Int_t iPosCircuit=Position(fIdCircuit); // position of circuit in module
a9e2aefa 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);
aac5be80 149 Int_t nStrD=AliMUONTriggerConstants::NstripY(ModuleNumber(idModuleD));
a9e2aefa 150
151 if (nStrY!=nStrD
152 &&TMath::Abs(idModule)!=42&&TMath::Abs(idModule)!=52) {
ecfa008b 153 if (nStrY==8) fX2m=1;
154 if (nStrD==8) fX2ud=1;
a9e2aefa 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);
aac5be80 168 Int_t nStrU=AliMUONTriggerConstants::NstripY(ModuleNumber(idModuleU));
a9e2aefa 169
170 if (nStrY!=nStrU
171 &&TMath::Abs(idModule)!=62&&TMath::Abs(idModule)!=52) {
ecfa008b 172 if (nStrY==8) fX2m=1;
173 if (nStrU==8) fX2ud=1;
a9e2aefa 174 }
175 }
176
177 } else { // upper strips within same module
178 fOrMud[1]=0;
179 }
180}
181
182//----------------------------------------------------------------------
183void 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;
ecfa008b 189 Int_t idModule=Module(fIdCircuit); // corresponding module Id.
aac5be80 190// and its number of strips
191 Int_t nStrX=AliMUONTriggerConstants::NstripX(ModuleNumber(idModule));
ecfa008b 192 Int_t iPosCircuit=Position(fIdCircuit); // position of circuit in module
a9e2aefa 193 Int_t sign=TMath::Abs(idModule)/idModule; // left or right
aac5be80 194 Int_t istrip;
a9e2aefa 195
aac5be80 196 for (istrip=(iPosCircuit-1)*16;
a9e2aefa 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
ecfa008b 212 idModule=Module(fIdCircuit); // corresponding module Id.
aac5be80 213// number of X strips
214 nStrX=AliMUONTriggerConstants::NstripX(ModuleNumber(idModule));
a9e2aefa 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
aac5be80 221// and its number of strips
222 nStrD=AliMUONTriggerConstants::NstripX(ModuleNumber(idModuleD));
a9e2aefa 223
224 iStripCircMT2=0;
aac5be80 225 for (istrip=nStrD-8; istrip<nStrD; istrip++) {
a9e2aefa 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;
aac5be80 235 for (istrip=(iPosCircuit-1)*16-8;
a9e2aefa 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
aac5be80 248// and its number of strips
249 nStrU=AliMUONTriggerConstants::NstripX(ModuleNumber(idModuleU));
a9e2aefa 250
251 iStripCircMT2=24;
aac5be80 252 for (istrip=0; istrip<8; istrip++) {
a9e2aefa 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;
aac5be80 263 for (istrip=(iPosCircuit-1)*16+16;
a9e2aefa 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//----------------------------------------------------------------------
273void 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
ecfa008b 279 Int_t idModule=Module(fIdCircuit); // corresponding module Id.
aac5be80 280// and its number of Y strips
281 Int_t nStrY=AliMUONTriggerConstants::NstripY(ModuleNumber(idModule));
a9e2aefa 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//----------------------------------------------------------------------
293void 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;
802a864d 298 Float_t x, y, z, width;
aac5be80 299 Int_t istrip;
a9e2aefa 300
301 AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
302 AliMUONChamber* iChamber;
a30a000f 303 AliSegmentation* segmentation;
a9e2aefa 304
305// first plane (11)
306 chamber=11;
307 cathode=1;
308 iChamber = &(pMUON->Chamber(chamber-1));
309 segmentation=iChamber->SegmentationModel(cathode);
310
aac5be80 311 for (istrip=0; istrip<16; istrip++) {
a9e2aefa 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
a30a000f 317 segmentation->GetPadC(idModule,idStrip,x,y,z); // get strip real position
a9e2aefa 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
aac5be80 329 for (istrip=0; istrip<32; istrip++) {
a9e2aefa 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
a30a000f 335 segmentation->GetPadC(idModule,idStrip,x,y,z); // get strip real position
a9e2aefa 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//----------------------------------------------------------------------
347void 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
802a864d 353 Float_t x, y, z;
aac5be80 354 Int_t istrip;
a9e2aefa 355
356 Int_t chamber=11;
357 Int_t cathode=2;
358 AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
359 AliMUONChamber* iChamber;
a30a000f 360 AliSegmentation* segmentation;
a9e2aefa 361 iChamber = &(pMUON->Chamber(chamber-1));
362 segmentation=iChamber->SegmentationModel(cathode);
363
ecfa008b 364 Int_t idModule=Module(fIdCircuit); // corresponding module Id.
aac5be80 365// number of Y strips
366 Int_t nStrY=AliMUONTriggerConstants::NstripY(ModuleNumber(idModule));
a9e2aefa 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
ecfa008b 371 if ((nStrY==16)||(nStrY==8&&fX2m==0&&fX2ud==0)) {
aac5be80 372 for (istrip=0; istrip<nStrY; istrip++) {
a30a000f 373 segmentation->GetPadC(idModule,istrip,x,y,z);
a9e2aefa 374 fXpos11[istrip]=x;
375 }
376// second case : mixing 8 and 16 strips within same circuit
377 } else {
aac5be80 378 for (istrip=0; istrip<nStrY; istrip++) {
cbc57deb 379 if (nStrY!=8) { printf(" bug in LoadXpos \n");}
a30a000f 380 segmentation->GetPadC(idModule,istrip,x,y,z);
a9e2aefa 381 fXpos11[2*istrip]=x-width/4.;
382 fXpos11[2*istrip+1]=fXpos11[2*istrip]+width/2.;
383 }
384 }
385}
386
387//----------------------------------------------------------------------
388Float_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
3f434b6f 399 Float_t zf=975.;
400 Float_t z1=AliMUONConstants::DefaultChamberZ(10);
401 Float_t z2=AliMUONConstants::DefaultChamberZ(12);
a9e2aefa 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}
331dcacd 407//---------------------------------------------------------------------
408//----------------------- New Segmentation ----------------------------
409//---------------------------------------------------------------------
410
411//---------------------------------------------------------------------
412void 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;
3bf95daf 423
331dcacd 424// first plane (11)
425 chamber=11;
426 cathode=1;
427 iChamber = &(pMUON->Chamber(chamber-1));
428 segmentation=iChamber->SegmentationModel2(cathode);
429
3bf95daf 430 if (!segmentation) {
431 AliWarning("Segmentation not defined.");
432 return;
433 }
434
331dcacd 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//----------------------------------------------------------------------
474void 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
3bf95daf 491 if (!segmentation) {
492 AliWarning("Segmentation not defined.");
493 return;
494 }
495
331dcacd 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}
a9e2aefa 519
520//----------------------------------------------------------------------
521//--- methods which return member data related info
522//----------------------------------------------------------------------
30178c30 523Int_t AliMUONTriggerCircuit::GetIdCircuit() const {
a9e2aefa 524// returns circuit Id
ecfa008b 525 return fIdCircuit;
a9e2aefa 526}
527//----------------------------------------------------------------------
30178c30 528Int_t AliMUONTriggerCircuit::GetIdModule() const {
a9e2aefa 529// returns module Id
ecfa008b 530 return Module(fIdCircuit);
a9e2aefa 531}
532//----------------------------------------------------------------------
30178c30 533Int_t AliMUONTriggerCircuit::GetNstripX() const {
a9e2aefa 534// returns the number of X strips in the module where the circuit is sitting
ecfa008b 535 return AliMUONTriggerConstants::NstripX(ModuleNumber(Module(fIdCircuit)));
a9e2aefa 536}
537//----------------------------------------------------------------------
30178c30 538Int_t AliMUONTriggerCircuit::GetNstripY() const {
a9e2aefa 539// returns the number of Y strips in the module where the circuit is sitting
ecfa008b 540 return AliMUONTriggerConstants::NstripY(ModuleNumber(Module(fIdCircuit)));
a9e2aefa 541}
542//----------------------------------------------------------------------
30178c30 543Int_t AliMUONTriggerCircuit::GetPosCircuit() const {
a9e2aefa 544// returns the position of the circuit in its module
ecfa008b 545 return Position(fIdCircuit);
a9e2aefa 546}
547//----------------------------------------------------------------------
30178c30 548Int_t AliMUONTriggerCircuit::GetIdCircuitD() const {
a9e2aefa 549// returns the Id of the circuit down
ecfa008b 550 Int_t idModule=Module(fIdCircuit);
a9e2aefa 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//----------------------------------------------------------------------
30178c30 555Int_t AliMUONTriggerCircuit::GetICircuitD() const {
a9e2aefa 556// returns the number of the circuit down
ecfa008b 557 Int_t idModule=Module(fIdCircuit);
a9e2aefa 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//----------------------------------------------------------------------
30178c30 564Int_t AliMUONTriggerCircuit::GetIdCircuitU() const {
a9e2aefa 565// returns the Id of the circuit up
ecfa008b 566 Int_t idModule=Module(fIdCircuit);
a9e2aefa 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//----------------------------------------------------------------------
30178c30 571Int_t AliMUONTriggerCircuit::GetICircuitU() const {
a9e2aefa 572// returns the number of the circuit up
ecfa008b 573 Int_t idModule=Module(fIdCircuit);
a9e2aefa 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//----------------------------------------------------------------------
30178c30 580Int_t AliMUONTriggerCircuit::GetX2m() const {
ecfa008b 581// returns fX2m
582 return fX2m;
a9e2aefa 583}
584//----------------------------------------------------------------------
30178c30 585Int_t AliMUONTriggerCircuit::GetX2ud() const {
ecfa008b 586// returns fX2ud
587 return fX2ud;
a9e2aefa 588}
589//----------------------------------------------------------------------
30178c30 590void AliMUONTriggerCircuit::GetOrMud(Int_t orMud[2]) const {
a9e2aefa 591// returns fOrMud
592 orMud[0]=fOrMud[0];
593 orMud[1]=fOrMud[1];
594}
595//----------------------------------------------------------------------
30178c30 596Int_t AliMUONTriggerCircuit::GetXcode(Int_t chamber, Int_t istrip) const {
a9e2aefa 597// returns X code of circuit/chamber/istrip (warning : chamber in [0,3])
598 return fXcode[chamber][istrip];
599}
600//----------------------------------------------------------------------
30178c30 601Int_t AliMUONTriggerCircuit::GetYcode(Int_t chamber, Int_t istrip) const {
a9e2aefa 602// returns Y code of circuit/chamber/istrip (warning : chamber in [0,3])
603 return fYcode[chamber][istrip];
604}
605//----------------------------------------------------------------------
30178c30 606Float_t AliMUONTriggerCircuit::GetY11Pos(Int_t istrip) const {
a9e2aefa 607// returns Y position of X strip istrip in MC11
608 return fYpos11[istrip];
609}
610//----------------------------------------------------------------------
30178c30 611Float_t AliMUONTriggerCircuit::GetY21Pos(Int_t istrip) const {
a9e2aefa 612// returns Y position of X strip istrip in MC21
613 return fYpos21[istrip];
614}
615//----------------------------------------------------------------------
30178c30 616Float_t AliMUONTriggerCircuit::GetX11Pos(Int_t istrip) const {
a9e2aefa 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
331dcacd 625Int_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}
a9e2aefa 632
633
634
635