* provided "as is" without express or implied warranty. *
**************************************************************************/
/*
+$Log$
+Revision 1.6 2000/07/13 16:19:44 fca
+Mainly coding conventions + some small bug fixes
+Revision 1.5 2000/07/03 11:54:57 morsch
+AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
+The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.
+
+Revision 1.4 2000/06/28 15:16:35 morsch
+(1) Client code adapted to new method signatures in AliMUONSegmentation (see comments there)
+to allow development of slat-muon chamber simulation and reconstruction code in the MUON
+framework. The changes should have no side effects (mostly dummy arguments).
+(2) Hit disintegration uses 3-dim hit coordinates to allow simulation
+of chambers with overlapping modules (MakePadHits, Disintegration).
+
+Revision 1.3 2000/06/26 10:04:49 pcrochet
+problem with HP compiler solved (PH), static variables removed : now defined in AliMUONTriggerConstants
*/
+
#include "AliRun.h"
#include "AliMUON.h"
#include "AliMUONPoints.h"
#include "AliMUONTriggerCircuit.h"
-#include "AliMUONSegmentation.h"
+#include "AliMUONTriggerConstants.h"
+#include "AliSegmentation.h"
#include "AliMUONResponse.h"
#include "AliMUONChamber.h"
#include "TMath.h"
ClassImp(AliMUONTriggerCircuit)
-static Int_t circuitId[234]=
-{111, 121, 131, 141, 151, 161, 171,
- 211, 212, 221, 222, 231, 232, 241, 242, 251, 252, 261, 262, 271,
- 311, 312, 321, 322, 331, 332, 341, 342, 351, 352, 361, 362, 371,
- 411, 412, 413, 421, 422, 423, 424, 431, 432, 433, 434, 441, 442,
- 451, 452, 461, 462, 471,
- 521, 522, 523, 524, 531, 532, 533, 534, 541, 542, 551, 552, 561, 562, 571,
- 611, 612, 613, 621, 622, 623, 624, 631, 632, 633, 634, 641, 642,
- 651, 652, 661, 662, 671,
- 711, 712, 721, 722, 731, 732, 741, 742, 751, 752, 761, 762, 771,
- 811, 812, 821, 822, 831, 832, 841, 842, 851, 852, 861, 862, 871,
- 911, 921, 931, 941, 951, 961, 971,
- -111, -121, -131, -141, -151, -161, -171,
- -211, -212, -221, -222, -231, -232, -241, -242, -251, -252, -261, -262, -271,
- -311, -312, -321, -322, -331, -332, -341, -342, -351, -352, -361, -362, -371,
- -411, -412, -413, -421, -422, -423, -424, -431, -432, -433, -434, -441, -442,
- -451, -452, -461, -462, -471,
- -521, -522, -523, -524, -531, -532, -533, -534, -541, -542, -551, -552, -561, -562, -571,
- -611, -612, -613, -621, -622, -623, -624, -631, -632, -633, -634, -641, -642,
- -651, -652, -661, -662, -671,
- -711, -712, -721, -722, -731, -732, -741, -742, -751, -752, -761, -762, -771,
- -811, -812, -821, -822, -831, -832, -841, -842, -851, -852, -861, -862, -871,
- -911, -921, -931, -941, -951, -961, -971};
-
-static Int_t moduleId[63]=
-{11,12,13,14,15,16,17,
- 21,22,23,24,25,26,27,
- 31,32,33,34,35,36,37,
- 41,42,43,44,45,46,47,
- 51,52,53,54,55,56,57,
- 61,62,63,64,65,66,67,
- 71,72,73,74,75,76,77,
- 81,82,83,84,85,86,87,
- 91,92,93,94,95,96,97};
-
-static Int_t nStripX[63]=
-{16,16,16,16,16,16,16,
- 32,32,32,32,32,32,16,
- 32,32,32,32,32,32,16,
- 48,64,64,32,32,32,16,
- 0,64,64,32,32,32,16,
- 48,64,64,32,32,32,16,
- 32,32,32,32,32,32,16,
- 32,32,32,32,32,32,16,
- 16,16,16,16,16,16,16};
-
-static Int_t nStripY[63]=
-{8,8,8,8,8,8,16,
- 8,8,8,8,8,8,16,
- 16,16,16,16,16,8,16,
- 16,16,16,16,16,8,16,
- 0,8,16,16,16,8,16,
- 16,16,16,16,16,8,16,
- 16,16,16,16,16,8,16,
- 8,8,8,8,8,8,16,
- 8,8,8,8,8,8,16};
-
//----------------------------------------------------------------------
AliMUONTriggerCircuit::AliMUONTriggerCircuit()
{
// Constructor
- fidCircuit=0;
- fx2m=0;
- fx2ud=0;
+ fSegmentation=0;
+ fIdCircuit=0;
+ fX2m=0;
+ fX2ud=0;
fOrMud[0]=fOrMud[1]=0;
- for (Int_t i=0; i<4; i++) {
+ Int_t i;
+ for (i=0; i<4; i++) {
for (Int_t j=0; j<32; j++) {
fXcode[i][j]=0;
fYcode[i][j]=0;
}
}
- for (Int_t i=0; i<16; i++) { fXpos11[i]=0.; }
- for (Int_t i=0; i<31; i++) { fYpos11[i]=0.; }
- for (Int_t i=0; i<63; i++) { fYpos21[i]=0.; }
+ for (i=0; i<16; i++) { fXpos11[i]=0.; }
+ for (i=0; i<31; i++) { fYpos11[i]=0.; }
+ for (i=0; i<63; i++) { fYpos21[i]=0.; }
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
void AliMUONTriggerCircuit::Init(Int_t iCircuit) {
// initialize circuit characteristics
- fidCircuit=circuitId[iCircuit];
+ fIdCircuit=AliMUONTriggerConstants::CircuitId(iCircuit);
LoadX2();
LoadXCode();
LoadYCode();
// returns circuit number iCircuit (0-234) corresponding to circuit idCircuit
Int_t iCircuit=0;
for (Int_t i=0; i<234; i++) {
- if (circuitId[i]==idCircuit) {
+ if (AliMUONTriggerConstants::CircuitId(i)==idCircuit) {
iCircuit=i;
break;
}
Int_t absidModule=TMath::Abs(idModule);
Int_t iModule=0;
for (Int_t i=0; i<63; i++) {
- if (moduleId[i]==absidModule) {
+ if (AliMUONTriggerConstants::ModuleId(i)==absidModule) {
iModule=i;
break;
}
//----------------------------------------------------------------------
void AliMUONTriggerCircuit::LoadX2() {
-// initialize fx2m, fx2ud and fOrMud
+// initialize fX2m, fX2ud and fOrMud
- Int_t idModule=Module(fidCircuit); // corresponding module Id.
- Int_t nStrX=nStripX[ModuleNumber(idModule)]; // and its number of X strips
- Int_t nStrY=nStripY[ModuleNumber(idModule)]; // and its number of Y strips
- Int_t iPosCircuit=Position(fidCircuit); // position of circuit in module
+ Int_t idModule=Module(fIdCircuit); // corresponding module Id.
+// and its number of X strips
+ Int_t nStrX=AliMUONTriggerConstants::NstripX(ModuleNumber(idModule));
+// and its number of Y strips
+ Int_t nStrY=AliMUONTriggerConstants::NstripY(ModuleNumber(idModule));
+ Int_t iPosCircuit=Position(fIdCircuit); // position of circuit in module
// first step : look at lower part
if (iPosCircuit==1) { // need to scan lower module
if(idModule<91&&TMath::Abs(idModule)!=41&&idModule>-91) {
fOrMud[0]=1;
Int_t idModuleD=(TMath::Abs(idModule)+10)*(TMath::Abs(idModule)/idModule);
- Int_t nStrD=nStripY[ModuleNumber(idModuleD)];
+ Int_t nStrD=AliMUONTriggerConstants::NstripY(ModuleNumber(idModuleD));
if (nStrY!=nStrD
&&TMath::Abs(idModule)!=42&&TMath::Abs(idModule)!=52) {
- if (nStrY==8) fx2m=1;
- if (nStrD==8) fx2ud=1;
+ if (nStrY==8) fX2m=1;
+ if (nStrD==8) fX2ud=1;
}
}
if ((idModule>17||idModule<-17)&&TMath::Abs(idModule)!=61) {
fOrMud[1]=1;
Int_t idModuleU=(TMath::Abs(idModule)-10)*(TMath::Abs(idModule)/idModule);
- Int_t nStrU=nStripY[ModuleNumber(idModuleU)];
+ Int_t nStrU=AliMUONTriggerConstants::NstripY(ModuleNumber(idModuleU));
if (nStrY!=nStrU
&&TMath::Abs(idModule)!=62&&TMath::Abs(idModule)!=52) {
- if (nStrY==8) fx2m=1;
- if (nStrU==8) fx2ud=1;
+ if (nStrY==8) fX2m=1;
+ if (nStrU==8) fX2ud=1;
}
}
// first part : fill XMC11 XMC12 and strips 8 to 24 (middle) XMC21 XMC22
Int_t iStripCircMT1=0, iStripCircMT2=8;
- Int_t idModule=Module(fidCircuit); // corresponding module Id.
- Int_t nStrX=nStripX[ModuleNumber(idModule)]; // and its number of strips
- Int_t iPosCircuit=Position(fidCircuit); // position of circuit in module
+ Int_t idModule=Module(fIdCircuit); // corresponding module Id.
+// and its number of strips
+ Int_t nStrX=AliMUONTriggerConstants::NstripX(ModuleNumber(idModule));
+ Int_t iPosCircuit=Position(fIdCircuit); // position of circuit in module
Int_t sign=TMath::Abs(idModule)/idModule; // left or right
+ Int_t istrip;
- for (Int_t istrip=(iPosCircuit-1)*16;
+ for (istrip=(iPosCircuit-1)*16;
istrip<(iPosCircuit-1)*16+16; istrip++) {
fXcode[0][iStripCircMT1]=sign*(TMath::Abs(idModule)*100+istrip);
Int_t idModuleD, idModuleU;
Int_t nStrD, nStrU;
- idModule=Module(fidCircuit); // corresponding module Id.
- nStrX=nStripX[ModuleNumber(idModule)]; // number of X strips
+ idModule=Module(fIdCircuit); // corresponding module Id.
+// number of X strips
+ nStrX=AliMUONTriggerConstants::NstripX(ModuleNumber(idModule));
sign=TMath::Abs(idModule)/idModule;
// fill lower part (0 to 7)
if (iPosCircuit==1) { // need to scan lower module
if(idModule<91&&TMath::Abs(idModule)!=41&&idModule>-91) { // non-existing
idModuleD=sign*(TMath::Abs(idModule)+10); // lower module Id
- nStrD=nStripX[ModuleNumber(idModuleD)]; // and its number of strips
+// and its number of strips
+ nStrD=AliMUONTriggerConstants::NstripX(ModuleNumber(idModuleD));
iStripCircMT2=0;
- for (Int_t istrip=nStrD-8; istrip<nStrD; istrip++) {
+ for (istrip=nStrD-8; istrip<nStrD; istrip++) {
fXcode[2][iStripCircMT2]=sign*(TMath::Abs(idModuleD)*100+istrip);
fXcode[3][iStripCircMT2]=sign*(TMath::Abs(idModuleD)*100+istrip);
iStripCircMT2++;
} else { // lower strips within same module
iStripCircMT2=0;
- for (Int_t istrip=(iPosCircuit-1)*16-8;
+ for (istrip=(iPosCircuit-1)*16-8;
istrip<(iPosCircuit-1)*16; istrip++) {
fXcode[2][iStripCircMT2]=sign*(TMath::Abs(idModule)*100+istrip);
fXcode[3][iStripCircMT2]=sign*(TMath::Abs(idModule)*100+istrip);
(iPosCircuit==3&&nStrX==48)||(iPosCircuit==4&&nStrX==64)) {
if ((idModule>17||idModule<-17)&&TMath::Abs(idModule)!=61) {
idModuleU=sign*(TMath::Abs(idModule)-10); // upper module Id
- nStrU=nStripX[ModuleNumber(idModuleU)]; // and its number of strips
+// and its number of strips
+ nStrU=AliMUONTriggerConstants::NstripX(ModuleNumber(idModuleU));
iStripCircMT2=24;
- for (Int_t istrip=0; istrip<8; istrip++) {
+ for (istrip=0; istrip<8; istrip++) {
fXcode[2][iStripCircMT2]=sign*(TMath::Abs(idModuleU)*100+istrip);
fXcode[3][iStripCircMT2]=sign*(TMath::Abs(idModuleU)*100+istrip);
iStripCircMT2++;
(iPosCircuit==3&&nStrX>48)) { // upper strips within same mod.
iStripCircMT2=24;
- for (Int_t istrip=(iPosCircuit-1)*16+16;
+ for (istrip=(iPosCircuit-1)*16+16;
istrip<(iPosCircuit-1)*16+24; istrip++) {
fXcode[2][iStripCircMT2]=sign*(TMath::Abs(idModule)*100+istrip);
fXcode[3][iStripCircMT2]=sign*(TMath::Abs(idModule)*100+istrip);
// note : for Y plane fill only "central part" of circuit
// (upper and lower parts are filled in PreHandlingY of AliMUONTriggerDecision)
- Int_t idModule=Module(fidCircuit); // corresponding module Id.
- Int_t nStrY=nStripY[ModuleNumber(idModule)]; // its number of Y strips
+ Int_t idModule=Module(fIdCircuit); // corresponding module Id.
+// and its number of Y strips
+ Int_t nStrY=AliMUONTriggerConstants::NstripY(ModuleNumber(idModule));
Int_t sign=TMath::Abs(idModule)/idModule; // left or right
for (Int_t istrip=0; istrip<nStrY; istrip++) {
Int_t chamber, cathode;
Int_t code, idModule, idStrip, idSector;
- Float_t x, y, width;
+ Float_t x, y, z, width;
+ Int_t istrip;
AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
AliMUONChamber* iChamber;
- AliMUONSegmentation* segmentation;
+ AliSegmentation* segmentation;
// first plane (11)
chamber=11;
iChamber = &(pMUON->Chamber(chamber-1));
segmentation=iChamber->SegmentationModel(cathode);
- for (Int_t istrip=0; istrip<16; istrip++) {
+ for (istrip=0; istrip<16; istrip++) {
code=fXcode[0][istrip]; // decode current strip
idModule=Int_t(code/100); // corresponding module Id.
idStrip=TMath::Abs(code-idModule*100); // corresp. strip number in module
idSector=segmentation->Sector(idModule,idStrip); // corresponding sector
width=segmentation->Dpy(idSector); // corresponding strip width
- segmentation->GetPadCxy(idModule,idStrip,x,y); // get strip real position
+ segmentation->GetPadC(idModule,idStrip,x,y,z); // get strip real position
fYpos11[2*istrip]=y;
if (istrip!=15) fYpos11[2*istrip+1]=y+width/2.;
iChamber = &(pMUON->Chamber(chamber-1));
segmentation=iChamber->SegmentationModel(cathode);
- for (Int_t istrip=0; istrip<32; istrip++) {
+ for (istrip=0; istrip<32; istrip++) {
code=fXcode[2][istrip]; // decode current strip
idModule=Int_t(code/100); // corresponding module Id.
idStrip=TMath::Abs(code-idModule*100); // corresp. strip number in module
idSector=segmentation->Sector(idModule,idStrip); // corresponding sector
width=segmentation->Dpy(idSector); // corresponding strip width
- segmentation->GetPadCxy(idModule,idStrip,x,y); // get strip real position
+ segmentation->GetPadC(idModule,idStrip,x,y,z); // get strip real position
// using idModule!=0 prevents to fill garbage in case of circuits
// in the first and last rows
// taking into account whether or nor not part(s) of the circuit
// (middle, up or down) has(have) 16 strips
- Float_t x, y;
+ Float_t x, y, z;
+ Int_t istrip;
Int_t chamber=11;
Int_t cathode=2;
AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
AliMUONChamber* iChamber;
- AliMUONSegmentation* segmentation;
+ AliSegmentation* segmentation;
iChamber = &(pMUON->Chamber(chamber-1));
segmentation=iChamber->SegmentationModel(cathode);
- Int_t idModule=Module(fidCircuit); // corresponding module Id.
- Int_t nStrY=nStripY[ModuleNumber(idModule)]; // number of Y strips
+ Int_t idModule=Module(fIdCircuit); // corresponding module Id.
+// number of Y strips
+ Int_t nStrY=AliMUONTriggerConstants::NstripY(ModuleNumber(idModule));
Int_t idSector=segmentation->Sector(idModule,0); // corresp. sector
Float_t width=segmentation->Dpx(idSector); // corresponding strip width
// first case : up middle and down parts have all 8 or 16 strip
- if ((nStrY==16)||(nStrY==8&&fx2m==0&&fx2ud==0)) {
- for (Int_t istrip=0; istrip<nStrY; istrip++) {
- segmentation->GetPadCxy(idModule,istrip,x,y);
+ if ((nStrY==16)||(nStrY==8&&fX2m==0&&fX2ud==0)) {
+ for (istrip=0; istrip<nStrY; istrip++) {
+ segmentation->GetPadC(idModule,istrip,x,y,z);
fXpos11[istrip]=x;
}
// second case : mixing 8 and 16 strips within same circuit
} else {
- for (Int_t istrip=0; istrip<nStrY; istrip++) {
+ for (istrip=0; istrip<nStrY; istrip++) {
if (nStrY!=8) { cout << " bug in LoadXpos " << "\n";}
- segmentation->GetPadCxy(idModule,istrip,x,y);
+ segmentation->GetPadC(idModule,istrip,x,y,z);
fXpos11[2*istrip]=x-width/4.;
fXpos11[2*istrip+1]=fXpos11[2*istrip]+width/2.;
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetIdCircuit(){
// returns circuit Id
- return fidCircuit;
+ return fIdCircuit;
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetIdModule(){
// returns module Id
- return Module(fidCircuit);
+ return Module(fIdCircuit);
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetNstripX() {
// returns the number of X strips in the module where the circuit is sitting
- return nStripX[ModuleNumber(Module(fidCircuit))];
+ return AliMUONTriggerConstants::NstripX(ModuleNumber(Module(fIdCircuit)));
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetNstripY() {
// returns the number of Y strips in the module where the circuit is sitting
- return nStripY[ModuleNumber(Module(fidCircuit))];
+ return AliMUONTriggerConstants::NstripY(ModuleNumber(Module(fIdCircuit)));
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetPosCircuit() {
// returns the position of the circuit in its module
- return Position(fidCircuit);
+ return Position(fIdCircuit);
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetIdCircuitD(){
// returns the Id of the circuit down
- Int_t idModule=Module(fidCircuit);
+ Int_t idModule=Module(fIdCircuit);
Int_t idModuleD=(TMath::Abs(idModule)+10)*(TMath::Abs(idModule)/idModule);
return (TMath::Abs(idModuleD)*10+1)*(TMath::Abs(idModule)/idModule);
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetICircuitD(){
// returns the number of the circuit down
- Int_t idModule=Module(fidCircuit);
+ Int_t idModule=Module(fIdCircuit);
Int_t idModuleD=(TMath::Abs(idModule)+10)*(TMath::Abs(idModule)/idModule);
Int_t idCircuitD=
(TMath::Abs(idModuleD)*10+1)*(TMath::Abs(idModule)/idModule);
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetIdCircuitU(){
// returns the Id of the circuit up
- Int_t idModule=Module(fidCircuit);
+ Int_t idModule=Module(fIdCircuit);
Int_t idModuleU=(TMath::Abs(idModule)-10)*(TMath::Abs(idModule)/idModule);
return (TMath::Abs(idModuleU)*10+1)*(TMath::Abs(idModule)/idModule);
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetICircuitU(){
// returns the number of the circuit up
- Int_t idModule=Module(fidCircuit);
+ Int_t idModule=Module(fIdCircuit);
Int_t idModuleU=(TMath::Abs(idModule)-10)*(TMath::Abs(idModule)/idModule);
Int_t idCircuitU=
(TMath::Abs(idModuleU)*10+1)*(TMath::Abs(idModule)/idModule);
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetX2m(){
-// returns fx2m
- return fx2m;
+// returns fX2m
+ return fX2m;
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetX2ud(){
-// returns fx2ud
- return fx2ud;
+// returns fX2ud
+ return fX2ud;
}
//----------------------------------------------------------------------
void AliMUONTriggerCircuit::GetOrMud(Int_t orMud[2]){
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff