Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines ScalarWave::Solutions::StandingWave
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <array>
      10             : #include <cstddef>
      11             : #include <memory>
      12             : 
      13             : #include "DataStructures/TaggedTuple.hpp"
      14             : #include "DataStructures/Tensor/TypeAliases.hpp"
      15             : #include "Options/String.hpp"
      16             : #include "PointwiseFunctions/AnalyticSolutions/AnalyticSolution.hpp"
      17             : #include "PointwiseFunctions/InitialDataUtilities/InitialData.hpp"
      18             : #include "Utilities/Serialization/CharmPupable.hpp"
      19             : #include "Utilities/TMPL.hpp"
      20             : 
      21             : /// \cond
      22             : class DataVector;
      23             : namespace ScalarWave::Tags {
      24             : struct Psi;
      25             : struct Pi;
      26             : template <size_t Dim, typename Frame>
      27             : struct Phi;
      28             : }  // namespace ScalarWave::Tags
      29             : namespace Tags {
      30             : template <typename Tag>
      31             : struct dt;
      32             : }  // namespace Tags
      33             : 
      34             : namespace PUP {
      35             : class er;
      36             : }  // namespace PUP
      37             : /// \endcond
      38             : 
      39             : namespace ScalarWave::Solutions {
      40             : /*!
      41             :  * \brief A standing wave solution to the Euclidean wave equation
      42             :  *
      43             :  * The solution is given by
      44             :  * \f$\Psi(\vec{x},t) = A \sin(\vec{k} \cdot (\vec{x} - \vec{x_0}))
      45             :  * \cos(\omega t)\f$
      46             :  * with the wave vector \f$\vec{k}\f$, frequency
      47             :  * \f$\omega = ||\vec{k}||\f$, amplitude \f$A\f$, and center
      48             :  * \f$\vec{x_0}\f$. The first-order variables follow the ScalarWave
      49             :  * conventions \f$\Pi = -\partial_t \Psi\f$ and \f$\Phi_i = \partial_i \Psi\f$.
      50             :  *
      51             :  * At \f$t = 0\f$ this gives \f$\Pi = 0\f$, meaning the initial data
      52             :  * decomposes into equal left-moving and right-moving components.
      53             :  *
      54             :  * \tparam Dim the spatial dimension of the solution
      55             :  */
      56             : template <size_t Dim>
      57           1 : class StandingWave : public evolution::initial_data::InitialData,
      58             :                      public MarkAsAnalyticSolution {
      59             :  public:
      60           0 :   static constexpr size_t volume_dim = Dim;
      61             : 
      62           0 :   struct WaveVector {
      63           0 :     using type = std::array<double, Dim>;
      64           0 :     static constexpr Options::String help = {
      65             :         "The wave vector of the standing wave."};
      66             :   };
      67             : 
      68           0 :   struct Center {
      69           0 :     using type = std::array<double, Dim>;
      70           0 :     static constexpr Options::String help = {
      71             :         "The center of the spatial profile."};
      72             :   };
      73             : 
      74           0 :   struct Amplitude {
      75           0 :     using type = double;
      76           0 :     static constexpr Options::String help = {
      77             :         "The amplitude of the standing wave."};
      78             :   };
      79             : 
      80           0 :   using options = tmpl::list<WaveVector, Center, Amplitude>;
      81             : 
      82           0 :   static constexpr Options::String help = {
      83             :       "A standing wave solution of the Euclidean wave equation. "
      84             :       "Psi = A sin(k.(x-x0)) cos(omega t), with omega = |k|. "
      85             :       "At t=0, Pi=0 so the wave has equal left- and right-moving components."};
      86             : 
      87           0 :   using tags = tmpl::list<Tags::Psi, Tags::Pi, Tags::Phi<Dim, Frame::Inertial>,
      88             :                           ::Tags::dt<Tags::Psi>, ::Tags::dt<Tags::Pi>,
      89             :                           ::Tags::dt<Tags::Phi<Dim, Frame::Inertial>>>;
      90             : 
      91           0 :   StandingWave() = default;
      92           0 :   StandingWave(std::array<double, Dim> wave_vector,
      93             :                std::array<double, Dim> center, double amplitude);
      94           0 :   StandingWave(const StandingWave&) = default;
      95           0 :   StandingWave& operator=(const StandingWave&) = default;
      96           0 :   StandingWave(StandingWave&&) = default;
      97           0 :   StandingWave& operator=(StandingWave&&) = default;
      98           0 :   ~StandingWave() override = default;
      99             : 
     100           0 :   auto get_clone() const
     101             :       -> std::unique_ptr<evolution::initial_data::InitialData> override;
     102             : 
     103             :   /// \cond
     104             :   explicit StandingWave(CkMigrateMessage* msg);
     105             :   using PUP::able::register_constructor;
     106             :   WRAPPED_PUPable_decl_template(StandingWave);
     107             :   /// \endcond
     108             : 
     109             :   /// Retrieve the evolution variables at time `t` and spatial coordinates `x`
     110             :   tuples::TaggedTuple<Tags::Psi, Tags::Pi, Tags::Phi<Dim, Frame::Inertial>>
     111           1 :   variables(const tnsr::I<DataVector, Dim>& x, double t,
     112             :             tmpl::list<Tags::Psi, Tags::Pi,
     113             :                        Tags::Phi<Dim, Frame::Inertial>> /*meta*/) const;
     114             : 
     115             :   /// Retrieve the time derivatives of the evolution variables
     116             :   tuples::TaggedTuple<::Tags::dt<Tags::Psi>, ::Tags::dt<Tags::Pi>,
     117             :                       ::Tags::dt<Tags::Phi<Dim, Frame::Inertial>>>
     118           1 :   variables(
     119             :       const tnsr::I<DataVector, Dim>& x, double t,
     120             :       tmpl::list<::Tags::dt<Tags::Psi>, ::Tags::dt<Tags::Pi>,
     121             :                  ::Tags::dt<Tags::Phi<Dim, Frame::Inertial>>> /*meta*/) const;
     122             : 
     123             :   // NOLINTNEXTLINE(google-runtime-references)
     124           0 :   void pup(PUP::er& p) override;
     125             : 
     126             :  private:
     127             :   template <size_t LocalDim>
     128             :   // NOLINTNEXTLINE(readability-redundant-declaration)
     129           0 :   friend bool operator==(const StandingWave<LocalDim>& lhs,
     130             :                          const StandingWave<LocalDim>& rhs);
     131             :   template <size_t LocalDim>
     132             :   // NOLINTNEXTLINE(readability-redundant-declaration)
     133           0 :   friend bool operator!=(const StandingWave<LocalDim>& lhs,
     134             :                          const StandingWave<LocalDim>& rhs);
     135             : 
     136           0 :   std::array<double, Dim> wave_vector_{};
     137           0 :   std::array<double, Dim> center_{};
     138           0 :   double amplitude_{};
     139           0 :   double omega_{};
     140             : };
     141             : }  // namespace ScalarWave::Solutions