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 <string>
       8             : 
       9             : #include "DataStructures/DataBox/Tag.hpp"
      10             : #include "NumericalAlgorithms/Convergence/Criteria.hpp"
      11             : #include "NumericalAlgorithms/Convergence/HasConverged.hpp"
      12             : #include "Options/String.hpp"
      13             : #include "Utilities/PrettyType.hpp"
      14             : 
      15             : namespace Convergence {
      16             : /// Option tags related to the convergence of iterative algorithms
      17           1 : namespace OptionTags {
      18             : 
      19             : template <typename OptionsGroup>
      20           0 : struct Criteria {
      21           0 :   static std::string name() { return "ConvergenceCriteria"; }
      22           0 :   static constexpr Options::String help =
      23             :       "Determine convergence of the algorithm";
      24           0 :   using type = Convergence::Criteria;
      25           0 :   using group = OptionsGroup;
      26             : };
      27             : 
      28             : template <typename OptionsGroup>
      29           0 : struct Iterations {
      30           0 :   static constexpr Options::String help =
      31             :       "Number of iterations to run the algorithm";
      32           0 :   using type = size_t;
      33           0 :   using group = OptionsGroup;
      34             : };
      35             : 
      36             : }  // namespace OptionTags
      37             : 
      38             : /// Tags related to the convergence of iterative algorithms
      39           1 : namespace Tags {
      40             : 
      41             : /// `Convergence::Criteria` that determine the iterative algorithm has converged
      42             : template <typename OptionsGroup>
      43           1 : struct Criteria : db::SimpleTag {
      44           0 :   static std::string name() {
      45             :     return "ConvergenceCriteria(" + pretty_type::name<OptionsGroup>() + ")";
      46             :   }
      47           0 :   using type = Convergence::Criteria;
      48             : 
      49           0 :   using option_tags = tmpl::list<OptionTags::Criteria<OptionsGroup>>;
      50           0 :   static constexpr bool pass_metavariables = false;
      51           0 :   static Convergence::Criteria create_from_options(
      52             :       const Convergence::Criteria& convergence_criteria) {
      53             :     return convergence_criteria;
      54             :   }
      55             : };
      56             : 
      57             : /// A fixed number of iterations to run the iterative algorithm
      58             : template <typename OptionsGroup>
      59           1 : struct Iterations : db::SimpleTag {
      60           0 :   static std::string name() {
      61             :     return "Iterations(" + pretty_type::name<OptionsGroup>() + ")";
      62             :   }
      63           0 :   using type = size_t;
      64             : 
      65           0 :   static constexpr bool pass_metavariables = false;
      66           0 :   using option_tags = tmpl::list<OptionTags::Iterations<OptionsGroup>>;
      67           0 :   static size_t create_from_options(const size_t max_iterations) {
      68             :     return max_iterations;
      69             :   }
      70             : };
      71             : 
      72             : /// Identifies a step in an iterative algorithm
      73             : template <typename Label>
      74           1 : struct IterationId : db::SimpleTag {
      75           0 :   static std::string name() {
      76             :     return "IterationId(" + pretty_type::name<Label>() + ")";
      77             :   }
      78           0 :   using type = size_t;
      79             : };
      80             : 
      81             : /*!
      82             :  * \brief Holds a `Convergence::HasConverged` flag that signals the iterative
      83             :  * algorithm has converged, along with the reason for convergence.
      84             :  */
      85             : template <typename Label>
      86           1 : struct HasConverged : db::SimpleTag {
      87           0 :   static std::string name() {
      88             :     return "HasConverged(" + pretty_type::name<Label>() + ")";
      89             :   }
      90           0 :   using type = Convergence::HasConverged;
      91             : };
      92             : 
      93             : }  // namespace Tags
      94             : }  // namespace Convergence