]> git.uio.no Git - u/mrichter/AliRoot.git/blob - ITS/AliITSgeomMatrix.h
Removing warnings (alpha)
[u/mrichter/AliRoot.git] / ITS / AliITSgeomMatrix.h
1 #ifndef ALIITSGEOMMATRIX_H
2 #define ALIITSGEOMMATRIX_H
3 /* Copyright(c) 2000, ALICE Experiment at CERN, All rights reserved. *
4  * see cxx source for full Copyright notice.                         */
5 /* $Id: */
6 ////////////////////////////////////////////////////////////////////////
7 // ITS geometry manipulation routines on the module level. This class is
8 // to replace the structure ITS_geom in the class AliITSgeom.
9 // Created May 30 2000.
10 // version 0.0.0
11 // By Bjorn S. Nilsen
12 ////////////////////////////////////////////////////////////////////////
13
14 #include <TObject.h>
15
16 class AliITSgeomMatrix : public TObject {
17  public:
18         AliITSgeomMatrix(); // Default constructor
19         // Standard constructor #1
20         AliITSgeomMatrix(Int_t idt,const Int_t id[3],
21                          const Double_t rot[3],const Double_t tran[3]);
22         // Standard constructor #2
23         AliITSgeomMatrix(Int_t idt,const Int_t id[3],
24                          Double_t matrix[3][3],const Double_t tran[3]);
25         // Standard constructor #3
26         AliITSgeomMatrix(const Double_t rotd[6]/*degrees GEANT angles*/,
27                          Int_t idt,const Int_t id[3],
28                          const Double_t tran[3]);
29         // Copy operator
30         AliITSgeomMatrix(const AliITSgeomMatrix &source);
31         // Alignment operator
32         void operator=(const AliITSgeomMatrix &sourse); // copy
33         virtual ~AliITSgeomMatrix(){}; // default constructor.
34         // Prints a line describing the output format of the function Print.
35         void PrintComment(ostream *os);
36         // Prints out the content of this class in ASCII format.
37         void Print(ostream *os);
38         // Prints out the content of this class in ASCII format but includes
39         // formating and strings that make it more humanly readable.
40         void PrintTitles(ostream *os);
41         // Reads in the content of this class in the format of Print
42         void Read(istream *is);
43
44         // Given the rotation angles [radians] it fills frot and computes
45         // the rotation matrix fm.
46         void SetAngles(const Double_t rot[3]){// [radians]
47               for(Int_t i=0;i<3;i++)frot[i] = rot[i];this->MatrixFromAngle();}
48         // Sets the translation vector and computes fCylR and fCylPhi.
49         void SetTranslation(const Double_t tran[3]){
50                             for(Int_t i=0;i<3;i++) ftran[i] = tran[i];
51                             fCylR   = TMath::Sqrt(ftran[0]*ftran[0]+
52                                                   ftran[1]*ftran[1]);
53                             fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
54                             if(fCylPhi<0.0) fCylPhi += TMath::Pi();}
55         // sets the rotation matrix and computes the rotation angles [radians]
56         void SetMatrix(Double_t matrix[3][3]){ for(Int_t i=0;i<3;i++)
57          for(Int_t j=0;j<3;j++) fm[i][j]=matrix[i][j];this->AngleFromMatrix();}
58         // Sets the detector index value
59         void SetDetectorIndex(Int_t idt) {fDetectorIndex = idt;}
60         // Sets the detector layer, ladder, detector (id) values.
61         void SetIndex(const Int_t id[3]){
62                            for(Int_t i=0;i<3;i++) fid[i] = id[i];}
63         // Returns the rotation angles [radians]
64         void GetAngles(Double_t rot[3]){// [radians]
65                            for(Int_t i=0;i<3;i++)  rot[i] = frot[i];}
66         // Returns the translation vector [cm]
67         void GetTranslation(Double_t tran[3]){
68                             for(Int_t i=0;i<3;i++) tran[i] = ftran[i];}
69         // Returns the translation vector in cylindrical
70         // coordinates [cm,radians]
71         void GetTranslationCylinderical(Double_t tran[3]){
72                             tran[0] = fCylR;
73                             tran[1] = fCylPhi;
74                             tran[2] = ftran[2];}
75         // Returns the values of the rotation matrix
76         void GetMatrix(Double_t matrix[3][3]){for(Int_t i=0;i<3;i++)
77                          for(Int_t j=0;j<3;j++) matrix[i][j] = fm[i][j];}
78         // Returns the detector index value.
79         Int_t GetDetectorIndex() const {return fDetectorIndex;}
80         // returns the modules index layer, ladder, detector
81         void  GetIndex(Int_t id[3]){for(Int_t i=0;i<3;i++) id[i] = fid[i];}
82         // Sets the rotation matrix based on the 6 GEANT rotation
83         // angles [radian]
84         void  MatrixFromSixAngles(const Double_t *ang);
85         // Returns the 6 GEANT rotation angles [radians] from the
86         // existing rotation matrix.
87         void  SixAnglesFromMatrix(Double_t *ang);
88
89         // Given a position in Cartesian ALICE global coordinates [cm]
90         // returns the position in Cartesian detector/module local
91         //coordinates [cm]
92         void GtoLPosition(const Double_t g[3],Double_t l[3]);
93         // Given a position in Cartesian detector/module local coordinates [cm]
94         // returns the position in Cartesian ALICE global
95         //coordinates [cm]
96         void LtoGPosition(const Double_t l[3],Double_t g[3]);
97         // Given a momentum in Cartesian ALICE global coordinates
98         // returns the momentum in Cartesian detector/module local
99         //coordinates
100         void GtoLMomentum(const Double_t g[3],Double_t l[3]);
101         // Given a momentum in Cartesian detector/module local coordinates 
102         // returns the momentum in Cartesian ALICE global coordinates
103         void LtoGMomentum(const Double_t l[3],Double_t g[3]);
104         // given a position error matrix in ALICE Cartesian global
105         // coordinates [cm] returns a position error matrix in detector/
106         // module local Cartesian local coordinates [cm]
107         void GtoLPositionError(Double_t g[3][3],Double_t l[3][3]);
108         // given a position error matrix in detector/module Cartesian local
109         // coordinates [cm] returns a position error matrix in ALICE
110         // Cartesian global coordinates [cm]
111         void LtoGPositionError(Double_t l[3][3],Double_t g[3][3]);
112         // Tracking Related Routines
113         void GtoLPositionTracking(const Double_t g[3],Double_t l[3]);
114         // Given a position in Cartesian Tracking global coordinates [cm]
115         // returns the position in Cartesian detector/module local
116         // coordinates [cm]
117         void LtoGPositionTracking(const Double_t l[3],Double_t g[3]);
118         // Given a position in Cartesian detector/module local coordinates [cm]
119         // returns the position in Cartesian Tracking global
120         //coordinates [cm]
121         void GtoLMomentumTracking(const Double_t g[3],Double_t l[3]);
122         // Given a momentum in Cartesian detector/module local coordinates 
123         // returns the momentum in Cartesian Tracking global coordinates
124         void LtoGMomentumTracking(const Double_t l[3],Double_t g[3]);
125         // given a position error matrix in Tracking Cartesian global
126         // coordinates [cm] returns a position error matrix in detector/
127         // module local Cartesian local coordinates [cm]
128         void GtoLPositionErrorTracking(Double_t g[3][3],
129                                        Double_t l[3][3]);
130         // given a position error matrix in detector/module Cartesian local
131         // coordinates [cm] returns a position error matrix in Tracking
132         // Cartesian global coordinates [cm]
133         void LtoGPositionErrorTracking(Double_t l[3][3],
134                                        Double_t g[3][3]);
135         // Computes the distance squared [cm^2] between a point t[3] and
136         // this module/detector
137         Double_t Distance2(const Double_t t[3]){Double_t d=0.0,q;
138                  for(Int_t i=0;i<3;i++){q = t[i]-ftran[i]; d += q*q;}
139                  return d;}
140  private: // private functions
141         // Given the rotation matrix fm it fills the rotation angles frot
142         void MatrixFromAngle();
143         // Given the rotation angles frot it fills the rotation matrix fm
144         void AngleFromMatrix();
145  private: // Data members.
146         Int_t    fDetectorIndex; // Detector type index (like fShapeIndex was)
147         Int_t    fid[3];         // layer, ladder, detector numbers.
148         Double_t frot[3];        //! vector of rotations about x,y,z [radians].
149         Double_t ftran[3];       // Translation vector of module x,y,z.
150         Double_t fCylR,fCylPhi;  //! Translation vector in Cylindrical coord.
151         Double_t fm[3][3];       // Rotation matrix based on frot.
152
153         // Note, fCylR and fCylPhi are added as data members because it costs
154         // about a factor of 10 to compute them over looking them up. Since
155         // they are used in some tracking algorithms this can be a large cost
156         // in computing time. They are not written out but computed.
157
158         ClassDef(AliITSgeomMatrix,1) // Matrix class used by AliITSgeom.
159 };
160 // Input and output function for standard C++ input/output.
161 ostream &operator<<(ostream &os,AliITSgeomMatrix &source);
162 istream &operator>>(istream &os,AliITSgeomMatrix &source);
163
164 #endif