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