Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <optional>
       7             : #include <set>
       8             : #include <sstream>
       9             : #include <string>
      10             : #include <type_traits>
      11             : 
      12             : #include "DataStructures/LinkedMessageId.hpp"
      13             : #include "DataStructures/Variables.hpp"
      14             : #include "Domain/Creators/Tags/Domain.hpp"
      15             : #include "Domain/FunctionsOfTime/Tags.hpp"
      16             : #include "Domain/Structure/ElementId.hpp"
      17             : #include "IO/Logging/Verbosity.hpp"
      18             : #include "Parallel/ArrayComponentId.hpp"
      19             : #include "Parallel/Callback.hpp"
      20             : #include "Parallel/GlobalCache.hpp"
      21             : #include "Parallel/Invoke.hpp"
      22             : #include "Parallel/ParallelComponentHelpers.hpp"
      23             : #include "Parallel/Printf/Printf.hpp"
      24             : #include "ParallelAlgorithms/ApparentHorizonFinder/HorizonAliases.hpp"
      25             : #include "ParallelAlgorithms/ApparentHorizonFinder/Storage.hpp"
      26             : #include "Utilities/ErrorHandling/Assert.hpp"
      27             : #include "Utilities/Gsl.hpp"
      28             : 
      29             : /// \cond
      30             : namespace ah {
      31             : template <class Metavariables, typename HorizonMetavars>
      32             : struct Component;
      33             : template <typename HorizonMetavars>
      34             : struct FindApparentHorizon;
      35             : }  // namespace ah
      36             : /// \endcond
      37             : 
      38             : namespace ah {
      39             : /*!
      40             :  * \brief Determines what the current time should be.
      41             :  *
      42             :  * \details If there's already a current time, or there are no pending times
      43             :  * available, then there's nothing to do. Otherwise, checks if the first pending
      44             :  * time is the next to use. If so, sets it as the current time and removes it
      45             :  * from pending.
      46             :  */
      47             : template <typename Fr>
      48           1 : void set_current_time(
      49             :     gsl::not_null<std::optional<LinkedMessageId<double>>*> current_time,
      50             :     gsl::not_null<std::set<LinkedMessageId<double>>*> pending_times,
      51             :     const std::set<LinkedMessageId<double>>& completed_times,
      52             :     const std::unordered_map<LinkedMessageId<double>,
      53             :                              ah::Storage::SingleTimeStorage<Fr>>& all_storage,
      54             :     const ::Verbosity& verbosity, const std::string& name);
      55             : 
      56             : /*!
      57             :  * \brief Checks if the current time is ready.
      58             :  *
      59             :  * \details If the current time is after any expiration time, registers a
      60             :  * callback for the `ah::FindApparentHorizon` action (but doesn't send the
      61             :  * volume variables again because we already did that). Returns if the current
      62             :  * time is ready or not.
      63             :  */
      64             : template <typename HorizonMetavars, typename Metavariables>
      65           1 : bool check_if_current_time_is_ready(
      66             :     const LinkedMessageId<double>& current_time,
      67             :     Parallel::GlobalCache<Metavariables>& cache,
      68             :     const LinkedMessageId<double>& incoming_time,
      69             :     const ElementId<3>& incoming_element_id, const ::Mesh<3>& incoming_mesh,
      70             :     const std::optional<std::string>& dependency) {
      71             :   const auto& domain = get<domain::Tags::Domain<3>>(cache);
      72             : 
      73             :   // Now we need to check the functions of time for the current time
      74             :   if constexpr (Parallel::is_in_global_cache<Metavariables,
      75             :                                              domain::Tags::FunctionsOfTime>) {
      76             :     if (domain.is_time_dependent()) {
      77             :       auto& this_proxy = Parallel::get_parallel_component<
      78             :           Component<Metavariables, HorizonMetavars>>(cache);
      79             :       double min_expiration_time = std::numeric_limits<double>::max();
      80             :       const Parallel::ArrayComponentId array_component_id =
      81             :           Parallel::make_array_component_id<
      82             :               Component<Metavariables, HorizonMetavars>>(0);
      83             :       // If the functions of time aren't ready, this will set a callback to
      84             :       // FindApparentHorizon that will be called by the GlobalCache when
      85             :       // domain::Tags::FunctionsOfTime is updated.
      86             :       return ::Parallel::mutable_cache_item_is_ready<
      87             :           domain::Tags::FunctionsOfTime>(
      88             :           cache, array_component_id,
      89             :           [&](const std::unordered_map<
      90             :               std::string,
      91             :               std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>>&
      92             :                   functions_of_time) -> std::unique_ptr<Parallel::Callback> {
      93             :             min_expiration_time =
      94             :                 std::min_element(functions_of_time.begin(),
      95             :                                  functions_of_time.end(),
      96             :                                  [](const auto& a, const auto& b) {
      97             :                                    return a.second->time_bounds()[1] <
      98             :                                           b.second->time_bounds()[1];
      99             :                                  })
     100             :                     ->second->time_bounds()[1];
     101             : 
     102             :             // Success: the current time is ok.
     103             :             // Failure: the current time is not ok.
     104             :             using horizon_frame = typename HorizonMetavars::frame;
     105             :             return current_time.id <= min_expiration_time
     106             :                        ? std::unique_ptr<Parallel::Callback>{}
     107             :                        : std::unique_ptr<Parallel::Callback>(
     108             :                              new Parallel::SimpleActionCallback<
     109             :                                  FindApparentHorizon<HorizonMetavars>,
     110             :                                  decltype(this_proxy), LinkedMessageId<double>,
     111             :                                  ElementId<3>, Mesh<3>,
     112             :                                  Variables<ah::vars_to_interpolate_to_target<
     113             :                                      3, horizon_frame>>,
     114             :                                  std::optional<std::string>, bool>(
     115             :                                  this_proxy, incoming_time, incoming_element_id,
     116             :                                  incoming_mesh,
     117             :                                  Variables<ah::vars_to_interpolate_to_target<
     118             :                                      3, horizon_frame>>{},
     119             :                                  dependency,
     120             :                                  /* vars_have_already_been_received */ true));
     121             :           });
     122             :     }  // if (domain.is_time_dependent())
     123             :   } else {
     124             :     if (domain.is_time_dependent()) {
     125             :       // We error here because the maps are time-dependent, yet
     126             :       // the cache does not contain FunctionsOfTime.  It would be
     127             :       // nice to make this a compile-time error; however, we want
     128             :       // the code to compile for the completely time-independent
     129             :       // case where there are no FunctionsOfTime in the cache at
     130             :       // all.  Unfortunately, checking whether the maps are
     131             :       // time-dependent is currently not constexpr.
     132             :       ERROR(
     133             :           "There is a time-dependent CoordinateMap in at least one "
     134             :           "of the Blocks, but FunctionsOfTime are not in the "
     135             :           "GlobalCache.  If you intend to use a time-dependent "
     136             :           "CoordinateMap, please add FunctionsOfTime to the GlobalCache.");
     137             :     }
     138             :   }
     139             : 
     140             :   // The current time is ready
     141             :   return true;
     142             : }
     143             : }  // namespace ah