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