SpECTRE Documentation Coverage Report
Current view: top level - Domain/Creators - ExpandOverBlocks.hpp Hit Total Coverage
Commit: 9a905b0737f373631c1b8e8389b8f26e67fa5313 Lines: 5 11 45.5 %
Date: 2024-03-28 09:03:18
Legend: Lines: hit not hit

          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 <string>
       9             : #include <unordered_map>
      10             : #include <unordered_set>
      11             : #include <vector>
      12             : 
      13             : #include "Utilities/MakeArray.hpp"
      14             : 
      15             : namespace domain {
      16             : 
      17             : namespace ExpandOverBlocks_detail {
      18             : template <typename T, typename U, typename = std::void_t<>>
      19             : struct is_value_type {
      20             :   static constexpr bool value = false;
      21             : };
      22             : 
      23             : template <typename T, typename U>
      24             : struct is_value_type<T, U, std::void_t<typename T::value_type>> {
      25             :   static constexpr bool value = std::is_same_v<U, typename T::value_type>;
      26             : };
      27             : }  // namespace ExpandOverBlocks_detail
      28             : 
      29             : /*!
      30             :  * \brief Produce a std::vector<T> over all blocks of the domain
      31             :  *
      32             :  * This class is useful to option-create values for e.g. the initial refinement
      33             :  * level or initial number of grid points for domain creators. It can be used
      34             :  * with `std::visit` and a `std::variant` with (a subset of) these types:
      35             :  *
      36             :  * - `T`: Repeat the given value over all blocks (homogeneous).
      37             :  * - `std::vector<T>`: Only check if the size matches the
      38             :  *   number of blocks, throwing a `std::length_error` if it doesn't.
      39             :  * - `std::unordered_map<std::string, T>`: Map block names, or
      40             :  *   names of block groups, to values. The map must cover all blocks once the
      41             :  *   groups are expanded. To use this option you must pass the list of block
      42             :  *   names and groups to the constructor.
      43             :  * - `T::value_type`: Repeat the given value over all blocks and dimensions
      44             :  *   (isotropic and homogeneous). Only works if `T` is a `std::array`. For
      45             :  *   example, if `T` is `std::array<size_t, 3>`, this will produce a
      46             :  *   `std::vector<std::array<size_t, 3>>` with the same value repeated
      47             :  *   `num_blocks x 3` times.
      48             :  *
      49             :  * If `T` is a `std::unique_ptr`, the class will clone the value for each block
      50             :  * using `T::get_clone()`.
      51             :  *
      52             :  * Note that the call-operators `throw` when they encounter errors, such as
      53             :  * mismatches in the number of blocks. The exceptions can be used to output
      54             :  * user-facing error messages in an option-parsing context.
      55             :  *
      56             :  * Here's an example for using this class:
      57             :  *
      58             :  * \snippet Test_ExpandOverBlocks.cpp expand_over_blocks_example
      59             :  *
      60             :  * Here's an example using block names and groups:
      61             :  *
      62             :  * \snippet Test_ExpandOverBlocks.cpp expand_over_blocks_named_example
      63             :  *
      64             :  * \tparam T The type distributed over the domain
      65             :  */
      66             : template <typename T>
      67           1 : struct ExpandOverBlocks {
      68           0 :   ExpandOverBlocks(size_t num_blocks);
      69           0 :   ExpandOverBlocks(
      70             :       std::vector<std::string> block_names,
      71             :       std::unordered_map<std::string, std::unordered_set<std::string>>
      72             :           block_groups = {});
      73             : 
      74             :   /// Repeat over all blocks (homogeneous)
      75           1 :   std::vector<T> operator()(const T& value) const;
      76             : 
      77             :   /// Only check if the size matches the number of blocks, throwing a
      78             :   /// `std::length_error` if it doesn't
      79           1 :   std::vector<T> operator()(const std::vector<T>& value) const;
      80             : 
      81             :   /// Map block names, or names of block groups, to values. The map must cover
      82             :   /// all blocks once the groups are expanded. To use this option you must pass
      83             :   /// the list of block names and groups to the constructor. Here's an example:
      84             :   ///
      85             :   /// \snippet Test_ExpandOverBlocks.cpp expand_over_blocks_named_example
      86           1 :   std::vector<T> operator()(
      87             :       const std::unordered_map<std::string, T>& value) const;
      88             : 
      89             :   /// Repeat over all blocks and dimensions (isotropic and homogeneous)
      90             :   template <
      91             :       typename U,
      92             :       Requires<ExpandOverBlocks_detail::is_value_type<T, U>::value> = nullptr>
      93           1 :   std::vector<T> operator()(const U& value) const {
      94             :     return {num_blocks_, make_array<std::tuple_size_v<T>>(value)};
      95             :   }
      96             : 
      97             :  private:
      98           0 :   size_t num_blocks_;
      99           0 :   std::vector<std::string> block_names_;
     100             :   std::unordered_map<std::string, std::unordered_set<std::string>>
     101           0 :       block_groups_;
     102             : };
     103             : 
     104             : }  // namespace domain

Generated by: LCOV version 1.14