Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <cstddef>
       7             : #include <memory>
       8             : #include <pup.h>
       9             : 
      10             : #include "DataStructures/TaggedTuple.hpp"
      11             : #include "DataStructures/Tensor/IndexType.hpp"
      12             : #include "DataStructures/Tensor/Tensor.hpp"
      13             : #include "Evolution/Systems/CurvedScalarWave/Tags.hpp"
      14             : #include "NumericalAlgorithms/LinearOperators/PartialDerivatives.hpp"
      15             : #include "Options/String.hpp"
      16             : #include "PointwiseFunctions/AnalyticData/ScalarTensor/ScalarField/AnalyticData.hpp"
      17             : #include "Utilities/MakeWithValue.hpp"
      18             : #include "Utilities/Serialization/CharmPupable.hpp"
      19             : #include "Utilities/TMPL.hpp"
      20             : 
      21             : namespace ScalarTensor::AnalyticData::ScalarField {
      22             : 
      23             : /*!
      24             :  * \brief $\frac{A}{r}$ profile for the scalar field.
      25             :  *
      26             :  * The expression of the profile as a function of the coordinates reads
      27             :  * \begin{equation}
      28             :  *   \Psi(x^i) = \frac{A}{|x^i - x^i_0|},
      29             :  * \end{equation}
      30             :  * where $\Psi$ is the scalar field, $x^i_0 = (0, 0, 0)$ is the coordinate
      31             :  * location of the center of the profile and $A$ is the amplitude. Note that the
      32             :  * norm for the distance is computed using the eucledian metric.
      33             :  */
      34             : template <size_t Dim>
      35           1 : class Inverser
      36             :     : public ScalarTensor::AnalyticData::ScalarField::AnalyticData<Dim> {
      37             :  public:
      38           0 :   struct Amplitude {
      39           0 :     using type = double;
      40           0 :     static constexpr Options::String help = "Scaled Amplitude.";
      41             :   };
      42             : 
      43           0 :   using options = tmpl::list<Amplitude>;
      44           0 :   static constexpr Options::String help{
      45             :       "A/r profile for initial guess of the scalar field."};
      46             : 
      47           0 :   using scalar_field_tags =
      48             :       typename ScalarTensor::AnalyticData::ScalarField::AnalyticData<
      49             :           Dim>::scalar_field_tags;
      50             : 
      51           0 :   Inverser() = default;
      52           0 :   Inverser(const Inverser&) = default;
      53           0 :   Inverser& operator=(const Inverser&) = default;
      54           0 :   Inverser(Inverser&&) = default;
      55           0 :   Inverser& operator=(Inverser&&) = default;
      56           0 :   ~Inverser() override = default;
      57             : 
      58           0 :   explicit Inverser(double amplitude);
      59             : 
      60             :   /// \cond
      61             :   explicit Inverser(CkMigrateMessage* m)
      62             :       : ScalarTensor::AnalyticData::ScalarField::AnalyticData<Dim>(m) {}
      63             :   using PUP::able::register_constructor;
      64             :   WRAPPED_PUPable_decl_template(Inverser);  // NOLINT
      65             :   /// \endcond
      66             : 
      67             :   std::unique_ptr<ScalarTensor::AnalyticData::ScalarField::AnalyticData<Dim>>
      68           0 :   get_clone() const override;
      69             : 
      70           0 :   tuples::TaggedTuple<::CurvedScalarWave::Tags::Psi> variables(
      71             :       const tnsr::I<DataVector, Dim>& x,
      72             :       tmpl::list<::CurvedScalarWave::Tags::Psi> /*meta*/) const;
      73             : 
      74             :   tuples::TaggedTuple<::CurvedScalarWave::Tags::Phi<Dim, Frame::Inertial>>
      75           0 :   variables(
      76             :       const tnsr::I<DataVector, Dim>& x,
      77             :       tmpl::list<::CurvedScalarWave::Tags::Phi<Dim, Frame::Inertial>> /*meta*/)
      78             :       const;
      79             : 
      80             :   template <typename... RequestedTags>
      81           0 :   tuples::TaggedTuple<RequestedTags...> variables(
      82             :       const tnsr::I<DataVector, Dim>& x,
      83             :       tmpl::list<RequestedTags...> /*meta*/) const {
      84             :     static_assert(
      85             :         tmpl::size<tmpl::list_difference<tmpl::list<RequestedTags...>,
      86             :                                          scalar_field_tags>>::value == 0,
      87             :         "The requested tag is not supported");
      88             :     return {make_with_value<typename RequestedTags::type>(x, 0.)...};
      89             :   }
      90             : 
      91           0 :   void pup(PUP::er& p) override;
      92             : 
      93             :  private:
      94           0 :   double amplitude_{std::numeric_limits<double>::signaling_NaN()};
      95             : 
      96             :   template <size_t SpatialDim>
      97           0 :   friend bool operator==(const Inverser<SpatialDim>& lhs,
      98             :                          const Inverser<SpatialDim>& rhs);
      99             : };
     100             : 
     101             : template <size_t SpatialDim>
     102           0 : bool operator!=(const Inverser<SpatialDim>& lhs,
     103             :                 const Inverser<SpatialDim>& rhs);
     104             : 
     105             : }  // namespace ScalarTensor::AnalyticData::ScalarField