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 <optional>
       8             : #include <tuple>
       9             : #include <utility>
      10             : 
      11             : #include "DataStructures/DataBox/DataBox.hpp"
      12             : #include "DataStructures/DataBox/MetavariablesTag.hpp"
      13             : #include "DataStructures/DataBox/PrefixHelpers.hpp"
      14             : #include "DataStructures/DataBox/Prefixes.hpp"
      15             : #include "DataStructures/TaggedTuple.hpp"
      16             : #include "DataStructures/Tensor/Tensor.hpp"
      17             : #include "DataStructures/Variables.hpp"
      18             : #include "Domain/Structure/ElementId.hpp"
      19             : #include "Domain/Tags.hpp"
      20             : #include "Parallel/AlgorithmExecution.hpp"
      21             : #include "Parallel/GlobalCache.hpp"
      22             : #include "ParallelAlgorithms/Amr/Protocols/Projector.hpp"
      23             : #include "ParallelAlgorithms/Initialization/MutateAssign.hpp"
      24             : #include "PointwiseFunctions/AnalyticSolutions/Tags.hpp"
      25             : #include "Utilities/CallWithDynamicType.hpp"
      26             : #include "Utilities/TMPL.hpp"
      27             : 
      28             : /// \cond
      29             : namespace Frame {
      30             : struct Inertial;
      31             : }  // namespace Frame
      32             : /// \endcond
      33             : 
      34           0 : namespace elliptic::Actions {
      35             : /// @{
      36             : /*!
      37             :  * \brief Place the analytic solution of the system fields in the DataBox.
      38             :  *
      39             :  * The `::Tags::AnalyticSolutions` tag retrieved from the DataBox will hold
      40             :  * a `std::optional`. The analytic solution is only evaluated and stored in the
      41             :  * DataBox if the `BackgroundTag` holds a type that inherits from the
      42             :  * `AnalyticSolutionType`.
      43             :  *
      44             :  * Uses:
      45             :  * - DataBox:
      46             :  *   - `AnalyticSolutionTag` or `BackgroundTag`
      47             :  *   - `domain::Tags::Mesh<Dim>`
      48             :  *   - `Tags::Coordinates<Dim, Frame::Inertial>`
      49             :  *   - `domain::Tags::InverseJacobian<Dim, Frame::ElementLogical,
      50             :  *     Frame::Inertial>`
      51             :  *
      52             :  * DataBox:
      53             :  * - Adds:
      54             :  *   - `::Tags::AnalyticSolutions<AnalyticSolutionFields>`
      55             :  */
      56             : template <size_t Dim, typename BackgroundTag, typename AnalyticSolutionFields,
      57             :           typename AnalyticSolutionType>
      58           1 : struct InitializeOptionalAnalyticSolution
      59             :     : tt::ConformsTo<::amr::protocols::Projector> {
      60             :  private:
      61           0 :   using analytic_fields_tag = ::Tags::AnalyticSolutions<AnalyticSolutionFields>;
      62             : 
      63             :  public:  // Iterable action
      64           0 :   using simple_tags = tmpl::list<analytic_fields_tag>;
      65           0 :   using compute_tags = tmpl::list<>;
      66           0 :   using const_global_cache_tags = tmpl::list<BackgroundTag>;
      67             : 
      68             :   template <typename DbTagsList, typename... InboxTags, typename Metavariables,
      69             :             typename ActionList, typename ParallelComponent>
      70           0 :   static Parallel::iterable_action_return_t apply(
      71             :       db::DataBox<DbTagsList>& box,
      72             :       const tuples::TaggedTuple<InboxTags...>& /*inboxes*/,
      73             :       const Parallel::GlobalCache<Metavariables>& /*cache*/,
      74             :       const ElementId<Dim>& /*array_index*/, const ActionList /*meta*/,
      75             :       const ParallelComponent* const /*meta*/) {
      76             :     db::mutate_apply<InitializeOptionalAnalyticSolution>(make_not_null(&box));
      77             :     return {Parallel::AlgorithmExecution::Continue, std::nullopt};
      78             :   }
      79             : 
      80             :  public:  // DataBox mutator, amr::protocols::Projector
      81           0 :   using return_tags = tmpl::list<analytic_fields_tag>;
      82           0 :   using argument_tags =
      83             :       tmpl::list<domain::Tags::Mesh<Dim>,
      84             :                  domain::Tags::Coordinates<Dim, Frame::Inertial>,
      85             :                  domain::Tags::InverseJacobian<Dim, Frame::ElementLogical,
      86             :                                                Frame::Inertial>,
      87             :                  BackgroundTag, Parallel::Tags::Metavariables>;
      88             : 
      89             :   template <typename Background, typename Metavariables, typename... AmrData>
      90           0 :   static void apply(
      91             :       const gsl::not_null<typename analytic_fields_tag::type*>
      92             :           analytic_solution_fields,
      93             :       const Mesh<Dim>& mesh, const tnsr::I<DataVector, Dim> inertial_coords,
      94             :       const InverseJacobian<DataVector, Dim, Frame::ElementLogical,
      95             :                             Frame::Inertial>& inv_jacobian,
      96             :       const Background& background, const Metavariables& /*meta*/,
      97             :       const AmrData&... amr_data) {
      98             :     if constexpr (sizeof...(AmrData) == 1) {
      99             :       if constexpr (std::is_same_v<AmrData...,
     100             :                                    std::pair<Mesh<Dim>, Element<Dim>>>) {
     101             :         if (((mesh == amr_data.first) and ...)) {
     102             :           // This element hasn't changed during AMR. Nothing to do.
     103             :           return;
     104             :         }
     105             :       }
     106             :     }
     107             : 
     108             :     const auto analytic_solution =
     109             :         dynamic_cast<const AnalyticSolutionType*>(&background);
     110             :     if (analytic_solution != nullptr) {
     111             :       using factory_classes = typename std::decay_t<
     112             :           Metavariables>::factory_creation::factory_classes;
     113             :       *analytic_solution_fields = call_with_dynamic_type<
     114             :           Variables<AnalyticSolutionFields>,
     115             :           tmpl::at<factory_classes, AnalyticSolutionType>>(
     116             :           analytic_solution,
     117             :           [&inertial_coords, &mesh, &inv_jacobian](const auto* const derived) {
     118             :             return variables_from_tagged_tuple(derived->variables(
     119             :                 inertial_coords, mesh, inv_jacobian, AnalyticSolutionFields{}));
     120             :           });
     121             :     } else {
     122             :       *analytic_solution_fields = std::nullopt;
     123             :     }
     124             :   }
     125             : };
     126             : /// @}
     127             : }  // namespace elliptic::Actions