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/demos/intro/adaptive.py

@@ -0,0 +1,123 @@
+from ngsolve import *
+from netgen.geom2d import SplineGeometry
+
+
+#   point numbers 0, 1, ... 11
+#   sub-domain numbers (1), (2), (3)
+#  
+#
+#             7-------------6
+#             |             |
+#             |     (2)     |
+#             |             |
+#      3------4-------------5------2
+#      |                           |
+#      |             11            |
+#      |           /   \           |
+#      |         10 (3) 9          |
+#      |           \   /     (1)   |
+#      |             8             |
+#      |                           |
+#      0---------------------------1
+#
+
+def MakeGeometry():
+    geometry = SplineGeometry()
+    
+    # point coordinates ...
+    pnts = [ (0,0), (1,0), (1,0.6), (0,0.6), \
+             (0.2,0.6), (0.8,0.6), (0.8,0.8), (0.2,0.8), \
+             (0.5,0.15), (0.65,0.3), (0.5,0.45), (0.35,0.3) ]
+    pnums = [geometry.AppendPoint(*p) for p in pnts]
+    
+    # start-point, end-point, boundary-condition, domain on left side, domain on right side:
+    lines = [ (0,1,1,1,0), (1,2,2,1,0), (2,5,2,1,0), (5,4,2,1,2), (4,3,2,1,0), (3,0,2,1,0), \
+              (5,6,2,2,0), (6,7,2,2,0), (7,4,2,2,0), \
+              (8,9,2,3,1), (9,10,2,3,1), (10,11,2,3,1), (11,8,2,3,1) ]
+        
+    for p1,p2,bc,left,right in lines:
+        geometry.Append( ["line", pnums[p1], pnums[p2]], bc=bc, leftdomain=left, rightdomain=right)
+    return geometry
+
+
+
+mesh = Mesh(MakeGeometry().GenerateMesh (maxh=0.2))
+
+
+fes = H1(mesh, order=3, dirichlet=[1], autoupdate=True)
+u = fes.TrialFunction()
+v = fes.TestFunction()
+
+# one heat conductivity coefficient per sub-domain
+lam = CoefficientFunction([1, 1000, 10])
+a = BilinearForm(fes, symmetric=False)
+a += lam*grad(u)*grad(v)*dx
+
+
+# heat-source in sub-domain 3
+f = LinearForm(fes)
+f += CoefficientFunction([0, 0, 1])*v*dx
+
+c = MultiGridPreconditioner(a, inverse = "sparsecholesky")
+
+gfu = GridFunction(fes, autoupdate=True)
+Draw (gfu)
+
+# finite element space and gridfunction to represent
+# the heatflux:
+space_flux = HDiv(mesh, order=2, autoupdate=True)
+gf_flux = GridFunction(space_flux, "flux", autoupdate=True)
+
+def SolveBVP():
+    a.Assemble()
+    f.Assemble()
+    inv = CGSolver(a.mat, c.mat)
+    gfu.vec.data = inv * f.vec
+    Redraw (blocking=True)
+
+
+
+l = []
+
+def CalcError():
+    flux = lam * grad(gfu)
+    # interpolate finite element flux into H(div) space:
+    gf_flux.Set (flux)
+
+    # Gradient-recovery error estimator
+    err = 1/lam*(flux-gf_flux)*(flux-gf_flux)
+    elerr = Integrate (err, mesh, VOL, element_wise=True)
+
+    maxerr = max(elerr)
+    l.append ( (fes.ndof, sqrt(sum(elerr)) ))
+    print ("maxerr = ", maxerr)
+
+    for el in mesh.Elements():
+        mesh.SetRefinementFlag(el, elerr[el.nr] > 0.25*maxerr)
+
+
+with TaskManager():
+    while fes.ndof < 100000:  
+        SolveBVP()
+        CalcError()
+        mesh.Refine()
+    
+SolveBVP()
+
+
+
+
+## import matplotlib.pyplot as plt
+
+## plt.yscale('log')
+## plt.xscale('log')
+## plt.xlabel("ndof")
+## plt.ylabel("H1 error-estimate")
+## ndof,err = zip(*l)
+## plt.plot(ndof,err, "-*")
+
+## plt.ion()
+## plt.show()
+
+## input("<press enter to quit>")
+

ngsolve-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/ngsolve/demos/intro/cmagnet.py

@@ -0,0 +1,59 @@
+from netgen.occ import *
+from ngsolve import *
+
+
+def MakeGeometry():
+    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)
+
+ngsglobals.msg_level = 5
+
+fes = HCurl(mesh, order=4, dirichlet="outer", nograds = True)
+
+# u and v refer to trial and test-functions in the definition of forms below
+u = fes.TrialFunction()
+v = fes.TestFunction()
+
+mur = mesh.MaterialCF({ "core" : 1000 }, default=1)
+mu0 = 1.257e-6
+nu = 1/(mu0*mur)
+
+a = BilinearForm(fes, symmetric=True)
+a += nu*curl(u)*curl(v)*dx + 1e-6*nu*u*v*dx
+
+c = Preconditioner(a, type="bddc")
+# c = Preconditioner(a, type="multigrid", flags = { "smoother" : "block" } )
+
+f = LinearForm(fes)
+f += CoefficientFunction((y,0.05-x,0)) * v * dx("coil")
+
+u = GridFunction(fes)
+
+
+with TaskManager():
+    a.Assemble()
+    f.Assemble()
+    solver = CGSolver(mat=a.mat, pre=c.mat)
+    u.vec.data = solver * f.vec
+
+
+Draw (u.Deriv(), mesh, "B-field", draw_surf=False)

