ROOT   Reference Guide
Searching...
No Matches
PositionVector2D.h
Go to the documentation of this file.
1// @(#)root/mathcore:$Id$
2// Authors: W. Brown, M. Fischler, L. Moneta 2005
3
4 /**********************************************************************
5 * *
6 * Copyright (c) 2005 , LCG ROOT MathLib Team *
7 * *
8 * *
9 **********************************************************************/
10
11// Header file for class PositionVector2D
12//
13// Created by: Lorenzo Moneta at Mon Apr 16 2007
14//
15//
16#ifndef ROOT_Math_GenVector_PositionVector2D
17#define ROOT_Math_GenVector_PositionVector2D 1
18
20
22
24
26
27
28namespace ROOT {
29
30 namespace Math {
31
32
33//__________________________________________________________________________________________
34 /**
35 Class describing a generic position vector (point) in 2 dimensions.
36 This class is templated on the type of Coordinate system.
37 One example is the XYPoint which is a vector based on
38 double precision x,y data members by using the
39 ROOT::Math::Cartesian2D<double> Coordinate system.
40 The class is having also an extra template parameter, the coordinate system tag,
41 to be able to identify (tag) vector described in different reference coordinate system,
42 like global or local coordinate systems.
43
44 @ingroup GenVector
45 */
46
47 template <class CoordSystem, class Tag = DefaultCoordinateSystemTag >
49
50 public:
51
52 typedef typename CoordSystem::Scalar Scalar;
53 typedef CoordSystem CoordinateType;
55
56 // ------ ctors ------
57
58 /**
59 Default constructor. Construct an empty object with zero values
60 */
61
63
64 /**
65 Construct from three values of type <em>Scalar</em>.
66 In the case of a XYPoint the values are x,y
67 In the case of a polar vector they are r,phi
68 */
69 PositionVector2D(const Scalar & a, const Scalar & b) :
70 fCoordinates ( a , b) { }
71
72 /**
73 Construct from a position vector expressed in different
74 coordinates, or using a different Scalar type
75 */
76 template <class T>
78 fCoordinates ( v.Coordinates() ) { }
79
80 /**
81 Construct from an arbitrary displacement vector
82 */
83 template <class T>
85 fCoordinates ( p.Coordinates() ) { }
86
87 /**
88 Construct from a foreign 2D vector type, for example, Hep2Vector
89 Precondition: v must implement methods x() and y()
90 */
91 template <class ForeignVector>
92 explicit PositionVector2D( const ForeignVector & v) :
93 fCoordinates ( Cartesian2D<Scalar>( v.x(), v.y() ) ) { }
94
95 // compiler-generated copy ctor and dtor are fine.
96
97 // ------ assignment ------
98
99 /**
100 Assignment operator from a position vector of arbitrary type
101 */
102 template <class OtherCoords>
106 return *this;
107 }
108
109 /**
110 Assignment operator from a displacement vector of arbitrary type
111 */
112 template <class OtherCoords>
116 return *this;
117 }
118
119 /**
120 Assignment from a foreign 2D vector type, for example, Hep2Vector
121 Precondition: v must implement methods x() and y()
122 */
123 template <class ForeignVector>
124 PositionVector2D & operator= ( const ForeignVector & v) {
125 SetXY( v.x(), v.y() );
126 return *this;
127 }
128
129 /**
130 Retrieve a copy of the coordinates object
131 */
132 const CoordSystem & Coordinates() const {
133 return fCoordinates;
134 }
135
136 /**
137 Set internal data based on 2 Scalar numbers.
138 These are for example (x,y) for a cartesian vector or (r,phi) for a polar vector
139 */
141 fCoordinates.SetCoordinates(a, b);
142 return *this;
143 }
144
145
146 /**
147 get internal data into 2 Scalar numbers.
148 These are for example (x,y) for a cartesian vector or (r,phi) for a polar vector
149 */
151 { fCoordinates.GetCoordinates(a, b); }
152
153
154 /**
155 set the values of the vector from the cartesian components (x,y)
156 (if the vector is held in polar coordinates,
157 then (x, y) are converted to that form)
158 */
160 fCoordinates.SetXY (a,b);
161 return *this;
162 }
163
164 // ------------------- Equality -----------------
165
166 /**
167 Exact equality
168 */
169 bool operator==(const PositionVector2D & rhs) const {
170 return fCoordinates==rhs.fCoordinates;
171 }
172 bool operator!= (const PositionVector2D & rhs) const {
173 return !(operator==(rhs));
174 }
175
176 // ------ Individual element access, in various coordinate systems ------
177
178 /**
179 Cartesian X, converting if necessary from internal coordinate system.
180 */
181 Scalar X() const { return fCoordinates.X(); }
182
183 /**
184 Cartesian Y, converting if necessary from internal coordinate system.
185 */
186 Scalar Y() const { return fCoordinates.Y(); }
187
188 /**
189 Polar R, converting if necessary from internal coordinate system.
190 */
191 Scalar R() const { return fCoordinates.R(); }
192
193 /**
194 Polar phi, converting if necessary from internal coordinate system.
195 */
196 Scalar Phi() const { return fCoordinates.Phi(); }
197
198 /**
199 Magnitute squared ( r^2 in spherical coordinate)
200 */
201 Scalar Mag2() const { return fCoordinates.Mag2();}
202
203
204 // It is physically meaningless to speak of the unit vector corresponding
205 // to a point.
206
207 // ------ Setting individual elements present in coordinate system ------
208
209 /**
210 Change X - Cartesian2D coordinates only
211 */
213 fCoordinates.SetX(a);
214 return *this;
215 }
216
217 /**
218 Change Y - Cartesian2D coordinates only
219 */
221 fCoordinates.SetY(a);
222 return *this;
223 }
224
225
226 /**
227 Change R - Polar2D coordinates only
228 */
230 fCoordinates.SetR(a);
231 return *this;
232 }
233
234 /**
235 Change Phi - Polar2D coordinates
236 */
238 fCoordinates.SetPhi(ang);
239 return *this;
240 }
241
242
243 // ------ Operations combining two vectors ------
244 // need to specialize to exclude those with a different tags
245
246 /**
247 Return the scalar (Dot) product of this with a displacement vector in
248 any coordinate system, but with the same tag
249 */
250 template< class OtherCoords >
252 return X()*v.x() + Y()*v.y();
253 }
254
255
256 // The Dot product of a pair of point vectors are physically
257 // meaningless concepts and thus are defined as private methods
258
259
260 /**
261 Self Addition with a displacement vector.
262 */
263 template <class OtherCoords>
265 {
266 SetXY( X() + v.X(), Y() + v.Y() );
267 return *this;
268 }
269
270 /**
271 Self Difference with a displacement vector.
272 */
273 template <class OtherCoords>
275 {
276 SetXY( X() - v.X(), Y() - v.Y() );
277 return *this;
278 }
279
280 /**
281 multiply this vector by a scalar quantity
282 */
284 fCoordinates.Scale(a);
285 return *this;
286 }
287
288 /**
289 divide this vector by a scalar quantity
290 */
292 fCoordinates.Scale(1/a);
293 return *this;
294 }
295
296 // The following methods (v*a and v/a) could instead be free functions.
297 // They were moved into the class to solve a problem on AIX.
298 /**
299 Multiply a vector by a real number
300 */
302 PositionVector2D tmp(*this);
303 tmp *= a;
304 return tmp;
305 }
306
307 /**
308 Division of a vector with a real number
309 */
311 PositionVector2D tmp(*this);
312 tmp /= a;
313 return tmp;
314 }
315
316 /**
317 Rotate by an angle
318 */
319 void Rotate( Scalar angle) {
320 return fCoordinates.Rotate(angle);
321 }
322
323 // Limited backward name compatibility with CLHEP
324
325 Scalar x() const { return fCoordinates.X(); }
326 Scalar y() const { return fCoordinates.Y(); }
327 Scalar r() const { return fCoordinates.R(); }
328 Scalar phi() const { return fCoordinates.Phi(); }
329 Scalar mag2() const { return fCoordinates.Mag2(); }
330
331 private:
332
333 CoordSystem fCoordinates;
334
335 // Prohibited methods
336
337 // this should not compile (if from a vector or points with different tag
338
339 template <class OtherCoords, class OtherTag>
341
342 template <class OtherCoords, class OtherTag>
344
345 template <class OtherCoords, class OtherTag>
347
348 template <class OtherCoords, class OtherTag>
350
351 template <class OtherCoords, class OtherTag>
353
354 template <class OtherCoords, class OtherTag>
356
357// /**
358// Dot product of two position vectors is inappropriate
359// */
360// template <class T2, class U>
361// PositionVector2D Dot( const PositionVector2D<T2,U> & v) const;
362
363
364
365 };
366
367// ---------- PositionVector2D class template ends here ----------------
368// ---------------------------------------------------------------------
369
370 /**
371 Multiplication of a position vector by real number a*v
372 */
373 template <class CoordSystem, class U>
374 inline
378 return v *= a;
379 // Note - passing v by value and using operator *= may save one
380 // copy relative to passing v by const ref and creating a temporary.
381 }
382
383 /**
384 Difference between two PositionVector2D vectors.
385 The result is a DisplacementVector2D.
386 The (coordinate system) type of the returned vector is defined to
387 be identical to that of the first position vector.
388 */
389
390 template <class CoordSystem1, class CoordSystem2, class U>
391 inline
392 DisplacementVector2D<CoordSystem1,U>
396 v1.X()-v2.X(), v1.Y()-v2.Y() )
397 );
398 }
399
400 /**
401 Addition of a PositionVector2D and a DisplacementVector2D.
402 The return type is a PositionVector2D,
403 of the same (coordinate system) type as the input PositionVector2D.
404 */
405 template <class CoordSystem1, class CoordSystem2, class U>
406 inline
407 PositionVector2D<CoordSystem2,U>
410 return p1 += v2;
411 }
412
413 /**
414 Addition of a DisplacementVector2D and a PositionVector2D.
415 The return type is a PositionVector2D,
416 of the same (coordinate system) type as the input PositionVector2D.
417 */
418 template <class CoordSystem1, class CoordSystem2, class U>
419 inline
420 PositionVector2D<CoordSystem2,U>
423 return p2 += v1;
424 }
425
426 /**
427 Subtraction of a DisplacementVector2D from a PositionVector2D.
428 The return type is a PositionVector2D,
429 of the same (coordinate system) type as the input PositionVector2D.
430 */
431 template <class CoordSystem1, class CoordSystem2, class U>
432 inline
433 PositionVector2D<CoordSystem2,U>
436 return p1 -= v2;
437 }
438
439 // Scaling of a position vector with a real number is not physically meaningful
440
441 // ------------- I/O to/from streams -------------
442
443 template< class char_t, class traits_t, class T, class U >
444 inline
445 std::basic_ostream<char_t,traits_t> &
446 operator << ( std::basic_ostream<char_t,traits_t> & os
447 , PositionVector2D<T,U> const & v
448 )
449 {
450 if( !os ) return os;
451
452 typename T::Scalar a, b;
454
457 typedef GenVector_detail::BitReproducible BR;
458 BR::Output(os, a);
459 BR::Output(os, b);
460 }
461 else {
462 os << detail::get_manip( os, detail::open ) << a
463 << detail::get_manip( os, detail::sep ) << b
465 }
466
467 return os;
468
469 } // op<< <>()
470
471
472 template< class char_t, class traits_t, class T, class U >
473 inline
474 std::basic_istream<char_t,traits_t> &
475 operator >> ( std::basic_istream<char_t,traits_t> & is
477 )
478 {
479 if( !is ) return is;
480
481 typename T::Scalar a, b;
482
486 BR::Input(is, a);
487 BR::Input(is, b);
488 }
489 else {
491 detail::require_delim( is, detail::sep ); is >> b;
493 }
494
495 if( is )
496 v.SetCoordinates(a, b);
497 return is;
498
499 } // op>> <>()
500
501
502
503
504 } // namespace Math
505
506} // namespace ROOT
507
508
509#endif /* ROOT_Math_GenVector_PositionVector2D */
#define b(i)
Definition RSha256.hxx:100
#define a(i)
Definition RSha256.hxx:99
Class describing a 2D cartesian coordinate system (x, y coordinates)
Definition Cartesian2D.h:37
Class describing a generic displacement vector in 2 dimensions.
Class describing a generic position vector (point) in 2 dimensions.
PositionVector2D< CoordSystem, Tag > & SetX(Scalar a)
Change X - Cartesian2D coordinates only.
Scalar Mag2() const
Magnitute squared ( r^2 in spherical coordinate)
bool operator!=(const PositionVector2D &rhs) const
PositionVector2D & operator-=(const DisplacementVector2D< OtherCoords, OtherTag > &)
void GetCoordinates(Scalar &a, Scalar &b) const
get internal data into 2 Scalar numbers.
PositionVector2D & operator=(const PositionVector2D< OtherCoords, Tag > &v)
Assignment operator from a position vector of arbitrary type.
Scalar R() const
Polar R, converting if necessary from internal coordinate system.
PositionVector2D & operator=(const DisplacementVector2D< OtherCoords, OtherTag > &)
void Rotate(Scalar angle)
Rotate by an angle.
Scalar Dot(const DisplacementVector2D< OtherCoords, Tag > &v) const
Return the scalar (Dot) product of this with a displacement vector in any coordinate system,...
PositionVector2D & operator=(const PositionVector2D< OtherCoords, OtherTag > &)
const CoordSystem & Coordinates() const
Retrieve a copy of the coordinates object.
PositionVector2D< CoordSystem, Tag > & SetY(Scalar a)
Change Y - Cartesian2D coordinates only.
PositionVector2D(const PositionVector2D< OtherCoords, OtherTag > &)
Scalar Y() const
Cartesian Y, converting if necessary from internal coordinate system.
PositionVector2D< CoordSystem, Tag > & SetPhi(Scalar ang)
Change Phi - Polar2D coordinates.
PositionVector2D< CoordSystem, Tag > & SetXY(Scalar a, Scalar b)
set the values of the vector from the cartesian components (x,y) (if the vector is held in polar coor...
PositionVector2D(const PositionVector2D< T, Tag > &v)
Construct from a position vector expressed in different coordinates, or using a different Scalar type...
PositionVector2D(const DisplacementVector2D< T, Tag > &p)
Construct from an arbitrary displacement vector.
PositionVector2D< CoordSystem, Tag > & SetCoordinates(Scalar a, Scalar b)
Set internal data based on 2 Scalar numbers.
PositionVector2D operator*(Scalar a) const
Multiply a vector by a real number.
PositionVector2D operator/(Scalar a) const
Division of a vector with a real number.
PositionVector2D & operator-=(const DisplacementVector2D< OtherCoords, Tag > &v)
Self Difference with a displacement vector.
Scalar X() const
Cartesian X, converting if necessary from internal coordinate system.
PositionVector2D & operator+=(const DisplacementVector2D< OtherCoords, OtherTag > &)
PositionVector2D()
Default constructor.
PositionVector2D(const ForeignVector &v)
Construct from a foreign 2D vector type, for example, Hep2Vector Precondition: v must implement metho...
PositionVector2D & operator/=(Scalar a)
divide this vector by a scalar quantity
bool operator==(const PositionVector2D &rhs) const
Exact equality.
Scalar Phi() const
Polar phi, converting if necessary from internal coordinate system.
PositionVector2D< CoordSystem, Tag > & SetR(Scalar a)
Change R - Polar2D coordinates only.
PositionVector2D(const Scalar &a, const Scalar &b)
Construct from three values of type Scalar.
PositionVector2D & operator+=(const DisplacementVector2D< OtherCoords, Tag > &v)
Self Addition with a displacement vector.
PositionVector2D(const DisplacementVector2D< OtherCoords, OtherTag > &)
PositionVector2D & operator*=(Scalar a)
multiply this vector by a scalar quantity
Double_t y[n]
Definition legend1.C:17
Double_t x[n]
Definition legend1.C:17
Namespace for new Math classes and functions.
char_t get_manip(std::basic_ios< char_t, traits_t > &ios, manip_t m)
Definition GenVectorIO.h:54
std::basic_istream< char_t, traits_t > & require_delim(std::basic_istream< char_t, traits_t > &is, manip_t m)
void set_manip(std::basic_ios< char_t, traits_t > &ios, manip_t m, char_t ch)
Definition GenVectorIO.h:74
std::basic_istream< char_t, traits_t > & operator>>(std::basic_istream< char_t, traits_t > &is, DisplacementVector2D< T, U > &v)
DisplacementVector2D< CoordSystem1, U > operator+(DisplacementVector2D< CoordSystem1, U > v1, const DisplacementVector2D< CoordSystem2, U > &v2)