ngsolve 6.2.2506.post74.dev0__cp314-cp314-macosx_10_15_universal2.whl

ngsolve/nonlinearsolvers.pyi

@@ -0,0 +1,95 @@
+from __future__ import annotations
+from math import sqrt
+from netgen import TimeFunction
+from ngsolve.bla import Norm
+from ngsolve.la import InnerProduct
+from ngsolve.la import Projector
+__all__: list[str] = ['InnerProduct', 'Newton', 'NewtonMinimization', 'NewtonSolver', 'Norm', 'Projector', 'TimeFunction', 'sqrt']
+class NewtonSolver:
+    @staticmethod
+    def Solve(*args, **kwargs):
+        ...
+    def SetDirichlet(self, dirichletvalues):
+        ...
+    def _UpdateInverse(self):
+        ...
+    def __init__(self, a, u, rhs = None, freedofs = None, inverse = '', solver = None, lin_solver_cls = None, lin_solver_args = None):
+        ...
+def Newton(a, u, freedofs = None, maxit = 100, maxerr = 1e-11, inverse = '', dirichletvalues = None, dampfactor = 1, printing = True, callback = None):
+    """
+    
+    Newton's method for solving non-linear problems of the form A(u)=0.
+    
+    Parameters
+    ----------
+    a : BilinearForm
+      The BilinearForm of the non-linear variational problem. It does not have to be assembled.
+    
+    u : GridFunction
+      The GridFunction where the solution is saved. The values are used as initial guess for Newton's method.
+    
+    freedofs : BitArray
+      The FreeDofs on which the assembled matrix is inverted. If argument is 'None' then the FreeDofs of the underlying FESpace is used.
+    
+    maxit : int
+      Number of maximal iteration for Newton. If the maximal number is reached before the maximal error Newton might no converge and a warning is displayed.
+    
+    maxerr : float
+      The maximal error which Newton should reach before it stops. The error is computed by the square root of the inner product of the residuum and the correction.
+    
+    inverse : string
+      A string of the sparse direct solver which should be solved for inverting the assembled Newton matrix.
+    
+    dampfactor : float
+      Set the damping factor for Newton's method. If dampfactor is 1 then no damping is done. If value is < 1 then the damping is done by the formula 'min(1,dampfactor*numit)' for the correction, where 'numit' denotes the Newton iteration.
+    
+    printing : bool
+      Set if Newton's method should print informations about the actual iteration like the error. 
+    
+    Returns
+    -------
+    (int, int)
+      List of two integers. The first one is 0 if Newton's method did converge, -1 otherwise. The second one gives the number of Newton iterations needed.
+    
+    """
+def NewtonMinimization(a, u, freedofs = None, maxit = 100, maxerr = 1e-11, inverse = '', dampfactor = 1, linesearch = False, printing = True, callback = None):
+    """
+    
+    Newton's method for solving non-linear problems of the form A(u)=0 involving energy integrators.
+    
+    
+    Parameters
+    ----------
+    a : BilinearForm
+      The BilinearForm of the non-linear variational problem. It does not have to be assembled.
+    
+    u : GridFunction
+      The GridFunction where the solution is saved. The values are used as initial guess for Newton's method.
+    
+    freedofs : BitArray
+      The FreeDofs on which the assembled matrix is inverted. If argument is 'None' then the FreeDofs of the underlying FESpace is used.
+    
+    maxit : int
+      Number of maximal iteration for Newton. If the maximal number is reached before the maximal error Newton might no converge and a warning is displayed.
+    
+    maxerr : float
+      The maximal error which Newton should reach before it stops. The error is computed by the square root of the inner product of the residuum and the correction.
+    
+    inverse : string
+      A string of the sparse direct solver which should be solved for inverting the assembled Newton matrix.
+    
+    dampfactor : float
+      Set the damping factor for Newton's method. If dampfactor is 1 then no damping is done. If value is < 1 then the damping is done by the formula 'min(1,dampfactor*numit)' for the correction, where 'numit' denotes the Newton iteration.
+    
+    linesearch : bool
+      If True then linesearch is used to guarantee that the energy decreases in every Newton iteration.
+    
+    printing : bool
+      Set if Newton's method should print informations about the actual iteration like the error. 
+    
+    Returns
+    -------
+    (int, int)
+      List of two integers. The first one is 0 if Newton's method did converge, -1 otherwise. The second one gives the number of Newton iterations needed.
+    
+    """

