Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <cstddef>
       7             : #include <vector>
       8             : 
       9             : #include "Domain/Structure/DirectionalId.hpp"
      10             : #include "Domain/Structure/ElementId.hpp"
      11             : #include "NumericalAlgorithms/Interpolation/IrregularInterpolant.hpp"
      12             : #include "NumericalAlgorithms/Spectral/Mesh.hpp"
      13             : 
      14             : /// \cond
      15             : template <size_t Dim>
      16             : class Domain;
      17             : class DataVector;
      18             : namespace gsl {
      19             : template <typename T>
      20             : class not_null;
      21             : }  // namespace gsl
      22             : /// \endcond
      23             : 
      24             : namespace dg {
      25             : /// \brief Interpolator to be used for interpolating boundary data from (to) a
      26             : /// Neighbor onto a mortar between nonconforming Blocks.
      27             : ///
      28             : /// \details This interpolator is designed to be used when multiple
      29             : /// nonconforming elements are neighbors with a single element (e.g deformed
      30             : /// cubes of a cubed sphere next to a single S2 spherical shell). Each of the
      31             : /// multiple elements (the hosts) should create this class to both interpolate
      32             : /// neighbor boundary data to the mortar of the host as well as interpolate the
      33             : /// host boundary data onto the subset of points of the mortar of the neighbor.
      34             : ///
      35             : /// \note For nonconforming neighbors, the block logical coordinates of
      36             : /// neighboring elements are not related by a discrete rotation (i.e. an
      37             : /// OrientationMap). Therefore boundary data cannot be copied or projected to a
      38             : /// neighbor, but must be interpolated.  As nonconforming neighbors cannot exist
      39             : /// in one dimension, this class is not instantiated for Dim = 1.
      40             : template <size_t Dim>
      41           1 : class MortarInterpolator {
      42             :  public:
      43             :   /// The Element with host_id is one of the multiple nonconforming Elements
      44             :   /// abutting the single Element with neighbor_id.  The host_mortar_mesh and
      45             :   /// neighbor_mortar_mesh are simply the appropriate face Mesh of the host and
      46             :   /// neighbor.
      47           1 :   MortarInterpolator(const ElementId<Dim>& host_id,
      48             :                      const DirectionalId<Dim>& neighbor_id,
      49             :                      const Domain<Dim>& domain,
      50             :                      const Mesh<Dim - 1>& host_mortar_mesh,
      51             :                      const Mesh<Dim - 1>& neighbor_mortar_mesh);
      52             : 
      53           0 :   MortarInterpolator() = default;
      54             : 
      55             :   /// @{
      56             :   /// \brief Interpolates the boundary data of the neighbor to the host mortar
      57             :   ///
      58             :   /// \details neighbor_data is a type-erased Variables so will have a size
      59             :   /// equal to the product of the number of components and the number of grid
      60             :   /// points of the neighbor_mortar_mesh.  The returned DataVector will have a
      61             :   /// size equal to the number of components and the number of grid points of
      62             :   /// the host_mortar_mesh.
      63           1 :   void interpolate_to_host(gsl::not_null<DataVector*> result,
      64             :                            const DataVector& neighbor_data) const;
      65           1 :   DataVector interpolate_to_host(const DataVector& neighbor_data) const;
      66             :   /// @}
      67             : 
      68             :   /// @{
      69             :   /// \brief Interpolates the boundary data of the host to a subset of the
      70             :   /// points of the neighbor mortar
      71             :   ///
      72             :   /// \details host_data is a type-erased Variables so will have a size
      73             :   /// equal to the product of the number of components and the number of grid
      74             :   /// points of the host_mortar_mesh.  The returned DataVector will have a
      75             :   /// size equal to the number of components and the number of grid points of
      76             :   /// the neighbor_mortar_mesh that the host is able to interpolate to.
      77           1 :   void interpolate_to_neighbor(gsl::not_null<DataVector*> result,
      78             :                                const DataVector& host_data) const;
      79           1 :   DataVector interpolate_to_neighbor(const DataVector& host_data) const;
      80             :   /// @}
      81             : 
      82             :   /// \brief The offsets of the data returned by interpolate_to_neighbor into
      83             :   /// the full data on the neighbor_mortar_mesh.
      84             :   ///
      85             :   /// \details  The DataVectors of type-erased Variables store data such that
      86             :   /// the grid point index varies fastest (as opposed to the component index).
      87             :   /// The size of the returned vector is equal to the number of grid points of
      88             :   /// the neighbor_mortar_mesh that the host is able to interpolate to, and the
      89             :   /// values of the returned vector map the grid point index of the partial
      90             :   /// DataVector returned by interpolate_to_neighbor to the grid point index of
      91             :   /// the full DataVector on the neighbor_mortar_mesh
      92           1 :   const std::vector<size_t>& interpolated_neighbor_data_offsets() const {
      93             :     return interpolated_neighbor_data_offsets_;
      94             :   }
      95             : 
      96             :   /// \brief The neighbor mortar mesh that is used to compute the target points
      97             :   /// and offsets when interpolating to the neighbor
      98           1 :   const Mesh<Dim - 1>& neighbor_mortar_mesh() const {
      99             :     return neighbor_mortar_mesh_;
     100             :   }
     101             : 
     102             :   /// \brief Updates the interpolator if either of the mortar Mesh change
     103           1 :   void reset_if_necessary(const Domain<Dim>& domain,
     104             :                           const Mesh<Dim - 1>& host_mortar_mesh,
     105             :                           const Mesh<Dim - 1>& neighbor_mortar_mesh);
     106             : 
     107             :   // NOLINTNEXTLINE(google-runtime-references)
     108           0 :   void pup(PUP::er& p);
     109             : 
     110             :  private:
     111             :   template <size_t LocalDim>
     112           0 :   friend bool operator==(const MortarInterpolator<LocalDim>& lhs,
     113             :                          const MortarInterpolator<LocalDim>& rhs);
     114             : 
     115           0 :   ElementId<Dim> host_id_{};
     116           0 :   DirectionalId<Dim> neighbor_id_{};
     117           0 :   Mesh<Dim - 1> host_mortar_mesh_{};
     118           0 :   Mesh<Dim - 1> neighbor_mortar_mesh_{};
     119           0 :   intrp::Irregular<Dim - 1> neighbor_to_host_interpolant_{};
     120           0 :   intrp::Irregular<Dim - 1> host_to_neighbor_interpolant_{};
     121           0 :   std::vector<size_t> interpolated_neighbor_data_offsets_{};
     122             : };
     123             : 
     124             : template <>
     125           0 : class MortarInterpolator<1> {
     126             :  public:  // NOLINTNEXTLINE(google-runtime-references)
     127           0 :   void pup(PUP::er& /*unused*/) {}
     128             : };
     129             : 
     130             : template <size_t Dim>
     131           0 : bool operator==(const MortarInterpolator<Dim>& lhs,
     132             :                 const MortarInterpolator<Dim>& rhs);
     133             : 
     134             : template <>
     135           0 : inline bool operator==(const MortarInterpolator<1>& /*unused*/,
     136             :                        const MortarInterpolator<1>& /*unused*/) {
     137             :   return true;
     138             : }
     139             : }  // namespace dg