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 <memory>
       9             : #include <pup.h>
      10             : 
      11             : #include "DataStructures/TaggedTuple.hpp"
      12             : #include "DataStructures/Tensor/IndexType.hpp"
      13             : #include "DataStructures/Tensor/Tensor.hpp"
      14             : #include "Evolution/Systems/CurvedScalarWave/Tags.hpp"
      15             : #include "NumericalAlgorithms/LinearOperators/PartialDerivatives.hpp"
      16             : #include "Options/String.hpp"
      17             : #include "PointwiseFunctions/AnalyticData/ScalarTensor/ScalarField/AnalyticData.hpp"
      18             : #include "Utilities/MakeWithValue.hpp"
      19             : #include "Utilities/Serialization/CharmPupable.hpp"
      20             : #include "Utilities/TMPL.hpp"
      21             : 
      22             : namespace ScalarTensor::AnalyticData::ScalarField {
      23             : 
      24             : /*!
      25             :  * \brief Analytic profile for the scalar field composed by two superimposed
      26             :  * $\frac{A}{r}$ profiles.
      27             :  *
      28             :  * This profile is inteded to be used in binary black hole configurations, and
      29             :  * describes the superposition of two $\frac{A}{r}$ profiles, centered on the
      30             :  * two black holes. The expression of the profile then reads
      31             :  * \begin{equation}
      32             :  *   \Psi(x^i) = \frac{A_a}{|x^i - x^i_a|} + \frac{A_b}{|x^i - x^i_b|},
      33             :  * \end{equation}
      34             :  * where $\Psi$ is the scalar field, $x_{a,b}$ are the coordinate locations of
      35             :  * the centers of the two profiles and $A_{a,b}$ are the amplitudes. Note that
      36             :  * the norm for the distance is computed using the eucledian metric.
      37             :  */
      38             : template <size_t Dim>
      39           1 : class SuperposedInverser
      40             :     : public ScalarTensor::AnalyticData::ScalarField::AnalyticData<Dim> {
      41             :  public:
      42           0 :   struct AmplitudeA {
      43           0 :     using type = double;
      44           0 :     static constexpr Options::String help = "Scaled Amplitude A.";
      45             :   };
      46           0 :   struct AmplitudeB {
      47           0 :     using type = double;
      48           0 :     static constexpr Options::String help = "Scaled Amplitude B.";
      49             :   };
      50           0 :   struct LocationA {
      51           0 :     using type = std::array<double, Dim>;
      52           0 :     static constexpr Options::String help = "Location of black hole A.";
      53             :   };
      54           0 :   struct LocationB {
      55           0 :     using type = std::array<double, Dim>;
      56           0 :     static constexpr Options::String help = "location of black hole B.";
      57             :   };
      58             : 
      59           0 :   using options = tmpl::list<AmplitudeA, AmplitudeB, LocationA, LocationB>;
      60           0 :   static constexpr Options::String help{
      61             :       "Superposed 1/r intitial guesses for the scalar field in a black hole "
      62             :       "binary system."};
      63             : 
      64           0 :   using scalar_field_tags =
      65             :       typename ScalarTensor::AnalyticData::ScalarField::AnalyticData<
      66             :           Dim>::scalar_field_tags;
      67             : 
      68           0 :   SuperposedInverser() = default;
      69           0 :   SuperposedInverser(const SuperposedInverser&) = default;
      70           0 :   SuperposedInverser& operator=(const SuperposedInverser&) = default;
      71           0 :   SuperposedInverser(SuperposedInverser&&) = default;
      72           0 :   SuperposedInverser& operator=(SuperposedInverser&&) = default;
      73           0 :   ~SuperposedInverser() override = default;
      74           0 :   SuperposedInverser(double amplitude_a, double amplitude_b,
      75             :                      std::array<double, Dim> location_a,
      76             :                      std::array<double, Dim> location_b);
      77             : 
      78             :   /// \cond
      79             :   explicit SuperposedInverser(CkMigrateMessage* m)
      80             :       : ScalarTensor::AnalyticData::ScalarField::AnalyticData<Dim>(m) {}
      81             :   using PUP::able::register_constructor;
      82             :   WRAPPED_PUPable_decl_template(SuperposedInverser);  // NOLINT
      83             :   /// \endcond
      84             : 
      85             :   std::unique_ptr<ScalarTensor::AnalyticData::ScalarField::AnalyticData<Dim>>
      86           0 :   get_clone() const override;
      87             : 
      88           0 :   tuples::TaggedTuple<::CurvedScalarWave::Tags::Psi> variables(
      89             :       const tnsr::I<DataVector, Dim>& x,
      90             :       tmpl::list<::CurvedScalarWave::Tags::Psi> /*meta*/) const;
      91             : 
      92             :   tuples::TaggedTuple<::CurvedScalarWave::Tags::Phi<Dim, Frame::Inertial>>
      93           0 :   variables(
      94             :       const tnsr::I<DataVector, Dim>& x,
      95             :       tmpl::list<::CurvedScalarWave::Tags::Phi<Dim, Frame::Inertial>> /*meta*/)
      96             :       const;
      97             : 
      98             :   template <typename... RequestedTags>
      99           0 :   tuples::TaggedTuple<RequestedTags...> variables(
     100             :       const tnsr::I<DataVector, Dim>& x,
     101             :       tmpl::list<RequestedTags...> /*meta*/) const {
     102             :     static_assert(
     103             :         tmpl::size<tmpl::list_difference<tmpl::list<RequestedTags...>,
     104             :                                          scalar_field_tags>>::value == 0,
     105             :         "The requested tag is not supported");
     106             :     return {make_with_value<typename RequestedTags::type>(x, 0.)...};
     107             :   }
     108             : 
     109           0 :   void pup(PUP::er& p) override;
     110             : 
     111             :  private:
     112           0 :   double amplitude_a_{std::numeric_limits<double>::signaling_NaN()};
     113           0 :   double amplitude_b_{std::numeric_limits<double>::signaling_NaN()};
     114           0 :   std::array<double, Dim> location_a_{
     115             :       std::numeric_limits<double>::signaling_NaN()};
     116           0 :   std::array<double, Dim> location_b_{
     117             :       std::numeric_limits<double>::signaling_NaN()};
     118             : 
     119             :   template <size_t SpatialDim>
     120           0 :   friend bool operator==(const SuperposedInverser<SpatialDim>& lhs,
     121             :                          const SuperposedInverser<SpatialDim>& rhs);
     122             : };
     123             : 
     124             : template <size_t SpatialDim>
     125           0 : bool operator!=(const SuperposedInverser<SpatialDim>& lhs,
     126             :                 const SuperposedInverser<SpatialDim>& rhs);
     127             : }  // namespace ScalarTensor::AnalyticData::ScalarField