ngsolve 6.2.2506.post216.dev0__cp314-cp314-manylinux_2_28_x86_64.whl

ngsolve-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/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-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/ngsolve/solvers/__init__.py

@@ -0,0 +1,7 @@
+from ngsolve.eigenvalues import PINVIT, LOBPCG
+from ngsolve.krylovspace import CG, QMR, TFQMR, 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-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/ngsolve/solvers/cudss.py

@@ -0,0 +1,112 @@
+try:
+    import nvmath.sparse.advanced as nvs
+    from nvmath.internal import utils
+    from nvmath.internal.tensor_ifc_numpy import NumpyTensor
+except ImportError:
+    raise ImportError("CUDSS solver requires nvmath-python module.")
+
+import ngsolve.la as ngla
+import scipy.sparse as sp
+import numpy as np
+
+from ngsolve import TimeFunction
+
+class CudssSolver(ngla.SparseFactorizationInterface):
+    solver: nvs.DirectSolver = None
+
+    @TimeFunction
+    def Analyze(self):
+        if hasattr(self, "solver") and self.solver is not None:
+            self.solver.free()
+            del self.solver
+
+        csr = sp.csr_matrix(self.GetInnerMatrix().CSR())
+
+        options = make_directsolver_options()
+        self.extract_symmetric = (csr != csr.T).nnz == 0
+        if self.extract_symmetric:
+            csr = sp.triu(csr, format="csr")
+            options.sparse_system_type = nvs.DirectSolverMatrixType.SYMMETRIC
+            options.sparse_system_view = nvs.DirectSolverMatrixViewType.UPPER
+
+        tmp = np.empty(csr.shape[1], dtype=csr.dtype)
+        self.solver = nvs.DirectSolver(csr, tmp, options=options)
+        self.solver.plan()
+        self._is_first_factor_call = True
+
+    @TimeFunction
+    def Factor(self):
+        if not self._is_first_factor_call:
+            mat = self.GetInnerMatrix()
+            if self.extract_symmetric:
+                csr = sp.csr_matrix(mat.CSR())
+                csr = sp.triu(csr, format="csr")
+                values = csr.data
+            else:
+                values = mat.AsVector().FV().NumPy()
+            stream_holder = utils.get_or_create_stream(self.solver.device_id, None, self.solver.rhs_package)
+            values_tensor = NumpyTensor(values)
+            self.solver.a.values.copy_(values_tensor, stream_holder)
+        self.solver.factorize()
+        self._is_first_factor_call = False
+
+    @TimeFunction
+    def Solve(self, b, sol):
+        stream_holder = utils.get_or_create_stream(self.solver.device_id, None, self.solver.rhs_package)
+        self.solver.b.copy_(NumpyTensor(b.FV().NumPy()), stream_holder)
+        sol.FV().NumPy()[:] = self.solver.solve()
+
+    def __del__(self):
+        if self.solver is not None:
+            self.solver.free()
+            del self.solver
+
+
+ngla.RegisterInverseType("cudss", CudssSolver)
+
+
+# find cudss multithreading lib from installed distribution
+
+import os, pathlib
+from importlib import util as importlib_util
+from importlib import metadata as importlib_metadata
+
+def _from_dist_files():
+    # Use the wheel’s file manifest (most reliable)
+    candidates = []
+    # for dist_name in ("nvidia-cudss-cu12", "nvidia_cudss_cu12", "nvidia-cudss"):  # try common variants
+    for dist_name in ("nvidia-cudss-cu12", "nvidia_cudss_cu12", "nvidia-cudss",
+                      "nvidia-cudss-cu13", "nvidia_cudss_cu13"):  # try common variants
+        try:
+            dist = importlib_metadata.distribution(dist_name)
+        except importlib_metadata.PackageNotFoundError:
+            continue
+        for f in dist.files or []:
+            name = f.name.lower()
+            # check for name ends in .so or .so.*
+            endwith_so = name.endswith(".so") or (".so." in name and name.rsplit(".so.", 1)[1].replace(".", "").isdigit())
+            if name.startswith("libcudss_mtlayer_") and endwith_so:
+                candidates.append(dist.locate_file(f))
+            if name.startswith("cudss_mtlayer_") and name.endswith(".dll"):
+                candidates.append(dist.locate_file(f))
+        if candidates:
+            # Prefer anything in bin/ or lib/ if multiple
+            candidates.sort(key=lambda p: ("bin" not in str(p) and "lib" not in str(p), str(p)))
+            return str(candidates[0])
+    return None
+
+
+def make_directsolver_options():
+    # Helpful on Windows (Python 3.8+): ensure DLL deps can be found
+    if os.name == "nt":
+        for var in ("CUDA_PATH", "CUDSS_PATH", "CONDA_PREFIX"):
+            base = os.environ.get(var)
+            if base:
+                p = pathlib.Path(base) / "bin"
+                if p.exists():
+                    try:
+                        os.add_dll_directory(str(p))
+                    except Exception:
+                        pass
+    mtlib = _from_dist_files()
+    return nvs.DirectSolverOptions(multithreading_lib=mtlib)

ngsolve-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/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-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/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"]        
+