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

ngsolve/demos/intro/poisson.ipynb

@@ -0,0 +1,170 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Poisson Equation\n",
+    "==="
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Import Netgen/NGSolve Python modules:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from ngsolve import *\n",
+    "from netgen.geom2d import unit_square\n",
+    "import netgen.gui\n",
+    "%gui tk"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The unit_square is a predefined domain, use Netgen to generate a mesh:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mesh = Mesh(unit_square.GenerateMesh(maxh=0.2))\n",
+    "Draw (mesh)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Define a finite element space on that mesh. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fes = H1(mesh, order=3, dirichlet=\"left|right|bottom|top\")\n",
+    "print (\"ndof =\", fes.ndof)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Define linear and bilinear-forms. Forms are expressed in terms of trial and test-functions:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "u = fes.TrialFunction()\n",
+    "v = fes.TestFunction()\n",
+    "\n",
+    "f = LinearForm(fes)\n",
+    "f += 32 * (y*(1-y)+x*(1-x)) * v * dx\n",
+    "\n",
+    "a = BilinearForm(fes)\n",
+    "a += grad(u)*grad(v)*dx\n",
+    "\n",
+    "a.Assemble()\n",
+    "f.Assemble()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Solve the problem:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gfu = GridFunction(fes)\n",
+    "gfu.vec.data = a.mat.Inverse(fes.FreeDofs()) * f.vec"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Plot the solution:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Draw (gfu)\n",
+    "Draw (-grad(gfu), mesh, \"Flux\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exact = 16*x*(1-x)*y*(1-y)\n",
+    "print (\"L2-error:\", sqrt (Integrate ( (gfu-exact)*(gfu-exact), mesh)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

ngsolve/demos/intro/poisson.py

@@ -0,0 +1,41 @@
+# solve the Poisson equation -Delta u = f
+# with Dirichlet boundary condition u = 0
+
+from ngsolve import *
+# from netgen.geom2d import unit_square
+
+ngsglobals.msg_level = 1
+
+# generate a triangular mesh of mesh-size 0.2
+mesh = Mesh(unit_square.GenerateMesh(maxh=0.2))
+
+# H1-conforming finite element space
+fes = H1(mesh, order=3, dirichlet=[1,2,3,4])
+
+# define trial- and test-functions
+u = fes.TrialFunction()
+v = fes.TestFunction()
+
+# the right hand side
+f = LinearForm(fes)
+f += 32 * (y*(1-y)+x*(1-x)) * v * dx
+
+# the bilinear-form 
+a = BilinearForm(fes, symmetric=True)
+a += grad(u)*grad(v)*dx
+
+a.Assemble()
+f.Assemble()
+
+# the solution field 
+gfu = GridFunction(fes)
+gfu.vec.data = a.mat.Inverse(fes.FreeDofs(), inverse="sparsecholesky") * f.vec
+# print (u.vec)
+
+
+# plot the solution (netgen-gui only)
+Draw (gfu)
+Draw (-grad(gfu), mesh, "Flux")
+
+exact = 16*x*(1-x)*y*(1-y)
+print ("L2-error:", sqrt (Integrate ( (gfu-exact)*(gfu-exact), mesh)))

ngsolve/demos/mpi/mpi_cmagnet.py

