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              : #include <limits>
       9              : #include <memory>
      10              : #include <utility>
      11              : 
      12              : #include "Utilities/Gsl.hpp"
      13              : 
      14              : /// \cond
      15              : template <size_t>
      16              : class Index;
      17              : /// \endcond
      18              : 
      19              : /*!
      20              :  * \ingroup DataStructuresGroup
      21              :  * \brief Iterate over a (dim-1)-dimensional slice
      22              :  */
      23            1 : class SliceIterator {
      24              :  public:
      25              :   /*!
      26              :    * @param extents the number of grid points in each dimension
      27              :    * @param fixed_dim the dimension to slice in
      28              :    * @param fixed_index the index of the `fixed_dim` to slice at
      29              :    */
      30              :   template <size_t Dim>
      31            1 :   SliceIterator(const Index<Dim>& extents, size_t fixed_dim,
      32              :                 size_t fixed_index);
      33              : 
      34              :   /// Returns `true` if the iterator is valid
      35            1 :   explicit operator bool() const { return volume_offset_ < size_; }
      36              : 
      37              :   /// Step to the next grid point
      38            1 :   SliceIterator& operator++();
      39              : 
      40              :   /// Offset into a Dim-dimensional DataVector at the current gridpoint.
      41              :   /// Note that the size of the DataVector is assumed to be the product of the
      42              :   /// extents used to construct this SliceIterator
      43            1 :   size_t volume_offset() const { return volume_offset_; }
      44              : 
      45              :   /// Offset into a (Dim-1)-dimensional DataVector at the current gridpoint.
      46              :   /// Note that the size of the DataVector is assumed to be the product of the
      47              :   /// extents used to construct this SliceIterator divided by the extent in
      48              :   /// the fixed_dim used to construct this SliceIterator
      49            1 :   size_t slice_offset() const { return slice_offset_; }
      50              : 
      51              :   /// Reset the iterator
      52            1 :   void reset();
      53              : 
      54              :  private:
      55            0 :   size_t size_ = std::numeric_limits<size_t>::max();
      56            0 :   size_t stride_ = std::numeric_limits<size_t>::max();
      57            0 :   size_t stride_count_ = std::numeric_limits<size_t>::max();
      58            0 :   size_t jump_ = std::numeric_limits<size_t>::max();
      59            0 :   size_t initial_offset_ = std::numeric_limits<size_t>::max();
      60            0 :   size_t volume_offset_ = std::numeric_limits<size_t>::max();
      61            0 :   size_t slice_offset_ = std::numeric_limits<size_t>::max();
      62              : };
      63              : 
      64              : /*!
      65              :  * \ingroup DataStructuresGroup
      66              :  * \brief Get the mapping between volume and boundary slice indices
      67              :  *
      68              :  * SliceIterator is used to map between the index of a point on a slice in the
      69              :  * volume data and the index in the corresponding sliced data. Repeatedly
      70              :  * applying the SliceIterator on various components of a tensor becomes very
      71              :  * expensive and so precomputing the index map is sometimes advantageous. This
      72              :  * function computes the index map onto all boundary slices of volume mesh with
      73              :  * extents `extents`.
      74              :  *
      75              :  * The `unique_ptr` is where the volume and slice indices are stored in memory,
      76              :  * the array holds views into the memory buffer. The index of the array is the
      77              :  * fixed dimension, the outer `pair` holds the indices for the lower and upper
      78              :  * side,  respectively, while the `pair`s in the `span`s hold the volume and
      79              :  * slice indices, respectively.
      80              :  */
      81              : template <size_t VolumeDim>
      82            1 : auto volume_and_slice_indices(const Index<VolumeDim>& extents)
      83              :     -> std::pair<std::unique_ptr<std::pair<size_t, size_t>[]>,
      84              :                  std::array<std::pair<gsl::span<std::pair<size_t, size_t>>,
      85              :                                       gsl::span<std::pair<size_t, size_t>>>,
      86              :                             VolumeDim>>;