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 <iosfwd>
       8              : #include <map>
       9              : #include <string>
      10              : #include <tuple>
      11              : #include <unordered_map>
      12              : 
      13              : #include "Utilities/TMPL.hpp"
      14              : 
      15              : /// \cond
      16              : template <size_t VolumeDim>
      17              : class ElementId;
      18              : namespace PUP {
      19              : class er;
      20              : }  // namespace PUP
      21              : /// \endcond
      22              : 
      23              : namespace evolution::dg {
      24              : /// Unique identifier for an equal-rate region.
      25              : ///
      26              : /// \see EqualRateRegions
      27            1 : struct EqualRateRegionId {
      28            0 :   size_t type;
      29            0 :   size_t label;
      30              : 
      31            0 :   EqualRateRegionId() = default;
      32            0 :   EqualRateRegionId(const size_t type_in, const size_t label_in)
      33              :       : type(type_in), label(label_in) {}
      34              : 
      35            0 :   void pup(PUP::er& p);
      36              : 
      37            0 :   friend auto operator<=>(const EqualRateRegionId&,
      38              :                           const EqualRateRegionId&) = default;
      39            0 :   friend bool operator==(const EqualRateRegionId&,
      40              :                          const EqualRateRegionId&) = default;
      41            0 :   friend bool operator<(const EqualRateRegionId&,
      42              :                         const EqualRateRegionId&) = default;
      43              : };
      44              : 
      45            0 : std::ostream& operator<<(std::ostream& os, const EqualRateRegionId& id);
      46              : 
      47              : namespace EqualRateRegions_detail {
      48              : template <typename T>
      49              : struct creation_tags {
      50              :   using type = typename T::creation_tags;
      51              : };
      52              : }  // namespace EqualRateRegions_detail
      53              : 
      54              : /// Regions of the domain that cannot perform local time-stepping.
      55              : ///
      56              : /// The \p RegionGenerators template argument must be a `tmpl::list`
      57              : /// of classes satisfying the `equal_rate_region_generator<Dim>`
      58              : /// concept.
      59              : template <
      60              :     size_t Dim, typename RegionGenerators,
      61              :     typename CreationTags = tmpl::join<tmpl::transform<
      62              :         RegionGenerators, EqualRateRegions_detail::creation_tags<tmpl::_1>>>>
      63            1 : class EqualRateRegions;
      64              : 
      65              : /// \copydoc EqualRateRegions
      66              : template <size_t Dim>
      67            1 : class EqualRateRegionsBase {
      68              :  protected:
      69            0 :   EqualRateRegionsBase() = default;
      70            0 :   EqualRateRegionsBase(const EqualRateRegionsBase&) = default;
      71            0 :   EqualRateRegionsBase(EqualRateRegionsBase&&) = default;
      72            0 :   EqualRateRegionsBase& operator=(const EqualRateRegionsBase&) = default;
      73            0 :   EqualRateRegionsBase& operator=(EqualRateRegionsBase&&) = default;
      74            0 :   ~EqualRateRegionsBase() = default;
      75              : 
      76              :  public:
      77              :   /// Map from all region names to ids.  Inverse of `region_names()`.
      78            1 :   virtual const std::unordered_map<std::string, EqualRateRegionId>& regions()
      79              :       const = 0;
      80              : 
      81              :   /// Map from all region ids to names.  Inverse of `regions()`.
      82            1 :   virtual const std::map<EqualRateRegionId, std::string>& region_names()
      83              :       const = 0;
      84              : 
      85              :   /// Check whether a particular element is in a given region.
      86            1 :   virtual bool is_in_region(const EqualRateRegionId& region,
      87              :                             const ElementId<Dim>& element) const = 0;
      88              : };
      89              : 
      90              : /// \copydoc EqualRateRegions
      91              : template <size_t Dim, typename... RegionGenerators, typename... CreationTags>
      92            1 : class EqualRateRegions<Dim, tmpl::list<RegionGenerators...>,
      93              :                        tmpl::list<CreationTags...>>
      94              :     final : public EqualRateRegionsBase<Dim> {
      95              :  public:
      96            0 :   explicit EqualRateRegions()
      97              :     requires(sizeof...(CreationTags) > 0)
      98              :   = default;
      99              : 
     100            0 :   using creation_tags = tmpl::list<CreationTags...>;
     101              : 
     102            0 :   explicit EqualRateRegions(const typename CreationTags::type&... args);
     103              : 
     104            1 :   const std::unordered_map<std::string, EqualRateRegionId>& regions()
     105              :       const override;
     106              : 
     107            1 :   const std::map<EqualRateRegionId, std::string>& region_names() const override;
     108              : 
     109            1 :   bool is_in_region(const EqualRateRegionId& region,
     110              :                     const ElementId<Dim>& element) const override;
     111              : 
     112            0 :   void pup(PUP::er& p);
     113              : 
     114              :  private:
     115            0 :   std::tuple<RegionGenerators...> generators_{};
     116            0 :   std::unordered_map<std::string, EqualRateRegionId> regions_{};
     117            0 :   std::map<EqualRateRegionId, std::string> region_names_{};
     118              : };
     119              : }  // namespace evolution::dg