# class ROOT::Math::DisplacementVector3D<ROOT::Math::Cylindrical3D<Double32_t>,ROOT::Math::DefaultCoordinateSystemTag>

```
Class describing a generic displacement vector in 3 dimensions.
This class is templated on the type of Coordinate system.
One example is the XYZVector 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

```

## Data Members

private:
 ROOT::Math::Cylindrical3D fCoordinates internal coordinate system

## Function documentation

DisplacementVector3D & operator=( const ForeignVector & v)
```          Assignment from a foreign 3D vector type, for example, Hep3Vector
Precondition: v must implement methods x(), y() and z()

```
CoordSystem Coordinates() const
``` ------ Set, Get, and access coordinate data ------

Retrieve a copy of the coordinates object

```
DisplacementVector3D<CoordSystem, Tag>& SetCoordinates(const Scalar[] src)
```         Set internal data based on a C-style array of 3 Scalar numbers

```
`{ fCoordinates.SetCoordinates(src); return *this; }`

```         Set internal data based on 3 Scalar numbers

```
`{ fCoordinates.SetCoordinates(a, b, c); return *this; }`

```         get internal data into 3 Scalar numbers

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

```
`{ fCoordinates.GetCoordinates(dest); }`

``` ------------------- Equality -----------------

Exact equality

```

Scalar X() const
``` ------ Individual element access, in various coordinate systems ------

Cartesian X, converting if necessary from internal coordinate system.

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

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

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

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

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

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

```
`{ return fCoordinates.Eta(); }`
Scalar Rho() const
```          Cylindrical transverse component rho

```
`{ return fCoordinates.Rho(); }`
Scalar Mag2() const
``` ----- Other fundamental properties -----

Magnitute squared ( r^2 in spherical coordinate)

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

```
`{ return fCoordinates.Perp2();}`
DisplacementVector3D Unit() const
```         return unit vector parallel to this

```

``` ------ Setting of individual elements present in coordinate system ------

Change X - Cartesian3D coordinates only

```
`{ fCoordinates.SetX(xx); return *this;}`

```         Change Y - Cartesian3D coordinates only

```
`{ fCoordinates.SetY(yy); return *this;}`

```         Change Z - Cartesian3D coordinates only

```
`{ fCoordinates.SetZ(zz); return *this;}`

```         Change R - Polar3D coordinates only

```
`{ fCoordinates.SetR(rr); return *this;}`

```         Change Theta - Polar3D coordinates only

```
`{ fCoordinates.SetTheta(ang); return *this;}`

```         Change Phi - Polar3D or CylindricalEta3D coordinates

```
`{ fCoordinates.SetPhi(ang); return *this;}`

```         Change Rho - CylindricalEta3D coordinates only

```
`{ fCoordinates.SetRho(rr); return *this;}`

```         Change Eta - CylindricalEta3D coordinates only

```
`{ fCoordinates.SetEta(etaval); return *this;}`

```         multiply this vector by a scalar quantity

```

```         divide this vector by a scalar quantity

```
return operator*( Scalar(-1) )

```         Division of a vector with a real number

```
Scalar x() const
``` Methods providing limited backward name compatibility with CLHEP
```
`{ return fCoordinates.X(); }`
Scalar y() const
`{ return fCoordinates.Y(); }`
Scalar z() const
`{ return fCoordinates.Z(); }`
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(); }`
DisplacementVector3D unit() const
`{return Unit();}`
DisplacementVector3D & operator=( const DisplacementVector3D<OtherCoords, OtherTag> & )
operator+( DisplacementVector3D<CoordSystem1,U> v1, const DisplacementVector3D<CoordSystem2,U> & v2)
``` ---------- DisplacementVector3D class template ends here ------------

Addition of DisplacementVector3D vectors.
The (coordinate system) type of the returned vector is defined to
be identical to that of the first vector, which is passed by value

```
operator-( DisplacementVector3D<CoordSystem1,U> v1, DisplacementVector3D<CoordSystem2,U> const & v2)
```        Difference between two DisplacementVector3D vectors.
The (coordinate system) type of the returned vector is defined to
be identical to that of the first vector.

```