ngsolve 6.2.2405.post37.dev1__cp313-cp313-macosx_10_15_universal2.whl → 6.2.2405.post53.dev1__cp313-cp313-macosx_10_15_universal2.whl

ngsolve/demos/howto/hhj.py

@@ -0,0 +1,44 @@
+#
+# The Hellan-Herrmann-Johnson method for a Kirchhoff plate
+# 
+# M. I. Comodi: The Hellan–Herrmann-Johnson Method
+# Some error estimates and postprocessing. Math. Comp. 52, 17–39, 1989
+# 
+
+from ngsolve import *
+from netgen.geom2d import unit_square
+
+mesh = Mesh (unit_square.GenerateMesh(maxh=0.05))
+order = 3
+
+V = HDivDiv(mesh, order=order-1)
+Q = H1(mesh, order=order, dirichlet="left|right|top|bottom")
+X = V*Q
+
+print ("ndof-V:", V.ndof, ", ndof-Q:", Q.ndof)
+
+sigma, u = X.TrialFunction()
+tau, v = X.TestFunction()
+
+n = specialcf.normal(2)
+
+def tang(u): return u-(u*n)*n
+
+a = BilinearForm(X, symmetric=True)
+a += (InnerProduct (sigma, tau) + div(sigma)*grad(v) + div(tau)*grad(u) - 1e-10*u*v)*dx
+a += (-(sigma*n) * tang(grad(v)) - (tau*n)*tang(grad(u)))*dx(element_boundary=True)
+a.Assemble()
+
+f = LinearForm(X)
+f += 1 * v * dx
+# f += Trace(tau.Trace()) * ds("bottom")
+f.Assemble()
+
+u = GridFunction(X)
+u.vec.data = a.mat.Inverse(X.FreeDofs()) * f.vec
+
+Draw (u.components[0], mesh, name="sigma")
+Draw (u.components[1], mesh, name="disp")
+
+
+

ngsolve/demos/howto/hybrid_dg.py

@@ -0,0 +1,53 @@
+from netgen.geom2d import unit_square
+from ngsolve import *
+
+
+ngsglobals.msg_level = 1
+mesh = Mesh(unit_square.GenerateMesh(maxh=0.4))
+for k in range(5):
+    mesh.Refine()
+
+
+order = 3
+fes1 = L2(mesh, order=order)
+fes2 = FacetFESpace(mesh, order=order, dirichlet="bottom|right|top")
+
+print ("element dofs: ", fes1.ndof)
+print ("facet dofs: ", fes2.ndof)
+
+fes = fes1*fes2
+
+u,uhat = fes.TrialFunction()
+v,vhat = fes.TestFunction()
+
+n = specialcf.normal(mesh.dim)
+h = specialcf.mesh_size
+
+a = BilinearForm(fes, symmetric=True, condense = True)
+a += grad(u) * grad(v) * dx
+a += (grad(u)*n*(vhat-v)+grad(v)*n*(uhat-u)+10*order*order/h*(u-uhat)*(v-vhat))*dx(element_boundary=True)
+
+c = Preconditioner(type="direct", bf=a, inverse = "sparsecholesky")
+# c = Preconditioner(type="bddc", bf=a)
+
+with TaskManager():
+    a.Assemble()
+    ainv = CGSolver(a.mat, c.mat)
+
+f = LinearForm(fes)
+f += 1*v*dx
+f.Assemble()
+
+u = GridFunction(fes)
+
+
+f.vec.data += a.harmonic_extension_trans * f.vec
+
+u.vec.data = ainv * f.vec
+
+u.vec.data += a.harmonic_extension * u.vec
+u.vec.data += a.inner_solve * f.vec
+
+Draw (u.components[0], mesh, "sol")
+
+

ngsolve/demos/howto/mixed.py

@@ -0,0 +1,30 @@
+from netgen.geom2d import unit_square
+from ngsolve import *
+
+ngsglobals.msg_level = 1
+
+mesh = Mesh(unit_square.GenerateMesh(maxh=0.1))
+
+order = 2
+fes1 = HDiv(mesh, order=order)
+fes2 = L2(mesh, order=order-1)
+
+fes = fes1*fes2
+
+sigma,u = fes.TrialFunction()
+tau,v = fes.TestFunction()
+
+a = BilinearForm(fes)
+a += (sigma*tau + div(sigma)*v + div(tau)*u - 1e-10*u*v)*dx
+# (regularization needed for direct solver)
+a.Assemble()
+
+f = LinearForm(fes)
+f += -v*dx
+f.Assemble()
+
+u = GridFunction(fes)
+u.vec.data = a.mat.Inverse(fes.FreeDofs()) * f.vec
+
+Draw (u.components[0], mesh, "flux")
+Draw (u.components[1], mesh, "sol")

