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