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

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/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/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/timing.py

@@ -0,0 +1,108 @@
+import os
+import pickle
+from ngsolve import TaskManager
+
+class Timing():
+    """
+Class for timing analysis of performance critical functions. Some 
+classes export a C++ function as __timing__, which returns a map 
+of performance critical parts with their timings. The class can save 
+these maps, load them and compare them. It can be saved as a benchmark 
+to be compared against.
+
+2 overloaded __init__ functions:
+
+1. __init__(name,obj,parallel=True,serial=True)
+2. __init__(filename)
+
+Parameters
+----------
+
+name (str): Name for the timed class (for output formatting and 
+    saving/loading of results)
+obj (NGSolve object): Some NGSolve class which has the __timing__ 
+    functionality implemented. Currently supported classes:
+        FESpace
+filename (str): Filename to load a previously saved Timing
+parallel (bool=True): Time in parallel (using TaskManager)
+serial (bool=True): Time not in parallel (not using TaskManager)
+
+"""
+    def __init__(self,name=None,obj=None,filename=None,parallel=True,serial=True):
+        assert (not name and not obj and filename) or (name and obj and not filename)
+        if filename:
+            myself = pickle.load(open(filename,"rb"))
+            self.timings = myself.timings
+            self.name = myself.name
+            self.timings_par = myself.timings_par
+        else:
+            if serial:
+                self.timings = obj.__timing__()
+            else:
+                self.timings = None
+            if parallel:
+                with TaskManager():
+                    self.timings_par = obj.__timing__()
+            else:
+                self.timings_par = None
+            self.name = name
+        
+    def __str__(self):
+        string = "Timing for " + self.name + ":"
+        if self.timings:
+            for key, value in self.timings:
+                string += "\n" + key + ": " + value
+        if self.timings_par:
+            for key, value in self.timings_par:
+                string += "\n" + key + " parallel: " + value
+        return string
+
+    def Save(self, folder):
+        """ Saves the pickled results in folder 'folder' """
+        if not os.path.exists(folder):
+            os.makedirs(folder)
+        if folder[-1] == "/":
+            pickle.dump(self,open(folder + self.name + ".dat","wb"))
+        else:
+            pickle.dump(self,open(folder + "/" + self.name + ".dat","wb"))
+                
+    def CompareTo(self,folder):
+        """ 
+Compares the timing with the one saved in folder 'folder' with filename 
+'name.dat'.
+"""
+        try:
+            if folder[-1] == "/":
+                other = Timing(filename=folder + self.name + ".dat")
+            else:
+                other = Timing(filename=folder + "/" + self.name + ".dat")
+        except:
+            raise Exception("Other timing couldn't be loaded!")
+        result = []
+        dict_self = { key : value for key,value in self.timings }
+        dict_other = { key : value for key,value in other.timings }
+        for i, val in enumerate(self.timings):
+            try:
+                result.append((val[0], dict_self[val[0]]/dict_other[val[0]]))
+            except KeyError:
+                print("WARNING: No timing for '", val[0], "' in other file!")
+        dict_self_par = { key : value for key,value in self.timings_par }
+        dict_other_par = { key : value for key,value in other.timings_par }
+        for i,val in enumerate(self.timings_par):
+            try:
+                result.append((val[0]+" parallel", dict_self_par[val[0]]/dict_other_par[val[0]]))
+            except KeyError:
+                print("WARNING: No timing for '",val[0],"' with parallel in other file!") 
+        return result
+
+    def CompareToBenchmark(self):
+        """ Compares the timing with the one stored as benchmark"""
+        return self.CompareTo("benchmark")
+        
+    def SaveBenchmark(self):
+        """ Makes the timing the new benchmark for that object. """
+        self.Save("benchmark")
+
+
+__all__ = ["Timing"]        
+        

ngsolve/utils.py

