AxialVector.h

Go to the documentation of this file.

#ifndef _utl_AxialVector_h_
#define _utl_AxialVector_h_

#include <utl/BasicVector.h>
#include <utl/Vector.h>
#include <utl/CoordinateSystem.h>

#include <CLHEP/Geometry/Normal3D.h>

namespace utl {

  class Vector;


  class AxialVector : public AxialVectorBase {

  public:
    AxialVector() : AxialVectorBase() { }

    AxialVector(double x, double y, double z,
                const CoordinateSystemPtr& theCoordinateSystem)
      : AxialVectorBase(x, y, z, theCoordinateSystem) { }

    AxialVector(double p1, double p2, double p3,
                const CoordinateSystemPtr& theCoordinateSystem,
                const CoordinateType& theType)
      : AxialVectorBase(p1, p2, p3, theCoordinateSystem, theType) { }

    AxialVector(const Vector& a)
      : AxialVectorBase(a.fVector, a.fCoordinateSystem) { }

    //~AxialVector() { };

    operator Vector() const
    { return Vector(fVector, fCoordinateSystem); }

    double GetMag() const
    { return GetR(fCoordinateSystem); }

    double GetMag2() const
    { return GetR2(fCoordinateSystem); }

    void Normalize() { AxialVectorBase::Normalize(); }

    explicit operator bool() const { return fVector.x() || fVector.y() || fVector.z(); }

  private:
    AxialVector(const AxialVectorBase::DataType& theVector,
                const CoordinateSystemPtr& theCoordinateSystem)
      : AxialVectorBase(theVector, theCoordinateSystem) { }

    friend class TransformationPolicy;
    friend class Vector;
    friend AxialVector Cross(const Vector& l, const Vector& r);

  };


  inline
  AxialVector
  Normalized(const AxialVector& v)
  {
    AxialVector vv = v;
    vv.Normalize();
    return vv;
  }


}


#include <utl/OperationsAV.h>


#endif