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             : 
       8             : #include "DataStructures/CachedTempBuffer.hpp"
       9             : #include "DataStructures/DataBox/Prefixes.hpp"
      10             : #include "DataStructures/Tensor/Tensor.hpp"
      11             : #include "Elliptic/Systems/Punctures/Tags.hpp"
      12             : #include "NumericalAlgorithms/LinearOperators/PartialDerivatives.hpp"
      13             : #include "Options/String.hpp"
      14             : #include "PointwiseFunctions/InitialDataUtilities/AnalyticSolution.hpp"
      15             : #include "Utilities/Gsl.hpp"
      16             : #include "Utilities/TMPL.hpp"
      17             : #include "Utilities/TaggedTuple.hpp"
      18             : 
      19           0 : namespace Punctures::Solutions {
      20             : 
      21             : /// Flat spacetime. Useful as initial guess.
      22           1 : class Flatness : public elliptic::analytic_data::AnalyticSolution {
      23             :  public:
      24           0 :   using options = tmpl::list<>;
      25           0 :   static constexpr Options::String help{
      26             :       "Flat spacetime, useful as initial guess."};
      27             : 
      28           0 :   Flatness() = default;
      29           0 :   Flatness(const Flatness&) = default;
      30           0 :   Flatness& operator=(const Flatness&) = default;
      31           0 :   Flatness(Flatness&&) = default;
      32           0 :   Flatness& operator=(Flatness&&) = default;
      33           0 :   ~Flatness() = default;
      34           0 :   std::unique_ptr<elliptic::analytic_data::AnalyticSolution> get_clone()
      35             :       const override {
      36             :     return std::make_unique<Flatness>(*this);
      37             :   }
      38             : 
      39             :   /// \cond
      40             :   explicit Flatness(CkMigrateMessage* m)
      41             :       : elliptic::analytic_data::AnalyticSolution(m) {}
      42             :   using PUP::able::register_constructor;
      43             :   WRAPPED_PUPable_decl_template(Flatness);
      44             :   /// \endcond
      45             : 
      46             :   template <typename... RequestedTags>
      47           0 :   tuples::TaggedTuple<RequestedTags...> variables(
      48             :       const tnsr::I<DataVector, 3, Frame::Inertial>& x,
      49             :       tmpl::list<RequestedTags...> /*meta*/) const {
      50             :     // These are all zero
      51             :     using supported_tags =
      52             :         tmpl::list<Tags::Field,
      53             :                    ::Tags::deriv<Tags::Field, tmpl::size_t<3>, Frame::Inertial>,
      54             :                    ::Tags::Flux<Tags::Field, tmpl::size_t<3>, Frame::Inertial>,
      55             :                    Punctures::Tags::Alpha,
      56             :                    Punctures::Tags::TracelessConformalExtrinsicCurvature,
      57             :                    Punctures::Tags::Beta,
      58             :                    ::Tags::FixedSource<Punctures::Tags::Field>>;
      59             :     static_assert(
      60             :         std::is_same_v<
      61             :             tmpl::list_difference<tmpl::list<RequestedTags...>, supported_tags>,
      62             :             tmpl::list<>>,
      63             :         "Not all requested tags are supported. The static_assert lists the "
      64             :         "unsupported tags.");
      65             :     const auto make_value = [&x](auto tag_v) {
      66             :       using tag = std::decay_t<decltype(tag_v)>;
      67             :       return make_with_value<typename tag::type>(x, 0.);
      68             :     };
      69             :     return {make_value(RequestedTags{})...};
      70             :   }
      71             : 
      72             :   template <typename... RequestedTags>
      73           0 :   tuples::TaggedTuple<RequestedTags...> variables(
      74             :       const tnsr::I<DataVector, 3, Frame::Inertial>& x, const Mesh<3>& /*mesh*/,
      75             :       const InverseJacobian<DataVector, 3, Frame::ElementLogical,
      76             :                             Frame::Inertial>& /*inv_jacobian*/,
      77             :       tmpl::list<RequestedTags...> /*meta*/) const {
      78             :     return variables(x, tmpl::list<RequestedTags...>{});
      79             :   }
      80             : };
      81             : 
      82           0 : bool operator==(const Flatness& lhs, const Flatness& rhs);
      83             : 
      84           0 : bool operator!=(const Flatness& lhs, const Flatness& rhs);
      85             : 
      86             : }  // namespace Punctures::Solutions