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