ngsolve 6.2.2504.post44.dev0__cp311-cp311-win_amd64.whl → 6.2.2601__cp311-cp311-win_amd64.whl

ngsolve/config/config.py

@@ -15,7 +15,7 @@ USE_MUMPS            = _cmake_to_bool("OFF")
 USE_PARDISO          = _cmake_to_bool("OFF")
 USE_UMFPACK          = _cmake_to_bool("OFF")
 
-NETGEN_DIR = "C:/gitlabci/tools/builds/3zsqG5ns/0/ngsolve/venv_ngs/Lib/site-packages"
+NETGEN_DIR = "C:/gitlabci/tools/builds/3zsqG5ns9/0/ngsolve/venv_ngs/Lib/site-packages"
 
 NGSOLVE_COMPILE_DEFINITIONS         = "HAVE_NETGEN_SOURCES;USE_TIMEOFDAY;TCL;LAPACK;USE_PARDISO;NGS_PYTHON"
 NGSOLVE_COMPILE_DEFINITIONS_PRIVATE = "USE_MKL"
@@ -29,21 +29,21 @@ NGSOLVE_INSTALL_DIR_INCLUDE  = "netgen/include"
 NGSOLVE_INSTALL_DIR_CMAKE    = "ngsolve/cmake"
 NGSOLVE_INSTALL_DIR_RES      = "share"
 
-NGSOLVE_VERSION = "6.2.2504-44-g8fbbbc389"
-NGSOLVE_VERSION_GIT = "v6.2.2504-44-g8fbbbc389"
-NGSOLVE_VERSION_PYTHON = "6.2.2504.post44.dev0"
+NGSOLVE_VERSION = "6.2.2601"
+NGSOLVE_VERSION_GIT = "v6.2.2601-0-g3a3ce7f49"
+NGSOLVE_VERSION_PYTHON = "6.2.2601"
 
 NGSOLVE_VERSION_MAJOR = "6"
 NGSOLVE_VERSION_MINOR = "2"
-NGSOLVE_VERSION_TWEAK = "44"
-NGSOLVE_VERSION_PATCH = "2504"
-NGSOLVE_VERSION_HASH = "g8fbbbc389"
+NGSOLVE_VERSION_TWEAK = "0"
+NGSOLVE_VERSION_PATCH = "2601"
+NGSOLVE_VERSION_HASH = "g3a3ce7f49"
 
 CMAKE_CXX_COMPILER           = "C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Tools/MSVC/14.44.35207/bin/Hostx64/x64/cl.exe"
 CMAKE_CUDA_COMPILER          = ""
 CMAKE_C_COMPILER             = "C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Tools/MSVC/14.44.35207/bin/Hostx64/x64/cl.exe"
 CMAKE_LINKER                 = "C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Tools/MSVC/14.44.35207/bin/Hostx64/x64/link.exe"
-CMAKE_INSTALL_PREFIX         = "C:/gitlabci/tools/builds/3zsqG5ns/0/ngsolve/ngsolve/_skbuild/win-amd64-3.11/cmake-install"
+CMAKE_INSTALL_PREFIX         = "C:/gitlabci/tools/builds/3zsqG5ns9/0/ngsolve/ngsolve/_skbuild/win-amd64-3.11/cmake-install"
 CMAKE_CXX_COMPILER_LAUNCHER  = ""
 
 version = NGSOLVE_VERSION_GIT

ngsolve/demos/intro/cmagnet.py

@@ -1,29 +1,26 @@
-from netgen.csg import *
+from netgen.occ import *
 from ngsolve import *
 
 
 def MakeGeometry():
