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 <optional>
       8              : #include <unordered_set>
       9              : #include <utility>
      10              : 
      11              : #include "DataStructures/DataVector.hpp"
      12              : #include "DataStructures/Variables.hpp"
      13              : #include "Domain/Structure/Direction.hpp"
      14              : #include "Domain/Structure/DirectionalId.hpp"
      15              : #include "Domain/Structure/DirectionalIdMap.hpp"
      16              : #include "Domain/Structure/ElementId.hpp"
      17              : #include "NumericalAlgorithms/Interpolation/IrregularInterpolant.hpp"
      18              : #include "Utilities/Gsl.hpp"
      19              : 
      20              : /// \cond
      21              : template <size_t Dim>
      22              : class Direction;
      23              : template <size_t Dim, typename T>
      24              : class DirectionMap;
      25              : template <size_t Dim>
      26              : class Index;
      27              : /// \endcond
      28              : 
      29              : namespace evolution::dg::subcell {
      30              : namespace detail {
      31              : template <size_t Dim>
      32              : DirectionMap<Dim, DataVector> slice_data_impl(
      33              :     const gsl::span<const double>& volume_subcell_vars,
      34              :     const Index<Dim>& subcell_extents, size_t number_of_ghost_points,
      35              :     const std::unordered_set<Direction<Dim>>& directions_to_slice,
      36              :     size_t additional_buffer,
      37              :     const DirectionalIdMap<Dim, std::optional<intrp::Irregular<Dim>>>&
      38              :         fd_to_neighbor_fd_interpolants);
      39              : }  // namespace detail
      40              : 
      41              : /// @{
      42              : /*!
      43              :  * \brief Slice the subcell variables needed for neighbors to perform
      44              :  * reconstruction.
      45              :  *
      46              :  * Note that we slice to a grid that is against the boundary of the element but
      47              :  * is several ghost points deep. This is in contrast to the slicing used in the
      48              :  * DG method which is to the boundary of the element only.
      49              :  *
      50              :  * The `number_of_ghost_points` will depend on the number of neighboring points
      51              :  * the reconstruction method needs that is used on the subcell. The
      52              :  * `directions_to_slice` determines in which directions data is sliced.
      53              :  * Generally this will be the directions in which the element has neighbors.
      54              :  *
      55              :  * The data always has the same ordering as the volume data (tags have the same
      56              :  * ordering, grid points are x-varies-fastest).
      57              :  *
      58              :  * The `additional_buffer` argument is used to add extra padding to the result
      59              :  * storage to be used for example for sending the RDMP TCI data. This eliminates
      60              :  * expensive data copying.
      61              :  */
      62              : template <size_t Dim>
      63            1 : DirectionMap<Dim, DataVector> slice_data(
      64              :     const DataVector& volume_subcell_vars, const Index<Dim>& subcell_extents,
      65              :     const size_t number_of_ghost_points,
      66              :     const std::unordered_set<Direction<Dim>>& directions_to_slice,
      67              :     const size_t additional_buffer,
      68              :     const DirectionalIdMap<Dim, std::optional<intrp::Irregular<Dim>>>&
      69              :         fd_to_neighbor_fd_interpolants) {
      70              :   return detail::slice_data_impl(
      71              :       gsl::make_span(volume_subcell_vars.data(), volume_subcell_vars.size()),
      72              :       subcell_extents, number_of_ghost_points, directions_to_slice,
      73              :       additional_buffer, fd_to_neighbor_fd_interpolants);
      74              : }
      75              : 
      76              : template <size_t Dim, typename TagList>
      77            1 : DirectionMap<Dim, DataVector> slice_data(
      78              :     const Variables<TagList>& volume_subcell_vars,
      79              :     const Index<Dim>& subcell_extents, const size_t number_of_ghost_points,
      80              :     const std::unordered_set<Direction<Dim>>& directions_to_slice,
      81              :     const size_t additional_buffer,
      82              :     const DirectionalIdMap<Dim, std::optional<intrp::Irregular<Dim>>>&
      83              :         fd_to_neighbor_fd_interpolants) {
      84              :   // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
      85              :   const DataVector view{const_cast<double*>(volume_subcell_vars.data()),
      86              :                         volume_subcell_vars.size()};
      87              :   return slice_data(view, subcell_extents, number_of_ghost_points,
      88              :                     directions_to_slice, additional_buffer,
      89              :                     fd_to_neighbor_fd_interpolants);
      90              : }
      91              : /// @}
      92              : }  // namespace evolution::dg::subcell