ngsolve/preconditioners.py

@@ -0,0 +1,11 @@
+from ngsolve.comp import MultiGridPreconditioner as MultiGrid
+from ngsolve.comp import LocalPreconditioner as Local
+from ngsolve.comp import HCurlAMG
+from ngsolve.comp import H1AMG
+from ngsolve.comp import BDDCPreconditioner as BDDC
+
+
+
+
+
+

ngsolve/preconditioners.pyi

@@ -0,0 +1,7 @@
+from __future__ import annotations
+from ngsolve.comp import BDDCPreconditioner as BDDC
+from ngsolve.comp import H1AMG
+from ngsolve.comp import HCurlAMG
+from ngsolve.comp import LocalPreconditioner as Local
+from ngsolve.comp import MultiGridPreconditioner as MultiGrid
+__all__: list[str] = ['BDDC', 'H1AMG', 'HCurlAMG', 'Local', 'MultiGrid']

ngsolve/solve.pyi

@@ -0,0 +1,109 @@
+"""
+pybind solve
+"""
+from __future__ import annotations
+import collections.abc
+import ngsolve.comp
+import ngsolve.fem
+import typing
+__all__: list[str] = ['Draw', 'SetVisualization', 'Tcl_Eval']
+@typing.overload
+def Draw(cf: ngsolve.fem.CoefficientFunction, mesh: ngsolve.comp.Mesh | ngsolve.comp.Region, name: str, sd: typing.SupportsInt = 2, autoscale: bool = True, min: typing.SupportsFloat = 0.0, max: typing.SupportsFloat = 1.0, draw_vol: bool = True, draw_surf: bool = True, reset: bool = False, title: str = '', number_format: str = '%.3e', unit: str = '', **kwargs) -> None:
+    """
+    Parameters:
+    
+    cf : ngsolve.comp.CoefficientFunction
+      input CoefficientFunction to draw
+    
+    mesh : ngsolve.comp.Mesh
+      input mesh
+    
+    name : string
+      input name
+    
+    sd : int
+      input subdivisions
+    
+    autoscale : bool
+      input autscale
+    
+    min : float
+      input minimum value. Need autoscale = false
+    
+    max : float
+      input maximum value. Need autoscale = false
+    
+    draw_vol : bool
+      input draw volume
+    
+    draw_surf : bool
+      input draw surface
+    
+    title : string
+      printed on top of colormap
+    
+    number_format : string
+      printf-style format string for numbers under colormap
+    
+    unit : string
+      string (ASCII only) to print after maximum value of colormap
+    """
+@typing.overload
+def Draw(gf: ngsolve.comp.GridFunction, sd: typing.SupportsInt = 2, autoscale: bool = True, min: typing.SupportsFloat = 0.0, max: typing.SupportsFloat = 1.0, **kwargs) -> None:
+    """
+    Parameters:
+    
+    gf : ngsolve.comp.GridFunction
+      input GridFunction to draw
+    
+    sd : int
+      input subdivisions
+    
+    autoscale : bool
+      input autscale
+    
+    min : float
+      input minimum value. Need autoscale = false
+    
+    max : float
+      input maximum value. Need autoscale = false
+    """
+@typing.overload
+def Draw(mesh: ngsolve.comp.Mesh, **kwargs) -> None:
+    ...
+@typing.overload
+def Draw(arg0: typing.Any) -> None:
+    ...
+def SetVisualization(deformation: bool | None = None, min: typing.SupportsFloat | None = None, max: typing.SupportsFloat | None = None, clipnormal: tuple | None = None, clipping: bool | None = None) -> None:
+    """
+    Set visualization options
+    
+    Parameters:
+    
+    deformation : object
+      input deformation
+    
+    min : object
+      input min
+    
+    max : object
+      input max
+    
+    clipnormal : object
+      input clipnormal
+    
+    clipping : object
+      input clipping
+    """
+def Tcl_Eval(arg0: str) -> None:
+    ...
+def _GetFacetValues(arg0: ngsolve.fem.CoefficientFunction, arg1: ngsolve.comp.Mesh, arg2: collections.abc.Mapping[ngsolve.fem.ET, ngsolve.fem.IntegrationRule]) -> dict:
+    ...
+def _GetValues(arg0: ngsolve.fem.CoefficientFunction, arg1: ngsolve.comp.Mesh, arg2: ngsolve.comp.VorB, arg3: collections.abc.Mapping[ngsolve.fem.ET, ngsolve.fem.IntegrationRule], arg4: bool) -> dict:
+    ...
+def _GetVisualizationData(arg0: ngsolve.comp.Mesh, arg1: collections.abc.Mapping[ngsolve.fem.ET, ngsolve.fem.IntegrationRule]) -> dict:
+    ...
+def _SetLocale() -> None:
+    ...
+def __Cleanup() -> None:
+    ...