-    geometry = CSGeometry()
-    box = OrthoBrick(Pnt(-1,-1,-1),Pnt(2,1,2)).bc("outer")
-
-    core = OrthoBrick(Pnt(0,-0.05,0),Pnt(0.8,0.05,1))- \
-           OrthoBrick(Pnt(0.1,-1,0.1),Pnt(0.7,1,0.9))- \
-           OrthoBrick(Pnt(0.5,-1,0.4),Pnt(1,1,0.6)).maxh(0.2).mat("core")
-    
-    coil = (Cylinder(Pnt(0.05,0,0), Pnt(0.05,0,1), 0.3) - \
-            Cylinder(Pnt(0.05,0,0), Pnt(0.05,0,1), 0.15)) * \
-            OrthoBrick (Pnt(-1,-1,0.3),Pnt(1,1,0.7)).maxh(0.2).mat("coil")
-    
-    geometry.Add ((box-core-coil).mat("air"))
-    geometry.Add (core)
-    geometry.Add (coil)
-    return geometry
-
-
-
-ngmesh = MakeGeometry().GenerateMesh(maxh=0.5)
-ngmesh.Save("coil.vol")
-mesh = Mesh(ngmesh)
+    box = Box((-1,-1,-1), (2,1,2))
+    box.faces.name = "outer"
+    core = Box((0,-0.05,0), (0.8,0.05,1)) - \
+        Box((0.1,-1,0.1), (0.7,1,0.9)) - \
+        Box((0.5,-1,0.4), (1,1,0.6))
+    core.solids.name = "core"
+    core.solids.maxh = 0.03
+
+    coil = Cylinder((0.05,0,0.3), (0,0,1), 0.3, 0.4) - \
+        Cylinder((0.05,0,0.3), (0,0,1), 0.15, 0.4)
+    coil.solids.name = "coil"
+    air = box - core - coil
+    air.solids.name = "air"
+    return Glue([core, coil, air])
+
+
+
+mesh = MakeGeometry().GenerateMesh(maxh=0.5)
 
 # curve elements for geometry approximation
 mesh.Curve(5)

ngsolve/directsolvers.py

@@ -1,26 +1,14 @@
 from ngsolve import BaseMatrix, BitArray, BilinearForm, BaseVector
+import ngsolve
 
-class SuperLU(BaseMatrix):
-    # def __init__(self, a: BaseMatrix | BilinearForm, freedofs: BitArray = None):
-    def __init__(self, a, freedofs: BitArray = None):        
-        super().__init__()
-        self.a = a
-        self.freedofs = freedofs
-
-    def Update(self):
+class SuperLU(ngsolve.la.SparseFactorizationInterface):
+    def Factor(self):
         import scipy.sparse as sp
         import scipy.sparse.linalg as spla
-        a = self.a if isinstance(self.a, BaseMatrix) else self.a.mat
-        mat = sp.csr_matrix(a.CSR())
-        if self.freedofs is not None:
-            self.fd = list(self.freedofs)
-            mat = mat[self.fd,:][:,self.fd]
-        self.lu = spla.factorized(sp.csc_matrix(mat))
+        vals, rows, cols = self.GetInnerMatrix().CSR()
+        self.inv_mat = spla.factorized(sp.csr_matrix((vals, rows, cols)))
+
+    def Solve(self, rhs, sol):
+        sol.FV().NumPy()[:] = self.inv_mat(rhs.FV().NumPy())
 
-    def Mult(self, x: BaseVector, y: BaseVector):
-        if not hasattr(self, "lu"):
-            self.Update()
-        if self.freedofs is not None:
-            y.FV().NumPy()[self.fd] = self.lu(x.FV().NumPy()[self.fd])
-        else:
-            y.FV().NumPy()[:] = self.lu(x.FV().NumPy())
+ngsolve.la.RegisterInverseType("superlu", SuperLU)

ngsolve/krylovspace.py

