Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <deque>
       7             : 
       8             : #include "DataStructures/LinkedMessageId.hpp"
       9             : #include "Domain/FunctionsOfTime/FunctionOfTime.hpp"
      10             : #include "ParallelAlgorithms/ApparentHorizonFinder/Storage.hpp"
      11             : #include "Utilities/Gsl.hpp"
      12             : 
      13             : template <size_t VolumeDim>
      14             : class Domain;
      15             : class FastFlow;
      16             : namespace ylm {
      17             : template <typename Frame>
      18             : class Strahlkorper;
      19             : }  // namespace ylm
      20             : 
      21             : namespace ah {
      22             : /*!
      23             :  * \brief Compute the target points for the current iteration.
      24             :  *
      25             :  * \details Returns whether the computation of the target points was successful
      26             :  * or if there are some points outside the domain. If computation fails, one of
      27             :  * two attempts to recover will happen:
      28             :  *
      29             :  * - For the zeroth fast flow iteration, this will increase the $l=0,m=0$
      30             :  *   coefficient (i.e. the size) by 50%.
      31             :  * - For all other iterations, the coefficients become
      32             :  * \begin{equation}
      33             :  * S^{\mathrm{new}}_{lm} = \frac{1}{2}\left(S^{\mathrm{previous}}_{lm} +
      34             :  * S^{\mathrm{failed}}_{lm}\right)
      35             :  * \end{equation}
      36             :  *   where $S^{\mathrm{failed}}_{lm}$ are the coefficients of the failed
      37             :  *   computation and $S^{\mathrm{previous}}_{lm}$ are the coefficients from
      38             :  *   the previous successful iteration.
      39             :  *
      40             :  * This function will try recomputing the coords using the above two rules
      41             :  * \p max_compute_coords_retries times before returning false.
      42             :  *
      43             :  * \param current_iteration The returned pointer to the current Iteration object
      44             :  * \param block_order Priority order to search blocks for containing points
      45             :  * (see `::block_logical_coordinates` for details)
      46             :  * \param time The current time
      47             :  * \param fast_flow The FastFlow object for the current horizon find
      48             :  * \param initial_guess If the current iteration number is zero and
      49             :  * rerunning_with_higher_resolution == false, current_iteration is set to
      50             :  * this Strahlkorper
      51             :  * \param previous_iteration_surface If empty, current_iteration is set to
      52             :  * initial_guess; if one previous iteration, current_iteration is set to
      53             :  * that previous iteration; if two previous iterations, current_iteration
      54             :  * is set by linearly extrapolating in time the two pervious iterations;
      55             :  * if three or more previous iterations, current_iteration is set by
      56             :  * quadratic extrpolation of the three most recent iterations
      57             :  * \param previous_surfaces Previously successful iteratios used to attempt to
      58             :  * recover when some points are outside the domain.
      59             :  * \param max_compute_coords_retries Retry up to this many times before
      60             :  * returning false
      61             :  * \param domain The spatial domain in which the horizon is being found
      62             :  * \param functions_of_time The functions of time for the current domain
      63             :  * \param current_resolution_l Optional; if specified, current_iteration is
      64             :  * prolonged or restricted to this resolution
      65             :  * \param rerunning_with_higher_resolution Must be false unless
      66             :  * current_resolution_l is set; if true, then on iteration zero, set
      67             :  * the initial guess to the previous iteration surface
      68             :  * \returns Whether or not set_current_iteration_coords succeeded
      69             :  */
      70             : template <typename Fr>
      71           1 : bool set_current_iteration_coords(
      72             :     gsl::not_null<ah::Storage::Iteration<Fr>*> current_iteration,
      73             :     gsl::not_null<std::vector<size_t>*> block_order,
      74             :     const LinkedMessageId<double>& time, const FastFlow& fast_flow,
      75             :     const ylm::Strahlkorper<Fr>& initial_guess,
      76             :     const ylm::Strahlkorper<Fr>& previous_iteration_surface,
      77             :     const std::deque<ah::Storage::PreviousSurface<Fr>>& previous_surfaces,
      78             :     size_t max_compute_coords_retries, const Domain<3>& domain,
      79             :     const domain::FunctionsOfTimeMap& functions_of_time,
      80             :     const std::optional<size_t>& current_resolution_l = std::nullopt,
      81             :     bool rerunning_with_higher_resolution = false);
      82             : }  // namespace ah