```// @(#)root/mathcore:\$Id: PositionVector3D.h 38652 2011-03-29 14:24:43Z moneta \$
// Authors: W. Brown, M. Fischler, L. Moneta    2005

/**********************************************************************
*                                                                    *
* Copyright (c) 2005 , LCG ROOT MathLib Team                         *
*                                                                    *
*                                                                    *
**********************************************************************/

// Header file for class PositionVector3D
//
// Created by: Lorenzo Moneta  at Mon May 30 15:25:04 2005
//
// Last update: \$Id: PositionVector3D.h 38652 2011-03-29 14:24:43Z moneta \$
//
#ifndef ROOT_Math_GenVector_PositionVector3D
#define ROOT_Math_GenVector_PositionVector3D  1

#ifndef ROOT_Math_GenVector_DisplacementVector3Dfwd
#include "Math/GenVector/DisplacementVector3Dfwd.h"
#endif

#ifndef ROOT_Math_GenVector_Cartesian3D
#include "Math/GenVector/Cartesian3D.h"
#endif

#ifndef ROOT_Math_GenVector_GenVectorIO
#include "Math/GenVector/GenVectorIO.h"
#endif

#ifndef ROOT_Math_GenVector_BitReproducible
#include "Math/GenVector/BitReproducible.h"
#endif

#ifndef ROOT_Math_GenVector_CoordinateSystemTags
#include "Math/GenVector/CoordinateSystemTags.h"
#endif

#include <cassert>

namespace ROOT {

namespace Math {

//__________________________________________________________________________________________
/**
Class describing a generic position vector (point) in 3 dimensions.
This class is templated on the type of Coordinate system.
One example is the XYZPoint which is a vector based on
double precision x,y,z data members by using the
ROOT::Math::Cartesian3D<double> Coordinate system.
The class is having also an extra template parameter, the coordinate system tag,
to be able to identify (tag) vector described in different reference coordinate system,
like global or local coordinate systems.

@ingroup GenVector
*/

template <class CoordSystem, class Tag = DefaultCoordinateSystemTag >
class PositionVector3D {

public:

typedef typename CoordSystem::Scalar Scalar;
typedef CoordSystem CoordinateType;
typedef Tag  CoordinateSystemTag;

// ------ ctors ------

/**
Default constructor. Construct an empty object with zero values
*/

PositionVector3D() : fCoordinates() { }

/**
Construct from three values of type <em>Scalar</em>.
In the case of a XYZPoint the values are x,y,z
In the case of  a polar vector they are r,theta,phi
*/
PositionVector3D(const Scalar & a, const Scalar & b, const Scalar & c) :
fCoordinates ( a , b,  c)  { }

/**
Construct from a position vector expressed in different
coordinates, or using a different Scalar type
*/
template <class T>
explicit PositionVector3D( const PositionVector3D<T,Tag> & v) :
fCoordinates ( v.Coordinates() ) { }

/**
Construct from an arbitrary displacement vector
*/
template <class T>
explicit PositionVector3D( const DisplacementVector3D<T,Tag> & p) :
fCoordinates ( p.Coordinates() ) { }

/**
Construct from a foreign 3D vector type, for example, Hep3Vector
Precondition: v must implement methods x(), y() and z()
*/
template <class ForeignVector>
explicit PositionVector3D( const ForeignVector & v) :
fCoordinates ( Cartesian3D<Scalar>( v.x(), v.y(), v.z() ) ) { }

#ifdef LATER
/**
construct from a generic linear algebra  vector of at least size 3
implementing operator []. This could be also a C array
\par v  LAVector
\par index0   index where coordinates starts (typically zero)
It works for all Coordinates types,
( x= v[index0] for Cartesian and r=v[index0] for Polar )
*/
template <class LAVector>
PositionVector3D(const LAVector & v, size_t index0 ) {
fCoordinates = CoordSystem  ( v[index0], v[index0+1], v[index0+2] );
}
#endif

// compiler-generated copy ctor and dtor are fine.

// ------ assignment ------

/**
Assignment operator from a position vector of arbitrary type
*/
template <class OtherCoords>
PositionVector3D & operator=
( const PositionVector3D<OtherCoords,Tag> & v) {
fCoordinates = v.Coordinates();
return *this;
}

/**
Assignment operator from a displacement vector of arbitrary type
*/
template <class OtherCoords>
PositionVector3D & operator=
( const DisplacementVector3D<OtherCoords,Tag> & v) {
fCoordinates = v.Coordinates();
return *this;
}

/**
Assignment from a foreign 3D vector type, for example, Hep3Vector
Precondition: v must implement methods x(), y() and z()
*/
template <class ForeignVector>
PositionVector3D & operator= ( const ForeignVector & v) {
SetXYZ( v.x(),  v.y(), v.z() );
return *this;
}

#ifdef LATER
/**
assign from a generic linear algebra  vector of at least size 3
implementing operator [].
\par v  LAVector
\par index0   index where coordinates starts (typically zero)
It works for all Coordinates types,
( x= v[index0] for Cartesian and r=v[index0] for Polar )
*/
template <class LAVector>
PositionVector3D & assignFrom(const LAVector & v, size_t index0 = 0) {
fCoordinates = CoordSystem  ( v[index0], v[index0+1], v[index0+2] );
return *this;
}
#endif

/**
Retrieve a copy of the coordinates object
*/
const CoordSystem & Coordinates() const {
return fCoordinates;
}

/**
Set internal data based on a C-style array of 3 Scalar numbers
*/
PositionVector3D<CoordSystem, Tag>& SetCoordinates( const Scalar src[] )
{ fCoordinates.SetCoordinates(src); return *this;  }

/**
Set internal data based on 3 Scalar numbers
*/
PositionVector3D<CoordSystem, Tag>& SetCoordinates( Scalar a, Scalar b, Scalar c )
{ fCoordinates.SetCoordinates(a, b, c); return *this; }

/**
Set internal data based on 3 Scalars at *begin to *end
*/
template <class IT>
#ifndef NDEBUG
PositionVector3D<CoordSystem, Tag>& SetCoordinates( IT begin, IT end )
#else
PositionVector3D<CoordSystem, Tag>& SetCoordinates( IT begin, IT /* end */ )
#endif
{ IT a = begin; IT b = ++begin; IT c = ++begin;
assert (++begin==end);
SetCoordinates (*a,*b,*c);
return *this;
}

/**
get internal data into 3 Scalar numbers
*/
void GetCoordinates( Scalar& a, Scalar& b, Scalar& c ) const
{ fCoordinates.GetCoordinates(a, b, c);  }

/**
get internal data into a C-style array of 3 Scalar numbers
*/
void GetCoordinates( Scalar dest[] ) const
{ fCoordinates.GetCoordinates(dest);  }

/**
get internal data into 3 Scalars at *begin to *end (3 past begin)
*/
template <class IT>
#ifndef NDEBUG
void GetCoordinates( IT begin, IT end ) const
#else
void GetCoordinates( IT begin, IT /* end */ ) const
#endif
{ IT a = begin; IT b = ++begin; IT c = ++begin;
assert (++begin==end);
GetCoordinates (*a,*b,*c);
}

/**
get internal data into 3 Scalars at *begin
*/
template <class IT>
void GetCoordinates( IT begin ) const {
Scalar a,b,c = 0;
GetCoordinates (a,b,c);
*begin++ = a;
*begin++ = b;
*begin   = c;
}

/**
set the values of the vector from the cartesian components (x,y,z)
(if the vector is held in polar or cylindrical eta coordinates,
then (x, y, z) are converted to that form)
*/
PositionVector3D<CoordSystem, Tag>& SetXYZ (Scalar a, Scalar b, Scalar c) {
fCoordinates.SetXYZ(a,b,c);
return *this;
}

// ------------------- Equality -----------------

/**
Exact equality
*/
bool operator==(const PositionVector3D & rhs) const {
return fCoordinates==rhs.fCoordinates;
}
bool operator!= (const PositionVector3D & rhs) const {
return !(operator==(rhs));
}

// ------ Individual element access, in various coordinate systems ------

/**
Cartesian X, converting if necessary from internal coordinate system.
*/
Scalar X() const { return fCoordinates.X(); }

/**
Cartesian Y, converting if necessary from internal coordinate system.
*/
Scalar Y() const { return fCoordinates.Y(); }

/**
Cartesian Z, converting if necessary from internal coordinate system.
*/
Scalar Z() const { return fCoordinates.Z(); }

/**
Polar R, converting if necessary from internal coordinate system.
*/
Scalar R() const { return fCoordinates.R(); }

/**
Polar theta, converting if necessary from internal coordinate system.
*/
Scalar Theta() const { return fCoordinates.Theta(); }

/**
Polar phi, converting if necessary from internal coordinate system.
*/
Scalar Phi() const { return fCoordinates.Phi(); }

/**
Polar eta, converting if necessary from internal coordinate system.
*/
Scalar Eta() const { return fCoordinates.Eta(); }

/**
Cylindrical transverse component rho
*/
Scalar Rho() const { return fCoordinates.Rho(); }

// ----- Other fundamental properties -----

/**
Magnitute squared ( r^2 in spherical coordinate)
*/
Scalar Mag2() const { return fCoordinates.Mag2();}

/**
Transverse component squared (rho^2 in cylindrical coordinates.
*/
Scalar Perp2() const { return fCoordinates.Perp2();}

// It is physically meaningless to speak of the unit vector corresponding
// to a point.

// ------ Setting individual elements present in coordinate system ------

/**
Change X - Cartesian3D coordinates only
*/
PositionVector3D<CoordSystem, Tag>& SetX (Scalar xx) { fCoordinates.SetX(xx); return *this;}

/**
Change Y - Cartesian3D coordinates only
*/
PositionVector3D<CoordSystem, Tag>& SetY (Scalar yy) { fCoordinates.SetY(yy); return *this;}

/**
Change Z - Cartesian3D coordinates only
*/
PositionVector3D<CoordSystem, Tag>& SetZ (Scalar zz) { fCoordinates.SetZ(zz); return *this;}

/**
Change R - Polar3D coordinates only
*/
PositionVector3D<CoordSystem, Tag>& SetR (Scalar rr) { fCoordinates.SetR(rr); return *this;}

/**
Change Theta - Polar3D coordinates only
*/
PositionVector3D<CoordSystem, Tag>& SetTheta (Scalar ang) { fCoordinates.SetTheta(ang); return *this;}

/**
Change Phi - Polar3D or CylindricalEta3D coordinates
*/
PositionVector3D<CoordSystem, Tag>& SetPhi (Scalar ang) { fCoordinates.SetPhi(ang); return *this;}

/**
Change Rho - CylindricalEta3D coordinates only
*/
PositionVector3D<CoordSystem, Tag>& SetRho (Scalar rr) { fCoordinates.SetRho(rr); return *this;}

/**
Change Eta - CylindricalEta3D coordinates only
*/
PositionVector3D<CoordSystem, Tag>& SetEta (Scalar etaval) { fCoordinates.SetEta(etaval); return *this;}

// ------ Operations combining two vectors ------
// need to specialize to exclude those with a different tags

/**
Return the scalar (Dot) product of this with a displacement vector in
any coordinate system, but with the same tag
*/
template< class OtherCoords >
Scalar Dot( const  DisplacementVector3D<OtherCoords,Tag> & v) const {
return X()*v.x() + Y()*v.y() + Z()*v.z();
}

/**
Return vector (Cross) product of this point with a displacement, as a
point vector in this coordinate system of the first.
*/
template< class OtherCoords >
PositionVector3D Cross( const DisplacementVector3D<OtherCoords,Tag> & v) const  {
PositionVector3D  result;
result.SetXYZ (  Y()*v.z() - v.y()*Z(),
Z()*v.x() - v.z()*X(),
X()*v.y() - v.x()*Y() );
return result;
}

// The Dot and Cross products of a pair of point vectors are physically
// meaningless concepts and thus are defined as private methods

// It is physically meaningless to speak of the Unit vector corresponding
// to a point.

/**
Self Addition with a displacement vector.
*/
template <class OtherCoords>
PositionVector3D & operator+= (const  DisplacementVector3D<OtherCoords,Tag> & v)
{
SetXYZ( X() + v.X(), Y() + v.Y(), Z() + v.Z() );
return *this;
}

/**
Self Difference with a displacement vector.
*/
template <class OtherCoords>
PositionVector3D & operator-= (const  DisplacementVector3D<OtherCoords,Tag> & v)
{
SetXYZ(  X() - v.X(), Y() - v.Y(), Z() - v.Z() );
return *this;
}

/**
multiply this vector by a scalar quantity
*/
PositionVector3D & operator *= (Scalar a) {
fCoordinates.Scale(a);
return *this;
}

/**
divide this vector by a scalar quantity
*/
PositionVector3D & operator /= (Scalar a) {
fCoordinates.Scale(1/a);
return *this;
}

// The following methods (v*a and v/a) could instead be free functions.
// They were moved into the class to solve a problem on AIX.
/**
Multiply a vector by a real number
*/
PositionVector3D operator * ( Scalar a ) const {
PositionVector3D tmp(*this);
tmp *= a;
return tmp;
}

/**
Division of a vector with a real number
*/
PositionVector3D operator / (Scalar a) const {
PositionVector3D tmp(*this);
tmp /= a;
return tmp;
}

// Limited backward name compatibility with CLHEP

Scalar x()     const { return fCoordinates.X();     }
Scalar y()     const { return fCoordinates.Y();     }
Scalar z()     const { return fCoordinates.Z();     }
Scalar r()     const { return fCoordinates.R();     }
Scalar theta() const { return fCoordinates.Theta(); }
Scalar phi()   const { return fCoordinates.Phi();   }
Scalar eta()   const { return fCoordinates.Eta();   }
Scalar rho()   const { return fCoordinates.Rho();   }
Scalar mag2()  const { return fCoordinates.Mag2();  }
Scalar perp2() const { return fCoordinates.Perp2(); }

private:

CoordSystem fCoordinates;

// Prohibited methods

// this should not compile (if from a vector or points with different tag

template <class OtherCoords, class OtherTag>
explicit PositionVector3D( const PositionVector3D<OtherCoords, OtherTag> & );

template <class OtherCoords, class OtherTag>
explicit PositionVector3D( const DisplacementVector3D<OtherCoords, OtherTag> & );

template <class OtherCoords, class OtherTag>
PositionVector3D & operator=( const PositionVector3D<OtherCoords, OtherTag> & );

template <class OtherCoords, class OtherTag>
PositionVector3D & operator=( const DisplacementVector3D<OtherCoords, OtherTag> & );

template <class OtherCoords, class OtherTag>
PositionVector3D & operator+=(const  DisplacementVector3D<OtherCoords, OtherTag> & );

template <class OtherCoords, class OtherTag>
PositionVector3D & operator-=(const  DisplacementVector3D<OtherCoords, OtherTag> & );

//       /**
//          Dot product of two position vectors is inappropriate
//       */
//       template <class T2, class U>
//       PositionVector3D Dot( const PositionVector3D<T2,U> & v) const;

//       /**
//          Cross product of two position vectors is inappropriate
//       */
//       template <class T2, class U>
//       PositionVector3D Cross( const PositionVector3D<T2,U> & v) const;

};

// ---------- PositionVector3D class template ends here ----------------
// ---------------------------------------------------------------------

/**
Multiplication of a position vector by real number  a*v
*/
template <class CoordSystem, class U>
inline
PositionVector3D<CoordSystem>
operator * ( typename PositionVector3D<CoordSystem,U>::Scalar a,
PositionVector3D<CoordSystem,U> v) {
return v *= a;
// Note - passing v by value and using operator *= may save one
// copy relative to passing v by const ref and creating a temporary.
}

/**
Difference between two PositionVector3D vectors.
The result is a DisplacementVector3D.
The (coordinate system) type of the returned vector is defined to
be identical to that of the first position vector.
*/

template <class CoordSystem1, class CoordSystem2, class U>
inline
DisplacementVector3D<CoordSystem1,U>
operator-( const PositionVector3D<CoordSystem1,U> & v1,
const PositionVector3D<CoordSystem2,U> & v2) {
return DisplacementVector3D<CoordSystem1,U>( Cartesian3D<typename CoordSystem1::Scalar>(
v1.X()-v2.X(), v1.Y()-v2.Y(),v1.Z()-v2.Z() )
);
}

/**
Addition of a PositionVector3D and a DisplacementVector3D.
The return type is a PositionVector3D,
of the same (coordinate system) type as the input PositionVector3D.
*/
template <class CoordSystem1, class CoordSystem2, class U>
inline
PositionVector3D<CoordSystem2,U>
operator+( PositionVector3D<CoordSystem2,U> p1,
const DisplacementVector3D<CoordSystem1,U>  & v2)        {
return p1 += v2;
}

/**
Addition of a DisplacementVector3D and a PositionVector3D.
The return type is a PositionVector3D,
of the same (coordinate system) type as the input PositionVector3D.
*/
template <class CoordSystem1, class CoordSystem2, class U>
inline
PositionVector3D<CoordSystem2,U>
operator+( DisplacementVector3D<CoordSystem1,U> const & v1,
PositionVector3D<CoordSystem2,U> p2)        {
return p2 += v1;
}

/**
Subtraction of a DisplacementVector3D from a PositionVector3D.
The return type is a PositionVector3D,
of the same (coordinate system) type as the input PositionVector3D.
*/
template <class CoordSystem1, class CoordSystem2, class U>
inline
PositionVector3D<CoordSystem2,U>
operator-( PositionVector3D<CoordSystem2,U> p1,
DisplacementVector3D<CoordSystem1,U> const & v2)        {
return p1 -= v2;
}

// Scaling of a position vector with a real number is not physically meaningful

// ------------- I/O to/from streams -------------

template< class char_t, class traits_t, class T, class U >
inline
std::basic_ostream<char_t,traits_t> &
operator << ( std::basic_ostream<char_t,traits_t> & os
, PositionVector3D<T,U> const & v
)
{
if( !os )  return os;

typename T::Scalar a, b, c;
v.GetCoordinates(a, b, c);

if( detail::get_manip( os, detail::bitforbit ) )  {
detail::set_manip( os, detail::bitforbit, '\00' );
typedef GenVector_detail::BitReproducible BR;
BR::Output(os, a);
BR::Output(os, b);
BR::Output(os, c);
}
else  {
os << detail::get_manip( os, detail::open  ) << a
<< detail::get_manip( os, detail::sep   ) << b
<< detail::get_manip( os, detail::sep   ) << c
<< detail::get_manip( os, detail::close );
}

return os;

}  // op<< <>()

template< class char_t, class traits_t, class T, class U >
inline
std::basic_istream<char_t,traits_t> &
operator >> ( std::basic_istream<char_t,traits_t> & is
, PositionVector3D<T,U> & v
)
{
if( !is )  return is;

typename T::Scalar a, b, c;

if( detail::get_manip( is, detail::bitforbit ) )  {
detail::set_manip( is, detail::bitforbit, '\00' );
typedef GenVector_detail::BitReproducible BR;
BR::Input(is, a);
BR::Input(is, b);
BR::Input(is, c);
}
else  {
detail::require_delim( is, detail::open  );  is >> a;
detail::require_delim( is, detail::sep   );  is >> b;
detail::require_delim( is, detail::sep   );  is >> c;
detail::require_delim( is, detail::close );
}

if( is )
v.SetCoordinates(a, b, c);
return is;

}  // op>> <>()

} // namespace Math

} // namespace ROOT

#endif /* ROOT_Math_GenVector_PositionVector3D  */
```
PositionVector3D.h:1
PositionVector3D.h:2
PositionVector3D.h:3
PositionVector3D.h:4
PositionVector3D.h:5
PositionVector3D.h:6
PositionVector3D.h:7
PositionVector3D.h:8
PositionVector3D.h:9
PositionVector3D.h:10
PositionVector3D.h:11
PositionVector3D.h:12
PositionVector3D.h:13
PositionVector3D.h:14
PositionVector3D.h:15
PositionVector3D.h:16
PositionVector3D.h:17
PositionVector3D.h:18
PositionVector3D.h:19
PositionVector3D.h:20
PositionVector3D.h:21
PositionVector3D.h:22
PositionVector3D.h:23
PositionVector3D.h:24
PositionVector3D.h:25
PositionVector3D.h:26
PositionVector3D.h:27
PositionVector3D.h:28
PositionVector3D.h:29
PositionVector3D.h:30
PositionVector3D.h:31
PositionVector3D.h:32
PositionVector3D.h:33
PositionVector3D.h:34
PositionVector3D.h:35
PositionVector3D.h:36
PositionVector3D.h:37
PositionVector3D.h:38
PositionVector3D.h:39
PositionVector3D.h:40
PositionVector3D.h:41
PositionVector3D.h:42
PositionVector3D.h:43
PositionVector3D.h:44
PositionVector3D.h:45
PositionVector3D.h:46
PositionVector3D.h:47
PositionVector3D.h:48
PositionVector3D.h:49
PositionVector3D.h:50
PositionVector3D.h:51
PositionVector3D.h:52
PositionVector3D.h:53
PositionVector3D.h:54
PositionVector3D.h:55
PositionVector3D.h:56
PositionVector3D.h:57
PositionVector3D.h:58
PositionVector3D.h:59
PositionVector3D.h:60
PositionVector3D.h:61
PositionVector3D.h:62
PositionVector3D.h:63
PositionVector3D.h:64
PositionVector3D.h:65
PositionVector3D.h:66
PositionVector3D.h:67
PositionVector3D.h:68
PositionVector3D.h:69
PositionVector3D.h:70
PositionVector3D.h:71
PositionVector3D.h:72
PositionVector3D.h:73
PositionVector3D.h:74
PositionVector3D.h:75
PositionVector3D.h:76
PositionVector3D.h:77
PositionVector3D.h:78
PositionVector3D.h:79
PositionVector3D.h:80
PositionVector3D.h:81
PositionVector3D.h:82
PositionVector3D.h:83
PositionVector3D.h:84
PositionVector3D.h:85
PositionVector3D.h:86
PositionVector3D.h:87
PositionVector3D.h:88
PositionVector3D.h:89
PositionVector3D.h:90
PositionVector3D.h:91
PositionVector3D.h:92
PositionVector3D.h:93
PositionVector3D.h:94
PositionVector3D.h:95
PositionVector3D.h:96
PositionVector3D.h:97
PositionVector3D.h:98
PositionVector3D.h:99
PositionVector3D.h:100
PositionVector3D.h:101
PositionVector3D.h:102
PositionVector3D.h:103
PositionVector3D.h:104
PositionVector3D.h:105
PositionVector3D.h:106
PositionVector3D.h:107
PositionVector3D.h:108
PositionVector3D.h:109
PositionVector3D.h:110
PositionVector3D.h:111
PositionVector3D.h:112
PositionVector3D.h:113
PositionVector3D.h:114
PositionVector3D.h:115
PositionVector3D.h:116
PositionVector3D.h:117
PositionVector3D.h:118
PositionVector3D.h:119
PositionVector3D.h:120
PositionVector3D.h:121
PositionVector3D.h:122
PositionVector3D.h:123
PositionVector3D.h:124
PositionVector3D.h:125
PositionVector3D.h:126
PositionVector3D.h:127
PositionVector3D.h:128
PositionVector3D.h:129
PositionVector3D.h:130
PositionVector3D.h:131
PositionVector3D.h:132
PositionVector3D.h:133
PositionVector3D.h:134
PositionVector3D.h:135
PositionVector3D.h:136
PositionVector3D.h:137
PositionVector3D.h:138
PositionVector3D.h:139
PositionVector3D.h:140
PositionVector3D.h:141
PositionVector3D.h:142
PositionVector3D.h:143
PositionVector3D.h:144
PositionVector3D.h:145
PositionVector3D.h:146
PositionVector3D.h:147
PositionVector3D.h:148
PositionVector3D.h:149
PositionVector3D.h:150
PositionVector3D.h:151
PositionVector3D.h:152
PositionVector3D.h:153
PositionVector3D.h:154
PositionVector3D.h:155
PositionVector3D.h:156
PositionVector3D.h:157
PositionVector3D.h:158
PositionVector3D.h:159
PositionVector3D.h:160
PositionVector3D.h:161
PositionVector3D.h:162
PositionVector3D.h:163
PositionVector3D.h:164
PositionVector3D.h:165
PositionVector3D.h:166
PositionVector3D.h:167
PositionVector3D.h:168
PositionVector3D.h:169
PositionVector3D.h:170
PositionVector3D.h:171
PositionVector3D.h:172
PositionVector3D.h:173
PositionVector3D.h:174
PositionVector3D.h:175
PositionVector3D.h:176
PositionVector3D.h:177
PositionVector3D.h:178
PositionVector3D.h:179
PositionVector3D.h:180
PositionVector3D.h:181
PositionVector3D.h:182
PositionVector3D.h:183
PositionVector3D.h:184
PositionVector3D.h:185
PositionVector3D.h:186
PositionVector3D.h:187
PositionVector3D.h:188
PositionVector3D.h:189
PositionVector3D.h:190
PositionVector3D.h:191
PositionVector3D.h:192
PositionVector3D.h:193
PositionVector3D.h:194
PositionVector3D.h:195
PositionVector3D.h:196
PositionVector3D.h:197
PositionVector3D.h:198
PositionVector3D.h:199
PositionVector3D.h:200
PositionVector3D.h:201
PositionVector3D.h:202
PositionVector3D.h:203
PositionVector3D.h:204
PositionVector3D.h:205
PositionVector3D.h:206
PositionVector3D.h:207
PositionVector3D.h:208
PositionVector3D.h:209
PositionVector3D.h:210
PositionVector3D.h:211
PositionVector3D.h:212
PositionVector3D.h:213
PositionVector3D.h:214
PositionVector3D.h:215
PositionVector3D.h:216
PositionVector3D.h:217
PositionVector3D.h:218
PositionVector3D.h:219
PositionVector3D.h:220
PositionVector3D.h:221
PositionVector3D.h:222
PositionVector3D.h:223
PositionVector3D.h:224
PositionVector3D.h:225
PositionVector3D.h:226
PositionVector3D.h:227
PositionVector3D.h:228
PositionVector3D.h:229
PositionVector3D.h:230
PositionVector3D.h:231
PositionVector3D.h:232
PositionVector3D.h:233
PositionVector3D.h:234
PositionVector3D.h:235
PositionVector3D.h:236
PositionVector3D.h:237
PositionVector3D.h:238
PositionVector3D.h:239
PositionVector3D.h:240
PositionVector3D.h:241
PositionVector3D.h:242
PositionVector3D.h:243
PositionVector3D.h:244
PositionVector3D.h:245
PositionVector3D.h:246
PositionVector3D.h:247
PositionVector3D.h:248
PositionVector3D.h:249
PositionVector3D.h:250
PositionVector3D.h:251
PositionVector3D.h:252
PositionVector3D.h:253
PositionVector3D.h:254
PositionVector3D.h:255
PositionVector3D.h:256
PositionVector3D.h:257
PositionVector3D.h:258
PositionVector3D.h:259
PositionVector3D.h:260
PositionVector3D.h:261
PositionVector3D.h:262
PositionVector3D.h:263
PositionVector3D.h:264
PositionVector3D.h:265
PositionVector3D.h:266
PositionVector3D.h:267
PositionVector3D.h:268
PositionVector3D.h:269
PositionVector3D.h:270
PositionVector3D.h:271
PositionVector3D.h:272
PositionVector3D.h:273
PositionVector3D.h:274
PositionVector3D.h:275
PositionVector3D.h:276
PositionVector3D.h:277
PositionVector3D.h:278
PositionVector3D.h:279
PositionVector3D.h:280
PositionVector3D.h:281
PositionVector3D.h:282
PositionVector3D.h:283
PositionVector3D.h:284
PositionVector3D.h:285
PositionVector3D.h:286
PositionVector3D.h:287
PositionVector3D.h:288
PositionVector3D.h:289
PositionVector3D.h:290
PositionVector3D.h:291
PositionVector3D.h:292
PositionVector3D.h:293
PositionVector3D.h:294
PositionVector3D.h:295
PositionVector3D.h:296
PositionVector3D.h:297
PositionVector3D.h:298
PositionVector3D.h:299
PositionVector3D.h:300
PositionVector3D.h:301
PositionVector3D.h:302
PositionVector3D.h:303
PositionVector3D.h:304
PositionVector3D.h:305
PositionVector3D.h:306
PositionVector3D.h:307
PositionVector3D.h:308
PositionVector3D.h:309
PositionVector3D.h:310
PositionVector3D.h:311
PositionVector3D.h:312
PositionVector3D.h:313
PositionVector3D.h:314
PositionVector3D.h:315
PositionVector3D.h:316
PositionVector3D.h:317
PositionVector3D.h:318
PositionVector3D.h:319
PositionVector3D.h:320
PositionVector3D.h:321
PositionVector3D.h:322
PositionVector3D.h:323
PositionVector3D.h:324
PositionVector3D.h:325
PositionVector3D.h:326
PositionVector3D.h:327
PositionVector3D.h:328
PositionVector3D.h:329
PositionVector3D.h:330
PositionVector3D.h:331
PositionVector3D.h:332
PositionVector3D.h:333
PositionVector3D.h:334
PositionVector3D.h:335
PositionVector3D.h:336
PositionVector3D.h:337
PositionVector3D.h:338
PositionVector3D.h:339
PositionVector3D.h:340
PositionVector3D.h:341
PositionVector3D.h:342
PositionVector3D.h:343
PositionVector3D.h:344
PositionVector3D.h:345
PositionVector3D.h:346
PositionVector3D.h:347
PositionVector3D.h:348
PositionVector3D.h:349
PositionVector3D.h:350
PositionVector3D.h:351
PositionVector3D.h:352
PositionVector3D.h:353
PositionVector3D.h:354
PositionVector3D.h:355
PositionVector3D.h:356
PositionVector3D.h:357
PositionVector3D.h:358
PositionVector3D.h:359
PositionVector3D.h:360
PositionVector3D.h:361
PositionVector3D.h:362
PositionVector3D.h:363
PositionVector3D.h:364
PositionVector3D.h:365
PositionVector3D.h:366
PositionVector3D.h:367
PositionVector3D.h:368
PositionVector3D.h:369
PositionVector3D.h:370
PositionVector3D.h:371
PositionVector3D.h:372
PositionVector3D.h:373
PositionVector3D.h:374
PositionVector3D.h:375
PositionVector3D.h:376
PositionVector3D.h:377
PositionVector3D.h:378
PositionVector3D.h:379
PositionVector3D.h:380
PositionVector3D.h:381
PositionVector3D.h:382
PositionVector3D.h:383
PositionVector3D.h:384
PositionVector3D.h:385
PositionVector3D.h:386
PositionVector3D.h:387
PositionVector3D.h:388
PositionVector3D.h:389
PositionVector3D.h:390
PositionVector3D.h:391
PositionVector3D.h:392
PositionVector3D.h:393
PositionVector3D.h:394
PositionVector3D.h:395
PositionVector3D.h:396
PositionVector3D.h:397
PositionVector3D.h:398
PositionVector3D.h:399
PositionVector3D.h:400
PositionVector3D.h:401
PositionVector3D.h:402
PositionVector3D.h:403
PositionVector3D.h:404
PositionVector3D.h:405
PositionVector3D.h:406
PositionVector3D.h:407
PositionVector3D.h:408
PositionVector3D.h:409
PositionVector3D.h:410
PositionVector3D.h:411
PositionVector3D.h:412
PositionVector3D.h:413
PositionVector3D.h:414
PositionVector3D.h:415
PositionVector3D.h:416
PositionVector3D.h:417
PositionVector3D.h:418
PositionVector3D.h:419
PositionVector3D.h:420
PositionVector3D.h:421
PositionVector3D.h:422
PositionVector3D.h:423
PositionVector3D.h:424
PositionVector3D.h:425
PositionVector3D.h:426
PositionVector3D.h:427
PositionVector3D.h:428
PositionVector3D.h:429
PositionVector3D.h:430
PositionVector3D.h:431
PositionVector3D.h:432
PositionVector3D.h:433
PositionVector3D.h:434
PositionVector3D.h:435
PositionVector3D.h:436
PositionVector3D.h:437
PositionVector3D.h:438
PositionVector3D.h:439
PositionVector3D.h:440
PositionVector3D.h:441
PositionVector3D.h:442
PositionVector3D.h:443
PositionVector3D.h:444
PositionVector3D.h:445
PositionVector3D.h:446
PositionVector3D.h:447
PositionVector3D.h:448
PositionVector3D.h:449
PositionVector3D.h:450
PositionVector3D.h:451
PositionVector3D.h:452
PositionVector3D.h:453
PositionVector3D.h:454
PositionVector3D.h:455
PositionVector3D.h:456
PositionVector3D.h:457
PositionVector3D.h:458
PositionVector3D.h:459
PositionVector3D.h:460
PositionVector3D.h:461
PositionVector3D.h:462
PositionVector3D.h:463
PositionVector3D.h:464
PositionVector3D.h:465
PositionVector3D.h:466
PositionVector3D.h:467
PositionVector3D.h:468
PositionVector3D.h:469
PositionVector3D.h:470
PositionVector3D.h:471
PositionVector3D.h:472
PositionVector3D.h:473
PositionVector3D.h:474
PositionVector3D.h:475
PositionVector3D.h:476
PositionVector3D.h:477
PositionVector3D.h:478
PositionVector3D.h:479
PositionVector3D.h:480
PositionVector3D.h:481
PositionVector3D.h:482
PositionVector3D.h:483
PositionVector3D.h:484
PositionVector3D.h:485
PositionVector3D.h:486
PositionVector3D.h:487
PositionVector3D.h:488
PositionVector3D.h:489
PositionVector3D.h:490
PositionVector3D.h:491
PositionVector3D.h:492
PositionVector3D.h:493
PositionVector3D.h:494
PositionVector3D.h:495
PositionVector3D.h:496
PositionVector3D.h:497
PositionVector3D.h:498
PositionVector3D.h:499
PositionVector3D.h:500
PositionVector3D.h:501
PositionVector3D.h:502
PositionVector3D.h:503
PositionVector3D.h:504
PositionVector3D.h:505
PositionVector3D.h:506
PositionVector3D.h:507
PositionVector3D.h:508
PositionVector3D.h:509
PositionVector3D.h:510
PositionVector3D.h:511
PositionVector3D.h:512
PositionVector3D.h:513
PositionVector3D.h:514
PositionVector3D.h:515
PositionVector3D.h:516
PositionVector3D.h:517
PositionVector3D.h:518
PositionVector3D.h:519
PositionVector3D.h:520
PositionVector3D.h:521
PositionVector3D.h:522
PositionVector3D.h:523
PositionVector3D.h:524
PositionVector3D.h:525
PositionVector3D.h:526
PositionVector3D.h:527
PositionVector3D.h:528
PositionVector3D.h:529
PositionVector3D.h:530
PositionVector3D.h:531
PositionVector3D.h:532
PositionVector3D.h:533
PositionVector3D.h:534
PositionVector3D.h:535
PositionVector3D.h:536
PositionVector3D.h:537
PositionVector3D.h:538
PositionVector3D.h:539
PositionVector3D.h:540
PositionVector3D.h:541
PositionVector3D.h:542
PositionVector3D.h:543
PositionVector3D.h:544
PositionVector3D.h:545
PositionVector3D.h:546
PositionVector3D.h:547
PositionVector3D.h:548
PositionVector3D.h:549
PositionVector3D.h:550
PositionVector3D.h:551
PositionVector3D.h:552
PositionVector3D.h:553
PositionVector3D.h:554
PositionVector3D.h:555
PositionVector3D.h:556
PositionVector3D.h:557
PositionVector3D.h:558
PositionVector3D.h:559
PositionVector3D.h:560
PositionVector3D.h:561
PositionVector3D.h:562
PositionVector3D.h:563
PositionVector3D.h:564
PositionVector3D.h:565
PositionVector3D.h:566
PositionVector3D.h:567
PositionVector3D.h:568
PositionVector3D.h:569
PositionVector3D.h:570
PositionVector3D.h:571
PositionVector3D.h:572
PositionVector3D.h:573
PositionVector3D.h:574
PositionVector3D.h:575
PositionVector3D.h:576
PositionVector3D.h:577
PositionVector3D.h:578
PositionVector3D.h:579
PositionVector3D.h:580
PositionVector3D.h:581
PositionVector3D.h:582
PositionVector3D.h:583
PositionVector3D.h:584
PositionVector3D.h:585
PositionVector3D.h:586
PositionVector3D.h:587
PositionVector3D.h:588
PositionVector3D.h:589
PositionVector3D.h:590
PositionVector3D.h:591
PositionVector3D.h:592
PositionVector3D.h:593
PositionVector3D.h:594
PositionVector3D.h:595
PositionVector3D.h:596
PositionVector3D.h:597
PositionVector3D.h:598
PositionVector3D.h:599
PositionVector3D.h:600
PositionVector3D.h:601
PositionVector3D.h:602
PositionVector3D.h:603
PositionVector3D.h:604
PositionVector3D.h:605
PositionVector3D.h:606
PositionVector3D.h:607
PositionVector3D.h:608
PositionVector3D.h:609
PositionVector3D.h:610
PositionVector3D.h:611
PositionVector3D.h:612
PositionVector3D.h:613
PositionVector3D.h:614
PositionVector3D.h:615
PositionVector3D.h:616
PositionVector3D.h:617
PositionVector3D.h:618
PositionVector3D.h:619
PositionVector3D.h:620
PositionVector3D.h:621
PositionVector3D.h:622
PositionVector3D.h:623
PositionVector3D.h:624
PositionVector3D.h:625
PositionVector3D.h:626
PositionVector3D.h:627
PositionVector3D.h:628
PositionVector3D.h:629
PositionVector3D.h:630
PositionVector3D.h:631
PositionVector3D.h:632
PositionVector3D.h:633
PositionVector3D.h:634
PositionVector3D.h:635
PositionVector3D.h:636
PositionVector3D.h:637
PositionVector3D.h:638
PositionVector3D.h:639
PositionVector3D.h:640
PositionVector3D.h:641
PositionVector3D.h:642
PositionVector3D.h:643
PositionVector3D.h:644
PositionVector3D.h:645
PositionVector3D.h:646
PositionVector3D.h:647
PositionVector3D.h:648
PositionVector3D.h:649
PositionVector3D.h:650
PositionVector3D.h:651
PositionVector3D.h:652
PositionVector3D.h:653
PositionVector3D.h:654
PositionVector3D.h:655
PositionVector3D.h:656
PositionVector3D.h:657
PositionVector3D.h:658