MUON/AliMUONSegmentationV01.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.21  2001/08/30 09:52:12  hristov
  19 The operator[] is replaced by At() or AddAt() in case of TObjArray.
  20
  21 Revision 1.20  2001/07/20 10:03:14  morsch
  22 Changes needed to work with Root 3.01 (substitute lhs [] operator). (Jiri Chudoba)
  23
  24 Revision 1.19  2001/05/16 14:57:17  alibrary
  25 New files for folders and Stack
  26
  27 Revision 1.18  2001/04/11 12:33:56  morsch
  28 Bug in GetPadC in case of staggered planes corrected. (Thanks to J.P. Cussonneau)
  29
  30 Revision 1.17  2001/01/30 12:17:04  morsch
  31 Remove obolete print-statement.
  32
  33 Revision 1.16  2001/01/30 09:23:14  hristov
  34 Streamers removed (R.Brun)
  35
  36 Revision 1.15  2001/01/26 21:25:48  morsch
  37 Empty default constructors and.
  38
  39 Revision 1.14  2000/12/21 22:12:41  morsch
  40 Clean-up of coding rule violations,
  41
  42 Revision 1.13  2000/12/07 10:41:51  hristov
  43 fCorr replaced by fCorrA
  44
  45 Revision 1.12  2000/12/06 11:55:41  morsch
  46 Introduce  SetOffsetY(Float_t off) method as simplified simulation of pad staggering.
  47 fOffset is the staggering offset in y.
  48
  49 Revision 1.11  2000/11/06 09:20:43  morsch
  50 AliMUON delegates part of BuildGeometry() to AliMUONSegmentation using the
  51 Draw() method. This avoids code and parameter replication.
  52
  53 Revision 1.10  2000/10/18 11:42:06  morsch
  54 - AliMUONRawCluster contains z-position.
  55 - Some clean-up of useless print statements during initialisations.
  56
  57 Revision 1.9  2000/10/18 08:41:32  morsch
  58 Make NextPad() and MorePads() to iterate until the end.
  59
  60 Revision 1.8  2000/10/03 21:48:07  morsch
  61 Adopt to const declaration of some of the methods in AliSegmentation.
  62
  63 Revision 1.7  2000/10/02 21:28:09  fca
  64 Removal of useless dependecies via forward declarations
  65
  66 Revision 1.6  2000/10/02 16:58:29  egangler
  67 Cleaning of the code :
  68 -> coding conventions
  69 -> void Streamers
  70 -> some useless includes removed or replaced by "class" statement
  71
  72 Revision 1.5  2000/07/13 16:19:44  fca
  73 Mainly coding conventions + some small bug fixes
  74
  75 Revision 1.4  2000/07/03 11:54:57  morsch
  76 AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
  77 The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.
  78
  79 Revision 1.3  2000/06/29 12:34:09  morsch
  80 AliMUONSegmentation class has been made independent of AliMUONChamber. This makes
  81 it usable with any other geometry class. The link to the object to which it belongs is
  82 established via an index. This assumes that there exists a global geometry manager
  83 from which the pointer to the parent object can be obtained (in our case gAlice).
  84
  85 Revision 1.2  2000/06/15 07:58:48  morsch
  86 Code from MUON-dev joined
  87
  88 Revision 1.1.2.1  2000/06/09 21:37:30  morsch
  89 AliMUONSegmentationV01 code  from  AliMUONSegResV01.cxx
  90
  91 */
  92
  93
  94 /////////////////////////////////////////////////////
  95 //  Segmentation and Response classes version 01   //
  96 /////////////////////////////////////////////////////
  97
  98 #include <TBox.h>
  99 #include <TTUBE.h>
 100 #include <TBRIK.h>
 101 #include <TNode.h>
 102 #include <TGeometry.h>
 103 #include <TF1.h>
 104 #include <TObjArray.h>
 105 #include <Riostream.h>
 106
 107 #include "AliMUONSegmentationV01.h"
 108 #include "AliMUON.h"
 109 #include "AliMUONChamber.h"
 110 #include "AliRun.h"
 111
 112
 113
 114 //___________________________________________
 115 ClassImp(AliMUONSegmentationV01)
 116
 117 AliMUONSegmentationV01::AliMUONSegmentationV01(const AliMUONSegmentationV01& segmentation)
 118 {
 119 // Dummy copy constructor
 120 }
 121
 122 AliMUONSegmentationV01::AliMUONSegmentationV01()
 123 {
 124 // Default constructor
 125     fRSec = 0;
 126     fNDiv = 0;
 127     fDpxD = 0;
 128     fCorrA = 0;
 129 }
 130
 131 AliMUONSegmentationV01::AliMUONSegmentationV01(Int_t nsec)
 132 {
 133 //  Non default constructor
 134
 135     fNsec = nsec;
 136     fRSec = new TArrayF(fNsec);
 137     fNDiv = new TArrayI(fNsec);
 138     fDpxD = new TArrayF(fNsec);
 139
 140
 141     (*fRSec)[0]=(*fRSec)[1]=(*fRSec)[2]=(*fRSec)[3]=0;
 142     (*fNDiv)[0]=(*fNDiv)[1]=(*fNDiv)[2]=(*fNDiv)[3]=0;
 143     (*fDpxD)[0]=(*fDpxD)[1]=(*fDpxD)[2]=(*fDpxD)[3]=0;
 144     fCorrA = new TObjArray(3);
 145     fCorrA->AddAt(0,0);
 146     fCorrA->AddAt(0,1);
 147     fCorrA->AddAt(0,2);
 148     fOffsetY=0;
 149 }
 150
 151 AliMUONSegmentationV01::~AliMUONSegmentationV01()
 152 {
 153 // Destructor
 154     if (fRSec) delete fRSec;
 155     if (fNDiv) delete fNDiv;
 156     if (fDpxD) delete fDpxD;
 157     if (fCorrA) {
 158         fCorrA->Delete();
 159         delete fCorrA;
 160     }
 161 }
 162
 163
 164 Float_t AliMUONSegmentationV01::Dpx(Int_t isec) const
 165 {
 166 //
 167 // Returns x-pad size for given sector isec
 168    Float_t dpx = (*fDpxD)[isec];
 169    return dpx;
 170 }
 171
 172 Float_t AliMUONSegmentationV01::Dpy(Int_t isec) const
 173 {
 174 //
 175 // Returns y-pad size for given sector isec
 176    return fDpy;
 177 }
 178
 179 void   AliMUONSegmentationV01::SetSegRadii(Float_t  r[4])
 180 {
 181 //
 182 // Set the radii of the segmentation zones
 183     for (Int_t i=0; i<4; i++) {
 184         (*fRSec)[i]=r[i];
 185     }
 186 }
 187
 188
 189 void AliMUONSegmentationV01::SetPadDivision(Int_t ndiv[4])
 190 {
 191 //
 192 // Defines the pad size perp. to the anode wire (y) for different sectors.
 193 // Pad sizes are defined as integral fractions ndiv of a basis pad size
 194 // fDpx
 195 //
 196     for (Int_t i=0; i<4; i++) {
 197         (*fNDiv)[i]=ndiv[i];
 198     }
 199     ndiv[0]=ndiv[1];
 200 }
 201
 202
 203 void AliMUONSegmentationV01::Init(Int_t chamber)
 204 {
 205 //
 206 //  Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
 207 //  These arrays help in converting from real to pad co-ordinates and
 208 //  vice versa.
 209 //  This version approximates concentric segmentation zones
 210 //
 211     Int_t isec;
 212     //printf("\n Initialise Segmentation V01\n");
 213
 214
 215     fNpy=Int_t((*fRSec)[fNsec-1]/fDpy)+1;
 216
 217     (*fDpxD)[fNsec-1]=fDpx;
 218     if (fNsec > 1) {
 219         for (Int_t i=fNsec-2; i>=0; i--){
 220             (*fDpxD)[i]=(*fDpxD)[fNsec-1]/(*fNDiv)[i];
 221         }
 222     }
 223 //
 224 // fill the arrays defining the pad segmentation boundaries
 225     Float_t ry;
 226     Int_t   dnx;
 227     Int_t   add;
 228 //
 229 //  loop over sections
 230     for(isec=0; isec<fNsec; isec++) {
 231 //
 232 //  loop over pads along the aode wires
 233         for (Int_t iy=1; iy<=fNpy; iy++) {
 234 //
 235             Float_t x=iy*fDpy-fDpy/2;
 236             if (x > (*fRSec)[isec]) {
 237                 fNpxS[isec][iy]=0;
 238                 fCx[isec][iy]=0;
 239             } else {
 240                 ry=TMath::Sqrt((*fRSec)[isec]*(*fRSec)[isec]-x*x);
 241                 if (isec > 1) {
 242                     dnx= Int_t((ry-fCx[isec-1][iy])/(*fDpxD)[isec]);
 243                     if (isec < fNsec-1) {
 244                         if (TMath::Odd((Long_t)dnx)) dnx++;
 245                     }
 246                     fNpxS[isec][iy]=fNpxS[isec-1][iy]+dnx;
 247                     fCx[isec][iy]=fCx[isec-1][iy]+dnx*(*fDpxD)[isec];
 248                 } else if (isec == 1) {
 249                     dnx= Int_t((ry-fCx[isec-1][iy])/(*fDpxD)[isec]);
 250                     fNpxS[isec][iy]=fNpxS[isec-1][iy]+dnx;
 251                     add=4 - (fNpxS[isec][iy])%4;
 252                     if (add < 4) fNpxS[isec][iy]+=add;
 253                     dnx=fNpxS[isec][iy]-fNpxS[isec-1][iy];
 254                     fCx[isec][iy]=fCx[isec-1][iy]+dnx*(*fDpxD)[isec];
 255                 } else {
 256                     dnx=Int_t(ry/(*fDpxD)[isec]);
 257                     fNpxS[isec][iy]=dnx;
 258                     fCx[isec][iy]=dnx*(*fDpxD)[isec];
 259                 }
 260             }
 261         } // y-pad loop
 262     } // sector loop
 263 // reference to chamber
 264     AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
 265     fChamber=&(pMUON->Chamber(chamber));
 266     fZ = fChamber->Z();
 267     fId=chamber;
 268 }
 269
 270 Int_t AliMUONSegmentationV01::Sector(Int_t ix, Int_t iy)
 271 {
 272 // Returns sector number for given pad position
 273 //
 274     Int_t absix=TMath::Abs(ix);
 275     Int_t absiy=TMath::Abs(iy);
 276     Int_t isec=0;
 277     for (Int_t i=0; i<fNsec; i++) {
 278         if (absix<=fNpxS[i][absiy]){
 279             isec=i;
 280             break;
 281         }
 282     }
 283     return isec;
 284 }
 285
 286 void AliMUONSegmentationV01::
 287 GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
 288 {
 289 //  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
 290 //
 291     iy = (y-fOffsetY >0)?
 292       Int_t((y-fOffsetY)/fDpy)+1
 293       :
 294       Int_t((y-fOffsetY)/fDpy)-1;
 295
 296     if (iy >  fNpy) iy= fNpy;
 297     if (iy < -fNpy) iy=-fNpy;
 298 //
 299 //  Find sector isec
 300     Int_t isec=-1;
 301     Float_t absx=TMath::Abs(x);
 302     Int_t absiy=TMath::Abs(iy);
 303     for (Int_t i=0; i < fNsec; i++) {
 304         if (absx <= fCx[i][absiy]) {
 305             isec=i;
 306             break;
 307         }
 308     }
 309     if (isec>0) {
 310         ix= Int_t((absx-fCx[isec-1][absiy])/(*fDpxD)[isec])
 311             +fNpxS[isec-1][absiy]+1;
 312     } else if (isec == 0) {
 313         ix= Int_t(absx/(*fDpxD)[isec])+1;
 314     } else {
 315         ix=fNpxS[fNsec-1][absiy]+1;
 316     }
 317     ix = (x>0) ? ix:-ix;
 318 }
 319
 320 void AliMUONSegmentationV01::
 321 GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
 322 {
 323 //  Returns real coordinates (x,y) for given pad coordinates (ix,iy)
 324 //
 325     y = (iy>0) ?
 326       Float_t(iy*fDpy)-fDpy/2.+fOffsetY
 327       :
 328       Float_t(iy*fDpy)+fDpy/2.+fOffsetY;
 329
 330 //
 331 //  Find sector isec
 332     Int_t isec=AliMUONSegmentationV01::Sector(ix,iy);
 333 //
 334     Int_t absix=TMath::Abs(ix);
 335     Int_t absiy=TMath::Abs(iy);
 336     if (isec) {
 337         x=fCx[isec-1][absiy]+(absix-fNpxS[isec-1][absiy])*(*fDpxD)[isec];
 338         x=(ix>0) ?  x-(*fDpxD)[isec]/2 : -x+(*fDpxD)[isec]/2;
 339     } else {
 340         x=y=0;
 341     }
 342 }
 343
 344 void AliMUONSegmentationV01::
 345 SetPad(Int_t ix, Int_t iy)
 346 {
 347     //
 348     // Sets virtual pad coordinates, needed for evaluating pad response
 349     // outside the tracking program
 350     GetPadC(ix,iy,fX,fY);
 351     fSector=Sector(ix,iy);
 352 }
 353
 354
 355 void AliMUONSegmentationV01::
 356 FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
 357 {
 358 // Initialises iteration over pads for charge distribution algorithm
 359 //
 360     //
 361     // Find the wire position (center of charge distribution)
 362     Float_t x0a=GetAnod(xhit);
 363     fXhit=x0a;
 364     fYhit=yhit;
 365
 366     //
 367     // and take fNsigma*sigma around this center
 368     Float_t x01=x0a  - dx;
 369     Float_t x02=x0a  + dx;
 370     Float_t y01=yhit - dy;
 371     Float_t y02=yhit + dy;
 372     //
 373     // find the pads over which the charge distributes
 374
 375     GetPadI(x01,y01,fIxmin,fIymin);
 376     GetPadI(x02,y02,fIxmax,fIymax);
 377     fXmin=x01;
 378     fXmax=x02;
 379     fYmin=y01;
 380     fYmax=y02;
 381
 382     //
 383     // Set current pad to lower left corner
 384     if (fIxmax < fIxmin) fIxmax=fIxmin;
 385     if (fIymax < fIymin) fIymax=fIymin;
 386     fIx=fIxmin;
 387     fIy=fIymin;
 388     GetPadC(fIx,fIy,fX,fY);
 389 }
 390
 391
 392 void AliMUONSegmentationV01::NextPad()
 393 {
 394 // Stepper for the iteration over pads
 395 //
 396 // Step to next pad in the integration region
 397   //
 398   // Step to next pad in integration region
 399     Float_t xc,yc;
 400     Int_t   iyc;
 401
 402 //  step from left to right
 403
 404     if (fX < fXmax && fX != 0) {
 405         if (fIx==-1) fIx++;
 406         fIx++;
 407 //  step up
 408     } else if (fIy != fIymax) {
 409         if (fIy==-1) fIy++;
 410         fIy++;
 411 //      get y-position of next row (yc), xc not used here
 412         GetPadC(fIx,fIy,xc,yc);
 413 //      get x-pad coordiante for first pad in row (fIx)
 414         GetPadI(fXmin,yc,fIx,iyc);
 415     } else {
 416         fIx=-1;
 417         fIy=-1;
 418     }
 419     GetPadC(fIx,fIy,fX,fY);
 420     fSector=Sector(fIx,fIy);
 421     if (MorePads() &&
 422         (fSector ==-1 || fSector==0))
 423         NextPad();
 424 }
 425
 426 Int_t AliMUONSegmentationV01::MorePads()
 427
 428 {
 429 // Stopping condition for the iterator over pads
 430 //
 431 // Are there more pads in the integration region
 432     return  (fIx != -1  || fIy != -1);
 433 /*
 434     if ((fX >= fXmax  && fIy >= fIymax) || fY==0) {
 435         return 0;
 436     } else {
 437         return 1;
 438     }
 439 */
 440 }
 441
 442 void AliMUONSegmentationV01::
 443 IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
 444 {
 445 //  Returns integration limits for current pad
 446 //
 447     x1=fXhit-fX-Dpx(fSector)/2.;
 448     x2=x1+Dpx(fSector);
 449     y1=fYhit-fY-Dpy(fSector)/2.;
 450     y2=y1+Dpy(fSector);
 451 }
 452
 453 void AliMUONSegmentationV01::
 454 Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
 455 {
 456 // Returns list of next neighbours for given Pad (iX, iY)
 457 //
 458     const Float_t kEpsilon=fDpy/1000;
 459
 460     Float_t x,y;
 461     Int_t   ixx, iyy, isec1;
 462 //
 463     Int_t   isec0=AliMUONSegmentationV01::Sector(iX,iY);
 464     Int_t i=0;
 465 //
 466 //  step right
 467     Xlist[i]=iX+1;
 468     if (Xlist[i]==0) Xlist[i]++;
 469     Ylist[i++]=iY;
 470 //
 471 //  step left
 472     Xlist[i]=iX-1;
 473     if (Xlist[i]==0) Xlist[i]--;
 474     Ylist[i++]=iY;
 475 //
 476 //  step up
 477     AliMUONSegmentationV01::GetPadC(iX,iY,x,y);
 478     AliMUONSegmentationV01::GetPadI(x+kEpsilon,y+fDpy,ixx,iyy);
 479     Xlist[i]=ixx;
 480     Ylist[i++]=iyy;
 481     isec1=AliMUONSegmentationV01::Sector(ixx,iyy);
 482     if (isec1==isec0) {
 483 //
 484 //  no sector boundary crossing
 485 //      Xlist[i]=ixx+1;
 486 //      Ylist[i++]=iY+1;
 487
 488 //      Xlist[i]=ixx-1;
 489 //      Ylist[i++]=iY+1;
 490     } else if (isec1 < isec0) {
 491 // finer segmentation
 492 //      Xlist[i]=ixx+1;
 493 //      Ylist[i++]=iY+1;
 494
 495         Xlist[i]=ixx-1;
 496         Ylist[i++]=iyy;
 497
 498 //      Xlist[i]=ixx-2;
 499 //      Ylist[i++]=iY+1;
 500     } else {
 501 // coarser segmenation
 502 /*
 503         if (TMath::Odd(iX-fNpxS[isec1-1][iY+1])) {
 504             Xlist[i]=ixx-1;
 505             Ylist[i++]=iY+1;
 506         } else {
 507             Xlist[i]=ixx+1;
 508             Ylist[i++]=iY+1;
 509         }
 510 */
 511     }
 512
 513 //
 514 // step down
 515     AliMUONSegmentationV01::GetPadC(iX,iY,x,y);
 516     AliMUONSegmentationV01::GetPadI(x+kEpsilon,y-fDpy,ixx,iyy);
 517     Xlist[i]=ixx;
 518     Ylist[i++]=iyy;
 519     isec1=AliMUONSegmentationV01::Sector(ixx,iyy);
 520     if (isec1==isec0) {
 521 //
 522 //  no sector boundary crossing
 523 /*
 524     Xlist[i]=ixx+1;
 525     Ylist[i++]=iY-1;
 526
 527     Xlist[i]=ixx-1;
 528     Ylist[i++]=iY-1;
 529 */
 530     } else if (isec1 < isec0) {
 531 // finer segmentation
 532 //      Xlist[i]=ixx+1;
 533 //      Ylist[i++]=iY-1;
 534
 535         Xlist[i]=ixx-1;
 536         Ylist[i++]=iyy;
 537
 538 //      Xlist[i]=ixx-2;
 539 //      Ylist[i++]=iY-1;
 540     } else {
 541 // coarser segmentation
 542 /*
 543         if (TMath::Odd(iX-fNpxS[isec1-1][iY-1])) {
 544             Xlist[i]=ixx-1;
 545             Ylist[i++]=iY-1;
 546         } else {
 547             Xlist[i]=ixx+1;
 548             Ylist[i++]=iY-1;
 549         }
 550 */
 551     }
 552     *Nlist=i;
 553 }
 554
 555 void AliMUONSegmentationV01::GiveTestPoints(Int_t &n, Float_t *x, Float_t *y) const
 556 {
 557 // Returns test point on the pad plane.
 558 // Used during determination of the segmoid correction of the COG-method
 559
 560     n=3;
 561     x[0]=((*fRSec)[0]+(*fRSec)[1])/2/TMath::Sqrt(2.);
 562     y[0]=x[0];
 563     x[1]=((*fRSec)[1]+(*fRSec)[2])/2/TMath::Sqrt(2.);
 564     y[1]=x[1];
 565     x[2]=((*fRSec)[2]+(*fRSec)[3])/2/TMath::Sqrt(2.);
 566     y[2]=x[2];
 567 }
 568
 569 void AliMUONSegmentationV01::Draw(const char* opt) const
 570 {
 571
 572 // Draws the segmentation zones
 573 //
 574   if (!strcmp(opt,"eventdisplay")) {
 575     const int kColorMUON  = kBlue;
 576
 577     TRotMatrix* rot000 = new TRotMatrix("Rot000"," ", 90,  0, 90, 90, 0, 0);
 578     TRotMatrix* rot090 = new TRotMatrix("Rot090"," ", 90, 90, 90,180, 0, 0);
 579     TRotMatrix* rot180 = new TRotMatrix("Rot180"," ", 90,180, 90,270, 0, 0);
 580     TRotMatrix* rot270 = new TRotMatrix("Rot270"," ", 90,270, 90,  0, 0, 0);
 581
 582     char nameChamber[9], nameSense[9], nameFrame[9], nameNode[9];
 583     char nameSense1[9], nameSense2[9];
 584     TNode *node, *nodeF;
 585
 586     sprintf(nameChamber,"C_MUON%d",fId+1);
 587     sprintf(nameSense,"S_MUON%d",fId+1);
 588     sprintf(nameSense1,"S1_MUON%d",fId+1);
 589     sprintf(nameSense2,"S2_MUON%d",fId+1);
 590     sprintf(nameFrame,"F_MUON%d",fId+1);
 591
 592     TNode* top=gAlice->GetGeometry()->GetNode("alice");
 593
 594     Float_t rmin = (*fRSec)[0]-3;
 595     Float_t rmax = (*fRSec)[3]+3;
 596     new TTUBE(nameChamber,"Mother","void",rmin,rmax,0.25,1.);
 597     rmin = (*fRSec)[0];
 598     rmax = (*fRSec)[3];
 599     new TTUBE(nameSense,"Sens. region","void",rmin,rmax,0.25, 1.);
 600     Float_t dx=(rmax-rmin)/2;
 601     Float_t dy=3.;
 602     Float_t dz=0.25;
 603     TBRIK* frMUON = new TBRIK(nameFrame,"Frame","void",dx,dy,dz);
 604     top->cd();
 605     sprintf(nameNode,"MUON%d",100+fId+1);
 606     node = new TNode(nameNode,"ChamberNode",nameChamber,0,0,fChamber->Z(),"");
 607     node->SetLineColor(kColorMUON);
 608     AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
 609     (pMUON->Nodes())->Add(node);
 610     node->cd();
 611     sprintf(nameNode,"MUON%d",200+fId+1);
 612     node = new TNode(nameNode,"Sens. Region Node",nameSense,0,0,0,"");
 613     node->SetLineColor(kColorMUON);
 614     node->cd();
 615     Float_t dr=dx+rmin;
 616     sprintf(nameNode,"MUON%d",300+fId+1);
 617     nodeF = new TNode(nameNode,"Frame0",frMUON,dr, 0, 0,rot000,"");
 618     nodeF->SetLineColor(kColorMUON);
 619     node->cd();
 620     sprintf(nameNode,"MUON%d",400+fId+1);
 621     nodeF = new TNode(nameNode,"Frame1",frMUON,0 ,dr,0,rot090,"");
 622     nodeF->SetLineColor(kColorMUON);
 623     node->cd();
 624     sprintf(nameNode,"MUON%d",500+fId+1);
 625     nodeF = new TNode(nameNode,"Frame2",frMUON,-dr,0,0,rot180,"");
 626     nodeF->SetLineColor(kColorMUON);
 627     node  ->cd();
 628     sprintf(nameNode,"MUON%d",600+fId+1);
 629     nodeF = new TNode(nameNode,"Frame3",frMUON,0,-dr,0,rot270,"");
 630     nodeF->SetLineColor(kColorMUON);
 631   } else {
 632     TBox *box;
 633
 634     Float_t dx=0.95/fCx[3][1]/2;
 635     Float_t dy=0.95/(Float_t(Npy()))/2;
 636     Float_t x0,y0,x1,y1;
 637     Float_t xc=0.5;
 638     Float_t yc=0.5;
 639
 640     for (Int_t iy=1; iy<Npy(); iy++) {
 641       for (Int_t isec=0; isec<4; isec++) {
 642         if (isec==0) {
 643           x0=0;
 644           x1=fCx[isec][iy]*dx;
 645         } else {
 646           x0=fCx[isec-1][iy]*dx;
 647           x1=fCx[isec][iy]*dx;
 648         }
 649         y0=Float_t(iy-1)*dy;
 650         y1=y0+dy;
 651         box=new TBox(x0+xc,y0+yc,x1+xc,y1+yc);
 652         box->SetFillColor(isec+1);
 653         box->Draw();
 654
 655         box=new TBox(-x1+xc,y0+yc,-x0+xc,y1+yc);
 656         box->SetFillColor(isec+1);
 657         box->Draw();
 658
 659         box=new TBox(x0+xc,-y1+yc,x1+xc,-y0+yc);
 660         box->SetFillColor(isec+1);
 661         box->Draw();
 662
 663         box=new TBox(-x1+xc,-y1+yc,-x0+xc,-y0+yc);
 664         box->SetFillColor(isec+1);
 665         box->Draw();
 666       }
 667     }
 668   }
 669 }
 670 void AliMUONSegmentationV01::SetCorrFunc(Int_t isec, TF1* func)
 671 {
 672 // Set the correction function
 673     fCorrA->AddAt(func,isec);
 674 }
 675
 676 TF1* AliMUONSegmentationV01::CorrFunc(Int_t isec) const
 677 {
 678 // Get correction function
 679   //PH    return (TF1*) (*fCorrA)[isec];
 680     return (TF1*) fCorrA->At(isec);
 681 }
 682
 683 AliMUONSegmentationV01& AliMUONSegmentationV01::operator
 684 =(const AliMUONSegmentationV01 & rhs)
 685 {
 686 // Dummy assignment operator
 687     return *this;
 688 }
 689