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