Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines the class Identity.
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <array>
      10             : #include <cstddef>
      11             : #include <optional>
      12             : 
      13             : #include "DataStructures/Tensor/TypeAliases.hpp"
      14             : 
      15             : /// \cond
      16             : namespace PUP {
      17             : class er;
      18             : }  // namespace PUP
      19             : /// \endcond
      20             : 
      21             : namespace domain {
      22             : namespace CoordinateMaps {
      23             : 
      24             : /// \ingroup CoordinateMapsGroup
      25             : /// Identity  map from \f$\xi \rightarrow x\f$.
      26             : template <size_t Dim>
      27           1 : class Identity {
      28             :  public:
      29           0 :   static constexpr size_t dim = Dim;
      30             : 
      31           0 :   Identity() = default;
      32           0 :   ~Identity() = default;
      33           0 :   Identity(const Identity&) = default;
      34           0 :   Identity(Identity&&) = default;  // NOLINT
      35           0 :   Identity& operator=(const Identity&) = default;
      36           0 :   Identity& operator=(Identity&&) = default;
      37             : 
      38             :   template <typename T>
      39           0 :   std::array<T, Dim> operator()(const std::array<T, Dim>& source_coords) const;
      40             : 
      41             :   /// The inverse function is only callable with doubles because the inverse
      42             :   /// might fail if called for a point out of range, and it is unclear
      43             :   /// what should happen if the inverse were to succeed for some points in a
      44             :   /// DataVector but fail for other points.
      45           1 :   std::optional<std::array<double, Dim>> inverse(
      46             :       const std::array<double, Dim>& target_coords) const;
      47             : 
      48             :   template <typename T>
      49           0 :   tnsr::Ij<T, Dim, Frame::NoFrame> jacobian(
      50             :       const std::array<T, Dim>& source_coords) const;
      51             : 
      52             :   template <typename T>
      53           0 :   tnsr::Ij<T, Dim, Frame::NoFrame> inv_jacobian(
      54             :       const std::array<T, Dim>& source_coords) const;
      55             : 
      56             :   // NOLINTNEXTLINE(google-runtime-references)
      57           0 :   void pup(PUP::er& /*p*/) {}
      58             : 
      59           0 :   bool is_identity() const { return true; }
      60             : 
      61           0 :   static constexpr bool supports_hessian{true};
      62             : };
      63             : 
      64             : template <size_t Dim>
      65           0 : inline constexpr bool operator==(const CoordinateMaps::Identity<Dim>& /*lhs*/,
      66             :                                  const CoordinateMaps::Identity<Dim>& /*rhs*/) {
      67             :   return true;
      68             : }
      69             : 
      70             : template <size_t Dim>
      71           0 : inline constexpr bool operator!=(const CoordinateMaps::Identity<Dim>& lhs,
      72             :                                  const CoordinateMaps::Identity<Dim>& rhs) {
      73             :   return not(lhs == rhs);
      74             : }
      75             : }  // namespace CoordinateMaps
      76             : }  // namespace domain