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