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 // Hep2Vector is a general 2-vector class defi 8 // Hep2Vector is a general 2-vector class defining vectors in two 9 // dimension using double components. It com 9 // dimension using double components. It comes from the ZOOM 10 // PlaneVector class (the PhysicsVectors Plane 10 // PlaneVector class (the PhysicsVectors PlaneVector.h will typedef 11 // PlaneVector to Hep2Vector). 11 // PlaneVector to Hep2Vector). 12 // 12 // 13 // .SS See Also 13 // .SS See Also 14 // ThreeVector.h 14 // ThreeVector.h 15 // 15 // 16 // .SS Authors 16 // .SS Authors 17 // John Marraffino and Mark Fischler 17 // John Marraffino and Mark Fischler 18 // 18 // 19 19 20 #ifndef HEP_TWOVECTOR_H 20 #ifndef HEP_TWOVECTOR_H 21 #define HEP_TWOVECTOR_H 21 #define HEP_TWOVECTOR_H 22 22 >> 23 #ifdef GNUPRAGMA >> 24 #pragma interface >> 25 #endif >> 26 23 #include <iostream> 27 #include <iostream> 24 28 25 #include "CLHEP/Vector/ThreeVector.h" 29 #include "CLHEP/Vector/ThreeVector.h" 26 30 27 namespace CLHEP { 31 namespace CLHEP { 28 32 29 // Declarations of classes and global methods 33 // Declarations of classes and global methods 30 class Hep2Vector; 34 class Hep2Vector; 31 std::ostream & operator << (std::ostream &, co 35 std::ostream & operator << (std::ostream &, const Hep2Vector &); 32 std::istream & operator >> (std::istream &, He 36 std::istream & operator >> (std::istream &, Hep2Vector &); 33 inline double operator * (const Hep2Vector & a 37 inline double operator * (const Hep2Vector & a,const Hep2Vector & b); 34 inline Hep2Vector operator * (const Hep2Vector 38 inline Hep2Vector operator * (const Hep2Vector & p, double a); 35 inline Hep2Vector operator * (double a, const 39 inline Hep2Vector operator * (double a, const Hep2Vector & p); 36 Hep2Vector operator / (const Hep2Vector 40 Hep2Vector operator / (const Hep2Vector & p, double a); 37 inline Hep2Vector operator + (const Hep2Vector 41 inline Hep2Vector operator + (const Hep2Vector & a, const Hep2Vector & b); 38 inline Hep2Vector operator - (const Hep2Vector 42 inline Hep2Vector operator - (const Hep2Vector & a, const Hep2Vector & b); 39 43 40 /** 44 /** 41 * @author 45 * @author 42 * @ingroup vector 46 * @ingroup vector 43 */ 47 */ 44 class Hep2Vector { 48 class Hep2Vector { 45 49 46 public: 50 public: 47 51 48 enum { X=0, Y=1, NUM_COORDINATES=2, SIZE=NUM 52 enum { X=0, Y=1, NUM_COORDINATES=2, SIZE=NUM_COORDINATES }; 49 // Safe indexing of the coordinates when usi 53 // Safe indexing of the coordinates when using with matrices, arrays, etc. 50 54 51 inline Hep2Vector( double x = 0.0, double y 55 inline Hep2Vector( double x = 0.0, double y = 0.0 ); 52 // The constructor. 56 // The constructor. 53 57 54 inline Hep2Vector(const Hep2Vector & p); 58 inline Hep2Vector(const Hep2Vector & p); 55 inline Hep2Vector(Hep2Vector && p) = default << 59 // The copy constructor. 56 // The copy and move constructors. << 57 60 58 explicit Hep2Vector( const Hep3Vector & ); << 61 explicit Hep2Vector( const Hep3Vector & s); 59 // "demotion" constructor" 62 // "demotion" constructor" 60 // WARNING -- THIS IGNORES THE Z COMPONENT O 63 // WARNING -- THIS IGNORES THE Z COMPONENT OF THE Hep3Vector. 61 // SO IN GENERAL, Hep2Vector(v)==v WILL N 64 // SO IN GENERAL, Hep2Vector(v)==v WILL NOT HOLD! 62 65 63 inline ~Hep2Vector(); 66 inline ~Hep2Vector(); 64 // The destructor. 67 // The destructor. 65 68 66 inline double x() const; 69 inline double x() const; 67 inline double y() const; 70 inline double y() const; 68 // The components in cartesian coordinate sy 71 // The components in cartesian coordinate system. 69 72 70 double operator () (int i) const; 73 double operator () (int i) const; 71 inline double operator [] (int i) const; 74 inline double operator [] (int i) const; 72 // Get components by index. 0-based. 75 // Get components by index. 0-based. 73 76 74 double & operator () (int i); 77 double & operator () (int i); 75 inline double & operator [] (int i); 78 inline double & operator [] (int i); 76 // Set components by index. 0-based. 79 // Set components by index. 0-based. 77 80 78 inline void setX(double x); 81 inline void setX(double x); 79 inline void setY(double y); 82 inline void setY(double y); 80 inline void set (double x, double y); 83 inline void set (double x, double y); 81 // Set the components in cartesian coordinat 84 // Set the components in cartesian coordinate system. 82 85 83 inline double phi() const; 86 inline double phi() const; 84 // The azimuth angle. 87 // The azimuth angle. 85 88 86 inline double mag2() const; 89 inline double mag2() const; 87 // The magnitude squared. 90 // The magnitude squared. 88 91 89 inline double mag() const; 92 inline double mag() const; 90 // The magnitude. 93 // The magnitude. 91 94 92 inline double r() const; 95 inline double r() const; 93 // r in polar coordinates (r, phi): equal t 96 // r in polar coordinates (r, phi): equal to mag(). 94 97 95 inline void setPhi(double phi); 98 inline void setPhi(double phi); 96 // Set phi keeping mag constant. 99 // Set phi keeping mag constant. 97 100 98 inline void setMag(double r); 101 inline void setMag(double r); 99 // Set magnitude keeping phi constant. 102 // Set magnitude keeping phi constant. 100 103 101 inline void setR(double r); 104 inline void setR(double r); 102 // Set R keeping phi constant. Same as setM 105 // Set R keeping phi constant. Same as setMag. 103 106 104 inline void setPolar(double r, double phi); 107 inline void setPolar(double r, double phi); 105 // Set by polar coordinates. 108 // Set by polar coordinates. 106 109 107 inline Hep2Vector & operator = (const Hep2Ve 110 inline Hep2Vector & operator = (const Hep2Vector & p); 108 inline Hep2Vector & operator = (Hep2Vector & << 111 // Assignment. 109 // The copy and move assignment operators. << 110 112 111 inline bool operator == (const Hep2Vector & 113 inline bool operator == (const Hep2Vector & v) const; 112 inline bool operator != (const Hep2Vector & 114 inline bool operator != (const Hep2Vector & v) const; 113 // Comparisons. 115 // Comparisons. 114 116 115 int compare (const Hep2Vector & v) const; 117 int compare (const Hep2Vector & v) const; 116 bool operator > (const Hep2Vector & v) const 118 bool operator > (const Hep2Vector & v) const; 117 bool operator < (const Hep2Vector & v) const 119 bool operator < (const Hep2Vector & v) const; 118 bool operator>= (const Hep2Vector & v) const 120 bool operator>= (const Hep2Vector & v) const; 119 bool operator<= (const Hep2Vector & v) const 121 bool operator<= (const Hep2Vector & v) const; 120 // dictionary ordering according to y, then 122 // dictionary ordering according to y, then x component 121 123 122 static inline double getTolerance(); 124 static inline double getTolerance(); 123 static double setTolerance(double tol); 125 static double setTolerance(double tol); 124 126 125 double howNear (const Hep2Vector &p) const; 127 double howNear (const Hep2Vector &p) const; 126 bool isNear (const Hep2Vector & p, double e 128 bool isNear (const Hep2Vector & p, double epsilon=tolerance) const; 127 129 128 double howParallel (const Hep2Vector &p) con 130 double howParallel (const Hep2Vector &p) const; 129 bool isParallel 131 bool isParallel 130 (const Hep2Vector & p, double epsilon=tole 132 (const Hep2Vector & p, double epsilon=tolerance) const; 131 133 132 double howOrthogonal (const Hep2Vector &p) c 134 double howOrthogonal (const Hep2Vector &p) const; 133 bool isOrthogonal 135 bool isOrthogonal 134 (const Hep2Vector & p, double epsilon=tole 136 (const Hep2Vector & p, double epsilon=tolerance) const; 135 137 136 inline Hep2Vector & operator += (const Hep2V 138 inline Hep2Vector & operator += (const Hep2Vector &p); 137 // Addition. 139 // Addition. 138 140 139 inline Hep2Vector & operator -= (const Hep2V 141 inline Hep2Vector & operator -= (const Hep2Vector &p); 140 // Subtraction. 142 // Subtraction. 141 143 142 inline Hep2Vector operator - () const; 144 inline Hep2Vector operator - () const; 143 // Unary minus. 145 // Unary minus. 144 146 145 inline Hep2Vector & operator *= (double a); 147 inline Hep2Vector & operator *= (double a); 146 // Scaling with real numbers. 148 // Scaling with real numbers. 147 149 148 inline Hep2Vector unit() const; 150 inline Hep2Vector unit() const; 149 // Unit vector parallel to this. 151 // Unit vector parallel to this. 150 152 151 inline Hep2Vector orthogonal() const; 153 inline Hep2Vector orthogonal() const; 152 // Vector orthogonal to this. 154 // Vector orthogonal to this. 153 155 154 inline double dot(const Hep2Vector &p) const 156 inline double dot(const Hep2Vector &p) const; 155 // Scalar product. 157 // Scalar product. 156 158 157 inline double angle(const Hep2Vector &) cons 159 inline double angle(const Hep2Vector &) const; 158 // The angle w.r.t. another 2-vector. 160 // The angle w.r.t. another 2-vector. 159 161 160 void rotate(double); 162 void rotate(double); 161 // Rotates the Hep2Vector. 163 // Rotates the Hep2Vector. 162 164 163 operator Hep3Vector () const; 165 operator Hep3Vector () const; 164 // Cast a Hep2Vector as a Hep3Vector. 166 // Cast a Hep2Vector as a Hep3Vector. 165 167 166 // The remaining methods are friends, thus d 168 // The remaining methods are friends, thus defined at global scope: 167 // - - - - - - - - - - - - - - - - - - - - - 169 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 168 170 169 friend std::ostream & operator<< (std::ostre 171 friend std::ostream & operator<< (std::ostream &, const Hep2Vector &); 170 // Output to a stream. 172 // Output to a stream. 171 173 172 inline friend double operator * (const Hep2V 174 inline friend double operator * (const Hep2Vector & a, 173 const Hep2Vector & b); 175 const Hep2Vector & b); 174 // Scalar product. 176 // Scalar product. 175 177 176 inline friend Hep2Vector operator * (const H 178 inline friend Hep2Vector operator * (const Hep2Vector & p, double a); 177 // v*c 179 // v*c 178 180 179 inline friend Hep2Vector operator * (double 181 inline friend Hep2Vector operator * (double a, const Hep2Vector & p); 180 // c*v 182 // c*v 181 183 182 friend Hep2Vector operator / (const H 184 friend Hep2Vector operator / (const Hep2Vector & p, double a); 183 // v/c 185 // v/c 184 186 185 inline friend Hep2Vector operator + (const H 187 inline friend Hep2Vector operator + (const Hep2Vector & a, 186 const Hep2Vector & b); 188 const Hep2Vector & b); 187 // v1+v2 189 // v1+v2 188 190 189 inline friend Hep2Vector operator - (const H 191 inline friend Hep2Vector operator - (const Hep2Vector & a, 190 const Hep2Vector & b); 192 const Hep2Vector & b); 191 // v1-v2 193 // v1-v2 192 194 193 static const int ZMpvToleranceTicks = 100; << 195 enum { ZMpvToleranceTicks = 100 }; 194 196 195 private: 197 private: 196 198 197 double dx; 199 double dx; 198 double dy; 200 double dy; 199 // The components. 201 // The components. 200 202 201 static double tolerance; 203 static double tolerance; 202 // default tolerance criterion for isNear() 204 // default tolerance criterion for isNear() to return true. 203 205 204 }; // Hep2Vector 206 }; // Hep2Vector 205 207 206 static const Hep2Vector X_HAT2(1.0, 0.0); 208 static const Hep2Vector X_HAT2(1.0, 0.0); 207 static const Hep2Vector Y_HAT2(0.0, 1.0); 209 static const Hep2Vector Y_HAT2(0.0, 1.0); 208 210 209 } // namespace CLHEP 211 } // namespace CLHEP 210 212 211 #include "CLHEP/Vector/TwoVector.icc" 213 #include "CLHEP/Vector/TwoVector.icc" 212 214 213 #endif /* HEP_TWOVECTOR_H */ 215 #endif /* HEP_TWOVECTOR_H */ 214 216