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