Vector.hpp

/*
 * (c) Copyright 2020 CORSIKA Project, corsika-project@lists.kit.edu
 *
 * This software is distributed under the terms of the GNU General Public
 * Licence version 3 (GPL Version 3). See file LICENSE for a full version of
 * the license.
 */

#pragma once

#include <corsika/framework/core/PhysicalUnits.hpp>
#include <corsika/framework/geometry/BaseVector.hpp>
#include <corsika/framework/geometry/QuantityVector.hpp>

namespace corsika {

  template <typename TDimension>
  class Vector : public BaseVector<TDimension> {
  public:
    using quantity_type = phys::units::quantity<TDimension, double>;
    using quantity_square_type =
        decltype(std::declval<quantity_type>() * std::declval<quantity_type>());

    Vector(CoordinateSystemPtr const& pCS, QuantityVector<TDimension> const& pQVector)
        : BaseVector<TDimension>(pCS, pQVector) {}

    Vector(CoordinateSystemPtr const& cs, quantity_type const x = quantity_type::zero(),
           quantity_type const y = quantity_type::zero(),
           quantity_type const z = quantity_type::zero())
        : BaseVector<TDimension>(cs, QuantityVector<TDimension>(x, y, z)) {}

    QuantityVector<TDimension> const& getComponents() const;
    QuantityVector<TDimension>& getComponents();

    QuantityVector<TDimension> getComponents(CoordinateSystemPtr const& pCS) const;

    QuantityVector<TDimension>& getComponents(CoordinateSystemPtr const& pCS);

    quantity_type getX(CoordinateSystemPtr const& pCS) const;
    quantity_type getY(CoordinateSystemPtr const& pCS) const;
    quantity_type getZ(CoordinateSystemPtr const& pCS) const;
    void rebase(CoordinateSystemPtr const& pCS);

    quantity_type getNorm() const;

    quantity_square_type getSquaredNorm() const;

    template <typename TDimension2>
    auto getParallelProjectionOnto(Vector<TDimension2> const& pVec,
                                   CoordinateSystemPtr const& pCS) const;
    template <typename TDimension2>
    auto getParallelProjectionOnto(Vector<TDimension2> const& pVec) const;

    Vector operator+(Vector<TDimension> const& pVec) const;

    Vector operator-(Vector<TDimension> const& pVec) const;

    auto& operator*=(double const p);

    template <typename TScalarDim>
    auto operator*(phys::units::quantity<TScalarDim, double> const p) const;
    template <typename TScalarDim>
    auto operator/(phys::units::quantity<TScalarDim, double> const p) const;

    auto operator*(double const p) const;

    auto operator/(double const p) const;

    auto& operator+=(Vector<TDimension> const& pVec);

    auto& operator-=(Vector<TDimension> const& pVec);

    auto operator-() const;

    auto normalized() const;

    template <typename TDimension2>
    auto cross(Vector<TDimension2> const& pV) const;

    template <typename TDimension2>
    auto dot(Vector<TDimension2> const& pV) const;
  };

  template <typename TDimension, typename UDimension>
  Vector<phys::units::detail::product_d<TDimension, UDimension>> operator*(
      quantity<UDimension> const n, Vector<TDimension> const& vec);

  template <typename TDimension>
  Vector<TDimension> operator*(double const n, Vector<TDimension> const& vec);

} // namespace corsika

#include <corsika/detail/framework/geometry/Vector.inl>