Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <limits>
       7             : 
       8             : #include "DataStructures/DataBox/Prefixes.hpp"  // IWYU pragma: keep
       9             : #include "DataStructures/Tensor/TypeAliases.hpp"
      10             : #include "Evolution/Systems/Burgers/Tags.hpp"  // IWYU pragma: keep
      11             : #include "Options/String.hpp"
      12             : #include "PointwiseFunctions/AnalyticSolutions/AnalyticSolution.hpp"
      13             : #include "PointwiseFunctions/InitialDataUtilities/InitialData.hpp"
      14             : #include "Utilities/Serialization/CharmPupable.hpp"
      15             : #include "Utilities/TMPL.hpp"
      16             : #include "Utilities/TaggedTuple.hpp"
      17             : 
      18             : /// \cond
      19             : class DataVector;
      20             : // IWYU pragma: no_forward_declare Tensor
      21             : namespace PUP {
      22             : class er;
      23             : }  // namespace PUP
      24             : /// \endcond
      25             : 
      26           1 : namespace Burgers::Solutions {
      27             : /*!
      28             :  * \brief A solution resembling a bump.
      29             :  *
      30             :  * At \f$t=0\f$, the solution is a parabola:
      31             :  * \f{equation*}
      32             :  *  u(x, t) = h \left(1 - \left(\frac{x - c}{w}\right)^2\right),
      33             :  * \f}
      34             :  * where \f$h\f$ is the height, \f$c\f$ is the center, and \f$w\f$ is
      35             :  * the distance from the center to the zeros.  A shock propagates in
      36             :  * from infinity and reaches one of the zeros at \f$t = \frac{w}{2
      37             :  * h}\f$.
      38             :  */
      39           1 : class Bump : public evolution::initial_data::InitialData,
      40             :              public MarkAsAnalyticSolution {
      41             :  public:
      42           0 :   struct HalfWidth {
      43           0 :     using type = double;
      44           0 :     static constexpr Options::String help{
      45             :         "The distance from the center to the zero of the bump"};
      46           0 :     static type lower_bound() { return 0.; }
      47             :   };
      48             : 
      49           0 :   struct Height {
      50           0 :     using type = double;
      51           0 :     static constexpr Options::String help{"The height of the bump"};
      52             :   };
      53             : 
      54           0 :   struct Center {
      55           0 :     using type = double;
      56           0 :     static constexpr Options::String help{"The center of the bump"};
      57             :   };
      58             : 
      59           0 :   using options = tmpl::list<HalfWidth, Height, Center>;
      60           0 :   static constexpr Options::String help{"A bump solution"};
      61             : 
      62           0 :   Bump() = default;
      63           0 :   Bump(const Bump&) = default;
      64           0 :   Bump& operator=(const Bump&) = default;
      65           0 :   Bump(Bump&&) = default;
      66           0 :   Bump& operator=(Bump&&) = default;
      67           0 :   ~Bump() override = default;
      68             : 
      69           0 :   Bump(double half_width, double height, double center = 0.);
      70             : 
      71           0 :   auto get_clone() const
      72             :       -> std::unique_ptr<evolution::initial_data::InitialData> override;
      73             : 
      74             :   /// \cond
      75             :   explicit Bump(CkMigrateMessage* msg);
      76             :   using PUP::able::register_constructor;
      77             :   WRAPPED_PUPable_decl_template(Bump);
      78             :   /// \endcond
      79             : 
      80             :   template <typename T>
      81           0 :   Scalar<T> u(const tnsr::I<T, 1>& x, double t) const;
      82             : 
      83             :   template <typename T>
      84           0 :   Scalar<T> du_dt(const tnsr::I<T, 1>& x, double t) const;
      85             : 
      86           0 :   tuples::TaggedTuple<Tags::U> variables(const tnsr::I<DataVector, 1>& x,
      87             :                                          double t,
      88             :                                          tmpl::list<Tags::U> /*meta*/) const;
      89             : 
      90           0 :   tuples::TaggedTuple<::Tags::dt<Burgers::Tags::U>> variables(
      91             :       const tnsr::I<DataVector, 1>& x, double t,
      92             :       tmpl::list<::Tags::dt<Tags::U>> /*meta*/) const;
      93             : 
      94             :   // NOLINTNEXTLINE(google-runtime-references)
      95           0 :   void pup(PUP::er& p) override;
      96             : 
      97             :  private:
      98           0 :   double half_width_ = std::numeric_limits<double>::signaling_NaN();
      99           0 :   double height_ = std::numeric_limits<double>::signaling_NaN();
     100           0 :   double center_ = std::numeric_limits<double>::signaling_NaN();
     101             : };
     102             : }  // namespace Burgers::Solutions