Geant4 Cross Reference |
1 // -*- C++ -*- 1 // -*- C++ -*- 2 // CLASSDOC OFF 2 // CLASSDOC OFF 3 // ------------------------------------------- 3 // --------------------------------------------------------------------------- 4 // CLASSDOC ON 4 // CLASSDOC ON 5 // 5 // 6 // This file is a part of the CLHEP - a Class 6 // This file is a part of the CLHEP - a Class Library for High Energy Physics. 7 // 7 // 8 // This is the definition of the HepRotationX 8 // This is the definition of the HepRotationX class for performing rotations 9 // around the X axis on objects of the Hep3Vec 9 // around the X axis on objects of the Hep3Vector (and HepLorentzVector) class. 10 // 10 // 11 // HepRotationX is a concrete implementation o 11 // HepRotationX is a concrete implementation of Hep3RotationInterface. 12 // 12 // 13 // .SS See Also 13 // .SS See Also 14 // RotationInterfaces.h 14 // RotationInterfaces.h 15 // ThreeVector.h, LorentzVector.h, LorentzRota 15 // ThreeVector.h, LorentzVector.h, LorentzRotation.h 16 // 16 // 17 // .SS Author 17 // .SS Author 18 // Mark Fischler 18 // Mark Fischler 19 19 20 #ifndef HEP_ROTATIONX_H 20 #ifndef HEP_ROTATIONX_H 21 #define HEP_ROTATIONX_H 21 #define HEP_ROTATIONX_H 22 22 >> 23 #ifdef GNUPRAGMA >> 24 #pragma interface >> 25 #endif >> 26 23 #include "CLHEP/Vector/RotationInterfaces.h" 27 #include "CLHEP/Vector/RotationInterfaces.h" 24 28 25 namespace CLHEP { 29 namespace CLHEP { 26 30 27 class HepRotationX; 31 class HepRotationX; 28 32 29 class HepRotation; 33 class HepRotation; 30 class HepBoost; 34 class HepBoost; 31 35 32 inline HepRotationX inverseOf(const HepRotatio 36 inline HepRotationX inverseOf(const HepRotationX & r); 33 // Returns the inverse of a RotationX. 37 // Returns the inverse of a RotationX. 34 38 35 /** 39 /** 36 * @author 40 * @author 37 * @ingroup vector 41 * @ingroup vector 38 */ 42 */ 39 class HepRotationX { 43 class HepRotationX { 40 44 41 public: 45 public: 42 46 43 // ---------- Constructors and Assignment: 47 // ---------- Constructors and Assignment: 44 48 45 inline HepRotationX(); 49 inline HepRotationX(); 46 // Default constructor. Gives an identity ro 50 // Default constructor. Gives an identity rotation. 47 51 48 HepRotationX(double delta); 52 HepRotationX(double delta); 49 // supply angle of rotation 53 // supply angle of rotation 50 54 51 inline HepRotationX(const HepRotationX & ori 55 inline HepRotationX(const HepRotationX & orig); 52 inline HepRotationX(HepRotationX && orig) = << 56 // Copy constructor. 53 // Copy and move constructors. << 54 57 55 inline HepRotationX & operator = (const HepR 58 inline HepRotationX & operator = (const HepRotationX & r); 56 inline HepRotationX & operator = (HepRotatio << 59 // Assignment from a Rotation, which must be RotationX 57 // Copy and move assignments from a Rotation << 58 60 59 HepRotationX & set ( double delta ); 61 HepRotationX & set ( double delta ); 60 // set angle of rotation 62 // set angle of rotation 61 63 62 inline ~HepRotationX(); 64 inline ~HepRotationX(); 63 // Trivial destructor. 65 // Trivial destructor. 64 66 65 // ---------- Accessors: 67 // ---------- Accessors: 66 68 67 inline Hep3Vector colX() const; 69 inline Hep3Vector colX() const; 68 inline Hep3Vector colY() const; 70 inline Hep3Vector colY() const; 69 inline Hep3Vector colZ() const; 71 inline Hep3Vector colZ() const; 70 // orthogonal unit-length column vectors 72 // orthogonal unit-length column vectors 71 73 72 inline Hep3Vector rowX() const; 74 inline Hep3Vector rowX() const; 73 inline Hep3Vector rowY() const; 75 inline Hep3Vector rowY() const; 74 inline Hep3Vector rowZ() const; 76 inline Hep3Vector rowZ() const; 75 // orthogonal unit-length row vectors 77 // orthogonal unit-length row vectors 76 78 77 inline double xx() const; 79 inline double xx() const; 78 inline double xy() const; 80 inline double xy() const; 79 inline double xz() const; 81 inline double xz() const; 80 inline double yx() const; 82 inline double yx() const; 81 inline double yy() const; 83 inline double yy() const; 82 inline double yz() const; 84 inline double yz() const; 83 inline double zx() const; 85 inline double zx() const; 84 inline double zy() const; 86 inline double zy() const; 85 inline double zz() const; 87 inline double zz() const; 86 // Elements of the rotation matrix (Geant4). 88 // Elements of the rotation matrix (Geant4). 87 89 88 inline HepRep3x3 rep3x3() const; 90 inline HepRep3x3 rep3x3() const; 89 // 3x3 representation: 91 // 3x3 representation: 90 92 91 // ------------ Euler angles: 93 // ------------ Euler angles: 92 inline double getPhi () const; 94 inline double getPhi () const; 93 inline double getTheta() const; 95 inline double getTheta() const; 94 inline double getPsi () const; 96 inline double getPsi () const; 95 double phi () const; 97 double phi () const; 96 double theta() const; 98 double theta() const; 97 double psi () const; 99 double psi () const; 98 HepEulerAngles eulerAngles() const; 100 HepEulerAngles eulerAngles() const; 99 101 100 // ------------ axis & angle of rotation: 102 // ------------ axis & angle of rotation: 101 inline double getDelta() const; 103 inline double getDelta() const; 102 inline Hep3Vector getAxis () const; 104 inline Hep3Vector getAxis () const; 103 inline double delta() const; 105 inline double delta() const; 104 inline Hep3Vector axis () const; 106 inline Hep3Vector axis () const; 105 inline HepAxisAngle axisAngle() const; 107 inline HepAxisAngle axisAngle() const; 106 inline void getAngleAxis(double & delta, He 108 inline void getAngleAxis(double & delta, Hep3Vector & axis) const; 107 // Returns the rotation angle and rotation a 109 // Returns the rotation angle and rotation axis (Geant4). 108 110 109 // ------------- Angles of rotated axes 111 // ------------- Angles of rotated axes 110 double phiX() const; 112 double phiX() const; 111 double phiY() const; 113 double phiY() const; 112 double phiZ() const; 114 double phiZ() const; 113 double thetaX() const; 115 double thetaX() const; 114 double thetaY() const; 116 double thetaY() const; 115 double thetaZ() const; 117 double thetaZ() const; 116 // Return angles (RADS) made by rotated axes 118 // Return angles (RADS) made by rotated axes against original axes (Geant4). 117 119 118 // ---------- Other accessors treating pure 120 // ---------- Other accessors treating pure rotation as a 4-rotation 119 121 120 inline HepLorentzVector col1() const; 122 inline HepLorentzVector col1() const; 121 inline HepLorentzVector col2() const; 123 inline HepLorentzVector col2() const; 122 inline HepLorentzVector col3() const; 124 inline HepLorentzVector col3() const; 123 // orthosymplectic 4-vector columns - T com 125 // orthosymplectic 4-vector columns - T component will be zero 124 126 125 inline HepLorentzVector col4() const; 127 inline HepLorentzVector col4() const; 126 // Will be (0,0,0,1) for this pure Rotation. 128 // Will be (0,0,0,1) for this pure Rotation. 127 129 128 inline HepLorentzVector row1() const; 130 inline HepLorentzVector row1() const; 129 inline HepLorentzVector row2() const; 131 inline HepLorentzVector row2() const; 130 inline HepLorentzVector row3() const; 132 inline HepLorentzVector row3() const; 131 // orthosymplectic 4-vector rows - T compon 133 // orthosymplectic 4-vector rows - T component will be zero 132 134 133 inline HepLorentzVector row4() const; 135 inline HepLorentzVector row4() const; 134 // Will be (0,0,0,1) for this pure Rotation. 136 // Will be (0,0,0,1) for this pure Rotation. 135 137 136 inline double xt() const; 138 inline double xt() const; 137 inline double yt() const; 139 inline double yt() const; 138 inline double zt() const; 140 inline double zt() const; 139 inline double tx() const; 141 inline double tx() const; 140 inline double ty() const; 142 inline double ty() const; 141 inline double tz() const; 143 inline double tz() const; 142 // Will be zero for this pure Rotation 144 // Will be zero for this pure Rotation 143 145 144 inline double tt() const; 146 inline double tt() const; 145 // Will be one for this pure Rotation 147 // Will be one for this pure Rotation 146 148 147 inline HepRep4x4 rep4x4() const; 149 inline HepRep4x4 rep4x4() const; 148 // 4x4 representation. 150 // 4x4 representation. 149 151 150 // --------- Mutators 152 // --------- Mutators 151 153 152 void setDelta (double delta); 154 void setDelta (double delta); 153 // change angle of rotation, leaving rotatio 155 // change angle of rotation, leaving rotation axis unchanged. 154 156 155 // ---------- Decomposition: 157 // ---------- Decomposition: 156 158 157 void decompose (HepAxisAngle & rotation, Hep 159 void decompose (HepAxisAngle & rotation, Hep3Vector & boost) const; 158 void decompose (Hep3Vector & boost, HepAxisA 160 void decompose (Hep3Vector & boost, HepAxisAngle & rotation) const; 159 void decompose (HepRotation & rotation, HepB 161 void decompose (HepRotation & rotation, HepBoost & boost) const; 160 void decompose (HepBoost & boost, HepRotatio 162 void decompose (HepBoost & boost, HepRotation & rotation) const; 161 // These are trivial, as the boost vector is 163 // These are trivial, as the boost vector is 0. 162 164 163 // ---------- Comparisons: 165 // ---------- Comparisons: 164 166 165 inline bool isIdentity() const; 167 inline bool isIdentity() const; 166 // Returns true if the identity matrix (Gean 168 // Returns true if the identity matrix (Geant4). 167 169 168 inline int compare( const HepRotationX & r 170 inline int compare( const HepRotationX & r ) const; 169 // Dictionary-order comparison, in order of 171 // Dictionary-order comparison, in order of delta 170 // Used in operator<, >, <=, >= 172 // Used in operator<, >, <=, >= 171 173 172 inline bool operator== ( const HepRotationX 174 inline bool operator== ( const HepRotationX & r ) const; 173 inline bool operator!= ( const HepRotationX 175 inline bool operator!= ( const HepRotationX & r ) const; 174 inline bool operator< ( const HepRotationX 176 inline bool operator< ( const HepRotationX & r ) const; 175 inline bool operator> ( const HepRotationX 177 inline bool operator> ( const HepRotationX & r ) const; 176 inline bool operator<= ( const HepRotationX 178 inline bool operator<= ( const HepRotationX & r ) const; 177 inline bool operator>= ( const HepRotationX 179 inline bool operator>= ( const HepRotationX & r ) const; 178 180 179 double distance2( const HepRotationX & r ) 181 double distance2( const HepRotationX & r ) const; 180 // 3 - Tr ( this/r ) 182 // 3 - Tr ( this/r ) 181 183 182 double distance2( const HepRotation & r ) 184 double distance2( const HepRotation & r ) const; 183 // 3 - Tr ( this/r ) -- This works with Rota 185 // 3 - Tr ( this/r ) -- This works with RotationY or Z also 184 186 185 double howNear( const HepRotationX & r ) con 187 double howNear( const HepRotationX & r ) const; 186 double howNear( const HepRotation & r ) con 188 double howNear( const HepRotation & r ) const; 187 bool isNear( const HepRotationX & r, 189 bool isNear( const HepRotationX & r, 188 double epsilon=Hep4RotationInte 190 double epsilon=Hep4RotationInterface::tolerance) const; 189 bool isNear( const HepRotation & r, 191 bool isNear( const HepRotation & r, 190 double epsilon=Hep4RotationInte 192 double epsilon=Hep4RotationInterface::tolerance) const; 191 193 192 double distance2( const HepBoost & 194 double distance2( const HepBoost & lt ) const; 193 // 3 - Tr ( this ) + |b|^2 / (1-|b|^2) 195 // 3 - Tr ( this ) + |b|^2 / (1-|b|^2) 194 double distance2( const HepLorentzRotation & 196 double distance2( const HepLorentzRotation & lt ) const; 195 // 3 - Tr ( this/r ) + |b|^2 / (1-|b|^2) whe 197 // 3 - Tr ( this/r ) + |b|^2 / (1-|b|^2) where b is the boost vector of lt 196 198 197 double howNear( const HepBoost & l 199 double howNear( const HepBoost & lt ) const; 198 double howNear( const HepLorentzRotation & l 200 double howNear( const HepLorentzRotation & lt ) const; 199 bool isNear( const HepBoost & lt, 201 bool isNear( const HepBoost & lt, 200 double epsilon=Hep4RotationInte 202 double epsilon=Hep4RotationInterface::tolerance) const; 201 bool isNear( const HepLorentzRotation & lt, 203 bool isNear( const HepLorentzRotation & lt, 202 double epsilon=Hep4RotationInte 204 double epsilon=Hep4RotationInterface::tolerance) const; 203 205 204 // ---------- Properties: 206 // ---------- Properties: 205 207 206 double norm2() const; 208 double norm2() const; 207 // distance2 (IDENTITY), which is 3 - Tr ( * 209 // distance2 (IDENTITY), which is 3 - Tr ( *this ) 208 210 209 inline void rectify(); 211 inline void rectify(); 210 // non-const but logically moot correction f 212 // non-const but logically moot correction for accumulated roundoff errors 211 213 212 // ---------- Application: 214 // ---------- Application: 213 215 214 inline Hep3Vector operator() (const Hep3Vect 216 inline Hep3Vector operator() (const Hep3Vector & p) const; 215 // Rotate a Hep3Vector. 217 // Rotate a Hep3Vector. 216 218 217 inline Hep3Vector operator * (const Hep3Vec 219 inline Hep3Vector operator * (const Hep3Vector & p) const; 218 // Multiplication with a Hep3Vector. 220 // Multiplication with a Hep3Vector. 219 221 220 inline HepLorentzVector operator()( const He 222 inline HepLorentzVector operator()( const HepLorentzVector & w ) const; 221 // Rotate (the space part of) a HepLorentzVe 223 // Rotate (the space part of) a HepLorentzVector. 222 224 223 inline HepLorentzVector operator* ( const H 225 inline HepLorentzVector operator* ( const HepLorentzVector & w ) const; 224 // Multiplication with a HepLorentzVector. 226 // Multiplication with a HepLorentzVector. 225 227 226 // ---------- Operations in the group of Rot 228 // ---------- Operations in the group of Rotations 227 229 228 inline HepRotationX operator * (const HepRot 230 inline HepRotationX operator * (const HepRotationX & rx) const; 229 // Product of two X rotations: (this) * rx i 231 // Product of two X rotations: (this) * rx is known to be RotationX. 230 232 231 inline HepRotationX & operator *= (const He 233 inline HepRotationX & operator *= (const HepRotationX & r); 232 inline HepRotationX & transform (const He 234 inline HepRotationX & transform (const HepRotationX & r); 233 // Matrix multiplication. 235 // Matrix multiplication. 234 // Note a *= b; <=> a = a * b; while a.trans 236 // Note a *= b; <=> a = a * b; while a.transform(b); <=> a = b * a; 235 // However, in this special case, they commu 237 // However, in this special case, they commute: Both just add deltas. 236 238 237 inline HepRotationX inverse() const; 239 inline HepRotationX inverse() const; 238 // Returns the inverse. 240 // Returns the inverse. 239 241 240 friend HepRotationX inverseOf(const HepRotat 242 friend HepRotationX inverseOf(const HepRotationX & r); 241 // Returns the inverse of a RotationX. 243 // Returns the inverse of a RotationX. 242 244 243 inline HepRotationX & invert(); 245 inline HepRotationX & invert(); 244 // Inverts the Rotation matrix (be negating 246 // Inverts the Rotation matrix (be negating delta). 245 247 246 // ---------- I/O: 248 // ---------- I/O: 247 249 248 std::ostream & print( std::ostream & os ) co 250 std::ostream & print( std::ostream & os ) const; 249 // Output, identifying type of rotation and 251 // Output, identifying type of rotation and delta. 250 252 251 // ---------- Tolerance 253 // ---------- Tolerance 252 254 253 static inline double getTolerance(); 255 static inline double getTolerance(); 254 static inline double setTolerance(double tol 256 static inline double setTolerance(double tol); 255 257 256 protected: 258 protected: 257 259 258 double its_d; 260 double its_d; 259 // The angle of rotation. 261 // The angle of rotation. 260 262 261 double its_s; 263 double its_s; 262 double its_c; 264 double its_c; 263 // Cache the trig functions, for rapid opera 265 // Cache the trig functions, for rapid operations. 264 266 265 inline HepRotationX ( double dd, double ss, 267 inline HepRotationX ( double dd, double ss, double cc ); 266 // Unchecked load-the-data-members 268 // Unchecked load-the-data-members 267 269 268 static inline double proper (double delta); 270 static inline double proper (double delta); 269 // Put an angle into the range of (-PI, PI]. 271 // Put an angle into the range of (-PI, PI]. Useful helper method. 270 272 271 }; // HepRotationX 273 }; // HepRotationX 272 // ---------- Free-function operations in the 274 // ---------- Free-function operations in the group of Rotations 273 275 274 inline 276 inline 275 std::ostream & operator << 277 std::ostream & operator << 276 ( std::ostream & os, const HepRotationX & r 278 ( std::ostream & os, const HepRotationX & r ) {return r.print(os);} 277 279 278 } // namespace CLHEP 280 } // namespace CLHEP 279 281 280 #include "CLHEP/Vector/RotationX.icc" 282 #include "CLHEP/Vector/RotationX.icc" 281 283 282 #endif /* HEP_ROTATIONX_H */ 284 #endif /* HEP_ROTATIONX_H */ 283 285