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 <memory>
       8              : #include <string>
       9              : #include <unordered_map>
      10              : #include <vector>
      11              : 
      12              : #include "Domain/CoordinateMaps/CoordinateMap.hpp"
      13              : #include "Domain/Creators/TimeDependence/TimeDependence.hpp"
      14              : #include "Options/String.hpp"
      15              : #include "Utilities/TMPL.hpp"
      16              : 
      17              : /// \cond
      18              : namespace domain::FunctionsOfTime {
      19              : class FunctionOfTime;
      20              : }  // namespace domain::FunctionsOfTime
      21              : 
      22              : namespace Frame {
      23              : struct Distorted;
      24              : struct Grid;
      25              : struct Inertial;
      26              : }  // namespace Frame
      27              : /// \endcond
      28              : 
      29              : namespace domain::creators::time_dependence {
      30              : /// \brief Make the mesh time independent so that it isn't moving.
      31              : ///
      32              : /// \warning Calling the `block_maps` functions causes an error because the
      33              : /// `None` class should be detected separately and optimizations applied so that
      34              : /// the coordinates, Jacobians, etc. are not recomputed.
      35              : template <size_t MeshDim>
      36            1 : class None final : public TimeDependence<MeshDim> {
      37              :  public:
      38            0 :   using maps_list = tmpl::list<>;
      39            0 :   using options = tmpl::list<>;
      40              : 
      41            0 :   static constexpr Options::String help = {
      42              :       "No time dependence in the in grid."};
      43              : 
      44            0 :   None() = default;
      45            0 :   ~None() override = default;
      46            0 :   None(const None&) = default;
      47            0 :   None(None&&) = default;
      48            0 :   None& operator=(const None&) = default;
      49            0 :   None& operator=(None&&) = default;
      50              : 
      51            1 :   auto get_clone() const -> std::unique_ptr<TimeDependence<MeshDim>> override;
      52              : 
      53            1 :   [[noreturn]] auto block_maps_grid_to_inertial(size_t number_of_blocks) const
      54              :       -> std::vector<std::unique_ptr<domain::CoordinateMapBase<
      55              :           Frame::Grid, Frame::Inertial, MeshDim>>> override;
      56              : 
      57            1 :   [[noreturn]] auto block_maps_grid_to_distorted(size_t number_of_blocks) const
      58              :       -> std::vector<std::unique_ptr<domain::CoordinateMapBase<
      59              :           Frame::Grid, Frame::Distorted, MeshDim>>> override;
      60              : 
      61            1 :   [[noreturn]] auto block_maps_distorted_to_inertial(size_t number_of_blocks)
      62              :       const -> std::vector<std::unique_ptr<domain::CoordinateMapBase<
      63              :           Frame::Distorted, Frame::Inertial, MeshDim>>> override;
      64              : 
      65            1 :   auto functions_of_time(const std::unordered_map<std::string, double>&
      66              :                              initial_expiration_times = {}) const
      67              :       -> std::unordered_map<
      68              :           std::string,
      69              :           std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>> override;
      70              : };
      71              : 
      72              : template <size_t Dim>
      73            0 : bool operator==(const None<Dim>& lhs, const None<Dim>& rhs);
      74              : 
      75              : template <size_t Dim>
      76            0 : bool operator!=(const None<Dim>& lhs, const None<Dim>& rhs);
      77              : }  // namespace domain::creators::time_dependence