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