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 <memory>
       8             : #include <string>
       9             : #include <type_traits>
      10             : #include <utility>
      11             : 
      12             : #include "DataStructures/TaggedTuple.hpp"
      13             : #include "DataStructures/Tensor/TypeAliases.hpp"
      14             : #include "Options/String.hpp"
      15             : #include "PointwiseFunctions/AnalyticSolutions/AnalyticSolution.hpp"
      16             : #include "PointwiseFunctions/InitialDataUtilities/InitialData.hpp"
      17             : #include "Utilities/PrettyType.hpp"
      18             : #include "Utilities/Serialization/CharmPupable.hpp"
      19             : #include "Utilities/TMPL.hpp"
      20             : 
      21             : /// \cond
      22             : class DataVector;
      23             : namespace SecondOrderScalarWave::Tags {
      24             : struct Psi;
      25             : struct Pi;
      26             : template <size_t Dim>
      27             : struct Phi;
      28             : }  // namespace SecondOrderScalarWave::Tags
      29             : namespace Tags {
      30             : template <typename Tag>
      31             : struct dt;
      32             : }  // namespace Tags
      33             : namespace PUP {
      34             : class er;
      35             : }  // namespace PUP
      36             : /// \endcond
      37             : 
      38             : namespace SecondOrderScalarWave::Solutions {
      39             : /*!
      40             :  * \brief Adapts a `ScalarWave` analytic solution to an analytic solution of
      41             :  * the `SecondOrderScalarWave` system.
      42             :  *
      43             :  * The wrapped `SolutionType` supplies the mathematics of the solution together
      44             :  * with its variables and their time derivatives in the `ScalarWave` tag
      45             :  * namespace. This adapter re-exposes those quantities through the
      46             :  * `SecondOrderScalarWave` tags, adding the three `variables` interfaces the
      47             :  * second-order-in-space system requires: the evolved and auxiliary variables
      48             :  * \f$\{\Psi, \Pi, \Phi_i\}\f$, the evolved variables \f$\{\Psi, \Pi\}\f$, and
      49             :  * the time derivatives of the evolved variables
      50             :  * \f$\{\partial_t\Psi, \partial_t\Pi\}\f$. In the second-order-in-space system
      51             :  * only \f$\Psi\f$ and \f$\Pi\f$ are evolved; \f$\Phi_i\f$ is auxiliary and is
      52             :  * not evolved, so \f$\partial_t\Phi_i\f$ from the wrapped solution is
      53             :  * discarded.
      54             :  *
      55             :  * The wrapped solution is held by composition, so only the second-order
      56             :  * interface below is public; the `ScalarWave` interface of `SolutionType` is
      57             :  * not exposed.
      58             :  *
      59             :  * \tparam SolutionType a `ScalarWave` analytic solution to adapt
      60             :  */
      61             : template <typename SolutionType>
      62           1 : class SecondOrderWrapper : public evolution::initial_data::InitialData,
      63             :                            public MarkAsAnalyticSolution {
      64             :  private:
      65             :   // Lifetime-safe backing storage for `help`, built on first use so it is
      66             :   // constructed before `help` reads it.
      67           0 :   static const std::string& help_storage() {
      68             :     static const std::string storage =
      69             :         "Adapts a ScalarWave analytic solution for SecondOrderScalarWave.\n" +
      70             :         std::string{SolutionType::help};
      71             :     return storage;
      72             :   }
      73             : 
      74             :  public:
      75           0 :   SecondOrderWrapper() = default;
      76           0 :   SecondOrderWrapper(const SecondOrderWrapper& /*rhs*/) = default;
      77           0 :   SecondOrderWrapper& operator=(const SecondOrderWrapper& /*rhs*/) = default;
      78           0 :   SecondOrderWrapper(SecondOrderWrapper&& /*rhs*/) = default;
      79           0 :   SecondOrderWrapper& operator=(SecondOrderWrapper&& /*rhs*/) = default;
      80           0 :   ~SecondOrderWrapper() override = default;
      81             : 
      82           0 :   explicit SecondOrderWrapper(SolutionType solution)
      83             :       : wrapped_solution_(std::move(solution)) {}
      84             : 
      85             :   template <typename... Args>
      86             :   requires std::is_constructible_v<SolutionType, Args&&...>
      87           0 :   explicit SecondOrderWrapper(Args&&... args)
      88             :       : wrapped_solution_(std::forward<Args>(args)...) {}
      89             : 
      90           0 :   auto get_clone() const
      91             :       -> std::unique_ptr<evolution::initial_data::InitialData> override;
      92             : 
      93             :   /// \cond
      94             :   explicit SecondOrderWrapper(CkMigrateMessage* msg);
      95             :   using PUP::able::register_constructor;
      96             :   WRAPPED_PUPable_decl_template(SecondOrderWrapper);
      97             :   /// \endcond
      98             : 
      99           0 :   static constexpr size_t volume_dim = SolutionType::volume_dim;
     100           0 :   using options = typename SolutionType::options;
     101           0 :   inline static Options::String help = help_storage().c_str();
     102           0 :   static std::string name() {
     103             :     return "SecondOrder" + pretty_type::name<SolutionType>();
     104             :   }
     105             : 
     106           0 :   using tags = tmpl::list<SecondOrderScalarWave::Tags::Psi,
     107             :                           SecondOrderScalarWave::Tags::Pi,
     108             :                           SecondOrderScalarWave::Tags::Phi<volume_dim>,
     109             :                           ::Tags::dt<SecondOrderScalarWave::Tags::Psi>,
     110             :                           ::Tags::dt<SecondOrderScalarWave::Tags::Pi>>;
     111             : 
     112             :   /// Retrieve the evolved and auxiliary variables (Psi, Pi, Phi) at time `t`
     113             :   /// and spatial coordinates `x`
     114             :   tuples::TaggedTuple<SecondOrderScalarWave::Tags::Psi,
     115             :                       SecondOrderScalarWave::Tags::Pi,
     116             :                       SecondOrderScalarWave::Tags::Phi<volume_dim>>
     117           1 :   variables(const tnsr::I<DataVector, volume_dim>& x, double t,
     118             :             tmpl::list<SecondOrderScalarWave::Tags::Psi,
     119             :                        SecondOrderScalarWave::Tags::Pi,
     120             :                        SecondOrderScalarWave::Tags::Phi<volume_dim>>
     121             :             /*meta*/) const;
     122             : 
     123             :   /// Retrieve the evolved variables (Psi, Pi)
     124             :   tuples::TaggedTuple<SecondOrderScalarWave::Tags::Psi,
     125             :                       SecondOrderScalarWave::Tags::Pi>
     126           1 :   variables(const tnsr::I<DataVector, volume_dim>& x, double t,
     127             :             tmpl::list<SecondOrderScalarWave::Tags::Psi,
     128             :                        SecondOrderScalarWave::Tags::Pi> /*meta*/) const;
     129             : 
     130             :   /// Retrieve the time derivatives of the evolved variables (dt(Psi), dt(Pi))
     131             :   /// at time `t` and spatial coordinates `x`
     132             :   tuples::TaggedTuple<::Tags::dt<SecondOrderScalarWave::Tags::Psi>,
     133             :                       ::Tags::dt<SecondOrderScalarWave::Tags::Pi>>
     134           1 :   variables(const tnsr::I<DataVector, volume_dim>& x, double t,
     135             :             tmpl::list<::Tags::dt<SecondOrderScalarWave::Tags::Psi>,
     136             :                        ::Tags::dt<SecondOrderScalarWave::Tags::Pi>>
     137             :             /*meta*/) const;
     138             : 
     139             :   // NOLINTNEXTLINE(google-runtime-references)
     140           0 :   void pup(PUP::er& p) override;
     141             : 
     142             :  private:
     143           0 :   friend bool operator==(const SecondOrderWrapper& lhs,
     144             :                          const SecondOrderWrapper& rhs) {
     145             :     return lhs.wrapped_solution_ == rhs.wrapped_solution_;
     146             :   }
     147           0 :   friend bool operator!=(const SecondOrderWrapper& lhs,
     148             :                          const SecondOrderWrapper& rhs) {
     149             :     return not(lhs == rhs);
     150             :   }
     151             : 
     152           0 :   SolutionType wrapped_solution_{};
     153             : };
     154             : }  // namespace SecondOrderScalarWave::Solutions