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 <string>
       9             : 
      10             : #include "DataStructures/DataBox/Prefixes.hpp"
      11             : #include "DataStructures/DataVector.hpp"
      12             : #include "DataStructures/TaggedTuple.hpp"
      13             : #include "DataStructures/Tensor/Tensor.hpp"
      14             : #include "Evolution/Systems/Ccz4/Tags.hpp"
      15             : #include "Options/String.hpp"
      16             : #include "PointwiseFunctions/GeneralRelativity/Tags.hpp"
      17             : #include "PointwiseFunctions/InitialDataUtilities/InitialData.hpp"
      18             : #include "Utilities/GenerateInstantiations.hpp"
      19             : #include "Utilities/Serialization/CharmPupable.hpp"
      20             : #include "Utilities/TMPL.hpp"
      21             : 
      22             : /// \cond
      23             : namespace PUP {
      24             : class er;
      25             : }  // namespace PUP
      26             : /// \endcond
      27             : 
      28           0 : namespace Ccz4::Solutions {
      29             : /*!
      30             :  * \brief A wrapper for general-relativity analytic solutions that loads
      31             :  * the analytic solution and then adds a function that returns
      32             :  * any combination of the Ccz4 evolution variables.
      33             :  * Specifically, see `Ccz4::fd::System`.
      34             :  *
      35             :  * The wrapper returns the everywhere-nonnegative lapse
      36             :  * \f$|\alpha|\f$ in place of the wrapped solution's lapse \f$\alpha\f$, with
      37             :  * the lapse derivative and time derivative scaled by
      38             :  * \f$\mathrm{sgn}(\alpha)\f$ (where \f$\mathrm{sgn}(0) := 0\f$). For
      39             :  * solutions with positive lapse this is an exact no-op. For solutions whose
      40             :  * lapse is negative somewhere (e.g. the lapse of
      41             :  * `gr::Solutions::HighSpinKerrPuncture` inside its throat) the sign flip is
      42             :  * pure gauge: the spatial metric and extrinsic curvature are unchanged.
      43             :  */
      44             : template <typename SolutionType>
      45           1 : class Ccz4WrappedGr : public virtual evolution::initial_data::InitialData,
      46             :                       public SolutionType {
      47             :  public:
      48             :   using SolutionType::SolutionType;
      49             : 
      50           0 :   Ccz4WrappedGr() = default;
      51           0 :   Ccz4WrappedGr(const Ccz4WrappedGr& /*rhs*/) = default;
      52           0 :   Ccz4WrappedGr& operator=(const Ccz4WrappedGr& /*rhs*/) = default;
      53           0 :   Ccz4WrappedGr(Ccz4WrappedGr&& /*rhs*/) = default;
      54           0 :   Ccz4WrappedGr& operator=(Ccz4WrappedGr&& /*rhs*/) = default;
      55           0 :   ~Ccz4WrappedGr() override = default;
      56             : 
      57           0 :   explicit Ccz4WrappedGr(const SolutionType& wrapped_solution);
      58             : 
      59           0 :   auto get_clone() const
      60             :       -> std::unique_ptr<evolution::initial_data::InitialData> override;
      61             : 
      62             :   /// \cond
      63             :   explicit Ccz4WrappedGr(CkMigrateMessage* msg);
      64             :   using PUP::able::register_constructor;
      65             :   WRAPPED_PUPable_decl_template(Ccz4WrappedGr);
      66             :   /// \endcond
      67             : 
      68           0 :   static constexpr size_t volume_dim = SolutionType::volume_dim;
      69             :   static_assert(volume_dim == 3,
      70             :                 "Ccz4 evolution system has only been implemented in 3D!");
      71           0 :   using options = typename SolutionType::options;
      72           0 :   static constexpr Options::String help = SolutionType::help;
      73           0 :   static std::string name() {
      74             :     return "Ccz4(" + pretty_type::name<SolutionType>() + ")";
      75             :   }
      76             : 
      77           0 :   using DerivLapse = ::Tags::deriv<gr::Tags::Lapse<DataVector>,
      78             :                                    tmpl::size_t<volume_dim>, Frame::Inertial>;
      79           0 :   using DerivShift = ::Tags::deriv<gr::Tags::Shift<DataVector, volume_dim>,
      80             :                                    tmpl::size_t<volume_dim>, Frame::Inertial>;
      81           0 :   using DerivSpatialMetric =
      82             :       ::Tags::deriv<gr::Tags::SpatialMetric<DataVector, volume_dim>,
      83             :                     tmpl::size_t<volume_dim>, Frame::Inertial>;
      84           0 :   using TimeDerivLapse = ::Tags::dt<gr::Tags::Lapse<DataVector>>;
      85           0 :   using TimeDerivShift = ::Tags::dt<gr::Tags::Shift<DataVector, volume_dim>>;
      86           0 :   using TimeDerivSpatialMetric =
      87             :       ::Tags::dt<gr::Tags::SpatialMetric<DataVector, volume_dim>>;
      88             : 
      89           0 :   using IntermediateVars = tuples::tagged_tuple_from_typelist<
      90             :       typename SolutionType::template tags<DataVector>>;
      91             : 
      92             :   template <typename DataType>
      93           0 :   using tags =
      94             :       tmpl::push_back<typename SolutionType::template tags<DataType>,
      95             :                       Ccz4::Tags::ConformalMetric<DataType, volume_dim>,
      96             :                       Ccz4::Tags::ConformalFactor<DataType>,
      97             :                       Ccz4::Tags::ATilde<DataType, volume_dim>,
      98             :                       gr::Tags::TraceExtrinsicCurvature<DataType>,
      99             :                       Ccz4::Tags::Theta<DataType>,
     100             :                       Ccz4::Tags::GammaHat<DataType, volume_dim>,
     101             :                       Ccz4::Tags::AuxiliaryShiftB<DataType, volume_dim>>;
     102             : 
     103             :   template <typename... Tags>
     104           0 :   tuples::TaggedTuple<Tags...> variables(
     105             :       const tnsr::I<DataVector, volume_dim>& x, const double t,
     106             :       tmpl::list<Tags...> /*meta*/) const {
     107             :     const IntermediateVars intermediate_vars = make_intermediate_vars(x, t);
     108             : 
     109             :     return {
     110             :         get<Tags>(variables(x, t, tmpl::list<Tags>{}, intermediate_vars))...};
     111             :   }
     112             : 
     113             :   template <typename Tag>
     114           0 :   tuples::TaggedTuple<Tag> variables(const tnsr::I<DataVector, volume_dim>& x,
     115             :                                      const double t,
     116             :                                      tmpl::list<Tag> /*meta*/) const {
     117             :     const IntermediateVars intermediate_vars = make_intermediate_vars(x, t);
     118             :     return {get<Tag>(variables(x, t, tmpl::list<Tag>{}, intermediate_vars))};
     119             :   }
     120             : 
     121             :   // overloads for wrapping analytic data
     122             : 
     123             :   template <typename... Tags>
     124           0 :   tuples::TaggedTuple<Tags...> variables(
     125             :       const tnsr::I<DataVector, volume_dim>& x,
     126             :       tmpl::list<Tags...> /*meta*/) const {
     127             :     const IntermediateVars intermediate_vars = make_intermediate_vars(x);
     128             : 
     129             :     return {get<Tags>(variables(x, tmpl::list<Tags>{}, intermediate_vars))...};
     130             :   }
     131             : 
     132             :   template <typename Tag>
     133           0 :   tuples::TaggedTuple<Tag> variables(const tnsr::I<DataVector, volume_dim>& x,
     134             :                                      tmpl::list<Tag> /*meta*/) const {
     135             :     const IntermediateVars intermediate_vars = make_intermediate_vars(x);
     136             :     return {get<Tag>(variables(x, tmpl::list<Tag>{}, intermediate_vars))};
     137             :   }
     138             : 
     139             :   // NOLINTNEXTLINE(google-runtime-references)
     140           0 :   void pup(PUP::er& p) override;
     141             : 
     142             :  private:
     143             :   // Computes the wrapped solution's variables and applies the nonnegative
     144             :   // lapse: the lapse is replaced by its absolute
     145             :   // value, and the lapse derivative and time derivative are scaled by
     146             :   // sign(lapse), with sign(0) := 0. Every tag the wrapper returns,
     147             :   // passed through or derived, must be computed from the IntermediateVars
     148             :   // returned here, never by calling the solution directly, so that any
     149             :   // lapse-dependent quantity added in the future automatically sees the
     150             :   // corrected gauge.
     151             :   template <typename... OptionalTime>
     152           0 :   IntermediateVars make_intermediate_vars(
     153             :       const tnsr::I<DataVector, volume_dim>& x, OptionalTime... time) const {
     154             :     IntermediateVars vars = SolutionType::variables(
     155             :         x, time..., typename SolutionType::template tags<DataVector>{});
     156             :     // The sign must be taken before the lapse is replaced
     157             :     const DataVector sgn_of_lapse =
     158             :         sign(get(get<gr::Tags::Lapse<DataVector>>(vars)));
     159             :     for (size_t i = 0; i < volume_dim; ++i) {
     160             :       get<DerivLapse>(vars).get(i) *= sgn_of_lapse;
     161             :     }
     162             :     get(get<TimeDerivLapse>(vars)) *= sgn_of_lapse;
     163             :     get(get<gr::Tags::Lapse<DataVector>>(vars)) =
     164             :         abs(get(get<gr::Tags::Lapse<DataVector>>(vars)));
     165             :     return vars;
     166             :   }
     167             : 
     168             :   // The generic overloads below pass the wrapped solution's tags through
     169             :   // from the IntermediateVars; the explicit overloads compute the seven
     170             :   // tags the wrapper adds (Ccz4::Tags::ConformalMetric,
     171             :   // Ccz4::Tags::ConformalFactor, Ccz4::Tags::ATilde,
     172             :   // gr::Tags::TraceExtrinsicCurvature, Ccz4::Tags::Theta,
     173             :   // Ccz4::Tags::GammaHat, Ccz4::Tags::AuxiliaryShiftB)
     174           0 :   using TagShift = gr::Tags::Shift<DataVector, volume_dim>;
     175           0 :   using TagSpatialMetric = gr::Tags::SpatialMetric<DataVector, volume_dim>;
     176           0 :   using TagInverseSpatialMetric =
     177             :       gr::Tags::InverseSpatialMetric<DataVector, volume_dim>;
     178           0 :   using TagExCurvature = gr::Tags::ExtrinsicCurvature<DataVector, volume_dim>;
     179             : 
     180             :   template <typename Tag>
     181           0 :   tuples::TaggedTuple<Tag> variables(
     182             :       const tnsr::I<DataVector, volume_dim>& /*x*/, double /*t*/,
     183             :       tmpl::list<Tag> /*meta*/,
     184             :       const IntermediateVars& intermediate_vars) const {
     185             :     static_assert(
     186             :         tmpl::list_contains_v<typename SolutionType::template tags<DataVector>,
     187             :                               Tag>);
     188             :     return {get<Tag>(intermediate_vars)};
     189             :   }
     190             : 
     191             :   template <typename Tag>
     192           0 :   tuples::TaggedTuple<Tag> variables(
     193             :       const tnsr::I<DataVector, volume_dim>& /*x*/, tmpl::list<Tag> /*meta*/,
     194             :       const IntermediateVars& intermediate_vars) const {
     195             :     static_assert(
     196             :         tmpl::list_contains_v<typename SolutionType::template tags<DataVector>,
     197             :                               Tag>);
     198             :     return {get<Tag>(intermediate_vars)};
     199             :   }
     200             : 
     201             :   tuples::TaggedTuple<Ccz4::Tags::ConformalMetric<DataVector, volume_dim>>
     202           0 :   variables(
     203             :       const tnsr::I<DataVector, volume_dim>& /*x*/,
     204             :       tmpl::list<Ccz4::Tags::ConformalMetric<DataVector, volume_dim>> /*meta*/,
     205             :       const IntermediateVars& intermediate_vars) const;
     206           0 :   tuples::TaggedTuple<Ccz4::Tags::ConformalFactor<DataVector>> variables(
     207             :       const tnsr::I<DataVector, volume_dim>& /*x*/,
     208             :       tmpl::list<Ccz4::Tags::ConformalFactor<DataVector>> /*meta*/,
     209             :       const IntermediateVars& intermediate_vars) const;
     210           0 :   tuples::TaggedTuple<Ccz4::Tags::ATilde<DataVector, volume_dim>> variables(
     211             :       const tnsr::I<DataVector, volume_dim>& /*x*/,
     212             :       tmpl::list<Ccz4::Tags::ATilde<DataVector, volume_dim>> /*meta*/,
     213             :       const IntermediateVars& intermediate_vars) const;
     214           0 :   tuples::TaggedTuple<gr::Tags::TraceExtrinsicCurvature<DataVector>> variables(
     215             :       const tnsr::I<DataVector, volume_dim>& /*x*/,
     216             :       tmpl::list<gr::Tags::TraceExtrinsicCurvature<DataVector>> /*meta*/,
     217             :       const IntermediateVars& intermediate_vars) const;
     218           0 :   tuples::TaggedTuple<Ccz4::Tags::Theta<DataVector>> variables(
     219             :       const tnsr::I<DataVector, volume_dim>& /*x*/,
     220             :       tmpl::list<Ccz4::Tags::Theta<DataVector>> /*meta*/,
     221             :       const IntermediateVars& intermediate_vars) const;
     222           0 :   tuples::TaggedTuple<Ccz4::Tags::GammaHat<DataVector, volume_dim>> variables(
     223             :       const tnsr::I<DataVector, volume_dim>& /*x*/,
     224             :       tmpl::list<Ccz4::Tags::GammaHat<DataVector, volume_dim>> /*meta*/,
     225             :       const IntermediateVars& intermediate_vars) const;
     226             :   tuples::TaggedTuple<Ccz4::Tags::AuxiliaryShiftB<DataVector, volume_dim>>
     227           0 :   variables(
     228             :       const tnsr::I<DataVector, volume_dim>& /*x*/,
     229             :       tmpl::list<Ccz4::Tags::AuxiliaryShiftB<DataVector, volume_dim>> /*meta*/,
     230             :       const IntermediateVars& intermediate_vars) const;
     231             : 
     232             :   tuples::TaggedTuple<Ccz4::Tags::ConformalMetric<DataVector, volume_dim>>
     233           0 :   variables(
     234             :       const tnsr::I<DataVector, volume_dim>& x, const double /*t*/,
     235             :       tmpl::list<Ccz4::Tags::ConformalMetric<DataVector, volume_dim>> meta,
     236             :       const IntermediateVars& intermediate_vars) const {
     237             :     return variables(x, meta, intermediate_vars);
     238             :   }
     239           0 :   tuples::TaggedTuple<Ccz4::Tags::ConformalFactor<DataVector>> variables(
     240             :       const tnsr::I<DataVector, volume_dim>& x, double /*t*/,
     241             :       tmpl::list<Ccz4::Tags::ConformalFactor<DataVector>> meta,
     242             :       const IntermediateVars& intermediate_vars) const {
     243             :     return variables(x, meta, intermediate_vars);
     244             :   }
     245           0 :   tuples::TaggedTuple<Ccz4::Tags::ATilde<DataVector, volume_dim>> variables(
     246             :       const tnsr::I<DataVector, volume_dim>& x, double /*t*/,
     247             :       tmpl::list<Ccz4::Tags::ATilde<DataVector, volume_dim>> meta,
     248             :       const IntermediateVars& intermediate_vars) const {
     249             :     return variables(x, meta, intermediate_vars);
     250             :   }
     251           0 :   tuples::TaggedTuple<gr::Tags::TraceExtrinsicCurvature<DataVector>> variables(
     252             :       const tnsr::I<DataVector, volume_dim>& x, const double /*t*/,
     253             :       tmpl::list<gr::Tags::TraceExtrinsicCurvature<DataVector>> meta,
     254             :       const IntermediateVars& intermediate_vars) const {
     255             :     return variables(x, meta, intermediate_vars);
     256             :   }
     257           0 :   tuples::TaggedTuple<Ccz4::Tags::Theta<DataVector>> variables(
     258             :       const tnsr::I<DataVector, volume_dim>& x, double /*t*/,
     259             :       tmpl::list<Ccz4::Tags::Theta<DataVector>> meta,
     260             :       const IntermediateVars& intermediate_vars) const {
     261             :     return variables(x, meta, intermediate_vars);
     262             :   }
     263           0 :   tuples::TaggedTuple<Ccz4::Tags::GammaHat<DataVector, volume_dim>> variables(
     264             :       const tnsr::I<DataVector, volume_dim>& x, double /*t*/,
     265             :       tmpl::list<Ccz4::Tags::GammaHat<DataVector, volume_dim>> meta,
     266             :       const IntermediateVars& intermediate_vars) const {
     267             :     return variables(x, meta, intermediate_vars);
     268             :   }
     269             :   tuples::TaggedTuple<Ccz4::Tags::AuxiliaryShiftB<DataVector, volume_dim>>
     270           0 :   variables(
     271             :       const tnsr::I<DataVector, volume_dim>& x, double /*t*/,
     272             :       tmpl::list<Ccz4::Tags::AuxiliaryShiftB<DataVector, volume_dim>> meta,
     273             :       const IntermediateVars& intermediate_vars) const {
     274             :     return variables(x, meta, intermediate_vars);
     275             :   }
     276             : };
     277             : 
     278             : template <typename SolutionType>
     279           0 : bool operator==(const Ccz4WrappedGr<SolutionType>& lhs,
     280             :                 const Ccz4WrappedGr<SolutionType>& rhs);
     281             : 
     282             : template <typename SolutionType>
     283           0 : bool operator!=(const Ccz4WrappedGr<SolutionType>& lhs,
     284             :                 const Ccz4WrappedGr<SolutionType>& rhs);
     285             : 
     286             : template <typename SolutionType>
     287           0 : Ccz4WrappedGr(SolutionType solution) -> Ccz4WrappedGr<SolutionType>;
     288             : }  // namespace Ccz4::Solutions