Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <pup.h>
       7              : 
       8              : #include "DataStructures/TaggedTuple.hpp"
       9              : #include "DataStructures/Tensor/TypeAliases.hpp"
      10              : #include "Options/String.hpp"
      11              : #include "PointwiseFunctions/AnalyticSolutions/AnalyticSolution.hpp"
      12              : #include "PointwiseFunctions/AnalyticSolutions/GeneralRelativity/Minkowski.hpp"
      13              : #include "PointwiseFunctions/AnalyticSolutions/GrMhd/Solutions.hpp"
      14              : #include "PointwiseFunctions/AnalyticSolutions/RelativisticEuler/SmoothFlow.hpp"
      15              : #include "PointwiseFunctions/Hydro/TagsDeclarations.hpp"
      16              : #include "Utilities/Serialization/CharmPupable.hpp"
      17              : #include "Utilities/TMPL.hpp"
      18              : 
      19              : namespace grmhd::Solutions {
      20              : 
      21              : /*!
      22              :  * \brief Periodic GrMhd solution in Minkowski spacetime.
      23              :  *
      24              :  * An analytic solution to the 3-D GrMhd system. The user specifies the mean
      25              :  * flow velocity of the fluid, the wavevector of the density profile, and the
      26              :  * amplitude \f$A\f$ of the density profile. The magnetic field is taken to be
      27              :  * zero everywhere. In Cartesian coordinates \f$(x, y, z)\f$, and using
      28              :  * dimensionless units, the primitive quantities at a given time \f$t\f$ are
      29              :  * then
      30              :  *
      31              :  * \f{align*}
      32              :  * \rho(\vec{x},t) &= 1 + A \sin(\vec{k}\cdot(\vec{x} - \vec{v}t)) \\
      33              :  * \vec{v}(\vec{x},t) &= [v_x, v_y, v_z]^{T},\\
      34              :  * P(\vec{x},t) &= P, \\
      35              :  * \epsilon(\vec{x}, t) &= \frac{P}{(\gamma - 1)\rho}\\
      36              :  * \vec{B}(\vec{x},t) &= [0, 0, 0]^{T}
      37              :  * \f}
      38              :  */
      39            1 : class SmoothFlow : virtual public MarkAsAnalyticSolution,
      40              :                    public RelativisticEuler::Solutions::SmoothFlow<3> {
      41            0 :   using smooth_flow = RelativisticEuler::Solutions::SmoothFlow<3>;
      42              : 
      43              :  public:
      44            0 :   using options = smooth_flow::options;
      45              : 
      46            0 :   static constexpr Options::String help = {
      47              :       "Periodic smooth flow in Minkowski spacetime with zero magnetic field."};
      48              : 
      49            0 :   SmoothFlow() = default;
      50            0 :   SmoothFlow(const SmoothFlow& /*rhs*/) = default;
      51            0 :   SmoothFlow& operator=(const SmoothFlow& /*rhs*/) = default;
      52            0 :   SmoothFlow(SmoothFlow&& /*rhs*/) = default;
      53            0 :   SmoothFlow& operator=(SmoothFlow&& /*rhs*/) = default;
      54            0 :   ~SmoothFlow() override = default;
      55              : 
      56            0 :   SmoothFlow(const std::array<double, 3>& mean_velocity,
      57              :              const std::array<double, 3>& wavevector, double pressure,
      58              :              double adiabatic_index, double perturbation_size);
      59              : 
      60            0 :   auto get_clone() const
      61              :       -> std::unique_ptr<evolution::initial_data::InitialData> override;
      62              : 
      63              :   /// \cond
      64              :   explicit SmoothFlow(CkMigrateMessage* msg);
      65              :   using PUP::able::register_constructor;
      66              :   WRAPPED_PUPable_decl_template(SmoothFlow);
      67              :   /// \endcond
      68              : 
      69              :   using smooth_flow::equation_of_state;
      70              :   using smooth_flow::equation_of_state_type;
      71              : 
      72              :   // Overload the variables function from the base class.
      73            0 :   using smooth_flow::variables;
      74              : 
      75              :   /// @{
      76              :   /// Retrieve hydro variable at `(x, t)`
      77              :   template <typename DataType>
      78            1 :   auto variables(const tnsr::I<DataType, 3>& x, double /*t*/,
      79              :                  tmpl::list<hydro::Tags::MagneticField<DataType, 3>> /*meta*/)
      80              :       const -> tuples::TaggedTuple<hydro::Tags::MagneticField<DataType, 3>>;
      81              : 
      82              :   template <typename DataType>
      83            1 :   auto variables(
      84              :       const tnsr::I<DataType, 3>& x, double /*t*/,
      85              :       tmpl::list<hydro::Tags::DivergenceCleaningField<DataType>> /*meta*/) const
      86              :       -> tuples::TaggedTuple<hydro::Tags::DivergenceCleaningField<DataType>>;
      87              :   /// @}
      88              : 
      89              :   /// Retrieve a collection of hydro variables at `(x, t)`
      90              :   template <typename DataType, typename... Tags>
      91            1 :   tuples::TaggedTuple<Tags...> variables(const tnsr::I<DataType, 3>& x,
      92              :                                          double t,
      93              :                                          tmpl::list<Tags...> /*meta*/) const {
      94              :     static_assert(sizeof...(Tags) > 1,
      95              :                   "The generic template will recurse infinitely if only one "
      96              :                   "tag is being retrieved.");
      97              :     return {get<Tags>(variables(x, t, tmpl::list<Tags>{}))...};
      98              :   }
      99              : 
     100              :   // NOLINTNEXTLINE(google-runtime-references)
     101            0 :   void pup(PUP::er& /*p*/) override;
     102              : 
     103              :  protected:
     104            0 :   friend bool operator==(const SmoothFlow& lhs, const SmoothFlow& rhs);
     105              : };
     106              : 
     107            0 : bool operator!=(const SmoothFlow& lhs, const SmoothFlow& rhs);
     108              : }  // namespace grmhd::Solutions