MUON/AliMUONSegmentationSlat.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 /*
  17 $Log$
  18 Revision 1.10  2001/01/23 18:58:19  hristov
  19 Initialisation of some pointers
  20
  21 Revision 1.9  2001/01/17 20:53:40  hristov
  22 Destructors corrected to avoid memory leaks
  23
  24 Revision 1.8  2000/12/21 22:12:41  morsch
  25 Clean-up of coding rule violations,
  26
  27 Revision 1.7  2000/11/08 13:01:40  morsch
  28 Chamber half-planes of stations 3-5 at different z-positions.
  29
  30 Revision 1.6  2000/11/06 09:20:43  morsch
  31 AliMUON delegates part of BuildGeometry() to AliMUONSegmentation using the
  32 Draw() method. This avoids code and parameter replication.
  33
  34 Revision 1.5  2000/10/23 13:37:40  morsch
  35 Correct z-position of slat planes.
  36
  37 Revision 1.4  2000/10/22 16:55:43  morsch
  38 Use only x-symmetry in global to local transformations and delegation.
  39
  40 Revision 1.3  2000/10/18 11:42:06  morsch
  41 - AliMUONRawCluster contains z-position.
  42 - Some clean-up of useless print statements during initialisations.
  43
  44 Revision 1.2  2000/10/09 14:06:18  morsch
  45 Some type cast problems of type  (TMath::Sign((Float_t)1.,x)) corrected (P.H.)
  46
  47 Revision 1.1  2000/10/06 09:00:47  morsch
  48 Segmentation class for chambers built out of slats.
  49
  50 */
  51
  52 #include "AliMUONSegmentationSlat.h"
  53 #include "AliMUONSegmentationSlatModule.h"
  54 #include "AliMUON.h"
  55 #include "AliMUONChamber.h"
  56 #include "TArrayI.h"
  57 #include "TObjArray.h"
  58 #include "AliRun.h"
  59 #include <TMath.h>
  60 #include <TBRIK.h>
  61 #include <TNode.h>
  62 #include <TGeometry.h>
  63 #include <iostream.h>
  64
  65 //___________________________________________
  66 ClassImp(AliMUONSegmentationSlat)
  67
  68 AliMUONSegmentationSlat::AliMUONSegmentationSlat()
  69 {
  70 // Default constructor
  71 }
  72
  73 AliMUONSegmentationSlat::AliMUONSegmentationSlat(Int_t nsec)
  74 {
  75 // Non default constructor
  76     fSlats=0;
  77     fNDiv = new TArrayI(4);
  78     fChamber = 0;
  79     fCurrentSlat = 0;
  80 }
  81
  82 AliMUONSegmentationSlat::~AliMUONSegmentationSlat(){
  83   //PH Delete TObjArrays
  84   if (fSlats) {
  85     fSlats->Delete();
  86     delete fSlats;
  87   }
  88
  89   if (fNDiv) {
  90     delete fNDiv;
  91   }
  92
  93 }
  94
  95 void AliMUONSegmentationSlat::SetPadSize(Float_t p1, Float_t p2)
  96 {
  97 //  Sets the pad (strip) size
  98 //
  99     fDpx=p1;
 100     fDpy=p2;
 101 }
 102
 103 Float_t AliMUONSegmentationSlat::GetAnod(Float_t xhit) const
 104 {
 105 // Returns for a hit position xhit the position of the nearest anode wire
 106     Float_t wire= (xhit>0)? Int_t(xhit/fWireD)+0.5:Int_t(xhit/fWireD)-0.5;
 107     return fWireD*wire;
 108 }
 109
 110 Float_t AliMUONSegmentationSlat::Dpx(Int_t isec) const
 111 {
 112 //
 113 // Returns x-pad size for given sector isec
 114 // isec = 100*islat+iregion
 115 //
 116     Int_t islat, iregion;
 117     islat    = isec/100;
 118     iregion  = isec%100;
 119     return Slat(islat)->Dpx(iregion);
 120 }
 121
 122 Float_t AliMUONSegmentationSlat::Dpy(Int_t isec) const
 123 {
 124 //
 125 // Returns y-pad (strip)  size for given sector isec
 126    return fDpy;
 127 }
 128
 129 void AliMUONSegmentationSlat::SetPadDivision(Int_t ndiv[4])
 130 {
 131 //
 132 // Defines the pad size perp. to the anode wire (y) for different sectors.
 133 // Pad sizes are defined as integral fractions ndiv of a basis pad size
 134 // fDpx
 135 //
 136     for (Int_t i=0; i<4; i++) {
 137         (*fNDiv)[i]=ndiv[i];
 138     }
 139 }
 140
 141 void AliMUONSegmentationSlat::GlobalToLocal(
 142     Float_t x, Float_t y, Float_t z, Int_t &islat, Float_t &xlocal, Float_t &ylocal)
 143 {
 144 //
 145 // Perform local to global transformation for space coordinates
 146 //
 147     Float_t zlocal;
 148     Int_t i;
 149     Int_t index=-1;
 150 // Transform According to slat plane z-position: negative side is shifted down
 151 //                                                 positive side is shifted up
 152 // by half the overlap
 153     zlocal = z-fChamber->Z();
 154     zlocal = (x>0) ? zlocal-2.*fDz : zlocal+2.*fDz;
 155 //  Set the signs for the symmetry transformation and transform to first quadrant
 156     SetSymmetry(x);
 157     Float_t xabs=TMath::Abs(x);
 158
 159     Int_t ifirst = (zlocal < Float_t(0))? 0:1;
 160 //
 161 // Find slat number
 162     for (i=ifirst; i<fNSlats; i+=2) {
 163         index=i;
 164         if ((y >= fYPosition[i]) && (y < fYPosition[i]+fSlatY)) break;
 165     }
 166
 167 //
 168 // Transform to local coordinate system
 169
 170
 171     ylocal = y   -fYPosition[index];
 172     xlocal = xabs-fXPosition[index];
 173     islat  = index;
 174     if (i >= fNSlats) {islat = -1; x=-1; y = -1;}
 175 }
 176
 177 void AliMUONSegmentationSlat::GlobalToLocal(
 178     Int_t ix, Int_t iy, Int_t &islat, Int_t &ixlocal, Int_t &iylocal)
 179 {
 180 //
 181 // Perform global to local transformation for pad coordinates
 182 //
 183     Int_t iytemp = iy;
 184     Int_t index  =  0;
 185
 186     iylocal = iytemp;
 187
 188 //
 189 // Find slat number (index) and iylocal
 190     for (Int_t i=0; i<fNSlats; i++) {
 191         iytemp-=Slat(i)->Npy();
 192
 193
 194         if (iytemp <= 0) break;
 195         iylocal = iytemp;
 196         index=i+1;
 197     }
 198
 199     ixlocal=TMath::Abs(ix);
 200     islat=index;
 201 }
 202
 203 void AliMUONSegmentationSlat::
 204 LocalToGlobal(Int_t islat, Float_t  xlocal, Float_t  ylocal, Float_t  &x, Float_t  &y, Float_t &z)
 205 {
 206 // Transform from local to global space coordinates
 207 //
 208 // upper plane (y>0) even slat number is shifted down
 209 // upper plane (y>0)  odd slat number is shifted up
 210 // lower plane (y<0) even slat number is shifted up
 211 // lower plane (y<0)  odd slat number is shifted down
 212 //
 213
 214     x = (xlocal+fXPosition[islat])*fSym;
 215     y=(ylocal+fYPosition[islat]);
 216
 217     z = (TMath::Even(islat)) ?     -fDz : fDz ;
 218     z = (x>0)                ? z+2.*fDz : z-2.*fDz ;
 219
 220     z+=fChamber->Z();
 221 }
 222
 223
 224 void AliMUONSegmentationSlat::LocalToGlobal(
 225     Int_t islat, Int_t ixlocal, Int_t iylocal, Int_t &ix, Int_t &iy)
 226 {
 227 // Transform from local to global pad coordinates
 228 //
 229     Int_t i;
 230     iy=iylocal;
 231
 232 //
 233 // Find slat number (index) and iylocal
 234     for (i=0; i<islat; i++) iy+=Slat(islat)->Npy();
 235
 236     ix=ixlocal*fSym;
 237     iy=iy;
 238 }
 239
 240
 241 void AliMUONSegmentationSlat::SetSymmetry(Int_t   ix)
 242 {
 243 // Set set signs for symmetry transformation
 244     fSym=TMath::Sign(1,ix);
 245 }
 246
 247 void AliMUONSegmentationSlat::SetSymmetry(Float_t  x)
 248 {
 249 // Set set signs for symmetry transformation
 250     fSym=Int_t (TMath::Sign((Float_t)1.,x));
 251 }
 252
 253 void AliMUONSegmentationSlat::
 254 GetPadI(Float_t x, Float_t y, Float_t z, Int_t &ix, Int_t &iy)
 255 {
 256 // Returns pad coordinates for given set of space coordinates
 257
 258     Int_t islat, i;
 259     Float_t xlocal, ylocal;
 260
 261     GlobalToLocal(x,y,z,islat,xlocal,ylocal);
 262     if (islat == -1) {
 263         ix=0; iy=0; return;
 264     }
 265
 266     Slat(islat)->GetPadI(xlocal, ylocal, ix, iy);
 267     for (i=0; i<islat; i++) iy+=Slat(islat)->Npy();
 268
 269     ix=ix*Int_t(TMath::Sign((Float_t)1.,x));
 270 }
 271
 272
 273 void AliMUONSegmentationSlat::
 274 GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y, Float_t &z)
 275 {
 276 //  Returns real coordinates (x,y) for given pad coordinates (ix,iy)
 277 //
 278     Int_t islat, ixlocal, iylocal;
 279 //
 280 // Delegation of transforamtion to slat
 281     GlobalToLocal(ix,iy,islat,ixlocal,iylocal);
 282     Slat(islat)->GetPadC(ixlocal, iylocal, x, y);
 283 // Slat offset
 284     x+=fXPosition[islat];
 285     y+=fYPosition[islat];
 286
 287 // Symmetry transformation of half planes
 288     x=x*TMath::Sign(1,ix);
 289
 290 // z-position
 291     z = (TMath::Even(islat)) ?      -fDz : fDz ;
 292     z = (x>0)                ?  z+2.*fDz : z-2.*fDz ;
 293     z += fChamber->Z();
 294 }
 295
 296 Int_t AliMUONSegmentationSlat::ISector()
 297 {
 298 // Returns current sector during tracking
 299     Int_t iregion;
 300
 301     iregion =  fCurrentSlat->ISector();
 302     return 100*fSlatIndex+iregion;
 303 }
 304
 305 Int_t AliMUONSegmentationSlat::Sector(Int_t ix, Int_t iy)
 306 {
 307 // Returns sector for pad coordiantes (ix,iy)
 308     Int_t ixlocal, iylocal, iregion, islat;
 309
 310     GlobalToLocal(ix,iy,islat,ixlocal,iylocal);
 311
 312     iregion =  Slat(islat)->Sector(ixlocal, iylocal);
 313     return 100*islat+iregion;
 314 }
 315
 316
 317 void AliMUONSegmentationSlat::SetPad(Int_t ix, Int_t iy)
 318 {
 319     //
 320     // Sets virtual pad coordinates, needed for evaluating pad response
 321     // outside the tracking program
 322     Int_t islat, ixlocal, iylocal;
 323
 324     SetSymmetry(ix);
 325
 326     GlobalToLocal(ix,iy,islat,ixlocal,iylocal);
 327     fSlatIndex=islat;
 328     fCurrentSlat=Slat(islat);
 329     fCurrentSlat->SetPad(ixlocal, iylocal);
 330 }
 331
 332 void  AliMUONSegmentationSlat::SetHit(Float_t xhit, Float_t yhit, Float_t zhit)
 333 {   //
 334     // Sets current hit coordinates
 335
 336     Float_t xlocal, ylocal;
 337     Int_t islat;
 338
 339
 340
 341     GlobalToLocal(xhit,yhit,zhit,islat,xlocal,ylocal);
 342     fSlatIndex=islat;
 343     if (islat < 0) printf("\n SetHit: %d", islat);
 344
 345     fCurrentSlat=Slat(islat);
 346     fCurrentSlat->SetHit(xlocal, ylocal);
 347 }
 348
 349
 350 void AliMUONSegmentationSlat::
 351 FirstPad(Float_t xhit, Float_t yhit, Float_t zhit, Float_t dx, Float_t dy)
 352 {
 353 // Initialises iteration over pads for charge distribution algorithm
 354 //
 355
 356
 357
 358     Int_t islat;
 359     Float_t xlocal, ylocal;
 360     GlobalToLocal(xhit, yhit, zhit, islat, xlocal, ylocal);
 361     fSlatIndex=islat;
 362     fCurrentSlat=Slat(islat);
 363     fCurrentSlat->FirstPad(xlocal, ylocal, dx, dy);
 364
 365 }
 366
 367
 368 void AliMUONSegmentationSlat::NextPad()
 369 {
 370 // Stepper for the iteration over pads
 371 //
 372     fCurrentSlat->NextPad();
 373 }
 374
 375
 376 Int_t AliMUONSegmentationSlat::MorePads()
 377 // Stopping condition for the iterator over pads
 378 //
 379 // Are there more pads in the integration region
 380 {
 381     return fCurrentSlat->MorePads();
 382 }
 383
 384 void AliMUONSegmentationSlat::
 385 IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
 386 {
 387 //  Returns integration limits for current pad
 388 //
 389
 390     fCurrentSlat->IntegrationLimits(x1, x2, y1, y2);
 391
 392 }
 393
 394 void AliMUONSegmentationSlat::
 395 Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
 396 {
 397 // Returns list of neighbours of pad with coordinates iX, iY
 398
 399     Int_t i, xListLocal[10], yListLocal[10], iXlocal, iYlocal, islat;
 400
 401     SetSymmetry(iX);
 402
 403     GlobalToLocal(iX, iY, islat, iXlocal, iYlocal);
 404
 405     Slat(islat)->Neighbours(iXlocal, iYlocal, Nlist, xListLocal, yListLocal);
 406
 407     for (i=0; i<*Nlist; i++) LocalToGlobal(islat, xListLocal[i], yListLocal[i], Xlist[i], Ylist[i]);
 408
 409 }
 410
 411
 412 Int_t  AliMUONSegmentationSlat::Ix()
 413 {
 414 // Return current pad coordinate ix during stepping
 415     Int_t ixl,iyl,ix,iy;
 416     ixl=fCurrentSlat->Ix();
 417     iyl=fCurrentSlat->Iy();
 418
 419     LocalToGlobal(fSlatIndex, ixl, iyl, ix, iy);
 420     Int_t ixc, iyc, isc;
 421     Float_t xc, yc;
 422     GlobalToLocal(ix, iy, isc, ixc, iyc);
 423     Slat(isc)->GetPadC(ixc,iyc,xc,yc);
 424     return ix;
 425 }
 426
 427
 428 Int_t  AliMUONSegmentationSlat::Iy()
 429 {
 430 // Return current pad coordinate iy during stepping
 431     Int_t ixl,iyl,ix,iy;
 432     ixl=fCurrentSlat->Ix();
 433     iyl=fCurrentSlat->Iy();
 434     LocalToGlobal(fSlatIndex, ixl, iyl, ix, iy);
 435     return iy;
 436 }
 437
 438
 439
 440    // Signal Generation Condition during Stepping
 441 Int_t AliMUONSegmentationSlat::SigGenCond(Float_t x, Float_t y, Float_t z)
 442 {
 443 //
 444 //  True if signal generation condition fullfilled
 445     Float_t xlocal, ylocal;
 446     Int_t islat;
 447     GlobalToLocal(x, y, z, islat, xlocal, ylocal);
 448     return Slat(islat)->SigGenCond(xlocal, ylocal, z);
 449 }
 450
 451 // Initialise signal generation at coord (x,y,z)
 452 void  AliMUONSegmentationSlat::SigGenInit(Float_t x, Float_t y, Float_t z)
 453 {
 454 // Initialize the signal generation condition
 455 //
 456     Float_t xlocal, ylocal;
 457     Int_t islat;
 458
 459     GlobalToLocal(x, y, z, islat, xlocal, ylocal);
 460     Slat(islat)->SigGenInit(xlocal, ylocal, z);
 461 }
 462
 463
 464
 465 void AliMUONSegmentationSlat::Init(Int_t chamber)
 466 {
 467 //
 468 // Initialize slat modules of quadrant +/+
 469 // The other three quadrants are handled through symmetry transformations
 470 //
 471     printf("\n Initialise Segmentation Slat \n");
 472 //
 473
 474 // Initialize Slat modules
 475     Int_t islat, i;
 476     Int_t ndiv[4];
 477 // Pad division
 478     for (i=0; i<4; i++) ndiv[i]=(*fNDiv)[i];
 479 //
 480     fDz=0.813;
 481 // Slat height
 482     fSlatY=40.;
 483     for (i=0; i<15; i++) fSlatX[i]=0.;
 484
 485 // Initialize array of slats
 486     fSlats  = new TObjArray(fNSlats);
 487 // Maximum number of strips (pads) in x and y
 488     fNpy=0;
 489     fNpx=0;
 490 // for each slat in the quadrant (+,+)
 491     for (islat=0; islat<fNSlats; islat++) {
 492         (*fSlats)[islat] = CreateSlatModule();
 493
 494         AliMUONSegmentationSlatModule *slat =  Slat(islat);
 495         // Configure Slat
 496         slat->SetId(islat);
 497
 498 // Foward pad size
 499         slat->SetPadSize(fDpx, fDpy);
 500 // Forward wire pitch
 501         slat->SetDAnod(fWireD);
 502 // Foward segmentation
 503         slat->SetPadDivision(ndiv);
 504         slat->SetPcbBoards(fPcb[islat]);
 505 // Initialize slat module
 506         slat->Init(chamber);
 507 // y-position of slat module relative to the first (closest to the beam)
 508         fYPosition[islat]= fYPosOrigin+islat*(fSlatY-2.*fShift);
 509 //
 510         fNpy+=slat->Npy();
 511         if (slat->Npx() > fNpx) fNpx=slat->Npx();
 512         Int_t isec;
 513         for (isec=0; isec< 4; isec++)
 514         {
 515             fSlatX[islat]+=40.*fPcb[islat][isec];
 516         }
 517
 518     }
 519 // Set parent chamber number
 520     AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
 521     fChamber=&(pMUON->Chamber(chamber));
 522     fId=chamber;
 523 }
 524
 525
 526
 527
 528
 529 void AliMUONSegmentationSlat::SetNPCBperSector(Int_t *npcb)
 530 {
 531     //  PCB distribution for station 4 (6 rows with 1+3 segmentation regions)
 532     for (Int_t islat=0; islat<fNSlats; islat++){
 533         fPcb[islat][0] = *(npcb + 4 * islat);
 534         fPcb[islat][1] = *(npcb + 4 * islat + 1);
 535         fPcb[islat][2] = *(npcb + 4 * islat + 2);
 536         fPcb[islat][3] = *(npcb + 4 * islat + 3);
 537     }
 538 }
 539
 540
 541 void  AliMUONSegmentationSlat::SetSlatXPositions(Float_t *xpos)
 542 {
 543 // Set x-positions of Slats
 544     for (Int_t islat=0; islat<fNSlats; islat++) fXPosition[islat]=xpos[islat];
 545 }
 546
 547 AliMUONSegmentationSlatModule*  AliMUONSegmentationSlat::Slat(Int_t index) const
 548 { return ((AliMUONSegmentationSlatModule*) (*fSlats)[index]);}
 549
 550
 551 AliMUONSegmentationSlatModule* AliMUONSegmentationSlat::
 552 CreateSlatModule()
 553 {
 554     // Factory method for slat module
 555     return new AliMUONSegmentationSlatModule(4);
 556 }
 557
 558
 559 void AliMUONSegmentationSlat::Draw(const char* opt) const
 560 {
 561 // Draw method for event display
 562 //
 563   if (!strcmp(opt,"eventdisplay")) {
 564     const int kColorMUON1 = kYellow;
 565     const int kColorMUON2 = kBlue;
 566     //
 567     //  Drawing Routines for example for Event Display
 568     Int_t i,j;
 569     Int_t npcb[15];
 570     char nameChamber[9], nameSlat[9], nameNode[9];
 571
 572     //
 573     // Number of modules per slat
 574     for (i=0; i<fNSlats; i++) {
 575       npcb[i]=0;
 576       for (j=0; j<4; j++) npcb[i]+=fPcb[i][j];
 577     }
 578     //
 579     TNode* top=gAlice->GetGeometry()->GetNode("alice");
 580     sprintf(nameChamber,"C_MUON%d",fId+1);
 581     new TBRIK(nameChamber,"Mother","void",340,340,5.);
 582     top->cd();
 583     sprintf(nameNode,"MUON%d",100+fId+1);
 584     TNode* node = new TNode(nameNode,"Chambernode",nameChamber,0,0,fChamber->Z(),"");
 585
 586     node->SetLineColor(kBlack);
 587     AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
 588     (pMUON->Nodes())->Add(node);
 589     TNode* nodeSlat;
 590     Int_t color;
 591
 592     for (j=0; j<fNSlats; j++)
 593       {
 594         sprintf(nameSlat,"SLAT%d",100*fId+1+j);
 595         Float_t dx = 20.*npcb[j];
 596         Float_t dy = 20;
 597         new TBRIK(nameSlat,"Slat Module","void",dx,20.,0.25);
 598         node->cd();
 599         color =  TMath::Even(j) ? kColorMUON1 : kColorMUON2;
 600
 601         sprintf(nameNode,"SLAT%d",100*fId+1+j);
 602         nodeSlat =
 603           new TNode(nameNode,"Slat Module",nameSlat, dx+fXPosition[j],fYPosition[j]+dy,0,"");
 604         nodeSlat->SetLineColor(color);
 605         node->cd();
 606         sprintf(nameNode,"SLAT%d",100*fId+1+j+fNSlats);
 607         nodeSlat =
 608           new TNode(nameNode,"Slat Module",nameSlat,-dx-fXPosition[j],fYPosition[j]+dy,0,"");
 609         nodeSlat->SetLineColor(color);
 610       }
 611   }
 612 }
 613
 614
 615