ngsolve/demos/howto/nonlin.py

@@ -0,0 +1,29 @@
+from netgen.geom2d import unit_square
+from ngsolve import *
+
+m = Mesh (unit_square.GenerateMesh(maxh=0.3))
+
+V = H1(m, order=3, dirichlet="left|right|top|bottom")
+u = V.TrialFunction()
+v = V.TestFunction()
+
+a = BilinearForm(V)
+a += ( grad(u) * grad(v) + 5*u*u*v- 1 * v)*dx
+
+u = GridFunction(V)
+r = u.vec.CreateVector()
+w = u.vec.CreateVector()
+
+for it in range(5):
+    print ("Iteration",it)
+    a.Apply(u.vec, r)
+    a.AssembleLinearization(u.vec)
+    
+    w.data = a.mat.Inverse(V.FreeDofs()) * r.data
+    print ("|w| =", w.Norm())
+    u.vec.data -= w
+
+    Draw(u)
+    input("<press a key>")
+    
+    

ngsolve/demos/howto/pickling.py

@@ -0,0 +1,26 @@
+from ngsolve import *
+import netgen.geom2d
+
+mesh = Mesh (netgen.geom2d.unit_square.GenerateMesh(maxh=0.1))
+
+v = FESpace ("h1ho", mesh, order=4, dirichlet=[1])
+v2 = L2(mesh,order=2)
+u = GridFunction (v)
+u2 = GridFunction(v)
+vec = u.vec
+data = [v,v2,u,u2,u.vec]
+
+import pickle
+pickler = pickle.Pickler(open ("1.dat", "wb"))
+pickler.dump (data)
+del pickler
+
+unpickler = pickle.Unpickler(open("1.dat","rb"))
+fes,fes2,w,w2,z = unpickler.load()
+
+assert fes.mesh is fes2.mesh
+assert w.space is w2.space
+
+assert len(z) == len(u.vec)
+for i in range(len(u.vec)):
+    assert u.vec[i] == z[i]

ngsolve/demos/howto/pml.py

@@ -0,0 +1,31 @@
+from netgen.geom2d import SplineGeometry
+from ngsolve import *
+
+geo = SplineGeometry()
+geo.AddCircle( (0,0), 1.4, leftdomain=2)
+geo.AddCircle( (0,0), 1, leftdomain=1, rightdomain=2)
+geo.SetMaterial(1, "inner")
+geo.SetMaterial(2, "pml")
+mesh = Mesh(geo.GenerateMesh (maxh=0.1))
+
+mesh.SetPML(pml.Radial(rad=1,alpha=1j,origin=(0,0)), "pml")
+
+fes = H1(mesh, order=4, complex=True)
+u = fes.TrialFunction()
+v = fes.TestFunction()
+
+omega = 10
+
+a = BilinearForm(fes)
+a += (grad(u)*grad(v)-omega*omega*u*v)*dx
+
+f = LinearForm(fes)
+f += exp(-20**2*((x-0.3)*(x-0.3)+y*y))*v*dx
+
+a.Assemble()
+f.Assemble()
+
+gfu = GridFunction(fes)
+gfu.vec.data = a.mat.Inverse() * f.vec
+
+Draw(gfu)

ngsolve/demos/howto/taskmanager.py

@@ -0,0 +1,20 @@
+from netgen.csg import unit_cube
+from ngsolve import *
+
+mesh = Mesh (unit_cube.GenerateMesh(maxh=0.4))
+for l in range(3):
+    mesh.Refine()
+
+fes = H1(mesh, order=3)
+u,v = fes.TnT()
+a = BilinearForm(fes)
+a += grad(u) * grad(v) * dx
+
+
+print('sequential assembly...')
+a.Assemble()
+
+print('parallel assembly...')
+with TaskManager():
+    a.Assemble()
+    

ngsolve/demos/howto/tdnns.py

