PMD/AliPMDUtility.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 //                                                     //
  18 //  Date   : August 05 2003                            //
  19 //                                                     //
  20 //  Utility code for ALICE-PMD                         //
  21 //                                                     //
  22 //-----------------------------------------------------//
  23
  24 #include "Riostream.h"
  25 #include "TMath.h"
  26 #include "TText.h"
  27 #include "TLine.h"
  28
  29 #include <stdio.h>
  30 #include <math.h>
  31
  32 #include "AliPMDUtility.h"
  33
  34 ClassImp(AliPMDUtility)
  35
  36 AliPMDUtility::AliPMDUtility():
  37   fPx(0.),
  38   fPy(0.),
  39   fPz(0.),
  40   fTheta(0.),
  41   fEta(0.),
  42   fPhi(0.),
  43   fWriteModule(1)
  44 {
  45   // Default constructor
  46   for (Int_t i = 0; i < 4; i++)
  47     {
  48       for (Int_t j = 0; j < 3; j++)
  49         {
  50           fSecTr[i][j] = 0.;
  51         }
  52     }
  53
  54 }
  55
  56 AliPMDUtility::AliPMDUtility(Float_t px, Float_t py, Float_t pz):
  57   fPx(px),
  58   fPy(py),
  59   fPz(pz),
  60   fTheta(0.),
  61   fEta(0.),
  62   fPhi(0.),
  63   fWriteModule(1)
  64 {
  65   // Constructor
  66   for (Int_t i = 0; i < 4; i++)
  67     {
  68       for (Int_t j = 0; j < 3; j++)
  69         {
  70           fSecTr[i][j] = 0.;
  71         }
  72     }
  73
  74 }
  75 AliPMDUtility::AliPMDUtility(const AliPMDUtility &pmdutil):
  76   TObject(pmdutil),
  77   fPx(pmdutil.fPx),
  78   fPy(pmdutil.fPy),
  79   fPz(pmdutil.fPz),
  80   fTheta(pmdutil.fTheta),
  81   fEta(pmdutil.fEta),
  82   fPhi(pmdutil.fPhi),
  83   fWriteModule(pmdutil.fWriteModule)
  84 {
  85   // copy constructor
  86     for (Int_t i = 0; i < 4; i++)
  87     {
  88       for (Int_t j = 0; j < 3; j++)
  89         {
  90           fSecTr[i][j] = pmdutil.fSecTr[i][j];
  91         }
  92     }
  93
  94 }
  95 AliPMDUtility & AliPMDUtility::operator=(const AliPMDUtility &pmdutil)
  96 {
  97   // assignment operator
  98   if(this != &pmdutil)
  99     {
 100       fPx = pmdutil.fPx;
 101       fPy = pmdutil.fPy;
 102       fPz = pmdutil.fPz;
 103       fTheta = pmdutil.fTheta;
 104       fEta = pmdutil.fEta;
 105       fPhi = pmdutil.fPhi;
 106       fWriteModule = pmdutil.fWriteModule;
 107       for (Int_t i = 0; i < 4; i++)
 108         {
 109           for (Int_t j = 0; j < 3; j++)
 110             {
 111               fSecTr[i][j] = pmdutil.fSecTr[i][j];
 112             }
 113         }
 114
 115     }
 116   return *this;
 117 }
 118 AliPMDUtility::~AliPMDUtility()
 119 {
 120   // Default destructor
 121 }
 122
 123 void AliPMDUtility::RectGeomCellPos(Int_t ism, Int_t xpad, Int_t ypad, Float_t &xpos, Float_t &ypos)
 124 {
 125   // This routine finds the cell eta,phi for the new PMD rectangular
 126   // geometry in ALICE
 127   // Authors : Bedanga Mohanty and Dipak Mishra - 29.4.2003
 128   // modified by B. K. Nandi for change of coordinate sys
 129   //
 130   // SMA  ---> Supermodule Type A           ( SM - 0)
 131   // SMAR ---> Supermodule Type A ROTATED   ( SM - 1)
 132   // SMB  ---> Supermodule Type B           ( SM - 2)
 133   // SMBR ---> Supermodule Type B ROTATED   ( SM - 3)
 134   //
 135   // ism   : Serial module number from 0 to 23 for each plane
 136
 137
 138   // Corner positions (x,y) of the 24 unit moudles in ALICE PMD
 139
 140   double xcorner[24] =
 141     {
 142       74.8833,  53.0045, 31.1255,    //Type-A
 143       74.8833,  53.0045, 31.1255,    //Type-A
 144       -74.8833, -53.0044, -31.1255,  //Type-AR
 145       -74.8833, -53.0044, -31.1255,  //Type-AR
 146       8.9165, -33.7471,            //Type-B
 147       8.9165, -33.7471,            //Type-B
 148       8.9165, -33.7471,            //Type-B
 149       -8.9165, 33.7471,            //Type-BR
 150       -8.9165, 33.7471,            //Type-BR
 151       -8.9165, 33.7471,            //Type-BR
 152     };
 153
 154
 155   double ycorner[24] =
 156     {
 157       86.225,  86.225,  86.225,      //Type-A
 158       37.075,  37.075,  37.075,      //Type-A
 159       -86.225, -86.225, -86.225,     //Type-AR
 160       -37.075, -37.075, -37.075,     //Type-AR
 161       86.225,  86.225,               //Type-B
 162       61.075,  61.075,               //Type-B
 163       35.925,  35.925,               //Type-B
 164       -86.225, -86.225,              //Type-BR
 165       -61.075, -61.075,              //Type-BR
 166       -35.925, -35.925               //Type-BR
 167     };
 168
 169
 170   const Float_t kSqroot3      = 1.73205;  // sqrt(3.);
 171   const Float_t kCellRadius   = 0.25;
 172
 173   //
 174   //Every even row of cells is shifted and placed
 175   //in geant so this condition
 176   //
 177   Float_t cellRadius = 0.25;
 178   Float_t shift = 0.0;
 179   if(xpad%2 == 0)
 180     {
 181       shift = -cellRadius/2.0;
 182     }
 183   else
 184     {
 185       shift = 0.0;
 186     }
 187
 188
 189   if(ism < 6)
 190     {
 191       ypos = ycorner[ism] - (Float_t) xpad*kCellRadius*2.0 + shift;
 192       xpos = xcorner[ism] - (Float_t) ypad*kSqroot3*kCellRadius;
 193     }
 194   else if(ism >=6 && ism < 12)
 195     {
 196       ypos = ycorner[ism] + (Float_t) xpad*kCellRadius*2.0 + shift;
 197       xpos = xcorner[ism] + (Float_t) ypad*kSqroot3*kCellRadius;
 198     }
 199   else if(ism >= 12 && ism < 18)
 200     {
 201       ypos = ycorner[ism] - (Float_t) xpad*kCellRadius*2.0 + shift;
 202       xpos = xcorner[ism] - (Float_t) ypad*kSqroot3*kCellRadius;
 203     }
 204   else if(ism >= 18 && ism < 24)
 205     {
 206       ypos = ycorner[ism] + (Float_t) xpad*kCellRadius*2.0 + shift;
 207       xpos = xcorner[ism] + (Float_t) ypad*kSqroot3*kCellRadius;
 208     }
 209   // Apply the alignment here to the x, y values
 210   if(ism < 6)
 211     {
 212       xpos += fSecTr[0][0];
 213       ypos += fSecTr[0][1];
 214     }
 215   else if(ism >= 6 && ism < 12)
 216     {
 217       xpos += fSecTr[1][0];
 218       ypos += fSecTr[1][1];
 219     }
 220   else if(ism >=12 && ism < 18)
 221     {
 222       xpos += fSecTr[2][0];
 223       ypos += fSecTr[2][1];
 224     }
 225   else if(ism >= 18 && ism < 24)
 226     {
 227       xpos += fSecTr[3][0];
 228       ypos += fSecTr[3][1];
 229     }
 230
 231 }
 232 // ----------------------------------------------------------
 233 void AliPMDUtility::RectGeomCellPos(Int_t ism, Float_t xpad, Float_t ypad, Float_t &xpos, Float_t &ypos)
 234 {
 235   // If the xpad and ypad inputs are float, then 0.5 is added to it
 236   // to find the layer which is shifted.
 237   // This routine finds the cell eta,phi for the new PMD rectangular
 238   // geometry in ALICE
 239   // Authors : Bedanga Mohanty and Dipak Mishra - 29.4.2003
 240   // modified by B. K. Nnadi for change of coordinate sys
 241   //
 242   // SMA  ---> Supermodule Type A           ( SM - 0)
 243   // SMAR ---> Supermodule Type A ROTATED   ( SM - 1)
 244   // SMB  ---> Supermodule Type B           ( SM - 2)
 245   // SMBR ---> Supermodule Type B ROTATED   ( SM - 3)
 246   //
 247   // ism   : Serial Module number from 0 to 23 for each plane
 248
 249   // Corner positions (x,y) of the 24 unit moudles in ALICE PMD
 250
 251   double xcorner[24] =
 252     {
 253       74.8833,  53.0045, 31.1255,    //Type-A
 254       74.8833,  53.0045, 31.1255,    //Type-A
 255       -74.8833, -53.0044, -31.1255,  //Type-AR
 256       -74.8833, -53.0044, -31.1255,  //Type-AR
 257       8.9165, -33.7471,            //Type-B
 258       8.9165, -33.7471,            //Type-B
 259       8.9165, -33.7471,            //Type-B
 260       -8.9165, 33.7471,            //Type-BR
 261       -8.9165, 33.7471,            //Type-BR
 262       -8.9165, 33.7471,            //Type-BR
 263     };
 264
 265
 266
 267   double ycorner[24] =
 268     {
 269       86.225,  86.225,  86.225,      //Type-A
 270       37.075,  37.075,  37.075,      //Type-A
 271       -86.225, -86.225, -86.225,     //Type-AR
 272       -37.075, -37.075, -37.075,     //Type-AR
 273       86.225,  86.225,               //Type-B
 274       61.075,  61.075,               //Type-B
 275       35.925,  35.925,               //Type-B
 276       -86.225, -86.225,              //Type-BR
 277       -61.075, -61.075,              //Type-BR
 278       -35.925, -35.925               //Type-BR
 279     };
 280
 281
 282   const Float_t kSqroot3    = 1.73205;  // sqrt(3.);
 283   const Float_t kCellRadius = 0.25;
 284
 285   //
 286   //Every even row of cells is shifted and placed
 287   //in geant so this condition
 288   //
 289   Float_t cellRadius = 0.25;
 290   Float_t shift = 0.0;
 291   Int_t iirow = (Int_t) (xpad+0.5);
 292   if(iirow%2 == 0)
 293     {
 294       shift = -cellRadius/2.0;
 295     }
 296   else
 297     {
 298       shift = 0.0;
 299     }
 300
 301   if(ism < 6)
 302     {
 303       ypos = ycorner[ism] - xpad*kCellRadius*2.0 + shift;
 304       xpos = xcorner[ism] - ypad*kSqroot3*kCellRadius;
 305     }
 306   else if(ism >=6 && ism < 12)
 307     {
 308       ypos = ycorner[ism] + xpad*kCellRadius*2.0 + shift;
 309       xpos = xcorner[ism] + ypad*kSqroot3*kCellRadius;
 310     }
 311   else if(ism >= 12 && ism < 18)
 312     {
 313       ypos = ycorner[ism] - xpad*kCellRadius*2.0 + shift;
 314       xpos = xcorner[ism] - ypad*kSqroot3*kCellRadius;
 315     }
 316   else if(ism >= 18 && ism < 24)
 317     {
 318       ypos = ycorner[ism] + xpad*kCellRadius*2.0 + shift;
 319       xpos = xcorner[ism] + ypad*kSqroot3*kCellRadius;
 320     }
 321
 322   // Apply the alignment here to the x, y values
 323   if(ism < 6)
 324     {
 325       xpos += fSecTr[0][0];
 326       ypos += fSecTr[0][1];
 327     }
 328   else if(ism >= 6 && ism < 12)
 329     {
 330       xpos += fSecTr[1][0];
 331       ypos += fSecTr[1][1];
 332     }
 333   else if(ism >=12 && ism < 18)
 334     {
 335       xpos += fSecTr[2][0];
 336       ypos += fSecTr[2][1];
 337     }
 338   else if(ism >= 18 && ism < 24)
 339     {
 340       xpos += fSecTr[3][0];
 341       ypos += fSecTr[3][1];
 342     }
 343
 344 }
 345
 346 // -------------------------------------------------------- //
 347
 348 void AliPMDUtility::RectGeomCellPos(Int_t ism, Float_t xpad,
 349                                     Float_t ypad, Float_t &xpos,
 350                                     Float_t &ypos, Float_t & zpos)
 351 {
 352   // If the xpad and ypad inputs are float, then 0.5 is added to it
 353   // to find the layer which is shifted.
 354   // This routine finds the cell eta,phi for the new PMD rectangular
 355   // geometry in ALICE
 356   // Authors : Bedanga Mohanty and Dipak Mishra - 29.4.2003
 357   // modified by B. K. Nnadi for change of coordinate sys
 358   //
 359   // SMA  ---> Supermodule Type A           ( SM - 0)
 360   // SMAR ---> Supermodule Type A ROTATED   ( SM - 1)
 361   // SMB  ---> Supermodule Type B           ( SM - 2)
 362   // SMBR ---> Supermodule Type B ROTATED   ( SM - 3)
 363   //
 364   // ism   : Serial Module number from 0 to 23 for each plane
 365
 366   // Corner positions (x,y) of the 24 unit moudles in ALICE PMD
 367
 368   double xcorner[24] =
 369     {
 370       74.8833,  53.0045, 31.1255,    //Type-A
 371       74.8833,  53.0045, 31.1255,    //Type-A
 372       -74.8833, -53.0044, -31.1255,  //Type-AR
 373       -74.8833, -53.0044, -31.1255,  //Type-AR
 374       8.9165, -33.7471,            //Type-B
 375       8.9165, -33.7471,            //Type-B
 376       8.9165, -33.7471,            //Type-B
 377       -8.9165, 33.7471,            //Type-BR
 378       -8.9165, 33.7471,            //Type-BR
 379       -8.9165, 33.7471,            //Type-BR
 380     };
 381
 382
 383
 384   double ycorner[24] =
 385     {
 386       86.225,  86.225,  86.225,      //Type-A
 387       37.075,  37.075,  37.075,      //Type-A
 388       -86.225, -86.225, -86.225,     //Type-AR
 389       -37.075, -37.075, -37.075,     //Type-AR
 390       86.225,  86.225,               //Type-B
 391       61.075,  61.075,               //Type-B
 392       35.925,  35.925,               //Type-B
 393       -86.225, -86.225,              //Type-BR
 394       -61.075, -61.075,              //Type-BR
 395       -35.925, -35.925               //Type-BR
 396     };
 397
 398
 399   const Float_t kSqroot3    = 1.73205;  // sqrt(3.);
 400   const Float_t kCellRadius = 0.25;
 401
 402   //
 403   //Every even row of cells is shifted and placed
 404   //in geant so this condition
 405   //
 406   Float_t cellRadius = 0.25;
 407   Float_t shift = 0.0;
 408   Int_t iirow = (Int_t) (xpad+0.5);
 409   if(iirow%2 == 0)
 410     {
 411       shift = -cellRadius/2.0;
 412     }
 413   else
 414     {
 415       shift = 0.0;
 416     }
 417
 418   if(ism < 6)
 419     {
 420       ypos = ycorner[ism] - xpad*kCellRadius*2.0 + shift;
 421       xpos = xcorner[ism] - ypad*kSqroot3*kCellRadius;
 422     }
 423   else if(ism >=6 && ism < 12)
 424     {
 425       ypos = ycorner[ism] + xpad*kCellRadius*2.0 + shift;
 426       xpos = xcorner[ism] + ypad*kSqroot3*kCellRadius;
 427     }
 428   else if(ism >= 12 && ism < 18)
 429     {
 430       ypos = ycorner[ism] - xpad*kCellRadius*2.0 + shift;
 431       xpos = xcorner[ism] - ypad*kSqroot3*kCellRadius;
 432     }
 433   else if(ism >= 18 && ism < 24)
 434     {
 435       ypos = ycorner[ism] + xpad*kCellRadius*2.0 + shift;
 436       xpos = xcorner[ism] + ypad*kSqroot3*kCellRadius;
 437     }
 438
 439   // Apply the alignment here to the x, y, and z values
 440   if(ism < 6)
 441     {
 442       xpos += fSecTr[0][0];
 443       ypos += fSecTr[0][1];
 444       zpos += fSecTr[0][2];
 445     }
 446   else if(ism >= 6 && ism < 12)
 447     {
 448       xpos += fSecTr[1][0];
 449       ypos += fSecTr[1][1];
 450       zpos += fSecTr[1][2];
 451     }
 452   else if(ism >=12 && ism < 18)
 453     {
 454       xpos += fSecTr[2][0];
 455       ypos += fSecTr[2][1];
 456       zpos += fSecTr[2][2];
 457     }
 458   else if(ism >= 18 && ism < 24)
 459     {
 460       xpos += fSecTr[3][0];
 461       ypos += fSecTr[3][1];
 462       zpos += fSecTr[3][2];
 463     }
 464
 465
 466
 467 }
 468 // -------------------------------------------------------- //
 469
 470 void AliPMDUtility::GenerateBoundaryPoints(Int_t ism, Float_t &x1ism,
 471                                            Float_t &y1ism, Float_t &x2ism,
 472                                            Float_t &y2ism)
 473 {
 474   // Generate bounding-box.
 475
 476
 477     Float_t xism = 0, yism = 0;
 478     Float_t dxism = 0., dyism = 0.;
 479
 480     const Float_t kRad     = 0.25;
 481     const Float_t kSqRoot3 = 1.732050808;
 482     const Float_t kDia     = 0.50;
 483
 484
 485   const Double_t kXcorner[24] =
 486     {
 487       74.8833,  53.0045, 31.1255,    //Type-A
 488       74.8833,  53.0045, 31.1255,    //Type-A
 489       -74.8833, -53.0044, -31.1255,  //Type-AR
 490       -74.8833, -53.0044, -31.1255,  //Type-AR
 491       8.9165, -33.7471,            //Type-B
 492       8.9165, -33.7471,            //Type-B
 493       8.9165, -33.7471,            //Type-B
 494       -8.9165, 33.7471,            //Type-BR
 495       -8.9165, 33.7471,            //Type-BR
 496       -8.9165, 33.7471,            //Type-BR
 497     };
 498
 499
 500   const Double_t kYcorner[24] =
 501     {
 502       86.225,  86.225,  86.225,      //Type-A
 503       37.075,  37.075,  37.075,      //Type-A
 504       -86.225, -86.225, -86.225,     //Type-AR
 505       -37.075, -37.075, -37.075,     //Type-AR
 506       86.225,  86.225,               //Type-B
 507       61.075,  61.075,               //Type-B
 508       35.925,  35.925,               //Type-B
 509       -86.225, -86.225,              //Type-BR
 510       -61.075, -61.075,              //Type-BR
 511       -35.925, -35.925               //Type-BR
 512     };
 513
 514
 515   if (ism > 23) ism -= 24;
 516
 517
 518   if (ism < 6)
 519     {
 520       xism  = kXcorner[ism] + kRad;
 521       yism  = kYcorner[ism] + kRad;
 522       dxism = -kRad*kSqRoot3*48.;
 523       dyism = -kDia*96. - kRad;
 524   }
 525   if (ism >= 6 && ism < 12)
 526     {
 527       xism  = kXcorner[ism] - kRad;
 528       yism  = kYcorner[ism] - kRad;
 529       dxism = kRad*kSqRoot3*48.;
 530       dyism = kDia*96. + kRad;
 531   }
 532   if (ism >= 12 && ism < 18)
 533     {
 534       xism  = kXcorner[ism] + kRad;
 535       yism  = kYcorner[ism] + kRad;
 536       dxism = -kRad*kSqRoot3*96.;
 537       dyism = -kDia*48. - kRad;
 538   }
 539   if (ism >= 18 && ism < 24)
 540     {
 541       xism  = kXcorner[ism] - kRad;
 542       yism  = kYcorner[ism] - kRad;
 543       dxism = kRad*kSqRoot3*96.;
 544       dyism = kDia*48. + kRad;
 545   }
 546
 547   x1ism = xism;
 548   x2ism = xism + dxism;
 549   y1ism = yism;
 550   y2ism = yism + dyism;
 551
 552 }
 553 // ------------------------------------------------------------------- //
 554
 555 void AliPMDUtility::DrawPMDModule(Int_t idet)
 556 {
 557
 558     Float_t x1ism = 0., x2ism = 0., y1ism = 0., y2ism = 0.;
 559     Float_t deltaX = 0., deltaY = 0.;
 560
 561     //TH2F *h2 = new TH2F("h2","Y vs. X",200,-100.,100.,200,-100.,100.);
 562     //h2->Draw();
 563
 564     TLine t;
 565     t.SetLineColor(2);
 566
 567     TText tt;
 568     tt.SetTextColor(4);
 569
 570     Char_t smnumber[10];
 571
 572     for(Int_t ism=0; ism < 24; ism++)
 573     {
 574         GenerateBoundaryPoints(ism, x1ism, y1ism, x2ism, y2ism);
 575         deltaX = (x2ism - x1ism)/2.;
 576         deltaY = (y2ism - y1ism)/2.;
 577         if (fWriteModule == 1)
 578         {
 579           if(idet == 0)
 580             {
 581               snprintf(smnumber,10,"%d",ism);
 582             }
 583           else if (idet == 1)
 584             {
 585               snprintf(smnumber,10,"%d",24+ism);
 586             }
 587             tt.DrawText(x1ism+deltaX,y1ism+deltaY,smnumber);
 588         }
 589         t.DrawLine(x1ism, y1ism, x1ism, y2ism);
 590         t.DrawLine(x1ism, y1ism, x2ism, y1ism);
 591         t.DrawLine(x2ism, y1ism, x2ism, y2ism);
 592         t.DrawLine(x1ism, y2ism, x2ism, y2ism);
 593     }
 594
 595 }
 596
 597 // ------------------------------------------------------------------- //
 598
 599
 600 void AliPMDUtility::ApplyVertexCorrection(Float_t vertex[], Float_t xpos,
 601                                           Float_t ypos, Float_t zpos)
 602 {
 603   // Not implemented
 604   fPx = xpos - vertex[0];
 605   fPy = ypos - vertex[1];
 606   fPz = zpos - vertex[2];
 607 }
 608 void AliPMDUtility::ApplyAlignment(Double_t sectr[][3])
 609 {
 610   // Get the alignment stuff here
 611
 612   for (Int_t isector=0; isector<4; isector++)
 613     {
 614       for(Int_t ixyz=0; ixyz < 3; ixyz++)
 615         {
 616           fSecTr[isector][ixyz] = (Float_t) sectr[isector][ixyz];
 617         }
 618     }
 619 }
 620
 621 void AliPMDUtility::SetPxPyPz(Float_t px, Float_t py, Float_t pz)
 622 {
 623   fPx = px;
 624   fPy = py;
 625   fPz = pz;
 626 }
 627
 628 void AliPMDUtility::SetXYZ(Float_t xpos, Float_t ypos, Float_t zpos)
 629 {
 630   fPx = xpos;
 631   fPy = ypos;
 632   fPz = zpos;
 633 }
 634 void AliPMDUtility::SetWriteModule(Int_t wrmod)
 635 {
 636     fWriteModule = wrmod;
 637 }
 638 void AliPMDUtility::CalculateEta()
 639 {
 640   Float_t rpxpy  = TMath::Sqrt(fPx*fPx + fPy*fPy);
 641   Float_t theta  = TMath::ATan2(rpxpy,fPz);
 642   Float_t eta    = -TMath::Log(TMath::Tan(0.5*theta));
 643   fTheta = theta;
 644   fEta   = eta;
 645 }
 646 void AliPMDUtility::CalculatePhi()
 647 {
 648   Float_t pybypx = 0., phi = 0., phi1 = 0.;
 649
 650   if(fPx==0)
 651     {
 652       if(fPy>0) phi = 90.;
 653       if(fPy<0) phi = 270.;
 654     }
 655   if(fPx != 0)
 656     {
 657       pybypx = fPy/fPx;
 658       if(pybypx < 0) pybypx = - pybypx;
 659       phi1 = TMath::ATan(pybypx)*180./3.14159;
 660
 661       if(fPx > 0 && fPy > 0) phi = phi1;        // 1st Quadrant
 662       if(fPx < 0 && fPy > 0) phi = 180 - phi1;  // 2nd Quadrant
 663       if(fPx < 0 && fPy < 0) phi = 180 + phi1;  // 3rd Quadrant
 664       if(fPx > 0 && fPy < 0) phi = 360 - phi1;  // 4th Quadrant
 665
 666     }
 667   phi = phi*3.14159/180.;
 668
 669   fPhi = phi;
 670
 671 }
 672 void AliPMDUtility::CalculateEtaPhi()
 673 {
 674   Float_t pybypx = 0., phi = 0., phi1 = 0.;
 675
 676   Float_t rpxpy = TMath::Sqrt(fPx*fPx + fPy*fPy);
 677   Float_t theta = TMath::ATan2(rpxpy,fPz);
 678   Float_t eta   = -TMath::Log(TMath::Tan(0.5*theta));
 679
 680   if(fPx == 0)
 681     {
 682       if(fPy>0) phi = 90.;
 683       if(fPy<0) phi = 270.;
 684     }
 685   if(fPx != 0)
 686     {
 687       pybypx = fPy/fPx;
 688       if(pybypx < 0) pybypx = - pybypx;
 689       phi1 = TMath::ATan(pybypx)*180./3.14159;
 690       if(fPx > 0 && fPy > 0) phi = phi1;        // 1st Quadrant
 691       if(fPx < 0 && fPy > 0) phi = 180 - phi1;  // 2nd Quadrant
 692       if(fPx < 0 && fPy < 0) phi = 180 + phi1;  // 3rd Quadrant
 693       if(fPx > 0 && fPy < 0) phi = 360 - phi1;  // 4th Quadrant
 694
 695     }
 696   phi = phi*3.14159/180.;
 697
 698   fTheta = theta;
 699   fEta   = eta;
 700   fPhi   = phi;
 701 }
 702 void AliPMDUtility::CalculateXY(Float_t eta, Float_t phi, Float_t zpos)
 703 {
 704   // Not implemented
 705
 706   //  eta   = -TMath::Log(TMath::Tan(0.5*theta));
 707
 708   Float_t xpos = 0., ypos = 0.;
 709
 710   //  Float_t theta = 2.0*TMath::ATan(TMath::Log(-eta));
 711
 712   fEta = eta;
 713   fPhi = phi;
 714   fPx  = xpos;
 715   fPy  = ypos;
 716   fPz  = zpos;
 717 }
 718
 719 void AliPMDUtility::GetEtaIndexXY(Int_t smn, Int_t row, Int_t col, Float_t &xp, Float_t &yp, Double_t &eta, Int_t &etaindex) {
 720   // Takes smn, row, col
 721   // Calculates x, y, eta and etabin into 10.
 722   // Use only in raw Data.
 723
 724   Float_t xx = 0., yy = 0.;
 725   Int_t xpad = -1, ypad = -1;
 726
 727   if(smn <12) {
 728     xpad = col;
 729     ypad = row;
 730   }
 731   else if(smn >=12 && smn < 24) {
 732     xpad = row;
 733     ypad = col;
 734   }
 735
 736
 737
 738   RectGeomCellPos(smn,xpad,ypad,xx,yy);
 739   xp = xx;
 740   yp = yy;
 741
 742   Float_t rpxpy  = TMath::Sqrt(xx*xx + yy*yy);
 743   Float_t theta  = TMath::ATan2(rpxpy,365.0);
 744   eta    = -TMath::Log(TMath::Tan(0.5*theta));
 745
 746   Int_t etaBin = -1;
 747
 748   if( eta > 2.1 && eta < 2.3) etaBin = 0;
 749   else if( eta > 2.3 && eta < 2.5) etaBin = 1;
 750   else if( eta > 2.5 && eta < 2.7) etaBin = 2;
 751   else if( eta > 2.7 && eta < 2.9) etaBin = 3;
 752   else if( eta > 2.9 && eta < 3.1) etaBin = 4;
 753   else if( eta > 3.1 && eta < 3.3) etaBin = 5;
 754   else if( eta > 3.3 && eta < 3.5) etaBin = 6;
 755   else if( eta > 3.5 && eta < 3.7) etaBin = 7;
 756   else if( eta > 3.7 && eta < 3.9) etaBin = 8;
 757   else if( eta > 3.9 && eta < 4.1) etaBin = 9;
 758   else etaBin = 13;
 759
 760   etaindex = etaBin;
 761
 762
 763 }
 764
 765 //_____________________________________________________
 766
 767 Float_t AliPMDUtility::GetTheta() const
 768 {
 769   return fTheta;
 770 }
 771 Float_t AliPMDUtility::GetEta() const
 772 {
 773   return fEta;
 774 }
 775 Float_t AliPMDUtility::GetPhi() const
 776 {
 777   return fPhi;
 778 }
 779 Float_t AliPMDUtility::GetX() const
 780 {
 781   return fPx;
 782 }
 783 Float_t AliPMDUtility::GetY() const
 784 {
 785   return fPy;
 786 }
 787 Float_t AliPMDUtility::GetZ() const
 788 {
 789   return fPz;
 790 }
 791 //--------------------------------------------------------------------//