Cce::InitializeJ::CauchySecondOrder Struct Reference

Initialize \(J\) on the first hypersurface by second-order Cauchy matching at the worldtube. More...

#include <CauchySecondOrder.hpp>

Classes
struct	DuDrJInterpolator
struct	J0MaxIterations
struct	J2MaxIterations
struct	J2Tolerance
struct	MaxCauchyJ0
struct	MaxPartiallyFlatJ0
struct	MaxPartiallyFlatJ2

Public Types
using	options
using	return_tags
using	argument_tags
Public Types inherited from Cce::InitializeJ::InitializeJ< false >
using	boundary_tags
using	mutate_tags
using	return_tags = mutate_tags
using	argument_tags
using	creatable_classes

Public Member Functions
	WRAPPED_PUPable_decl_template (CauchySecondOrder)
	CauchySecondOrder (CkMigrateMessage *)
	CauchySecondOrder (double max_partially_flat_j0, size_t j0_max_iterations, double max_cauchy_j0, double j2_tolerance, size_t j2_max_iterations, double max_partially_flat_j2, std::unique_ptr< intrp::SpanInterpolator > du_dr_j_interpolator)
std::unique_ptr< InitializeJ >	get_clone () const override
std::unique_ptr< intrp::SpanInterpolator >	du_dr_j_interpolator () const override
	The interpolator this generator wants used to build the worldtube boundary value of \(\partial_u \partial_r J\), or nullptr to use the evolution's H5Interpolator.
void	operator() (gsl::not_null< Scalar< SpinWeighted< ComplexDataVector, 2 > > * > j, gsl::not_null< tnsr::i< DataVector, 3 > * > cartesian_cauchy_coordinates, gsl::not_null< tnsr::i< DataVector, 2, ::Frame::Spherical<::Frame::Inertial > > * > angular_cauchy_coordinates, const Scalar< SpinWeighted< ComplexDataVector, 2 > > &boundary_j, const Scalar< SpinWeighted< ComplexDataVector, 1 > > &boundary_u, const Scalar< SpinWeighted< ComplexDataVector, 0 > > &boundary_w, const Scalar< SpinWeighted< ComplexDataVector, 0 > > &boundary_beta, const Scalar< SpinWeighted< ComplexDataVector, 1 > > &boundary_q, const Scalar< SpinWeighted< ComplexDataVector, 2 > > &boundary_du_j, const Scalar< SpinWeighted< ComplexDataVector, 2 > > &boundary_dr_j, const Scalar< SpinWeighted< ComplexDataVector, 2 > > &boundary_du_dr_j, const Scalar< SpinWeighted< ComplexDataVector, 0 > > &boundary_du_r, const Scalar< SpinWeighted< ComplexDataVector, 0 > > &r, size_t l_max, size_t number_of_radial_points, gsl::not_null< Parallel::NodeLock * > hdf5_lock) const
void	pup (PUP::er &p) override
Public Member Functions inherited from Cce::InitializeJ::InitializeJ< false >
	InitializeJ (CkMigrateMessage *)
	WRAPPED_PUPable_abstract (InitializeJ)
template<typename DbTags>
void	operator() (const gsl::not_null< db::DataBox< DbTags > * > box, const gsl::not_null< Parallel::NodeLock * > hdf5_lock) const

Static Public Attributes
static constexpr size_t	max_potential_iterations = 20
	The largest number of iterations of the potential solve. It reaches its minimum within a few, so this cap only bounds its cost on data it cannot solve.
static constexpr Options::String	help
static constexpr size_t	j0_plateau_sweeps = 50
	The linearized sweeps continue while the smallest \(\max|\breve J^{(0)}|\) reached improves by at least the fraction j0_plateau_improvement over j0_plateau_sweeps sweeps.
static constexpr double	j0_plateau_improvement = 1.0e-2
	The linearized sweeps continue while the smallest \(\max|\breve J^{(0)}|\) reached improves by at least the fraction j0_plateau_improvement over j0_plateau_sweeps sweeps.

Detailed Description

Initialize \(J\) on the first hypersurface by second-order Cauchy matching at the worldtube.

Details

Here \(\tilde J\) denotes \(J\) in the Cauchy coordinates and \(\breve J\) its counterpart in the partially flat coordinates, and \(\tilde J^{(n)}\) and \(\breve J^{(n)}\) are their coefficients of \((1 - \tilde y)^n\), where \(\tilde y = 1 - 2R/r\) is the compactified radial coordinate and \(R\) the worldtube radius. The initial data must satisfy the partially flat conditions \(\breve J^{(0)} = 0\) and \(\breve J^{(2)} = 0\). They are constructed in three steps:

1. Match the initial \(\tilde J\) to the worldtube value and its first two radial derivatives in the Cauchy gauge, using the ansatz of CauchySecondOrder_detail::radial_ansatz_coefficients, and solve the fixed-point problem that the remaining condition \(\breve J^{(2)} = 0\) poses for \(x = \tilde J^{(2)}\) (CauchySecondOrder_detail::solve_asymptotic_j2). The worldtube \(\partial_{\tilde y}^2 \tilde J|_\Gamma\) is obtained by inverting the \(H\)-hypersurface equation at the worldtube (CauchySecondOrder_detail::compute_dy_dy_j).
2. Use the resulting \(\tilde J^{(0)}\) to solve the Beltrami problem \(\breve J^{(0)} = 0\) for the initial angular map, as described below.
3. Transform the whole profile into the partially flat gauge with this map (GaugeAdjustInitialJ).