ngsolve/solve_implementation.py

@@ -0,0 +1,168 @@
+import functools
+
+from ngsolve import (
+    BilinearForm,
+    GridFunction,
+    CoefficientFunction,
+    Region,
+    BND,
+    Preconditioner,
+)
+from .nonlinearsolvers import NewtonSolver
+from .krylovspace import GMResSolver, LinearSolver
+
+
+class Dirichlet:
+    def __init__(self, cf, region):
+        self.cf = cf
+        self.region = region
+
+
+class Application:
+    def __init__(self, a: BilinearForm, gf: GridFunction):
+        self.a = a
+        self.gf = gf
+
+    def Solve(
+        self,
+        rhs,
+        *args,
+        dirichlet = None,
+        pre = None,
+        printrates: bool = False,
+        **kwargs,
+    ):
+        raise NotImplementedError("Solve method must be implemented in subclasses")
+
+    def __eq__(self, other):
+        return Equation(self, other)
+
+
+class NonLinearApplication(Application):
+    def Solve(
+        self,
+        rhs=None,
+        dirichlet = None,
+        printing: bool = False,
+        **kwargs,
+    ):
+        solver_args = {}
+
+        if rhs is not None and rhs != 0:
+            rhs.Assemble()
+            solver_args["rhs"] = rhs
+        if "freedofs" in kwargs:
+            solver_args["freedofs"] = kwargs.pop("freedofs")
+        if "inverse" in kwargs:
+            solver_args["inverse"] = kwargs.pop("inverse")
+        solver = NewtonSolver(self.a, self.gf, **solver_args)
+        if dirichlet is not None:
+            dirichlet_gf = GridFunction(self.gf.space)
+            if isinstance(dirichlet, list):
+                for i in range(len(dirichlet)):
+                    if dirichlet[i] is not None:
+                        if isinstance(dirichlet[i], Dirichlet):
+                            dirichlet_gf.components[i].Set(
+                                dirichlet[i].cf, definedon=dirichlet[i].region
+                            )
+                        else:
+                            dirichlet_gf.components[i].Set(dirichlet[i], BND)
+            elif isinstance(dirichlet, Dirichlet):
+                dirichlet_gf.Set(dirichlet.cf, definedon=dirichlet.region)
+            else:
+                dirichlet_gf.Set(dirichlet, BND)
+            solver.SetDirichlet(dirichlet_gf.vec)
+        solver.Solve(printing=printing, **kwargs)
+
+
+class LinearApplication(Application):
+    def Assemble(self):
+        if not hasattr(self, "vec"):
+            self.vec = self.gf.vec.CreateVector()
+        self.a.Apply(self.gf.vec, self.vec)
+
+    def Solve(
+        self,
+        rhs,
+        *args,
+        dirichlet = None,
+        pre = None,
+        lin_solver=None,
+        lin_solver_args = None,
+        printrates: bool = False,
+    ):
+        self.a.Assemble()
+        for arg in args:
+            if isinstance(arg, Dirichlet) or isinstance(arg, CoefficientFunction):
+                assert dirichlet is None, "Only one dirichlet condition can be set"
+                dirichlet = arg
+            if isinstance(arg, Preconditioner):
+                assert pre is None, "Only one preconditioner can be set"
+                pre = arg
+            if isinstance(arg, type) and issubclass(arg, LinearSolver):
+                assert lin_solver is None, "Only one linear solver can be set"
+                lin_solver = arg
+        rhs.Assemble()
+        if dirichlet is not None:
+            if isinstance(dirichlet, list):
+                for i in range(len(dirichlet)):
+                    if dirichlet[i] is not None:
+                        if isinstance(dirichlet[i], Dirichlet):
+                            self.gf.components[i].Set(
+                                dirichlet[i].cf, definedon=dirichlet[i].region
+                            )
+                        else:
+                            self.gf.components[i].Set(dirichlet[i], BND)
+            elif isinstance(dirichlet, Dirichlet):
+                self.gf.Set(dirichlet.cf, definedon=dirichlet.region)
+            else:
+                self.gf.Set(dirichlet, BND)
+            rhs.vec.data += -self.a.mat * self.gf.vec
+        else:
+            self.gf.vec[:] = 0.0
+        if self.a.condense:
+            rhs.vec.data += self.a.harmonic_extension_trans * rhs.vec
+        if pre is None and lin_solver is None:
+            ainv = self.a.mat.Inverse(self.a.space.FreeDofs(self.a.condense))
+        else:
+            if lin_solver is None:
+                lin_solver = GMResSolver
+            if lin_solver_args is None:
+                lin_solver_args = {}
+            if pre is None:
+                freedofs = self.a.space.FreeDofs(self.a.condense)
+            else:
+                freedofs = None
+            if "printrates" not in lin_solver_args:
+                lin_solver_args["printrates"] = printrates
+            ainv = lin_solver(
+                mat=self.a.mat, pre=pre, freedofs=freedofs, **lin_solver_args
+            )
+        self.gf.vec.data += ainv * rhs.vec
+        if self.a.condense:
+            self.gf.vec.data += self.a.harmonic_extension * self.gf.vec
+            self.gf.vec.data += self.a.inner_solve * rhs.vec
+
+
+class Equation:
+    def __init__(self, lhs, rhs):
+        self.lhs = lhs
+        self.rhs = rhs
+
+    @functools.wraps(Application.Solve)
+    def Solve(self, *args, **kwargs):
+        self.lhs.Solve(self.rhs, *args, **kwargs)
+
+
+def _create_lin_appl(self, gfu: GridFunction) -> LinearApplication:
+    if not isinstance(gfu, GridFunction):
+        raise TypeError("gfu must be a GridFunction")
+    return LinearApplication(self, gfu)
+
+
+BilinearForm.__mul__ = _create_lin_appl
+
+
+@functools.wraps(Application.Solve)
+def Solve(eq: Equation, *args, **kwargs):
+    eq.Solve(*args, **kwargs)

