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