Reduced QA output (Yves)
[u/mrichter/AliRoot.git] / ITS / AliITSgeomMatrix.cxx
CommitLineData
df5240ea 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
023ae34b 16/*
17$Id$
18*/
6b0f3880 19////////////////////////////////////////////////////////////////////////
20// This is the implementation file for AliITSgeomMatrix class. It
21// contains the routines to manipulate, setup, and queary the geometry
22// of a given ITS module. An ITS module may be one of at least three
23// ITS detector technologies, Silicon Pixel, Drift, or Strip Detectors,
24// and variations of these in size and/or layout. These routines let
25// one go between ALICE global coordiantes (cm) to a given modules
26// specific local coordinates (cm).
27////////////////////////////////////////////////////////////////////////
28
4ae5bbc4 29#include <Riostream.h>
a1e17193 30#include <TClass.h>
df5240ea 31#include <TMath.h>
32#include <TBuffer.h>
023ae34b 33#include <TCanvas.h>
5385facc 34#if ROOT_VERSION_CODE>= 331523
35#include <TView3D.h>
36#else
023ae34b 37#include <TView.h>
5385facc 38#endif
023ae34b 39#include <TPolyLine3D.h>
023ae34b 40#include <TNode.h>
41#include <TPCON.h>
42#include <TBRIK.h>
43#include <TXTRU.h>
df5240ea 44
45#include "AliITSgeomMatrix.h"
46
47ClassImp(AliITSgeomMatrix)
48//----------------------------------------------------------------------
023ae34b 49AliITSgeomMatrix::AliITSgeomMatrix():
012f0f4c 50TObject(), // Base Class.
023ae34b 51fDetectorIndex(0), // Detector type index (like fShapeIndex was)
52fid(), // layer, ladder, detector numbers.
53frot(), //! vector of rotations about x,y,z [radians].
54ftran(), // Translation vector of module x,y,z.
55fCylR(0.0), //! R Translation in Cylinderical coordinates
56fCylPhi(0.0),//! Phi Translation vector in Cylindrical coord.
57fm(), // Rotation matrix based on frot.
58fPath(){ // Path in geometry to this module
59 // The Default constructor for the AliITSgeomMatrix class. By Default
60 // the angles of rotations are set to zero, meaning that the rotation
61 // matrix is the unit matrix. The translation vector is also set to
62 // zero as are the module id number. The detector type is set to -1
63 // (an undefined value). The full rotation matrix is kept so that
64 // the evaluation of a coordinate transformation can be done
65 // quickly and with a minimum of CPU overhead. The basic coordinate
66 // systems are the ALICE global coordinate system and the detector
67 // local coordinate system. In general this structure is not limited
68 // to just those two coordinate systems.
69 //Begin_Html
70 /*
71 <img src="picts/ITS/AliITSgeomMatrix_L1.gif">
72 */
73 //End_Html
74 // Inputs:
75 // none.
76 // Outputs:
77 // none.
78 // Return:
79 // A default constructes AliITSgeomMatrix class.
df5240ea 80 Int_t i,j;
81
82 fDetectorIndex = -1; // a value never defined.
83 for(i=0;i<3;i++){
84 fid[i] = 0;
85 frot[i] = ftran[i] = 0.0;
86 for(j=0;j<3;j++) fm[i][j] = 0.0;
87 }// end for i
88 fm[0][0] = fm[1][1] = fm[2][2] = 1.0;
89}
e56160b8 90
df5240ea 91//----------------------------------------------------------------------
e56160b8 92AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &source) :
012f0f4c 93TObject(source), // Base Class.
94fDetectorIndex(source.fDetectorIndex),// Detector type index (like
95 // fShapeIndex was)
96fid(), // layer, ladder, detector numbers.
97frot(), //! vector of rotations about x,y,z [radians].
98ftran(), // Translation vector of module x,y,z.
99fCylR(source.fCylR), //! R Translation in Cylinderical coordinates
100fCylPhi(source.fCylPhi),//! Phi Translation vector in Cylindrical coord.
101fm(), // Rotation matrix based on frot.
e56160b8 102fPath(source.fPath){
023ae34b 103 // The standard Copy constructor. This make a full / proper copy of
104 // this class.
105 // Inputs:
106 // AliITSgeomMatrix &source The source of this copy
107 // Outputs:
108 // none.
109 // Return:
110 // A copy constructes AliITSgeomMatrix class.
012f0f4c 111 Int_t i,j;
112
113 for(i=0;i<3;i++){
114 this->fid[i] = source.fid[i];
115 this->frot[i] = source.frot[i];
116 this->ftran[i] = source.ftran[i];
117 for(j=0;j<3;j++) this->fm[i][j] = source.fm[i][j];
118 }// end for i
df5240ea 119}
120//----------------------------------------------------------------------
e56160b8 121AliITSgeomMatrix& AliITSgeomMatrix::operator=(const AliITSgeomMatrix &source){
023ae34b 122 // The standard = operator. This make a full / proper copy of
123 // this class.
124 // The standard Copy constructor. This make a full / proper copy of
125 // this class.
126 // Inputs:
127 // AliITSgeomMatrix &source The source of this copy
128 // Outputs:
129 // none.
130 // Return:
131 // A copy of the source AliITSgeomMatrix class.
df5240ea 132
012f0f4c 133 if(this == &source)return *this;
134 Int_t i,j;
e56160b8 135
012f0f4c 136 this->fDetectorIndex = source.fDetectorIndex;
137 this->fCylR = source.fCylR;
138 this->fCylPhi = source.fCylPhi;
139 for(i=0;i<3;i++){
140 this->fid[i] = source.fid[i];
141 this->frot[i] = source.frot[i];
142 this->ftran[i] = source.ftran[i];
143 for(j=0;j<3;j++) this->fm[i][j] = source.fm[i][j];
144 } // end for i
145 this->fPath = source.fPath;
146 return *this;
df5240ea 147}
148//----------------------------------------------------------------------
6ba216a4 149AliITSgeomMatrix::AliITSgeomMatrix(Int_t idt,const Int_t id[3],
023ae34b 150 const Double_t rot[3],const Double_t tran[3]):
012f0f4c 151TObject(), // Base class
4bfbde86 152fDetectorIndex(idt), // Detector type index (like fShapeIndex was)
023ae34b 153fid(), // layer, ladder, detector numbers.
154frot(), //! vector of rotations about x,y,z [radians].
155ftran(), // Translation vector of module x,y,z.
156fCylR(0.0), //! R Translation in Cylinderical coordinates
157fCylPhi(0.0),//! Phi Translation vector in Cylindrical coord.
158fm(), // Rotation matrix based on frot.
159fPath(){ // Path in geometry to this moduel
160 // This is a constructor for the AliITSgeomMatrix class. The matrix is
161 // defined by 3 standard rotation angles [radians], and the translation
162 // vector tran [cm]. In addition the layer, ladder, and detector number
163 // for this particular module and the type of module must be given.
164 // The full rotation matrix is kept so that the evaluation
165 // of a coordinate transformation can be done quickly and with a minimum
166 // of CPU overhead. The basic coordinate systems are the ALICE global
167 // coordinate system and the detector local coordinate system. In general
168 // this structure is not limited to just those two coordinate systems.
169 //Begin_Html
170 /*
171 <img src="picts/ITS/AliITSgeomMatrix_L1.gif">
172 */
173 //End_Html
174 // Inputs:
175 // Int_t idt The detector index value
176 // Int_t id[3] The layer, ladder, and detector numbers
177 // Double_t rot[3] The 3 Cartician rotaion angles [radians]
178 // Double_t tran[3] The 3 Cartician translation distnaces
179 // Outputs:
180 // none.
181 // Return:
182 // A properly inilized AliITSgeomMatrix class.
d8cc8493 183 Int_t i;
df5240ea 184
d8cc8493 185 for(i=0;i<3;i++){
186 fid[i] = id[i];
187 frot[i] = rot[i];
188 ftran[i] = tran[i];
189 }// end for i
190 fCylR = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
191 fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
547a9bad 192 if(fCylPhi<0.0) fCylPhi += 2.*TMath::Pi();
d8cc8493 193 this->MatrixFromAngle();
df5240ea 194}
195//----------------------------------------------------------------------
6ba216a4 196AliITSgeomMatrix::AliITSgeomMatrix(Int_t idt, const Int_t id[3],
d962cab4 197 Double_t matrix[3][3],
023ae34b 198 const Double_t tran[3]):
012f0f4c 199TObject(), // Base class
4bfbde86 200fDetectorIndex(idt), // Detector type index (like fShapeIndex was)
023ae34b 201fid(), // layer, ladder, detector numbers.
202frot(), //! vector of rotations about x,y,z [radians].
203ftran(), // Translation vector of module x,y,z.
204fCylR(0.0), //! R Translation in Cylinderical coordinates
205fCylPhi(0.0),//! Phi Translation vector in Cylindrical coord.
206fm(), // Rotation matrix based on frot.
207fPath(){ // Path in geometry to this module
208 // This is a constructor for the AliITSgeomMatrix class. The
209 // rotation matrix is given as one of the inputs, and the
210 // translation vector tran [cm]. In addition the layer, ladder,
211 // and detector number for this particular module and the type of
212 // module must be given. The full rotation matrix is kept so that
213 // the evaluation of a coordinate transformation can be done quickly
214 // and with a minimum of CPU overhead. The basic coordinate systems
215 // are the ALICE global coordinate system and the detector local
216 // coordinate system. In general this structure is not limited to just
217 // those two coordinate systems.
218 //Begin_Html
219 /*
220 <img src="picts/ITS/AliITSgeomMatrix_L1.gif">
221 */
222 //End_Html
223 // Inputs:
224 // Int_t idt The detector index value
225 // Int_t id[3] The layer, ladder, and detector numbers
226 // Double_t rot[3][3] The 3x3 Cartician rotaion matrix
227 // Double_t tran[3] The 3 Cartician translation distnaces
228 // Outputs:
229 // none.
230 // Return:
231 // A properly inilized AliITSgeomMatrix class.
d8cc8493 232 Int_t i,j;
df5240ea 233
d8cc8493 234 for(i=0;i<3;i++){
235 fid[i] = id[i];
236 ftran[i] = tran[i];
237 for(j=0;j<3;j++) fm[i][j] = matrix[i][j];
238 }// end for i
239 fCylR = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
240 fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
547a9bad 241 if(fCylPhi<0.0) fCylPhi += 2.*TMath::Pi();
d8cc8493 242 this->AngleFromMatrix();
df5240ea 243}
244//----------------------------------------------------------------------
5cf690c1 245void AliITSgeomMatrix::SixAnglesFromMatrix(Double_t *ang)const{
023ae34b 246 // This function returns the 6 GEANT 3.21 rotation angles [degrees] in
247 // the array ang which must be at least [6] long.
248 // Inputs:
249 // none.
250 // Outputs:
251 // Double_t ang[6] The 6 Geant3.21 rotation angles. [degrees]
252 // Return:
253 // noting
df5240ea 254 Double_t si,c=180./TMath::Pi();
255
256 ang[1] = TMath::ATan2(fm[0][1],fm[0][0]);
257 if(TMath::Cos(ang[1])!=0.0) si = fm[0][0]/TMath::Cos(ang[1]);
258 else si = fm[0][1]/TMath::Sin(ang[1]);
259 ang[0] = TMath::ATan2(si,fm[0][2]);
260
261 ang[3] = TMath::ATan2(fm[1][1],fm[1][0]);
262 if(TMath::Cos(ang[3])!=0.0) si = fm[1][0]/TMath::Cos(ang[3]);
263 else si = fm[1][1]/TMath::Sin(ang[3]);
3f616de1 264 ang[2] = TMath::ATan2(si,fm[1][2]);
df5240ea 265
3f616de1 266 ang[5] = TMath::ATan2(fm[2][1],fm[2][0]);
267 if(TMath::Cos(ang[5])!=0.0) si = fm[2][0]/TMath::Cos(ang[5]);
268 else si = fm[2][1]/TMath::Sin(ang[5]);
269 ang[4] = TMath::ATan2(si,fm[2][2]);
df5240ea 270
271 for(Int_t i=0;i<6;i++) {ang[i] *= c; if(ang[i]<0.0) ang[i] += 360.;}
272}
273//----------------------------------------------------------------------
274void AliITSgeomMatrix::MatrixFromSixAngles(const Double_t *ang){
023ae34b 275 // Given the 6 GEANT 3.21 rotation angles [degree], this will compute and
276 // set the rotations matrix and 3 standard rotation angles [radians].
277 // These angles and rotation matrix are overwrite the existing values in
278 // this class.
279 // Inputs:
280 // Double_t ang[6] The 6 Geant3.21 rotation angles. [degrees]
281 // Outputs:
282 // none.
283 // Return:
284 // noting
df5240ea 285 Int_t i,j;
286 Double_t si,lr[9],c=TMath::Pi()/180.;
287
288 si = TMath::Sin(c*ang[0]);
289 if(ang[0]== 90.0) si = +1.0;
290 if(ang[0]==270.0) si = -1.0;
291 if(ang[0]== 0.0||ang[0]==180.) si = 0.0;
292 lr[0] = si * TMath::Cos(c*ang[1]);
293 lr[1] = si * TMath::Sin(c*ang[1]);
294 lr[2] = TMath::Cos(c*ang[0]);
295 if(ang[0]== 90.0||ang[0]==270.) lr[2] = 0.0;
296 if(ang[0]== 0.0) lr[2] = +1.0;
297 if(ang[0]==180.0) lr[2] = -1.0;
298//
299 si = TMath::Sin(c*ang[2]);
300 if(ang[2]== 90.0) si = +1.0;
301 if(ang[2]==270.0) si = -1.0;
302 if(ang[2]== 0.0||ang[2]==180.) si = 0.0;
303 lr[3] = si * TMath::Cos(c*ang[3]);
304 lr[4] = si * TMath::Sin(c*ang[3]);
305 lr[5] = TMath::Cos(c*ang[2]);
306 if(ang[2]== 90.0||ang[2]==270.) lr[5] = 0.0;
307 if(ang[2]== 0.0) lr[5] = +1.0;
308 if(ang[2]==180.0) lr[5] = -1.0;
309//
310 si = TMath::Sin(c*ang[4]);
311 if(ang[4]== 90.0) si = +1.0;
312 if(ang[4]==270.0) si = -1.0;
313 if(ang[4]== 0.0||ang[4]==180.) si = 0.0;
314 lr[6] = si * TMath::Cos(c*ang[5]);
315 lr[7] = si * TMath::Sin(c*ang[5]);
316 lr[8] = TMath::Cos(c*ang[4]);
317 if(ang[4]== 90.0||ang[4]==270.0) lr[8] = 0.0;
318 if(ang[4]== 0.0) lr[8] = +1.0;
319 if(ang[4]==180.0) lr[8] = -1.0;
320 // Normalize these elements and fill matrix fm.
321 for(i=0;i<3;i++){// reuse si.
322 si = 0.0;
323 for(j=0;j<3;j++) si += lr[3*i+j]*lr[3*i+j];
324 si = TMath::Sqrt(1./si);
325 for(j=0;j<3;j++) fm[i][j] = si*lr[3*i+j];
326 } // end for i
327 this->AngleFromMatrix();
328}
329//----------------------------------------------------------------------
330AliITSgeomMatrix::AliITSgeomMatrix(const Double_t rotd[6]/*degrees*/,
6ba216a4 331 Int_t idt,const Int_t id[3],
4bfbde86 332 const Double_t tran[3]):
012f0f4c 333TObject(), // Base class
334fDetectorIndex(idt), // Detector type index (like fShapeIndex was)
335fid(), // layer, ladder, detector numbers.
336frot(), //! vector of rotations about x,y,z [radians].
337ftran(), // Translation vector of module x,y,z.
338fCylR(0.0), //! R Translation in Cylinderical coordinates
339fCylPhi(0.0),//! Phi Translation vector in Cylindrical coord.
340fm(), // Rotation matrix based on frot.
341fPath(){ // Path in geometry to this module
023ae34b 342 // This is a constructor for the AliITSgeomMatrix class. The matrix
343 // is defined by the 6 GEANT 3.21 rotation angles [degrees], and
344 // the translation vector tran [cm]. In addition the layer, ladder,
345 // and detector number for this particular module and the type of
346 // module must be given. The full rotation matrix is kept so that
347 // the evaluation of a coordinate transformation can be done
348 // quickly and with a minimum of CPU overhead. The basic coordinate
349 // systems are the ALICE global coordinate system and the detector
350 // local coordinate system. In general this structure is not limited
351 // to just those two coordinate systems.
352 //Begin_Html
353 /*
354 <img src="picts/ITS/AliITSgeomMatrix_L1.gif">
355 */
356 //End_Html
357 // Inputs:
358 // Double_t rotd[6] The 6 Geant 3.21 rotation angles [degrees]
359 // Int_t idt The module Id number
360 // Int_t id[3] The layer, ladder and detector number
361 // Double_t tran[3] The translation vector
df5240ea 362 Int_t i;
363
df5240ea 364 for(i=0;i<3;i++){
365 fid[i] = id[i];
366 ftran[i] = tran[i];
367 }// end for i
d8cc8493 368 fCylR = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
369 fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
547a9bad 370 if(fCylPhi<0.0) fCylPhi += 2.*TMath::Pi();
df5240ea 371 this->MatrixFromSixAngles(rotd);
372}
373//----------------------------------------------------------------------
374void AliITSgeomMatrix::AngleFromMatrix(){
023ae34b 375 // Computes the angles from the rotation matrix up to a phase of
e16acbad 376 // 180 degrees. The matrix used in AliITSgeomMatrix::MatrixFromAngle()
377 // and its inverse AliITSgeomMatrix::AngleFromMatrix() are defined in
378 // the following ways, R = Rz*Ry*Rx (M=R*L+T) where
78d2d72a 379 // 1 0 0 Cy 0 +Sy Cz -Sz 0
380 // Rx= 0 Cx -Sx Ry= 0 1 0 Rz=+Sz Cz 0
381 // 0 +Sx Cx -Sy 0 Cy 0 0 1
e16acbad 382 // The choice of the since of S, comes from the choice between
383 // the rotation of the object or the coordinate system (view). I think
384 // that this choice is the first, the rotation of the object.
023ae34b 385 // Inputs:
386 // none
387 // Outputs:
388 // none
389 // Return:
390 // none
df5240ea 391 Double_t rx,ry,rz;
392 // get angles from matrix up to a phase of 180 degrees.
393
394 rx = TMath::ATan2(fm[2][1],fm[2][2]);if(rx<0.0) rx += 2.0*TMath::Pi();
78d2d72a 395 ry = TMath::ASin(-fm[0][2]); if(ry<0.0) ry += 2.0*TMath::Pi();
e16acbad 396 rz = TMath::ATan2(fm[1][0],fm[0][0]);if(rz<0.0) rz += 2.0*TMath::Pi();
df5240ea 397 frot[0] = rx;
398 frot[1] = ry;
399 frot[2] = rz;
400 return;
401}
402//----------------------------------------------------------------------
403void AliITSgeomMatrix::MatrixFromAngle(){
023ae34b 404 // Computes the Rotation matrix from the angles [radians] kept in this
e16acbad 405 // class. The matrix used in AliITSgeomMatrix::MatrixFromAngle() and
406 // its inverse AliITSgeomMatrix::AngleFromMatrix() are defined in
407 // the following ways, R = Rz*Ry*Rx (M=R*L+T) where
78d2d72a 408 // 1 0 0 Cy 0 +Sy Cz -Sz 0
409 // Rx= 0 Cx -Sx Ry= 0 1 0 Rz=+Sz Cz 0
410 // 0 +Sx Cx -Sy 0 Cy 0 0 1
e16acbad 411 // The choice of the since of S, comes from the choice between
412 // the rotation of the object or the coordinate system (view). I think
413 // that this choice is the first, the rotation of the object.
023ae34b 414 // Inputs:
415 // none
416 // Outputs:
417 // none
418 // Return:
419 // none
012f0f4c 420 Double_t sx,sy,sz,cx,cy,cz;
df5240ea 421
012f0f4c 422 sx = TMath::Sin(frot[0]); cx = TMath::Cos(frot[0]);
423 sy = TMath::Sin(frot[1]); cy = TMath::Cos(frot[1]);
424 sz = TMath::Sin(frot[2]); cz = TMath::Cos(frot[2]);
425 fm[0][0] = +cz*cy; // fr[0]
426 fm[0][1] = +cz*sy*sx - sz*cx; // fr[1]
427 fm[0][2] = +cz*sy*cx + sz*sx; // fr[2]
428 fm[1][0] = +sz*cy; // fr[3]
429 fm[1][1] = +sz*sy*sx + cz*cx; // fr[4]
430 fm[1][2] = +sz*sy*cx - cz*sx; // fr[5]
431 fm[2][0] = -sy; // fr[6]
432 fm[2][1] = +cy*sx; // fr[7]
433 fm[2][2] = +cy*cx; // fr[8]
df5240ea 434}
012f0f4c 435//----------------------------------------------------------------------
436void AliITSgeomMatrix::SetEulerAnglesChi(const Double_t ang[3]){
437 // Computes the Rotation matrix from the Euler angles [radians],
438 // Chi-convention, kept in this class. The matrix used in
439 // AliITSgeomMatrix::SetEulerAnglesChi and
440 // its inverse AliITSgeomMatrix::GetEulerAnglesChi() are defined in
441 // the following ways, R = Rb*Rc*Rd (M=R*L+T) where
442 // C2 +S2 0 1 0 0 C0 +S0 0
443 // Rb=-S2 C2 0 Rc= 0 C1 +S1 Rd=-S0 C0 0
444 // 0 0 1 0 -S1 C1 0 0 1
445 // This form is taken from Wolfram Research's Geometry>
446 // Transformations>Rotations web page (also should be
447 // found in their book).
448 // Inputs:
449 // Double_t ang[3] The three Euler Angles Phi, Theta, Psi
450 // Outputs:
451 // none
452 // Return:
453 // none
454 Double_t s0,s1,s2,c0,c1,c2;
78d2d72a 455
012f0f4c 456 s0 = TMath::Sin(ang[0]); c0 = TMath::Cos(ang[0]);
457 s1 = TMath::Sin(ang[1]); c1 = TMath::Cos(ang[1]);
458 s2 = TMath::Sin(ang[2]); c2 = TMath::Cos(ang[2]);
459 fm[0][0] = +c2*c0-c1*s0*s2; // fr[0]
460 fm[0][1] = +c2*s0+c1*c0*s2; // fr[1]
461 fm[0][2] = +s2*s1; // fr[2]
462 fm[1][0] = -s2*c0-c1*s0*c2; // fr[3]
463 fm[1][1] = -s2*s0+c1*c0*c2; // fr[4]
464 fm[1][2] = +c2*s1; // fr[5]
465 fm[2][0] = s1*s0; // fr[6]
466 fm[2][1] = -s1*c0; // fr[7]
467 fm[2][2] = +c1; // fr[8]
468 AngleFromMatrix();
469 return ;
470}
df5240ea 471//----------------------------------------------------------------------
024a4246 472void AliITSgeomMatrix::GtoLPosition(const Double_t g0[3],Double_t l[3]) const {
023ae34b 473 // Returns the local coordinates given the global coordinates [cm].
474 // Inputs:
475 // Double_t g[3] The position represented in the ALICE
476 // global coordinate system
477 // Outputs:
478 // Double_t l[3] The poistion represented in the local
479 // detector coordiante system
480 // Return:
481 // none
012f0f4c 482 Int_t i,j;
483 Double_t g[3];
df5240ea 484
012f0f4c 485 for(i=0;i<3;i++) g[i] = g0[i] - ftran[i];
486 for(i=0;i<3;i++){
487 l[i] = 0.0;
488 for(j=0;j<3;j++) l[i] += fm[i][j]*g[j];
489 // g = R l + translation
490 } // end for i
491 return;
df5240ea 492}
493//----------------------------------------------------------------------
024a4246 494void AliITSgeomMatrix::LtoGPosition(const Double_t l[3],Double_t g[3]) const {
023ae34b 495 // Returns the global coordinates given the local coordinates [cm].
496 // Inputs:
497 // Double_t l[3] The poistion represented in the detector
498 // local coordinate system
499 // Outputs:
500 // Double_t g[3] The poistion represented in the ALICE
501 // Global coordinate system
502 // Return:
503 // none.
012f0f4c 504 Int_t i,j;
df5240ea 505
012f0f4c 506 for(i=0;i<3;i++){
507 g[i] = 0.0;
508 for(j=0;j<3;j++) g[i] += fm[j][i]*l[j];
509 g[i] += ftran[i];
510 // g = R^t l + translation
511 } // end for i
512 return;
df5240ea 513}
514//----------------------------------------------------------------------
024a4246 515void AliITSgeomMatrix::GtoLMomentum(const Double_t g[3],Double_t l[3]) const{
023ae34b 516 // Returns the local coordinates of the momentum given the global
517 // coordinates of the momentum. It transforms just like GtoLPosition
518 // except that the translation vector is zero.
519 // Inputs:
520 // Double_t g[3] The momentum represented in the ALICE global
521 // coordinate system
522 // Outputs:
523 // Double_t l[3] the momentum represented in the detector
524 // local coordinate system
525 // Return:
526 // none.
012f0f4c 527 Int_t i,j;
df5240ea 528
012f0f4c 529 for(i=0;i<3;i++){
530 l[i] = 0.0;
531 for(j=0;j<3;j++) l[i] += fm[i][j]*g[j];
532 // g = R l
533 } // end for i
534 return;
df5240ea 535}
536//----------------------------------------------------------------------
024a4246 537void AliITSgeomMatrix::LtoGMomentum(const Double_t l[3],Double_t g[3]) const {
023ae34b 538 // Returns the Global coordinates of the momentum given the local
539 // coordinates of the momentum. It transforms just like LtoGPosition
540 // except that the translation vector is zero.
541 // Inputs:
542 // Double_t l[3] the momentum represented in the detector
543 // local coordinate system
544 // Outputs:
545 // Double_t g[3] The momentum represented in the ALICE global
546 // coordinate system
547 // Return:
548 // none.
012f0f4c 549 Int_t i,j;
df5240ea 550
012f0f4c 551 for(i=0;i<3;i++){
552 g[i] = 0.0;
553 for(j=0;j<3;j++) g[i] += fm[j][i]*l[j];
554 // g = R^t l
555 } // end for i
556 return;
df5240ea 557}
558//----------------------------------------------------------------------
023ae34b 559void AliITSgeomMatrix::GtoLPositionError(const Double_t g[3][3],
560 Double_t l[3][3]) const {
561 // Given an Uncertainty matrix in Global coordinates it is
562 // rotated so that its representation in local coordinates can
563 // be returned. There is no effect due to the translation vector
564 // or its uncertainty.
565 // Inputs:
566 // Double_t g[3][3] The error matrix represented in the ALICE global
567 // coordinate system
568 // Outputs:
569 // Double_t l[3][3] the error matrix represented in the detector
570 // local coordinate system
571 // Return:
572 // none.
012f0f4c 573 Int_t i,j,k,m;
df5240ea 574
012f0f4c 575 for(i=0;i<3;i++)for(m=0;m<3;m++){
576 l[i][m] = 0.0;
577 for(j=0;j<3;j++)for(k=0;k<3;k++)
578 l[i][m] += fm[j][i]*g[j][k]*fm[k][m];
579 } // end for i,m
580 // g = R^t l R
581 return;
df5240ea 582}
583//----------------------------------------------------------------------
023ae34b 584void AliITSgeomMatrix::LtoGPositionError(const Double_t l[3][3],
024a4246 585 Double_t g[3][3]) const {
023ae34b 586 // Given an Uncertainty matrix in Local coordinates it is rotated so that
587 // its representation in global coordinates can be returned. There is no
588 // effect due to the translation vector or its uncertainty.
589 // Inputs:
590 // Double_t l[3][3] the error matrix represented in the detector
591 // local coordinate system
592 // Outputs:
593 // Double_t g[3][3] The error matrix represented in the ALICE global
594 // coordinate system
595 // Return:
596 // none.
012f0f4c 597 Int_t i,j,k,m;
df5240ea 598
012f0f4c 599 for(i=0;i<3;i++)for(m=0;m<3;m++){
600 g[i][m] = 0.0;
601 for(j=0;j<3;j++)for(k=0;k<3;k++)
602 g[i][m] += fm[i][j]*l[j][k]*fm[m][k];
603 } // end for i,m
604 // g = R l R^t
605 return;
df5240ea 606}
607//----------------------------------------------------------------------
023ae34b 608void AliITSgeomMatrix::GtoLPositionTracking(const Double_t g[3],
609 Double_t l[3]) const {
610 // A slightly different coordinate system is used when tracking.
611 // This coordinate system is only relevant when the geometry represents
612 // the cylindrical ALICE ITS geometry. For tracking the Z axis is left
613 // alone but X -> -Y and Y -> X such that X always points out of the
614 // ITS Cylinder for every layer including layer 1 (where the detector
615 // are mounted upside down).
616 //Begin_Html
617 /*
618 <img src="picts/ITS/AliITSgeomMatrix_T1.gif">
619 */
620 //End_Html
621 // Inputs:
622 // Double_t g[3] The position represented in the ALICE
623 // global coordinate system
624 // Outputs:
625 // Double_t l[3] The poistion represented in the local
626 // detector coordiante system
627 // Return:
628 // none
df5240ea 629 Double_t l0[3];
630
023ae34b 631 this->GtoLPosition(g,l0);
df5240ea 632 if(fid[0]==1){ // for layer 1 the detector are flipped upside down
633 // with respect to the others.
634 l[0] = +l0[1];
635 l[1] = -l0[0];
636 l[2] = +l0[2];
637 }else{
638 l[0] = -l0[1];
639 l[1] = +l0[0];
640 l[2] = +l0[2];
641 } // end if
642 return;
643}
644//----------------------------------------------------------------------
645void AliITSgeomMatrix::LtoGPositionTracking(const Double_t l[3],
023ae34b 646 Double_t g[3]) const {
647 // A slightly different coordinate system is used when tracking.
648 // This coordinate system is only relevant when the geometry represents
649 // the cylindrical ALICE ITS geometry. For tracking the Z axis is left
650 // alone but X -> -Y and Y -> X such that X always points out of the
651 // ITS Cylinder for every layer including layer 1 (where the detector
652 // are mounted upside down).
653 //Begin_Html
654 /*
655 <img src="picts/ITS/AliITSgeomMatrix_T1.gif">
656 */
657 //End_Html
658 // Inputs:
659 // Double_t l[3] The poistion represented in the detector
660 // local coordinate system
661 // Outputs:
662 // Double_t g[3] The poistion represented in the ALICE
663 // Global coordinate system
664 // Return:
665 // none.
df5240ea 666 Double_t l0[3];
667
668 if(fid[0]==1){ // for layer 1 the detector are flipped upside down
669 // with respect to the others.
670 l0[0] = -l[1];
671 l0[1] = +l[0];
672 l0[2] = +l[2];
673 }else{
674 l0[0] = +l[1];
675 l0[1] = -l[0];
676 l0[2] = +l[2];
677 } // end if
678 this->LtoGPosition(l0,g);
679 return;
680}
681//----------------------------------------------------------------------
682void AliITSgeomMatrix::GtoLMomentumTracking(const Double_t g[3],
023ae34b 683 Double_t l[3]) const {
684 // A slightly different coordinate system is used when tracking.
685 // This coordinate system is only relevant when the geometry represents
686 // the cylindrical ALICE ITS geometry. For tracking the Z axis is left
687 // alone but X -> -Y and Y -> X such that X always points out of the
688 // ITS Cylinder for every layer including layer 1 (where the detector
689 // are mounted upside down).
690 //Begin_Html
691 /*
692 <img src="picts/ITS/AliITSgeomMatrix_T1.gif">
693 */
694 //End_Html
695 // Inputs:
696 // Double_t g[3] The momentum represented in the ALICE global
697 // coordinate system
698 // Outputs:
699 // Double_t l[3] the momentum represented in the detector
700 // local coordinate system
701 // Return:
702 // none.
df5240ea 703 Double_t l0[3];
704
705 this->GtoLMomentum(g,l0);
706 if(fid[0]==1){ // for layer 1 the detector are flipped upside down
707 // with respect to the others.
708 l[0] = +l0[1];
709 l[1] = -l0[0];
710 l[2] = +l0[2];
711 }else{
712 l[0] = -l0[1];
713 l[1] = +l0[0];
714 l[2] = +l0[2];
715 } // end if
716 return;
df5240ea 717}
718//----------------------------------------------------------------------
719void AliITSgeomMatrix::LtoGMomentumTracking(const Double_t l[3],
023ae34b 720 Double_t g[3]) const {
721 // A slightly different coordinate system is used when tracking.
722 // This coordinate system is only relevant when the geometry represents
723 // the cylindrical ALICE ITS geometry. For tracking the Z axis is left
724 // alone but X -> -Y and Y -> X such that X always points out of the
725 // ITS Cylinder for every layer including layer 1 (where the detector
726 // are mounted upside down).
727 //Begin_Html
728 /*
729 <img src="picts/ITS/AliITSgeomMatrix_T1.gif">
730 */
731 //End_Html
732 // Inputs:
733 // Double_t l[3] the momentum represented in the detector
734 // local coordinate system
735 // Outputs:
736 // Double_t g[3] The momentum represented in the ALICE global
737 // coordinate system
738 // Return:
739 // none.
df5240ea 740 Double_t l0[3];
741
742 if(fid[0]==1){ // for layer 1 the detector are flipped upside down
743 // with respect to the others.
744 l0[0] = -l[1];
745 l0[1] = +l[0];
746 l0[2] = +l[2];
747 }else{
748 l0[0] = +l[1];
749 l0[1] = -l[0];
750 l0[2] = +l[2];
751 } // end if
752 this->LtoGMomentum(l0,g);
753 return;
754}
755//----------------------------------------------------------------------
023ae34b 756void AliITSgeomMatrix::GtoLPositionErrorTracking(const Double_t g[3][3],
757 Double_t l[3][3]) const {
758 // A slightly different coordinate system is used when tracking.
759 // This coordinate system is only relevant when the geometry represents
760 // the cylindrical ALICE ITS geometry. For tracking the Z axis is left
761 // alone but X -> -Y and Y -> X such that X always points out of the
762 // ITS Cylinder for every layer including layer 1 (where the detector
763 // are mounted upside down).
764 //Begin_Html
765 /*
766 <img src="picts/ITS/AliITSgeomMatrix_TE1.gif">
767 */
768 //End_Html
769 // Inputs:
770 // Double_t g[3][3] The error matrix represented in the ALICE global
771 // coordinate system
772 // Outputs:
773 // Double_t l[3][3] the error matrix represented in the detector
774 // local coordinate system
775 // Return:
012f0f4c 776 Int_t i,j,k,m;
777 Double_t rt[3][3];
778 Double_t a0[3][3] = {{0.,+1.,0.},{-1.,0.,0.},{0.,0.,+1.}};
779 Double_t a1[3][3] = {{0.,-1.,0.},{+1.,0.,0.},{0.,0.,+1.}};
df5240ea 780
012f0f4c 781 if(fid[0]==1) for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
782 rt[i][k] = a0[i][j]*fm[j][k];
783 else for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
784 rt[i][k] = a1[i][j]*fm[j][k];
785 for(i=0;i<3;i++)for(m=0;m<3;m++){
786 l[i][m] = 0.0;
787 for(j=0;j<3;j++)for(k=0;k<3;k++)
788 l[i][m] += rt[j][i]*g[j][k]*rt[k][m];
789 } // end for i,m
790 // g = R^t l R
791 return;
df5240ea 792}
793//----------------------------------------------------------------------
023ae34b 794void AliITSgeomMatrix::LtoGPositionErrorTracking(const Double_t l[3][3],
795 Double_t g[3][3]) const {
796 // A slightly different coordinate system is used when tracking.
797 // This coordinate system is only relevant when the geometry represents
798 // the cylindrical ALICE ITS geometry. For tracking the Z axis is left
799 // alone but X -> -Y and Y -> X such that X always points out of the
800 // ITS Cylinder for every layer including layer 1 (where the detector
801 // are mounted upside down).
802 //Begin_Html
803 /*
804 <img src="picts/ITS/AliITSgeomMatrix_TE1.gif">
805 */
806 //End_Html
807 // Inputs:
808 // Double_t l[3][3] the error matrix represented in the detector
809 // local coordinate system
810 // Outputs:
811 // Double_t g[3][3] The error matrix represented in the ALICE global
812 // coordinate system
813 // Return:
814 // none.
012f0f4c 815 Int_t i,j,k,m;
816 Double_t rt[3][3];
817 Double_t a0[3][3] = {{0.,+1.,0.},{-1.,0.,0.},{0.,0.,+1.}};
818 Double_t a1[3][3] = {{0.,-1.,0.},{+1.,0.,0.},{0.,0.,+1.}};
df5240ea 819
012f0f4c 820 if(fid[0]==1) for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
821 rt[i][k] = a0[i][j]*fm[j][k];
822 else for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
823 rt[i][k] = a1[i][j]*fm[j][k];
824 for(i=0;i<3;i++)for(m=0;m<3;m++){
825 g[i][m] = 0.0;
826 for(j=0;j<3;j++)for(k=0;k<3;k++)
827 g[i][m] += rt[i][j]*l[j][k]*rt[m][k];
828 } // end for i,m
829 // g = R l R^t
830 return;
df5240ea 831}
832//----------------------------------------------------------------------
024a4246 833void AliITSgeomMatrix::PrintTitles(ostream *os) const {
023ae34b 834 // Standard output format for this class but it includes variable
835 // names and formatting that makes it easer to read.
836 // Inputs:
837 // ostream *os The output stream to print the title on
838 // Outputs:
839 // none.
840 // Return:
841 // none.
df5240ea 842 Int_t i,j;
843
844 *os << "fDetectorIndex=" << fDetectorIndex << " fid[3]={";
845 for(i=0;i<3;i++) *os << fid[i] << " ";
846 *os << "} frot[3]={";
847 for(i=0;i<3;i++) *os << frot[i] << " ";
848 *os << "} ftran[3]={";
849 for(i=0;i<3;i++) *os << ftran[i] << " ";
850 *os << "} fm[3][3]={";
851 for(i=0;i<3;i++){for(j=0;j<3;j++){ *os << fm[i][j] << " ";} *os <<"}{";}
852 *os << "}" << endl;
853 return;
854}
855//----------------------------------------------------------------------
024a4246 856void AliITSgeomMatrix::PrintComment(ostream *os) const {
023ae34b 857 // output format used by Print.
858 // Inputs:
859 // ostream *os The output stream to print the comments on
860 // Outputs:
861 // none.
862 // Return:
863 // none.
8253cd9a 864 *os << "fDetectorIndex fid[0] fid[1] fid[2] ftran[0] ftran[1] ftran[2] ";
865 *os << "fm[0][0] fm[0][1] fm[0][2] fm[1][0] fm[1][1] fm[1][2] ";
866 *os << "fm[2][0] fm[2][1] fm[2][2] ";
867 return;
868}
869//----------------------------------------------------------------------
5cf690c1 870void AliITSgeomMatrix::Print(ostream *os)const{
023ae34b 871 // Standard output format for this class.
872 // Inputs:
873 // ostream *os The output stream to print the class data on
874 // Outputs:
875 // none.
876 // Return:
877 // none.
df5240ea 878 Int_t i,j;
431a7819 879#if defined __GNUC__
880#if __GNUC__ > 2
881 ios::fmtflags fmt;
882#else
883 Int_t fmt;
884#endif
885#else
9f69211c 886#if defined __ICC || defined __ECC || defined __xlC__
94831058 887 ios::fmtflags fmt;
888#else
31b8cd63 889 Int_t fmt;
431a7819 890#endif
94831058 891#endif
df5240ea 892
8253cd9a 893 fmt = os->setf(ios::scientific); // set scientific floating point output
df5240ea 894 *os << fDetectorIndex << " ";
895 for(i=0;i<3;i++) *os << fid[i] << " ";
8253cd9a 896// for(i=0;i<3;i++) *os << frot[i] << " "; // Redundant with fm[][].
897 for(i=0;i<3;i++) *os << setprecision(16) << ftran[i] << " ";
898 for(i=0;i<3;i++)for(j=0;j<3;j++) *os << setprecision(16) <<
899 fm[i][j] << " ";
023ae34b 900 *os << fPath.Length()<< " ";
901 for(i=0;i<fPath.Length();i++) *os << fPath[i];
df5240ea 902 *os << endl;
8253cd9a 903 os->flags(fmt); // reset back to old formating.
df5240ea 904 return;
905}
906//----------------------------------------------------------------------
8253cd9a 907void AliITSgeomMatrix::Read(istream *is){
023ae34b 908 // Standard input format for this class.
909 // Inputs:
910 // istream *is The input stream to read on
911 // Outputs:
912 // none.
913 // Return:
914 // none.
df5240ea 915 Int_t i,j;
916
917 *is >> fDetectorIndex;
918 for(i=0;i<3;i++) *is >> fid[i];
8253cd9a 919// for(i=0;i<3;i++) *is >> frot[i]; // Redundant with fm[][].
df5240ea 920 for(i=0;i<3;i++) *is >> ftran[i];
921 for(i=0;i<3;i++)for(j=0;j<3;j++) *is >> fm[i][j];
5cf690c1 922 while(is->peek()==' ')is->get(); // skip white spaces
923 if(isprint(is->peek())){ // old format did not have path.
924 *is >> j; // string length
925 fPath.Resize(j);
926 for(i=0;i<j;i++) {*is >> fPath[i];}
927 } // end if
8253cd9a 928 AngleFromMatrix(); // compute angles frot[].
d8cc8493 929 fCylR = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
930 fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
547a9bad 931 if(fCylPhi<0.0) fCylPhi += 2.*TMath::Pi();
df5240ea 932 return;
933}
d8cc8493 934//______________________________________________________________________
935void AliITSgeomMatrix::Streamer(TBuffer &R__b){
936 // Stream an object of class AliITSgeomMatrix.
023ae34b 937 // Inputs:
938 // TBuffer &R__b The output buffer to stream data on.
939 // Outputs:
940 // none.
941 // Return:
942 // none.
d8cc8493 943
023ae34b 944 if (R__b.IsReading()) {
945 AliITSgeomMatrix::Class()->ReadBuffer(R__b, this);
946 fCylR = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
947 fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
948 this->AngleFromMatrix();
547a9bad 949 if(fCylPhi<0.0) fCylPhi += 2.*TMath::Pi();
023ae34b 950 } else {
951 AliITSgeomMatrix::Class()->WriteBuffer(R__b, this);
952 } // end if
d8cc8493 953}
024a4246 954//______________________________________________________________________
955void AliITSgeomMatrix::SetTranslation(const Double_t tran[3]){
023ae34b 956 // Sets the translation vector and computes fCylR and fCylPhi.
957 // Inputs:
958 // Double_t trans[3] The translation vector to be used
959 // Outputs:
960 // none.
961 // Return:
962 // none.
963 for(Int_t i=0;i<3;i++) ftran[i] = tran[i];
964 fCylR = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
965 fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
547a9bad 966 if(fCylPhi<0.0) fCylPhi += 2.*TMath::Pi();
023ae34b 967}
968//----------------------------------------------------------------------
6b0f3880 969TPolyLine3D* AliITSgeomMatrix::CreateLocalAxis() const {
023ae34b 970 // This class is used as part of the documentation of this class
971 // Inputs:
972 // none.
973 // Outputs:
974 // none.
975 // Return:
976 // A pointer to a new TPolyLine3D object showing the 3 line
977 // segments that make up the this local axis in the global
978 // reference system.
979 Float_t gf[15];
980 Double_t g[5][3];
981 Double_t l[5][3]={{1.0,0.0,0.0},{0.0,0.0,0.0},{0.0,1.0,0.0},{0.0,0.0,0.0},
982 {0.0,0.0,1.0}};
983 Int_t i;
984
985 for(i=0;i<5;i++) {
986 LtoGPosition(l[i],g[i]);
987 gf[3*i]=(Float_t)g[i][0];
988 gf[3*i+1]=(Float_t)g[i][1];
989 gf[3*i+2]=(Float_t)g[i][2];
990 } // end for i
991 return new TPolyLine3D(5,gf);
992}
993//----------------------------------------------------------------------
6b0f3880 994TPolyLine3D* AliITSgeomMatrix::CreateLocalAxisTracking() const {
023ae34b 995 // This class is used as part of the documentation of this class
996 // Inputs:
997 // none.
998 // Outputs:
999 // none.
1000 // Return:
1001 // A pointer to a new TPolyLine3D object showing the 3 line
1002 // segments that make up the this local axis in the global
1003 // reference system.
1004 Float_t gf[15];
1005 Double_t g[5][3];
1006 Double_t l[5][3]={{1.0,0.0,0.0},{0.0,0.0,0.0},{0.0,1.0,0.0},{0.0,0.0,0.0},
1007 {0.0,0.0,1.0}};
1008 Int_t i;
1009
1010 for(i=0;i<5;i++) {
1011 LtoGPositionTracking(l[i],g[i]);
1012 gf[3*i]=(Float_t)g[i][0];
1013 gf[3*i+1]=(Float_t)g[i][1];
1014 gf[3*i+2]=(Float_t)g[i][2];
1015 } // end for i
1016 return new TPolyLine3D(5,gf);
1017}
1018//----------------------------------------------------------------------
1019TNode* AliITSgeomMatrix::CreateNode(const Char_t *nodeName,
1020 const Char_t *nodeTitle,TNode *mother,
6b0f3880 1021 TShape *shape,Bool_t axis) const {
023ae34b 1022 // Creates a node inside of the node mother out of the shape shape
1023 // in the position, with respect to mother, indecated by "this". If axis
1024 // is ture, it will insert an axis within this node/shape.
1025 // Inputs:
1026 // Char_t *nodeName This name of this node
1027 // Char_t *nodeTitle This node title
1028 // TNode *mother The node this node will be inside of/with respect to
1029 // TShape *shape The shape of this node
1030 // Bool_t axis If ture, a set of x,y,z axis will be included
1031 // Outputs:
1032 // none.
1033 // Return:
1034 // A pointer to "this" node.
1035 Double_t trans[3],matrix[3][3],*matr;
1036 TRotMatrix *rot = new TRotMatrix();
1037 TString name,title;
1038
1039 matr = &(matrix[0][0]);
1040 this->GetTranslation(trans);
1041 this->GetMatrix(matrix);
1042 rot->SetMatrix(matr);
1043 //
1044 name = nodeName;
1045 title = nodeTitle;
1046 //
1047 mother->cd();
012f0f4c 1048 TNode *node1 = new TNode(name.Data(),title.Data(),shape,
1049 trans[0],trans[1],trans[2],rot);
023ae34b 1050 if(axis){
1051 Int_t i,j;
6b0f3880 1052 const Float_t kScale=0.5,kLw=0.2;
012f0f4c 1053 Float_t xchar[13][2]={
1054 {0.5*kLw,1.},{0.,0.5*kLw},{0.5-0.5*kLw,0.5},
1055 {0.,0.5*kLw},{0.5*kLw,0.},{0.5,0.5-0.5*kLw},
1056 {1-0.5*kLw,0.},{1.,0.5*kLw},{0.5+0.5*kLw,0.5},
1057 {1.,1.-0.5*kLw},{1.-0.5*kLw,1.},{0.5,0.5+0.5*kLw},
1058 {0.5*kLw,1.}};
1059 Float_t ychar[10][2]={
1060 {.5-0.5*kLw,0.},{.5+0.5*kLw,0.},{.5+0.5*kLw,0.5-0.5*kLw},
1061 {1.,1.-0.5*kLw},{1.-0.5*kLw,1.},{0.5+0.5*kLw,0.5},
1062 {0.5*kLw,1.} ,{0.,1-0.5*kLw} ,{0.5-0.5*kLw,0.5},
1063 {.5-0.5*kLw,0.}};
1064 Float_t zchar[11][2]={
1065 {0.,1.},{0,1.-kLw},{1.-kLw,1.-kLw},{0.,kLw} ,{0.,0.},
1066 {1.,0.},{1.,kLw} ,{kLw,kLw} ,{1.,1.-kLw},{1.,1.},
1067 {0.,1.}};
023ae34b 1068 for(i=0;i<13;i++)for(j=0;j<2;j++){
6b0f3880 1069 if(i<13) xchar[i][j] = kScale*xchar[i][j];
1070 if(i<10) ychar[i][j] = kScale*ychar[i][j];
1071 if(i<11) zchar[i][j] = kScale*zchar[i][j];
023ae34b 1072 } // end for i,j
1073 TXTRU *axisxl = new TXTRU("x","x","text",12,2);
1074 for(i=0;i<12;i++) axisxl->DefineVertex(i,xchar[i][0],xchar[i][1]);
6b0f3880 1075 axisxl->DefineSection(0,-0.5*kLw);axisxl->DefineSection(1,0.5*kLw);
023ae34b 1076 TXTRU *axisyl = new TXTRU("y","y","text",9,2);
1077 for(i=0;i<9;i++) axisyl->DefineVertex(i,ychar[i][0],ychar[i][1]);
6b0f3880 1078 axisyl->DefineSection(0,-0.5*kLw);axisyl->DefineSection(1,0.5*kLw);
023ae34b 1079 TXTRU *axiszl = new TXTRU("z","z","text",10,2);
1080 for(i=0;i<10;i++) axiszl->DefineVertex(i,zchar[i][0],zchar[i][1]);
6b0f3880 1081 axiszl->DefineSection(0,-0.5*kLw);axiszl->DefineSection(1,0.5*kLw);
012f0f4c 1082 Float_t lxy[13][2]={
1083 {-0.5*kLw,-0.5*kLw},{0.8,-0.5*kLw},{0.8,-0.1},{1.0,0.0},
1084 {0.8,0.1},{0.8,0.5*kLw},{0.5*kLw,0.5*kLw},{0.5*kLw,0.8},
1085 {0.1,0.8},{0.0,1.0},{-0.1,0.8},{-0.5*kLw,0.8},
1086 {-0.5*kLw,-0.5*kLw}};
023ae34b 1087 TXTRU *axisxy = new TXTRU("axisxy","axisxy","text",13,2);
1088 for(i=0;i<13;i++) axisxy->DefineVertex(i,lxy[i][0],lxy[i][1]);
6b0f3880 1089 axisxy->DefineSection(0,-0.5*kLw);axisxy->DefineSection(1,0.5*kLw);
012f0f4c 1090 Float_t lz[8][2]={
1091 {0.5*kLw,-0.5*kLw},{0.8,-0.5*kLw},{0.8,-0.1},{1.0,0.0},
1092 {0.8,0.1},{0.8,0.5*kLw},{0.5*kLw,0.5*kLw},
1093 {0.5*kLw,-0.5*kLw}};
023ae34b 1094 TXTRU *axisz = new TXTRU("axisz","axisz","text",8,2);
1095 for(i=0;i<8;i++) axisz->DefineVertex(i,lz[i][0],lz[i][1]);
6b0f3880 1096 axisz->DefineSection(0,-0.5*kLw);axisz->DefineSection(1,0.5*kLw);
023ae34b 1097 //TRotMatrix *xaxis90= new TRotMatrix("xaixis90","",90.0, 0.0, 0.0);
1098 TRotMatrix *yaxis90= new TRotMatrix("yaixis90","", 0.0,90.0, 0.0);
1099 TRotMatrix *zaxis90= new TRotMatrix("zaixis90","", 0.0, 0.0,90.0);
1100 //
1101 node1->cd();
1102 title = name.Append("axisxy");
1103 TNode *nodeaxy = new TNode(title.Data(),title.Data(),axisxy);
1104 title = name.Append("axisz");
012f0f4c 1105 TNode *nodeaz = new TNode(title.Data(),title.Data(),axisz,
1106 0.,0.,0.,yaxis90);
023ae34b 1107 TNode *textboxX0 = new TNode("textboxX0","textboxX0",axisxl,
1108 lxy[3][0],lxy[3][1],0.0);
1109 TNode *textboxX1 = new TNode("textboxX1","textboxX1",axisxl,
1110 lxy[3][0],lxy[3][1],0.0,yaxis90);
1111 TNode *textboxX2 = new TNode("textboxX2","textboxX2",axisxl,
1112 lxy[3][0],lxy[3][1],0.0,zaxis90);
1113 TNode *textboxY0 = new TNode("textboxY0","textboxY0",axisyl,
1114 lxy[9][0],lxy[9][1],0.0);
1115 TNode *textboxY1 = new TNode("textboxY1","textboxY1",axisyl,
1116 lxy[9][0],lxy[9][1],0.0,yaxis90);
1117 TNode *textboxY2 = new TNode("textboxY2","textboxY2",axisyl,
1118 lxy[9][0],lxy[9][1],0.0,zaxis90);
1119 TNode *textboxZ0 = new TNode("textboxZ0","textboxZ0",axiszl,
1120 0.0,0.0,lz[3][0]);
1121 TNode *textboxZ1 = new TNode("textboxZ1","textboxZ1",axiszl,
1122 0.0,0.0,lz[3][0],yaxis90);
1123 TNode *textboxZ2 = new TNode("textboxZ2","textboxZ2",axiszl,
1124 0.0,0.0,lz[3][0],zaxis90);
1125 nodeaxy->Draw();
1126 nodeaz->Draw();
1127 textboxX0->Draw();
1128 textboxX1->Draw();
1129 textboxX2->Draw();
1130 textboxY0->Draw();
1131 textboxY1->Draw();
1132 textboxY2->Draw();
1133 textboxZ0->Draw();
1134 textboxZ1->Draw();
1135 textboxZ2->Draw();
1136 } // end if
1137 mother->cd();
1138 return node1;
024a4246 1139}
023ae34b 1140//----------------------------------------------------------------------
6b0f3880 1141void AliITSgeomMatrix::MakeFigures() const {
023ae34b 1142 // make figures to help document this class
1143 // Inputs:
1144 // none.
1145 // Outputs:
1146 // none.
1147 // Return:
1148 // none.
6b0f3880 1149 const Double_t kDx0=550.,kDy0=550.,kDz0=550.; // cm
1150 const Double_t kDx=1.0,kDy=0.300,kDz=3.0,kRmax=0.1; // cm
023ae34b 1151 Float_t l[5][3]={{1.0,0.0,0.0},{0.0,0.0,0.0},{0.0,1.0,0.0},{0.0,0.0,0.0},
1152 {0.0,0.0,1.0}};
1153 TCanvas *c = new TCanvas(kFALSE);// create a batch mode canvas.
5385facc 1154#if ROOT_VERSION_CODE>= 331523
1155 Double_t rmin[]={-1,-1,-1};
1156 Double_t rmax[]={ 1, 1, 1};
1157 TView *view = new TView3D(1,rmin,rmax);
1158#else
023ae34b 1159 TView *view = new TView(1); // Create Cartesian coordiante view
5385facc 1160#endif
6b0f3880 1161 TBRIK *mother = new TBRIK("Mother","Mother","void",kDx0,kDy0,kDz0);
1162 TBRIK *det = new TBRIK("Detector","","Si",kDx,kDy,kDz);
023ae34b 1163 TPolyLine3D *axis = new TPolyLine3D(5,&(l[0][0]));
1164 TPCON *arrow = new TPCON("arrow","","air",0.0,360.,2);
1165 TRotMatrix *xarrow= new TRotMatrix("xarrow","",90.,0.0,0.0);
1166 TRotMatrix *yarrow= new TRotMatrix("yarrow","",0.0,90.,0.0);
024a4246 1167
023ae34b 1168 det->SetLineColor(0); // black
1169 det->SetLineStyle(1); // solid line
1170 det->SetLineWidth(2); // pixel units
1171 det->SetFillColor(1); // black
1172 det->SetFillStyle(4010); // window is 90% transparent
1173 arrow->SetLineColor(det->GetLineColor());
1174 arrow->SetLineWidth(det->GetLineWidth());
1175 arrow->SetLineStyle(det->GetLineStyle());
1176 arrow->SetFillColor(1); // black
1177 arrow->SetFillStyle(4100); // window is 100% opaque
6b0f3880 1178 arrow->DefineSection(0,0.0,0.0,kRmax);
1179 arrow->DefineSection(1,2.*kRmax,0.0,0.0);
1180 view->SetRange(-kDx0,-kDy0,-kDz0,kDx0,kDy0,kDz0);
023ae34b 1181 //
1182 TNode *node0 = new TNode("NODE0","NODE0",mother);
1183 node0->cd();
1184 TNode *node1 = new TNode("NODE1","NODE1",det);
1185 node1->cd();
012f0f4c 1186 TNode *nodex = new TNode("NODEx","NODEx",arrow,
1187 l[0][0],l[0][1],l[0][2],xarrow);
1188 TNode *nodey = new TNode("NODEy","NODEy",arrow,
1189 l[2][0],l[2][1],l[2][2],yarrow);
023ae34b 1190 TNode *nodez = new TNode("NODEz","NODEz",arrow,l[4][0],l[4][1],l[4][2]);
1191 //
1192 axis->Draw();
1193 nodex->Draw();
1194 nodey->Draw();
1195 nodez->Draw();
1196
1197 //
1198 node0->cd();
1199 node0->Draw();
1200 c->Update();
1201 c->SaveAs("AliITSgeomMatrix_L1.gif");
1202}
df5240ea 1203//----------------------------------------------------------------------
1204ostream &operator<<(ostream &os,AliITSgeomMatrix &p){
023ae34b 1205 // Standard output streaming function.
1206 // Inputs:
1207 // ostream &os The output stream to print the class data on
1208 // AliITSgeomMatrix &p This class
1209 // Outputs:
1210 // none.
1211 // Return:
1212 // none.
df5240ea 1213
8253cd9a 1214 p.Print(&os);
df5240ea 1215 return os;
1216}
1217//----------------------------------------------------------------------
1218istream &operator>>(istream &is,AliITSgeomMatrix &r){
023ae34b 1219 // Standard input streaming function.
1220 // Inputs:
1221 // ostream &os The input stream to print the class data on
1222 // AliITSgeomMatrix &p This class
1223 // Outputs:
1224 // none.
1225 // Return:
1226 // none.
df5240ea 1227
8253cd9a 1228 r.Read(&is);
df5240ea 1229 return is;
1230}
8253cd9a 1231//----------------------------------------------------------------------