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 <memory>
       9              : #include <optional>
      10              : #include <string>
      11              : #include <variant>
      12              : 
      13              : #include "DataStructures/DataVector.hpp"
      14              : #include "Domain/Creators/TimeDependentOptions/FromVolumeFile.hpp"
      15              : #include "Domain/FunctionsOfTime/FunctionOfTime.hpp"
      16              : #include "Options/Auto.hpp"
      17              : #include "Options/Context.hpp"
      18              : #include "Options/Options.hpp"
      19              : #include "Options/String.hpp"
      20              : #include "Utilities/TMPL.hpp"
      21              : 
      22            0 : namespace domain::creators::time_dependent_options {
      23              : /*!
      24              :  * \brief Class that holds hard coded expansion map options from the input file.
      25              :  *
      26              :  * \details This class can also be used as an option tag with the \p type type
      27              :  * alias, `name()` function, and \p help string.
      28              :  */
      29              : template <bool AllowSettleFoTs>
      30            1 : struct ExpansionMapOptions {
      31            0 :   using type = Options::Auto<
      32              :       std::variant<ExpansionMapOptions<AllowSettleFoTs>, FromVolumeFile>,
      33              :       Options::AutoLabel::None>;
      34            0 :   static std::string name() { return "ExpansionMap"; }
      35            0 :   static constexpr Options::String help = {
      36              :       "Options for a time-dependent expansion of the coordinates. Specify "
      37              :       "'None' to not use this map."};
      38              : 
      39            0 :   struct InitialValues {
      40            0 :     using type = std::array<double, 3>;
      41            0 :     static constexpr Options::String help =
      42              :         "Initial values for the expansion map, its velocity and acceleration.";
      43              :   };
      44              : 
      45            0 :   struct InitialValuesOuterBoundary {
      46            0 :     using type = std::array<double, 3>;
      47            0 :     static constexpr Options::String help = {
      48              :         "Initial values for the expansion map, its velocity and acceleration "
      49              :         "at the outer boundary."};
      50              :   };
      51              : 
      52            0 :   struct DecayTimescaleOuterBoundary {
      53            0 :     using type = double;
      54            0 :     static constexpr Options::String help = {
      55              :         "A timescale for how fast the outer boundary expansion approaches its "
      56              :         "asymptotic value."};
      57              :   };
      58              : 
      59            0 :   struct DecayTimescale {
      60            0 :     using type = double;
      61            0 :     static constexpr Options::String help = {
      62              :         "A timescale for how fast the expansion approaches its asymptotic "
      63              :         "value with a SettleToConstant function of time."};
      64              :   };
      65              : 
      66            0 :   struct AsymptoticVelocityOuterBoundary {
      67            0 :     using type = double;
      68            0 :     static constexpr Options::String help = {
      69              :         "The constant velocity of the outer boundary expansion."};
      70              :   };
      71              : 
      72            0 :   using common_options = tmpl::list<InitialValues, DecayTimescaleOuterBoundary>;
      73            0 :   using settle_options =
      74              :       tmpl::push_back<common_options, InitialValuesOuterBoundary,
      75              :                       DecayTimescale>;
      76            0 :   using non_settle_options =
      77              :       tmpl::push_back<common_options, AsymptoticVelocityOuterBoundary>;
      78              : 
      79            0 :   using options = tmpl::conditional_t<
      80              :       AllowSettleFoTs,
      81              :       tmpl::list<Options::Alternatives<settle_options, non_settle_options>>,
      82              :       non_settle_options>;
      83              : 
      84            0 :   ExpansionMapOptions() = default;
      85              :   // Constructor for SettleToConstant functions of time
      86            0 :   ExpansionMapOptions(
      87              :       const std::array<double, 3>& initial_values_in,
      88              :       double decay_timescale_outer_boundary_in,
      89              :       const std::array<double, 3>& initial_values_outer_boundary_in,
      90              :       double decay_timescale_in, const Options::Context& context = {});
      91              :   // Constructor for non SettleToConstant functions of time
      92            0 :   ExpansionMapOptions(const std::array<double, 3>& initial_values_in,
      93              :                       double decay_timescale_outer_boundary_in,
      94              :                       double asymptotic_velocity_outer_boundary_in,
      95              :                       const Options::Context& context = {});
      96              : 
      97            0 :   std::array<DataVector, 3> initial_values{};
      98            0 :   std::array<DataVector, 3> initial_values_outer_boundary{};
      99            0 :   double decay_timescale_outer_boundary{};
     100            0 :   std::optional<double> decay_timescale;
     101            0 :   std::optional<double> asymptotic_velocity_outer_boundary;
     102              : };
     103              : 
     104              : /*!
     105              :  * \brief Helper functions that take the variant of the expansion map options,
     106              :  * and return the fully constructed expansion functions of time.
     107              :  *
     108              :  * \details The function of time will have a new \p initial_time and \p
     109              :  * expiration_time, unless it is read from a file and is replaying.
     110              :  */
     111              : template <bool AllowSettleFoTs>
     112            1 : FunctionsOfTimeMap get_expansion(
     113              :     const std::variant<ExpansionMapOptions<AllowSettleFoTs>, FromVolumeFile>&
     114              :         expansion_map_options,
     115              :     double initial_time, double expiration_time);
     116              : }  // namespace domain::creators::time_dependent_options