ngsolve 6.2.2502__cp311-cp311-win_amd64.whl → 6.2.2601__cp311-cp311-win_amd64.whl

ngsolve/cmake/NGSolveConfig.cmake

@@ -1,4 +1,4 @@
-set(PACKAGE_VERSION "6.2.2502")
+set(PACKAGE_VERSION "6.2.2601")
 find_package(Netgen CONFIG REQUIRED HINTS
   ${CMAKE_CURRENT_LIST_DIR}
   ${CMAKE_CURRENT_LIST_DIR}/..
@@ -18,20 +18,20 @@ set(NGSOLVE_CXX_COMPILER "C:/Program Files/Microsoft Visual Studio/2022/Communit
 set(NGSOLVE_CMAKE_BUILD_TYPE "Release")
 
 set(NGSOLVE_CMAKE_THREAD_LIBS_INIT "")
-set(NGSOLVE_MKL_LIBRARIES "C:/gitlabci/tools/builds/3zsqG5ns/0/ngsolve/venv_ngs/Library/lib/mkl_rt.lib")
+set(NGSOLVE_MKL_LIBRARIES "C:/gitlabci/tools/builds/3zsqG5ns9/0/ngsolve/venv_ngs/Library/lib/mkl_rt.lib")
 set(NGSOLVE_PYBIND_INCLUDE_DIR "")
 set(NGSOLVE_PYTHON_INCLUDE_DIRS "C:/Python311/include")
 set(NGSOLVE_PYTHON_LIBRARIES "C:/Python311/libs/python311.lib")
 set(NGSOLVE_PYTHON_PACKAGES_INSTALL_DIR  "")
-set(NGSOLVE_TCL_INCLUDE_PATH "C:/gitlabci/tools/builds/3zsqG5ns/0/ngsolve/ngsolve/external_dependencies/netgen/_skbuild/win-amd64-3.11/cmake-build/dependencies/src/project_tcl/generic")
+set(NGSOLVE_TCL_INCLUDE_PATH "C:/gitlabci/tools/builds/3zsqG5ns9/0/ngsolve/netgen/_skbuild/win-amd64-3.11/cmake-build/dependencies/src/project_tcl/generic")
 set(NGSOLVE_TCL_LIBRARY "C:/Python311/tcl/tclstub86.lib")
 set(NGSOLVE_TK_DND_LIBRARY "")
-set(NGSOLVE_TK_INCLUDE_PATH "C:/gitlabci/tools/builds/3zsqG5ns/0/ngsolve/ngsolve/external_dependencies/netgen/_skbuild/win-amd64-3.11/cmake-build/dependencies/src/project_tk/generic")
+set(NGSOLVE_TK_INCLUDE_PATH "C:/gitlabci/tools/builds/3zsqG5ns9/0/ngsolve/netgen/_skbuild/win-amd64-3.11/cmake-build/dependencies/src/project_tk/generic")
 set(NGSOLVE_TK_LIBRARY "C:/Python311/tcl/tkstub86.lib")
 set(NGSOLVE_X11_X11_LIB "")
 set(NGSOLVE_X11_Xmu_LIB "")
-set(NGSOLVE_ZLIB_INCLUDE_DIRS "C:/gitlabci/tools/builds/3zsqG5ns/0/ngsolve/ngsolve/external_dependencies/netgen/_skbuild/win-amd64-3.11/cmake-build/dependencies/zlib/include")
-set(NGSOLVE_ZLIB_LIBRARIES "C:/gitlabci/tools/builds/3zsqG5ns/0/ngsolve/ngsolve/external_dependencies/netgen/_skbuild/win-amd64-3.11/cmake-build/dependencies/zlib/lib/zlibstatic.lib")
+set(NGSOLVE_ZLIB_INCLUDE_DIRS "C:/gitlabci/tools/builds/3zsqG5ns9/0/ngsolve/netgen/_skbuild/win-amd64-3.11/cmake-build/dependencies/zlib/include")
+set(NGSOLVE_ZLIB_LIBRARIES "C:/gitlabci/tools/builds/3zsqG5ns9/0/ngsolve/netgen/_skbuild/win-amd64-3.11/cmake-build/dependencies/zlib/lib/zlibstatic.lib")
 
 set(NGSOLVE_INTEL_MIC       OFF)
 set(NGSOLVE_USE_CCACHE ON)
@@ -50,8 +50,8 @@ set(NGSOLVE_USE_VTUNE       OFF)
 set(NGSOLVE_MAX_SYS_DIM       3)
 
 set(NGSOLVE_COMPILE_FLAGS " /DHAVE_NETGEN_SOURCES /DUSE_TIMEOFDAY /DTCL /DLAPACK /DUSE_PARDISO /DNGS_PYTHON /DNETGEN_PYTHON /DNG_PYTHON /DPYBIND11_SIMPLE_GIL_MANAGEMENT /D_WIN32_WINNT=0x1000 /DWNT /DWNT_WINDOW /DNOMINMAX /DMSVC_EXPRESS /D_CRT_SECURE_NO_WARNINGS /DHAVE_STRUCT_TIMESPEC /DWIN32 /DPARALLEL /DNG_MPI_WRAPPER" CACHE STRING "Preprocessor definitions of ngscxx")
-set(NGSOLVE_LINK_FLAGS " -LC:/gitlabci/tools/builds/3zsqG5ns/0/ngsolve/venv_ngs/Library/lib -l_rt /LIBPATH:\"%NGSCXX_DIR%/lib\" nglib.lib ngcore.lib libngsolve.lib /LIBPATH:\"%PYTHON_LIBDIR%\"" CACHE STRING "Link flags set in ngsld")
-set(NGSOLVE_INCLUDE_DIRS C:/gitlabci/tools/builds/3zsqG5ns/0/ngsolve/venv_ngs/Library/include;C:/Python311/include CACHE STRING "Include dirs set in ngscxx")
+set(NGSOLVE_LINK_FLAGS " -LC:/gitlabci/tools/builds/3zsqG5ns9/0/ngsolve/venv_ngs/Library/lib -l_rt /LIBPATH:\"%NGSCXX_DIR%/lib\" nglib.lib ngcore.lib libngsolve.lib /LIBPATH:\"%PYTHON_LIBDIR%\"" CACHE STRING "Link flags set in ngsld")
+set(NGSOLVE_INCLUDE_DIRS C:/gitlabci/tools/builds/3zsqG5ns9/0/ngsolve/venv_ngs/Library/include;C:/Python311/include CACHE STRING "Include dirs set in ngscxx")
 
 set(NGSOLVE_INSTALL_DIR_PYTHON  .)
 set(NGSOLVE_INSTALL_DIR_BIN     netgen)

ngsolve/cmake/ngsolve-targets.cmake

@@ -19,7 +19,7 @@ set(CMAKE_IMPORT_FILE_VERSION 1)
 set(_cmake_targets_defined "")
 set(_cmake_targets_not_defined "")
 set(_cmake_expected_targets "")
-foreach(_cmake_expected_target IN ITEMS netgen_libs ngs_lapack netgen_python ngstd ngbla ngla ngfem ngcomp ngsolve)
+foreach(_cmake_expected_target IN ITEMS netgen_lib netgen_core_lib ngs_lapack ngstd ngbla ngla ngfem ngsbem ngcomp ngsolve)
   list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
   if(TARGET "${_cmake_expected_target}")
     list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
@@ -54,27 +54,26 @@ if(_IMPORT_PREFIX STREQUAL "/")
   set(_IMPORT_PREFIX "")
 endif()
 
-# Create imported target netgen_libs
-add_library(netgen_libs INTERFACE IMPORTED)
+# Create imported target netgen_lib
+add_library(netgen_lib INTERFACE IMPORTED)
 
-set_target_properties(netgen_libs PROPERTIES
-  INTERFACE_LINK_LIBRARIES "nglib;ngcore"
+set_target_properties(netgen_lib PROPERTIES
+  INTERFACE_LINK_LIBRARIES "nglib"
 )
 
-# Create imported target ngs_lapack
-add_library(ngs_lapack INTERFACE IMPORTED)
+# Create imported target netgen_core_lib
+add_library(netgen_core_lib INTERFACE IMPORTED)
 
-set_target_properties(ngs_lapack PROPERTIES
-  INTERFACE_INCLUDE_DIRECTORIES "C:/gitlabci/tools/builds/3zsqG5ns/0/ngsolve/venv_ngs/Library/include"
-  INTERFACE_LINK_LIBRARIES "C:/gitlabci/tools/builds/3zsqG5ns/0/ngsolve/venv_ngs/Library/lib/mkl_rt.lib"
+set_target_properties(netgen_core_lib PROPERTIES
+  INTERFACE_LINK_LIBRARIES "ngcore"
 )
 
-# Create imported target netgen_python
-add_library(netgen_python INTERFACE IMPORTED)
+# Create imported target ngs_lapack
+add_library(ngs_lapack INTERFACE IMPORTED)
 
-set_target_properties(netgen_python PROPERTIES
-  INTERFACE_INCLUDE_DIRECTORIES "C:/Python311/include"
-  INTERFACE_LINK_LIBRARIES "C:/Python311/libs/python311.lib"
+set_target_properties(ngs_lapack PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "C:/gitlabci/tools/builds/3zsqG5ns9/0/ngsolve/venv_ngs/Library/include"
+  INTERFACE_LINK_LIBRARIES "C:/gitlabci/tools/builds/3zsqG5ns9/0/ngsolve/venv_ngs/Library/lib/mkl_rt.lib"
 )
 
 # Create imported target ngstd
@@ -83,7 +82,7 @@ add_library(ngstd INTERFACE IMPORTED)
 set_target_properties(ngstd PROPERTIES
   INTERFACE_COMPILE_DEFINITIONS "HAVE_NETGEN_SOURCES;USE_TIMEOFDAY;TCL;LAPACK;USE_PARDISO;NGS_PYTHON"
   INTERFACE_COMPILE_OPTIONS "/std:c++17;/bigobj;/wd4068;-DMAX_SYS_DIM=3"
-  INTERFACE_LINK_LIBRARIES "netgen_libs;\$<LINK_ONLY:>"
+  INTERFACE_LINK_LIBRARIES "netgen_core_lib;\$<LINK_ONLY:>"
 )
 
 # Create imported target ngbla
@@ -107,18 +106,25 @@ set_target_properties(ngfem PROPERTIES
   INTERFACE_LINK_LIBRARIES "ngbla;ngstd;\$<LINK_ONLY:>"
 )
 
+# Create imported target ngsbem
+add_library(ngsbem INTERFACE IMPORTED)
+
+set_target_properties(ngsbem PROPERTIES
+  INTERFACE_LINK_LIBRARIES "ngcomp;ngfem;ngla;ngbla;ngstd;\$<LINK_ONLY:>"
+)
+
 # Create imported target ngcomp
 add_library(ngcomp INTERFACE IMPORTED)
 
 set_target_properties(ngcomp PROPERTIES
-  INTERFACE_LINK_LIBRARIES "ngfem;ngla;ngbla;ngstd;\$<LINK_ONLY:>"
+  INTERFACE_LINK_LIBRARIES "ngfem;ngla;ngbla;ngstd;\$<LINK_ONLY:>;netgen_lib"
 )
 
 # Create imported target ngsolve
 add_library(ngsolve SHARED IMPORTED)
 
 set_target_properties(ngsolve PROPERTIES
-  INTERFACE_LINK_LIBRARIES "netgen_libs;ngsolve;ngcomp;ngfem;ngbla;ngla;ngstd"
+  INTERFACE_LINK_LIBRARIES "netgen_lib;netgen_core_lib;ngsolve;ngcomp;ngfem;ngsbem;ngbla;ngla;ngstd"
 )
 
 if(CMAKE_VERSION VERSION_LESS 3.0.0)

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.2502"
-NGSOLVE_VERSION_GIT = "v6.2.2502-0-g984bf8ae2"
-NGSOLVE_VERSION_PYTHON = "6.2.2502"
+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 = "0"
-NGSOLVE_VERSION_PATCH = "2502"
-NGSOLVE_VERSION_HASH = "g984bf8ae2"
+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/preconditioners.py

@@ -1,6 +1,7 @@
 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/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 → 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