CartesianVector.h

Go to the documentation of this file.

 
#ifndef PANDORA_CARTESIAN_VECTOR_H
#define PANDORA_CARTESIAN_VECTOR_H 1
 
#include "Pandora/StatusCodes.h"
 
#include <cmath>
#include <iostream>
#include <limits>
 
namespace pandora
{
 
class CartesianVector
{
public:
    CartesianVector(float x, float y, float z);
 
    CartesianVector(const CartesianVector &rhs);
 
    void SetValues(float x, float y, float z);
 
    float GetX() const;
 
    float GetY() const;
 
    float GetZ() const;
 
    float GetMagnitude() const;
 
    float GetMagnitudeSquared() const;
 
    float GetDotProduct(const CartesianVector &rhs) const;
 
    CartesianVector GetCrossProduct(const CartesianVector &rhs) const;
 
    float GetCosOpeningAngle(const CartesianVector &rhs) const;
 
    float GetOpeningAngle(const CartesianVector &rhs) const;
 
    float GetDistanceSquared(const CartesianVector &rhs) const;
 
    void GetSphericalCoordinates(float &radius, float &phi, float &theta) const;
 
    void GetCylindricalCoordinates(float &radius, float &phi, float &z) const;
 
    CartesianVector GetUnitVector() const;
 
    CartesianVector &operator=(const CartesianVector &rhs);
 
    CartesianVector &operator+=(const CartesianVector &rhs);
 
    CartesianVector &operator-=(const CartesianVector &rhs);
 
    CartesianVector &operator*=(const double scalar);
 
    bool operator==(const CartesianVector &rhs) const;
 
private:
    float   m_x;                
    float   m_y;                
    float   m_z;                
};
 
CartesianVector operator+(const CartesianVector &lhs, const CartesianVector &rhs);
 
CartesianVector operator-(const CartesianVector &lhs, const CartesianVector &rhs);
 
CartesianVector operator*(const CartesianVector &lhs, const double scalar);
 
std::ostream &operator<<(std::ostream & stream, const CartesianVector& cartesianVector);
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline CartesianVector::CartesianVector(float x, float y, float z) :
    m_x(x),
    m_y(y),
    m_z(z)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline CartesianVector::CartesianVector(const CartesianVector &rhs) :
    m_x(rhs.m_x),
    m_y(rhs.m_y),
    m_z(rhs.m_z)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline void CartesianVector::SetValues(float x, float y, float z)
{
    m_x = x;
    m_y = y;
    m_z = z;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CartesianVector::GetX() const
{
    return m_x;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CartesianVector::GetY() const
{
    return m_y;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CartesianVector::GetZ() const
{
    return m_z;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CartesianVector::GetMagnitude() const
{
    return std::sqrt(this->GetMagnitudeSquared());
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CartesianVector::GetMagnitudeSquared() const
{
    return ((m_x * m_x) + (m_y * m_y) + (m_z * m_z));
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CartesianVector::GetDotProduct(const CartesianVector &rhs) const
{
    return ((m_x * rhs.m_x) + (m_y * rhs.m_y) + (m_z * rhs.m_z));
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline CartesianVector CartesianVector::GetCrossProduct(const CartesianVector &rhs) const
{
    return CartesianVector( (m_y * rhs.m_z) - (rhs.m_y * m_z),
                            (m_z * rhs.m_x) - (rhs.m_z * m_x),
                            (m_x * rhs.m_y) - (rhs.m_x * m_y));
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CartesianVector::GetOpeningAngle(const CartesianVector &rhs) const
{
    return std::acos(this->GetCosOpeningAngle(rhs));
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CartesianVector::GetDistanceSquared(const CartesianVector &rhs) const
{
    return (  (m_x - rhs.m_x) * (m_x - rhs.m_x)
            + (m_y - rhs.m_y) * (m_y - rhs.m_y)
            + (m_z - rhs.m_z) * (m_z - rhs.m_z));
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline CartesianVector &CartesianVector::operator=(const CartesianVector &rhs)
{
    this->SetValues(rhs.m_x, rhs.m_y, rhs.m_z);
    return *this;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline CartesianVector &CartesianVector::operator+=(const CartesianVector &rhs)
{
    this->SetValues(m_x + rhs.m_x, m_y + rhs.m_y, m_z + rhs.m_z);
    return *this;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline CartesianVector &CartesianVector::operator-=(const CartesianVector &rhs)
{
    this->SetValues(m_x - rhs.m_x, m_y - rhs.m_y, m_z - rhs.m_z);
    return *this;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline CartesianVector &CartesianVector::operator*=(const double scalar)
{
    this->SetValues(static_cast<float>(m_x * scalar), static_cast<float>(m_y * scalar), static_cast<float>(m_z * scalar));
    return *this;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool CartesianVector::operator==(const CartesianVector &rhs) const
{
    return ( (std::fabs(m_x - rhs.m_x) < std::numeric_limits<float>::epsilon()) &&
        (std::fabs(m_y - rhs.m_y) < std::numeric_limits<float>::epsilon()) &&
        (std::fabs(m_z - rhs.m_z) < std::numeric_limits<float>::epsilon()) );
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline CartesianVector operator+(const CartesianVector &lhs, const CartesianVector &rhs)
{
    return CartesianVector(lhs.GetX() + rhs.GetX(), lhs.GetY() + rhs.GetY(), lhs.GetZ() + rhs.GetZ());
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline CartesianVector operator-(const CartesianVector &lhs, const CartesianVector &rhs)
{
    return CartesianVector(lhs.GetX() - rhs.GetX(), lhs.GetY() - rhs.GetY(), lhs.GetZ() - rhs.GetZ());
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline CartesianVector operator*(const CartesianVector &lhs, const double scalar)
{
    return CartesianVector(static_cast<float>(lhs.GetX() * scalar), static_cast<float>(lhs.GetY() * scalar), static_cast<float>(lhs.GetZ() * scalar));
}
 
} // namespace pandora
 
#endif // #ifndef PANDORA_CARTESIAN_VECTOR_H