| 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 & );
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