ngsolve-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/ngsolve/demos/intro/elasticity.py

@@ -0,0 +1,76 @@
+#
+# geometric non-linear elasticity with Neo-Hooke hyperelastic material
+#
+# featuring automatic differentiation in SymbolicEnergy
+#
+
+import netgen.geom2d as geom2d
+from ngsolve import *
+
+geo = geom2d.SplineGeometry()
+pnums = [ geo.AddPoint (x,y,maxh=0.01) for x,y in [(0,0), (1,0), (1,0.1), (0,0.1)] ]
+for p1,p2,bc in [(0,1,"bot"), (1,2,"right"), (2,3,"top"), (3,0,"left")]:
+     geo.Append(["line", pnums[p1], pnums[p2]], bc=bc)
+mesh = Mesh(geo.GenerateMesh(maxh=0.05))
+
+
+E, nu = 210, 0.2
+mu  = E / 2 / (1+nu)
+lam = E * nu / ((1+nu)*(1-2*nu))
+
+fes = H1(mesh, order=2, dirichlet="left", dim=mesh.dim)
+# fes = VectorH1(mesh, order=2, dirichlet="left")
+
+u  = fes.TrialFunction()
+
+force = CoefficientFunction( (0,1/2) )
+
+I = Id(mesh.dim)
+F = I + Grad(u)
+C = F.trans * F
+E = 0.5 * (C-I)
+
+def Pow(a, b):
+    return a**b  # exp (log(a)*b)
+  
+def NeoHooke (C):
+    return 0.5 * mu * (Trace(C-I) + 2*mu/lam * Pow(Det(C),-lam/2/mu) - 1)
+
+
+
+factor = Parameter(1)
+
+a = BilinearForm(fes, symmetric=False)
+a += Variation (NeoHooke(C).Compile()*dx)
+a += Variation ((-factor * InnerProduct(force,u) ).Compile()*dx)
+
+
+u = GridFunction(fes)
+u.vec[:] = 0
+
+res = u.vec.CreateVector()
+w = u.vec.CreateVector()
+
+
+for loadstep in range(10):
+    
+    print ("loadstep", loadstep)
+    factor.Set (loadstep+1)
+    
+    for it in range(5):
+        print ("Newton iteration", it)
+        print ("energy = ", a.Energy(u.vec))
+        a.Apply(u.vec, res)
+        a.AssembleLinearization(u.vec)
+        inv = a.mat.Inverse(fes.FreeDofs() ) 
+        w.data = inv*res
+        print ("err^2 = ", InnerProduct (w,res))
+        u.vec.data -= w
+    
+    Draw (u, mesh, "displacement")
+    SetVisualization (deformation=True)
+    input ("<press a key>")
+
+
+
+    

ngsolve-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/ngsolve/demos/intro/navierstokes.py

@@ -0,0 +1,74 @@
+from ngsolve import *
+
+# viscosity
+nu = 0.001
+
+# timestepping parameters
+tau = 0.001
+tend = 10
+
+from netgen.geom2d import SplineGeometry
+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", maxh=0.02)
+mesh = Mesh( geo.GenerateMesh(maxh=0.07))
+
+mesh.Curve(3)
+
+V = VectorH1(mesh,order=3, dirichlet="wall|cyl|inlet")
+Q = H1(mesh,order=2)
+
+X = V*Q
+
+u,p = X.TrialFunction()
+v,q = X.TestFunction()
+
+stokes = nu*InnerProduct(grad(u), grad(v))+div(u)*q+div(v)*p - 1e-10*p*q
+a = BilinearForm(X, symmetric=True)
+a += stokes*dx
+a.Assemble()
+
+# nothing here ...
+f = LinearForm(X)   
+f.Assemble()
+
+# gridfunction for the solution
+gfu = GridFunction(X)
+
+# parabolic inflow at inlet:
+uin = CoefficientFunction( (1.5*4*y*(0.41-y)/(0.41*0.41), 0) )
+gfu.components[0].Set(uin, definedon=mesh.Boundaries("inlet"))
+
+# solve Stokes problem for initial conditions:
+inv_stokes = a.mat.Inverse(X.FreeDofs())
+
+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, symmetric=True)
+mstar += (u*v + tau*stokes)*dx
+mstar.Assemble()
+inv = mstar.mat.Inverse(X.FreeDofs(), inverse="sparsecholesky")
+
+# the non-linear term 
+conv = BilinearForm(X, nonassemble = True)
+conv += (grad(u) * u) * v * dx
+
+# for visualization
+Draw (Norm(gfu.components[0]), mesh, "velocity", sd=3)
+
+# implicit Euler/explicit Euler splitting method:
+t = 0
+with TaskManager():
+    while t < tend:
+        print ("t=", t, end="\r")
+
+        conv.Apply (gfu.vec, res)
+        res.data += a.mat*gfu.vec
+        gfu.vec.data -= tau * inv * res    
+
+        t = t + tau
+        Redraw()

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