ngsolve/solve_implementation.pyi

@@ -0,0 +1,42 @@
+from __future__ import annotations
+import functools as functools
+import ngsolve.comp
+from ngsolve.comp import BilinearForm
+from ngsolve.comp import GridFunction
+from ngsolve.comp import Preconditioner
+from ngsolve.comp import Region
+from ngsolve.fem import CoefficientFunction
+from ngsolve.krylovspace import GMResSolver
+from ngsolve.krylovspace import LinearSolver
+from ngsolve.nonlinearsolvers import NewtonSolver
+import typing
+__all__: list[str] = ['Application', 'BND', 'BilinearForm', 'CoefficientFunction', 'Dirichlet', 'Equation', 'GMResSolver', 'GridFunction', 'LinearApplication', 'LinearSolver', 'NewtonSolver', 'NonLinearApplication', 'Preconditioner', 'Region', 'Solve', 'functools']
+class Application:
+    __hash__: typing.ClassVar[None] = None
+    def Solve(self, rhs, *args, dirichlet = None, pre = None, printrates: bool = False, **kwargs):
+        ...
+    def __eq__(self, other):
+        ...
+    def __init__(self, a: ngsolve.comp.BilinearForm, gf: ngsolve.comp.GridFunction):
+        ...
+class Dirichlet:
+    def __init__(self, cf, region):
+        ...
+class Equation:
+    def Solve(self, *args, **kwargs):
+        ...
+    def __init__(self, lhs, rhs):
+        ...
+class LinearApplication(Application):
+    def Assemble(self):
+        ...
+    def Solve(self, rhs, *args, dirichlet = None, pre = None, lin_solver = None, lin_solver_args = None, printrates: bool = False):
+        ...
+class NonLinearApplication(Application):
+    def Solve(self, rhs = None, dirichlet = None, printing: bool = False, **kwargs):
+        ...
+def Solve(eq, *args, **kwargs):
+    ...
+def _create_lin_appl(self, gfu: ngsolve.comp.GridFunction) -> LinearApplication:
+    ...
+BND: ngsolve.comp.VorB  # value = <VorB.BND: 1>

ngsolve/solvers.py

