Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <memory>
       7             : #include <string>
       8             : #include <type_traits>
       9             : #include <unordered_map>
      10             : 
      11             : #include "ControlSystem/ExpirationTimes.hpp"
      12             : #include "ControlSystem/Tags/IsActiveMap.hpp"
      13             : #include "ControlSystem/Tags/OptionTags.hpp"
      14             : #include "ControlSystem/Tags/SystemTags.hpp"
      15             : #include "DataStructures/DataBox/Tag.hpp"
      16             : #include "Domain/Creators/OptionTags.hpp"
      17             : #include "Domain/Creators/Tags/FunctionsOfTime.hpp"
      18             : #include "Domain/FunctionsOfTime/FunctionOfTime.hpp"
      19             : #include "Domain/FunctionsOfTime/Tags.hpp"
      20             : #include "Options/Auto.hpp"
      21             : #include "Time/OptionTags/InitialTime.hpp"
      22             : #include "Time/OptionTags/InitialTimeStep.hpp"
      23             : #include "Utilities/TMPL.hpp"
      24             : #include "Utilities/TypeTraits/IsA.hpp"
      25             : 
      26             : /// \cond
      27             : template <class Metavariables, typename ControlSystem>
      28             : struct ControlComponent;
      29             : /// \endcond
      30             : 
      31             : namespace control_system::Tags {
      32             : namespace detail {
      33             : // Check that all control systems are actually controlling a function of
      34             : // time, and that the expiration times have been set appropriately. If there
      35             : // exists a control system that isn't controlling a function of time, or the
      36             : // expiration times were set improperly, this is an error and we shouldn't
      37             : // continue.
      38             : void check_expiration_time_consistency(
      39             :     const std::unordered_map<std::string, double>& initial_expiration_times,
      40             :     const std::unordered_map<std::string, bool>& is_active_map,
      41             :     const std::unordered_map<
      42             :         std::string, std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>>&
      43             :         functions_of_time);
      44             : }  // namespace detail
      45             : 
      46             : /// \ingroup ControlSystemGroup
      47             : /// The FunctionsOfTime initialized from a DomainCreator, initial time, and
      48             : /// control system OptionHolders.
      49           1 : struct FunctionsOfTimeInitialize : domain::Tags::FunctionsOfTime {
      50           0 :   using base = domain::Tags::FunctionsOfTime;
      51             : 
      52           0 :   static constexpr bool pass_metavariables = true;
      53             : 
      54           0 :   static std::string name() { return "FunctionsOfTime"; }
      55             : 
      56             :   template <typename Metavariables>
      57           0 :   using option_holders = control_system::inputs<
      58             :       tmpl::transform<tmpl::filter<typename Metavariables::component_list,
      59             :                                    tt::is_a<ControlComponent, tmpl::_1>>,
      60             :                       tmpl::bind<tmpl::back, tmpl::_1>>>;
      61             : 
      62             :   template <typename Metavariables>
      63           0 :   static constexpr bool metavars_has_control_systems =
      64             :       tmpl::size<option_holders<Metavariables>>::value > 0;
      65             : 
      66             :   template <typename Metavariables>
      67           0 :   using option_tags = tmpl::push_front<
      68             :       tmpl::conditional_t<
      69             :           metavars_has_control_systems<Metavariables>,
      70             :           tmpl::flatten<tmpl::list<
      71             :               control_system::OptionTags::MeasurementsPerUpdate,
      72             :               control_system::OptionTags::DelayUpdate,
      73             :               ::OptionTags::InitialTime, option_holders<Metavariables>>>,
      74             :           tmpl::list<>>,
      75             :       domain::OptionTags::DomainCreator<Metavariables::volume_dim>>;
      76             : 
      77             :   /// @{
      78             :   /// This version of create_from_options is used if the metavariables did
      79             :   /// define control systems
      80             :   template <typename Metavariables, typename... OptionHolders>
      81           1 :   static type create_from_options(
      82             :       const std::unique_ptr<::DomainCreator<Metavariables::volume_dim>>&
      83             :           domain_creator,
      84             :       const int measurements_per_update, const bool delay_update,
      85             :       const double initial_time,
      86             :       const Options::Auto<OptionHolders,
      87             :                           Options::AutoLabel::None>&... option_holders) {
      88             :     return create_from_options<Metavariables>(
      89             :         domain_creator, measurements_per_update, delay_update, initial_time,
      90             :         static_cast<const std::optional<OptionHolders>&>(option_holders)...);
      91             :   }
      92             : 
      93             :   template <typename Metavariables, typename... OptionHolders>
      94           1 :   static type create_from_options(
      95             :       const std::unique_ptr<::DomainCreator<Metavariables::volume_dim>>&
      96             :           domain_creator,
      97             :       const int measurements_per_update, const bool delay_update,
      98             :       const double initial_time,
      99             :       const std::optional<OptionHolders>&... option_holders) {
     100             :     const auto initial_expiration_times =
     101             :         control_system::initial_expiration_times(
     102             :             initial_time, measurements_per_update, delay_update, domain_creator,
     103             :             option_holders...);
     104             : 
     105             :     // We need to check the expiration times so we can ensure a proper domain
     106             :     // creator was chosen from options.
     107             :     auto functions_of_time =
     108             :         domain_creator->functions_of_time(initial_expiration_times);
     109             : 
     110             :     const auto is_active_map = detail::create_is_active_map(option_holders...);
     111             : 
     112             :     detail::check_expiration_time_consistency(initial_expiration_times,
     113             :                                               is_active_map, functions_of_time);
     114             : 
     115             :     return functions_of_time;
     116             :   }
     117             :   /// @}
     118             : 
     119             :   /// This version of create_from_options is used if the metavariables did not
     120             :   /// define control systems
     121             :   template <typename Metavariables>
     122           1 :   static type create_from_options(
     123             :       const std::unique_ptr<::DomainCreator<Metavariables::volume_dim>>&
     124             :           domain_creator) {
     125             :     return domain_creator->functions_of_time();
     126             :   }
     127             : };
     128             : }  // namespace control_system::Tags