Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <boost/range/combine.hpp>
       7             : #include <boost/tuple/tuple.hpp>
       8             : #include <cstddef>
       9             : #include <optional>
      10             : 
      11             : #include "DataStructures/Index.hpp"
      12             : #include "DataStructures/SliceIterator.hpp"
      13             : #include "DataStructures/Tensor/Tensor.hpp"
      14             : #include "Utilities/Gsl.hpp"
      15             : #include "Utilities/TMPL.hpp"
      16             : #include "Utilities/TypeTraits.hpp"
      17             : 
      18             : /// @{
      19             : /*!
      20             :  * \ingroup DataStructuresGroup
      21             :  * \brief Slices the data within `volume_tensor` to a codimension 1 slice. The
      22             :  * slice has a constant logical coordinate in direction `sliced_dim`,
      23             :  * slicing the volume at `fixed_index` in that dimension.  For
      24             :  * example, to get the lower boundary of `sliced_dim`, pass `0` for
      25             :  * `fixed_index`; to get the upper boundary, pass
      26             :  * `extents[sliced_dim] - 1`.
      27             :  *
      28             :  * \see add_slice_to_data
      29             :  *
      30             :  * Returns Tensor class sliced to a hypersurface.
      31             :  */
      32             : template <std::size_t VolumeDim, typename VectorType, typename... Structure>
      33           1 : void data_on_slice(
      34             :     const gsl::not_null<Tensor<VectorType, Structure...>*> interface_tensor,
      35             :     const Tensor<VectorType, Structure...>& volume_tensor,
      36             :     const Index<VolumeDim>& element_extents, const size_t sliced_dim,
      37             :     const size_t fixed_index) {
      38             :   const size_t interface_grid_points =
      39             :       element_extents.slice_away(sliced_dim).product();
      40             :   if (interface_tensor->begin()->size() != interface_grid_points) {
      41             :     *interface_tensor = Tensor<VectorType, Structure...>(interface_grid_points);
      42             :   }
      43             : 
      44             :   for (SliceIterator si(element_extents, sliced_dim, fixed_index); si; ++si) {
      45             :     for (decltype(auto) interface_and_volume_tensor_components :
      46             :          boost::combine(*interface_tensor, volume_tensor)) {
      47             :       boost::get<0>(interface_and_volume_tensor_components)[si.slice_offset()] =
      48             :           boost::get<1>(
      49             :               interface_and_volume_tensor_components)[si.volume_offset()];
      50             :     }
      51             :   }
      52             : }
      53             : 
      54             : template <std::size_t VolumeDim, typename VectorType, typename... Structure>
      55           1 : Tensor<VectorType, Structure...> data_on_slice(
      56             :     const Tensor<VectorType, Structure...>& volume_tensor,
      57             :     const Index<VolumeDim>& element_extents, const size_t sliced_dim,
      58             :     const size_t fixed_index) {
      59             :   Tensor<VectorType, Structure...> interface_tensor(
      60             :       element_extents.slice_away(sliced_dim).product());
      61             :   data_on_slice(make_not_null(&interface_tensor), volume_tensor,
      62             :                 element_extents, sliced_dim, fixed_index);
      63             :   return interface_tensor;
      64             : }
      65             : 
      66             : template <std::size_t VolumeDim, typename VectorType, typename... Structure>
      67           1 : void data_on_slice(
      68             :     const gsl::not_null<std::optional<Tensor<VectorType, Structure...>>*>
      69             :         interface_tensor,
      70             :     const std::optional<Tensor<VectorType, Structure...>>& volume_tensor,
      71             :     const Index<VolumeDim>& element_extents, const size_t sliced_dim,
      72             :     const size_t fixed_index) {
      73             :   if (volume_tensor.has_value()) {
      74             :     if (not(*interface_tensor)) {
      75             :       *interface_tensor = Tensor<VectorType, Structure...>{
      76             :           element_extents.slice_away(sliced_dim).product()};
      77             :     }
      78             :     data_on_slice(make_not_null(&**interface_tensor), *volume_tensor,
      79             :                   element_extents, sliced_dim, fixed_index);
      80             :   } else {
      81             :     *interface_tensor = std::nullopt;
      82             :   }
      83             : }
      84             : 
      85             : template <std::size_t VolumeDim, typename VectorType, typename... Structure>
      86           1 : std::optional<Tensor<VectorType, Structure...>> data_on_slice(
      87             :     const std::optional<Tensor<VectorType, Structure...>>& volume_tensor,
      88             :     const Index<VolumeDim>& element_extents, const size_t sliced_dim,
      89             :     const size_t fixed_index) {
      90             :   if (volume_tensor.has_value()) {
      91             :     Tensor<VectorType, Structure...> interface_tensor(
      92             :         element_extents.slice_away(sliced_dim).product());
      93             :     data_on_slice(make_not_null(&interface_tensor), *volume_tensor,
      94             :                   element_extents, sliced_dim, fixed_index);
      95             :     return interface_tensor;
      96             :   }
      97             :   return std::nullopt;
      98             : }
      99             : /// @}