@@ -0,0 +1,7 @@
+from ngsolve.eigenvalues import PINVIT, LOBPCG
+from ngsolve.krylovspace import CG, QMR, MinRes, PreconditionedRichardson, GMRes
+from ngsolve.krylovspace import CGSolver
+from ngsolve.nonlinearsolvers import Newton, NewtonMinimization
+from ngsolve.bvp import BVP
+from ngsolve.directsolvers import SuperLU
+

ngsolve/solvers.pyi

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from ngsolve.bvp import BVP
+from ngsolve.directsolvers import SuperLU
+from ngsolve.eigenvalues import LOBPCG
+from ngsolve.eigenvalues import PINVIT
+from ngsolve.krylovspace import CG
+from ngsolve.krylovspace import CGSolver
+from ngsolve.krylovspace import GMRes
+from ngsolve.krylovspace import MinRes
+from ngsolve.krylovspace import PreconditionedRichardson
+from ngsolve.krylovspace import QMR
+from ngsolve.nonlinearsolvers import Newton
+from ngsolve.nonlinearsolvers import NewtonMinimization
+__all__: list[str] = ['BVP', 'CG', 'CGSolver', 'GMRes', 'LOBPCG', 'MinRes', 'Newton', 'NewtonMinimization', 'PINVIT', 'PreconditionedRichardson', 'QMR', 'SuperLU']

ngsolve/timestepping.py