@@ -0,0 +1,87 @@
+from netgen.csg import *
+import netgen.meshing
+
+from ngsolve import *
+
+from mpi4py.MPI import COMM_WORLD as comm
+rank = comm.rank
+np = comm.size
+
+do_vtk = False
+
+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
+
+# For curving, we need the geometry. We have to
+# generate it everywhere and then set it.
+# It is not distributed automatically.
+geom = MakeGeometry()
+if rank==0:
+    # master proc generates and immediately distributes
+    ngmesh = geom.GenerateMesh(maxh=0.5)
+    ngmesh.Distribute(comm)
+else:
+    # worker procs receive mesh
+    ngmesh = netgen.meshing.Mesh.Receive(comm)
+    # and then manually set the geometry
+    ngmesh.SetGeometry(geom)
+mesh = Mesh(ngmesh)
+
+# now we can curve!
+mesh.Curve(5)
+
+ngsglobals.msg_level = 5
+
+fes = HCurl(mesh, order=4, dirichlet="outer", nograds = True)
+
+
+u = fes.TrialFunction()
+v = fes.TestFunction()
+
+mur = { "core" : 1000, "coil" : 1, "air" : 1 }
+mu0 = 1.257e-6
+
+nu_coef = [ 1/(mu0*mur[mat]) for mat in mesh.GetMaterials() ]
+
+nu = CoefficientFunction(nu_coef)
+a = BilinearForm(fes, symmetric=True)
+a += SymbolicBFI(nu*curl(u)*curl(v) + 1e-6*nu*u*v)
+
+c = Preconditioner(a, type="bddc", flags={"inverse":"masterinverse"})
+#c = Preconditioner(a, type="bddc", inverse = "mumps")
+
+f = LinearForm(fes)
+f += SymbolicLFI(CoefficientFunction((y,0.05-x,0)) * v, definedon=mesh.Materials("coil"))
+
+u = GridFunction(fes)
+
+
+a.Assemble()
+f.Assemble()
+solver = CGSolver(mat=a.mat, pre=c.mat)
+u.vec.data = solver * f.vec
+
+if do_vtk:
+    import os
+    output_path = os.path.dirname(os.path.realpath(__file__)) + "/cmagnet_output"
+    if rank==0 and not os.path.exists(output_path):
+        os.mkdir(output_path)
+    comm.Barrier() #wait until master has created the directory!!
+    vtk = VTKOutput(ma=mesh, coefs=[u.Deriv()], names=["sol"], filename=output_path+"/vtkout", subdivision=2)
+    vtk.Do()
+
+#Draw (u.Deriv(), mesh, "B-field", draw_surf=False)

ngsolve/demos/mpi/mpi_navierstokes.py

@@ -0,0 +1,117 @@
+import netgen.meshing
+from netgen.geom2d import SplineGeometry
+
+
+from ngsolve import *
+
+SetNumThreads(1)  
+
+from mpi4py.MPI import COMM_WORLD as comm
+rank = comm.rank
+np = comm.size
+
+do_vtk = False
+
+# viscosity
+nu = 0.001
+
+# timestepping parameters
+tau = 0.001
+tend = 3
+
+# mesh = Mesh("cylinder.vol")
+geo = SplineGeometry()
+geo.AddRectangle( (0, 0), (2, 0.41), bcs = ("wall", "outlet", "wall", "inlet"))
+geo.AddCircle ( (0.2, 0.2), r=0.05, leftdomain=0, rightdomain=1, bc="cyl")
+if rank==0:
+    ngmesh = geo.GenerateMesh(maxh=0.08)
+    ngmesh.Distribute(comm)
+else:
+    ngmesh = netgen.meshing.Mesh.Receive(comm)
+    ngmesh.SetGeometry(geo)
+    
+mesh = Mesh(ngmesh)
+
+#does not work with mpi yet...
+#mesh.Curve(3)
+
+V = H1(mesh,order=3, dirichlet="wall|cyl|inlet")
+Q = H1(mesh,order=2)
+
+X = FESpace([V,V,Q])
+
+ux,uy,p = X.TrialFunction()
+vx,vy,q = X.TestFunction()
+
+div_u = grad(ux)[0]+grad(uy)[1]
+div_v = grad(vx)[0]+grad(vy)[1]
+
+stokes = nu*grad(ux)*grad(vx)+nu*grad(uy)*grad(vy)+div_u*q+div_v*p - 1e-10*p*q
+a = BilinearForm(X)
+a += SymbolicBFI(stokes)
+a.Assemble()
+
+# nothing here ...
+f = LinearForm(X)   
+f.Assemble()
+
+# gridfunction for the solution
+gfu = GridFunction(X)
+
+# parabolic inflow at bc=1:
+uin = 1.5*4*y*(0.41-y)/(0.41*0.41)
+gfu.components[0].Set(uin, definedon=mesh.Boundaries("inlet"))
+
+velocity = CoefficientFunction(gfu.components[0:2])
+
+
+# solve Stokes problem for initial conditions:
+#inv_stokes = a.mat.Inverse(X.FreeDofs(), inverse="mumps")
+inv_stokes = a.mat.Inverse(X.FreeDofs(), inverse="masterinverse")
+res = f.vec.CreateVector()
+res.data = f.vec - a.mat*gfu.vec
+gfu.vec.data += inv_stokes * res
+
+# matrix for implicit Euler 
+mstar = BilinearForm(X)
+mstar += SymbolicBFI(ux*vx+uy*vy + tau*stokes)
+mstar.Assemble()
+
+# inv = mstar.mat.Inverse(X.FreeDofs(), inverse="masterinverse")
+inv = mstar.mat.Inverse(X.FreeDofs(), inverse="masterinverse")
+
+# the non-linear term 
+conv = BilinearForm(X, nonassemble = True)
+conv += SymbolicBFI( CoefficientFunction( (ux,uy) ) * (grad(ux)*vx+grad(uy)*vy) )
+
+t = 0
+vtk_interval = int(0.05/tau);
+
+import os
+#output_path = os.path.dirname(os.path.realpath(__file__)) + "/navierstokes_output"
+output_path = os.path.dirname(os.path.realpath(__file__)) + "/navierstokes_output"
+if rank==0 and not os.path.exists(output_path):
+    os.mkdir(output_path)
+comm.Barrier() #wait until master has created the directory!!
+
+if do_vtk:
+    vtk = VTKOutput(ma=mesh,coefs=[velocity],names=["u"],filename=output_path+"/vtkout",subdivision=2)
+    vtk.Do()
+
+count = 1;
+# implicit Euler/explicit Euler splitting method:
+with TaskManager():
+    while t < tend:
+        if rank==0:
+            print ("t=", t)
+            
+        conv.Apply (gfu.vec, res)
+        res.data += a.mat*gfu.vec
+        gfu.vec.data -= tau * inv * res
+
+        if count%vtk_interval==0 and do_vtk:
+            vtk.Do(time = t)
+        count = count+1;
+
+        t = t + tau
+        comm.Barrier()

