Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <memory>
       7              : 
       8              : #include "DataStructures/TaggedTuple.hpp"
       9              : #include "DataStructures/Tensor/TypeAliases.hpp"
      10              : #include "Evolution/Systems/ForceFree/Tags.hpp"
      11              : #include "Options/String.hpp"
      12              : #include "PointwiseFunctions/AnalyticSolutions/AnalyticSolution.hpp"
      13              : #include "PointwiseFunctions/AnalyticSolutions/GeneralRelativity/Minkowski.hpp"
      14              : #include "PointwiseFunctions/InitialDataUtilities/InitialData.hpp"
      15              : #include "Utilities/Serialization/CharmPupable.hpp"
      16              : #include "Utilities/TMPL.hpp"
      17              : 
      18              : /// \cond
      19              : class DataVector;
      20              : 
      21              : namespace PUP {
      22              : class er;
      23              : }  // namespace PUP
      24              : /// \endcond
      25              : 
      26              : namespace ForceFree::Solutions {
      27              : 
      28              : /*!
      29              :  * \brief An electromagnetic wave propagating into \f$+x\f$ direction in flat
      30              :  * spacetime.
      31              :  *
      32              :  * The initial data is given by \cite Komissarov2002
      33              :  *
      34              :  * \f{align*}{
      35              :  *  B^x & = 1.0 , \\
      36              :  *  B^y & = \left\{\begin{array}{ll}
      37              :  *  1.0          & \text{if } x < -0.1 \\
      38              :  *  -1.5x + 0.85 & \text{if } -0.1 \leq x \leq 0.1 \\
      39              :  *  0.7          & \text{if } x > 0.1 \\
      40              :  * \end{array}\right\}, \\
      41              :  *  B^z & = 0 , \\
      42              :  *  E^x & = E^y = 0 , \\
      43              :  *  E^z & = -B^y .
      44              :  * \f}
      45              :  *
      46              :  * The electric and magnetic fields are advected to \f$+x\f$ direction with the
      47              :  * speed of light (\f$\lambda=+1\f$), and the solution at \f$(\vec{x},t)\f$ is
      48              :  *
      49              :  * \f{align*}{
      50              :  *  E^i(x,y,z,t) & = E^i(x-t,y,z,0) , \\
      51              :  *  B^i(x,y,z,t) & = B^i(x-t,y,z,0) .
      52              :  * \f}
      53              :  *
      54              :  * Electric charge density \f$q\f$ is zero everywhere.
      55              :  *
      56              :  */
      57            1 : class FastWave : public evolution::initial_data::InitialData,
      58              :                  public MarkAsAnalyticSolution {
      59              :  public:
      60            0 :   using options = tmpl::list<>;
      61            0 :   static constexpr Options::String help{
      62              :       "A fast mode wave propagating +x direction in flat spacetime"};
      63              : 
      64            0 :   FastWave() = default;
      65            0 :   FastWave(const FastWave&) = default;
      66            0 :   FastWave& operator=(const FastWave&) = default;
      67            0 :   FastWave(FastWave&&) = default;
      68            0 :   FastWave& operator=(FastWave&&) = default;
      69            0 :   ~FastWave() override = default;
      70              : 
      71            0 :   auto get_clone() const
      72              :       -> std::unique_ptr<evolution::initial_data::InitialData> override;
      73              : 
      74              :   /// \cond
      75              :   explicit FastWave(CkMigrateMessage* msg);
      76              :   using PUP::able::register_constructor;
      77              :   WRAPPED_PUPable_decl_template(FastWave);
      78              :   /// \endcond
      79              : 
      80              :   // NOLINTNEXTLINE(google-runtime-references)
      81            0 :   void pup(PUP::er& p) override;
      82              : 
      83              :   /// @{
      84              :   /// Retrieve the EM variables at (x,t).
      85            1 :   static auto variables(const tnsr::I<DataVector, 3>& x, double t,
      86              :                         tmpl::list<Tags::TildeE> /*meta*/)
      87              :       -> tuples::TaggedTuple<Tags::TildeE>;
      88              : 
      89            1 :   static auto variables(const tnsr::I<DataVector, 3>& x, double t,
      90              :                         tmpl::list<Tags::TildeB> /*meta*/)
      91              :       -> tuples::TaggedTuple<Tags::TildeB>;
      92              : 
      93            1 :   static auto variables(const tnsr::I<DataVector, 3>& x, double t,
      94              :                         tmpl::list<Tags::TildePsi> /*meta*/)
      95              :       -> tuples::TaggedTuple<Tags::TildePsi>;
      96              : 
      97            1 :   static auto variables(const tnsr::I<DataVector, 3>& x, double t,
      98              :                         tmpl::list<Tags::TildePhi> /*meta*/)
      99              :       -> tuples::TaggedTuple<Tags::TildePhi>;
     100              : 
     101            1 :   static auto variables(const tnsr::I<DataVector, 3>& x, double t,
     102              :                         tmpl::list<Tags::TildeQ> /*meta*/)
     103              :       -> tuples::TaggedTuple<Tags::TildeQ>;
     104              :   /// @}
     105              : 
     106              :   /// Retrieve a collection of EM variables at `(x, t)`
     107              :   template <typename... Tags>
     108            1 :   tuples::TaggedTuple<Tags...> variables(const tnsr::I<DataVector, 3>& x,
     109              :                                          const double t,
     110              :                                          tmpl::list<Tags...> /*meta*/) const {
     111              :     static_assert(sizeof...(Tags) > 1,
     112              :                   "The generic template will recurse infinitely if only one "
     113              :                   "tag is being retrieved.");
     114              :     return {get<Tags>(variables(x, t, tmpl::list<Tags>{}))...};
     115              :   }
     116              : 
     117              :   /// Retrieve the metric variables
     118              :   template <typename Tag>
     119            1 :   tuples::TaggedTuple<Tag> variables(const tnsr::I<DataVector, 3>& x, double t,
     120              :                                      tmpl::list<Tag> /*meta*/) const {
     121              :     return background_spacetime_.variables(x, t, tmpl::list<Tag>{});
     122              :   }
     123              : 
     124              :  private:
     125              :   // Computes the initial profile
     126            0 :   static DataVector initial_profile(const DataVector& coords);
     127            0 :   gr::Solutions::Minkowski<3> background_spacetime_{};
     128              : 
     129            0 :   friend bool operator==(const FastWave& lhs, const FastWave& rhs);
     130            0 :   friend bool operator!=(const FastWave& lhs, const FastWave& rhs);
     131              : };
     132              : 
     133              : }  // namespace ForceFree::Solutions