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 <functional>
       8             : #include <optional>
       9             : #include <pup.h>
      10             : #include <pup_stl.h>
      11             : #include <random>
      12             : #include <string>
      13             : #include <tuple>
      14             : #include <utility>
      15             : 
      16             : #include "DataStructures/DataBox/DataBox.hpp"
      17             : #include "DataStructures/Variables.hpp"
      18             : #include "DataStructures/VariablesTag.hpp"
      19             : #include "Domain/Structure/ElementId.hpp"
      20             : #include "Options/Auto.hpp"
      21             : #include "Options/String.hpp"
      22             : #include "Parallel/AlgorithmExecution.hpp"
      23             : #include "Utilities/Gsl.hpp"
      24             : #include "Utilities/PrettyType.hpp"
      25             : #include "Utilities/Serialization/PupStlCpp17.hpp"
      26             : #include "Utilities/TMPL.hpp"
      27             : 
      28             : /// \cond
      29             : namespace Parallel {
      30             : template <typename Metavariables>
      31             : struct GlobalCache;
      32             : }  // namespace Parallel
      33             : namespace tuples {
      34             : template <typename... Tags>
      35             : struct TaggedTuple;
      36             : }  // namespace tuples
      37             : /// \endcond
      38             : 
      39             : namespace Actions {
      40             : 
      41             : /*!
      42             :  * \brief Optionally add random noise to the initial guess.
      43             :  *
      44             :  * Use this action to add random noise to variables. The random noise can be
      45             :  * toggled and is configurable with input-file options. Adding random noise to
      46             :  * fields can be useful to test the convergence and stability.
      47             :  */
      48             : template <typename VariablesTag, typename Label>
      49           1 : struct RandomizeVariables {
      50             :  public:
      51             :   // Bundle the options so they can be placed in Options::Auto
      52           0 :   struct RandomParameters {
      53           0 :     struct Amplitude {
      54           0 :       using type = double;
      55           0 :       static constexpr Options::String help = "Amplitude of the uniform noise.";
      56             :     };
      57           0 :     struct Seed {
      58           0 :       using type = Options::Auto<size_t>;
      59           0 :       static constexpr Options::String help =
      60             :           "Random seed for the noise generator.";
      61             :     };
      62           0 :     using options = tmpl::list<Amplitude, Seed>;
      63           0 :     static constexpr Options::String help = "Parameters for the uniform noise.";
      64           0 :     void pup(PUP::er& p) {
      65             :       p | amplitude;
      66             :       p | seed;
      67             :     }
      68           0 :     double amplitude;
      69           0 :     std::optional<size_t> seed;
      70             :   };
      71             : 
      72           0 :   struct RandomParametersOptionTag {
      73           0 :     static std::string name() { return pretty_type::name<Label>(); }
      74           0 :     using type = Options::Auto<RandomParameters, Options::AutoLabel::None>;
      75           0 :     static constexpr Options::String help =
      76             :         "Add uniform random noise to variables.";
      77             :   };
      78             : 
      79           0 :   struct RandomParametersTag : db::SimpleTag {
      80           0 :     using type = std::optional<RandomParameters>;
      81           0 :     using option_tags = tmpl::list<RandomParametersOptionTag>;
      82           0 :     static constexpr bool pass_metavariables = false;
      83           0 :     static type create_from_options(const type& value) { return value; }
      84             :   };
      85             : 
      86           0 :   using const_global_cache_tags = tmpl::list<RandomParametersTag>;
      87             : 
      88             :   template <typename DbTagsList, typename... InboxTags, typename Metavariables,
      89             :             size_t Dim, typename ActionList, typename ParallelComponent>
      90           0 :   static Parallel::iterable_action_return_t apply(
      91             :       db::DataBox<DbTagsList>& box,
      92             :       const tuples::TaggedTuple<InboxTags...>& /*inboxes*/,
      93             :       const Parallel::GlobalCache<Metavariables>& /*cache*/,
      94             :       const ElementId<Dim>& element_id, const ActionList /*meta*/,
      95             :       const ParallelComponent* const /*meta*/) {
      96             :     // Retrieve the options
      97             :     const std::optional<RandomParameters>& params =
      98             :         db::get<RandomParametersTag>(box);
      99             :     if (not params.has_value()) {
     100             :       return {Parallel::AlgorithmExecution::Continue, std::nullopt};
     101             :     }
     102             :     const auto& [amplitude, seed] = params.value();
     103             :     // Seed a random generator. Include the element ID in the seed so the data
     104             :     // is different on each element.
     105             :     std::seed_seq seeds{std::hash<ElementId<Dim>>{}(element_id),
     106             :                         seed.value_or(std::random_device{}())};
     107             :     std::mt19937 generator{seeds};
     108             :     // Set up the random distribution
     109             :     std::uniform_real_distribution<> dist(-amplitude, amplitude);
     110             :     // Add noise to the fields
     111             :     db::mutate<VariablesTag>(
     112             :         [&generator, &dist](const auto fields) {
     113             :           for (size_t i = 0; i < fields->size(); ++i) {
     114             :             fields->data()[i] += dist(generator);
     115             :           }
     116             :         },
     117             :         make_not_null(&box));
     118             :     return {Parallel::AlgorithmExecution::Continue, std::nullopt};
     119             :   }
     120             : };
     121             : 
     122             : }  // namespace Actions