ngsolve/demos/mpi/mpi_poisson.py

@@ -0,0 +1,89 @@
+# Call with: 
+# mpirun -np 5 ngspy mpi_poisson.py
+
+# Solves -laplace(u)=f on [0,1]^3
+
+# netgen-imports
+#from netgen.geom2d import unit_square
+from netgen.csg import unit_cube
+import netgen.meshing
+
+# ngsolve-imports
+from ngsolve import *
+
+# initialize MPI
+from mpi4py.MPI import COMM_WORLD as comm
+rank = comm.rank
+np = comm.size
+
+do_vtk = False
+
+print("Hello from rank "+str(rank)+" of "+str(np))
+
+if rank==0:
+    # master-proc generates mesh
+    mesh = unit_cube.GenerateMesh(maxh=0.3)
+    # and saves it to file
+    mesh.Save("some_mesh.vol")
+
+# wait for master to be done meshing
+comm.Barrier()
+
+# now load mesh from file
+ngmesh = netgen.meshing.Mesh(dim=3, comm=comm)
+ngmesh.Load("some_mesh.vol")
+
+#refine once?
+# ngmesh.Refine()
+
+mesh = Mesh(ngmesh)
+
+# build H1-FESpace as usual
+V = H1(mesh, order=3, dirichlet=[1,2,3,4])
+u = V.TrialFunction()
+v = V.TestFunction()
+
+print("rank "+str(rank)+" has "+str(V.ndof)+" of "+str(V.ndofglobal)+" dofs!")
+
+# RHS does not change either!
+f = LinearForm (V)
+f += SymbolicLFI(32 * (y*(1-y)+x*(1-x)) * v)
+f.Assemble()
+
+# neither does the BLF!
+a = BilinearForm (V, symmetric=False)
+a += SymbolicBFI(grad(u)*grad(v))
+
+# Some possible preconditioners: 
+c = Preconditioner(a, type="direct", inverse = "masterinverse") # direct solve with mumps
+#c = Preconditioner(a, type="bddc", inverse = "mumps")   # BBDC + mumps for coarse inverse
+#c = Preconditioner(a, type="hypre")                             # BoomerAMG (use only for order 1)
+#c = Preconditioner(a, type="bddc", usehypre = True)     # BDDC + BoomerAMG for coarse matrix
+
+a.Assemble()
+
+# solve the equation
+u = GridFunction (V)
+u.vec.data = CGSolver(a.mat, c.mat) * f.vec  # use CG-solver with preconditioner c
+# u.vec.data = a.mat.Inverse(V.FreeDofs(), inverse="mumps") * f.vec  # use MUMPS parallel inverse
+# u.vec.data = a.mat.Inverse(V.FreeDofs(), inverse="masterinverse") * f.vec  # use masterinverse (master proc does all the work!)
+
+
+#exact solution
+exact = 16*x*(1-x)*y*(1-y)
+
+# error 
+error = Integrate ( (u-exact)*(u-exact) , mesh)
+if rank==0:
+    print("L2-error", error )
+
+if do_vtk:
+    # do VTK-output
+    import os
+    output_path = os.path.dirname(os.path.realpath(__file__)) + "/poisson_output"
+    if rank==0 and not os.path.exists(output_path):
+        os.mkdir(output_path)
+    comm.Barrier() #wait until master has created the directory!!
+
+    vtk = VTKOutput(mesh, coefs=[u], names=["sol"], filename=output_path+"/vtkout", subdivision=2)
+    vtk.Do()