@@ -0,0 +1,185 @@
+
+import ngsolve as ngs
+from typing import Type, Optional, Union, Callable
+
+class ImplicitEuler:
+    def __init__(self,
+            equation: ngs.comp.SumOfIntegrals,
+            dt: Union[float, ngs.Parameter],
+            time: ngs.Parameter = ngs.Parameter(0),
+            pc_cls: Type = ngs.preconditioners.MultiGrid,
+            pc_args: Optional[dict] = None,
+            lin_solver_cls: Type = ngs.solvers.CGSolver,
+            lin_solver_args: Optional[dict] = None):
+
+        self.time = time
+        proxies = equation.GetProxies()
+        udts = list(filter(lambda u: u.dt_order == 1, proxies))
+        self.gfu_old = ngs.GridFunction(udts[0].space)
+        self.dt = ngs.Parameter(dt) if (isinstance(dt, float) or isinstance(dt, int)) else dt
+        replacements = {}
+        for udt in udts:
+            replacements[udt] = 1/self.dt * (udt.anti_dt  - udt.anti_dt.ReplaceFunction(self.gfu_old))
+        self.bfmstar = ngs.BilinearForm(equation.Replace(replacements))
+        self.bfmstar.Assemble()
+        self.c = pc_cls(self.bfmstar, **(pc_args or {}))
+        self._lin_solver_cls = lin_solver_cls
+        self._lin_solver_args = lin_solver_args
+
+    def Integrate(self, u_start: ngs.GridFunction,
+                  end_time: float,
+                  start_time: Optional[float] = None,
+                  newton_args: Optional[dict] = None,
+                  callback: Optional[Callable] = None):
+        u = u_start
+        if start_time is not None:
+            self.time.Set(start_time)
+        while self.time.Get() < end_time * (1-1e-10):
+            dt = min(self.dt.Get(), end_time - self.time.Get())
+            self.time.Set(self.time.Get() + dt)
+            self.Step(u, dt=dt, newton_args=newton_args)
+            if callback is not None:
+                callback(self.time.Get(), u)
+        return u
+
+    def Step(self, u: ngs.GridFunction, dt: Optional[float] = None,
+             newton_args: Optional[dict] = None):
+        if dt is not None:
+            self.dt.Set(dt)
+        self.gfu_old.vec.data = u.vec
+        lin_solver = self._lin_solver_cls(mat=self.bfmstar.mat,
+                                         pre=self.c,
+                                         **(self._lin_solver_args or {}))
+        newton = ngs.nonlinearsolvers.NewtonSolver(a=self.bfmstar,
+                                                   u=u,
+                                                   solver=lin_solver)
+        newton.Solve(**(newton_args or {}))
+
+class Newmark:
+    def __init__(self,
+                 equation: ngs.comp.SumOfIntegrals,
+                 dt: Union[float, ngs.Parameter],
+                 time: ngs.Parameter = ngs.Parameter(0),
+                 pc_cls: Type = ngs.preconditioners.MultiGrid,
+                 pc_args: Optional[dict] = None,
+                 lin_solver_cls: Type = ngs.solvers.CGSolver,
+                 lin_solver_args: Optional[dict] = None):
+        self.time = time
+        proxies = equation.GetProxies()
+        udt2 = list(filter(lambda u: u.dt_order == 2, proxies))
+        if len(udt2) != 1:
+            raise ValueError("Only u.dt.dt allowed as time derivatives in newmark!")
+        udt2 = udt2[0]
+        self.gfu_old = ngs.GridFunction(udt2.space)
+        self.gfv_old = ngs.GridFunction(udt2.space)
+        self.gfa_old = ngs.GridFunction(udt2.space)
+        self.dt = ngs.Parameter(dt) if (isinstance(dt, float) or isinstance(dt, int)) else dt
+        self.bfmstar = ngs.BilinearForm(udt2.space)
+        u = udt2.anti_dt.anti_dt
+        vel_new = 2/self.dt * (u-self.gfu_old) - self.gfv_old
+        acc_new = 2/self.dt * (vel_new-self.gfv_old) - self.gfa_old
+        self.bfmstar += equation.Replace({ udt2: acc_new })
+        self.bfmstar.Assemble()
+        self.c = pc_cls(self.bfmstar, **(pc_args or {}))
+        self._lin_solver_cls = lin_solver_cls
+        self._lin_solver_args = lin_solver_args
+
+    def Integrate(self, u: ngs.GridFunction,
+                  end_time: float,
+                  v: Optional[ngs.GridFunction] = None,
+                  a: Optional[ngs.GridFunction] = None,
+                  start_time: Optional[float] = None,
+                  newton_args: Optional[dict] = None,
+                  callback: Optional[Callable] = None):
+        if start_time is not None:
+            self.time.Set(start_time)
+        if v is None:
+            v = ngs.GridFunction(u.space)
+        if a is None:
+            a = ngs.GridFunction(u.space)
+        while self.time.Get() < end_time * (1-1e-10):
+            dt = min(self.dt.Get(), end_time - self.time.Get())
+            self.time.Set(self.time.Get() + dt)
+            self.Step(u, v, a, dt=dt, newton_args=newton_args)
+            if callback is not None:
+                callback(self.time.Get(), u)
+        return u
+
+    def Step(self, u: ngs.GridFunction,
+             v: ngs.GridFunction,
+             a: ngs.GridFunction,
+             dt: Optional[float] = None,
+             newton_args: Optional[dict] = None):
+        if dt is not None:
+            self.dt.Set(dt)
+        self.gfu_old.vec.data = u.vec
+        self.gfv_old.vec.data = v.vec
+        self.gfa_old.vec.data = a.vec
+        lin_solver = self._lin_solver_cls(mat=self.bfmstar.mat,
+                                          pre=self.c,
+                                          **(self._lin_solver_args or {}))
+        newton = ngs.nonlinearsolvers.NewtonSolver(a=self.bfmstar,
+                                                   u=u,
+                                                   solver=lin_solver)
+        newton.Solve(**(newton_args or {}))
+        v.vec.data = 2/self.dt.Get() * (u.vec - self.gfu_old.vec) - self.gfv_old.vec
+        a.vec.data = 2/self.dt.Get() * (v.vec - self.gfv_old.vec) - self.gfa_old.vec
+
+
+class CrankNicolson:
+    def __init__(self,
+                 equation: ngs.comp.SumOfIntegrals,
+                 dt: Union[float, ngs.Parameter],
+                 time: ngs.Parameter = ngs.Parameter(0),
+                 pc_cls: Type = ngs.preconditioners.MultiGrid,
+                 pc_args: Optional[dict] = None,
+                 lin_solver_cls: Type = ngs.solvers.CGSolver,
+                 lin_solver_args: Optional[dict] = None):
+        self.time = time
+        proxies = equation.GetProxies()
+        fes = proxies[0].space
+        self.dt = ngs.Parameter(dt) if (isinstance(dt, float) or isinstance(dt, int)) else dt
+        self.gfu_old = ngs.GridFunction(fes)
+        replacements = {}
+        for p in proxies:
+            if p.dt_order == 1:
+                replacements[p] = 1/self.dt * (p.anti_dt  - p.anti_dt.ReplaceFunction(self.gfu_old))
+        terms = 0.5 * equation.Replace(replacements)
+        for p in proxies:
+            if p.dt_order == 0:
+                replacements[p] = p.ReplaceFunction(self.gfu_old)
+        terms += 0.5 * equation.Replace(replacements)
+        self.bfmstar = ngs.BilinearForm(terms)
+        self.bfmstar.Assemble()
+        self.c = pc_cls(self.bfmstar, **(pc_args or {}))
+        self._lin_solver_cls = lin_solver_cls
+        self._lin_solver_args = lin_solver_args
+
+    def Integrate(self, u_start: ngs.GridFunction,
+                  end_time: float,
+                  start_time: Optional[float] = None,
+                  newton_args: Optional[dict] = None,
+                  callback: Optional[Callable] = None):
+        u = u_start
+        if start_time is not None:
+            self.time.Set(start_time)
+        while self.time.Get() < end_time * (1-1e-10):
+            dt = min(self.dt.Get(), end_time - self.time.Get())
+            self.time.Set(self.time.Get() + dt)
+            self.Step(u, dt=dt, newton_args=newton_args)
+            if callback is not None:
+                callback(self.time.Get(), u)
+        return u
+
+    def Step(self, u: ngs.GridFunction, dt: Optional[float] = None,
+             newton_args: Optional[dict] = None):
+        if dt is not None:
+            self.dt.Set(dt)
+        self.gfu_old.vec.data = u.vec
+        lin_solver = self._lin_solver_cls(mat=self.bfmstar.mat,
+                                         pre=self.c,
+                                         **(self._lin_solver_args or {}))
+        newton = ngs.nonlinearsolvers.NewtonSolver(a=self.bfmstar,
+                                                   u=u,
+                                                   solver=lin_solver)
+        newton.Solve(**(newton_args or {}))

