Line data    Source code

       1            1 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : /// \file
       5              : /// Defines class DomainCreator.
       6              : 
       7              : #pragma once
       8              : 
       9              : #include <array>
      10              : #include <cstddef>
      11              : #include <memory>
      12              : #include <string>
      13              : #include <unordered_map>
      14              : #include <unordered_set>
      15              : #include <vector>
      16              : 
      17              : #include "DataStructures/Tensor/Tensor.hpp"
      18              : #include "Domain/FunctionsOfTime/FunctionOfTime.hpp"
      19              : #include "Domain/Structure/DirectionMap.hpp"
      20              : 
      21              : /// \cond
      22              : namespace Frame {
      23              : struct Grid;
      24              : }  // namespace Frame
      25              : template <size_t>
      26              : class Domain;
      27              : namespace domain::BoundaryConditions {
      28              : class BoundaryCondition;
      29              : }
      30              : /// \endcond
      31              : 
      32              : namespace domain {
      33              : /// \ingroup ComputationalDomainGroup
      34              : /// \brief Defines classes that create Domains.
      35              : namespace creators {}
      36              : }  // namespace domain
      37              : 
      38              : /// \ingroup ComputationalDomainGroup
      39              : /// \brief Base class for creating Domains from an option string.
      40              : template <size_t VolumeDim>
      41            1 : class DomainCreator {
      42              :  public:
      43            0 :   static constexpr size_t volume_dim = VolumeDim;
      44              : 
      45            0 :   DomainCreator() = default;
      46            0 :   DomainCreator(const DomainCreator<VolumeDim>&) = delete;
      47            0 :   DomainCreator(DomainCreator<VolumeDim>&&) = default;
      48            0 :   DomainCreator<VolumeDim>& operator=(const DomainCreator<VolumeDim>&) = delete;
      49            0 :   DomainCreator<VolumeDim>& operator=(DomainCreator<VolumeDim>&&) = default;
      50            0 :   virtual ~DomainCreator() = default;
      51              : 
      52            0 :   virtual Domain<VolumeDim> create_domain() const = 0;
      53              : 
      54              :   /// A set of named coordinates in the grid frame, like the center of the
      55              :   /// domain or the positions of specific objects in a domain
      56              :   virtual std::unordered_map<std::string,
      57              :                              tnsr::I<double, VolumeDim, Frame::Grid>>
      58            1 :   grid_anchors() const {
      59              :     return {};
      60              :   }
      61              : 
      62              :   /// The set of external boundary condition for every block in the domain
      63              :   virtual std::vector<DirectionMap<
      64              :       VolumeDim,
      65              :       std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>>>
      66            1 :   external_boundary_conditions() const = 0;
      67              : 
      68              :   /// A human-readable name for every block, or empty if the domain creator
      69              :   /// doesn't support block names (yet).
      70            1 :   virtual std::vector<std::string> block_names() const { return {}; }
      71              : 
      72              :   /// Labels to refer to groups of blocks. The groups can overlap, and they
      73              :   /// don't have to cover all blocks in the domain. The groups can be used to
      74              :   /// refer to multiple blocks at once when specifying input-file options.
      75              :   virtual std::unordered_map<std::string, std::unordered_set<std::string>>
      76            1 :   block_groups() const {
      77              :     return {};
      78              :   }
      79              : 
      80              :   /// Obtain the initial grid extents of the Element%s in each block.
      81            1 :   virtual std::vector<std::array<size_t, VolumeDim>> initial_extents()
      82              :       const = 0;
      83              : 
      84              :   /// Obtain the initial refinement levels of the blocks.
      85            1 :   virtual std::vector<std::array<size_t, VolumeDim>> initial_refinement_levels()
      86              :       const = 0;
      87              : 
      88              :   /// Retrieve the functions of time used for moving meshes.
      89              :   // LCOV_EXCL_START
      90            1 :   virtual auto functions_of_time(const std::unordered_map<std::string, double>&
      91              :                                      initial_expiration_times = {}) const
      92              :       -> std::unordered_map<
      93              :           std::string,
      94              :           std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>> {
      95              :     (void)(initial_expiration_times);
      96              :     return {};
      97              :   }
      98              :   // LCOV_EXCL_STOP
      99              : };