Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <array>
       7             : #include <cstddef>
       8             : #include <pup.h>
       9             : 
      10             : #include "Options/Context.hpp"
      11             : #include "Options/String.hpp"
      12             : #include "Utilities/Serialization/CharmPupable.hpp"
      13             : #include "Utilities/TMPL.hpp"
      14             : 
      15             : /// \cond
      16             : namespace PUP {
      17             : class er;
      18             : }  // namespace PUP
      19             : /// \endcond
      20             : 
      21             : namespace ylm {
      22             : template <typename Frame>
      23             : class Strahlkorper;
      24             : 
      25             : /*!
      26             :  * \ingroup SurfacesGroup
      27             :  * \brief Base class for constructing initial Strahlkorper shapes.
      28             :  * \details When constructing a Stahlkorper from options (such as the
      29             :  * initial guess for an apparent horizon), the user can specify a resolution
      30             :  * and a shape (such as spherical, or read from file).
      31             :  */
      32             : template <typename Frame>
      33           1 : class InitialShape : public PUP::able {
      34             :  protected:
      35             :   /// \cond
      36             :   InitialShape() = default;
      37             :   InitialShape(const InitialShape&) = default;
      38             :   InitialShape(InitialShape&&) = default;
      39             :   InitialShape& operator=(const InitialShape&) = default;
      40             :   InitialShape& operator=(InitialShape&&) = default;
      41             :   /// \endcond
      42             : 
      43             :  public:
      44           0 :   ~InitialShape() override = default;
      45           0 :   explicit InitialShape(CkMigrateMessage* msg) : PUP::able(msg) {}
      46             : 
      47           0 :   WRAPPED_PUPable_abstract(InitialShape);
      48             : 
      49             :   /// Construct a Strahlkorper with both `l_max` and `m_max` set to `l_max`.
      50             :   /// The `context` is used to report option-parsing errors.
      51           1 :   virtual Strahlkorper<Frame> strahlkorper(
      52             :       size_t l_max, const Options::Context& context) const = 0;
      53             : };
      54             : 
      55           0 : namespace InitialShapes {
      56             : /*!
      57             :  * \ingroup SurfacesGroup
      58             :  * \brief A spherical initial Strahlkorper shape.
      59             :  */
      60             : template <typename Frame>
      61           1 : class Sphere : public InitialShape<Frame> {
      62             :  public:
      63           0 :   struct Center {
      64           0 :     using type = std::array<double, 3>;
      65           0 :     static constexpr Options::String help = {
      66             :         "Center of the Strahlkorper expansion"};
      67             :   };
      68           0 :   struct Radius {
      69           0 :     using type = double;
      70           0 :     static constexpr Options::String help = {
      71             :         "Radius of spherical Strahlkorper"};
      72             :   };
      73             : 
      74           0 :   using options = tmpl::list<Center, Radius>;
      75           0 :   static constexpr Options::String help = {
      76             :       "Construct a spherical Strahlkorper."};
      77           0 :   static std::string name() { return "Sphere"; }
      78             : 
      79           0 :   Sphere() = default;
      80           0 :   Sphere(std::array<double, 3> center, double radius);
      81             : 
      82             :   /// \cond
      83             :   explicit Sphere(CkMigrateMessage* msg);
      84             :   using PUP::able::register_constructor;
      85             :   WRAPPED_PUPable_decl_template(Sphere);  // NOLINT
      86             :   /// \endcond
      87             : 
      88           1 :   Strahlkorper<Frame> strahlkorper(
      89             :       size_t l_max, const Options::Context& context) const override;
      90             : 
      91           0 :   void pup(PUP::er& p) override;
      92             : 
      93             :  private:
      94           0 :   std::array<double, 3> center_{};
      95           0 :   double radius_{};
      96             : };
      97             : 
      98             : }  // namespace InitialShapes
      99             : }  // namespace ylm