ngsolve 6.2.2501__cp312-cp312-macosx_10_15_universal2.whl → 6.2.2501.post37.dev1__cp312-cp312-macosx_10_15_universal2.whl

ngsolve/demos/howto/nonlin.py

@@ -1,29 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,47 +0,0 @@
-#
-# 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

@@ -1,45 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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)

ngsolve/demos/intro/elasticity.py

@@ -1,76 +0,0 @@
-#
-# 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/demos/intro/navierstokes.py

@@ -1,74 +0,0 @@
-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()