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              : 
       9              : /// \cond
      10              : class DataVector;
      11              : template <size_t>
      12              : class Direction;
      13              : template <size_t>
      14              : class Element;
      15              : template <size_t>
      16              : class Mesh;
      17              : /// \endcond
      18              : 
      19              : namespace Limiters::Weno_detail {
      20              : 
      21              : // Check that an element has just one neighbor in a particular direction, and
      22              : // that this neighbor has the same refinement level as the element.
      23              : template <size_t VolumeDim>
      24              : bool check_element_has_one_similar_neighbor_in_direction(
      25              :     const Element<VolumeDim>& element, const Direction<VolumeDim>& direction);
      26              : 
      27              : // Compute the coordinate positions of a neighbor element's grid points in the
      28              : // logical coordinates of the local element.
      29              : //
      30              : // However, the results are organized to match the expected input of a
      31              : // RegularGridInterpolator constructor:
      32              : // - The coordinates are given as an array of 1D coordinate values.
      33              : // - For any dimension where the local and neighbor meshes share the same 1D
      34              : //   submesh, the array is empty. (This tells the RegularGridInterpolator that
      35              : //   no interpolation needs to be done in this dimension.)
      36              : //
      37              : // Limitations:
      38              : // - No support for h-refinement. It is ASSERT'ed that the element has only one
      39              : //   neighbor in the specified direction, and that this neighbor is of the same
      40              : //   refinement level as the local element.
      41              : // - Assumes a uniform rectilinear grid. No support for elements of different
      42              : //   sizes (as could occur if all elements have the same refinement level but
      43              : //   different blocks have different physical size), or curvilinear elements.
      44              : //   This is not checked.
      45              : template <size_t VolumeDim>
      46              : std::array<DataVector, VolumeDim> neighbor_grid_points_in_local_logical_coords(
      47              :     const Mesh<VolumeDim>& local_mesh, const Mesh<VolumeDim>& neighbor_mesh,
      48              :     const Element<VolumeDim>& element,
      49              :     const Direction<VolumeDim>& direction_to_neighbor);
      50              : 
      51              : // Compute the coordinate positions of the local element's grid points in the
      52              : // logical coordinates of the a neighbor element.
      53              : //
      54              : // See documentation of `neighbor_grid_points_in_local_logical_coords` for
      55              : // further details and limitations.
      56              : template <size_t VolumeDim>
      57              : std::array<DataVector, VolumeDim> local_grid_points_in_neighbor_logical_coords(
      58              :     const Mesh<VolumeDim>& local_mesh, const Mesh<VolumeDim>& neighbor_mesh,
      59              :     const Element<VolumeDim>& element,
      60              :     const Direction<VolumeDim>& direction_to_neighbor);
      61              : 
      62              : }  // namespace Limiters::Weno_detail