TOF/AliTOFGeometry.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /*
  17 $Log$
  18 Revision 1.20.1  2007/05/19 decaro
  19          Added the following methods:
  20              GetVolumeIndices(Int_t index, Int_t *det), to get
  21           the volume indices (sector, plate, strip, padz, padx,
  22           stored respectively in det[0], det[1], det[2], det[3], det[4])
  23           from the calibration channel index;
  24              NStrip(Int_t nPlate), to get the strips number
  25           per each kind of TOF module.
  26
  27 Revision 1.20  2007/10/08 17:52:55  decaro
  28 hole region in front of PHOS detector: update of sectors' numbers
  29
  30 Revision 1.19  2007/10/04 14:05:09  zampolli
  31 AliTOFGeometryV5 becoming AliTOFGeometry
  32
  33 Revision 1.18  2007/02/19 18:55:26  decaro
  34 Added getter methods for volume path (for Event Display)
  35
  36 Revision 1.17.1  2006/12/15
  37          Added method DetToStripRF(...) to get
  38          a pad corner coordinates in its strip reference frame
  39          (A.De Caro, M.Di Stefano)
  40 Revision 1.17  2006/08/22 13:30:02  arcelli
  41 removal of effective c++ warnings (C.Zampolli)
  42
  43 Revision 1.16  2006/04/20 22:30:50  hristov
  44 Coding conventions (Annalisa)
  45
  46 Revision 1.15  2006/04/16 22:29:05  hristov
  47 Coding conventions (Annalisa)
  48
  49 Revision 1.14  2006/04/05 08:35:38  hristov
  50 Coding conventions (S.Arcelli, C.Zampolli)
  51
  52 Revision 1.13  2006/03/12 14:37:54  arcelli
  53  Changes for TOF Reconstruction using TGeo
  54
  55 Revision 1.12  2006/02/28 10:38:00  decaro
  56 AliTOFGeometry::fAngles, AliTOFGeometry::fHeights, AliTOFGeometry::fDistances arrays: dimension definition in the right location
  57
  58 Revision 1.11  2005/12/15 14:17:29  decaro
  59 Correction of some parameter values
  60
  61 Revision 1.10  2005/12/15 08:55:32  decaro
  62 New TOF geometry description (V5) -G. Cara Romeo and A. De Caro
  63
  64 Revision 1.9.1  2005/07/19 A. De Caro
  65         Created daughter-classes AliTOFGeometryV4 and AliTOFGeometryV5
  66         => moved global methods IsInsideThePad, DistanceToPad,
  67         GetPlate, GetSector, GetStrip, GetPadX, GetPadZ,
  68         GetX, GetY, GetZ, GetPadDx, GetPadDy and GetPadDz
  69         in daughter-classes
  70
  71 Revision 1.9  2005/10/20 12:41:35  hristov
  72 Implementation of parallel tracking. It is not the default version, one can use it passing option MI from AliReconstruction to TOF (M.Ivanov)
  73
  74 Revision 1.8  2004/11/29 08:28:01  decaro
  75 Introduction of a new TOF constant (i.e. TDC bin width)
  76
  77 Revision 1.7  2004/11/05 07:20:08  decaro
  78 TOF library splitting and conversion of some printout messages in AliLog schema (T.Kuhr)
  79
  80 Revision 1.6  2004/06/15 15:27:59  decaro
  81 TOF raw data: preliminary implementation and style changes
  82
  83 Revision 1.5  2004/04/20 14:37:22  hristov
  84 Using TMath::Abs instead of fabs, arrays of variable size created/deleted correctly (HP,Sun)
  85
  86 Revision 1.4  2004/04/13 09:42:51  decaro
  87 Track reconstruction code for TOF: updating
  88
  89 Revision 1.3  2003/12/29 18:40:39  hristov
  90 Copy/paste error corrected
  91
  92 Revision 1.2  2003/12/29 17:26:01  hristov
  93 Using enum to initaialize static ints in the header file, the initialization of static floats moved to the implementation file
  94
  95 Revision 1.1  2003/12/29 15:18:03  decaro
  96 TOF geometry updating (addition of AliTOFGeometry)
  97
  98 Revision 0.05  2004/6/11 A.De Caro
  99         Implement Global method NpadXStrip
 100         Insert four float constants (originally  in AliTOF class)
 101 Revision 0.04  2004/4/05 S.Arcelli
 102         Implement Global methods IsInsideThePad
 103                                   DistanceToPad
 104 Revision 0.03  2003/12/14 S.Arcelli
 105         Set Phi range [-180,180]->[0,360]
 106 Revision 0.02  2003/12/10 S.Arcelli:
 107         Implement Global methods GetPos & GetDetID
 108 Revision 0.01  2003/12/04 S.Arcelli
 109 */
 110
 111 ///////////////////////////////////////////////////////////////////////////////
 112 //                                                                           //
 113 //  TOF Geometry class                                                       //
 114 //                                                                           //
 115 ///////////////////////////////////////////////////////////////////////////////
 116
 117 #include "TGeoManager.h"
 118 //#include "TGeoMatrix.h"
 119 #include "TMath.h"
 120
 121 #include "AliConst.h"
 122 #include "AliGeomManager.h"
 123 #include "AliLog.h"
 124
 125 #include "AliTOFGeometry.h"
 126
 127 extern TGeoManager *gGeoManager;
 128
 129 ClassImp(AliTOFGeometry)
 130
 131 const Float_t AliTOFGeometry::fgkZlenA    = 370.6*2.; // length (cm) of the A module
 132 const Float_t AliTOFGeometry::fgkZlenB    = 146.5;    // length (cm) of the B module
 133 const Float_t AliTOFGeometry::fgkZlenC    = 170.45;   // length (cm) of the C module
 134 const Float_t AliTOFGeometry::fgkMaxhZtof = 370.6;    // Max half z-size of TOF (cm)
 135
 136 const Float_t AliTOFGeometry::fgkxTOF     = 372.00;// Inner radius of the TOF for Reconstruction (cm)
 137 const Float_t AliTOFGeometry::fgkRmin     = 371.00;// Inner radius of the TOF (cm)
 138 const Float_t AliTOFGeometry::fgkRmax     = 400.05;// Outer radius of the TOF (cm)
 139
 140 const Float_t AliTOFGeometry::fgkXPad     = 2.5;    // Pad size in the x direction (cm)
 141 const Float_t AliTOFGeometry::fgkZPad     = 3.5;    // Pad size in the z direction (cm)
 142
 143 const Float_t AliTOFGeometry::fgkStripLength = 122.;// Strip Length (rho X phi direction) (cm)
 144
 145 const Float_t AliTOFGeometry::fgkSigmaForTail1= 2.; //Sig1 for simulation of TDC tails
 146 const Float_t AliTOFGeometry::fgkSigmaForTail2= 0.5;//Sig2 for simulation of TDC tails
 147
 148 const Float_t AliTOFGeometry::fgkPhiSec= 20;//sector Phi width (deg)
 149
 150 const Float_t AliTOFGeometry::fgkTdcBin = 24.4;     // time-of-flight bin width [ps]
 151 const Float_t AliTOFGeometry::fgkToTBin = 48.8;     // time-over-threshold bin width [ps]
 152
 153 const Float_t AliTOFGeometry::fgkDeadTime = 25E+03;        // Single channel dead time (ps)
 154 const Float_t AliTOFGeometry::fgkMatchingWindow = fgkTdcBin*TMath::Power(2,13); // Matching window  (ps)
 155
 156 const Float_t AliTOFGeometry::fgkAngles[kNPlates][kMaxNstrip] = {
 157     { 43.99,  43.20,  42.40,  41.59,  40.77,  39.94,  39.11,  38.25,  37.40,  36.53,
 158       35.65,  34.76,  33.87,  32.96,  32.05,  31.13,  30.19,  29.24,  12.33,  0.00},
 159
 160     { 27.26,  26.28,  25.30,  24.31,  23.31,  22.31,  21.30,  20.29,  19.26,  18.24,
 161       17.20,  16.16,  15.11,  14.05,  13.00,  11.93,  10.87,   9.80,   8.74,  0.00},
 162
 163     {  0.00,   6.30,   5.31,   4.25,   3.19,   2.12,   1.06,   0.00,  -1.06,  -2.12,
 164       -3.19,  -4.25,  -5.31,  -6.30,   0.00,   0.00,   0.00,   0.00,   0.00,  0.00},
 165
 166     { -8.74,  -9.80, -10.87, -11.93, -13.00, -14.05, -15.11, -16.16, -17.20, -18.24,
 167      -19.26, -20.29, -21.30, -22.31, -23.31, -24.31, -25.30, -26.28, -27.26,  0.00},
 168
 169     {-12.33, -29.24, -30.19, -31.13, -32.05, -32.96, -33.87, -34.76, -35.65, -36.53,
 170      -37.40, -38.25, -39.11, -39.94, -40.77, -41.59, -42.40, -43.20, -43.99,  0.00}
 171   };
 172
 173 /*
 174 const Float_t AliTOFGeometry::fgkHeights[kNPlates][kMaxNstrip] = {
 175     {-8.2,  -7.5,  -8.2,  -7.7,  -8.1,  -7.6,  -7.7,  -7.7,  -7.7,  -7.7,
 176      -7.5,  -7.2,  -7.3,  -7.5,  -7.6,  -7.8,  -8.3,  -9.3,  -3.1,   0.0},
 177
 178     {-7.9,  -8.1,  -8.5,  -9.0, -10.1,  -3.9,  -5.9,  -7.7, -10.1,  -3.6,
 179      -5.8,  -8.0, -10.4,  -4.4,  -7.2, -10.2,  -4.6,  -7.4, -10.4,   0.0},
 180
 181     {-2.5, -10.4,  -5.0,  -9.9,  -4.8,  -9.9,  -4.7, -10.2,  -4.7,  -9.9,
 182      -4.8,  -9.9,  -5.0, -10.4,  -2.5,   0.0,   0.0,   0.0,   0.0,   0.0},
 183
 184     {-10.4, -7.4,  -4.6, -10.2,  -7.2,  -4.4, -10.4,  -8.0,  -5.8,  -3.6,
 185      -10.1, -7.7,  -5.9,  -3.9, -10.1,  -9.0,  -8.5,  -8.1,  -7.9,   0.0},
 186
 187     { -3.1, -9.3,  -8.3,  -7.8,  -7.6,  -7.5,  -7.3,  -7.2,  -7.5,  -7.7,
 188       -7.7, -7.7,  -7.7,  -7.6,  -8.1,  -7.7,  -8.2,  -7.5,  -8.2,   0.0}
 189   };
 190 */
 191 /*
 192 const Float_t AliTOFGeometry::fgkHeights[kNPlates][kMaxNstrip] = {
 193   {  -8.405, -10.885,  -8.405,  -7.765,  -8.285,  -7.745,  -7.865,  -7.905,  -7.895,  -7.885,
 194      -7.705,  -7.395,  -7.525,  -7.645, -11.285, -10.355,  -8.365,  -9.385,  -3.255,   0.000 },
 195   {  -7.905,  -8.235,  -8.605,  -9.045, -10.205,  -3.975,  -5.915,  -7.765, -10.205,  -3.635,
 196      -5.885,  -8.005, -10.505,  -4.395,  -7.325, -10.235,  -4.655,  -7.495, -10.515,   0.000 },
 197   {  -2.705, -10.645,  -5.165, -10.095,  -4.995, -10.815,  -4.835, -10.385,  -4.835, -10.815,
 198      -4.995, -10.095,  -5.165, -10.645,  -2.705,   0.000,   0.000,   0.000,   0.000,   0.000 },
 199   { -10.515,  -7.495,  -4.655, -10.235,  -7.325,  -4.395, -10.505,  -8.005,  -5.885,  -3.635,
 200     -10.205,  -7.765,  -5.915,  -3.975, -10.205,  -9.045,  -8.605,  -8.235,  -7.905,   0.000 },
 201   {  -3.255,  -9.385,  -8.365, -10.355, -11.285,  -7.645,  -7.525,  -7.395,  -7.705,  -7.885,
 202      -7.895,  -7.905,  -7.865,  -7.745,  -8.285,  -7.765,  -8.405, -10.885,  -8.405,   0.000 }
 203 };
 204 */
 205
 206
 207 const Float_t AliTOFGeometry::fgkHeights[kNPlates][kMaxNstrip] = {
 208   { -8.405,  -7.725,  -8.405,  -7.765,  -8.285,  -7.745,  -7.865,  -7.905,  -7.895,  -7.885,
 209     -7.705,  -7.395,  -7.525,  -7.645,  -7.835,  -7.965,  -8.365,  -9.385,  -3.255,   0.000 },
 210   { -7.905,  -8.235,  -8.605,  -9.045, -10.205,  -3.975,  -5.915,  -7.765, -10.205,  -3.635,
 211     -5.885,  -8.005, -10.505,  -4.395,  -7.325, -10.235,  -4.655,  -7.495, -10.515,   0.000 },
 212   { -2.705, -10.645,  -5.165, -10.095,  -4.995, -10.085,  -4.835, -10.385,  -4.835, -10.085,
 213     -4.995, -10.095,  -5.165, -10.645,  -2.705,   0.000,   0.000,   0.000,   0.000,   0.000 },
 214   {-10.515,  -7.495,  -4.655, -10.235,  -7.325,  -4.395, -10.505,  -8.005,  -5.885,  -3.635,
 215    -10.205,  -7.765,  -5.915,  -3.975, -10.205,  -9.045,  -8.605,  -8.235,  -7.905,   0.000 },
 216   { -3.255,  -9.385,  -8.365,  -7.965,  -7.835,  -7.645,  -7.525,  -7.395,  -7.705,  -7.885,
 217     -7.895,  -7.905,  -7.865,  -7.745,  -8.285,  -7.765,  -8.405,  -7.725,  -8.405,   0.000 }
 218 };
 219
 220
 221
 222 const Float_t AliTOFGeometry::fgkDistances[kNPlates][kMaxNstrip] = {
 223   { 364.14,  354.88,  344.49,  335.31,  325.44,  316.51,  307.11,  297.91,  288.84,  279.89,
 224     271.20,  262.62,  253.84,  245.20,  236.56,  228.06,  219.46,  210.63,  206.09,    0.00 },
 225   { 194.57,  186.38,  178.25,  170.13,  161.78,  156.62,  148.10,  139.72,  131.23,  125.87,
 226     117.61,  109.44,  101.29,   95.46,   87.36,   79.37,   73.17,   65.33,   57.71,    0.00 },
 227   {  49.28,   41.35,   35.37,   27.91,   21.20,   13.94,    7.06,    0.00,   -7.06,  -13.94,
 228     -21.20,  -27.91,  -35.37,  -41.35,  -49.28,    0.00,    0.00,    0.00,    0.00,    0.00 },
 229   { -57.71,  -65.33,  -73.17,  -79.37,  -87.36,  -95.46, -101.29, -109.44, -117.61, -125.87,
 230    -131.23, -139.72, -148.10, -156.62, -161.78, -170.13, -178.25, -186.38, -194.57,    0.00 },
 231   {-206.09, -210.63, -219.46, -228.06, -236.56, -245.20, -253.84, -262.62, -271.20, -279.89,
 232    -288.84, -297.91, -307.11, -316.51, -325.44, -335.31, -344.49, -354.88, -364.14,    0.00 }
 233 };
 234
 235 /*
 236 const Float_t AliTOFGeometry::fgkDistances[kNPlates][kMaxNstrip] = {
 237     { 364.1,  354.9,  344.5,  335.4,  325.5,  316.6,  307.2,  298.0,  288.9,  280.0,
 238       271.3,  262.7,  254.0,  244.8,  236.1,  227.7,  219.1,  210.3,  205.7,    0.0},
 239
 240     { 194.2,  186.1,  177.9,  169.8,  161.5,  156.3,  147.8,  139.4,  130.9,  125.6,
 241       117.3,  109.2,  101.1,   95.3,   87.1,   79.2,   73.0,   65.1,   57.6,    0.0},
 242
 243     {  49.5,   41.3,   35.3,   27.8,   21.2,   13.9,    7.0,    0.0,   -7.0,  -13.9,
 244       -21.2,  -27.8,  -35.3,  -41.3,  -49.5,    0.0,    0.0,    0.0,    0.0,    0.0},
 245
 246     { -57.6,  -65.1,  -73.0,  -79.2,  -87.1,  -95.3, -101.1, -109.2, -117.3, -125.6,
 247      -130.9, -139.4, -147.8, -156.3, -161.5, -169.8, -177.9, -186.1, -194.2,    0.0},
 248
 249     {-205.7, -210.3, -219.1, -227.7, -236.1, -244.8, -254.0, -262.7, -271.3, -280.0,
 250      -288.9, -298.0, -307.2, -316.6, -325.5, -335.4, -344.5, -354.9, -364.1,    0.0}
 251   };
 252 */
 253 //_____________________________________________________________________________
 254 AliTOFGeometry::AliTOFGeometry():
 255   fHoles(1)
 256 {
 257   //
 258   // AliTOFGeometry default constructor
 259   //
 260
 261 }
 262
 263 //_____________________________________________________________________________
 264 AliTOFGeometry::~AliTOFGeometry()
 265 {
 266   //
 267   // AliTOFGeometry destructor
 268   //
 269 }
 270 //_____________________________________________________________________________
 271 void AliTOFGeometry::ImportGeometry(){
 272   TGeoManager::Import("geometry.root");
 273 }
 274 //_____________________________________________________________________________
 275 void AliTOFGeometry::GetPosPar(Int_t *det, Float_t *pos) const
 276 {
 277 //
 278 // Returns space point coor (x,y,z) (cm)  for Detector
 279 // Indices  (iSect,iPlate,iStrip,iPadX,iPadZ)
 280 //
 281
 282   pos[0]=GetX(det);
 283   pos[1]=GetY(det);
 284   pos[2]=GetZ(det);
 285
 286 }
 287 //_____________________________________________________________________________
 288 void AliTOFGeometry::GetDetID( Float_t *pos, Int_t *det) const
 289 {
 290  //
 291  // Returns Detector Indices (iSect,iPlate,iStrip,iPadX,iPadZ)
 292  // space point coor (x,y,z) (cm)
 293
 294
 295   det[0]=GetSector(pos);
 296   det[1]=GetPlate(pos);
 297   det[2]=GetStrip(pos);
 298   det[3]=GetPadZ(pos);
 299   det[4]=GetPadX(pos);
 300
 301 }
 302 //_____________________________________________________________________________
 303
 304 void AliTOFGeometry::DetToStripRF(Int_t nPadX, Int_t nPadZ, Float_t &x,  Float_t &z) const
 305 {
 306   //
 307   // Returns the local coordinates (x, z) in strip reference frame
 308   // for the bottom corner of the pad number (nPadX, nPadZ)
 309   //
 310   /*
 311   const Float_t xCenterStrip = kNpadX * fgkXPad / 2.;
 312   const Float_t zCenterStrip = kNpadZ * fgkZPad / 2.;
 313
 314   const Float_t xCenterPad = nPadX*fgkXPad + fgkXPad / 2.;
 315   const Float_t zCenterPad = nPadZ*fgkZPad + fgkZPad / 2.;
 316
 317   x = xCenterPad - xCenterStrip;
 318   z = zCenterPad - zCenterStrip;
 319   */
 320
 321
 322   x = (nPadX - kNpadX*0.5) * fgkXPad;
 323   z = (nPadZ - kNpadZ*0.5) * fgkZPad;
 324
 325
 326 }
 327 //_____________________________________________________________________________
 328 Float_t AliTOFGeometry::DistanceToPadPar(Int_t *det, const Float_t * const pos, Float_t *dist3d) const
 329 {
 330 //
 331 // Returns distance of  space point with coor pos (x,y,z) (cm) wrt
 332 // pad with Detector Indices idet (iSect,iPlate,iStrip,iPadX,iPadZ)
 333 //
 334
 335   //Transform pos into Sector Frame
 336
 337   Float_t x = pos[0];
 338   Float_t y = pos[1];
 339   Float_t z = pos[2];
 340
 341   Float_t radius = TMath::Sqrt(x*x+y*y);
 342   //Float_t phi=TMath::ATan(y/x);
 343   //if(phi<0) phi = k2PI+phi; //2.*TMath::Pi()+phi;
 344   Float_t phi = TMath::Pi()+TMath::ATan2(-y,-x);
 345   //  Get the local angle in the sector philoc
 346   Float_t angle   = phi*kRaddeg-( Int_t (kRaddeg*phi/fgkPhiSec) + 0.5)*fgkPhiSec;
 347   Float_t xs = radius*TMath::Cos(angle/kRaddeg);
 348   Float_t ys = radius*TMath::Sin(angle/kRaddeg);
 349   Float_t zs = z;
 350
 351   // Do the same for the selected pad
 352
 353   Float_t g[3];
 354   GetPosPar(det,g);
 355
 356   Float_t padRadius = TMath::Sqrt(g[0]*g[0]+g[1]*g[1]);
 357   //Float_t padPhi = TMath::ATan(g[1]/g[0]);
 358   //if(padPhi<0) padPhi = k2Pi + padPhi;
 359   Float_t padPhi = TMath::Pi()+TMath::ATan2(-g[1],-g[0]);
 360
 361   //  Get the local angle in the sector philoc
 362   Float_t padAngle = padPhi*kRaddeg-( Int_t (padPhi*kRaddeg/fgkPhiSec)+ 0.5) * fgkPhiSec;
 363   Float_t padxs = padRadius*TMath::Cos(padAngle/kRaddeg);
 364   Float_t padys = padRadius*TMath::Sin(padAngle/kRaddeg);
 365   Float_t padzs = g[2];
 366
 367   //Now move to local pad coordinate frame. Translate:
 368
 369   Float_t xt = xs-padxs;
 370   Float_t yt = ys-padys;
 371   Float_t zt = zs-padzs;
 372   //Now Rotate:
 373
 374   Float_t alpha = GetAngles(det[1],det[2]);
 375   Float_t xr =  xt*TMath::Cos(alpha/kRaddeg)+zt*TMath::Sin(alpha/kRaddeg);
 376   Float_t yr =  yt;
 377   Float_t zr = -xt*TMath::Sin(alpha/kRaddeg)+zt*TMath::Cos(alpha/kRaddeg);
 378
 379   Float_t dist = TMath::Sqrt(xr*xr+yr*yr+zr*zr);
 380
 381   if (dist3d){
 382     dist3d[0] = xr;
 383     dist3d[1] = yr;
 384     dist3d[2] = zr;
 385   }
 386
 387   return dist;
 388
 389 }
 390 //_____________________________________________________________________________
 391 Bool_t AliTOFGeometry::IsInsideThePadPar(Int_t *det, const Float_t * const pos) const
 392 {
 393 //
 394 // Returns true if space point with coor pos (x,y,z) (cm) falls
 395 // inside pad with Detector Indices idet (iSect,iPlate,iStrip,iPadX,iPadZ)
 396 //
 397
 398   Bool_t isInside=false;
 399
 400   /*
 401   const Float_t khhony    = 1.0          ; // heigth of HONY  Layer
 402   const Float_t khpcby    = 0.08         ; // heigth of PCB   Layer
 403   const Float_t khrgly    = 0.055        ; // heigth of RED GLASS  Layer
 404   const Float_t khglfy    = 0.285        ; // heigth of GLASS+FISHLINE  Layer
 405   const Float_t khcpcby   = 0.16         ; // heigth of PCB  Central Layer
 406   //const Float_t kwcpcbz   = 12.4         ; // z dimension of PCB  Central Layer
 407   const Float_t khstripy = 2.*khhony+2.*khpcby+4.*khrgly+2.*khglfy+khcpcby;//3.11
 408   //const Float_t kwstripz = kwcpcbz;
 409   //const Float_t klstripx = fgkStripLength;
 410   */
 411
 412   const Float_t kPadDepth = 0.5;//0.05;//0.11;//0.16;//          // heigth of Sensitive Layer
 413
 414   //Transform pos into Sector Frame
 415
 416   Float_t x = pos[0];
 417   Float_t y = pos[1];
 418   Float_t z = pos[2];
 419
 420   Float_t radius = TMath::Sqrt(x*x+y*y);
 421   Float_t phi = TMath::Pi()+TMath::ATan2(-y,-x);
 422
 423   //  Get the local angle in the sector philoc
 424   Float_t angle = phi*kRaddeg-( Int_t (kRaddeg*phi/fgkPhiSec) + 0.5) *fgkPhiSec;
 425   Float_t xs = radius*TMath::Cos(angle/kRaddeg);
 426   Float_t ys = radius*TMath::Sin(angle/kRaddeg);
 427   Float_t zs = z;
 428
 429   // Do the same for the selected pad
 430
 431   Float_t g[3];
 432   GetPosPar(det,g);
 433
 434   Float_t padRadius = TMath::Sqrt(g[0]*g[0]+g[1]*g[1]);
 435   Float_t padPhi = TMath::Pi()+TMath::ATan2(-g[1],-g[0]);
 436
 437   //  Get the local angle in the sector philoc
 438   Float_t padAngle = padPhi*kRaddeg-( Int_t (padPhi*kRaddeg/fgkPhiSec)+ 0.5) * fgkPhiSec;
 439   Float_t padxs = padRadius*TMath::Cos(padAngle/kRaddeg);
 440   Float_t padys = padRadius*TMath::Sin(padAngle/kRaddeg);
 441   Float_t padzs = g[2];
 442
 443   //Now move to local pad coordinate frame. Translate:
 444
 445   Float_t xt = xs-padxs;
 446   Float_t yt = ys-padys;
 447   Float_t zt = zs-padzs;
 448
 449   //Now Rotate:
 450
 451   Float_t alpha = GetAngles(det[1],det[2]);
 452   Float_t xr =  xt*TMath::Cos(alpha/kRaddeg)+zt*TMath::Sin(alpha/kRaddeg);
 453   Float_t yr =  yt;
 454   Float_t zr = -xt*TMath::Sin(alpha/kRaddeg)+zt*TMath::Cos(alpha/kRaddeg);
 455
 456   if(TMath::Abs(xr)<=kPadDepth*0.5 && TMath::Abs(yr)<= (fgkXPad*0.5) && TMath::Abs(zr)<= (fgkZPad*0.5))
 457     isInside=true;
 458   return isInside;
 459
 460 }
 461 //_____________________________________________________________________________
 462 Bool_t AliTOFGeometry::IsInsideThePad(TGeoHMatrix mat, const Float_t * const pos, Float_t *dist3d) const
 463 {
 464   //
 465   // Returns true if space point with coor pos (x,y,z) [cm] falls inside
 466   // pad identified by the matrix mat. In case dist3d!=0, dist3d vector
 467   // has been filled with the 3D distance between the impact point on
 468   // the pad and the pad centre (in the reference frame of the TOF pad
 469   // identified by the matrix mat).
 470   //
 471
 472   const Float_t kPadDepth = 0.5;      // heigth of Sensitive Layer
 473
 474   Double_t posg[3];
 475   posg[0] = pos[0];
 476   posg[1] = pos[1];
 477   posg[2] = pos[2];
 478
 479   // from ALICE global reference system
 480   // towards TOF pad reference system
 481   Double_t posl[3] = {0., 0., 0.};
 482   mat.MasterToLocal(posg,posl);
 483
 484   Float_t xr = posl[0];
 485   Float_t yr = posl[1];
 486   Float_t zr = posl[2];
 487
 488   Bool_t isInside = false;
 489   if (TMath::Abs(yr)<= kPadDepth*0.5 &&
 490       TMath::Abs(xr)<= fgkXPad*0.5 &&
 491       TMath::Abs(zr)<= fgkZPad*0.5)
 492     isInside = true;
 493
 494   if (dist3d) {
 495     //Double_t padl[3] = {0., 0., 0.};
 496     dist3d[0] = posl[0]/* - padl[0]*/;
 497     dist3d[1] = posl[1]/* - padl[1]*/;
 498     dist3d[2] = posl[2]/* - padl[2]*/;
 499
 500     /*
 501     Double_t padg[3] = {0., 0., 0.};
 502     // from TOF pad local reference system
 503     // towards ALICE global reference system
 504     TGeoHMatrix inverse = mat.Inverse();
 505     inverse.MasterToLocal(padl,padg);
 506
 507     // returns the 3d distance
 508     // between the impact point on the pad
 509     // and the pad centre (in the ALICE global reference frame)
 510     dist3d[0] = posg[0] - padg[0];
 511     dist3d[1] = posg[1] - padg[1];
 512     dist3d[2] = posg[2] - padg[2];
 513     */
 514   }
 515
 516   return isInside;
 517
 518 }
 519 //_____________________________________________________________________________
 520 void AliTOFGeometry::GetVolumePath(const Int_t * const ind, Char_t *path ) {
 521   //--------------------------------------------------------------------
 522   // This function returns the colume path of a given pad
 523   //--------------------------------------------------------------------
 524   Int_t sector = ind[0];
 525   Char_t  string1[100];
 526   Char_t  string2[100];
 527   Char_t  string3[100];
 528
 529   Int_t icopy=-1;
 530   icopy=sector;
 531
 532   sprintf(string1,"/ALIC_1/B077_1/BSEGMO%i_1/BTOF%i_1",icopy,icopy);
 533
 534   Int_t iplate=ind[1];
 535   Int_t istrip=ind[2];
 536   if( iplate==0) icopy=istrip;
 537   if( iplate==1) icopy=istrip+NStripC();
 538   if( iplate==2) icopy=istrip+NStripC()+NStripB();
 539   if( iplate==3) icopy=istrip+NStripC()+NStripB()+NStripA();
 540   if( iplate==4) icopy=istrip+NStripC()+2*NStripB()+NStripA();
 541   icopy++;
 542   sprintf(string2,"FTOA_0/FLTA_0/FSTR_%i",icopy);
 543   if(fHoles && (sector==13 || sector==14 || sector==15)){
 544     if(iplate<2)  sprintf(string2,"FTOB_0/FLTB_0/FSTR_%i",icopy);
 545     if(iplate>2)  sprintf(string2,"FTOC_0/FLTC_0/FSTR_%i",icopy);
 546   }
 547
 548   Int_t padz = ind[3]+1;
 549   Int_t padx = ind[4]+1;
 550   sprintf(string3,"FPCB_1/FSEN_1/FSEZ_%i/FPAD_%i",padz,padx);
 551   sprintf(path,"%s/%s/%s",string1,string2,string3);
 552
 553 }
 554 //_____________________________________________________________________________
 555 void AliTOFGeometry::GetVolumePath(Int_t sector, Char_t *path ){
 556   //--------------------------------------------------------------------
 557   // This function returns the colume path of a given sector
 558   //--------------------------------------------------------------------
 559
 560   Char_t string[100];
 561
 562   Int_t icopy = sector;
 563
 564   sprintf(string,"/ALIC_1/B077_1/BSEGMO%i_1/BTOF%i_1",icopy,icopy);
 565   sprintf(path,"%s",string);
 566
 567 }
 568 //_____________________________________________________________________________
 569 void AliTOFGeometry::GetVolumePath(Int_t sector, Int_t plate, Int_t strip, Char_t *path ) {
 570   //--------------------------------------------------------------------
 571   // This function returns the colume path of a given strip
 572   //--------------------------------------------------------------------
 573
 574   Char_t string1[100];
 575   Char_t string2[100];
 576   Char_t string3[100];
 577
 578   Int_t icopy = sector;
 579
 580   sprintf(string1,"/ALIC_1/B077_1/BSEGMO%i_1/BTOF%i_1",icopy,icopy);
 581
 582   if(plate==0) icopy=strip;
 583   if(plate==1) icopy=strip+NStripC();
 584   if(plate==2) icopy=strip+NStripC()+NStripB();
 585   if(plate==3) icopy=strip+NStripC()+NStripB()+NStripA();
 586   if(plate==4) icopy=strip+NStripC()+2*NStripB()+NStripA();
 587   icopy++;
 588   sprintf(string2,"FTOA_0/FLTA_0/FSTR_%i",icopy);
 589   if(fHoles && (sector==13 || sector==14 || sector==15)){
 590     if(plate<2)  sprintf(string2,"FTOB_0/FLTB_0/FSTR_%i",icopy);
 591     if(plate>2)  sprintf(string2,"FTOC_0/FLTC_0/FSTR_%i",icopy);
 592   }
 593
 594   sprintf(string3,"FPCB_1/FSEN_1");
 595   sprintf(path,"%s/%s/%s",string1,string2,string3);
 596
 597 }
 598 //_____________________________________________________________________________
 599 void AliTOFGeometry::GetPos(Int_t *det, Float_t *pos)
 600 {
 601 //
 602 // Returns space point coor (x,y,z) (cm)  for Detector
 603 // Indices  (iSect,iPlate,iStrip,iPadX,iPadZ)
 604 //
 605   Char_t path[100];
 606   GetVolumePath(det,path );
 607   if (!gGeoManager) {
 608     printf("ERROR: no TGeo\n");
 609   }
 610   gGeoManager->cd(path);
 611   TGeoHMatrix global;
 612   global = *gGeoManager->GetCurrentMatrix();
 613   const Double_t *tr = global.GetTranslation();
 614
 615   pos[0]=tr[0];
 616   pos[1]=tr[1];
 617   pos[2]=tr[2];
 618 }
 619 //_____________________________________________________________________________
 620 Int_t AliTOFGeometry::GetPlate(const Float_t * const pos) const
 621 {
 622   //
 623   // Returns the Plate index
 624   //
 625   const Float_t kInterCentrModBorder1 = 49.5;
 626   const Float_t kInterCentrModBorder2 = 57.5;
 627   const Float_t kExterInterModBorder1 = 196.0;
 628   const Float_t kExterInterModBorder2 = 203.5;
 629
 630   const Float_t kLengthExInModBorder  = 4.7;
 631   const Float_t kLengthInCeModBorder  = 7.0;
 632
 633   //const Float_t khAlWall = 0.1;
 634   const Float_t kModuleWallThickness = 0.3;
 635   //const Float_t kHoneycombLayerThickness = 1.5;
 636
 637   Int_t iPlate=-1;
 638
 639   Float_t posLocal[3];
 640   for (Int_t ii=0; ii<3; ii++) posLocal[ii] = pos[ii];
 641
 642   Int_t isector = GetSector(posLocal);
 643   if(isector == -1){
 644     //AliError("Detector Index could not be determined");
 645     return iPlate;
 646   }
 647
 648   // ALICE reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
 649   Double_t angles[6] =
 650     {90., 90.+(isector+0.5)*fgkPhiSec,
 651       0., 0.,
 652      90., (isector+0.5)*fgkPhiSec
 653     };
 654   Rotation(posLocal,angles);
 655
 656   Float_t step[3] = {0., 0., (fgkRmax+fgkRmin)*0.5};
 657   Translation(posLocal,step);
 658
 659   // B071/B074/B075 = BTO1/2/3 reference frame -> FTOA = FLTA reference frame
 660   angles[0] = 90.;
 661   angles[1] =  0.;
 662   angles[2] =  0.;
 663   angles[3] =  0.;
 664   angles[4] = 90.;
 665   angles[5] =270.;
 666
 667   Rotation(posLocal,angles);
 668
 669   Float_t yLocal = posLocal[1];
 670   Float_t zLocal = posLocal[2];
 671
 672   Float_t deltaRhoLoc  = (fgkRmax-fgkRmin)*0.5 - kModuleWallThickness + yLocal;
 673   Float_t deltaZetaLoc = TMath::Abs(zLocal);
 674
 675   Float_t deltaRHOmax = 0.;
 676
 677   if (TMath::Abs(zLocal)>=kExterInterModBorder1 && TMath::Abs(zLocal)<=kExterInterModBorder2)
 678     {
 679       deltaRhoLoc -= kLengthExInModBorder;
 680       deltaZetaLoc = kExterInterModBorder2-deltaZetaLoc;
 681       deltaRHOmax  = (fgkRmax - fgkRmin)*0.5 - kModuleWallThickness - 2.*kLengthExInModBorder; // old 5.35, new 4.8
 682
 683       if (deltaRhoLoc > deltaZetaLoc*deltaRHOmax/(kInterCentrModBorder2-kInterCentrModBorder1)) {
 684         if (zLocal<0) iPlate = 0;
 685         else iPlate = 4;
 686       }
 687       else {
 688         if (zLocal<0) iPlate = 1;
 689         else iPlate = 3;
 690       }
 691     }
 692   else if (TMath::Abs(zLocal)>=kInterCentrModBorder1 && TMath::Abs(zLocal)<=kInterCentrModBorder2)
 693     {
 694       deltaRhoLoc -= kLengthInCeModBorder;
 695       deltaZetaLoc = deltaZetaLoc-kInterCentrModBorder1;
 696       deltaRHOmax = (fgkRmax - fgkRmin)*0.5 - kModuleWallThickness - 2.*kLengthInCeModBorder; // old 0.39, new 0.2
 697
 698       if (deltaRhoLoc>deltaZetaLoc*deltaRHOmax/(kInterCentrModBorder2-kInterCentrModBorder1)) iPlate = 2;
 699       else {
 700         if (zLocal<0) iPlate = 1;
 701         else iPlate = 3;
 702       }
 703     }
 704
 705   if      (zLocal>-fgkZlenA*0.5          && zLocal<-kExterInterModBorder2) iPlate = 0;
 706   else if (zLocal>-kExterInterModBorder1 && zLocal<-kInterCentrModBorder2) iPlate = 1;
 707   else if (zLocal>-kInterCentrModBorder1 && zLocal< kInterCentrModBorder1) iPlate = 2;
 708   else if (zLocal> kInterCentrModBorder2 && zLocal< kExterInterModBorder1) iPlate = 3;
 709   else if (zLocal> kExterInterModBorder2 && zLocal< fgkZlenA*0.5)          iPlate = 4;
 710
 711   return iPlate;
 712
 713 }
 714
 715 //_____________________________________________________________________________
 716 Int_t AliTOFGeometry::GetSector(const Float_t * const pos) const
 717 {
 718   //
 719   // Returns the Sector index
 720   //
 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>=-fgkZlenA*0.5 && z<=fgkZlenA*0.5) &&
 731         (rho>=(fgkRmin) && rho<=(fgkRmax)))) {
 732     //AliError("Detector Index could not be determined");
 733     return iSect;
 734   }
 735
 736   Float_t phi = TMath::Pi() + TMath::ATan2(-y,-x);
 737
 738   iSect  = (Int_t) (phi*kRaddeg/fgkPhiSec);
 739
 740   return iSect;
 741
 742 }
 743 //_____________________________________________________________________________
 744 Int_t AliTOFGeometry::GetStrip(const Float_t * const pos) const
 745 {
 746   //
 747   // Returns the Strip index
 748   //
 749   const Float_t khhony    = 1.0          ; // heigth of HONY  Layer
 750   const Float_t khpcby    = 0.08         ; // heigth of PCB   Layer
 751   const Float_t khrgly    = 0.055        ; // heigth of RED GLASS  Layer
 752   const Float_t khglfy    = 0.285        ; // heigth of GLASS+FISHLINE  Layer
 753   const Float_t khcpcby   = 0.16         ; // heigth of PCB  Central Layer
 754   const Float_t kwcpcbz   = 12.4         ; // z dimension of PCB  Central Layer
 755   const Float_t khstripy = 2.*khhony+2.*khpcby+4.*khrgly+2.*khglfy+khcpcby;//3.11
 756   const Float_t kwstripz = kwcpcbz;
 757   const Float_t klstripx = fgkStripLength;
 758
 759   Int_t iStrip=-1;
 760
 761   Float_t posLocal[3];
 762   for (Int_t ii=0; ii<3; ii++) posLocal[ii] = pos[ii];
 763   AliDebug(1,Form("  posLocal[0] = %f, posLocal[1] = %f, posLocal[2] = %f ",
 764                   posLocal[0],posLocal[1],posLocal[2]));
 765
 766   Int_t isector = GetSector(posLocal);
 767   if(isector == -1){
 768     //AliError("Detector Index could not be determined");
 769     return iStrip;}
 770   Int_t iplate =  GetPlate(posLocal);
 771   if(iplate == -1){
 772     //AliError("Detector Index could not be determined");
 773     return iStrip;}
 774
 775   Int_t nstrips=0;
 776   switch (iplate) {
 777   case 0:
 778   case 4:
 779     nstrips=kNStripC;
 780     break;
 781   case 1:
 782   case 3:
 783     nstrips=kNStripB;
 784     break;
 785   case 2:
 786     nstrips=kNStripA;
 787     break;
 788   }
 789
 790   // ALICE reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
 791   Double_t angles[6] =
 792     {90., 90.+(isector+0.5)*fgkPhiSec,
 793       0., 0.,
 794      90., (isector+0.5)*fgkPhiSec
 795     };
 796   Rotation(posLocal,angles);
 797   AliDebug(1,Form("  posLocal[0] = %f, posLocal[1] = %f, posLocal[2] = %f ",
 798                   posLocal[0],posLocal[1],posLocal[2]));
 799
 800   Float_t step[3] = {0., 0., (fgkRmax+fgkRmin)*0.5};
 801   Translation(posLocal,step);
 802   AliDebug(1,Form("  posLocal[0] = %f, posLocal[1] = %f, posLocal[2] = %f ",
 803                   posLocal[0],posLocal[1],posLocal[2]));
 804
 805   // B071/B074/B075 = BTO1/2/3 reference frame -> FTOA = FLTA reference frame
 806   angles[0] = 90.;
 807   angles[1] =  0.;
 808   angles[2] =  0.;
 809   angles[3] =  0.;
 810   angles[4] = 90.;
 811   angles[5] =270.;
 812
 813   Rotation(posLocal,angles);
 814   AliDebug(1,Form("  posLocal[0] = %f, posLocal[1] = %f, posLocal[2] = %f ",
 815                   posLocal[0],posLocal[1],posLocal[2]));
 816
 817   // FTOA/B/C = FLTA/B/C reference frame -> FSTR reference frame
 818   Int_t totStrip=0;
 819   for (Int_t istrip=0; istrip<nstrips; istrip++){
 820
 821     Float_t posLoc2[3]={posLocal[0],posLocal[1],posLocal[2]};
 822
 823     step[0] = 0.;
 824     step[1] = GetHeights(iplate,istrip);
 825     step[2] = -GetDistances(iplate,istrip);
 826     Translation(posLoc2,step);
 827
 828     if      (GetAngles(iplate,istrip) >0.) {
 829       angles[0] = 90.;
 830       angles[1] =  0.;
 831       angles[2] = 90.+GetAngles(iplate,istrip);
 832       angles[3] = 90.;
 833       angles[4] = GetAngles(iplate,istrip);
 834       angles[5] = 90.;
 835     }
 836     else if (GetAngles(iplate,istrip)==0.) {
 837       angles[0] = 90.;
 838       angles[1] =  0.;
 839       angles[2] = 90.;
 840       angles[3] = 90.;
 841       angles[4] =  0;
 842       angles[5] =  0.;
 843     }
 844     else if (GetAngles(iplate,istrip) <0.) {
 845       angles[0] = 90.;
 846       angles[1] =  0.;
 847       angles[2] = 90.+GetAngles(iplate,istrip);
 848       angles[3] = 90.;
 849       angles[4] =-GetAngles(iplate,istrip);
 850       angles[5] = 270.;
 851     }
 852     Rotation(posLoc2,angles);
 853     AliDebug(1,Form(" strip %2d:  posLoc2[0] = %f, posLoc2[1] = %f, posLoc2[2] = %f ",
 854                     istrip, posLoc2[0],posLoc2[1],posLoc2[2]));
 855
 856     if ((TMath::Abs(posLoc2[0])<=klstripx*0.5) &&
 857         (TMath::Abs(posLoc2[1])<=khstripy*0.5) &&
 858         (TMath::Abs(posLoc2[2])<=kwstripz*0.5)) {
 859       iStrip = istrip;
 860       totStrip++;
 861       for (Int_t jj=0; jj<3; jj++) posLocal[jj]=posLoc2[jj];
 862       AliDebug(2,Form(" posLocal[0] = %f, posLocal[1] = %f, posLocal[2] = %f ",
 863                       posLocal[0],posLocal[1],posLocal[2]));
 864
 865       AliDebug(2,Form(" GetAngles(%1i,%2i) = %f, pos[0] = %f, pos[1] = %f, pos[2] = %f",
 866                       iplate, istrip, GetAngles(iplate,istrip), pos[0], pos[1], pos[2]));
 867       break;
 868     }
 869
 870     if (totStrip>1) AliInfo(Form("total strip number found %2i",totStrip));
 871
 872   }
 873
 874   return iStrip;
 875
 876 }
 877 //_____________________________________________________________________________
 878 Int_t AliTOFGeometry::GetPadZ(const Float_t * const pos) const
 879 {
 880   //
 881   // Returns the Pad index along Z
 882   //
 883   //const Float_t klsensmx = kNpadX*fgkXPad;  // length of Sensitive Layer
 884   //const Float_t khsensmy = 0.05;//0.11;//0.16;// heigth of Sensitive Layer
 885   //const Float_t kwsensmz = kNpadZ*fgkZPad;  // width of Sensitive Layer
 886
 887   Int_t iPadZ = -1;
 888
 889   Float_t posLocal[3];
 890   for (Int_t ii=0; ii<3; ii++) posLocal[ii] = pos[ii];
 891
 892   Int_t isector = GetSector(posLocal);
 893   if(isector == -1){
 894     //AliError("Detector Index could not be determined");
 895     return iPadZ;}
 896   Int_t iplate =  GetPlate(posLocal);
 897   if(iplate == -1){
 898     //AliError("Detector Index could not be determined");
 899     return iPadZ;}
 900   Int_t istrip =  GetStrip(posLocal);
 901   if(istrip == -1){
 902     //AliError("Detector Index could not be determined");
 903     return iPadZ;}
 904
 905   // ALICE reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
 906   Double_t angles[6] =
 907     {90., 90.+(isector+0.5)*fgkPhiSec,
 908       0., 0.,
 909      90., (isector+0.5)*fgkPhiSec
 910     };
 911   Rotation(posLocal,angles);
 912
 913   Float_t step[3] = {0., 0., (fgkRmax+fgkRmin)*0.5};
 914   Translation(posLocal,step);
 915
 916   // B071/B074/B075 = BTO1/2/3 reference frame -> FTOA = FLTA reference frame
 917   angles[0] = 90.;
 918   angles[1] =  0.;
 919   angles[2] =  0.;
 920   angles[3] =  0.;
 921   angles[4] = 90.;
 922   angles[5] =270.;
 923
 924   Rotation(posLocal,angles);
 925
 926   // FTOA/B/C = FLTA/B/C reference frame -> FSTR reference frame
 927   step[0] = 0.;
 928   step[1] = GetHeights(iplate,istrip);
 929   step[2] = -GetDistances(iplate,istrip);
 930   Translation(posLocal,step);
 931
 932   if      (GetAngles(iplate,istrip) >0.) {
 933     angles[0] = 90.;
 934     angles[1] =  0.;
 935     angles[2] = 90.+GetAngles(iplate,istrip);
 936     angles[3] = 90.;
 937     angles[4] = GetAngles(iplate,istrip);
 938     angles[5] = 90.;
 939   }
 940   else if (GetAngles(iplate,istrip)==0.) {
 941     angles[0] = 90.;
 942     angles[1] =  0.;
 943     angles[2] = 90.;
 944     angles[3] = 90.;
 945     angles[4] =  0;
 946     angles[5] =  0.;
 947   }
 948   else if (GetAngles(iplate,istrip) <0.) {
 949     angles[0] = 90.;
 950     angles[1] =  0.;
 951     angles[2] = 90.+GetAngles(iplate,istrip);
 952     angles[3] = 90.;
 953     angles[4] =-GetAngles(iplate,istrip);
 954     angles[5] = 270.;
 955   }
 956   Rotation(posLocal,angles);
 957
 958   step[0] =-0.5*kNpadX*fgkXPad;
 959   step[1] = 0.;
 960   step[2] =-0.5*kNpadZ*fgkZPad;
 961   Translation(posLocal,step);
 962
 963   iPadZ = (Int_t)(posLocal[2]/fgkZPad);
 964   if (iPadZ==kNpadZ) iPadZ--;
 965   else if (iPadZ>kNpadZ) iPadZ=-1;
 966
 967   return iPadZ;
 968
 969 }
 970 //_____________________________________________________________________________
 971 Int_t AliTOFGeometry::GetPadX(const Float_t * const pos) const
 972 {
 973   //
 974   // Returns the Pad index along X
 975   //
 976   //const Float_t klsensmx = kNpadX*fgkXPad;  // length of Sensitive Layer
 977   //const Float_t khsensmy = 0.05;//0.11;//0.16;// heigth of Sensitive Layer
 978   //const Float_t kwsensmz = kNpadZ*fgkZPad;  // width of Sensitive Layer
 979
 980   Int_t iPadX  = -1;
 981
 982   Float_t posLocal[3];
 983   for (Int_t ii=0; ii<3; ii++) posLocal[ii] = pos[ii];
 984
 985   Int_t isector = GetSector(posLocal);
 986   if(isector == -1){
 987     //AliError("Detector Index could not be determined");
 988     return iPadX;}
 989   Int_t iplate =  GetPlate(posLocal);
 990   if(iplate == -1){
 991     //AliError("Detector Index could not be determined");
 992     return iPadX;}
 993   Int_t istrip =  GetStrip(posLocal);
 994   if(istrip == -1){
 995     //AliError("Detector Index could not be determined");
 996     return iPadX;}
 997
 998   // ALICE reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
 999   Double_t angles[6] =
1000     {90., 90.+(isector+0.5)*fgkPhiSec,
1001       0.,  0.,
1002      90., (isector+0.5)*fgkPhiSec
1003     };
1004   Rotation(posLocal,angles);
1005
1006   Float_t step[3] = {0., 0., (fgkRmax+fgkRmin)*0.5};
1007   Translation(posLocal,step);
1008
1009   // B071/B074/B075 = BTO1/2/3 reference frame -> FTOA/B/C = FLTA/B/C reference frame
1010   angles[0] = 90.;
1011   angles[1] =  0.;
1012   angles[2] =  0.;
1013   angles[3] =  0.;
1014   angles[4] = 90.;
1015   angles[5] =270.;
1016
1017   Rotation(posLocal,angles);
1018
1019   // FTOA/B/C = FLTA/B/C reference frame -> FSTR reference frame
1020   step[0] = 0.;
1021   step[1] = GetHeights(iplate,istrip);
1022   step[2] = -GetDistances(iplate,istrip);
1023   Translation(posLocal,step);
1024
1025   if      (GetAngles(iplate,istrip) >0.) {
1026     angles[0] = 90.;
1027     angles[1] =  0.;
1028     angles[2] = 90.+GetAngles(iplate,istrip);
1029     angles[3] = 90.;
1030     angles[4] = GetAngles(iplate,istrip);
1031     angles[5] = 90.;
1032   }
1033   else if (GetAngles(iplate,istrip)==0.) {
1034     angles[0] = 90.;
1035     angles[1] =  0.;
1036     angles[2] = 90.;
1037     angles[3] = 90.;
1038     angles[4] =  0;
1039     angles[5] =  0.;
1040   }
1041   else if (GetAngles(iplate,istrip) <0.) {
1042     angles[0] = 90.;
1043     angles[1] =  0.;
1044     angles[2] = 90.+GetAngles(iplate,istrip);
1045     angles[3] = 90.;
1046     angles[4] =-GetAngles(iplate,istrip);
1047     angles[5] = 270.;
1048   }
1049   Rotation(posLocal,angles);
1050
1051   step[0] =-0.5*kNpadX*fgkXPad;
1052   step[1] = 0.;
1053   step[2] =-0.5*kNpadZ*fgkZPad;
1054   Translation(posLocal,step);
1055
1056   iPadX = (Int_t)(posLocal[0]/fgkXPad);
1057   if (iPadX==kNpadX) iPadX--;
1058   else if (iPadX>kNpadX) iPadX=-1;
1059
1060   return iPadX;
1061
1062 }
1063 //_____________________________________________________________________________
1064 Float_t AliTOFGeometry::GetX(const Int_t * const det) const
1065 {
1066   //
1067   // Returns X coordinate (cm)
1068   //
1069
1070   Int_t isector = det[0];
1071   Int_t iplate  = det[1];
1072   Int_t istrip  = det[2];
1073   Int_t ipadz   = det[3];
1074   Int_t ipadx   = det[4];
1075
1076   /*
1077   // Find out distance d on the plane wrt median phi:
1078   Float_t d = (ipadx+0.5-kNpadX*0.5)*fgkXPad;
1079
1080   // The radius r in xy plane:
1081   //Float_t r = (fgkRmin+fgkRmax)*0.5-0.01+GetHeights(iplate,istrip)+
1082   //  (ipadz-0.5)*fgkZPad*TMath::Sin(GetAngles(iplate,istrip)/kRaddeg)-0.25; ???
1083   Float_t r = (fgkRmin+fgkRmax)*0.5-0.01+GetHeights(iplate,istrip)+
1084     (ipadz-0.5)*fgkZPad*TMath::Sin(GetAngles(iplate,istrip)/kRaddeg);
1085
1086   // local azimuthal angle in the sector philoc
1087   Float_t philoc  = TMath::ATan(d/r);
1088   //if(philoc<0.) philoc = k2PI + philoc;
1089
1090   // azimuthal angle in the global frame  phi
1091   Float_t phi   = philoc*kRaddeg+(isector+0.5)*fgkPhiSec;
1092
1093   Float_t xCoor = r/TMath::Cos(philoc)*TMath::Cos(phi/kRaddeg);
1094   */
1095
1096   // Pad reference frame -> FSTR reference frame
1097   Float_t posLocal[3] = {0., 0., 0.};
1098   Float_t step[3] = {-(ipadx+0.5)*fgkXPad, 0., -(ipadz+0.5)*fgkZPad};
1099   Translation(posLocal,step);
1100
1101   step[0] = kNpadX*0.5*fgkXPad;
1102   step[1] = 0.;
1103   step[2] = kNpadZ*0.5*fgkZPad;
1104   /*
1105   Float_t posLocal[3] = {(ipadx+0.5)*fgkXPad, 0., (ipadz+0.5)*fgkZPad};
1106   Float_t step[3]= {kNpadX*0.5*fgkXPad, 0., kNpadZ*0.5*fgkZPad};
1107   */
1108   Translation(posLocal,step);
1109
1110   // FSTR reference frame -> FTOA/B/C = FLTA/B/C reference frame
1111   Double_t angles[6];
1112   if      (GetAngles(iplate,istrip) >0.) {
1113     angles[0] = 90.;
1114     angles[1] =  0.;
1115     angles[2] = 90.+GetAngles(iplate,istrip);
1116     angles[3] = 90.;
1117     angles[4] = GetAngles(iplate,istrip);
1118     angles[5] = 90.;
1119   }
1120   else if (GetAngles(iplate,istrip)==0.) {
1121     angles[0] = 90.;
1122     angles[1] =  0.;
1123     angles[2] = 90.;
1124     angles[3] = 90.;
1125     angles[4] =  0;
1126     angles[5] =  0.;
1127   }
1128   else if (GetAngles(iplate,istrip) <0.) {
1129     angles[0] = 90.;
1130     angles[1] =  0.;
1131     angles[2] = 90.+GetAngles(iplate,istrip);
1132     angles[3] = 90.;
1133     angles[4] =-GetAngles(iplate,istrip);
1134     angles[5] = 270.;
1135   }
1136
1137   InverseRotation(posLocal,angles);
1138
1139   step[0] = 0.;
1140   step[1] = -GetHeights(iplate,istrip);
1141   step[2] =  GetDistances(iplate,istrip);
1142   Translation(posLocal,step);
1143
1144   // FTOA = FLTA reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
1145   angles[0] = 90.;
1146   angles[1] =  0.;
1147   angles[2] =  0.;
1148   angles[3] =  0.;
1149   angles[4] = 90.;
1150   angles[5] =270.;
1151
1152   InverseRotation(posLocal,angles);
1153
1154   // B071/B074/B075 = BTO1/2/3 reference frame -> ALICE reference frame
1155   step[0] = 0.;
1156   step[1] = 0.;
1157   step[2] = -((fgkRmax+fgkRmin)*0.5);
1158   Translation(posLocal,step);
1159
1160   angles[0] = 90.;
1161   angles[1] = 90.+(isector+0.5)*fgkPhiSec;
1162   angles[2] = 0.;
1163   angles[3] = 0.;
1164   angles[4] = 90.;
1165   angles[5] = (isector+0.5)*fgkPhiSec;
1166
1167   InverseRotation(posLocal,angles);
1168
1169   Float_t xCoor = posLocal[0];
1170
1171   return xCoor;
1172
1173 }
1174 //_____________________________________________________________________________
1175 Float_t AliTOFGeometry::GetY(const Int_t * const det) const
1176 {
1177   //
1178   // Returns Y coordinate (cm)
1179   //
1180
1181   Int_t isector = det[0];
1182   Int_t iplate  = det[1];
1183   Int_t istrip  = det[2];
1184   Int_t ipadz   = det[3];
1185   Int_t ipadx   = det[4];
1186
1187   /*
1188   // Find out distance d on the plane wrt median phi:
1189   Float_t d = (ipadx+0.5-kNpadX*0.5)*fgkXPad;
1190
1191   // The radius r in xy plane:
1192   //Float_t r = (fgkRmin+fgkRmax)*0.5-0.01+GetHeights(iplate,istrip)+
1193   //  (ipadz-0.5)*fgkZPad*TMath::Sin(GetAngles(iplate,istrip)/kRaddeg)-0.25; ???
1194   Float_t r = (fgkRmin+fgkRmax)*0.5-0.01+GetHeights(iplate,istrip)+
1195     (ipadz-0.5)*fgkZPad*TMath::Sin(GetAngles(iplate,istrip)/kRaddeg);
1196
1197   // local azimuthal angle in the sector philoc
1198   Float_t philoc = TMath::ATan(d/r);
1199   //if(philoc<0.) philoc = k2PI + philoc;
1200
1201   // azimuthal angle in the global frame  phi
1202   Float_t phi   = philoc*kRaddeg+(isector+0.5)*fgkPhiSec;
1203
1204   Float_t yCoor = r/TMath::Cos(philoc)*TMath::Sin(phi/kRaddeg);
1205   */
1206
1207   // Pad reference frame -> FSTR reference frame
1208   Float_t posLocal[3] = {0., 0., 0.};
1209   Float_t step[3] = {-(ipadx+0.5)*fgkXPad, 0., -(ipadz+0.5)*fgkZPad};
1210   Translation(posLocal,step);
1211
1212   step[0] = kNpadX*0.5*fgkXPad;
1213   step[1] = 0.;
1214   step[2] = kNpadZ*0.5*fgkZPad;
1215   /*
1216   Float_t posLocal[3] = {(ipadx+0.5)*fgkXPad, 0., (ipadz+0.5)*fgkZPad};
1217   Float_t step[3]= {kNpadX*0.5*fgkXPad, 0., kNpadZ*0.5*fgkZPad};
1218   */
1219   Translation(posLocal,step);
1220
1221   // FSTR reference frame -> FTOA/B/C = FLTA/B/C reference frame
1222
1223   Double_t angles[6];
1224   if      (GetAngles(iplate,istrip) >0.) {
1225     angles[0] = 90.;
1226     angles[1] =  0.;
1227     angles[2] = 90.+GetAngles(iplate,istrip);
1228     angles[3] = 90.;
1229     angles[4] = GetAngles(iplate,istrip);
1230     angles[5] = 90.;
1231   }
1232   else if (GetAngles(iplate,istrip)==0.) {
1233     angles[0] = 90.;
1234     angles[1] =  0.;
1235     angles[2] = 90.;
1236     angles[3] = 90.;
1237     angles[4] =  0;
1238     angles[5] =  0.;
1239   }
1240   else if (GetAngles(iplate,istrip) <0.) {
1241     angles[0] = 90.;
1242     angles[1] =  0.;
1243     angles[2] = 90.+GetAngles(iplate,istrip);
1244     angles[3] = 90.;
1245     angles[4] =-GetAngles(iplate,istrip);
1246     angles[5] = 270.;
1247   }
1248
1249   InverseRotation(posLocal,angles);
1250
1251   step[0] = 0.;
1252   step[1] = -GetHeights(iplate,istrip);
1253   step[2] =  GetDistances(iplate,istrip);
1254   Translation(posLocal,step);
1255
1256   // FTOA = FLTA reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
1257   angles[0] = 90.;
1258   angles[1] =  0.;
1259   angles[2] =  0.;
1260   angles[3] =  0.;
1261   angles[4] = 90.;
1262   angles[5] =270.;
1263
1264   InverseRotation(posLocal,angles);
1265
1266   // B071/B074/B075 = BTO1/2/3 reference frame -> ALICE reference frame
1267   step[0] = 0.;
1268   step[1] = 0.;
1269   step[2] = -((fgkRmax+fgkRmin)*0.5);
1270   Translation(posLocal,step);
1271
1272   angles[0] = 90.;
1273   angles[1] = 90.+(isector+0.5)*fgkPhiSec;
1274   angles[2] = 0.;
1275   angles[3] = 0.;
1276   angles[4] = 90.;
1277   angles[5] = (isector+0.5)*fgkPhiSec;
1278
1279   InverseRotation(posLocal,angles);
1280
1281   Float_t yCoor = posLocal[1];
1282
1283   return yCoor;
1284
1285 }
1286
1287 //_____________________________________________________________________________
1288 Float_t AliTOFGeometry::GetZ(const Int_t * const det) const
1289 {
1290   //
1291   // Returns Z coordinate (cm)
1292   //
1293
1294   Int_t isector = det[0];
1295   Int_t iplate  = det[1];
1296   Int_t istrip  = det[2];
1297   Int_t ipadz   = det[3];
1298   Int_t ipadx   = det[4];
1299
1300   /*
1301   Float_t zCoor = GetDistances(iplate,istrip) +
1302     (0.5-ipadz) * fgkZPad * TMath::Cos(GetAngles(iplate,istrip)*kDegrad);
1303   */
1304
1305   // Pad reference frame -> FSTR reference frame
1306   Float_t posLocal[3] = {0., 0., 0.};
1307   Float_t step[3] = {-(ipadx+0.5)*fgkXPad, 0., -(ipadz+0.5)*fgkZPad};
1308   Translation(posLocal,step);
1309
1310   step[0] = kNpadX*0.5*fgkXPad;
1311   step[1] = 0.;
1312   step[2] = kNpadZ*0.5*fgkZPad;
1313   /*
1314   Float_t posLocal[3] = {(ipadx+0.5)*fgkXPad, 0., (ipadz+0.5)*fgkZPad};
1315   Float_t step[3]= {kNpadX*0.5*fgkXPad, 0., kNpadZ*0.5*fgkZPad};
1316   */
1317   Translation(posLocal,step);
1318
1319   // FSTR reference frame -> FTOA/B/C = FLTA/B/C reference frame
1320   Double_t angles[6];
1321   if      (GetAngles(iplate,istrip) >0.) {
1322     angles[0] = 90.;
1323     angles[1] =  0.;
1324     angles[2] = 90.+GetAngles(iplate,istrip);
1325     angles[3] = 90.;
1326     angles[4] = GetAngles(iplate,istrip);
1327     angles[5] = 90.;
1328   }
1329   else if (GetAngles(iplate,istrip)==0.) {
1330     angles[0] = 90.;
1331     angles[1] =  0.;
1332     angles[2] = 90.;
1333     angles[3] = 90.;
1334     angles[4] =  0;
1335     angles[5] =  0.;
1336   }
1337   else if (GetAngles(iplate,istrip) <0.) {
1338     angles[0] = 90.;
1339     angles[1] =  0.;
1340     angles[2] = 90.+GetAngles(iplate,istrip);
1341     angles[3] = 90.;
1342     angles[4] =-GetAngles(iplate,istrip);
1343     angles[5] = 270.;
1344   }
1345
1346   InverseRotation(posLocal,angles);
1347
1348   step[0] = 0.;
1349   step[1] = -GetHeights(iplate,istrip);
1350   step[2] =  GetDistances(iplate,istrip);
1351   Translation(posLocal,step);
1352
1353   // FTOA = FLTA reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
1354   angles[0] = 90.;
1355   angles[1] =  0.;
1356   angles[2] =  0.;
1357   angles[3] =  0.;
1358   angles[4] = 90.;
1359   angles[5] =270.;
1360
1361   InverseRotation(posLocal,angles);
1362
1363   // B071/B074/B075 = BTO1/2/3 reference frame -> ALICE reference frame
1364   step[0] = 0.;
1365   step[1] = 0.;
1366   step[2] = -((fgkRmax+fgkRmin)*0.5);
1367   Translation(posLocal,step);
1368
1369   angles[0] = 90.;
1370   angles[1] = 90.+(isector+0.5)*fgkPhiSec;
1371   angles[2] = 0.;
1372   angles[3] = 0.;
1373   angles[4] = 90.;
1374   angles[5] = (isector+0.5)*fgkPhiSec;
1375
1376   InverseRotation(posLocal,angles);
1377
1378   Float_t zCoor = posLocal[2];
1379
1380   return zCoor;
1381
1382 }
1383 //_____________________________________________________________________________
1384
1385 void AliTOFGeometry::DetToSectorRF(Int_t vol[5], Double_t **coord)
1386 {
1387   //
1388   // Returns the local coordinates (x, y, z) in sector reference frame
1389   // for the 4 corners of each sector pad (vol[1], vol[2], vol[3], vol[4])
1390   //
1391
1392   if (!gGeoManager) printf("ERROR: no TGeo\n");
1393
1394   // ALICE -> TOF Sector
1395   Char_t path1[100]="";
1396   GetVolumePath(vol[0],path1);
1397   gGeoManager->cd(path1);
1398   TGeoHMatrix aliceToSector;
1399   aliceToSector = *gGeoManager->GetCurrentMatrix();
1400
1401   // TOF Sector -> ALICE
1402   //TGeoHMatrix sectorToALICE = aliceToSector.Inverse();
1403
1404   // ALICE -> TOF Pad
1405   Char_t path2[100]="";
1406   GetVolumePath(vol,path2);
1407   gGeoManager->cd(path2);
1408   TGeoHMatrix aliceToPad;
1409   aliceToPad = *gGeoManager->GetCurrentMatrix();
1410
1411   // TOF Pad -> ALICE
1412   TGeoHMatrix padToALICE = aliceToPad.Inverse();
1413
1414   // TOF Pad -> TOF Sector
1415   TGeoHMatrix padToSector = padToALICE*aliceToSector;
1416
1417   // TOF Sector -> TOF Pad
1418   //TGeoHMatrix sectorToPad = sectorToALICE*aliceToPad;
1419
1420   // coordinates of the pad bottom corner
1421   Double_t **cornerPad = new Double_t*[4];
1422   for (Int_t ii=0; ii<4; ii++) cornerPad[ii] = new Double_t[3];
1423
1424   cornerPad[0][0] = -fgkXPad/2.;
1425   cornerPad[0][1] =  0.;
1426   cornerPad[0][2] = -fgkZPad/2.;
1427
1428   cornerPad[1][0] =  fgkXPad/2.;
1429   cornerPad[1][1] =  0.;
1430   cornerPad[1][2] = -fgkZPad/2.;
1431
1432   cornerPad[2][0] =  fgkXPad/2.;
1433   cornerPad[2][1] =  0.;
1434   cornerPad[2][2] =  fgkZPad/2.;
1435
1436   cornerPad[3][0] = -fgkXPad/2.;
1437   cornerPad[3][1] =  0.;
1438   cornerPad[3][2] =  fgkZPad/2.;
1439
1440   for(Int_t aa=0; aa<4; aa++) for(Int_t bb=0; bb<3; bb++) coord[aa][bb]=0.;
1441
1442   for (Int_t jj=0; jj<4; jj++) padToSector.MasterToLocal(&cornerPad[jj][0], &coord[jj][0]);
1443
1444   delete cornerPad;
1445
1446   //sectorToPad.LocalToMaster(cornerPad, coord);
1447
1448 }
1449 //_____________________________________________________________________________
1450 Float_t AliTOFGeometry::GetPadDx(const Float_t * const pos)
1451 {
1452   //
1453   // Returns the x coordinate in the Pad reference frame
1454   //
1455
1456   Float_t xpad = -2.;
1457
1458   Float_t posLocal[3];
1459   for (Int_t ii=0; ii<3; ii++) posLocal[ii] = pos[ii];
1460
1461   Int_t isector = GetSector(posLocal);
1462   if(isector == -1){
1463     //AliError("Detector Index could not be determined");
1464     return xpad;}
1465   Int_t iplate =  GetPlate(posLocal);
1466   if(iplate == -1){
1467     //AliError("Detector Index could not be determined");
1468     return xpad;}
1469   Int_t istrip =  GetStrip(posLocal);
1470   if(istrip == -1){
1471     //AliError("Detector Index could not be determined");
1472     return xpad;}
1473   Int_t ipadz =  GetPadZ(posLocal);
1474   if(ipadz == -1){
1475     //AliError("Detector Index could not be determined");
1476     return xpad;}
1477   Int_t ipadx =  GetPadX(posLocal);
1478   if(ipadx == -1){
1479     //AliError("Detector Index could not be determined");
1480     return xpad;}
1481
1482   // ALICE reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
1483   Double_t angles[6] =
1484     {90., 90.+(isector+0.5)*fgkPhiSec,
1485       0.,  0.,
1486      90., (isector+0.5)*fgkPhiSec
1487     };
1488   Rotation(posLocal,angles);
1489
1490   Float_t step[3] = {0., 0., (fgkRmax+fgkRmin)*0.5};
1491   Translation(posLocal,step);
1492
1493   // B071/B074/B075 = BTO1/2/3 reference frame -> FTOA/B/C = FLTA/B/C reference frame
1494   angles[0] = 90.;
1495   angles[1] =  0.;
1496   angles[2] =  0.;
1497   angles[3] =  0.;
1498   angles[4] = 90.;
1499   angles[5] =270.;
1500
1501   Rotation(posLocal,angles);
1502
1503   // FTOA/B/C = FLTA/B/C reference frame -> FSTR reference frame
1504   step[0] = 0.;
1505   step[1] = GetHeights(iplate,istrip);
1506   step[2] = -GetDistances(iplate,istrip);
1507   Translation(posLocal,step);
1508
1509   if      (GetAngles(iplate,istrip) >0.) {
1510     angles[0] = 90.;
1511     angles[1] =  0.;
1512     angles[2] = 90.+GetAngles(iplate,istrip);
1513     angles[3] = 90.;
1514     angles[4] = GetAngles(iplate,istrip);
1515     angles[5] = 90.;
1516   }
1517   else if (GetAngles(iplate,istrip)==0.) {
1518     angles[0] = 90.;
1519     angles[1] =  0.;
1520     angles[2] = 90.;
1521     angles[3] = 90.;
1522     angles[4] =  0;
1523     angles[5] =  0.;
1524   }
1525   else if (GetAngles(iplate,istrip) <0.) {
1526     angles[0] = 90.;
1527     angles[1] =  0.;
1528     angles[2] = 90.+GetAngles(iplate,istrip);
1529     angles[3] = 90.;
1530     angles[4] =-GetAngles(iplate,istrip);
1531     angles[5] = 270.;
1532   }
1533   Rotation(posLocal,angles);
1534
1535   step[0] =-0.5*kNpadX*fgkXPad;
1536   step[1] = 0.;
1537   step[2] =-0.5*kNpadZ*fgkZPad;
1538   Translation(posLocal,step);
1539
1540   step[0] = (ipadx+0.5)*fgkXPad;
1541   step[1] = 0.;
1542   step[2] = (ipadz+0.5)*fgkZPad;
1543   Translation(posLocal,step);
1544
1545   xpad=posLocal[0];
1546
1547   return xpad;
1548
1549 }
1550 //_____________________________________________________________________________
1551 Float_t AliTOFGeometry::GetPadDy(const Float_t * const pos)
1552 {
1553   //
1554   // Returns the y coordinate in the Pad reference frame
1555   //
1556
1557   Float_t ypad = -2.;
1558
1559   Float_t posLocal[3];
1560   for (Int_t ii=0; ii<3; ii++) posLocal[ii] = pos[ii];
1561
1562   Int_t isector = GetSector(posLocal);
1563   if(isector == -1){
1564     //AliError("Detector Index could not be determined");
1565     return ypad;}
1566   Int_t iplate =  GetPlate(posLocal);
1567   if(iplate == -1){
1568     //AliError("Detector Index could not be determined");
1569     return ypad;}
1570   Int_t istrip =  GetStrip(posLocal);
1571   if(istrip == -1){
1572     //AliError("Detector Index could not be determined");
1573     return ypad;}
1574   Int_t ipadz =  GetPadZ(posLocal);
1575   if(ipadz == -1){
1576     //AliError("Detector Index could not be determined");
1577     return ypad;}
1578   Int_t ipadx =  GetPadX(posLocal);
1579   if(ipadx == -1){
1580     //AliError("Detector Index could not be determined");
1581     return ypad;}
1582
1583   // ALICE reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
1584   Double_t angles[6] =
1585     {90., 90.+(isector+0.5)*fgkPhiSec,
1586       0.,  0.,
1587      90., (isector+0.5)*fgkPhiSec
1588     };
1589   Rotation(posLocal,angles);
1590
1591   Float_t step[3] = {0., 0., (fgkRmax+fgkRmin)*0.5};
1592   Translation(posLocal,step);
1593
1594   // B071/B074/B075 = BTO1/2/3 reference frame -> FTOA/B/C = FLTA/B/C reference frame
1595   angles[0] = 90.;
1596   angles[1] =  0.;
1597   angles[2] =  0.;
1598   angles[3] =  0.;
1599   angles[4] = 90.;
1600   angles[5] =270.;
1601
1602   Rotation(posLocal,angles);
1603
1604   // FTOA/B/C = FLTA/B/C reference frame -> FSTR reference frame
1605   step[0] = 0.;
1606   step[1] = GetHeights(iplate,istrip);
1607   step[2] = -GetDistances(iplate,istrip);
1608   Translation(posLocal,step);
1609
1610   if      (GetAngles(iplate,istrip) >0.) {
1611     angles[0] = 90.;
1612     angles[1] =  0.;
1613     angles[2] = 90.+GetAngles(iplate,istrip);
1614     angles[3] = 90.;
1615     angles[4] = GetAngles(iplate,istrip);
1616     angles[5] = 90.;
1617   }
1618   else if (GetAngles(iplate,istrip)==0.) {
1619     angles[0] = 90.;
1620     angles[1] =  0.;
1621     angles[2] = 90.;
1622     angles[3] = 90.;
1623     angles[4] =  0;
1624     angles[5] =  0.;
1625   }
1626   else if (GetAngles(iplate,istrip) <0.) {
1627     angles[0] = 90.;
1628     angles[1] =  0.;
1629     angles[2] = 90.+GetAngles(iplate,istrip);
1630     angles[3] = 90.;
1631     angles[4] =-GetAngles(iplate,istrip);
1632     angles[5] = 270.;
1633   }
1634   Rotation(posLocal,angles);
1635
1636   step[0] =-0.5*kNpadX*fgkXPad;
1637   step[1] = 0.;
1638   step[2] =-0.5*kNpadZ*fgkZPad;
1639   Translation(posLocal,step);
1640
1641   step[0] = (ipadx+0.5)*fgkXPad;
1642   step[1] = 0.;
1643   step[2] = (ipadz+0.5)*fgkZPad;
1644   Translation(posLocal,step);
1645
1646   ypad=posLocal[1];
1647
1648   return ypad;
1649
1650 }
1651 //_____________________________________________________________________________
1652 Float_t AliTOFGeometry::GetPadDz(const Float_t * const pos)
1653 {
1654   //
1655   // Returns the z coordinate in the Pad reference frame
1656   //
1657
1658   Float_t zpad = -2.;
1659
1660   Float_t posLocal[3];
1661   for (Int_t ii=0; ii<3; ii++) posLocal[ii] = pos[ii];
1662
1663   Int_t isector = GetSector(posLocal);
1664   if(isector == -1){
1665     //AliError("Detector Index could not be determined");
1666     return zpad;}
1667   Int_t iplate =  GetPlate(posLocal);
1668   if(iplate == -1){
1669     //AliError("Detector Index could not be determined");
1670     return zpad;}
1671   Int_t istrip =  GetStrip(posLocal);
1672   if(istrip == -1){
1673     //AliError("Detector Index could not be determined");
1674     return zpad;}
1675   Int_t ipadz =  GetPadZ(posLocal);
1676   if(ipadz == -1){
1677     //AliError("Detector Index could not be determined");
1678     return zpad;}
1679   Int_t ipadx =  GetPadX(posLocal);
1680   if(ipadx == -1){
1681     //AliError("Detector Index could not be determined");
1682     return zpad;}
1683
1684   // ALICE reference frame -> B071/B074/B075 = BTO1/2/3 reference frame
1685   Double_t angles[6] =
1686     {90., 90.+(isector+0.5)*fgkPhiSec,
1687       0.,  0.,
1688      90., (isector+0.5)*fgkPhiSec
1689     };
1690   Rotation(posLocal,angles);
1691
1692   Float_t step[3] = {0., 0., (fgkRmax+fgkRmin)*0.5};
1693   Translation(posLocal,step);
1694
1695   // B071/B074/B075 = BTO1/2/3 reference frame -> FTOA/B/C = FLTA/B/C reference frame
1696   angles[0] = 90.;
1697   angles[1] =  0.;
1698   angles[2] =  0.;
1699   angles[3] =  0.;
1700   angles[4] = 90.;
1701   angles[5] =270.;
1702
1703   Rotation(posLocal,angles);
1704
1705   // FTOA/B/C = FLTA/B/C reference frame -> FSTR reference frame
1706   step[0] = 0.;
1707   step[1] = GetHeights(iplate,istrip);
1708   step[2] = -GetDistances(iplate,istrip);
1709   Translation(posLocal,step);
1710
1711   if      (GetAngles(iplate,istrip) >0.) {
1712     angles[0] = 90.;
1713     angles[1] =  0.;
1714     angles[2] = 90.+GetAngles(iplate,istrip);
1715     angles[3] = 90.;
1716     angles[4] = GetAngles(iplate,istrip);
1717     angles[5] = 90.;
1718   }
1719   else if (GetAngles(iplate,istrip)==0.) {
1720     angles[0] = 90.;
1721     angles[1] =  0.;
1722     angles[2] = 90.;
1723     angles[3] = 90.;
1724     angles[4] =  0;
1725     angles[5] =  0.;
1726   }
1727   else if (GetAngles(iplate,istrip) <0.) {
1728     angles[0] = 90.;
1729     angles[1] =  0.;
1730     angles[2] = 90.+GetAngles(iplate,istrip);
1731     angles[3] = 90.;
1732     angles[4] =-GetAngles(iplate,istrip);
1733     angles[5] = 270.;
1734   }
1735   Rotation(posLocal,angles);
1736
1737   step[0] =-0.5*kNpadX*fgkXPad;
1738   step[1] = 0.;
1739   step[2] =-0.5*kNpadZ*fgkZPad;
1740   Translation(posLocal,step);
1741
1742   step[0] = (ipadx+0.5)*fgkXPad;
1743   step[1] = 0.;
1744   step[2] = (ipadz+0.5)*fgkZPad;
1745   Translation(posLocal,step);
1746
1747   zpad=posLocal[2];
1748
1749   return zpad;
1750
1751 }
1752 //_____________________________________________________________________________
1753
1754 void AliTOFGeometry::Translation(Float_t *xyz, Float_t translationVector[3]) const
1755 {
1756   //
1757   // Return the vector xyz translated by translationVector vector
1758   //
1759
1760   Int_t ii=0;
1761
1762   for (ii=0; ii<3; ii++)
1763     xyz[ii] -= translationVector[ii];
1764
1765   return;
1766
1767 }
1768 //_____________________________________________________________________________
1769
1770 void AliTOFGeometry::Rotation(Float_t *xyz, Double_t rotationAngles[6]) const
1771 {
1772   //
1773   // Return the vector xyz rotated according to the rotationAngles angles
1774   //
1775
1776   Int_t ii=0;
1777   /*
1778   TRotMatrix *matrix = new TRotMatrix("matrix","matrix", angles[0], angles[1],
1779                                       angles[2], angles[3],
1780                                       angles[4], angles[5]);
1781   */
1782
1783   for (ii=0; ii<6; ii++) rotationAngles[ii]*=kDegrad;
1784
1785   Float_t xyzDummy[3] = {0., 0., 0.};
1786
1787   for (ii=0; ii<3; ii++) {
1788     xyzDummy[ii] =
1789       xyz[0]*TMath::Sin(rotationAngles[2*ii])*TMath::Cos(rotationAngles[2*ii+1]) +
1790       xyz[1]*TMath::Sin(rotationAngles[2*ii])*TMath::Sin(rotationAngles[2*ii+1]) +
1791       xyz[2]*TMath::Cos(rotationAngles[2*ii]);
1792   }
1793
1794   for (ii=0; ii<3; ii++) xyz[ii]=xyzDummy[ii];
1795
1796   return;
1797
1798 }
1799 //_____________________________________________________________________________
1800 void AliTOFGeometry::InverseRotation(Float_t *xyz, Double_t rotationAngles[6]) const
1801 {
1802   //
1803   // Rotates the vector xyz acordint to the rotationAngles
1804   //
1805
1806   Int_t ii=0;
1807
1808   for (ii=0; ii<6; ii++) rotationAngles[ii]*=kDegrad;
1809
1810   Float_t xyzDummy[3] = {0., 0., 0.};
1811
1812   xyzDummy[0] =
1813     xyz[0]*TMath::Sin(rotationAngles[0])*TMath::Cos(rotationAngles[1]) +
1814     xyz[1]*TMath::Sin(rotationAngles[2])*TMath::Cos(rotationAngles[3]) +
1815     xyz[2]*TMath::Sin(rotationAngles[4])*TMath::Cos(rotationAngles[5]);
1816
1817   xyzDummy[1] =
1818     xyz[0]*TMath::Sin(rotationAngles[0])*TMath::Sin(rotationAngles[1]) +
1819     xyz[1]*TMath::Sin(rotationAngles[2])*TMath::Sin(rotationAngles[3]) +
1820     xyz[2]*TMath::Sin(rotationAngles[4])*TMath::Sin(rotationAngles[5]);
1821
1822   xyzDummy[2] =
1823     xyz[0]*TMath::Cos(rotationAngles[0]) +
1824     xyz[1]*TMath::Cos(rotationAngles[2]) +
1825     xyz[2]*TMath::Cos(rotationAngles[4]);
1826
1827   for (ii=0; ii<3; ii++) xyz[ii]=xyzDummy[ii];
1828
1829   return;
1830
1831 }
1832 //_____________________________________________________________________________
1833
1834 Int_t AliTOFGeometry::GetIndex(const Int_t * const detId)
1835 {
1836   //Retrieve calibration channel index
1837   Int_t isector = detId[0];
1838   if (isector >= kNSectors){
1839     printf("Wrong sector number in TOF (%d) !\n",isector);
1840     return -1;
1841   }
1842   Int_t iplate = detId[1];
1843   if (iplate >= kNPlates){
1844     printf("Wrong plate number in TOF (%d) !\n",iplate);
1845     return -1;
1846   }
1847   Int_t istrip = detId[2];
1848   Int_t stripOffset = GetStripNumberPerSM(iplate,istrip);
1849   if (stripOffset==-1) {
1850     printf("Wrong strip number per SM in TOF (%d) !\n",stripOffset);
1851     return -1;
1852   }
1853
1854   Int_t ipadz = detId[3];
1855   Int_t ipadx = detId[4];
1856
1857   Int_t idet = ((2*(kNStripC+kNStripB)+kNStripA)*kNpadZ*kNpadX)*isector +
1858                (stripOffset*kNpadZ*kNpadX)+
1859                (kNpadX)*ipadz+
1860                 ipadx;
1861   return idet;
1862 }
1863 //_____________________________________________________________________________
1864
1865 void AliTOFGeometry::GetVolumeIndices(Int_t index, Int_t *detId)
1866 {
1867   //
1868   // Retrieve volume indices from the calibration channel index
1869   //
1870
1871   detId[0] = index/NpadXStrip()/NStripXSector();
1872
1873   Int_t dummyStripPerModule =
1874     ( index - ( NStripXSector()*NpadXStrip()*detId[0]) ) / NpadXStrip();
1875   if (dummyStripPerModule<kNStripC) {
1876     detId[1] = 0;
1877     detId[2] = dummyStripPerModule;
1878   }
1879   else if (dummyStripPerModule>=kNStripC && dummyStripPerModule<kNStripC+kNStripB) {
1880     detId[1] = 1;
1881     detId[2] = dummyStripPerModule-kNStripC;
1882   }
1883   else if (dummyStripPerModule>=kNStripC+kNStripB && dummyStripPerModule<kNStripC+kNStripB+kNStripA) {
1884     detId[1] = 2;
1885     detId[2] = dummyStripPerModule-kNStripC-kNStripB;
1886   }
1887   else if (dummyStripPerModule>=kNStripC+kNStripB+kNStripA && dummyStripPerModule<kNStripC+kNStripB+kNStripA+kNStripB) {
1888     detId[1] = 3;
1889     detId[2] = dummyStripPerModule-kNStripC-kNStripB-kNStripA;
1890   }
1891   else if (dummyStripPerModule>=kNStripC+kNStripB+kNStripA+kNStripB && dummyStripPerModule<NStripXSector()) {
1892     detId[1] = 4;
1893     detId[2] = dummyStripPerModule-kNStripC-kNStripB-kNStripA-kNStripB;
1894   }
1895
1896   Int_t padPerStrip = ( index - ( NStripXSector()*NpadXStrip()*detId[0]) ) - dummyStripPerModule*NpadXStrip();
1897
1898   detId[3] = padPerStrip / kNpadX; // padZ
1899   detId[4] = padPerStrip - detId[3]*kNpadX; // padX
1900
1901 }
1902 //_____________________________________________________________________________
1903
1904 Int_t AliTOFGeometry::NStrip(Int_t nPlate)
1905 {
1906   //
1907   // Returns the strips number for the plate number 'nPlate'
1908   //
1909
1910   Int_t nStrips = kNStripC;
1911
1912   switch(nPlate) {
1913   case 2:
1914     nStrips = kNStripA;
1915     break;
1916   case 1:
1917   case 3:
1918     nStrips = kNStripB;
1919     break;
1920   case 0:
1921   case 4:
1922   default:
1923     nStrips = kNStripC;
1924     break;
1925   }
1926
1927   return nStrips;
1928
1929 }
1930 //-------------------------------------------------------------------------
1931
1932 UShort_t AliTOFGeometry::GetAliSensVolIndex(Int_t isector, Int_t iplate, Int_t istrip) const
1933 {
1934   //
1935   // Get the index of the TOF alignable volume in the AliGeomManager order.
1936   //
1937
1938   Int_t index = GetStripNumber(isector, iplate, istrip);
1939
1940   UShort_t volIndex = AliGeomManager::LayerToVolUID(AliGeomManager::kTOF,index);
1941
1942   return volIndex;
1943
1944 }
1945 //-------------------------------------------------------------------------
1946
1947 Int_t AliTOFGeometry::GetStripNumber(Int_t isector, Int_t iplate, Int_t istrip)
1948 {
1949   //
1950   // Get the serial number of the TOF strip number istrip [0,14/18],
1951   //   in the module number iplate [0,4],
1952   //   in the TOF SM number isector [0,17].
1953   // This number will range in [0,1637].
1954   //
1955
1956   Bool_t check = (isector >= kNSectors);
1957
1958   if (check)
1959     printf("E-AliTOFGeometry::GetStripNumber: Wrong sector number in TOF (%d)!\n",isector);
1960
1961   Int_t index = -1;
1962   Int_t stripInSM = GetStripNumberPerSM(iplate, istrip);
1963   if (!check && stripInSM!=-1)
1964     index = (2*(kNStripC+kNStripB)+kNStripA)*isector + stripInSM;
1965
1966   return index;
1967
1968 }
1969 //-------------------------------------------------------------------------
1970
1971 Int_t AliTOFGeometry::GetStripNumberPerSM(Int_t iplate, Int_t istrip)
1972 {
1973   //
1974   // Get the serial number of the TOF strip number istrip [0,14/18],
1975   //   in the module number iplate [0,4].
1976   // This number will range in [0,90].
1977   //
1978
1979   Int_t index = -1;
1980
1981   Bool_t check = (
1982                   (iplate<0 || iplate>=kNPlates)
1983                   ||
1984                   (
1985                    (iplate==2 && (istrip<0 || istrip>=kNStripA))
1986                    ||
1987                    (iplate!=2 && (istrip<0 || istrip>=kNStripC))
1988                    )
1989                   );
1990
1991   if (iplate<0 || iplate>=kNPlates)
1992     printf("E-AliTOFGeometry::GetStripNumberPerSM: Wrong plate number in TOF (%1d)!\n",iplate);
1993
1994   if (
1995       (iplate==2 && (istrip<0 || istrip>=kNStripA))
1996       ||
1997       (iplate!=2 && (istrip<0 || istrip>=kNStripC))
1998       )
1999     printf("E-AliTOFGeometry::GetStripNumberPerSM: Wrong strip number in TOF "
2000            "(strip=%2d in the plate=%1d)!\n",istrip,iplate);
2001
2002   Int_t stripOffset = 0;
2003   switch (iplate) {
2004   case 0:
2005     stripOffset = 0;
2006     break;
2007   case 1:
2008     stripOffset = kNStripC;
2009     break;
2010   case 2:
2011     stripOffset = kNStripC+kNStripB;
2012     break;
2013   case 3:
2014     stripOffset = kNStripC+kNStripB+kNStripA;
2015     break;
2016   case 4:
2017     stripOffset = kNStripC+kNStripB+kNStripA+kNStripB;
2018     break;
2019   };
2020
2021   if (!check) index = stripOffset + istrip;
2022
2023   return index;
2024
2025 }
2026 //-------------------------------------------------------------------------
2027
2028 void AliTOFGeometry::PadRF2TrackingRF(Float_t *ctrackPos, Float_t *differenceT)
2029 {
2030   //
2031   // To convert the 3D distance ctrackPos, referred to the ALICE RF,
2032   // into the 3D distance differenceT, referred to the tracking RF
2033   // in case ctrakPos belongs to a TOF sensitive volume.
2034   //
2035
2036   for (Int_t ii=0; ii<3; ii++) differenceT[ii] = 999.;
2037
2038   AliDebug(1,Form(" track position in ALICE global Ref. frame -> %f, %f, %f",
2039                   ctrackPos[0],ctrackPos[1],ctrackPos[2]));
2040
2041   Int_t detId[5] = {-1,-1,-1,-1,-1};
2042
2043   detId[0] = GetSector(ctrackPos);
2044   if (detId[0]==-1) {
2045     AliWarning(Form("This point does not belong to any TOF sector"));
2046     return;
2047   }
2048
2049   detId[1] = GetPlate(ctrackPos);
2050   if (detId[1]==-1) {
2051     AliWarning(Form("This point does not belong to any TOF module"));
2052     return;
2053   }
2054
2055   detId[2] = GetStrip(ctrackPos);
2056   if (detId[2]==-1) {
2057     AliWarning(Form("This point does not belong to any TOF strip"));
2058     return;
2059   }
2060
2061   detId[3] = GetPadZ(ctrackPos);
2062   if (detId[3]==-1) {
2063     AliWarning(Form("This point does not belong to any TOF pad-row"));
2064     return;
2065   }
2066
2067   detId[4] = GetPadX(ctrackPos);
2068   if (detId[4]==-1) {
2069     AliWarning(Form("This point does not belong to any TOF pad"));
2070     return;
2071   }
2072
2073
2074   UShort_t alignableStripIndex =
2075     GetAliSensVolIndex(detId[0],detId[1],detId[2]);
2076   AliDebug(1,Form(" sector = %2d, plate = %1d, strip = %2d (padZ = %1d, padX = %2d) "
2077                   "---> stripIndex = %4d",
2078                   detId[0], detId[1], detId[2], detId[3], detId[4], alignableStripIndex));
2079
2080   // pad centre coordinates in the strip ref. frame
2081   Double_t padCentreL[3] = {(detId[4]-AliTOFGeometry::NpadX()/2)*AliTOFGeometry::XPad()
2082                             +AliTOFGeometry::XPad()/2.,
2083                             0.,
2084                             (detId[3]-AliTOFGeometry::NpadZ()/2)*AliTOFGeometry::XPad()
2085                             +AliTOFGeometry::XPad()/2.};
2086   // pad centre coordinates in the strip tracking frame
2087   Double_t padCentreT[3] = {0., 0., 0.};
2088   TGeoHMatrix l2t = *AliGeomManager::GetTracking2LocalMatrix(alignableStripIndex);
2089   l2t.MasterToLocal(padCentreL,padCentreT);
2090
2091
2092   Char_t path[100];
2093   // pad centre coordinates in its ref. frame
2094   Double_t padCentreL2[3] = {0., 0., 0.};
2095   // pad centre coordinates in the ALICE global ref. frame
2096   Double_t padCentreG[3] = {0., 0., 0.};
2097   GetVolumePath(detId,path);
2098   gGeoManager->cd(path);
2099   TGeoHMatrix g2l = *gGeoManager->GetCurrentMatrix();
2100   TGeoHMatrix l2g = g2l.Inverse();
2101   l2g.MasterToLocal(padCentreL2,padCentreG);
2102
2103
2104   Char_t path2[100];
2105   // strip centre coordinates in its ref. frame
2106   Double_t stripCentreL[3] = {0., 0., 0.};
2107   // strip centre coordinates in the ALICE global ref. frame
2108   Double_t stripCentreG[3] = {0., 0., 0.};
2109   GetVolumePath(detId[0],detId[1],detId[2],path2);
2110   gGeoManager->cd(path2);
2111   TGeoHMatrix g2lb = *gGeoManager->GetCurrentMatrix();
2112   TGeoHMatrix l2gb = g2lb.Inverse();
2113   l2gb.MasterToLocal(stripCentreL,stripCentreG);
2114
2115   TGeoHMatrix g2t = 0;
2116   AliGeomManager::GetTrackingMatrix(alignableStripIndex, g2t);
2117
2118   // track position in the ALICE global ref. frame
2119   Double_t posG[3];
2120   for (Int_t ii=0; ii<3; ii++) posG[ii] = (Double_t)ctrackPos[ii];
2121
2122   // strip centre coordinates in the tracking ref. frame
2123   Double_t stripCentreT[3] = {0., 0., 0.};
2124   // track position in the tracking ref. frame
2125   Double_t posT[3] = {0., 0., 0.};
2126   g2t.MasterToLocal(posG,posT);
2127   g2t.MasterToLocal(stripCentreG,stripCentreT);
2128
2129   for (Int_t ii=0; ii<3; ii++)
2130     AliDebug(1,Form(" track position in ALICE global and tracking RFs -> posG[%d] = %f --- posT[%d] = %f",
2131                     ii, posG[ii], ii, posT[ii]));
2132   for (Int_t ii=0; ii<3; ii++)
2133     AliDebug(1,Form(" pad centre coordinates in its, the ALICE global and tracking RFs -> "
2134                     "padCentreL[%d] = %f --- padCentreG[%d] = %f --- padCentreT[%d] = %f",
2135                     ii, padCentreL[ii],
2136                     ii, padCentreG[ii],
2137                     ii, padCentreT[ii]));
2138   for (Int_t ii=0; ii<3; ii++)
2139     AliDebug(1,Form(" strip centre coordinates in its, the ALICE global and tracking RFs -> "
2140                     "stripCentreL[%d] = %f --- stripCentreG[%d] = %f --- stripCentreT[%d] = %f",
2141                     ii, stripCentreL[ii],
2142                     ii, stripCentreG[ii],
2143                     ii, stripCentreT[ii]));
2144   for (Int_t ii=0; ii<3; ii++)
2145     AliDebug(1,Form(" difference between the track position and the pad centre in the tracking RF "
2146                     "-> posT[%d]-padCentreT[%d] = %f",
2147                     ii,ii,
2148                     posT[ii]-padCentreT[ii]));
2149
2150   for (Int_t ii=0; ii<3; ii++) differenceT[ii] = (Float_t)(posT[ii]-padCentreT[ii]);
2151
2152 }