In step 2, \(\breve J^{(0)} = 0\) specifies the target angular Jacobian

\begin{align*} \hat a_\star = -\frac{\bar{\hat b}_\star\, \tilde J^{(0)}} {1 + \tilde K^{(0)}}, \qquad \tilde K^{(0)} = \sqrt{1 + \big|\tilde J^{(0)}\big|^2} \end{align*}

at every point of the sphere, where \(\hat a\) and \(\hat b\) are the spin-weighted Jacobian factors of the angular map ( \(\hat c\) and \(\hat d\) in GaugeUpdateJacobianFromCoordinates). The map is recovered iteratively, in up to two stages that together take at most J0MaxIterations iterations. A potential-based solve (detail::adapt_angular_coordinates_via_potential) generates each displacement of the Cartesian coordinates \(\hat x^i\) of the map from a single spin-weight-1 potential \(\eta\),

\begin{align*} \delta \hat x^i = \mathrm{Re}\big(\eta\, \overline{\eth \hat x^i}\big), \qquad \eta = \eth^{-1}\big(\hat a_\star - \hat a\big), \end{align*}

and runs to its minimum residual, which takes a few iterations. If that brings \(\max|\breve J^{(0)}|\) within MaxPartiallyFlatJ0, its map is the solution. Otherwise linearized sweeps (detail::iteratively_adapt_angular_coordinates) continue from it until the smallest \(\max|\breve J^{(0)}|\) reached has improved by less than 1% over the last 50 sweeps, or until the two stages together have taken J0MaxIterations iterations. Both stages keep the best map they evaluated.

Initialization aborts if \(\max|\tilde J^{(0)}(0)|\), or \(\max|\breve J^{(0)}|\) at any iteration of step 2, exceeds MaxCauchyJ0, or if the fixed-point iteration of step 1 does not reach J2Tolerance within J2MaxIterations iterations. After step 3 it prints a summary of steps 1 and 2 and of \(\max|\breve J^{(0)}|\) and \(\max|\breve J^{(2)}|\), and aborts if either exceeds its bound, MaxPartiallyFlatJ0 or MaxPartiallyFlatJ2.

The worldtube \(\partial_{\tilde u}\partial_r J|_\Gamma\) that enters the \(H\)-hypersurface equation is obtained by differentiating an interpolant of the worldtube \(\partial_r J|_\Gamma\) in time with DuDrJInterpolator, which this generator supplies to the worldtube data manager. It is separate from the evolution's H5Interpolator because the match wants a low interpolation order for that derivative while the evolution wants a high one for the values it interpolates every step.

Member Typedef Documentation

argument_tags

using Cce::InitializeJ::CauchySecondOrder::argument_tags

Initial value:

 tmpl::list<
      Tags::BoundaryValue<Tags::BondiJ>, Tags::BoundaryValue<Tags::BondiU>,
      Tags::BoundaryValue<Tags::BondiW>, Tags::BoundaryValue<Tags::BondiBeta>,
      Tags::BoundaryValue<Tags::BondiQ>,
      Tags::BoundaryValue<Tags::Du<Tags::BondiJ>>,
      Tags::BoundaryValue<Tags::Dr<Tags::BondiJ>>,
      Tags::BoundaryValue<Tags::Du<Tags::Dr<Tags::BondiJ>>>,
      Tags::BoundaryValue<Tags::Du<Tags::BondiR>>,
      Tags::BoundaryValue<Tags::BondiR>, Tags::LMax,
      Tags::NumberOfRadialPoints>

options

using Cce::InitializeJ::CauchySecondOrder::options

Initial value:

 
      tmpl::list<MaxPartiallyFlatJ0, J0MaxIterations, MaxCauchyJ0, J2Tolerance,
                 J2MaxIterations, MaxPartiallyFlatJ2, DuDrJInterpolator>

return_tags

using Cce::InitializeJ::CauchySecondOrder::return_tags

Initial value:

 tmpl::list<Tags::BondiJ, Tags::CauchyCartesianCoords,
                                 Tags::CauchyAngularCoords>

Member Function Documentation

du_dr_j_interpolator()

std::unique_ptr< intrp::SpanInterpolator > Cce::InitializeJ::CauchySecondOrder::du_dr_j_interpolator ( ) const

overridevirtual

The interpolator this generator wants used to build the worldtube boundary value of \(\partial_u \partial_r J\), or nullptr to use the evolution's H5Interpolator.

Details

That boundary value is consumed by the initial data alone, so a generator is free to choose its own time-interpolation order for it without affecting the evolution.

Reimplemented from Cce::InitializeJ::InitializeJ< false >.

get_clone()

std::unique_ptr< InitializeJ > Cce::InitializeJ::CauchySecondOrder::get_clone ( ) const

overridevirtual

Implements Cce::InitializeJ::InitializeJ< false >.

Member Data Documentation

help

Options::String Cce::InitializeJ::CauchySecondOrder::help

staticconstexpr

Initial value:

= {
      "Second-order initial data generator for the Cauchy CCE evolution."}

---

The documentation for this struct was generated from the following file:

• src/Evolution/Systems/Cce/Initialize/CauchySecondOrder.hpp