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/DataBox/Protocols/Mutator.hpp"
       9             : #include "DataStructures/DataVector.hpp"
      10             : #include "DataStructures/Tensor/Tensor.hpp"
      11             : #include "Domain/Tags.hpp"
      12             : #include "Evolution/Initialization/InitialData.hpp"
      13             : #include "Evolution/Initialization/Tags.hpp"
      14             : #include "Evolution/Systems/CurvedScalarWave/BackgroundSpacetime.hpp"
      15             : #include "Evolution/Systems/CurvedScalarWave/System.hpp"
      16             : #include "Evolution/Systems/ScalarWave/System.hpp"
      17             : #include "Evolution/Systems/ScalarWave/TagsDeclarations.hpp"
      18             : #include "NumericalAlgorithms/Spectral/Mesh.hpp"
      19             : #include "PointwiseFunctions/AnalyticData/Tags.hpp"
      20             : #include "PointwiseFunctions/InitialDataUtilities/InitialData.hpp"
      21             : #include "PointwiseFunctions/InitialDataUtilities/Tags/InitialData.hpp"
      22             : #include "Utilities/CallWithDynamicType.hpp"
      23             : #include "Utilities/ProtocolHelpers.hpp"
      24             : #include "Utilities/TMPL.hpp"
      25             : 
      26             : /// \cond
      27             : namespace Tags {
      28             : struct Time;
      29             : }  // namespace Tags
      30             : /// \endcond
      31             : 
      32             : /// \brief Utilities for initializing the curved scalar wave system.
      33           1 : namespace CurvedScalarWave::Initialization {
      34             : /// \ingroup InitializationGroup
      35             : /// \brief Mutator meant to be used with
      36             : /// `Initialization::Actions::AddSimpleTags` to initialize the constraint
      37             : /// damping parameters of the CurvedScalarWave system
      38             : ///
      39             : /// DataBox changes:
      40             : /// - Adds:
      41             : ///   * `CurvedScalarWave::Tags::ConstraintGamma1`
      42             : ///   * `CurvedScalarWave::Tags::ConstraintGamma2`
      43             : /// - Removes: nothing
      44             : /// - Modifies: nothing
      45             : 
      46             : template <size_t Dim>
      47           1 : struct InitializeConstraintDampingGammas
      48             :     : tt::ConformsTo<db::protocols::Mutator> {
      49           0 :   using return_tags =
      50             :       tmpl::list<Tags::ConstraintGamma1, Tags::ConstraintGamma2>;
      51           0 :   using argument_tags = tmpl::list<domain::Tags::Mesh<Dim>>;
      52             : 
      53           0 :   static void apply(const gsl::not_null<Scalar<DataVector>*> gamma1,
      54             :                     const gsl::not_null<Scalar<DataVector>*> gamma2,
      55             :                     const Mesh<Dim>& mesh) {
      56             :     const size_t number_of_grid_points = mesh.number_of_grid_points();
      57             :     *gamma1 = Scalar<DataVector>{number_of_grid_points, 0.};
      58             :     *gamma2 = Scalar<DataVector>{number_of_grid_points, 1.};
      59             :   }
      60             : };
      61             : 
      62             : /*!
      63             :  * \brief Analytic initial data for scalar waves in curved spacetime
      64             :  *
      65             :  * \details When evolving a scalar field propagating through curved spacetime,
      66             :  * this mutator initializes the scalar field and spacetime variables using
      67             :  *
      68             :  * 1. analytic solution(s) or data of the flat or curved scalar wave equation
      69             :  * for the evolution variables
      70             :  * 2. solutions of the Einstein equations for the spacetime background.
      71             :  *
      72             :  * If the scalar field initial data returns `CurvedScalarWave` tags, \f$\Psi\f$,
      73             :  * \f$\Pi\f$ and \f$\Phi_i\f$ will simply be forwarded from the initial data
      74             :  * class. Alternatively, the scalar field initial data can be provided using any
      75             :  * member class of `ScalarWave::Solutions` which return `ScalarWave` tags. In
      76             :  * this case, \f$\Phi_i\f$ and \f$\Psi\f$ will also be forwarded but
      77             :  * \f$\Pi\f$ will be adjusted to account for the curved background. Its
      78             :  * definition comes from requiring it to be the future-directed time derivative
      79             :  * of the scalar field in curved spacetime:
      80             :  *
      81             :  * \f{align}
      82             :  * \Pi :=& -n^a \partial_a \Psi \\
      83             :  *     =&  \frac{1}{\alpha}\left(\beta^k \Phi_k - {\partial_t\Psi}\right),\\
      84             :  *     =&  \frac{1}{\alpha}\left(\beta^k \Phi_k + {\Pi}_{\mathrm{flat}}\right),
      85             :  * \f}
      86             :  *
      87             :  * where \f$n^a\f$ is the unit normal to spatial slices of the spacetime
      88             :  * foliation, and \f${\Pi}_{\mathrm{flat}}\f$ comes from the flat spacetime
      89             :  * solution.
      90             :  *
      91             :  * DataBox changes:
      92             :  * - Adds: nothing
      93             :  * - Removes: nothing
      94             :  * - Modifies: Tags::Variables<tmpl::list<CurvedScalarWave::Tags::Psi,
      95             :  * CurvedScalarWave::Tags::Pi, CurvedScalarWave::Tags::Phi<Dim>>>
      96             :  */
      97             : template <size_t Dim, typename DerivedClasses>
      98           1 : struct InitializeEvolvedVariables : tt::ConformsTo<db::protocols::Mutator> {
      99           0 :   using flat_variables_tag = typename ScalarWave::System<Dim>::variables_tag;
     100           0 :   using curved_variables_tag =
     101             :       typename CurvedScalarWave::System<Dim>::variables_tag;
     102             : 
     103           0 :   using return_tags = tmpl::list<curved_variables_tag>;
     104           0 :   using argument_tags =
     105             :       tmpl::list<::Tags::Time, domain::Tags::Coordinates<Dim, Frame::Inertial>,
     106             :                  evolution::initial_data::Tags::InitialData,
     107             :                  gr::Tags::Lapse<DataVector>, gr::Tags::Shift<DataVector, Dim>>;
     108             : 
     109           0 :   static void apply(
     110             :       const gsl::not_null<typename curved_variables_tag::type*> evolved_vars,
     111             :       const double initial_time,
     112             :       const tnsr::I<DataVector, Dim>& inertial_coords,
     113             :       const evolution::initial_data::InitialData& solution_or_data,
     114             :       [[maybe_unused]] const Scalar<DataVector>& lapse,
     115             :       [[maybe_unused]] const tnsr::I<DataVector, Dim>& shift) {
     116             :     call_with_dynamic_type<void, DerivedClasses>(
     117             :         &solution_or_data,
     118             :         [&evolved_vars, initial_time, &inertial_coords, &lapse,
     119             :          &shift]<typename InitialDataSubclass>(
     120             :             const InitialDataSubclass* const data_or_solution) {
     121             :           if constexpr (is_analytic_data_v<InitialDataSubclass> or
     122             :                         is_analytic_solution_v<InitialDataSubclass>) {
     123             :             if constexpr (tmpl::list_contains_v<
     124             :                               typename InitialDataSubclass::tags,
     125             :                               CurvedScalarWave::Tags::Psi>) {
     126             :               (void)lapse, (void)shift;
     127             :               evolved_vars->assign_subset(
     128             :                   evolution::Initialization::initial_data(
     129             :                       *data_or_solution, inertial_coords, initial_time,
     130             :                       typename curved_variables_tag::tags_list{}));
     131             :             } else {
     132             :               static_assert(
     133             :                   tmpl::list_contains_v<typename InitialDataSubclass::tags,
     134             :                                         ScalarWave::Tags::Psi>,
     135             :                   "The initial data class must either calculate ScalarWave "
     136             :                   "or CurvedScalarWave variables.");
     137             :               const auto initial_data = evolution::Initialization::initial_data(
     138             :                   *data_or_solution, inertial_coords, initial_time,
     139             :                   typename flat_variables_tag::tags_list{});
     140             : 
     141             :               get<CurvedScalarWave::Tags::Psi>(*evolved_vars) =
     142             :                   get<ScalarWave::Tags::Psi>(initial_data);
     143             :               get<CurvedScalarWave::Tags::Phi<Dim>>(*evolved_vars) =
     144             :                   get<ScalarWave::Tags::Phi<Dim>>(initial_data);
     145             :               const auto shift_dot_dpsi = dot_product(
     146             :                   shift, get<ScalarWave::Tags::Phi<Dim>>(initial_data));
     147             :               get(get<CurvedScalarWave::Tags::Pi>(*evolved_vars)) =
     148             :                   (get(shift_dot_dpsi) +
     149             :                    get(get<ScalarWave::Tags::Pi>(initial_data))) /
     150             :                   get(lapse);
     151             :             }
     152             :           } else {
     153             :             ERROR(
     154             :                 "Trying to use "
     155             :                 "'evolution::Initialization::Actions::SetVariables' with a "
     156             :                 "class that's not marked as analytic solution or analytic "
     157             :                 "data. To support numeric initial data, add a "
     158             :                 "system-specific initialization routine to your executable.");
     159             :           }
     160             :         });
     161             :   }
     162             : };
     163             : }  // namespace CurvedScalarWave::Initialization