@@ -0,0 +1,167 @@
+from ngsolve.ngstd import IntRange
+from ngsolve.fem import *
+from ngsolve.comp import *
+from ngsolve.bla import Norm
+from netgen import TimeFunction, Timer
+
+x = CoordCF(0)
+y = CoordCF(1)
+z = CoordCF(2)
+
+dx = DifferentialSymbol(VOL)
+ds = DifferentialSymbol(BND)
+
+
+def Laplace (coef):
+    return BFI("laplace", coef=coef)
+
+def Mass (coef):
+    return BFI("mass", coef=coef)
+
+def Source (coef):
+    return LFI("source", coef=coef)
+
+def Neumann (coef):
+    return LFI("neumann", coef=coef)
+
+
+# VectorFacet = TangentialFacetFESpace
+def VectorFacet (mesh, **args):
+    print ("deprecated warning: VectorFacet is renamed to TangentialFacetFESpace")
+    return TangentialFacetFESpace(mesh, **args)
+
+def grad(func):
+    try:
+        # now in C++ code
+        # if "normal vector" in str(func):
+        # return specialcf.Weingarten(func.dim)
+        if func.derivname == "grad":
+            return func.Deriv()
+    except:
+        pass
+    add = func.Operator("grad")
+    if add:
+        return add        
+    #     if func.derivname != "grad":
+    raise Exception("cannot form grad")
+    # return func.Deriv()
+
+def Grad(func):
+    """ Jacobi-matrix"""
+    # now in C++ code    
+    # if "normal vector" in str(func):        
+    # return specialcf.Weingarten(func.dim)
+    try:
+        return func.Operator("Grad")
+    except:
+        return grad(func).trans
+    
+
+
+def curl(func):
+    if func.derivname == "curl":
+        return func.Deriv()
+    add = func.Operator("curl")
+    if add:
+        return add
+    raise Exception("cannot form curl")    
+
+def div(func):
+    if func.derivname == "div":
+        return func.Deriv()
+    try:
+        return func.Operator("div")
+    except:
+        pass
+    try:
+        return Trace(grad(func))
+    except:
+        pass
+    #if func.derivname == "grad" and len(func.dims)==2:  # should check for square
+    #   return Trace(grad(func))
+    raise Exception("cannot form div")    
+
+
+def ConstantCF(val):
+    print ("Warning: ConstantCF deprecated, just use CoefficientFunction(val)")
+    return CoefficientFunction(val)
+
+def DomainConstantCF(values):
+    print ("Warning: DomainConstantCF deprecated, just use CoefficientFunction([values])")
+    return CoefficientFunction(values)
+
+
+def Deviator(mat):
+    return mat - 1/mat.dims[0]*Trace(mat)*Id(mat.dims[0])
+
+
+def PyId(dim):
+    return CoefficientFunction( tuple( [1 if i==j else 0 for i in range(dim) for j in range(dim)]), dims=(dim,dim) )
+
+def PyTrace(mat):
+    return sum( [mat[i,i] for i in range(mat.dims[0]) ])
+
+def PyDet(mat):
+    if mat.dims[0] == 1:
+        return mat[0,0]
+    elif mat.dims[0] == 2:
+        return mat[0,0]*mat[1,1]-mat[0,1]*mat[1,0]
+    elif mat.dims[0] == 3:
+        return mat[0,0]*(mat[1,1]*mat[2,2]-mat[1,2]*mat[2,1]) \
+              +mat[1,0]*(mat[2,1]*mat[0,2]-mat[2,2]*mat[0,1]) \
+              +mat[2,0]*(mat[0,1]*mat[1,2]-mat[0,2]*mat[1,1])
+
+def PyCross(a,b):
+    return CoefficientFunction( (a[1]*b[2]-a[2]*b[1],a[2]*b[0]-a[0]*b[2],a[0]*b[1]-a[1]*b[0]) )
+
+def PyCof(m):
+    if m.dims[0] == 1:
+        return CoefficientFunction(1, dims=(1,1))
+    elif m.dims[0] == 2:
+        return CoefficientFunction( (m[1,1], -m[1,0], -m[0,1], m[0,0]), dims=(2,2) )
+    elif m.dims[0] == 3:
+        return CoefficientFunction( 
+                    ( m[1,1]*m[2,2]-m[2,1]*m[1,2],
+                     -m[1,0]*m[2,2]+m[2,0]*m[1,2],
+                      m[1,0]*m[2,1]-m[2,0]*m[1,1],
+    
+                     -m[0,1]*m[2,2]+m[2,1]*m[0,2],
+                      m[0,0]*m[2,2]-m[2,0]*m[0,2], 
+                     -m[0,0]*m[2,1]+m[2,0]*m[0,1],
+    
+                      m[0,1]*m[1,2]-m[1,1]*m[0,2], 
+                     -m[0,0]*m[1,2]+m[1,0]*m[0,2], 
+                      m[0,0]*m[1,1]-m[1,0]*m[0,1] ), dims=(3,3) )
+
+def PyInv(m):
+    return 1/Det(m)*Cof(m).trans
+
+def PySym(m):
+    return 0.5*(m+m.trans)
+
+def PySkew(m):
+    return 0.5*(m-m.trans)
+
+def OuterProduct(a, b):
+    # return CoefficientFunction( (a,), dims=(a.dim,1)) * CoefficientFunction( (b,), dims=(b.dim,1)).trans
+    # return CoefficientFunction(a, dims=(a.dim,1)) * CoefficientFunction(b, dims=(1, b.dim))
+    return a.Reshape((a.dim,1)) * b.Reshape((1, b.dim))
+
+
+PrivateSpace = Hidden
+# def PrivateSpace(fes):
+# TODO: make space wrapper which also works after refinement
+# fes.SetCouplingType(IntRange(0,fes.ndof), COUPLING_TYPE.HIDDEN_DOF)
+# return Compress(fes)
+# return Hidden(fes)
+
+def Normalize (v):
+    return 1/Norm(v) * v
+
+def printonce (*args):
+    from mpi4py.MPI import COMM_WORLD
+    if COMM_WORLD.rank == 0:
+        print (*args)
+        
+
+def dt(u): return u.dt