@@ -0,0 +1,47 @@
+#
+# The tangential-displacement normal-normal-stress continuous method for elasticity
+#
+# A.S. Pechstein and J. Schoeberl:
+# Tangential-displacement and normal-normal-stress continuous mixed finite elements for elasticity.
+# Mathematical Models and Methods in Applied Sciences 21(8), 1761–1782, 2011.
+# 
+
+from ngsolve import *
+from netgen.geom2d import SplineGeometry
+
+geo = SplineGeometry()
+geo.AddRectangle( (0, 0), (10, 1), bcs = ("bottom", "right", "top", "left"))
+mesh = Mesh( geo.GenerateMesh(maxh=0.5))
+
+order = 3
+V = HDivDiv(mesh, order=order-1, dirichlet="bottom|right|top", plus = True)
+Q = HCurl(mesh, order=order, dirichlet="left", type1 = True)
+X = V*Q
+
+print ("ndof-V:", V.ndof, ", ndof-Q:", Q.ndof)
+
+sigma, u = X.TrialFunction()
+tau, v = X.TestFunction()
+
+n = specialcf.normal(2)
+
+def tang(u): return u-(u*n)*n
+
+a = BilinearForm(X, symmetric=True)
+a += (InnerProduct (sigma, tau) + div(sigma)*v + div(tau)*u - 1e-10 * u*v)*dx
+a += (-(sigma*n) * tang(v) - (tau*n)*tang(u))*dx(element_boundary=True)
+a.Assemble()
+
+f = LinearForm(X)
+f +=  1 * v[1] * dx
+f.Assemble()
+
+u = GridFunction(X)
+u.vec.data = a.mat.Inverse(X.FreeDofs(), inverse="sparsecholesky") * f.vec
+
+Draw (u.components[0], mesh, name="sigma")
+Draw (u.components[1], mesh, name="disp")
+
+Draw (u.components[0][0], mesh, name="s11")
+
+

ngsolve/demos/howto/timeDG-skeleton.py

@@ -0,0 +1,45 @@
+from netgen.geom2d import unit_square
+from ngsolve import *
+
+mesh = Mesh (unit_square.GenerateMesh(maxh=0.1))
+
+fes = L2(mesh, order=4) 
+
+u = fes.TrialFunction()
+v = fes.TestFunction()
+
+b = CoefficientFunction( (y-0.5,0.5-x) )
+bn = b*specialcf.normal(2)
+
+ubnd = CoefficientFunction(0)
+
+a = BilinearForm(fes)
+a += (-u * b*grad(v)) .Compile()*dx
+
+# the skeleton-formulation, sum over edges:
+a += bn*IfPos(bn, u, u.Other()) * (v-v.Other()) * dx(skeleton=True)
+a += bn*IfPos(bn, u, ubnd) * v * ds(skeleton=True)
+
+# or the element-boundary formulation
+# note the bnd-value in the .Other operator
+# a += bn*IfPos(bn, u, u.Other(bnd=ubnd)) * v * dx(element_boundary=True)
+
+u = GridFunction(fes)
+u.Set(exp (-40 * ( (x-0.7)*(x-0.7) + (y-0.7)*(y-0.7) )))
+
+w = u.vec.CreateVector()
+
+Draw (u, autoscale=False, sd=2)
+
+t = 0
+tau = 1e-3
+tend = 10
+
+with TaskManager():
+    while t < tend:
+        a.Apply (u.vec, w)
+        fes.SolveM (rho=CoefficientFunction(1), vec=w)
+        u.vec.data -= tau * w
+        t += tau
+        Redraw()
+    

ngsolve/demos/howto/timeDG.py

@@ -0,0 +1,38 @@
+from netgen.geom2d import unit_square
+from ngsolve import *
+
+mesh = Mesh (unit_square.GenerateMesh(maxh=0.1))
+
+fes = L2(mesh, order=4)
+
+u = fes.TrialFunction()
+v = fes.TestFunction()
+
+b = CoefficientFunction( (y-0.5,0.5-x) )
+bn = b*specialcf.normal(2)
+
+ubnd = CoefficientFunction(0)
+
+a = BilinearForm(fes)
+a += -u * b*grad(v) * dx
+a += bn*IfPos(bn, u, u.Other(bnd=ubnd)) * v * dx(element_boundary=True)
+
+u = GridFunction(fes)
+u.Set(exp (-40 * ( (x-0.7)*(x-0.7) + (y-0.7)*(y-0.7) )))
+
+w = u.vec.CreateVector()
+
+Draw (u, autoscale=False, sd=2)
+
+t = 0
+tau = 1e-3
+tend = 10
+
+with TaskManager():
+    while t < tend:
+        a.Apply (u.vec, w)
+        fes.SolveM (rho=CoefficientFunction(1), vec=w)
+        u.vec.data -= tau * w
+        t += tau
+        Redraw()
+    

