TOF/AliTOFGeometry.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.18  2007/02/19 18:55:26  decaro
  19 Added getter methods for volume path (for Event Display)
  20
  21 Revision 1.17.1  2006/12/15
  22          Added method DetToStripRF(...) to get
  23          a pad corner coordinates in its strip reference frame
  24          (A.De Caro, M.Di Stefano)
  25 Revision 1.17  2006/08/22 13:30:02  arcelli
  26 removal of effective c++ warnings (C.Zampolli)
  27
  28 Revision 1.16  2006/04/20 22:30:50  hristov
  29 Coding conventions (Annalisa)
  30
  31 Revision 1.15  2006/04/16 22:29:05  hristov
  32 Coding conventions (Annalisa)
  33
  34 Revision 1.14  2006/04/05 08:35:38  hristov
  35 Coding conventions (S.Arcelli, C.Zampolli)
  36
  37 Revision 1.13  2006/03/12 14:37:54  arcelli
  38  Changes for TOF Reconstruction using TGeo
  39
  40 Revision 1.12  2006/02/28 10:38:00  decaro
  41 AliTOFGeometry::fAngles, AliTOFGeometry::fHeights, AliTOFGeometry::fDistances arrays: dimension definition in the right location
  42
  43 Revision 1.11  2005/12/15 14:17:29  decaro
  44 Correction of some parameter values
  45
  46 Revision 1.10  2005/12/15 08:55:32  decaro
  47 New TOF geometry description (V5) -G. Cara Romeo and A. De Caro
  48
  49 Revision 1.9.1  2005/07/19 A. De Caro
  50         Created daughter-classes AliTOFGeometryV4 and AliTOFGeometryV5
  51         => moved global methods IsInsideThePad, DistanceToPad,
  52         GetPlate, GetSector, GetStrip, GetPadX, GetPadZ,
  53         GetX, GetY, GetZ, GetPadDx, GetPadDy and GetPadDz
  54         in daughter-classes
  55
  56 Revision 1.9  2005/10/20 12:41:35  hristov
  57 Implementation of parallel tracking. It is not the default version, one can use it passing option MI from AliReconstruction to TOF (M.Ivanov)
  58
  59 Revision 1.8  2004/11/29 08:28:01  decaro
  60 Introduction of a new TOF constant (i.e. TDC bin width)
  61
  62 Revision 1.7  2004/11/05 07:20:08  decaro
  63 TOF library splitting and conversion of some printout messages in AliLog schema (T.Kuhr)
  64
  65 Revision 1.6  2004/06/15 15:27:59  decaro
  66 TOF raw data: preliminary implementation and style changes
  67
  68 Revision 1.5  2004/04/20 14:37:22  hristov
  69 Using TMath::Abs instead of fabs, arrays of variable size created/deleted correctly (HP,Sun)
  70
  71 Revision 1.4  2004/04/13 09:42:51  decaro
  72 Track reconstruction code for TOF: updating
  73
  74 Revision 1.3  2003/12/29 18:40:39  hristov
  75 Copy/paste error corrected
  76
  77 Revision 1.2  2003/12/29 17:26:01  hristov
  78 Using enum to initaialize static ints in the header file, the initialization of static floats moved to the implementation file
  79
  80 Revision 1.1  2003/12/29 15:18:03  decaro
  81 TOF geometry updating (addition of AliTOFGeometry)
  82
  83 Revision 0.05  2004/6/11 A.De Caro
  84         Implement Global method NpadXStrip
  85         Insert four float constants (originally  in AliTOF class)
  86 Revision 0.04  2004/4/05 S.Arcelli
  87         Implement Global methods IsInsideThePad
  88                                   DistanceToPad
  89 Revision 0.03  2003/12/14 S.Arcelli
  90         Set Phi range [-180,180]->[0,360]
  91 Revision 0.02  2003/12/10 S.Arcelli:
  92         Implement Global methods GetPos & GetDetID
  93 Revision 0.01  2003/12/04 S.Arcelli
  94 */
  95
  96 ///////////////////////////////////////////////////////////////////////////////
  97 //                                                                           //
  98 //  TOF Geometry class                                                       //
  99 //                                                                           //
 100 ///////////////////////////////////////////////////////////////////////////////
 101
 102 #include "TGeoManager.h"
 103 #include "AliTOFGeometry.h"
 104 #include "AliLog.h"
 105 #include "AliConst.h"
 106
 107 extern TGeoManager *gGeoManager;
 108
 109 ClassImp(AliTOFGeometry)
 110
 111 const Float_t AliTOFGeometry::fgkZlenA    = 370.6*2.; // length (cm) of the A module
 112 const Float_t AliTOFGeometry::fgkZlenB    = 146.5;    // length (cm) of the B module
 113 const Float_t AliTOFGeometry::fgkZlenC    = 170.45;   // length (cm) of the C module
 114 const Float_t AliTOFGeometry::fgkMaxhZtof = 370.6;    // Max half z-size of TOF (cm)
 115
 116 const Float_t AliTOFGeometry::fgkxTOF     = 371.-0.01;// Inner radius of the TOF for Reconstruction (cm)
 117 const Float_t AliTOFGeometry::fgkRmin     = 370.-0.01;// Inner radius of the TOF (cm)
 118 const Float_t AliTOFGeometry::fgkRmax     = 399.-0.01;// Outer radius of the TOF (cm)
 119
 120 const Int_t AliTOFGeometry::fgkTimeDiff   = 25000;  // Min signal separation (ps)
 121 const Float_t AliTOFGeometry::fgkXPad     = 2.5;    // Pad size in the x direction (cm)
 122 const Float_t AliTOFGeometry::fgkZPad     = 3.5;    // Pad size in the z direction (cm)
 123
 124 const Float_t AliTOFGeometry::fgkStripLength = 122.;// Strip Length (rho X phi direction) (cm)
 125
 126 const Float_t AliTOFGeometry::fgkSigmaForTail1= 2.; //Sig1 for simulation of TDC tails
 127 const Float_t AliTOFGeometry::fgkSigmaForTail2= 0.5;//Sig2 for simulation of TDC tails
 128
 129 const Float_t AliTOFGeometry::fgkPhiSec= 20;//sector Phi width (deg)
 130
 131 const Float_t AliTOFGeometry::fgkTdcBin = 24.4;     // time-of-flight bin width [ps]
 132 const Float_t AliTOFGeometry::fgkToTBin = 48.8;     // time-over-threshold  bin width [ps]
 133
 134 const Float_t AliTOFGeometry::fgkAngles[kNPlates][kMaxNstrip] ={
 135     { 43.99,  43.20,  42.40,  41.59,  40.77,  39.94,  39.11,  38.25,  37.40,  36.53,
 136       35.65,  34.76,  33.87,  32.96,  32.05,  31.13,  30.19,  29.24,  12.33,  0.00},
 137
 138     { 27.26,  26.28,  25.30,  24.31,  23.31,  22.31,  21.30,  20.29,  19.26,  18.24,
 139       17.20,  16.16,  15.11,  14.05,  13.00,  11.93,  10.87,   9.80,   8.74,  0.00},
 140
 141     {  0.00,   6.30,   5.31,   4.25,   3.19,   2.12,   1.06,   0.00,  -1.06,  -2.12,
 142       -3.19,  -4.25,  -5.31,  -6.30,   0.00,   0.00,   0.00,   0.00,   0.00,  0.00},
 143
 144     { -8.74,  -9.80, -10.87, -11.93, -13.00, -14.05, -15.11, -16.16, -17.20, -18.24,
 145      -19.26, -20.29, -21.30, -22.31, -23.31, -24.31, -25.30, -26.28, -27.26,  0.00},
 146
 147     {-12.33, -29.24, -30.19, -31.13, -32.05, -32.96, -33.87, -34.76, -35.65, -36.53,
 148      -37.40, -38.25, -39.11, -39.94, -40.77, -41.59, -42.40, -43.20, -43.99,  0.00}
 149   };
 150 const Float_t AliTOFGeometry::fgkHeights[kNPlates][kMaxNstrip]= {
 151     {-8.2,  -7.5,  -8.2,  -7.7,  -8.1,  -7.6,  -7.7,  -7.7,  -7.7,  -7.7,
 152      -7.5,  -7.2,  -7.3,  -7.5,  -7.6,  -7.8,  -8.3,  -9.3,  -3.1,   0.0},
 153
 154     {-7.9,  -8.1,  -8.5,  -9.0, -10.1,  -3.9,  -5.9,  -7.7, -10.1,  -3.6,
 155      -5.8,  -8.0, -10.4,  -4.4,  -7.2, -10.2,  -4.6,  -7.4, -10.4,   0.0},
 156
 157     {-2.5, -10.4,  -5.0,  -9.9,  -4.8,  -9.9,  -4.7, -10.2,  -4.7,  -9.9,
 158      -4.8,  -9.9,  -5.0, -10.4,  -2.5,   0.0,   0.0,   0.0,   0.0,   0.0},
 159
 160     {-10.4, -7.4,  -4.6, -10.2,  -7.2,  -4.4, -10.4,  -8.0,  -5.8,  -3.6,
 161      -10.1,  -7.7, -5.9,  -3.9, -10.1,  -9.0,  -8.5,  -8.1,  -7.9,   0.0},
 162
 163     { -3.1,  -9.3, -8.3,  -7.8,  -7.6,  -7.5,  -7.3,  -7.2,  -7.5,  -7.7,
 164       -7.7,  -7.7, -7.7,  -7.6,  -8.1,  -7.7,  -8.2,  -7.5,  -8.2,   0.0}
 165   };
 166
 167
 168 const Float_t AliTOFGeometry::fgkDistances[kNPlates][kMaxNstrip]= {
 169     { 364.1,  354.9,  344.5,  335.4,  325.5,  316.6,  307.2,  298.0,  288.9,  280.0,
 170       271.3,  262.7,  254.0,  244.8,  236.1,  227.7,  219.1,  210.3,  205.7,    0.0},
 171
 172     { 194.2,  186.1,  177.9,  169.8,  161.5,  156.3,  147.8,  139.4,  130.9,  125.6,
 173       117.3,  109.2,  101.1,   95.3,   87.1,   79.2,   73.0,   65.1,   57.6,    0.0},
 174
 175     {  49.5,   41.3,   35.3,   27.8,   21.2,   13.9,    7.0,    0.0,   -7.0,  -13.9,
 176       -21.2,  -27.8,  -35.3,  -41.3,  -49.5,    0.0,    0.0,    0.0,    0.0,    0.0},
 177
 178     { -57.6,  -65.1,  -73.0,  -79.2,  -87.1,  -95.3, -101.1, -109.2, -117.3, -125.6,
 179      -130.9, -139.4, -147.8, -156.3, -161.5, -169.8, -177.9, -186.1, -194.2,    0.0},
 180
 181     {-205.7, -210.3, -219.1, -227.7, -236.1, -244.8, -254.0, -262.7, -271.3, -280.0,
 182      -288.9, -298.0, -307.2, -316.6, -325.5, -335.4, -344.5, -354.9, -364.1,    0.0}
 183   };
 184 //_____________________________________________________________________________
 185 AliTOFGeometry::AliTOFGeometry():
 186   fHoles(0)
 187 {
 188   //
 189   // AliTOFGeometry default constructor
 190   //
 191
 192 }
 193
 194 //_____________________________________________________________________________
 195 AliTOFGeometry::~AliTOFGeometry()
 196 {
 197   //
 198   // AliTOFGeometry destructor
 199   //
 200 }
 201 //_____________________________________________________________________________
 202 void AliTOFGeometry::ImportGeometry(){
 203   TGeoManager::Import("geometry.root");
 204 }
 205 //_____________________________________________________________________________
 206 void AliTOFGeometry::GetPosPar(Int_t *det, Float_t *pos) const
 207 {
 208 //
 209 // Returns space point coor (x,y,z) (cm)  for Detector
 210 // Indices  (iSect,iPlate,iStrip,iPadX,iPadZ)
 211 //
 212
 213   pos[0]=GetX(det);
 214   pos[1]=GetY(det);
 215   pos[2]=GetZ(det);
 216
 217 }
 218 //_____________________________________________________________________________
 219 void AliTOFGeometry::GetDetID( Float_t *pos, Int_t *det) const
 220 {
 221  //
 222  // Returns Detector Indices (iSect,iPlate,iStrip,iPadX,iPadZ)
 223  // space point coor (x,y,z) (cm)
 224
 225
 226   det[0]=GetSector(pos);
 227   det[1]=GetPlate(pos);
 228   det[2]=GetStrip(pos);
 229   det[3]=GetPadZ(pos);
 230   det[4]=GetPadX(pos);
 231
 232 }
 233 //_____________________________________________________________________________
 234
 235 void AliTOFGeometry::DetToStripRF(Int_t nPadX, Int_t nPadZ, Float_t &x,  Float_t &z) const
 236 {
 237   //
 238   // Returns the local coordinates (x, z) in strip reference frame
 239   // for the bottom corner of the pad number (nPadX, nPadZ)
 240   //
 241   /*
 242   const Float_t xCenterStrip = kNpadX * fgkXPad / 2.;
 243   const Float_t zCenterStrip = kNpadZ * fgkZPad / 2.;
 244
 245   const Float_t xCenterPad = nPadX*fgkXPad + fgkXPad / 2.;
 246   const Float_t zCenterPad = nPadZ*fgkZPad + fgkZPad / 2.;
 247
 248   x = xCenterPad - xCenterStrip;
 249   z = zCenterPad - zCenterStrip;
 250   */
 251
 252
 253   x = (nPadX - kNpadX*0.5) * fgkXPad;
 254   z = (nPadZ - kNpadZ*0.5) * fgkZPad;
 255
 256
 257 }
 258 //_____________________________________________________________________________
 259 Float_t AliTOFGeometry::DistanceToPadPar(Int_t *det, Float_t *pos, Float_t *dist3d) const
 260 {
 261 //
 262 // Returns distance of  space point with coor pos (x,y,z) (cm) wrt
 263 // pad with Detector Indices idet (iSect,iPlate,iStrip,iPadX,iPadZ)
 264 //
 265
 266   //Transform pos into Sector Frame
 267
 268   Float_t x = pos[0];
 269   Float_t y = pos[1];
 270   Float_t z = pos[2];
 271
 272   Float_t radius = TMath::Sqrt(x*x+y*y);
 273   //Float_t phi=TMath::ATan(y/x);
 274   //if(phi<0) phi = k2PI+phi; //2.*TMath::Pi()+phi;
 275   Float_t phi = TMath::Pi()+TMath::ATan2(-y,-x);
 276   //  Get the local angle in the sector philoc
 277   Float_t angle   = phi*kRaddeg-( Int_t (kRaddeg*phi/fgkPhiSec) + 0.5)*fgkPhiSec;
 278   Float_t xs = radius*TMath::Cos(angle/kRaddeg);
 279   Float_t ys = radius*TMath::Sin(angle/kRaddeg);
 280   Float_t zs = z;
 281
 282   // Do the same for the selected pad
 283
 284   Float_t g[3];
 285   GetPosPar(det,g);
 286
 287   Float_t padRadius = TMath::Sqrt(g[0]*g[0]+g[1]*g[1]);
 288   //Float_t padPhi = TMath::ATan(g[1]/g[0]);
 289   //if(padPhi<0) padPhi = k2Pi + padPhi;
 290   Float_t padPhi = TMath::Pi()+TMath::ATan2(-g[1],-g[0]);
 291
 292   //  Get the local angle in the sector philoc
 293   Float_t padAngle = padPhi*kRaddeg-( Int_t (padPhi*kRaddeg/fgkPhiSec)+ 0.5) * fgkPhiSec;
 294   Float_t padxs = padRadius*TMath::Cos(padAngle/kRaddeg);
 295   Float_t padys = padRadius*TMath::Sin(padAngle/kRaddeg);
 296   Float_t padzs = g[2];
 297
 298   //Now move to local pad coordinate frame. Translate:
 299
 300   Float_t xt = xs-padxs;
 301   Float_t yt = ys-padys;
 302   Float_t zt = zs-padzs;
 303   //Now Rotate:
 304
 305   Float_t alpha = GetAngles(det[1],det[2]);
 306   Float_t xr =  xt*TMath::Cos(alpha/kRaddeg)+zt*TMath::Sin(alpha/kRaddeg);
 307   Float_t yr =  yt;
 308   Float_t zr = -xt*TMath::Sin(alpha/kRaddeg)+zt*TMath::Cos(alpha/kRaddeg);
 309
 310   Float_t dist = TMath::Sqrt(xr*xr+yr*yr+zr*zr);
 311
 312   if (dist3d){
 313     dist3d[0] = xr;
 314     dist3d[1] = yr;
 315     dist3d[2] = zr;
 316   }
 317
 318   return dist;
 319
 320 }
 321 //_____________________________________________________________________________
 322 Bool_t AliTOFGeometry::IsInsideThePadPar(Int_t *det, Float_t *pos) const
 323 {
 324 //
 325 // Returns true if space point with coor pos (x,y,z) (cm) falls
 326 // inside pad with Detector Indices idet (iSect,iPlate,iStrip,iPadX,iPadZ)
 327 //
 328
 329   Bool_t isInside=false;
 330
 331   /*
 332   const Float_t khhony    = 1.0          ; // heigth of HONY  Layer
 333   const Float_t khpcby    = 0.08         ; // heigth of PCB   Layer
 334   const Float_t khrgly    = 0.055        ; // heigth of RED GLASS  Layer
 335   const Float_t khglfy    = 0.285        ; // heigth of GLASS+FISHLINE  Layer
 336   const Float_t khcpcby   = 0.16         ; // heigth of PCB  Central Layer
 337   //const Float_t kwcpcbz   = 12.4         ; // z dimension of PCB  Central Layer
 338   const Float_t khstripy = 2.*khhony+2.*khpcby+4.*khrgly+2.*khglfy+khcpcby;//3.11
 339   //const Float_t kwstripz = kwcpcbz;
 340   //const Float_t klstripx = fgkStripLength;
 341   */
 342
 343   const Float_t kPadDepth = 0.5;//0.05;//0.11;//0.16;//          // heigth of Sensitive Layer
 344
 345   //Transform pos into Sector Frame
 346
 347   Float_t x = pos[0];
 348   Float_t y = pos[1];
 349   Float_t z = pos[2];
 350
 351   Float_t radius = TMath::Sqrt(x*x+y*y);
 352   Float_t phi = TMath::Pi()+TMath::ATan2(-y,-x);
 353
 354   //  Get the local angle in the sector philoc
 355   Float_t angle = phi*kRaddeg-( Int_t (kRaddeg*phi/fgkPhiSec) + 0.5) *fgkPhiSec;
 356   Float_t xs = radius*TMath::Cos(angle/kRaddeg);
 357   Float_t ys = radius*TMath::Sin(angle/kRaddeg);
 358   Float_t zs = z;
 359
 360   // Do the same for the selected pad
 361
 362   Float_t g[3];
 363   GetPosPar(det,g);
 364
 365   Float_t padRadius = TMath::Sqrt(g[0]*g[0]+g[1]*g[1]);
 366   Float_t padPhi = TMath::Pi()+TMath::ATan2(-g[1],-g[0]);
 367
 368   //  Get the local angle in the sector philoc
 369   Float_t padAngle = padPhi*kRaddeg-( Int_t (padPhi*kRaddeg/fgkPhiSec)+ 0.5) * fgkPhiSec;
 370   Float_t padxs = padRadius*TMath::Cos(padAngle/kRaddeg);
 371   Float_t padys = padRadius*TMath::Sin(padAngle/kRaddeg);
 372   Float_t padzs = g[2];
 373
 374   //Now move to local pad coordinate frame. Translate:
 375
 376   Float_t xt = xs-padxs;
 377   Float_t yt = ys-padys;
 378   Float_t zt = zs-padzs;
 379
 380   //Now Rotate:
 381
 382   Float_t alpha = GetAngles(det[1],det[2]);
 383   Float_t xr =  xt*TMath::Cos(alpha/kRaddeg)+zt*TMath::Sin(alpha/kRaddeg);
 384   Float_t yr =  yt;
 385   Float_t zr = -xt*TMath::Sin(alpha/kRaddeg)+zt*TMath::Cos(alpha/kRaddeg);
 386
 387   if(TMath::Abs(xr)<=kPadDepth*0.5 && TMath::Abs(yr)<= (fgkXPad*0.5) && TMath::Abs(zr)<= (fgkZPad*0.5))
 388     isInside=true;
 389   return isInside;
 390
 391 }
 392 //_____________________________________________________________________________
 393 Bool_t AliTOFGeometry::IsInsideThePad(TGeoHMatrix mat, Float_t *pos, Float_t *dist3d) const
 394 {
 395 //
 396 // Returns true if space point with coor pos (x,y,z) (cm) falls
 397 // inside pad with Detector Indices idet (iSect,iPlate,iStrip,iPadX,iPadZ)
 398 //
 399
 400   const Float_t kPadDepth = 0.5;      // heigth of Sensitive Layer
 401   Double_t vecg[3];
 402   vecg[0]=pos[0];
 403   vecg[1]=pos[1];
 404   vecg[2]=pos[2];
 405   Double_t veclr[3]={-1.,-1.,-1.};
 406   Double_t vecl[3]={-1.,-1.,-1.};
 407   mat.MasterToLocal(vecg,veclr);
 408   vecl[0]=veclr[1];
 409   vecl[1]=veclr[0];
 410   //take into account reflections
 411   vecl[2]=-veclr[2];
 412
 413   Float_t xr = vecl[0];
 414   Float_t yr = vecl[1];
 415   Float_t zr = vecl[2];
 416
 417   if (dist3d){
 418     dist3d[0] = vecl[0];
 419     dist3d[1] = vecl[1];
 420     dist3d[2] = vecl[2];
 421   }
 422
 423   Bool_t isInside=false;
 424   if(TMath::Abs(xr)<= kPadDepth*0.5 && TMath::Abs(yr)<= (fgkXPad*0.5) && TMath::Abs(zr)<= (fgkZPad*0.5))
 425     isInside=true;
 426   return isInside;
 427
 428 }
 429 //_____________________________________________________________________________
 430 void AliTOFGeometry::GetVolumePath(Int_t *ind, Char_t *path ) {
 431   //--------------------------------------------------------------------
 432   // This function returns the colume path of a given pad
 433   //--------------------------------------------------------------------
 434   Int_t sector = ind[0];
 435   Char_t  string1[100];
 436   Char_t  string2[100];
 437   Char_t  string3[100];
 438
 439   Int_t icopy=-1;
 440   icopy=sector;
 441
 442   sprintf(string1,"/ALIC_1/B077_1/BSEGMO%i_1/BTOF%i_1",icopy,icopy);
 443
 444   Int_t iplate=ind[1];
 445   Int_t istrip=ind[2];
 446   if( iplate==0) icopy=istrip;
 447   if( iplate==1) icopy=istrip+NStripC();
 448   if( iplate==2) icopy=istrip+NStripC()+NStripB();
 449   if( iplate==3) icopy=istrip+NStripC()+NStripB()+NStripA();
 450   if( iplate==4) icopy=istrip+NStripC()+2*NStripB()+NStripA();
 451   icopy++;
 452   sprintf(string2,"FTOA_0/FLTA_0/FSTR_%i",icopy);
 453   if(fHoles && (sector==11 || sector==12)){
 454     if(iplate<2)  sprintf(string2,"FTOB_0/FLTB_0/FSTR_%i",icopy);
 455     if(iplate>2)  sprintf(string2,"FTOC_0/FLTC_0/FSTR_%i",icopy);
 456   }
 457
 458   Int_t padz = ind[3]+1;
 459   Int_t padx = ind[4]+1;
 460   sprintf(string3,"FPCB_1/FSEN_1/FSEZ_%i/FPAD_%i",padz,padx);
 461   sprintf(path,"%s/%s/%s",string1,string2,string3);
 462
 463 }
 464 //_____________________________________________________________________________
 465 void AliTOFGeometry::GetVolumePath(Int_t sector, Char_t *path ){
 466   //--------------------------------------------------------------------
 467   // This function returns the colume path of a given sector
 468   //--------------------------------------------------------------------
 469
 470   Char_t string[100];
 471
 472   Int_t icopy = sector;
 473
 474   sprintf(string,"/ALIC_1/B077_1/BSEGMO%i_1/BTOF%i_1",icopy,icopy);
 475   sprintf(path,"%s",string);
 476
 477 }
 478 //_____________________________________________________________________________
 479 void AliTOFGeometry::GetVolumePath(Int_t sector, Int_t plate, Int_t strip, Char_t *path ) {
 480   //--------------------------------------------------------------------
 481   // This function returns the colume path of a given strip
 482   //--------------------------------------------------------------------
 483
 484   Char_t string1[100];
 485   Char_t string2[100];
 486   Char_t string3[100];
 487
 488   Int_t icopy = sector;
 489
 490   sprintf(string1,"/ALIC_1/B077_1/BSEGMO%i_1/BTOF%i_1",icopy,icopy);
 491
 492   if(plate==0) icopy=strip;
 493   if(plate==1) icopy=strip+NStripC();
 494   if(plate==2) icopy=strip+NStripC()+NStripB();
 495   if(plate==3) icopy=strip+NStripC()+NStripB()+NStripA();
 496   if(plate==4) icopy=strip+NStripC()+2*NStripB()+NStripA();
 497   icopy++;
 498   sprintf(string2,"FTOA_0/FLTA_0/FSTR_%i",icopy);
 499   if(fHoles && (sector==11 || sector==12)) {
 500     if(plate<2)  sprintf(string2,"FTOB_0/FLTB_0/FSTR_%i",icopy);
 501     if(plate>2)  sprintf(string2,"FTOC_0/FLTC_0/FSTR_%i",icopy);
 502   }
 503
 504   sprintf(string3,"FPCB_1/FSEN_1");
 505   sprintf(path,"%s/%s/%s",string1,string2,string3);
 506
 507 }
 508 //_____________________________________________________________________________
 509 void AliTOFGeometry::GetPos(Int_t *det, Float_t *pos)
 510 {
 511 //
 512 // Returns space point coor (x,y,z) (cm)  for Detector
 513 // Indices  (iSect,iPlate,iStrip,iPadX,iPadZ)
 514 //
 515   Char_t path[100];
 516   GetVolumePath(det,path );
 517   if (!gGeoManager) {
 518     printf("ERROR: no TGeo\n");
 519   }
 520   gGeoManager->cd(path);
 521   TGeoHMatrix global;
 522   global = *gGeoManager->GetCurrentMatrix();
 523   const Double_t *tr = global.GetTranslation();
 524
 525   pos[0]=tr[0];
 526   pos[1]=tr[1];
 527   pos[2]=tr[2];
 528 }
 529 //_____________________________________________________________________________
 530 Int_t AliTOFGeometry::GetPlate(Float_t *pos) const
 531 {
 532   //
 533   // Returns the Plate index
 534   //
 535   const Float_t kInterCentrModBorder1 = 49.5;
 536   const Float_t kInterCentrModBorder2 = 57.5;
 537   const Float_t kExterInterModBorder1 = 196.0;
 538   const Float_t kExterInterModBorder2 = 203.5;
 539
 540   const Float_t kLengthExInModBorder  = 4.7;
 541   const Float_t kLengthInCeModBorder  = 7.0;
 542
 543   //const Float_t khAlWall = 0.1;
 544   const Float_t kModuleWallThickness = 0.3;
 545   //const Float_t kHoneycombLayerThickness = 1.5;
 546
 547   Int_t iPlate=-1;
 548
 549   Float_t posLocal[3];
 550   for (Int_t ii=0; ii<3; ii++) posLocal[ii] = pos[ii];
 551
 552   Int_t isector = GetSector(posLocal);
 553   if(isector == -1){
 554     //AliError("Detector Index could not be determined");
 555     return iPlate;
 556   }
 557
 558   // ALICE reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
 559   Double_t angles[6] =
 560     {90., 90.+(isector+0.5)*fgkPhiSec,
 561       0., 0.,
 562      90., (isector+0.5)*fgkPhiSec
 563     };
 564   Rotation(posLocal,angles);
 565
 566   Float_t step[3] = {0., 0., (fgkRmax+fgkRmin)*0.5};
 567   Translation(posLocal,step);
 568
 569   // B071/B074/B075 = BTO1/2/3 reference frame -> FTOA = FLTA reference frame
 570   angles[0] = 90.;
 571   angles[1] =  0.;
 572   angles[2] =  0.;
 573   angles[3] =  0.;
 574   angles[4] = 90.;
 575   angles[5] =270.;
 576
 577   Rotation(posLocal,angles);
 578
 579   Float_t yLocal = posLocal[1];
 580   Float_t zLocal = posLocal[2];
 581
 582   Float_t deltaRhoLoc  = (fgkRmax-fgkRmin)*0.5 - kModuleWallThickness + yLocal;
 583   Float_t deltaZetaLoc = TMath::Abs(zLocal);
 584
 585   Float_t deltaRHOmax = 0.;
 586
 587   if (TMath::Abs(zLocal)>=kExterInterModBorder1 && TMath::Abs(zLocal)<=kExterInterModBorder2)
 588     {
 589       deltaRhoLoc -= kLengthExInModBorder;
 590       deltaZetaLoc = kExterInterModBorder2-deltaZetaLoc;
 591       deltaRHOmax  = (fgkRmax - fgkRmin)*0.5 - kModuleWallThickness - 2.*kLengthExInModBorder; // old 5.35, new 4.8
 592
 593       if (deltaRhoLoc > deltaZetaLoc*deltaRHOmax/(kInterCentrModBorder2-kInterCentrModBorder1)) {
 594         if (zLocal<0) iPlate = 0;
 595         else iPlate = 4;
 596       }
 597       else {
 598         if (zLocal<0) iPlate = 1;
 599         else iPlate = 3;
 600       }
 601     }
 602   else if (TMath::Abs(zLocal)>=kInterCentrModBorder1 && TMath::Abs(zLocal)<=kInterCentrModBorder2)
 603     {
 604       deltaRhoLoc -= kLengthInCeModBorder;
 605       deltaZetaLoc = deltaZetaLoc-kInterCentrModBorder1;
 606       deltaRHOmax = (fgkRmax - fgkRmin)*0.5 - kModuleWallThickness - 2.*kLengthInCeModBorder; // old 0.39, new 0.2
 607
 608       if (deltaRhoLoc>deltaZetaLoc*deltaRHOmax/(kInterCentrModBorder2-kInterCentrModBorder1)) iPlate = 2;
 609       else {
 610         if (zLocal<0) iPlate = 1;
 611         else iPlate = 3;
 612       }
 613     }
 614
 615   if      (zLocal>-fgkZlenA*0.5/*fgkMaxhZtof*/ && zLocal<-kExterInterModBorder2)       iPlate = 0;
 616   else if (zLocal>-kExterInterModBorder1       && zLocal<-kInterCentrModBorder2)       iPlate = 1;
 617   else if (zLocal>-kInterCentrModBorder1       && zLocal< kInterCentrModBorder1)       iPlate = 2;
 618   else if (zLocal> kInterCentrModBorder2       && zLocal< kExterInterModBorder1)       iPlate = 3;
 619   else if (zLocal> kExterInterModBorder2       && zLocal< fgkZlenA*0.5/*fgkMaxhZtof*/) iPlate = 4;
 620
 621   return iPlate;
 622
 623 }
 624
 625 //_____________________________________________________________________________
 626 Int_t AliTOFGeometry::GetSector(Float_t *pos) const
 627 {
 628   //
 629   // Returns the Sector index
 630   //
 631
 632   //const Float_t khAlWall = 0.1;
 633   //const Float_t kModuleWallThickness = 0.3;
 634
 635   Int_t   iSect = -1;
 636
 637   Float_t x = pos[0];
 638   Float_t y = pos[1];
 639   Float_t z = pos[2];
 640
 641   Float_t rho = TMath::Sqrt(x*x + y*y);
 642
 643   //if (!((z>=-fgkMaxhZtof && z<=fgkMaxhZtof) &&
 644   if (!((z>=-fgkZlenA*0.5 && z<=fgkZlenA*0.5) &&
 645         (rho>=(fgkRmin) && rho<=(fgkRmax)))) {
 646     //(rho>=(fgkRmin-0.05)+kModuleWallThickness && rho<=(fgkRmax-0.05)-kModuleWallThickness-khAlWall-kModuleWallThickness))) {
 647     //AliError("Detector Index could not be determined");
 648     return iSect;
 649   }
 650
 651   Float_t phi = TMath::Pi() + TMath::ATan2(-y,-x);
 652
 653   iSect  = (Int_t) (phi*kRaddeg/fgkPhiSec);
 654
 655   return iSect;
 656
 657 }
 658 //_____________________________________________________________________________
 659 Int_t AliTOFGeometry::GetStrip(Float_t *pos) const
 660 {
 661   //
 662   // Returns the Strip index
 663   //
 664   const Float_t khhony    = 1.0          ; // heigth of HONY  Layer
 665   const Float_t khpcby    = 0.08         ; // heigth of PCB   Layer
 666   const Float_t khrgly    = 0.055        ; // heigth of RED GLASS  Layer
 667   const Float_t khglfy    = 0.285        ; // heigth of GLASS+FISHLINE  Layer
 668   const Float_t khcpcby   = 0.16         ; // heigth of PCB  Central Layer
 669   const Float_t kwcpcbz   = 12.4         ; // z dimension of PCB  Central Layer
 670   const Float_t khstripy = 2.*khhony+2.*khpcby+4.*khrgly+2.*khglfy+khcpcby;//3.11
 671   const Float_t kwstripz = kwcpcbz;
 672   const Float_t klstripx = fgkStripLength;
 673
 674   Int_t iStrip=-1;
 675
 676   Float_t posLocal[3];
 677   for (Int_t ii=0; ii<3; ii++) posLocal[ii] = pos[ii];
 678
 679   Int_t isector = GetSector(posLocal);
 680   if(isector == -1){
 681     //AliError("Detector Index could not be determined");
 682     return iStrip;}
 683   Int_t iplate =  GetPlate(posLocal);
 684   if(iplate == -1){
 685     //AliError("Detector Index could not be determined");
 686     return iStrip;}
 687
 688   Int_t nstrips=0;
 689   switch (iplate) {
 690   case 0:
 691     nstrips=kNStripC;
 692     break;
 693   case 4:
 694     nstrips=kNStripC;
 695     break;
 696   case 1:
 697     nstrips=kNStripB;
 698     break;
 699   case 3:
 700     nstrips=kNStripB;
 701     break;
 702   case 2:
 703     nstrips=kNStripA;
 704     break;
 705   }
 706
 707   // ALICE reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
 708   Double_t angles[6] =
 709     {90., 90.+(isector+0.5)*fgkPhiSec,
 710       0., 0.,
 711      90., (isector+0.5)*fgkPhiSec
 712     };
 713   Rotation(posLocal,angles);
 714
 715   Float_t step[3] = {0., 0., (fgkRmax+fgkRmin)*0.5};
 716   Translation(posLocal,step);
 717
 718   // B071/B074/B075 = BTO1/2/3 reference frame -> FTOA = FLTA reference frame
 719   angles[0] = 90.;
 720   angles[1] =  0.;
 721   angles[2] =  0.;
 722   angles[3] =  0.;
 723   angles[4] = 90.;
 724   angles[5] =270.;
 725
 726   Rotation(posLocal,angles);
 727
 728   // FTOA/B/C = FLTA/B/C reference frame -> FSTR reference frame
 729   Int_t totStrip=0;
 730   for (Int_t istrip=0; istrip<nstrips; istrip++){
 731
 732     Float_t posLoc2[3]={posLocal[0],posLocal[1],posLocal[2]};
 733
 734     step[0] = 0.;
 735     step[1] = GetHeights(iplate,istrip);
 736     step[2] = -GetDistances(iplate,istrip);
 737     Translation(posLoc2,step);
 738
 739     if      (GetAngles(iplate,istrip) >0.) {
 740       angles[0] = 90.;
 741       angles[1] =  0.;
 742       angles[2] = 90.+GetAngles(iplate,istrip);
 743       angles[3] = 90.;
 744       angles[4] = GetAngles(iplate,istrip);
 745       angles[5] = 90.;
 746     }
 747     else if (GetAngles(iplate,istrip)==0.) {
 748       angles[0] = 90.;
 749       angles[1] =  0.;
 750       angles[2] = 90.;
 751       angles[3] = 90.;
 752       angles[4] =  0;
 753       angles[5] =  0.;
 754     }
 755     else if (GetAngles(iplate,istrip) <0.) {
 756       angles[0] = 90.;
 757       angles[1] =  0.;
 758       angles[2] = 90.+GetAngles(iplate,istrip);
 759       angles[3] = 90.;
 760       angles[4] =-GetAngles(iplate,istrip);
 761       angles[5] = 270.;
 762     }
 763     Rotation(posLoc2,angles);
 764
 765     if ((TMath::Abs(posLoc2[0])<=klstripx*0.5) &&
 766         (TMath::Abs(posLoc2[1])<=khstripy*0.5) &&
 767         (TMath::Abs(posLoc2[2])<=kwstripz*0.5)) {
 768       iStrip = istrip;
 769       totStrip++;
 770       for (Int_t jj=0; jj<3; jj++) posLocal[jj]=posLoc2[jj];
 771       //AliInfo(Form(" posLocal[0] = %f, posLocal[1] = %f, posLocal[2] = %f ", posLocal[0],posLocal[1],posLocal[2]));
 772
 773       //AliInfo(Form(" GetAngles(%1i,%2i) = %f, pos[0] = %f, pos[1] = %f, pos[2] = %f", iplate, istrip, GetAngles(iplate,istrip), pos[0], pos[1], pos[2]));
 774       break;
 775     }
 776
 777     if (totStrip>1) AliInfo(Form("total strip number found %2i",totStrip));
 778
 779   }
 780
 781   return iStrip;
 782
 783 }
 784 //_____________________________________________________________________________
 785 Int_t AliTOFGeometry::GetPadZ(Float_t *pos) const
 786 {
 787   //
 788   // Returns the Pad index along Z
 789   //
 790   //const Float_t klsensmx = kNpadX*fgkXPad;  // length of Sensitive Layer
 791   //const Float_t khsensmy = 0.05;//0.11;//0.16;// heigth of Sensitive Layer
 792   //const Float_t kwsensmz = kNpadZ*fgkZPad;  // width of Sensitive Layer
 793
 794   Int_t iPadZ = -1;
 795
 796   Float_t posLocal[3];
 797   for (Int_t ii=0; ii<3; ii++) posLocal[ii] = pos[ii];
 798
 799   Int_t isector = GetSector(posLocal);
 800   if(isector == -1){
 801     //AliError("Detector Index could not be determined");
 802     return iPadZ;}
 803   Int_t iplate =  GetPlate(posLocal);
 804   if(iplate == -1){
 805     //AliError("Detector Index could not be determined");
 806     return iPadZ;}
 807   Int_t istrip =  GetStrip(posLocal);
 808   if(istrip == -1){
 809     //AliError("Detector Index could not be determined");
 810     return iPadZ;}
 811
 812   // ALICE reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
 813   Double_t angles[6] =
 814     {90., 90.+(isector+0.5)*fgkPhiSec,
 815       0., 0.,
 816      90., (isector+0.5)*fgkPhiSec
 817     };
 818   Rotation(posLocal,angles);
 819
 820   Float_t step[3] = {0., 0., (fgkRmax+fgkRmin)*0.5};
 821   Translation(posLocal,step);
 822
 823   // B071/B074/B075 = BTO1/2/3 reference frame -> FTOA = FLTA reference frame
 824   angles[0] = 90.;
 825   angles[1] =  0.;
 826   angles[2] =  0.;
 827   angles[3] =  0.;
 828   angles[4] = 90.;
 829   angles[5] =270.;
 830
 831   Rotation(posLocal,angles);
 832
 833   // FTOA/B/C = FLTA/B/C reference frame -> FSTR reference frame
 834   step[0] = 0.;
 835   step[1] = GetHeights(iplate,istrip);
 836   step[2] = -GetDistances(iplate,istrip);
 837   Translation(posLocal,step);
 838
 839   if      (GetAngles(iplate,istrip) >0.) {
 840     angles[0] = 90.;
 841     angles[1] =  0.;
 842     angles[2] = 90.+GetAngles(iplate,istrip);
 843     angles[3] = 90.;
 844     angles[4] = GetAngles(iplate,istrip);
 845     angles[5] = 90.;
 846   }
 847   else if (GetAngles(iplate,istrip)==0.) {
 848     angles[0] = 90.;
 849     angles[1] =  0.;
 850     angles[2] = 90.;
 851     angles[3] = 90.;
 852     angles[4] =  0;
 853     angles[5] =  0.;
 854   }
 855   else if (GetAngles(iplate,istrip) <0.) {
 856     angles[0] = 90.;
 857     angles[1] =  0.;
 858     angles[2] = 90.+GetAngles(iplate,istrip);
 859     angles[3] = 90.;
 860     angles[4] =-GetAngles(iplate,istrip);
 861     angles[5] = 270.;
 862   }
 863   Rotation(posLocal,angles);
 864
 865   //if (TMath::Abs(posLocal[0])<=klsensmx*0.5 && /*TMath::Abs(posLocal[1])<=khsensmy*0.5+0.005 &&*/ TMath::Abs(posLocal[2])<=kwsensmz*0.5) {
 866   //if (TMath::Abs(posLocal[1])<=khsensmy*0.5) {
 867
 868     step[0] =-0.5*kNpadX*fgkXPad;
 869     step[1] = 0.;
 870     step[2] =-0.5*kNpadZ*fgkZPad;
 871     Translation(posLocal,step);
 872
 873     iPadZ = (Int_t)(posLocal[2]/fgkZPad);
 874     if (iPadZ==kNpadZ) iPadZ--;
 875     else if (iPadZ>kNpadZ) iPadZ=-1;
 876
 877   //}
 878   // else AliError("Detector Index could not be determined");
 879
 880   return iPadZ;
 881
 882 }
 883 //_____________________________________________________________________________
 884 Int_t AliTOFGeometry::GetPadX(Float_t *pos) const
 885 {
 886   //
 887   // Returns the Pad index along X
 888   //
 889   //const Float_t klsensmx = kNpadX*fgkXPad;  // length of Sensitive Layer
 890   //const Float_t khsensmy = 0.05;//0.11;//0.16;// heigth of Sensitive Layer
 891   //const Float_t kwsensmz = kNpadZ*fgkZPad;  // width of Sensitive Layer
 892
 893   Int_t iPadX  = -1;
 894
 895   Float_t posLocal[3];
 896   for (Int_t ii=0; ii<3; ii++) posLocal[ii] = pos[ii];
 897
 898   Int_t isector = GetSector(posLocal);
 899   if(isector == -1){
 900     //AliError("Detector Index could not be determined");
 901     return iPadX;}
 902   Int_t iplate =  GetPlate(posLocal);
 903   if(iplate == -1){
 904     //AliError("Detector Index could not be determined");
 905     return iPadX;}
 906   Int_t istrip =  GetStrip(posLocal);
 907   if(istrip == -1){
 908     //AliError("Detector Index could not be determined");
 909     return iPadX;}
 910
 911   // ALICE reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
 912   Double_t angles[6] =
 913     {90., 90.+(isector+0.5)*fgkPhiSec,
 914       0.,  0.,
 915      90., (isector+0.5)*fgkPhiSec
 916     };
 917   Rotation(posLocal,angles);
 918
 919   Float_t step[3] = {0., 0., (fgkRmax+fgkRmin)*0.5};
 920   Translation(posLocal,step);
 921
 922   // B071/B074/B075 = BTO1/2/3 reference frame -> FTOA/B/C = FLTA/B/C reference frame
 923   angles[0] = 90.;
 924   angles[1] =  0.;
 925   angles[2] =  0.;
 926   angles[3] =  0.;
 927   angles[4] = 90.;
 928   angles[5] =270.;
 929
 930   Rotation(posLocal,angles);
 931
 932   // FTOA/B/C = FLTA/B/C reference frame -> FSTR reference frame
 933   step[0] = 0.;
 934   step[1] = GetHeights(iplate,istrip);
 935   step[2] = -GetDistances(iplate,istrip);
 936   Translation(posLocal,step);
 937
 938   if      (GetAngles(iplate,istrip) >0.) {
 939     angles[0] = 90.;
 940     angles[1] =  0.;
 941     angles[2] = 90.+GetAngles(iplate,istrip);
 942     angles[3] = 90.;
 943     angles[4] = GetAngles(iplate,istrip);
 944     angles[5] = 90.;
 945   }
 946   else if (GetAngles(iplate,istrip)==0.) {
 947     angles[0] = 90.;
 948     angles[1] =  0.;
 949     angles[2] = 90.;
 950     angles[3] = 90.;
 951     angles[4] =  0;
 952     angles[5] =  0.;
 953   }
 954   else if (GetAngles(iplate,istrip) <0.) {
 955     angles[0] = 90.;
 956     angles[1] =  0.;
 957     angles[2] = 90.+GetAngles(iplate,istrip);
 958     angles[3] = 90.;
 959     angles[4] =-GetAngles(iplate,istrip);
 960     angles[5] = 270.;
 961   }
 962   Rotation(posLocal,angles);
 963
 964   //if (TMath::Abs(posLocal[0])<=klsensmx*0.5 && /*TMath::Abs(posLocal[1])<=khsensmy*0.5+0.005 &&*/ TMath::Abs(posLocal[2])<=kwsensmz*0.5) {
 965   //if (TMath::Abs(posLocal[1])<=khsensmy*0.5) {
 966
 967     step[0] =-0.5*kNpadX*fgkXPad;
 968     step[1] = 0.;
 969     step[2] =-0.5*kNpadZ*fgkZPad;
 970     Translation(posLocal,step);
 971
 972     iPadX = (Int_t)(posLocal[0]/fgkXPad);
 973     if (iPadX==kNpadX) iPadX--;
 974     else if (iPadX>kNpadX) iPadX=-1;
 975
 976   //}
 977   //else AliError("Detector Index could not be determined");
 978
 979   return iPadX;
 980
 981 }
 982 //_____________________________________________________________________________
 983 Float_t AliTOFGeometry::GetX(Int_t *det) const
 984 {
 985   //
 986   // Returns X coordinate (cm)
 987   //
 988
 989   Int_t isector = det[0];
 990   Int_t iplate  = det[1];
 991   Int_t istrip  = det[2];
 992   Int_t ipadz   = det[3];
 993   Int_t ipadx   = det[4];
 994
 995   /*
 996   // Find out distance d on the plane wrt median phi:
 997   Float_t d = (ipadx+0.5-kNpadX*0.5)*fgkXPad;
 998
 999   // The radius r in xy plane:
1000   //Float_t r = (fgkRmin+fgkRmax)*0.5-0.01+GetHeights(iplate,istrip)+
1001   //  (ipadz-0.5)*fgkZPad*TMath::Sin(GetAngles(iplate,istrip)/kRaddeg)-0.25; ???
1002   Float_t r = (fgkRmin+fgkRmax)*0.5-0.01+GetHeights(iplate,istrip)+
1003     (ipadz-0.5)*fgkZPad*TMath::Sin(GetAngles(iplate,istrip)/kRaddeg);
1004
1005   // local azimuthal angle in the sector philoc
1006   Float_t philoc  = TMath::ATan(d/r);
1007   //if(philoc<0.) philoc = k2PI + philoc;
1008
1009   // azimuthal angle in the global frame  phi
1010   Float_t phi   = philoc*kRaddeg+(isector+0.5)*fgkPhiSec;
1011
1012   Float_t xCoor = r/TMath::Cos(philoc)*TMath::Cos(phi/kRaddeg);
1013   */
1014
1015   // Pad reference frame -> FSTR reference frame
1016   //  /*
1017   Float_t posLocal[3] = {0., 0., 0.};
1018   Float_t step[3] = {-(ipadx+0.5)*fgkXPad, 0., -(ipadz+0.5)*fgkZPad};
1019   Translation(posLocal,step);
1020
1021   step[0] = kNpadX*0.5*fgkXPad;
1022   step[1] = 0.;
1023   step[2] = kNpadZ*0.5*fgkZPad;
1024   //  */
1025   /*
1026   Float_t posLocal[3] = {(ipadx+0.5)*fgkXPad, 0., (ipadz+0.5)*fgkZPad};
1027   Float_t step[3]= {kNpadX*0.5*fgkXPad, 0., kNpadZ*0.5*fgkZPad};
1028   */
1029   Translation(posLocal,step);
1030
1031   // FSTR reference frame -> FTOA/B/C = FLTA/B/C reference frame
1032   Double_t angles[6];
1033   if      (GetAngles(iplate,istrip) >0.) {
1034     angles[0] = 90.;
1035     angles[1] =  0.;
1036     angles[2] = 90.+GetAngles(iplate,istrip);
1037     angles[3] = 90.;
1038     angles[4] = GetAngles(iplate,istrip);
1039     angles[5] = 90.;
1040   }
1041   else if (GetAngles(iplate,istrip)==0.) {
1042     angles[0] = 90.;
1043     angles[1] =  0.;
1044     angles[2] = 90.;
1045     angles[3] = 90.;
1046     angles[4] =  0;
1047     angles[5] =  0.;
1048   }
1049   else if (GetAngles(iplate,istrip) <0.) {
1050     angles[0] = 90.;
1051     angles[1] =  0.;
1052     angles[2] = 90.+GetAngles(iplate,istrip);
1053     angles[3] = 90.;
1054     angles[4] =-GetAngles(iplate,istrip);
1055     angles[5] = 270.;
1056   }
1057
1058   InverseRotation(posLocal,angles);
1059
1060   step[0] = 0.;
1061   step[1] = -GetHeights(iplate,istrip);
1062   step[2] =  GetDistances(iplate,istrip);
1063   Translation(posLocal,step);
1064
1065   // FTOA = FLTA reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
1066   angles[0] = 90.;
1067   angles[1] =  0.;
1068   angles[2] =  0.;
1069   angles[3] =  0.;
1070   angles[4] = 90.;
1071   angles[5] =270.;
1072
1073   InverseRotation(posLocal,angles);
1074
1075   // B071/B074/B075 = BTO1/2/3 reference frame -> ALICE reference frame
1076   step[0] = 0.;
1077   step[1] = 0.;
1078   step[2] = -((fgkRmax+fgkRmin)*0.5);
1079   Translation(posLocal,step);
1080
1081   angles[0] = 90.;
1082   angles[1] = 90.+(isector+0.5)*fgkPhiSec;
1083   angles[2] = 0.;
1084   angles[3] = 0.;
1085   angles[4] = 90.;
1086   angles[5] = (isector+0.5)*fgkPhiSec;
1087
1088   InverseRotation(posLocal,angles);
1089
1090   Float_t xCoor = posLocal[0];
1091
1092   return xCoor;
1093
1094 }
1095 //_____________________________________________________________________________
1096 Float_t AliTOFGeometry::GetY(Int_t *det) const
1097 {
1098   //
1099   // Returns Y coordinate (cm)
1100   //
1101
1102   Int_t isector = det[0];
1103   Int_t iplate  = det[1];
1104   Int_t istrip  = det[2];
1105   Int_t ipadz   = det[3];
1106   Int_t ipadx   = det[4];
1107
1108   /*
1109   // Find out distance d on the plane wrt median phi:
1110   Float_t d = (ipadx+0.5-kNpadX*0.5)*fgkXPad;
1111
1112   // The radius r in xy plane:
1113   //Float_t r = (fgkRmin+fgkRmax)*0.5-0.01+GetHeights(iplate,istrip)+
1114   //  (ipadz-0.5)*fgkZPad*TMath::Sin(GetAngles(iplate,istrip)/kRaddeg)-0.25; ???
1115   Float_t r = (fgkRmin+fgkRmax)*0.5-0.01+GetHeights(iplate,istrip)+
1116     (ipadz-0.5)*fgkZPad*TMath::Sin(GetAngles(iplate,istrip)/kRaddeg);
1117
1118   // local azimuthal angle in the sector philoc
1119   Float_t philoc = TMath::ATan(d/r);
1120   //if(philoc<0.) philoc = k2PI + philoc;
1121
1122   // azimuthal angle in the global frame  phi
1123   Float_t phi   = philoc*kRaddeg+(isector+0.5)*fgkPhiSec;
1124
1125   Float_t yCoor = r/TMath::Cos(philoc)*TMath::Sin(phi/kRaddeg);
1126   */
1127
1128   // Pad reference frame -> FSTR reference frame
1129   //  /*
1130   Float_t posLocal[3] = {0., 0., 0.};
1131   Float_t step[3] = {-(ipadx+0.5)*fgkXPad, 0., -(ipadz+0.5)*fgkZPad};
1132   Translation(posLocal,step);
1133
1134   step[0] = kNpadX*0.5*fgkXPad;
1135   step[1] = 0.;
1136   step[2] = kNpadZ*0.5*fgkZPad;
1137   //  */
1138   /*
1139   Float_t posLocal[3] = {(ipadx+0.5)*fgkXPad, 0., (ipadz+0.5)*fgkZPad};
1140   Float_t step[3]= {kNpadX*0.5*fgkXPad, 0., kNpadZ*0.5*fgkZPad};
1141   */
1142   Translation(posLocal,step);
1143
1144   // FSTR reference frame -> FTOA/B/C = FLTA/B/C reference frame
1145
1146   Double_t angles[6];
1147   if      (GetAngles(iplate,istrip) >0.) {
1148     angles[0] = 90.;
1149     angles[1] =  0.;
1150     angles[2] = 90.+GetAngles(iplate,istrip);
1151     angles[3] = 90.;
1152     angles[4] = GetAngles(iplate,istrip);
1153     angles[5] = 90.;
1154   }
1155   else if (GetAngles(iplate,istrip)==0.) {
1156     angles[0] = 90.;
1157     angles[1] =  0.;
1158     angles[2] = 90.;
1159     angles[3] = 90.;
1160     angles[4] =  0;
1161     angles[5] =  0.;
1162   }
1163   else if (GetAngles(iplate,istrip) <0.) {
1164     angles[0] = 90.;
1165     angles[1] =  0.;
1166     angles[2] = 90.+GetAngles(iplate,istrip);
1167     angles[3] = 90.;
1168     angles[4] =-GetAngles(iplate,istrip);
1169     angles[5] = 270.;
1170   }
1171
1172   InverseRotation(posLocal,angles);
1173
1174   step[0] = 0.;
1175   step[1] = -GetHeights(iplate,istrip);
1176   step[2] =  GetDistances(iplate,istrip);
1177   Translation(posLocal,step);
1178
1179   // FTOA = FLTA reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
1180   angles[0] = 90.;
1181   angles[1] =  0.;
1182   angles[2] =  0.;
1183   angles[3] =  0.;
1184   angles[4] = 90.;
1185   angles[5] =270.;
1186
1187   InverseRotation(posLocal,angles);
1188
1189   // B071/B074/B075 = BTO1/2/3 reference frame -> ALICE reference frame
1190   step[0] = 0.;
1191   step[1] = 0.;
1192   step[2] = -((fgkRmax+fgkRmin)*0.5);
1193   Translation(posLocal,step);
1194
1195   angles[0] = 90.;
1196   angles[1] = 90.+(isector+0.5)*fgkPhiSec;
1197   angles[2] = 0.;
1198   angles[3] = 0.;
1199   angles[4] = 90.;
1200   angles[5] = (isector+0.5)*fgkPhiSec;
1201
1202   InverseRotation(posLocal,angles);
1203
1204   Float_t yCoor = posLocal[1];
1205
1206   return yCoor;
1207
1208 }
1209
1210 //_____________________________________________________________________________
1211 Float_t AliTOFGeometry::GetZ(Int_t *det) const
1212 {
1213   //
1214   // Returns Z coordinate (cm)
1215   //
1216
1217   Int_t isector = det[0];
1218   Int_t iplate  = det[1];
1219   Int_t istrip  = det[2];
1220   Int_t ipadz   = det[3];
1221   Int_t ipadx   = det[4];
1222
1223   /*
1224   Float_t zCoor = GetDistances(iplate,istrip) +
1225     (0.5-ipadz) * fgkZPad * TMath::Cos(GetAngles(iplate,istrip)*kDegrad);
1226   */
1227
1228   // Pad reference frame -> FSTR reference frame
1229   //  /*
1230   Float_t posLocal[3] = {0., 0., 0.};
1231   Float_t step[3] = {-(ipadx+0.5)*fgkXPad, 0., -(ipadz+0.5)*fgkZPad};
1232   Translation(posLocal,step);
1233
1234   step[0] = kNpadX*0.5*fgkXPad;
1235   step[1] = 0.;
1236   step[2] = kNpadZ*0.5*fgkZPad;
1237   //  */
1238   /*
1239   Float_t posLocal[3] = {(ipadx+0.5)*fgkXPad, 0., (ipadz+0.5)*fgkZPad};
1240   Float_t step[3]= {kNpadX*0.5*fgkXPad, 0., kNpadZ*0.5*fgkZPad};
1241   */
1242   Translation(posLocal,step);
1243
1244   // FSTR reference frame -> FTOA/B/C = FLTA/B/C reference frame
1245   Double_t angles[6];
1246   if      (GetAngles(iplate,istrip) >0.) {
1247     angles[0] = 90.;
1248     angles[1] =  0.;
1249     angles[2] = 90.+GetAngles(iplate,istrip);
1250     angles[3] = 90.;
1251     angles[4] = GetAngles(iplate,istrip);
1252     angles[5] = 90.;
1253   }
1254   else if (GetAngles(iplate,istrip)==0.) {
1255     angles[0] = 90.;
1256     angles[1] =  0.;
1257     angles[2] = 90.;
1258     angles[3] = 90.;
1259     angles[4] =  0;
1260     angles[5] =  0.;
1261   }
1262   else if (GetAngles(iplate,istrip) <0.) {
1263     angles[0] = 90.;
1264     angles[1] =  0.;
1265     angles[2] = 90.+GetAngles(iplate,istrip);
1266     angles[3] = 90.;
1267     angles[4] =-GetAngles(iplate,istrip);
1268     angles[5] = 270.;
1269   }
1270
1271   InverseRotation(posLocal,angles);
1272
1273   step[0] = 0.;
1274   step[1] = -GetHeights(iplate,istrip);
1275   step[2] =  GetDistances(iplate,istrip);
1276   Translation(posLocal,step);
1277
1278   // FTOA = FLTA reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
1279   angles[0] = 90.;
1280   angles[1] =  0.;
1281   angles[2] =  0.;
1282   angles[3] =  0.;
1283   angles[4] = 90.;
1284   angles[5] =270.;
1285
1286   InverseRotation(posLocal,angles);
1287
1288   // B071/B074/B075 = BTO1/2/3 reference frame -> ALICE reference frame
1289   step[0] = 0.;
1290   step[1] = 0.;
1291   step[2] = -((fgkRmax+fgkRmin)*0.5);
1292   Translation(posLocal,step);
1293
1294   angles[0] = 90.;
1295   angles[1] = 90.+(isector+0.5)*fgkPhiSec;
1296   angles[2] = 0.;
1297   angles[3] = 0.;
1298   angles[4] = 90.;
1299   angles[5] = (isector+0.5)*fgkPhiSec;
1300
1301   InverseRotation(posLocal,angles);
1302
1303   Float_t zCoor = posLocal[2];
1304
1305   return zCoor;
1306
1307 }
1308 //_____________________________________________________________________________
1309
1310 void AliTOFGeometry::DetToSectorRF(Int_t vol[5], Double_t **coord)
1311 {
1312   //
1313   // Returns the local coordinates (x, y, z) in sector reference frame
1314   // for the 4 corners of each sector pad (vol[1], vol[2], vol[3], vol[4])
1315   //
1316
1317   if (!gGeoManager) printf("ERROR: no TGeo\n");
1318
1319   // ALICE -> TOF Sector
1320   Char_t path1[100]="";
1321   GetVolumePath(vol[0],path1);
1322   gGeoManager->cd(path1);
1323   TGeoHMatrix aliceToSector;
1324   aliceToSector = *gGeoManager->GetCurrentMatrix();
1325
1326   // TOF Sector -> ALICE
1327   //TGeoHMatrix sectorToALICE = aliceToSector.Inverse();
1328
1329   // ALICE -> TOF Pad
1330   Char_t path2[100]="";
1331   GetVolumePath(vol,path2);
1332   gGeoManager->cd(path2);
1333   TGeoHMatrix aliceToPad;
1334   aliceToPad = *gGeoManager->GetCurrentMatrix();
1335
1336   // TOF Pad -> ALICE
1337   TGeoHMatrix padToALICE = aliceToPad.Inverse();
1338
1339   // TOF Pad -> TOF Sector
1340   TGeoHMatrix padToSector = padToALICE*aliceToSector;
1341
1342   // TOF Sector -> TOF Pad
1343   //TGeoHMatrix sectorToPad = sectorToALICE*aliceToPad;
1344
1345   // coordinates of the pad bottom corner
1346   Double_t **cornerPad = new Double_t*[4];
1347   for (Int_t ii=0; ii<4; ii++) cornerPad[ii] = new Double_t[3];
1348
1349   cornerPad[0][0] = -fgkXPad/2.;
1350   cornerPad[0][1] =  0.;
1351   cornerPad[0][2] = -fgkZPad/2.;
1352
1353   cornerPad[1][0] =  fgkXPad/2.;
1354   cornerPad[1][1] =  0.;
1355   cornerPad[1][2] = -fgkZPad/2.;
1356
1357   cornerPad[2][0] =  fgkXPad/2.;
1358   cornerPad[2][1] =  0.;
1359   cornerPad[2][2] =  fgkZPad/2.;
1360
1361   cornerPad[3][0] = -fgkXPad/2.;
1362   cornerPad[3][1] =  0.;
1363   cornerPad[3][2] =  fgkZPad/2.;
1364
1365   for(Int_t aa=0; aa<4; aa++) for(Int_t bb=0; bb<3; bb++) coord[aa][bb]=0.;
1366
1367   for (Int_t jj=0; jj<4; jj++) padToSector.MasterToLocal(&cornerPad[jj][0], &coord[jj][0]);
1368
1369   delete cornerPad;
1370
1371   //sectorToPad.LocalToMaster(cornerPad, coord);
1372
1373 }
1374 //_____________________________________________________________________________
1375 Float_t AliTOFGeometry::GetPadDx(Float_t *pos)
1376 {
1377   //
1378   // Returns the x coordinate in the Pad reference frame
1379   //
1380
1381   Float_t xpad = -2.;
1382
1383   Float_t posLocal[3];
1384   for (Int_t ii=0; ii<3; ii++) posLocal[ii] = pos[ii];
1385
1386   Int_t isector = GetSector(posLocal);
1387   if(isector == -1){
1388     //AliError("Detector Index could not be determined");
1389     return xpad;}
1390   Int_t iplate =  GetPlate(posLocal);
1391   if(iplate == -1){
1392     //AliError("Detector Index could not be determined");
1393     return xpad;}
1394   Int_t istrip =  GetStrip(posLocal);
1395   if(istrip == -1){
1396     //AliError("Detector Index could not be determined");
1397     return xpad;}
1398   Int_t ipadz =  GetPadZ(posLocal);
1399   if(ipadz == -1){
1400     //AliError("Detector Index could not be determined");
1401     return xpad;}
1402   Int_t ipadx =  GetPadX(posLocal);
1403   if(ipadx == -1){
1404     //AliError("Detector Index could not be determined");
1405     return xpad;}
1406
1407   // ALICE reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
1408   Double_t angles[6] =
1409     {90., 90.+(isector+0.5)*fgkPhiSec,
1410       0.,  0.,
1411      90., (isector+0.5)*fgkPhiSec
1412     };
1413   Rotation(posLocal,angles);
1414
1415   Float_t step[3] = {0., 0., (fgkRmax+fgkRmin)*0.5};
1416   Translation(posLocal,step);
1417
1418   // B071/B074/B075 = BTO1/2/3 reference frame -> FTOA/B/C = FLTA/B/C reference frame
1419   angles[0] = 90.;
1420   angles[1] =  0.;
1421   angles[2] =  0.;
1422   angles[3] =  0.;
1423   angles[4] = 90.;
1424   angles[5] =270.;
1425
1426   Rotation(posLocal,angles);
1427
1428   // FTOA/B/C = FLTA/B/C reference frame -> FSTR reference frame
1429   step[0] = 0.;
1430   step[1] = GetHeights(iplate,istrip);
1431   step[2] = -GetDistances(iplate,istrip);
1432   Translation(posLocal,step);
1433
1434   if      (GetAngles(iplate,istrip) >0.) {
1435     angles[0] = 90.;
1436     angles[1] =  0.;
1437     angles[2] = 90.+GetAngles(iplate,istrip);
1438     angles[3] = 90.;
1439     angles[4] = GetAngles(iplate,istrip);
1440     angles[5] = 90.;
1441   }
1442   else if (GetAngles(iplate,istrip)==0.) {
1443     angles[0] = 90.;
1444     angles[1] =  0.;
1445     angles[2] = 90.;
1446     angles[3] = 90.;
1447     angles[4] =  0;
1448     angles[5] =  0.;
1449   }
1450   else if (GetAngles(iplate,istrip) <0.) {
1451     angles[0] = 90.;
1452     angles[1] =  0.;
1453     angles[2] = 90.+GetAngles(iplate,istrip);
1454     angles[3] = 90.;
1455     angles[4] =-GetAngles(iplate,istrip);
1456     angles[5] = 270.;
1457   }
1458   Rotation(posLocal,angles);
1459
1460   step[0] =-0.5*kNpadX*fgkXPad;
1461   step[1] = 0.;
1462   step[2] =-0.5*kNpadZ*fgkZPad;
1463   Translation(posLocal,step);
1464
1465   step[0] = (ipadx+0.5)*fgkXPad;
1466   step[1] = 0.;
1467   step[2] = (ipadz+0.5)*fgkZPad;
1468   Translation(posLocal,step);
1469
1470   xpad=posLocal[0];
1471
1472   return xpad;
1473
1474 }
1475 //_____________________________________________________________________________
1476 Float_t AliTOFGeometry::GetPadDy(Float_t *pos)
1477 {
1478   //
1479   // Returns the y coordinate in the Pad reference frame
1480   //
1481
1482   Float_t ypad = -2.;
1483
1484   Float_t posLocal[3];
1485   for (Int_t ii=0; ii<3; ii++) posLocal[ii] = pos[ii];
1486
1487   Int_t isector = GetSector(posLocal);
1488   if(isector == -1){
1489     //AliError("Detector Index could not be determined");
1490     return ypad;}
1491   Int_t iplate =  GetPlate(posLocal);
1492   if(iplate == -1){
1493     //AliError("Detector Index could not be determined");
1494     return ypad;}
1495   Int_t istrip =  GetStrip(posLocal);
1496   if(istrip == -1){
1497     //AliError("Detector Index could not be determined");
1498     return ypad;}
1499   Int_t ipadz =  GetPadZ(posLocal);
1500   if(ipadz == -1){
1501     //AliError("Detector Index could not be determined");
1502     return ypad;}
1503   Int_t ipadx =  GetPadX(posLocal);
1504   if(ipadx == -1){
1505     //AliError("Detector Index could not be determined");
1506     return ypad;}
1507
1508   // ALICE reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
1509   Double_t angles[6] =
1510     {90., 90.+(isector+0.5)*fgkPhiSec,
1511       0.,  0.,
1512      90., (isector+0.5)*fgkPhiSec
1513     };
1514   Rotation(posLocal,angles);
1515
1516   Float_t step[3] = {0., 0., (fgkRmax+fgkRmin)*0.5};
1517   Translation(posLocal,step);
1518
1519   // B071/B074/B075 = BTO1/2/3 reference frame -> FTOA/B/C = FLTA/B/C reference frame
1520   angles[0] = 90.;
1521   angles[1] =  0.;
1522   angles[2] =  0.;
1523   angles[3] =  0.;
1524   angles[4] = 90.;
1525   angles[5] =270.;
1526
1527   Rotation(posLocal,angles);
1528
1529   // FTOA/B/C = FLTA/B/C reference frame -> FSTR reference frame
1530   step[0] = 0.;
1531   step[1] = GetHeights(iplate,istrip);
1532   step[2] = -GetDistances(iplate,istrip);
1533   Translation(posLocal,step);
1534
1535   if      (GetAngles(iplate,istrip) >0.) {
1536     angles[0] = 90.;
1537     angles[1] =  0.;
1538     angles[2] = 90.+GetAngles(iplate,istrip);
1539     angles[3] = 90.;
1540     angles[4] = GetAngles(iplate,istrip);
1541     angles[5] = 90.;
1542   }
1543   else if (GetAngles(iplate,istrip)==0.) {
1544     angles[0] = 90.;
1545     angles[1] =  0.;
1546     angles[2] = 90.;
1547     angles[3] = 90.;
1548     angles[4] =  0;
1549     angles[5] =  0.;
1550   }
1551   else if (GetAngles(iplate,istrip) <0.) {
1552     angles[0] = 90.;
1553     angles[1] =  0.;
1554     angles[2] = 90.+GetAngles(iplate,istrip);
1555     angles[3] = 90.;
1556     angles[4] =-GetAngles(iplate,istrip);
1557     angles[5] = 270.;
1558   }
1559   Rotation(posLocal,angles);
1560
1561   step[0] =-0.5*kNpadX*fgkXPad;
1562   step[1] = 0.;
1563   step[2] =-0.5*kNpadZ*fgkZPad;
1564   Translation(posLocal,step);
1565
1566   step[0] = (ipadx+0.5)*fgkXPad;
1567   step[1] = 0.;
1568   step[2] = (ipadz+0.5)*fgkZPad;
1569   Translation(posLocal,step);
1570
1571   ypad=posLocal[1];
1572
1573   return ypad;
1574
1575 }
1576 //_____________________________________________________________________________
1577 Float_t AliTOFGeometry::GetPadDz(Float_t *pos)
1578 {
1579   //
1580   // Returns the z coordinate in the Pad reference frame
1581   //
1582
1583   Float_t zpad = -2.;
1584
1585   Float_t posLocal[3];
1586   for (Int_t ii=0; ii<3; ii++) posLocal[ii] = pos[ii];
1587
1588   Int_t isector = GetSector(posLocal);
1589   if(isector == -1){
1590     //AliError("Detector Index could not be determined");
1591     return zpad;}
1592   Int_t iplate =  GetPlate(posLocal);
1593   if(iplate == -1){
1594     //AliError("Detector Index could not be determined");
1595     return zpad;}
1596   Int_t istrip =  GetStrip(posLocal);
1597   if(istrip == -1){
1598     //AliError("Detector Index could not be determined");
1599     return zpad;}
1600   Int_t ipadz =  GetPadZ(posLocal);
1601   if(ipadz == -1){
1602     //AliError("Detector Index could not be determined");
1603     return zpad;}
1604   Int_t ipadx =  GetPadX(posLocal);
1605   if(ipadx == -1){
1606     //AliError("Detector Index could not be determined");
1607     return zpad;}
1608
1609   // ALICE reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
1610   Double_t angles[6] =
1611     {90., 90.+(isector+0.5)*fgkPhiSec,
1612       0.,  0.,
1613      90., (isector+0.5)*fgkPhiSec
1614     };
1615   Rotation(posLocal,angles);
1616
1617   Float_t step[3] = {0., 0., (fgkRmax+fgkRmin)*0.5};
1618   Translation(posLocal,step);
1619
1620   // B071/B074/B075 = BTO1/2/3 reference frame -> FTOA/B/C = FLTA/B/C reference frame
1621   angles[0] = 90.;
1622   angles[1] =  0.;
1623   angles[2] =  0.;
1624   angles[3] =  0.;
1625   angles[4] = 90.;
1626   angles[5] =270.;
1627
1628   Rotation(posLocal,angles);
1629
1630   // FTOA/B/C = FLTA/B/C reference frame -> FSTR reference frame
1631   step[0] = 0.;
1632   step[1] = GetHeights(iplate,istrip);
1633   step[2] = -GetDistances(iplate,istrip);
1634   Translation(posLocal,step);
1635
1636   if      (GetAngles(iplate,istrip) >0.) {
1637     angles[0] = 90.;
1638     angles[1] =  0.;
1639     angles[2] = 90.+GetAngles(iplate,istrip);
1640     angles[3] = 90.;
1641     angles[4] = GetAngles(iplate,istrip);
1642     angles[5] = 90.;
1643   }
1644   else if (GetAngles(iplate,istrip)==0.) {
1645     angles[0] = 90.;
1646     angles[1] =  0.;
1647     angles[2] = 90.;
1648     angles[3] = 90.;
1649     angles[4] =  0;
1650     angles[5] =  0.;
1651   }
1652   else if (GetAngles(iplate,istrip) <0.) {
1653     angles[0] = 90.;
1654     angles[1] =  0.;
1655     angles[2] = 90.+GetAngles(iplate,istrip);
1656     angles[3] = 90.;
1657     angles[4] =-GetAngles(iplate,istrip);
1658     angles[5] = 270.;
1659   }
1660   Rotation(posLocal,angles);
1661
1662   step[0] =-0.5*kNpadX*fgkXPad;
1663   step[1] = 0.;
1664   step[2] =-0.5*kNpadZ*fgkZPad;
1665   Translation(posLocal,step);
1666
1667   step[0] = (ipadx+0.5)*fgkXPad;
1668   step[1] = 0.;
1669   step[2] = (ipadz+0.5)*fgkZPad;
1670   Translation(posLocal,step);
1671
1672   zpad=posLocal[2];
1673
1674   return zpad;
1675
1676 }
1677 //_____________________________________________________________________________
1678
1679 void AliTOFGeometry::Translation(Float_t *xyz, Float_t translationVector[3]) const
1680 {
1681   //
1682   // Return the vector xyz translated by translationVector vector
1683   //
1684
1685   Int_t ii=0;
1686
1687   for (ii=0; ii<3; ii++)
1688     xyz[ii] -= translationVector[ii];
1689
1690   return;
1691
1692 }
1693 //_____________________________________________________________________________
1694
1695 void AliTOFGeometry::Rotation(Float_t *xyz, Double_t rotationAngles[6]) const
1696 {
1697   //
1698   // Return the vector xyz rotated according to the rotationAngles angles
1699   //
1700
1701   Int_t ii=0;
1702   /*
1703   TRotMatrix *matrix = new TRotMatrix("matrix","matrix", angles[0], angles[1],
1704                                       angles[2], angles[3],
1705                                       angles[4], angles[5]);
1706   */
1707
1708   for (ii=0; ii<6; ii++) rotationAngles[ii]*=kDegrad;
1709
1710   Float_t xyzDummy[3] = {0., 0., 0.};
1711
1712   for (ii=0; ii<3; ii++) {
1713     xyzDummy[ii] =
1714       xyz[0]*TMath::Sin(rotationAngles[2*ii])*TMath::Cos(rotationAngles[2*ii+1]) +
1715       xyz[1]*TMath::Sin(rotationAngles[2*ii])*TMath::Sin(rotationAngles[2*ii+1]) +
1716       xyz[2]*TMath::Cos(rotationAngles[2*ii]);
1717   }
1718
1719   for (ii=0; ii<3; ii++) xyz[ii]=xyzDummy[ii];
1720
1721   return;
1722
1723 }
1724 //_____________________________________________________________________________
1725 void AliTOFGeometry::InverseRotation(Float_t *xyz, Double_t rotationAngles[6]) const
1726 {
1727   //
1728   //
1729   //
1730
1731   Int_t ii=0;
1732
1733   for (ii=0; ii<6; ii++) rotationAngles[ii]*=kDegrad;
1734
1735   Float_t xyzDummy[3] = {0., 0., 0.};
1736
1737   xyzDummy[0] =
1738     xyz[0]*TMath::Sin(rotationAngles[0])*TMath::Cos(rotationAngles[1]) +
1739     xyz[1]*TMath::Sin(rotationAngles[2])*TMath::Cos(rotationAngles[3]) +
1740     xyz[2]*TMath::Sin(rotationAngles[4])*TMath::Cos(rotationAngles[5]);
1741
1742   xyzDummy[1] =
1743     xyz[0]*TMath::Sin(rotationAngles[0])*TMath::Sin(rotationAngles[1]) +
1744     xyz[1]*TMath::Sin(rotationAngles[2])*TMath::Sin(rotationAngles[3]) +
1745     xyz[2]*TMath::Sin(rotationAngles[4])*TMath::Sin(rotationAngles[5]);
1746
1747   xyzDummy[2] =
1748     xyz[0]*TMath::Cos(rotationAngles[0]) +
1749     xyz[1]*TMath::Cos(rotationAngles[2]) +
1750     xyz[2]*TMath::Cos(rotationAngles[4]);
1751
1752   for (ii=0; ii<3; ii++) xyz[ii]=xyzDummy[ii];
1753
1754   return;
1755
1756 }
1757 //_____________________________________________________________________________
1758
1759 Int_t AliTOFGeometry::GetIndex(Int_t *detId)
1760 {
1761   //Retrieve calibration channel index
1762   Int_t isector = detId[0];
1763   if (isector >= kNSectors){
1764     printf("Wrong sector number in TOF (%d) !",isector);
1765     return -1;
1766   }
1767   Int_t iplate = detId[1];
1768   if (iplate >= kNPlates){
1769     printf("Wrong plate number in TOF (%d) !",iplate);
1770     return -1;
1771   }
1772   Int_t istrip = detId[2];
1773   Int_t ipadz = detId[3];
1774   Int_t ipadx = detId[4];
1775   Int_t stripOffset = 0;
1776   switch (iplate) {
1777   case 0:
1778     stripOffset = 0;
1779     break;
1780   case 1:
1781     stripOffset = kNStripC;
1782     break;
1783   case 2:
1784     stripOffset = kNStripC+kNStripB;
1785     break;
1786   case 3:
1787     stripOffset = kNStripC+kNStripB+kNStripA;
1788     break;
1789   case 4:
1790     stripOffset = kNStripC+kNStripB+kNStripA+kNStripB;
1791     break;
1792   default:
1793     printf("Wrong plate number in TOF (%d) !",iplate);
1794     return -1;
1795   };
1796
1797   Int_t idet = ((2*(kNStripC+kNStripB)+kNStripA)
1798                *kNpadZ*kNpadX)*isector +
1799                (stripOffset*kNpadZ*kNpadX)+
1800                (kNpadZ*kNpadX)*istrip+
1801                (kNpadX)*ipadz+
1802                 ipadx;
1803   return idet;
1804 }
1805
1806
1807