Logo ROOT  
Reference Guide
TRotation.h
Go to the documentation of this file.
1 // @(#)root/physics:$Id$
2 // Author: Peter Malzacher 19/06/99
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 #ifndef ROOT_TRotation
12 #define ROOT_TRotation
13 
14 #include "TObject.h"
15 
16 #include "TVector3.h"
17 
18 class TQuaternion;
19 
20 class TRotation : public TObject {
21 
22 public:
23 
24 class TRotationRow {
25 public:
26  inline TRotationRow(const TRotation &, int);
27  inline TRotationRow(const TRotationRow &);
28  inline TRotationRow & operator=(const TRotationRow &);
29  inline Double_t operator [] (int) const;
30 private:
31  const TRotation * fRR;
32  // const TRotation & fRR;
33  int fII;
34 };
35  // Helper class for implemention of C-style subscripting r[i][j]
36 
37  TRotation();
38  // Default constructor. Gives a unit matrix.
39 
40  TRotation(const TRotation &);
41  TRotation(const TQuaternion &);
42  // Copy constructor.
43 
44  virtual ~TRotation() {;};
45 
46  inline Double_t XX() const;
47  inline Double_t XY() const;
48  inline Double_t XZ() const;
49  inline Double_t YX() const;
50  inline Double_t YY() const;
51  inline Double_t YZ() const;
52  inline Double_t ZX() const;
53  inline Double_t ZY() const;
54  inline Double_t ZZ() const;
55  // Elements of the rotation matrix (Geant4).
56 
57  inline TRotationRow operator [] (int) const;
58  // Returns object of the helper class for C-style subscripting r[i][j]
59 
60  Double_t operator () (int, int) const;
61  // Fortran-style subscripting: returns (i,j) element of the rotation matrix.
62 
63  inline TRotation & operator = (const TRotation &);
64  // Assignment.
65 
66  inline Bool_t operator == (const TRotation &) const;
67  inline Bool_t operator != (const TRotation &) const;
68  // Comparisons (Geant4).
69 
70  inline Bool_t IsIdentity() const;
71  // Returns true if the identity matrix (Geant4).
72 
73  inline TVector3 operator * (const TVector3 &) const;
74  // Multiplication with a TVector3.
75 
76  TRotation operator * (const TRotation &) const;
77  inline TRotation & operator *= (const TRotation &);
78  inline TRotation & Transform(const TRotation &);
79  // Matrix multiplication.
80  // Note a *= b; <=> a = a * b; while a.transform(b); <=> a = b * a;
81 
82  inline TRotation Inverse() const;
83  // Returns the inverse.
84 
85  inline TRotation & Invert();
86  // Inverts the Rotation matrix.
87 
89  // Rotation around the x-axis.
90 
92  // Rotation around the y-axis.
93 
95  // Rotation around the z-axis.
96 
97  TRotation & Rotate(Double_t, const TVector3 &);
98  inline TRotation & Rotate(Double_t, const TVector3 *);
99  // Rotation around a specified vector.
100 
101  TRotation & RotateAxes(const TVector3 & newX,
102  const TVector3 & newY,
103  const TVector3 & newZ);
104  // Rotation of local axes (Geant4).
105 
106  Double_t PhiX() const;
107  Double_t PhiY() const;
108  Double_t PhiZ() const;
109  Double_t ThetaX() const;
110  Double_t ThetaY() const;
111  Double_t ThetaZ() const;
112  // Return angles (RADS) made by rotated axes against original axes (Geant4).
113 
114  void AngleAxis(Double_t &, TVector3 &) const;
115  // Returns the rotation angle and rotation axis (Geant4).
116 
117  inline TRotation & SetToIdentity();
118  // Set equal to the identity rotation.
119 
121  void SetXPhi(Double_t);
122  void SetXTheta(Double_t);
123  void SetXPsi(Double_t);
124  // Set the euler angles of the rotation. The angles are defined using the
125  // y-convention which rotates around the Z axis, around the new X axis, and
126  // then around the new Z axis. The x-convention is used Goldstein, Landau
127  // and Lifshitz, and other common physics texts. Contrast this with
128  // SetYEulerAngles.
129 
131  // Adds a rotation of the local axes defined by the Euler angle to the
132  // current rotation. See SetXEulerAngles for a note about conventions.
133 
134  Double_t GetXPhi(void) const;
135  Double_t GetXTheta(void) const;
136  Double_t GetXPsi(void) const;
137  // Return the euler angles of the rotation. See SetYEulerAngles for a
138  // note about conventions.
139 
141  void SetYPhi(Double_t);
142  void SetYTheta(Double_t);
143  void SetYPsi(Double_t);
144  // Set the euler angles of the rotation. The angles are defined using the
145  // y-convention which rotates around the Z axis, around the new Y axis, and
146  // then around the new Z axis. The x-convention is used Goldstein, Landau
147  // and Lifshitz, and other common physics texts and is a rotation around the
148  // Z axis, around the new X axis, and then around the new Z axis.
149 
151  // Adds a rotation of the local axes defined by the Euler angle to the
152  // current rotation. See SetYEulerAngles for a note about conventions.
153 
154  Double_t GetYPhi(void) const;
155  Double_t GetYTheta(void) const;
156  Double_t GetYPsi(void) const;
157  // Return the euler angles of the rotation. See SetYEulerAngles for a
158  // note about conventions.
159 
160  TRotation & SetXAxis(const TVector3& axis);
161  TRotation & SetXAxis(const TVector3& axis, const TVector3& xyPlane);
162  TRotation & SetYAxis(const TVector3& axis);
163  TRotation & SetYAxis(const TVector3& axis, const TVector3& yzPlane);
164  TRotation & SetZAxis(const TVector3& axis);
165  TRotation & SetZAxis(const TVector3& axis, const TVector3& zxPlane);
166  // Create a rotation with the axis vector parallel to the rotated coordinate
167  // system. If a second vector is provided it defines a plane passing
168  // through the axis.
169 
170  void MakeBasis(TVector3& xAxis, TVector3& yAxis, TVector3& zAxis) const;
171  // Take two input vectors (in xAxis, and zAxis) and turn them into an
172  // orthogonal basis. This is an internal helper function used to implement
173  // the Set?Axis functions, but is exposed because the functionality is
174  // often useful.
175 
176 protected:
177 
180  // Protected constructor.
181 
183  // The matrix elements.
184 
185  ClassDef(TRotation,1) // Rotations of TVector3 objects
186 
187 };
188 
189 
190 inline Double_t TRotation::XX() const { return fxx; }
191 inline Double_t TRotation::XY() const { return fxy; }
192 inline Double_t TRotation::XZ() const { return fxz; }
193 inline Double_t TRotation::YX() const { return fyx; }
194 inline Double_t TRotation::YY() const { return fyy; }
195 inline Double_t TRotation::YZ() const { return fyz; }
196 inline Double_t TRotation::ZX() const { return fzx; }
197 inline Double_t TRotation::ZY() const { return fzy; }
198 inline Double_t TRotation::ZZ() const { return fzz; }
199 
201 (const TRotation & r, int i) : fRR(&r), fII(i) {}
202 
204 (const TRotationRow & rr) : fRR(rr.fRR), fII(rr.fII) {}
205 
207  fRR = rr.fRR;
208  fII = rr.fII;
209  return *this;
210 }
211 
213  return fRR->operator()(fII,jj);
214 }
215 
217  return TRotationRow(*this, i);
218 }
219 
221  fxx = m.fxx;
222  fxy = m.fxy;
223  fxz = m.fxz;
224  fyx = m.fyx;
225  fyy = m.fyy;
226  fyz = m.fyz;
227  fzx = m.fzx;
228  fzy = m.fzy;
229  fzz = m.fzz;
230  return *this;
231 }
232 
234  return (fxx == m.fxx && fxy == m.fxy && fxz == m.fxz &&
235  fyx == m.fyx && fyy == m.fyy && fyz == m.fyz &&
236  fzx == m.fzx && fzy == m.fzy && fzz == m.fzz) ? kTRUE : kFALSE;
237 }
238 
240  return (fxx != m.fxx || fxy != m.fxy || fxz != m.fxz ||
241  fyx != m.fyx || fyy != m.fyy || fyz != m.fyz ||
242  fzx != m.fzx || fzy != m.fzy || fzz != m.fzz) ? kTRUE : kFALSE;
243 }
244 
246  return (fxx == 1.0 && fxy == 0.0 && fxz == 0.0 &&
247  fyx == 0.0 && fyy == 1.0 && fyz == 0.0 &&
248  fzx == 0.0 && fzy == 0.0 && fzz == 1.0) ? kTRUE : kFALSE;
249 }
250 
252  fxx = fyy = fzz = 1.0;
253  fxy = fxz = fyx = fyz = fzx = fzy = 0.0;
254  return *this;
255 }
256 
257 inline TVector3 TRotation::operator * (const TVector3 & p) const {
258  return TVector3(fxx*p.X() + fxy*p.Y() + fxz*p.Z(),
259  fyx*p.X() + fyy*p.Y() + fyz*p.Z(),
260  fzx*p.X() + fzy*p.Y() + fzz*p.Z());
261 }
262 
264  return *this = operator * (m);
265 }
266 
268  return *this = m.operator * (*this);
269 }
270 
272  return TRotation(fxx, fyx, fzx, fxy, fyy, fzy, fxz, fyz, fzz);
273 }
274 
276  return *this=Inverse();
277 }
278 
279 inline TRotation & TRotation::Rotate(Double_t psi, const TVector3 * p) {
280  return Rotate(psi, *p);
281 }
282 
283 
284 
285 #endif
TRotation::operator*
TVector3 operator*(const TVector3 &) const
Definition: TRotation.h:257
TRotation::YY
Double_t YY() const
Definition: TRotation.h:194
m
auto * m
Definition: textangle.C:8
TVector3
Definition: TVector3.h:22
TRotation::GetYPsi
Double_t GetYPsi(void) const
Return YPsi.
Definition: TRotation.cxx:690
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
TRotation::SetXPhi
void SetXPhi(Double_t)
Set XPhi.
Definition: TRotation.cxx:536
TRotation::YZ
Double_t YZ() const
Definition: TRotation.h:195
TRotation::fzz
Double_t fzz
Definition: TRotation.h:182
TVector3::Y
Double_t Y() const
Definition: TVector3.h:217
TRotation::TRotationRow
Definition: TRotation.h:24
TRotation::ThetaZ
Double_t ThetaZ() const
Return Theta.
Definition: TRotation.cxx:455
TRotation::Rotate
TRotation & Rotate(Double_t, const TVector3 &)
Rotate along an axis.
Definition: TRotation.cxx:324
TRotation::ZX
Double_t ZX() const
Definition: TRotation.h:196
TRotation::RotateYEulerAngles
TRotation & RotateYEulerAngles(Double_t phi, Double_t theta, Double_t psi)
Rotate using the y-convention.
Definition: TRotation.cxx:525
TRotation::SetXAxis
TRotation & SetXAxis(const TVector3 &axis)
Set X axis.
Definition: TRotation.cxx:712
r
ROOT::R::TRInterface & r
Definition: Object.C:4
TRotation::operator=
TRotation & operator=(const TRotation &)
Definition: TRotation.h:220
TRotation::GetYPhi
Double_t GetYPhi(void) const
Return YPhi.
Definition: TRotation.cxx:623
TRotation::XZ
Double_t XZ() const
Definition: TRotation.h:192
TRotation::TRotationRow::fII
int fII
Definition: TRotation.h:33
TRotation::fzy
Double_t fzy
Definition: TRotation.h:182
TRotation::TRotation
TRotation()
Constructor.
Definition: TRotation.cxx:195
TRotation::SetXTheta
void SetXTheta(Double_t)
Set XTheta.
Definition: TRotation.cxx:543
TRotation::GetXPsi
Double_t GetXPsi(void) const
Get psi angle.
Definition: TRotation.cxx:644
Bool_t
bool Bool_t
Definition: RtypesCore.h:63
TRotation::YX
Double_t YX() const
Definition: TRotation.h:193
TRotation::MakeBasis
void MakeBasis(TVector3 &xAxis, TVector3 &yAxis, TVector3 &zAxis) const
Make the Z axis into a unit variable.
Definition: TRotation.cxx:766
bool
TRotation::GetYTheta
Double_t GetYTheta(void) const
Return YTheta.
Definition: TRotation.cxx:637
TRotation::ZZ
Double_t ZZ() const
Definition: TRotation.h:198
TVector3.h
TRotation::ThetaX
Double_t ThetaX() const
Return Theta.
Definition: TRotation.cxx:441
TRotation::PhiX
Double_t PhiX() const
Return Phi.
Definition: TRotation.cxx:420
TRotation::fyz
Double_t fyz
Definition: TRotation.h:182
TRotation::SetYAxis
TRotation & SetYAxis(const TVector3 &axis)
Set Y axis.
Definition: TRotation.cxx:735
TRotation::fxx
Double_t fxx
Definition: TRotation.h:182
TRotation::SetXEulerAngles
TRotation & SetXEulerAngles(Double_t phi, Double_t theta, Double_t psi)
Rotate using the x-convention (Landau and Lifshitz, Goldstein, &c) by doing the explicit rotations.
Definition: TRotation.cxx:487
TRotation::SetYTheta
void SetYTheta(Double_t)
Set YTheta.
Definition: TRotation.cxx:564
TRotation::SetYEulerAngles
TRotation & SetYEulerAngles(Double_t phi, Double_t theta, Double_t psi)
Rotate using the y-convention.
Definition: TRotation.cxx:501
TRotation::operator()
Double_t operator()(int, int) const
Dereferencing operator const.
Definition: TRotation.cxx:218
TRotation::TRotationRow::TRotationRow
TRotationRow(const TRotation &, int)
Definition: TRotation.h:201
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
TRotation::TRotationRow::fRR
const TRotation * fRR
Definition: TRotation.h:31
TRotation::TRotationRow::operator[]
Double_t operator[](int) const
Definition: TRotation.h:212
TRotation::XY
Double_t XY() const
Definition: TRotation.h:191
TRotation::AngleAxis
void AngleAxis(Double_t &, TVector3 &) const
Rotation defined by an angle and a vector.
Definition: TRotation.cxx:462
TRotation::Transform
TRotation & Transform(const TRotation &)
Definition: TRotation.h:267
TRotation::ZY
Double_t ZY() const
Definition: TRotation.h:197
TRotation::IsIdentity
Bool_t IsIdentity() const
Definition: TRotation.h:245
TRotation::RotateZ
TRotation & RotateZ(Double_t)
Rotate around z.
Definition: TRotation.cxx:377
TRotation::operator*=
TRotation & operator*=(const TRotation &)
Definition: TRotation.h:263
TRotation::operator!=
Bool_t operator!=(const TRotation &) const
Definition: TRotation.h:239
TRotation::TRotationRow::operator=
TRotationRow & operator=(const TRotationRow &)
Definition: TRotation.h:206
TRotation
Definition: TRotation.h:20
TRotation::Invert
TRotation & Invert()
Definition: TRotation.h:275
TRotation::fxz
Double_t fxz
Definition: TRotation.h:182
TRotation::fzx
Double_t fzx
Definition: TRotation.h:182
Double_t
double Double_t
Definition: RtypesCore.h:59
TRotation::PhiY
Double_t PhiY() const
Return Phi.
Definition: TRotation.cxx:427
TObject.h
TRotation::RotateXEulerAngles
TRotation & RotateXEulerAngles(Double_t phi, Double_t theta, Double_t psi)
Rotate using the x-convention.
Definition: TRotation.cxx:514
TRotation::PhiZ
Double_t PhiZ() const
Return Phi.
Definition: TRotation.cxx:434
TRotation::RotateAxes
TRotation & RotateAxes(const TVector3 &newX, const TVector3 &newY, const TVector3 &newZ)
Rotate axes.
Definition: TRotation.cxx:393
TObject
Definition: TObject.h:37
ClassDef
#define ClassDef(name, id)
Definition: Rtypes.h:325
TRotation::SetYPhi
void SetYPhi(Double_t)
Set YPhi.
Definition: TRotation.cxx:557
TRotation::~TRotation
virtual ~TRotation()
Definition: TRotation.h:44
TVector3::Z
Double_t Z() const
Definition: TVector3.h:218
TRotation::fyy
Double_t fyy
Definition: TRotation.h:182
TRotation::operator==
Bool_t operator==(const TRotation &) const
Definition: TRotation.h:233
TRotation::ThetaY
Double_t ThetaY() const
Return Theta.
Definition: TRotation.cxx:448
TRotation::SetXPsi
void SetXPsi(Double_t)
Set XPsi.
Definition: TRotation.cxx:550
TRotation::GetXPhi
Double_t GetXPhi(void) const
Return phi angle.
Definition: TRotation.cxx:578
TRotation::GetXTheta
Double_t GetXTheta(void) const
Return XTheta.
Definition: TRotation.cxx:630
TRotation::RotateY
TRotation & RotateY(Double_t)
Rotate around y.
Definition: TRotation.cxx:361
TRotation::RotateX
TRotation & RotateX(Double_t)
Rotate around x.
Definition: TRotation.cxx:345
TQuaternion
Definition: TQuaternion.h:11
TRotation::SetToIdentity
TRotation & SetToIdentity()
Definition: TRotation.h:251
TVector3::X
Double_t X() const
Definition: TVector3.h:216
TRotation::Inverse
TRotation Inverse() const
Definition: TRotation.h:271
TRotation::SetYPsi
void SetYPsi(Double_t)
Set YPsi.
Definition: TRotation.cxx:571
TRotation::XX
Double_t XX() const
Definition: TRotation.h:190
TRotation::fyx
Double_t fyx
Definition: TRotation.h:182
TRotation::operator[]
TRotationRow operator[](int) const
Definition: TRotation.h:216
TRotation::SetZAxis
TRotation & SetZAxis(const TVector3 &axis)
Set Z axis.
Definition: TRotation.cxx:758
TRotation::fxy
Double_t fxy
Definition: TRotation.h:182