ngsolve/demos/howto/timeDGlap.py

@@ -0,0 +1,42 @@
+from netgen.geom2d import unit_square
+from ngsolve import *
+
+mesh = Mesh (unit_square.GenerateMesh(maxh=0.05))
+
+order=2
+fes = L2(mesh, order=order)
+
+u = fes.TrialFunction()
+v = fes.TestFunction()
+
+u0 = exp (-40 * ( (x-0.5)*(x-0.5) + (y-0.5)*(y-0.5) ))
+
+n = specialcf.normal(2)
+h = specialcf.mesh_size
+
+a = BilinearForm(fes)
+a += grad(u) * grad(v) * dx
+cf1 = -0.5 * InnerProduct(grad(u), n)*(v-v.Other(bnd=0))
+cf2 = -0.5 * InnerProduct(grad(v), n)*(u-u.Other(bnd=u0))
+cf3 = 2*( (order+1)**2)/h * (u-u.Other(bnd=u0)) * v
+a += (cf1+cf2+cf3)*dx(element_boundary=True)
+
+u = GridFunction(fes)
+u.Set(u0)
+
+w = u.vec.CreateVector()
+
+Draw (u, mesh, "u")
+
+tau = 2e-6
+tend = 0.5
+
+t = 0
+with TaskManager():
+    while t < tend:
+        a.Apply (u.vec, w)
+        fes.SolveM (rho=CoefficientFunction(1), vec=w)
+        u.vec.data -= tau * w
+        t += tau
+        Redraw()
+    

ngsolve/demos/howto/timeDGwave.py

@@ -0,0 +1,61 @@
+from netgen.geom2d import unit_square
+from ngsolve import *
+
+mesh = Mesh (unit_square.GenerateMesh(maxh=0.05))
+
+order=4
+fes1 = L2(mesh, order=order)
+fes = fes1*fes1*fes1
+
+p,ux,uy = fes.TrialFunction()
+q,vx,vy = fes.TestFunction()
+
+u0 = exp (-400 * ( (x-0.5)*(x-0.5) + (y-0.5)*(y-0.5) ))
+
+n = specialcf.normal(2)
+
+v = CoefficientFunction( (vx, vy) )
+u = CoefficientFunction( (ux, uy) )
+
+a1 = BilinearForm(fes)
+a1 += grad(p) * v * dx
+a1 += -0.5 * (p - p.Other()) * (v*n) * dx(element_boundary = True)
+
+a2 = BilinearForm(fes)
+a2 += -grad(q) * u * dx
+a2 += 0.5 * (q - q.Other()) * (u*n) * dx(element_boundary = True)
+
+
+u = GridFunction(fes)
+u.components[0].Set(u0)
+
+res = u.vec.CreateVector()
+w = u.vec.CreateVector()
+
+Draw (u.components[1], mesh, "ux")
+Draw (u.components[2], mesh, "uy")
+Draw (u.components[0], mesh, "p")
+SetVisualization(min=-0.1, max=0.1, deformation=True)
+
+tau = 1e-3
+tend = 3
+
+t = 0
+nd = fes1.ndof
+
+input ("<press enter>")
+
+with TaskManager():
+    while t < tend:
+        a1.Apply (u.vec, w)
+        fes1.SolveM (rho=CoefficientFunction(1), vec=w.Range(nd,2*nd))
+        fes1.SolveM (rho=CoefficientFunction(1), vec=w.Range(2*nd,3*nd))
+        u.vec.data -= tau * w
+
+        a2.Apply (u.vec, w)
+        fes1.SolveM (rho=CoefficientFunction(1), vec=w.Range(0,nd))
+        u.vec.data -= tau * w
+
+        t += tau
+        Redraw()
+    

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

@@ -0,0 +1,62 @@
+from netgen.csg 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)
+
+# 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)