@@ -292,6 +292,10 @@ def CG(mat, rhs, pre=None, sol=None, tol=1e-12, maxsteps = 100, printrates = Tru
     solver.Solve(rhs=rhs, sol=sol, initialize=initialize)
     return solver.sol
 
+
+
+
+
 class QMRSolver(LinearSolver):
     """Quasi Minimal Residuum method
 
@@ -310,13 +314,15 @@ ep : double
     name = "QMR"
 
     def __init__(self, *args, pre2 : Preconditioner = None,
+                 matT = None,
                  ep : float = 1., **kwargs):
         super().__init__(*args, **kwargs)
         self.pre2 = pre2
         self.ep = ep
+        self.matT = matT if matT is not None else self.mat.T
 
     def _SolveImpl(self, rhs : BaseVector, sol : BaseVector):
-        u, mat, ep, pre1, pre2 = sol, self.mat, self.ep, self.pre, self.pre2
+        u, mat, matT, ep, pre1, pre2 = sol, self.mat, self.matT, self.ep, self.pre, self.pre2
         r = rhs.CreateVector()
         v = rhs.CreateVector()
         v_tld = rhs.CreateVector()
@@ -399,7 +405,7 @@ ep : double
             rho = InnerProduct(y,y)
             rho = sqrt(rho)
 
-            w_tld.data = mat.T * q
+            w_tld.data = matT * q
             w_tld.data -= beta * w
 
             z.data = pre2.T * w_tld if pre2 else w_tld
@@ -498,6 +504,169 @@ def QMR(mat, rhs, fdofs, pre1=None, pre2=None, sol=None, maxsteps = 100, printra
 
 
 
+
+
+
+class TFQMRSolver(LinearSolver):
+    """Transpose-Free Quasi Minimal Residuum method
+
+    Parameters
+    ----------
+
+""" + linear_solver_param_doc + """
+
+"""
+
+    name = "TFQMR"
+
+    def __init__(self, *args, pre2 : Preconditioner = None,
+                 matT = None,
+                 ep : float = 1., **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def _SolveImpl(self, rhs : BaseVector, sol : BaseVector):
+        # following implementation from scipy
+        mat,pre,tol = self.mat, self.pre, self.tol
+        
+        r = rhs.CreateVector()
+        u = rhs.CreateVector()
+        v = rhs.CreateVector()
+        w = rhs.CreateVector()
+        uhat = rhs.CreateVector()
+        uNext = rhs.CreateVector()                
+        rstar = rhs.CreateVector()
+        d = rhs.CreateVector()
+        x = rhs.CreateVector()
+        z = rhs.CreateVector()
+        tmp = rhs.CreateVector()                                
+        d[:] = 0
+        
+        if Norm(rhs)==0:
+            sol.data = 0
+            return
+
+        x.data = sol
+        r.data = rhs - mat*sol
+        
+        u.data = r
+        w.data = r
+        rstar.data = r
+
+        v.data = pre@mat * r
+        uhat.data = v
+
+        theta = eta = 0
+
+        rho = InnerProduct(rstar, r)
+        rhoLast = rho
+        r0norm = sqrt(rho)
+
+        tau = r0norm
+        if r0norm == 0:
+            return
+
+        for iter in range(0,self.maxiter):
+            even = iter%2 == 0
+            if (even):
+                vtrstar = InnerProduct(rstar, v)
+                if vtrstar==0:
+                    return
+
+                alpha = rho/vtrstar
+                uNext.data = u-alpha*v
+                
+            w -= alpha*uhat
+            d *= theta**2/alpha*eta
+            d += u
+            theta = Norm(w)/tau
+            c = sqrt(1/(1+theta**2))
+            tau *= theta*c
+
+            eta = c**2 * alpha
+            z.data = pre*d
+            x += eta*z
+
+            # callback ...
+
+            if self.CheckResidual(tau):
+                sol.data = x
+                return
+            # if tau < tol:
+            #    return
+
+            if not even:
+                rho = InnerProduct(rstar, w)
+                beta = rho/rhoLast
+                u *= beta
+                u += w
+                v *= beta**2
+                v += beta*uhat
+                # uhat.data = pre@mat * u
+                tmp.data = mat*u
+                uhat.data = pre*tmp
+                v += uhat
+            else:
+                # uhat.data = pre@mat * uNext
+                tmp.data = mat*uNext
+                uhat.data = pre*tmp
+                u.data = uNext
+                rhoLast = rho
+            
+
+def TFQMR(mat, rhs, pre=None, sol=None, maxsteps = 100, printrates = True, initialize = True, tol = 1e-7):
+    """Quasi Minimal Residuum method
+
+
+    Parameters
+    ----------
+
+    mat : Matrix
+      The left hand side of the equation to solve
+
+    rhs : Vector
+      The right hand side of the equation.
+
+    fdofs : BitArray
+      BitArray of free degrees of freedoms.
+
+    pre : Preconditioner
+      preconditioner if provided
+
+    sol : Vector
+      Start vector for QMR method, if initialize is set False. Gets overwritten by the solution vector. If sol = None then a new vector is created.
+
+    maxsteps : int
+      Number of maximal steps for QMR. If the maximal number is reached before the tolerance is reached QMR stops.
+
+    printrates : bool
+      If set to True then the error of the iterations is displayed.
+
+    initialize : bool
+      If set to True then the initial guess for the QMR method is set to zero. Otherwise the values of the vector sol, if provided, is used.
+
+    tol : double
+      Tolerance of the residuum. QMR stops if tolerance is reached.
+
+
+    Returns
+    -------
+    (vector)
+      Solution vector of the QMR method.
+
+    """
+    # backwards compatibility, but freedofs are not needed then.
+    return TFQMRSolver(mat=mat, pre=pre,
+                       maxiter=maxsteps,
+                       printrates=printrates, 
+                       tol=tol).Solve(rhs=rhs, sol=sol, initialize=initialize)
+
+
+
+
+
+
+
+
 #Source: Michael Kolmbauer https://www.numa.uni-linz.ac.at/Teaching/PhD/Finished/kolmbauer-diss.pdf
 class MinResSolver(LinearSolver):
     """Minimal Residuum method
@@ -803,7 +972,7 @@ restart : int = None
             h[:] = 0
             for i in range(k+1):
                 h[i] = innerproduct(Q[i],q)
-                q.data += (-1)* h[i] * Q[i]
+                q -= h[i] * Q[i]
             h[k+1] = norm(q)
             if abs(h[k+1]) < 1e-12:
                 return h, None

ngsolve/nonlinearsolvers.py

@@ -1,4 +1,4 @@
-from ngsolve.la import InnerProduct
+from ngsolve.la import InnerProduct, SparseFactorizationInterface
 from math import sqrt
 from ngsolve import Projector, Norm
 from .utils import TimeFunction
@@ -97,7 +97,7 @@ class NewtonSolver:
             else:
                 self.inv.Update()
         else:
-            if self.inverse == "sparsecholesky" and self.inv is not None:
+            if self.inv is not None and (self.inverse == "sparsecholesky" or isinstance(self.inv, SparseFactorizationInterface)):
                 self.inv.Update()
             else:
                 self.inv = self.a.mat.Inverse(self.freedofs,

ngsolve/solve_implementation.py

@@ -51,10 +51,23 @@ class NonLinearApplication(Application):
         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, Dirichlet):
+            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)

ngsolve/{solvers.py → solvers/__init__.py}

@@ -1,5 +1,5 @@
 from ngsolve.eigenvalues import PINVIT, LOBPCG
-from ngsolve.krylovspace import CG, QMR, MinRes, PreconditionedRichardson, GMRes
+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

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

@@ -603,6 +603,7 @@ def FieldLines(
         ngs.ET.HEX,
         ngs.ET.PRISM,
         ngs.ET.PYRAMID,
+        ngs.ET.SEGM
     ]:
         rules[et] = ngs.IntegrationRule(et, 5)
 

{ngsolve-6.2.2504.post44.dev0.dist-info → ngsolve-6.2.2601.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: ngsolve
-Version: 6.2.2504.post44.dev0
+Version: 6.2.2601
 Summary: NGSolve
 Author: The NGSolve team
 License: LGPL2.1
 License-File: LICENSE
-Requires-Dist: netgen-mesher==6.2.2504.post13.dev0
+Requires-Dist: netgen-mesher==6.2.2601
 Requires-Dist: mkl