ngsolve/timestepping.pyi

@@ -0,0 +1,28 @@
+from __future__ import annotations
+import ngsolve as ngs
+import ngsolve.comp
+import ngsolve.fem
+import ngsolve.krylovspace
+from typing import Union
+__all__: list[str] = ['CrankNicolson', 'ImplicitEuler', 'Newmark', 'Union', 'ngs']
+class CrankNicolson:
+    def Integrate(self, u_start: ngsolve.comp.GridFunction, end_time: float, start_time: float | None = None, newton_args: dict | None = None, callback: typing.Callable | None = None):
+        ...
+    def Step(self, u: ngsolve.comp.GridFunction, dt: float | None = None, newton_args: dict | None = None):
+        ...
+    def __init__(self, equation: ngsolve.comp.SumOfIntegrals, dt: float | ngsolve.fem.Parameter, time: ngsolve.fem.Parameter = ..., pc_cls: typing.Type = ngsolve.comp.MultiGridPreconditioner, pc_args: dict | None = None, lin_solver_cls: typing.Type = ngsolve.krylovspace.CGSolver, lin_solver_args: dict | None = None):
+        ...
+class ImplicitEuler:
+    def Integrate(self, u_start: ngsolve.comp.GridFunction, end_time: float, start_time: float | None = None, newton_args: dict | None = None, callback: typing.Callable | None = None):
+        ...
+    def Step(self, u: ngsolve.comp.GridFunction, dt: float | None = None, newton_args: dict | None = None):
+        ...
+    def __init__(self, equation: ngsolve.comp.SumOfIntegrals, dt: float | ngsolve.fem.Parameter, time: ngsolve.fem.Parameter = ..., pc_cls: typing.Type = ngsolve.comp.MultiGridPreconditioner, pc_args: dict | None = None, lin_solver_cls: typing.Type = ngsolve.krylovspace.CGSolver, lin_solver_args: dict | None = None):
+        ...
+class Newmark:
+    def Integrate(self, u: ngsolve.comp.GridFunction, end_time: float, v: ngsolve.comp.GridFunction | None = None, a: ngsolve.comp.GridFunction | None = None, start_time: float | None = None, newton_args: dict | None = None, callback: typing.Callable | None = None):
+        ...
+    def Step(self, u: ngsolve.comp.GridFunction, v: ngsolve.comp.GridFunction, a: ngsolve.comp.GridFunction, dt: float | None = None, newton_args: dict | None = None):
+        ...
+    def __init__(self, equation: ngsolve.comp.SumOfIntegrals, dt: float | ngsolve.fem.Parameter, time: ngsolve.fem.Parameter = ..., pc_cls: typing.Type = ngsolve.comp.MultiGridPreconditioner, pc_args: dict | None = None, lin_solver_cls: typing.Type = ngsolve.krylovspace.CGSolver, lin_solver_args: dict | None = None):
+        ...