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 "AliPMDUtility.h"
  26 #include "TMath.h"
  27 #include <stdio.h>
  28 #include <math.h>
  29
  30
  31 ClassImp(AliPMDUtility)
  32
  33 AliPMDUtility::AliPMDUtility()
  34 {
  35   // Default constructor
  36   fPx    = 0.;
  37   fPy    = 0.;
  38   fPz    = 0.;
  39   fTheta = 0.;
  40   fEta   = 0.;
  41   fPhi   = 0.;
  42 }
  43
  44 AliPMDUtility::AliPMDUtility(Float_t px, Float_t py, Float_t pz)
  45 {
  46   // Constructor
  47   fPx = px;
  48   fPy = py;
  49   fPz = pz;
  50   fTheta = 0.;
  51   fEta   = 0.;
  52   fPhi   = 0.;
  53 }
  54
  55 AliPMDUtility::~AliPMDUtility()
  56 {
  57   // Default destructor
  58 }
  59
  60 void AliPMDUtility::RectGeomCellPos(Int_t ism, Int_t xpad, Int_t ypad, Float_t &xpos, Float_t &ypos)
  61 {
  62   // This routine finds the cell eta,phi for the new PMD rectangular
  63   // geometry in ALICE
  64   // Authors : Bedanga Mohanty and Dipak Mishra - 29.4.2003
  65   // modified by B. K. Nandi for change of coordinate sys
  66   //
  67   // SMA  ---> Supermodule Type A           ( SM - 0)
  68   // SMAR ---> Supermodule Type A ROTATED   ( SM - 1)
  69   // SMB  ---> Supermodule Type B           ( SM - 2)
  70   // SMBR ---> Supermodule Type B ROTATED   ( SM - 3)
  71   //
  72   // ism   : Serial module number from 0 to 23 for each plane
  73
  74
  75   // Corner positions (x,y) of the 24 unit moudles in ALICE PMD
  76
  77   double xcorner[24] =
  78     {
  79       74.8833,  53.0045, 31.1255,    //Type-A
  80       74.8833,  53.0045, 31.1255,    //Type-A
  81       -74.8833, -53.0044, -31.1255,  //Type-AR
  82       -74.8833, -53.0044, -31.1255,  //Type-AR
  83       8.9165, -33.7471,            //Type-B
  84       8.9165, -33.7471,            //Type-B
  85       8.9165, -33.7471,            //Type-B
  86       -8.9165, 33.7471,            //Type-BR
  87       -8.9165, 33.7471,            //Type-BR
  88       -8.9165, 33.7471,            //Type-BR
  89     };
  90
  91
  92   double ycorner[24] =
  93     {
  94       86.225,  86.225,  86.225,      //Type-A
  95       37.075,  37.075,  37.075,      //Type-A
  96       -86.225, -86.225, -86.225,     //Type-AR
  97       -37.075, -37.075, -37.075,     //Type-AR
  98       86.225,  86.225,               //Type-B
  99       61.075,  61.075,               //Type-B
 100       35.925,  35.925,               //Type-B
 101       -86.225, -86.225,              //Type-BR
 102       -61.075, -61.075,              //Type-BR
 103       -35.925, -35.925               //Type-BR
 104     };
 105
 106
 107   const Float_t kSqroot3      = 1.73205;  // sqrt(3.);
 108   const Float_t kCellRadius   = 0.25;
 109
 110   //
 111   //Every even row of cells is shifted and placed
 112   //in geant so this condition
 113   //
 114   Float_t cellRadius = 0.25;
 115   Float_t shift = 0.0;
 116   if(xpad%2 == 0)
 117     {
 118       shift = -cellRadius/2.0;
 119     }
 120   else
 121     {
 122       shift = 0.0;
 123     }
 124
 125
 126   if(ism < 6)
 127     {
 128       ypos = ycorner[ism] - (Float_t) xpad*kCellRadius*2.0 + shift;
 129       xpos = xcorner[ism] - (Float_t) ypad*kSqroot3*kCellRadius;
 130     }
 131   else if(ism >=6 && ism < 12)
 132     {
 133       ypos = ycorner[ism] + (Float_t) xpad*kCellRadius*2.0 + shift;
 134       xpos = xcorner[ism] + (Float_t) ypad*kSqroot3*kCellRadius;
 135     }
 136   else if(ism >= 12 && ism < 18)
 137     {
 138       ypos = ycorner[ism] - (Float_t) xpad*kCellRadius*2.0 + shift;
 139       xpos = xcorner[ism] - (Float_t) ypad*kSqroot3*kCellRadius;
 140     }
 141   else if(ism >= 18 && ism < 24)
 142     {
 143       ypos = ycorner[ism] + (Float_t) xpad*kCellRadius*2.0 + shift;
 144       xpos = xcorner[ism] + (Float_t) ypad*kSqroot3*kCellRadius;
 145     }
 146
 147 }
 148
 149 void AliPMDUtility::RectGeomCellPos(Int_t ism, Float_t xpad, Float_t ypad, Float_t &xpos, Float_t &ypos)
 150 {
 151   // If the xpad and ypad inputs are float, then 0.5 is added to it
 152   // to find the layer which is shifted.
 153   // This routine finds the cell eta,phi for the new PMD rectangular
 154   // geometry in ALICE
 155   // Authors : Bedanga Mohanty and Dipak Mishra - 29.4.2003
 156   // modified by B. K. Nnadi for change of coordinate sys
 157   //
 158   // SMA  ---> Supermodule Type A           ( SM - 0)
 159   // SMAR ---> Supermodule Type A ROTATED   ( SM - 1)
 160   // SMB  ---> Supermodule Type B           ( SM - 2)
 161   // SMBR ---> Supermodule Type B ROTATED   ( SM - 3)
 162   //
 163   // ism   : Serial Module number from 0 to 23 for each plane
 164
 165   // Corner positions (x,y) of the 24 unit moudles in ALICE PMD
 166
 167   double xcorner[24] =
 168     {
 169       74.8833,  53.0045, 31.1255,    //Type-A
 170       74.8833,  53.0045, 31.1255,    //Type-A
 171       -74.8833, -53.0044, -31.1255,  //Type-AR
 172       -74.8833, -53.0044, -31.1255,  //Type-AR
 173       8.9165, -33.7471,            //Type-B
 174       8.9165, -33.7471,            //Type-B
 175       8.9165, -33.7471,            //Type-B
 176       -8.9165, 33.7471,            //Type-BR
 177       -8.9165, 33.7471,            //Type-BR
 178       -8.9165, 33.7471,            //Type-BR
 179     };
 180
 181
 182
 183   double ycorner[24] =
 184     {
 185       86.225,  86.225,  86.225,      //Type-A
 186       37.075,  37.075,  37.075,      //Type-A
 187       -86.225, -86.225, -86.225,     //Type-AR
 188       -37.075, -37.075, -37.075,     //Type-AR
 189       86.225,  86.225,               //Type-B
 190       61.075,  61.075,               //Type-B
 191       35.925,  35.925,               //Type-B
 192       -86.225, -86.225,              //Type-BR
 193       -61.075, -61.075,              //Type-BR
 194       -35.925, -35.925               //Type-BR
 195     };
 196
 197
 198   const Float_t kSqroot3    = 1.73205;  // sqrt(3.);
 199   const Float_t kCellRadius = 0.25;
 200
 201   //
 202   //Every even row of cells is shifted and placed
 203   //in geant so this condition
 204   //
 205   Float_t cellRadius = 0.25;
 206   Float_t shift = 0.0;
 207   Int_t iirow = (Int_t) (xpad+0.5);
 208   if(iirow%2 == 0)
 209     {
 210       shift = -cellRadius/2.0;
 211     }
 212   else
 213     {
 214       shift = 0.0;
 215     }
 216
 217   if(ism < 6)
 218     {
 219       ypos = ycorner[ism] - xpad*kCellRadius*2.0 + shift;
 220       xpos = xcorner[ism] - ypad*kSqroot3*kCellRadius;
 221     }
 222   else if(ism >=6 && ism < 12)
 223     {
 224       ypos = ycorner[ism] + xpad*kCellRadius*2.0 + shift;
 225       xpos = xcorner[ism] + ypad*kSqroot3*kCellRadius;
 226     }
 227   else if(ism >= 12 && ism < 18)
 228     {
 229       ypos = ycorner[ism] - xpad*kCellRadius*2.0 + shift;
 230       xpos = xcorner[ism] - ypad*kSqroot3*kCellRadius;
 231     }
 232   else if(ism >= 18 && ism < 24)
 233     {
 234       ypos = ycorner[ism] + xpad*kCellRadius*2.0 + shift;
 235       xpos = xcorner[ism] + ypad*kSqroot3*kCellRadius;
 236     }
 237
 238 }
 239
 240 void AliPMDUtility::SetPxPyPz(Float_t px, Float_t py, Float_t pz)
 241 {
 242   fPx = px;
 243   fPy = py;
 244   fPz = pz;
 245 }
 246
 247 void AliPMDUtility::SetXYZ(Float_t xpos, Float_t ypos, Float_t zpos)
 248 {
 249   fPx = xpos;
 250   fPy = ypos;
 251   fPz = zpos;
 252 }
 253 void AliPMDUtility::CalculateEta()
 254 {
 255   Float_t rpxpy, theta, eta;
 256
 257   rpxpy  = TMath::Sqrt(fPx*fPx + fPy*fPy);
 258   theta  = TMath::ATan2(rpxpy,fPz);
 259   eta    = -TMath::Log(TMath::Tan(0.5*theta));
 260   fTheta = theta;
 261   fEta   = eta;
 262 }
 263 void AliPMDUtility::CalculatePhi()
 264 {
 265   Float_t pybypx, phi = 0., phi1;
 266
 267   if(fPx==0)
 268     {
 269       if(fPy>0) phi = 90.;
 270       if(fPy<0) phi = 270.;
 271     }
 272   if(fPx != 0)
 273     {
 274       pybypx = fPy/fPx;
 275       if(pybypx < 0) pybypx = - pybypx;
 276       phi1 = TMath::ATan(pybypx)*180./3.14159;
 277
 278       if(fPx > 0 && fPy > 0) phi = phi1;        // 1st Quadrant
 279       if(fPx < 0 && fPy > 0) phi = 180 - phi1;  // 2nd Quadrant
 280       if(fPx < 0 && fPy < 0) phi = 180 + phi1;  // 3rd Quadrant
 281       if(fPx > 0 && fPy < 0) phi = 360 - phi1;  // 4th Quadrant
 282
 283     }
 284   phi = phi*3.14159/180.;
 285
 286   fPhi = phi;
 287
 288 }
 289 void AliPMDUtility::CalculateEtaPhi()
 290 {
 291   Float_t rpxpy, theta, eta;
 292   Float_t pybypx, phi = 0., phi1;
 293
 294   rpxpy = TMath::Sqrt(fPx*fPx + fPy*fPy);
 295   theta = TMath::ATan2(rpxpy,fPz);
 296   eta   = -TMath::Log(TMath::Tan(0.5*theta));
 297
 298   if(fPx==0)
 299     {
 300       if(fPy>0) phi = 90.;
 301       if(fPy<0) phi = 270.;
 302     }
 303   if(fPx != 0)
 304     {
 305       pybypx = fPy/fPx;
 306       if(pybypx < 0) pybypx = - pybypx;
 307       phi1 = TMath::ATan(pybypx)*180./3.14159;
 308       if(fPx > 0 && fPy > 0) phi = phi1;        // 1st Quadrant
 309       if(fPx < 0 && fPy > 0) phi = 180 - phi1;  // 2nd Quadrant
 310       if(fPx < 0 && fPy < 0) phi = 180 + phi1;  // 3rd Quadrant
 311       if(fPx > 0 && fPy < 0) phi = 360 - phi1;  // 4th Quadrant
 312
 313     }
 314   phi = phi*3.14159/180.;
 315
 316   fTheta = theta;
 317   fEta   = eta;
 318   fPhi   = phi;
 319 }
 320 Float_t AliPMDUtility::GetTheta() const
 321 {
 322   return fTheta;
 323 }
 324 Float_t AliPMDUtility::GetEta() const
 325 {
 326   return fEta;
 327 }
 328 Float_t AliPMDUtility::GetPhi() const
 329 {
 330   return fPhi;
 331 }
 332