ngsolve/demos/mpi/mpi_timeDG.py

@@ -0,0 +1,82 @@
+# Call with:
+# mpirun -np 5 ngspy mpi_timeDG.py
+
+# Then make movie with:
+# python3 make_timeDG_movie.py
+# (this only works if you have paraview+python3 configured properly)
+
+# circular convection; time-DG with skeleton-formulation
+
+
+from netgen.geom2d import unit_square
+import netgen.meshing
+
+
+from ngsolve import *
+
+SetNumThreads(1)
+
+from mpi4py.MPI import COMM_WORLD as comm
+rank = comm.rank
+np = comm.size
+
+do_vtk = False
+
+if rank==0:
+    ngmesh = unit_square.GenerateMesh(maxh=0.05)
+    ngmesh.Distribute(comm)
+else:
+    ngmesh = netgen.meshing.Mesh.Receive(comm)
+mesh = Mesh(ngmesh)
+
+# build L2-FESpace
+fes = L2(mesh, order=4)
+
+# Trial- and Test-functions
+u = fes.TrialFunction()
+v = fes.TestFunction()
+
+# RHS
+b = CoefficientFunction( (y-0.5,0.5-x) )
+bn = b*specialcf.normal(2)
+
+# Skeleton DG-formulation
+a = BilinearForm(fes)
+a += SymbolicBFI (-u * b*grad(v))
+a += SymbolicBFI ( bn*IfPos(bn, u, u.Other()) * (v-v.Other()), VOL, skeleton=True)
+a += SymbolicBFI ( bn*IfPos(bn, u, 0) * v, BND, skeleton=True)
+
+u = GridFunction(fes)
+u.Set(exp (-40 * ( (x-0.7)*(x-0.7) + (y-0.7)*(y-0.7) )))
+
+w = u.vec.CreateVector()
+
+t = 0
+tau = 5e-4
+tend = 2
+count = 0
+
+vtk_interval = int(0.02/tau);
+
+if do_vtk:
+    import os
+    output_path = os.path.dirname(os.path.realpath(__file__)) + "/timeDG_output"
+    if rank==0 and not os.path.exists(output_path):
+        os.mkdir(output_path)
+    comm.Barrier() #wait until master has created the directory!!
+    vtk = VTKOutput(ma=mesh,coefs=[u],names=["sol"],filename=output_path+"/vtkout",subdivision=2)
+
+with TaskManager():
+    while t < tend:
+        if rank==0:
+            print("t = ", t)
+        a.Apply (u.vec, w)
+        fes.SolveM (rho=CoefficientFunction(1), vec=w)
+        u.vec.data -= tau * w
+        t += tau
+
+        if count%vtk_interval==0 and do_vtk:
+            vtk.Do(time=t)
+        count = count+1;
+
+        comm.Barrier()

ngsolve/directsolvers.py

@@ -0,0 +1,26 @@
+from ngsolve import BaseMatrix, BitArray, BilinearForm, BaseVector
+
+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):
+        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))
+
+    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/directsolvers.pyi

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from ngsolve.comp import BilinearForm
+import ngsolve.la
+from ngsolve.la import BaseMatrix
+from ngsolve.la import BaseVector
+import pyngcore.pyngcore
+from pyngcore.pyngcore import BitArray
+__all__: list[str] = ['BaseMatrix', 'BaseVector', 'BilinearForm', 'BitArray', 'SuperLU']
+class SuperLU(ngsolve.la.BaseMatrix):
+    def Mult(self, x: ngsolve.la.BaseVector, y: ngsolve.la.BaseVector):
+        ...
+    def Update(self):
+        ...
+    def __init__(self, a, freedofs: pyngcore.pyngcore.BitArray = None):
+        ...