FourVector.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/Vector.hpp>
#include <type_traits>

namespace corsika {

  template <typename TTimeType, typename TSpaceVecType>
  class FourVector {

  public:
    using space_vec_type = typename std::decay<TSpaceVecType>::type;
    using space_type = typename space_vec_type::quantity_type;
    using time_type = typename std::decay<TTimeType>::type;

    // check the types and the physical units here:
    static_assert(std::is_same<time_type, space_type>::value ||
                      std::is_same<time_type, decltype(std::declval<space_type>() /
                                                       meter * second)>::value,
                  "Units of time-like and space-like coordinates must either be idential "
                  "(e.g. GeV) or [E/c]=[p]");

    using norm_type = space_type;
    using norm_square_type =
        decltype(std::declval<norm_type>() * std::declval<norm_type>());

  public:
    // resource management
    FourVector() = default;
    FourVector(FourVector&&) = default;
    FourVector(FourVector const&) = default;
    FourVector& operator=(const FourVector&) = default;
    ~FourVector() = default;

    FourVector(TTimeType const& eT, TSpaceVecType const& eS)
        : timeLike_(eT)
        , spaceLike_(eS) {}

    TTimeType getTimeLikeComponent() const;

    TSpaceVecType& getSpaceLikeComponents();

    TSpaceVecType const& getSpaceLikeComponents() const;

    norm_square_type getNormSqr() const;

    norm_type getNorm() const;

    bool isTimelike() const;
    bool isSpacelike() const;

    FourVector& operator+=(FourVector const&);
    FourVector& operator-=(FourVector const&);
    FourVector& operator*=(double const);
    FourVector& operator/=(double const);
    FourVector& operator/(double const);

    norm_type operator*(FourVector const& b);

  protected:
    // the data members
    TTimeType timeLike_;
    TSpaceVecType spaceLike_;

    friend FourVector<time_type, space_vec_type> operator+(FourVector const& a,
                                                           FourVector const& b) {
      return FourVector<time_type, space_vec_type>(a.timeLike_ + b.timeLike_,
                                                   a.spaceLike_ + b.spaceLike_);
    }

    friend FourVector<time_type, space_vec_type> operator-(FourVector const& a,
                                                           FourVector const& b) {
      return FourVector<time_type, space_vec_type>(a.timeLike_ - b.timeLike_,
                                                   a.spaceLike_ - b.spaceLike_);
    }

    friend FourVector<time_type, space_vec_type> operator*(FourVector const& a,
                                                           double const b) {
      return FourVector<time_type, space_vec_type>(a.timeLike_ * b, a.spaceLike_ * b);
    }

    friend FourVector<time_type, space_vec_type> operator/(FourVector const& a,
                                                           double const b) {
      return FourVector<time_type, space_vec_type>(a.timeLike_ / b, a.spaceLike_ / b);
    }

  private:
    norm_square_type getTimeSquared() const;
  };

  template <typename TTimeType, typename TSpaceVecType>
  std::ostream& operator<<(std::ostream& os,
                           corsika::FourVector<TTimeType, TSpaceVecType> const& qv);

} // namespace corsika

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