Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <algorithm>
       7              : #include <cstddef>
       8              : #include <unordered_set>
       9              : 
      10              : #include "DataStructures/Index.hpp"
      11              : #include "DataStructures/Tensor/Tensor.hpp"
      12              : #include "Domain/Structure/Direction.hpp"
      13              : #include "Domain/Structure/DirectionMap.hpp"
      14              : #include "Domain/Structure/DirectionalId.hpp"
      15              : #include "Domain/Structure/DirectionalIdMap.hpp"
      16              : #include "Evolution/DgSubcell/SliceData.hpp"
      17              : #include "Utilities/ContainerHelpers.hpp"
      18              : #include "Utilities/Gsl.hpp"
      19              : 
      20              : namespace evolution::dg::subcell {
      21              : // template specialization for handling scalar (rank 0)
      22              : template <size_t Dim, typename VectorType>
      23            0 : void slice_tensor_for_subcell(
      24              :     const gsl::not_null<Tensor<VectorType, Symmetry<>, index_list<>>*>
      25              :         sliced_scalar,
      26              :     const Tensor<VectorType, Symmetry<>, index_list<>>& volume_scalar,
      27              :     const Index<Dim>& subcell_extents, size_t number_of_ghost_points,
      28              :     const Direction<Dim>& direction,
      29              :     const DirectionalIdMap<Dim, std::optional<intrp::Irregular<Dim>>>&
      30              :         fd_to_neighbor_fd_interpolants) {
      31              :   std::unordered_set directions_to_slice{direction};
      32              : 
      33              :   auto& scalar_dv = get(volume_scalar);
      34              :   auto sliced_data = evolution::dg::subcell::detail::slice_data_impl(
      35              :       gsl::make_span(scalar_dv.data(), scalar_dv.size()), subcell_extents,
      36              :       number_of_ghost_points, directions_to_slice, 0,
      37              :       fd_to_neighbor_fd_interpolants)[direction];
      38              : 
      39              :   std::copy(sliced_data.begin(), sliced_data.end(), get(*sliced_scalar).data());
      40              : }
      41              : 
      42              : /// @{
      43              : /*!
      44              :  * \brief Slice a single volume tensor for a given direction and slicing depth
      45              :  * (number of ghost points).
      46              :  *
      47              :  * Note that the second to last argument has the type `Direction<Dim>`, not a
      48              :  * DirectionMap (cf. `evolution::dg::subcell::slice_data`)
      49              :  *
      50              :  */
      51              : template <size_t Dim, typename VectorType, typename... Structure>
      52            1 : void slice_tensor_for_subcell(
      53              :     const gsl::not_null<Tensor<VectorType, Structure...>*> sliced_tensor,
      54              :     const Tensor<VectorType, Structure...>& volume_tensor,
      55              :     const Index<Dim>& subcell_extents, size_t number_of_ghost_points,
      56              :     const Direction<Dim>& direction,
      57              :     const DirectionalIdMap<Dim, std::optional<intrp::Irregular<Dim>>>&
      58              :         fd_to_neighbor_fd_interpolants) {
      59              :   std::unordered_set directions_to_slice{direction};
      60              : 
      61              :   for (size_t i = 0; i < volume_tensor.size(); i++) {
      62              :     auto& ti = volume_tensor[i];
      63              : 
      64              :     auto sliced_data = evolution::dg::subcell::detail::slice_data_impl(
      65              :         gsl::make_span(ti.data(), ti.size()), subcell_extents,
      66              :         number_of_ghost_points, directions_to_slice, 0,
      67              :         fd_to_neighbor_fd_interpolants)[direction];
      68              : 
      69              :     std::copy(sliced_data.begin(), sliced_data.end(),
      70              :               (*sliced_tensor)[i].data());
      71              :   }
      72              : }
      73              : 
      74              : template <size_t Dim, typename VectorType, typename... Structure>
      75            1 : Tensor<VectorType, Structure...> slice_tensor_for_subcell(
      76              :     const Tensor<VectorType, Structure...>& volume_tensor,
      77              :     const Index<Dim>& subcell_extents, size_t number_of_ghost_points,
      78              :     const Direction<Dim>& direction,
      79              :     const DirectionalIdMap<Dim, std::optional<intrp::Irregular<Dim>>>&
      80              :         fd_to_neighbor_fd_interpolants) {
      81              :   Tensor<VectorType, Structure...> sliced_tensor(
      82              :       subcell_extents.slice_away(direction.dimension()).product() *
      83              :       number_of_ghost_points);
      84              :   slice_tensor_for_subcell(make_not_null(&sliced_tensor), volume_tensor,
      85              :                            subcell_extents, number_of_ghost_points, direction,
      86              :                            fd_to_neighbor_fd_interpolants);
      87              :   return sliced_tensor;
      88              : }
      89              : /// @}
      90              : }  // namespace evolution::dg::subcell