CLHEP 2.4.7.1
C++ Class Library for High Energy Physics
RotationX.icc
Go to the documentation of this file.
1// -*- C++ -*-
2// ---------------------------------------------------------------------------
3//
4// This file is a part of the CLHEP - a Class Library for High Energy Physics.
5//
6// This is the definitions of the inline member functions of the
7// HepRotationX class
8//
9
10#include <cmath>
12
13namespace CLHEP {
14
15inline double HepRotationX::yy() const { return its_c; }
16inline double HepRotationX::yz() const { return -its_s; }
17inline double HepRotationX::zy() const { return its_s; }
18inline double HepRotationX::zz() const { return its_c; }
19
20inline double HepRotationX::xx() const { return 1.0; }
21inline double HepRotationX::xy() const { return 0.0; }
22inline double HepRotationX::xz() const { return 0.0; }
23inline double HepRotationX::yx() const { return 0.0; }
24inline double HepRotationX::zx() const { return 0.0; }
25
27 return HepRep3x3 ( 1.0, 0.0, 0.0,
28 0.0, its_c, -its_s,
29 0.0, its_s, its_c );
30}
31
32inline HepRotationX::HepRotationX() : its_d(0.0), its_s(0.0), its_c(1.0) {}
33
35 its_d(orig.its_d), its_s(orig.its_s), its_c(orig.its_c)
36{}
37
38inline HepRotationX::HepRotationX(double dd, double ss, double cc) :
39 its_d(dd), its_s(ss), its_c(cc)
40{}
41
43 its_d = orig.its_d;
44 its_s = orig.its_s;
45 its_c = orig.its_c;
46 return *this;
47}
48
50
52 { return Hep3Vector ( 1.0, 0.0, 0.0 ); }
54 { return Hep3Vector ( 0.0, its_c, its_s ); }
56 { return Hep3Vector ( 0.0, -its_s, its_c ); }
57
59 { return Hep3Vector ( 1.0, 0.0, 0.0 ); }
61 { return Hep3Vector ( 0.0, its_c, -its_s ); }
63 { return Hep3Vector ( 0.0, its_s, its_c ); }
64
65inline double HepRotationX::getPhi () const { return phi(); }
66inline double HepRotationX::getTheta() const { return theta(); }
67inline double HepRotationX::getPsi () const { return psi(); }
68inline double HepRotationX::getDelta() const { return its_d; }
69inline Hep3Vector HepRotationX::getAxis () const { return axis(); }
70
71inline double HepRotationX::delta() const { return its_d; }
72inline Hep3Vector HepRotationX::axis() const { return Hep3Vector(1,0,0); }
73
75 return HepAxisAngle ( axis(), delta() );
76}
77
79 (double & ddelta, Hep3Vector & aaxis) const {
80 ddelta = its_d;
81 aaxis = getAxis();
82}
83
85 { return HepLorentzVector (colX(), 0); }
87 { return HepLorentzVector (colY(), 0); }
89 { return HepLorentzVector (colZ(), 0); }
91 { return HepLorentzVector (0,0,0,1); }
93 { return HepLorentzVector (rowX(), 0); }
95 { return HepLorentzVector (rowY(), 0); }
97 { return HepLorentzVector (rowZ(), 0); }
99 { return HepLorentzVector (0,0,0,1); }
100inline double HepRotationX::xt() const { return 0.0; }
101inline double HepRotationX::yt() const { return 0.0; }
102inline double HepRotationX::zt() const { return 0.0; }
103inline double HepRotationX::tx() const { return 0.0; }
104inline double HepRotationX::ty() const { return 0.0; }
105inline double HepRotationX::tz() const { return 0.0; }
106inline double HepRotationX::tt() const { return 1.0; }
107
109 return HepRep4x4 ( 1.0, 0.0, 0.0, 0.0,
110 0.0, its_c, -its_s, 0.0,
111 0.0, its_s, its_c, 0.0,
112 0.0, 0.0, 0.0, 1.0 );
113}
114
115inline bool HepRotationX::isIdentity() const {
116 return ( its_d==0 );
117}
118
119inline int HepRotationX::compare ( const HepRotationX & r ) const {
120 if (its_d > r.its_d) return 1; else if (its_d < r.its_d) return -1; else return 0;
121}
122
123inline bool HepRotationX::operator==(const HepRotationX & r) const
124 { return (its_d==r.its_d); }
125inline bool HepRotationX::operator!=(const HepRotationX & r) const
126 { return (its_d!=r.its_d); }
127inline bool HepRotationX::operator>=(const HepRotationX & r) const
128 { return (its_d>=r.its_d); }
129inline bool HepRotationX::operator<=(const HepRotationX & r) const
130 { return (its_d<=r.its_d); }
131inline bool HepRotationX::operator> (const HepRotationX & r) const
132 { return (its_d> r.its_d); }
133inline bool HepRotationX::operator< (const HepRotationX & r) const
134 { return (its_d< r.its_d); }
135
136inline void HepRotationX::rectify() {
137 its_d = proper(its_d); // Just in case!
138 its_s = std::sin(its_d);
139 its_c = std::cos(its_d);
140}
141
143 double x = p.x();
144 double y = p.y();
145 double z = p.z();
146 return Hep3Vector( x,
147 y * its_c - z * its_s,
148 z * its_c + y * its_s );
149}
150
152 return operator()(p);
153}
154
155inline HepLorentzVector HepRotationX::operator()
156 ( const HepLorentzVector & w ) const {
157 return HepLorentzVector( operator() (w.vect()) , w.t() );
158}
159
160inline HepLorentzVector HepRotationX::operator *
161 (const HepLorentzVector & p) const {
162 return operator()(p);
163}
164
166 return *this = (*this) * (m1);
167}
168
170 return *this = m1 * (*this);
171}
172
173inline double HepRotationX::proper( double ddelta ) {
174 // -PI < d <= PI
175 if ( std::fabs(ddelta) < CLHEP::pi ) {
176 return ddelta;
177 } else {
178 double x = ddelta / (CLHEP::twopi);
179 return (CLHEP::twopi) * ( x + std::floor(.5-x) );
180 }
181} // proper()
182
185 its_s*rx.its_c + its_c*rx.its_s,
186 its_c*rx.its_c - its_s*rx.its_s );
187}
188
190 return HepRotationX( proper(-its_d), -its_s, its_c );
191}
192
194 return r.inverse();
195}
196
198 return *this=inverse();
199}
200
204inline double HepRotationX::setTolerance(double tol) {
206}
207
208} // namespace CLHEP
double z() const
double x() const
double y() const
static double setTolerance(double tol)
double tt() const
HepLorentzVector row4() const
Definition RotationX.icc:98
double xy() const
Definition RotationX.icc:21
HepRotationX inverse() const
HepLorentzVector col1() const
Definition RotationX.icc:84
static double proper(double delta)
double getPsi() const
Definition RotationX.icc:67
double xx() const
Definition RotationX.icc:20
Hep3Vector rowX() const
Definition RotationX.icc:58
double yz() const
Definition RotationX.icc:16
HepRotationX & transform(const HepRotationX &r)
HepLorentzVector col3() const
Definition RotationX.icc:88
double tx() const
HepRep4x4 rep4x4() const
bool operator>=(const HepRotationX &r) const
double delta() const
Definition RotationX.icc:71
Hep3Vector colZ() const
Definition RotationX.icc:55
double zy() const
Definition RotationX.icc:17
HepLorentzVector col2() const
Definition RotationX.icc:86
Hep3Vector rowY() const
Definition RotationX.icc:60
int compare(const HepRotationX &r) const
HepRep3x3 rep3x3() const
Definition RotationX.icc:26
double getDelta() const
Definition RotationX.icc:68
double psi() const
double getPhi() const
Definition RotationX.icc:65
bool operator!=(const HepRotationX &r) const
Hep3Vector rowZ() const
Definition RotationX.icc:62
double yy() const
Definition RotationX.icc:15
double phi() const
static double setTolerance(double tol)
double xz() const
Definition RotationX.icc:22
HepRotationX & operator=(const HepRotationX &r)
Definition RotationX.icc:42
void getAngleAxis(double &delta, Hep3Vector &axis) const
Definition RotationX.icc:79
double ty() const
static double getTolerance()
double xt() const
Hep3Vector axis() const
Definition RotationX.icc:72
double tz() const
bool operator==(const HepRotationX &r) const
bool operator<=(const HepRotationX &r) const
HepLorentzVector col4() const
Definition RotationX.icc:90
HepRotationX & operator*=(const HepRotationX &r)
double yt() const
HepAxisAngle axisAngle() const
Definition RotationX.icc:74
HepLorentzVector row3() const
Definition RotationX.icc:96
HepLorentzVector row2() const
Definition RotationX.icc:94
Hep3Vector operator()(const Hep3Vector &p) const
double theta() const
double getTheta() const
Definition RotationX.icc:66
Hep3Vector colY() const
Definition RotationX.icc:53
double zz() const
Definition RotationX.icc:18
bool isIdentity() const
Hep3Vector getAxis() const
Definition RotationX.icc:69
Hep3Vector operator*(const Hep3Vector &p) const
bool operator<(const HepRotationX &r) const
HepLorentzVector row1() const
Definition RotationX.icc:92
Hep3Vector colX() const
Definition RotationX.icc:51
double yx() const
Definition RotationX.icc:23
HepRotationX & invert()
double zt() const
double zx() const
Definition RotationX.icc:24
bool operator>(const HepRotationX &r) const
HepBoost inverseOf(const HepBoost &lt)
Definition Boost.icc:266