Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <array>
       7             : #include <cstddef>
       8             : #include <optional>
       9             : 
      10             : #include "DataStructures/Tensor/TypeAliases.hpp"
      11             : 
      12             : /// \cond
      13             : namespace PUP {
      14             : class er;
      15             : }  // namespace PUP
      16             : /// \endcond
      17             : 
      18             : namespace domain::CoordinateMaps {
      19             : 
      20             : /*!
      21             :  * \ingroup CoordinateMapsGroup
      22             :  *
      23             :  * \brief Pfaffian transformation from spherical to Cartesian coordinates.
      24             :  *
      25             :  * \note This map is designed to be used together with Spherepack! Spherepack
      26             :  * expects a Pfaffian transformation of the derivatives.
      27             :  *
      28             :  * \details This is a Pfaffian mapping from \f$(r,\theta,\phi) \rightarrow
      29             :  * (x,y,z) \f$.
      30             :  *
      31             :  * The formula for the mapping is...
      32             :  * \f{eqnarray*}
      33             :  *     x &=& r \sin\theta \cos\phi \\
      34             :  *     y &=& r \sin\theta \sin\phi \\
      35             :  *     z &=& r \cos\theta
      36             :  * \f}
      37             :  *
      38             :  * The Pfaffian basis vectors
      39             :  * \f$ (e_{\hat r}, e_{\hat \theta}, e_{\hat \phi})\f$
      40             :  * are related to the coordinate basis vectors
      41             :  * \f$ (e_r, e_{\theta}, e_{\phi})\f$
      42             :  * by...
      43             :  * \f{eqnarray*}
      44             :  *     e_{\hat r}      &=& e_r \\
      45             :  *     e_{\hat \theta} &=& e_{\theta} \\
      46             :  *     e_{\hat \phi}   &=& \frac{1}{\sin \theta} e_{\phi}
      47             :  * \f}
      48             :  */
      49           1 : class SphericalToCartesianPfaffian {
      50             :  public:
      51           0 :   static constexpr size_t dim = 3;
      52           0 :   SphericalToCartesianPfaffian();
      53           0 :   ~SphericalToCartesianPfaffian() = default;
      54           0 :   SphericalToCartesianPfaffian(SphericalToCartesianPfaffian&&);
      55           0 :   SphericalToCartesianPfaffian(const SphericalToCartesianPfaffian&);
      56           0 :   SphericalToCartesianPfaffian& operator=(const SphericalToCartesianPfaffian&);
      57           0 :   SphericalToCartesianPfaffian& operator=(SphericalToCartesianPfaffian&&);
      58             : 
      59             :   template <typename T>
      60           0 :   std::array<T, 3> operator()(const std::array<T, 3>& source_coords) const;
      61             : 
      62             :   // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
      63           0 :   std::optional<std::array<double, 3>> inverse(
      64             :       const std::array<double, 3>& target_coords) const;
      65             : 
      66             :   template <typename T>
      67           0 :   tnsr::Ij<T, 3, Frame::NoFrame> jacobian(
      68             :       const std::array<T, 3>& source_coords) const;
      69             : 
      70             :   template <typename T>
      71           0 :   tnsr::Ij<T, 3, Frame::NoFrame> inv_jacobian(
      72             :       const std::array<T, 3>& source_coords) const;
      73             : 
      74             :   // NOLINTNEXTLINE(google-runtime-references)
      75           0 :   void pup(PUP::er& p);
      76             : 
      77           0 :   static constexpr bool is_identity() { return false; }
      78             : 
      79           0 :   static constexpr bool supports_hessian{false};
      80             : };
      81             : 
      82           0 : bool operator==(const SphericalToCartesianPfaffian& lhs,
      83             :                 const SphericalToCartesianPfaffian& rhs);
      84             : 
      85           0 : bool operator!=(const SphericalToCartesianPfaffian& lhs,
      86             :                 const SphericalToCartesianPfaffian& rhs);
      87             : }  // namespace domain::CoordinateMaps