Source code for struphy.propagators.sound_wave_linear

import logging
from dataclasses import dataclass

from feectools.linalg.solvers import inverse
from line_profiler import profile
from maybempi import MPI

from struphy.feec import preconditioner
from struphy.io.options import LiteralOptions, OptionsBase
from struphy.linear_algebra.schur_solver import SchurSolver
from struphy.linear_algebra.solver import SolverParameters
from struphy.models.variables import FEECVariable
from struphy.propagators.base import Propagator
from struphy.propagators.utils import SoundWaveSchurPreconditioner
from struphy.utils.utils import check_option

logger = logging.getLogger("struphy")


[docs] class SoundWaveLinear(Propagator): r"""Energy conserving sound wave step of linear MHD (zero-flow equilibrium): velocity and pressure perturbations, with the density perturbation carried along. **Continuous problem.** Find :math:`\tilde{\mathbf U} \in H(\textnormal{div})`, :math:`\tilde p \in L^2` and :math:`\tilde \rho \in L^2` such that .. math:: \int_\Omega \rho_0 \frac{\partial \tilde{\mathbf U}}{\partial t} \cdot \mathbf V \,\textnormal d \mathbf x - \int_\Omega \tilde p \, \nabla \cdot \mathbf V \,\textnormal d \mathbf x &= 0 \qquad \forall \, \mathbf V \in H(\textnormal{div})\,, \\[2mm] \int_\Omega \frac{1}{p_0} \frac{\partial \tilde p}{\partial t} \, q \,\textnormal d \mathbf x + \gamma \int_\Omega \nabla \cdot \tilde{\mathbf U} \, q \,\textnormal d \mathbf x &= 0 \qquad \forall \, q \in L^2\,, \\[2mm] \frac{\partial \tilde{\rho}}{\partial t} + \nabla\cdot(\rho_0 \tilde{\mathbf{U}}) &= 0\,, with :math:`\gamma = 5/3`. The momentum equation is weak (integration by parts of the pressure gradient; with free boundary conditions this imposes :math:`\tilde p = 0` weakly), the pressure equation is the :math:`1/p_0`-weighted :math:`L^2` projection of :math:`\partial_t \tilde p = - \gamma p_0 \nabla \cdot \tilde{\mathbf U}` and the continuity equation holds strongly. The first two equations conserve the energy .. math:: \frac 12 \int_\Omega \rho_0 |\tilde{\mathbf U}|^2 \,\textnormal d \mathbf x + \frac{1}{2\gamma} \int_\Omega \frac{\tilde p^2}{p_0} \,\textnormal d \mathbf x\,. The remaining term :math:`- \tilde{\mathbf U} \cdot \nabla p_0` of the linear pressure equation is the step :class:`~struphy.propagators.background_pressure_gradient.BackgroundPressureGradient`. **Semi-discrete problem.** With the FE coefficients :math:`\mathbf u` of :math:`\tilde{\mathbf U}_h \in V^2_h` and :math:`\mathbf p`, :math:`\mathbf n` of :math:`\tilde p_h, \tilde \rho_h \in V^3_h`, .. math:: \mathbb M^2_{\rho_0} \dot{\mathbf u} = \mathbb D^\top \mathbb M^3 \mathbf p\,, \qquad \mathbb M^3_{1/p_0} \dot{\mathbf p} = - \gamma \, \mathbb M^3 \mathbb D \mathbf u\,, \qquad \dot{\mathbf n} = - \mathbb D \mathbb Q^2 \mathbf u\,, with the discrete divergence :math:`\mathbb D` (:attr:`~struphy.feec.psydac_derham.Derham.div`), the mass matrix :math:`\mathbb M^3` (:attr:`~struphy.feec.mass.WeightedMassOperators.M3`), the weighted mass matrices :math:`\mathbb M^2_{\rho_0}` (:attr:`~struphy.feec.mass.WeightedMassOperators.M2n`) and :math:`\mathbb M^3_{1/p_0}` (:attr:`~struphy.feec.mass.WeightedMassOperators.M3p_inv`), and the basis projection operator :math:`\mathbb Q^2 \approx \hat \Pi^2[\rho_0 \,\cdot\,]` (:attr:`~struphy.feec.basis_projection_ops.BasisProjectionOperators.Q2`). It conserves the discrete energy :math:`\frac 12 \mathbf u^\top \mathbb M^2_{\rho_0} \mathbf u + \frac{1}{2\gamma} \mathbf p^\top \mathbb M^3_{1/p_0} \mathbf p`. **Time discretization.** Crank-Nicolson (implicit mid-point), the only option, which conserves the discrete energy exactly (up to the solver tolerances). The pressure is eliminated with :class:`~struphy.linear_algebra.schur_solver.SchurSolver` (:math:`x = \mathbf u`, :math:`y = \mathbf p`), with the symmetric positive definite Schur complement .. math:: S = \mathbb M^2_{\rho_0} + \frac{\gamma \Delta t^2}{4} \mathbb D^\top \mathbb M^3 (\mathbb M^3_{1/p_0})^{-1} \mathbb M^3 \mathbb D\,, solved by ``Options.solver``, where :math:`(\mathbb M^3_{1/p_0})^{-1}` is an inner iterative solve (``Options.solver_M3``, ``Options.precond_M3``). The preconditioner ``Options.precond`` is either the Kronecker (fast diagonalization) preconditioner of the whole Schur complement (``"StiffnessPreconditioner"``), with :math:`\mathbb M^3 (\mathbb M^3_{1/p_0})^{-1} \mathbb M^3` approximated by the pressure-weighted mass matrix :math:`\mathbb M^3_{p_0}` (:attr:`~struphy.feec.mass.WeightedMassOperators.M3p`), .. math:: S \approx \mathbb M^2_{\rho_0} + \frac{\gamma \Delta t^2}{4} \mathbb D^\top \mathbb M^3_{p_0} \mathbb D\,, i.e. :class:`~struphy.propagators.utils.SoundWaveSchurPreconditioner`: :class:`~struphy.feec.preconditioner.StiffnessPreconditioner` for the divergence, with or without the correction on the kernel of :math:`\mathbb D` (``Options.kernel_correction``; by default the faster one is chosen by trial for each new time step size), and with polar splines its 2D x 1D version :class:`~struphy.feec.preconditioner.PolarKroneckerBlockPreconditioner`, rebuilt when the time step size changes (the default ``precond``); or the mass matrix preconditioner of :math:`\mathbb M^2_{\rho_0}` alone. ITPA TAE of LinearMHD (4 MPI ranks, low beta, without the correction): 3-5 instead of 6-7 iterations and twice as fast on 24 x 88 x 8 tensor-product elements, 3 instead of 11 iterations and 3.3 times as fast on 24 x 48 x 8 polar elements. Then .. math:: \mathbf p^{n+1} = \mathbf p^n - \frac{\gamma \Delta t}{2} (\mathbb M^3_{1/p_0})^{-1} \mathbb M^3 \mathbb D (\mathbf u^{n+1} + \mathbf u^n)\,, \qquad \mathbf n^{n+1} = \mathbf n^n - \frac{\Delta t}{2} \mathbb D \mathbb Q^2 (\mathbf u^{n+1} + \mathbf u^n)\,. """
[docs] class Variables: """Container for variables advanced by :class:`SoundWaveLinear`. Attributes ---------- n : FEECVariable Density perturbation variable in ``"L2"`` space. u : FEECVariable Velocity perturbation variable in ``"Hdiv"`` space. p : FEECVariable Pressure perturbation variable in ``"L2"`` space. """ def __init__(self): self._n: FEECVariable = None self._u: FEECVariable = None self._p: FEECVariable = None @property def n(self) -> FEECVariable: return self._n @n.setter def n(self, new): assert isinstance(new, FEECVariable) assert new.space == "L2" self._n = new @property def u(self) -> FEECVariable: return self._u @u.setter def u(self, new): assert isinstance(new, FEECVariable) assert new.space == "Hdiv" self._u = new @property def p(self) -> FEECVariable: return self._p @p.setter def p(self, new): assert isinstance(new, FEECVariable) assert new.space == "L2" self._p = new
def __init__(self): self.variables = self.Variables()
[docs] @dataclass(repr=False) class Options(OptionsBase): """Configuration options for :class:`SoundWaveLinear`. Parameters ---------- solver : LiteralOptions.OptsSymmSolver, default="pcg" Iterative solver of the (symmetric) Schur complement. precond : LiteralOptions.OptsSoundWavePrecond, default="StiffnessPreconditioner" Preconditioner of the Schur complement: the Kronecker preconditioner of the whole Schur complement (``"StiffnessPreconditioner"``, polar with polar splines), or the mass matrix preconditioner of :math:`\\mathbb M^2_{\\rho_0}` (``M2n``; ``"PolarMassMatrixPreconditioner"`` with polar splines). Ignored (with a warning) with ``solver="cg"``, which takes no preconditioner. kernel_correction : bool | str, default="auto" With ``precond="StiffnessPreconditioner"`` and tensor-product splines: whether to add the correction of :class:`~struphy.feec.preconditioner.StiffnessPreconditioner` on the kernel of the divergence. It pays off where the stiffness term dominates (high beta, large time steps: 19 instead of 42 iterations at beta = 1, dt = 0.5) and costs where the mass term does (low beta: twice as many iterations on the ITPA TAE). ``"auto"``: for each new time step size, the first solve is made without and the second with the correction, and the one with fewer iterations is kept (the steps agree to the solver tolerance either way). solver_params : SolverParameters, default=None Controls of the Schur complement solve; defaults to ``SolverParameters()``. solver_M3 : LiteralOptions.OptsSymmSolver, default="pcg" Solver of the inner ``M3p_inv`` inversion. precond_M3 : LiteralOptions.OptsMassPrecond, default="MassMatrixPreconditioner" Preconditioner of the inner ``M3p_inv`` inversion. solver_params_M3 : SolverParameters, default=None Controls of the inner ``M3p_inv`` inversion; defaults to ``SolverParameters(tol=1e-14)`` (the outer Krylov solver and the energy conservation need an accurate inner inverse). """ solver: LiteralOptions.OptsSymmSolver = "pcg" precond: LiteralOptions.OptsSoundWavePrecond = "StiffnessPreconditioner" kernel_correction: bool | str = "auto" solver_params: SolverParameters = None solver_M3: LiteralOptions.OptsSymmSolver = "pcg" precond_M3: LiteralOptions.OptsMassPrecond = "MassMatrixPreconditioner" solver_params_M3: SolverParameters = None def __post_init__(self): # checks check_option(self.solver, LiteralOptions.OptsSymmSolver) check_option(self.precond, LiteralOptions.OptsSoundWavePrecond) check_option(self.solver_M3, LiteralOptions.OptsSymmSolver) check_option(self.precond_M3, LiteralOptions.OptsMassPrecond) assert self.kernel_correction in (True, False, "auto"), ( f'kernel_correction must be True, False or "auto", got {self.kernel_correction!r}.' ) # defaults if self.solver_params is None: self.solver_params = SolverParameters() if self.solver_params_M3 is None: self.solver_params_M3 = SolverParameters(tol=1e-14)
@property def options(self) -> Options: if not hasattr(self, "_options"): self._options = self.Options() return self._options @options.setter def options(self, new): assert isinstance(new, self.Options) self._options = new logger.info(f"\nNew options for propagator '{self.__class__.__name__}':\n{self._options}") @property def gamma(self) -> float: """Adiabatic index.""" return 5 / 3 @profile def allocate(self): self._info = self.options.solver_params.info _A = self.mass_ops.M2n _M3 = self.mass_ops.M3 div = self.derham.div # inverse of M3p_inv (inner solve) if self.options.precond_M3 is None: pc_M3 = None else: pc_M3 = getattr(preconditioner, self.options.precond_M3)(self.mass_ops.M3p_inv) self._M3p_inv_inv = inverse( self.mass_ops.M3p_inv, self.options.solver_M3, pc=pc_M3, tol=self.options.solver_params_M3.tol, maxiter=self.options.solver_params_M3.maxiter, verbose=self.options.solver_params_M3.verbose, ) # block matrix [[A B], [C I]] (without time step size dt in the off-diagonals) self._B = -1 / 2 * div.T @ _M3 self._C = self.gamma / 2 * self._M3p_inv_inv @ _M3 @ div self._DQ = div @ self.basis_ops.Q2 # preconditioner: the Kronecker preconditioner of the Schur complement is built for the time step at the first # call (and rebuilt when it changes) self._precond = self.options.precond if self._precond is not None and self.options.solver == "cg": logger.warning( f'solver="cg" of SoundWaveLinear takes no preconditioner; precond="{self._precond}" ignored.' ) self._precond = None self._schur_pc = None if self._precond is None or self._precond == "StiffnessPreconditioner": pc = None else: pc = getattr(preconditioner, self._precond)(_A) if self._precond == "StiffnessPreconditioner": self._schur_pc = SoundWaveSchurPreconditioner( self.derham, self.mass_ops, self.gamma, self.options.kernel_correction, "SoundWaveLinear" ) self._schur_solver = SchurSolver( _A, self._B @ self._C, self.options.solver, precond=pc, solver_params=self.options.solver_params, ) # allocate dummy vectors to avoid temporary array allocations self._u_tmp1 = self.variables.u.spline.vector.space.zeros() self._u_tmp2 = self.variables.u.spline.vector.space.zeros() self._p_tmp1 = self.variables.p.spline.vector.space.zeros() self._n_tmp1 = self.variables.n.spline.vector.space.zeros() self._byn = self._B.codomain.zeros() @profile def __call__(self, dt): # current FE coeffs nn = self.variables.n.spline.vector un = self.variables.u.spline.vector pn = self.variables.p.spline.vector if self._schur_pc is not None: self._schur_pc.update(self._schur_solver, dt) # solve for new u coeffs byn = self._B.dot(pn, out=self._byn) un1, info = self._schur_solver(un, byn, dt, out=self._u_tmp1) if self._schur_pc is not None: self._schur_pc.record(self._schur_solver, info) # new p and n coeffs from the mid-point velocity _u = un.copy(out=self._u_tmp2) _u += un1 pn1 = self._C.dot(_u, out=self._p_tmp1) pn1 *= -dt pn1 += pn # the inner solve is ill-conditioned where p0 is small (e.g. p0 = 0 at a wall): warn if it did not converge info_M3 = self._M3p_inv_inv.get_info() if not info_M3["success"] and MPI.COMM_WORLD.Get_rank() == 0: logger.warning(f"Inner M3p_inv solve of SoundWaveLinear not converged in {info_M3['niter']} iterations.") nn1 = self._DQ.dot(_u, out=self._n_tmp1) nn1 *= -dt / 2 nn1 += nn diffs = self.update_feec_variables(n=nn1, u=un1, p=pn1) if self._info and MPI.COMM_WORLD.Get_rank() == 0: logger.info(f"Status for SoundWaveLinear: {info['success']}") logger.info(f"Iterations for SoundWaveLinear: {info['niter']}") logger.info(f"Iterations of the inner M3p_inv solve (last) for SoundWaveLinear: {info_M3['niter']}") logger.info(f"Maxdiff n3 for SoundWaveLinear: {diffs['n']}") logger.info(f"Maxdiff u2 for SoundWaveLinear: {diffs['u']}") logger.info(f"Maxdiff p3 for SoundWaveLinear: {diffs['p']}") logger.info("")