def make_geo():
import netgen.geom2d as geom2d
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)
return geo
def geo2():
geo = geom2d.SplineGeometry()
# geo.AddRectangle2((0, 0), (1,1), ld=1, rd=0, bcs = ("bottom", "right", "top", "left"))
geo.AddRectangle2((0, 0), (0.25, 0.25),
ld=2,
rd=[0, 1, 1, 0],
bcs=("bottom", "inner", "inner", "left"))
geo.AddRectangle2((0.25, 0.25), (0.5, 0.5),
ld=2,
rd=1,
bcs=("inner", "inner", "inner", "inner"))
geo.AddRectangle2((0.5, 0.5), (0.75, 0.75),
ld=2,
rd=1,
bcs=("inner", "inner", "inner", "inner"))
geo.AddRectangle2((0.75, 0.75), (1, 1),
ld=2,
rd=[1, 0, 0, 1],
bcs=("inner", "right", "top", "inner"))
br = geo.AppendPoint(1, 0)
tl = geo.AppendPoint(0, 1)
geo.Append(["line", 3, tl], leftdomain=0, rightdomain=1, bc="left")
geo.Append(["line", tl, 15], leftdomain=0, rightdomain=1, bc="top")
geo.Append(["line", 1, br], leftdomain=1, rightdomain=0, bc="bottom")
geo.Append(["line", br, 13], leftdomain=1, rightdomain=0, bc="right")
geo.SetMaterial(1, "mat_a")
geo.SetMaterial(2, "mat_b")
return geo
def gen_2dbeam(maxh, nref, comm, lens=[10, 1]):
geo = geom2d.SplineGeometry()
geo.AddRectangle((0, 0), (lens[0], lens[1]),
leftdomain=1,
rightdomain=0,
bcs=("bottom", "right", "top", "left"))
return gen_ref_mesh(geo, maxh, nref, comm)
def test_pickle_geom2d():
import netgen.geom2d as geom2d
geo = geom2d.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 = [geo.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:
geo.Append(["line", pnums[p1], pnums[p2]],
bc=bc,
leftdomain=left,
rightdomain=right)
geo_dump = pickle.dumps(geo)
geo2 = pickle.loads(geo_dump)
vd1 = geo._visualizationData()
vd2 = geo2._visualizationData()
for val1, val2 in zip(vd1.values(), vd2.values()):
assert numpy.array_equal(val1, val2)
def geo3(stretch=1e2):
geo = geom2d.SplineGeometry()
geo.AddRectangle2((0, 0), (stretch, 1),
ld=1,
rd=0,
bcs=("bottom", "right", "top", "left"))
geo.SetMaterial(1, "mat_a")
return geo
def corners_2d(N=4, touch=True):
geo = geom2d.SplineGeometry()
nsqs = N + 1
h = 1 / (nsqs + (0 if touch else 1))
pts = [
geo.AppendPoint(*p)
for p in [(0, 0), (h, 0), (1, 0), (1, 1 - h), (1, 1), (1 - h,
1), (0,
1), (0, h)]
]
trco = (h, h)
tr = geo.AppendPoint(*trco)
if touch:
geo.Append(["line", 0, 1], leftdomain=2, rightdomain=0, bc="bottom")
geo.Append(["line", 1, tr], leftdomain=2, rightdomain=1, bc="inner")
geo.Append(["line", tr, 7], leftdomain=2, rightdomain=1, bc="inner")
geo.Append(["line", 7, 0], leftdomain=2, rightdomain=0, bc="left")
geo.Append(["line", 1, 2], leftdomain=1, rightdomain=0, bc="left")
geo.Append(["line", 6, 7], leftdomain=1, rightdomain=0, bc="bottom")
nsqs = nsqs - 1
else:
geo.Append(["line", 0, 2], leftdomain=1, rightdomain=0, bc="bottom")
geo.Append(["line", 6, 0], leftdomain=1, rightdomain=0, bc="left")
for k in range(nsqs):
bl = tr
x = trco[0]
trco = (x + h, x + h)
tr = geo.AppendPoint(*trco)
br = geo.AppendPoint(x + h, x)
tl = geo.AppendPoint(x, x + h)
geo.Append(["line", bl, br], leftdomain=2, rightdomain=1, bc="inner")
if k < nsqs - 1:
geo.Append(["line", br, tr],
leftdomain=2,
rightdomain=1,
bc="inner")
geo.Append(["line", tr, tl],
leftdomain=2,
rightdomain=1,
bc="inner")
geo.Append(["line", tl, bl], leftdomain=2, rightdomain=1, bc="inner")
geo.Append(["line", 2, br], leftdomain=1, rightdomain=0, bc="right")
geo.Append(["line", br, tr], leftdomain=2, rightdomain=0, bc="right")
geo.Append(["line", tr, tl], leftdomain=2, rightdomain=0, bc="top")
geo.Append(["line", tl, 6], leftdomain=1, rightdomain=0, bc="top")
geo.SetMaterial(1, "mat_a")
geo.SetMaterial(2, "mat_b")
return geo
def domain2_mesh_2d():
import netgen.geom2d as g2d
import ngsolve as ngs
geo = g2d.SplineGeometry()
geo.AddRectangle((-2, -2), (2, 2))
geo.AddRectangle((-1, -1), (1, 1), leftdomain=2, rightdomain=1)
geo.SetMaterial(1, "outer")
geo.SetMaterial(2, "inner")
return ngs.Mesh(geo.GenerateMesh(maxh=0.5))
def generateMesh(filename, mp):
folder = os.path.join("..","..","tutorials") if filename in _geofiles else "geofiles"
if filename.endswith(".geo"):
geo = csg.CSGeometry(os.path.join(folder, filename))
elif filename.endswith(".stl"):
geo = stl.STLGeometry(os.path.join(folder, filename))
elif filename.endswith(".step"):
geo = occ.OCCGeometry(os.path.join(folder, filename))
elif filename.endswith(".in2d"):
geo = geom2d.SplineGeometry(os.path.join(folder, filename))
return geo.GenerateMesh(mp)
def example6():
geo = g2.SplineGeometry()
p1 = geo.AppendPoint(0, 0)
p2 = geo.AppendPoint(1, 0)
p3 = geo.AppendPoint(1, 1)
p4 = geo.AppendPoint(0, 1)
geo.Append(["line", p1, p2])
geo.Append(["line", p2, p3])
geo.Append(["line", p3, p4])
geo.Append(["line", p4, p1])
mesh = geo.GenerateMesh(maxh=0.5, quad_dominated=True)
print(len(mesh.Points()))
def example4():
geo = g2.SplineGeometry()
p1, p2, p3, p4 = [
geo.AppendPoint(x, y) for x, y in [(0, 0), (1, 0), (1, 1), (0, 1)]
]
geo.Append(["line", p1, p2], maxh=0.1)
geo.Append(["line", p2, p3])
geo.Append(["line", p3, p4])
geo.Append(["line", p4, p1])
geo.SetDomainMaxH(1, 0.1) # 对指定区域按照第二个参数设置全域网格大小
geo.SetMaterial(1, "iron")
mesh = geo.GenerateMesh()
# print(geo.SetMaterial(1, "iron"))
print(len(mesh.Points()))
def example2():
geo = g2.SplineGeometry()
p1, p2, p3, p4 = [
geo.AppendPoint(x, y) for x, y in [(0, 0), (1, 0), (1, 1), (0, 1)]
]
geo.Append(["line", p1, p2])
geo.Append(["spline3", p2, p3, p4])
geo.Append(["line", p4, p1])
mesh = geo.GenerateMesh(maxh=0.1)
for p in mesh.Points():
x, y, z = p.p
print(x, y)
for el in mesh.Elements2D():
print(el.vertices)
def square_conductivity_geo():
"""Return geometry for a square with high conductivity area."""
geo = geom2d.SplineGeometry() # pylint: disable=no-member
p1, p2, p3, p4 = [
geo.AppendPoint(x, y) for x, y in [(0, 0), (1, 0), (1, 1), (0, 1)]
]
geo.Append(['line', p1, p2], leftdomain=1, rightdomain=0, bc='dirichlet')
geo.Append(['line', p2, p3], leftdomain=1, rightdomain=0, bc='dirichlet')
geo.Append(['line', p3, p4], leftdomain=1, rightdomain=0, bc='dirichlet')
geo.Append(['line', p4, p1], leftdomain=1, rightdomain=0)
geo.AddRectangle((0.2, 0.6), (0.8, 0.7), leftdomain=2, rightdomain=1)
return geo
def geo1():
geo = geom2d.SplineGeometry()
geo.AddRectangle((0, 0), (1, 1),
leftdomain=1,
rightdomain=0,
bcs=("bottom", "right", "top", "left"))
geo.AddRectangle((0.25, 0.25), (0.5, 0.5),
leftdomain=2,
rightdomain=1,
bcs=("inner", "inner", "inner", "inner"))
geo.AddRectangle((0.5, 0.5), (0.75, 0.75),
leftdomain=2,
rightdomain=1,
bcs=("inner", "inner", "inner", "inner"))
geo.SetMaterial(1, "mat_a")
geo.SetMaterial(2, "mat_b")
return geo
def example3():
geo = g2.SplineGeometry()
p1, p2, p3, p4 = [
geo.AppendPoint(x, y) for x, y in [(0, 0), (1, 0), (1, 1), (0, 1)]
]
p5, p6 = [geo.AppendPoint(x, y) for x, y in [(2, 0), (2, 1)]]
# 可以给出多个区域的网格，默认是左边是1，右边是0，如果区域增加就需要更多的数字
geo.Append(["line", p1, p2], leftdomain=1, rightdomain=0)
geo.Append(["line", p2, p3], leftdomain=1, rightdomain=2)
geo.Append(["line", p3, p4], leftdomain=1, rightdomain=0)
geo.Append(["line", p4, p1], leftdomain=1, rightdomain=0)
geo.Append(["line", p2, p5], leftdomain=2, rightdomain=0)
geo.Append(["line", p5, p6], leftdomain=2, rightdomain=0)
geo.Append(["line", p6, p3], leftdomain=2, rightdomain=0)
mesh = geo.GenerateMesh(maxh=0.1)
for p in mesh.Points():
x, y, z = p.p
print(x, y)
def loadGeometryFile():
filename, filt = QtWidgets.QFileDialog.getOpenFileName(caption = "Load Geometry",
filter = "Geometry file (*.in2d *.geo *.step *.stp *.iges *.stl *.stlb)")
if filename:
if filename.endswith(".in2d"):
import netgen.geom2d as gm
geo = gm.SplineGeometry(filename)
elif filename.endswith(".geo"):
import netgen.csg as gm
geo = gm.CSGeometry(filename)
elif filename.endswith(".step") or filename.endswith(".stp") or filename.endswith(".iges"):
import netgen.occ as gm
geo = gm.OCCGeometry(filename)
else:
import netgen.stl as gm
geo = gm.STLGeometry(filename)
ngsolve.Draw(geo)
if not self._flags.noConsole:
self.console.pushVariables({"geo" : geo})
def example5():
geo = g2.SplineGeometry()
p1, p2, p3, p4 = [
geo.AppendPoint(x, y) for x, y in [(0, 0), (1, 0), (1, 1), (0, 1)]
]
p5, p6 = [geo.AppendPoint(x, y) for x, y in [(2, 0), (2, 1)]]
# 可以给出多个区域的网格，默认是左边是1，右边是0，如果区域增加就需要更多的数字
geo.Append(["line", p1, p2], leftdomain=1, rightdomain=0, maxh=0.1)
geo.Append(["line", p2, p3], leftdomain=1, rightdomain=2)
geo.Append(["line", p3, p4], leftdomain=1, rightdomain=0)
geo.Append(["line", p4, p1], leftdomain=1, rightdomain=0)
geo.Append(["line", p2, p5], leftdomain=2, rightdomain=0)
geo.Append(["line", p5, p6], leftdomain=2, rightdomain=0)
geo.Append(["line", p6, p3], leftdomain=2, rightdomain=0)
geo.SetDomainMaxH(2, 0.01) # 对指定区域按照第二个参数设置全域网格大小
geo.SetMaterial(2, "iron")
# geo.AddCircle(c=(5, 0), r=0.5, leftdomain=2, rightdomain=1)
# geo.AddRectangle((0, 0), (3, 2))
mesh = geo.GenerateMesh()
for p in mesh.Points():
x, y, z = p.p
print(x, y)
#
# geometric non-linear elasticity with Neo-Hook 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)
u = fes.TrialFunction()
force = CoefficientFunction( (0,1) )
I = Id(mesh.dim)
F = I + u.Deriv() # attention: row .. component, col .. derivative
C = F * F.trans
E = 0.5 * (C-I)
from ngsolve import *
import ngs_petsc as petsc
import netgen.geom2d as geom2d
from netgen.meshing import Mesh as NGMesh
comm = mpi_world
dim, geo = 2, geom2d.SplineGeometry()
geo.AddRectangle((0, 0), (10, 1),
leftdomain=1,
rightdomain=0,
bcs=("left", "outer", "outer", "outer"))
geo.SetMaterial(1, "mat")
if comm.rank == 0:
ngm = geo.GenerateMesh(maxh=0.05)
ngm.Distribute(comm)
else:
ngm = NGMesh.Receive(comm)
ngm.SetGeometry(geo)
mesh = Mesh(ngm)
multidim = dim
V = H1(mesh, order=1, dirichlet="left", dim=multidim)
trials, tests = V.TnT()
u = CoefficientFunction(tuple(trials[k] for k in range(dim)))
gradu = CoefficientFunction(tuple(
grad(trials)[i, j] for i in range(dim) for j in range(dim)),
dims=(dim, dim))
epsu = 0.5 * (gradu + gradu.trans)
ut = CoefficientFunction(tuple(tests[k] for k in range(dim)))
def _loadin2d(gui, filename):
import netgen.geom2d as geom2d
geo = geom2d.SplineGeometry(filename)
ngsolve.Draw(geo)
import math
from ngsolve import *
import netgen.geom2d as gm
SetHeapSize(50 * 1000 * 1000)
# geometrical and material properties
geo = gm.SplineGeometry()
xneg = -0.43
xpos = 0.43
yneg = -0.48
ypos = 0.48
wslab = 0.04
cringx = 0.0
cringy = 0.0
rring = 0.4
gap = 0.005
pntx = [xneg, xpos]
pnty = [
yneg, -rring - gap - wslab, -rring - gap, rring + gap, rring + gap + wslab,
ypos
]
pts = []
for yi in pnty:
for xi in pntx:
pts.append(geo.AddPoint(xi, yi))
#### parameters for source position
def solve(self):
# disable garbage collector
# --------------------------------------------------------------------#
gc.disable()
while (gc.isenabled()):
time.sleep(0.1)
# --------------------------------------------------------------------#
# measure how much memory is used until here
process = psutil.Process()
memstart = process.memory_info().vms
# starts timer
tstart = time.time()
if self.show_gui:
import netgen.gui
# create mesh with initial size 0.1
geo = geom2d.SplineGeometry()
p1 = geo.AppendPoint(-2, -2)
p2 = geo.AppendPoint(2, -2)
p3 = geo.AppendPoint(2, 2)
p4 = geo.AppendPoint(-2, 2)
geo.Append(["line", p1, p2])
geo.Append(["line", p2, p3])
geo.Append(["line", p3, p4])
geo.Append(["line", p4, p1])
self._mesh = ngs.Mesh(geo.GenerateMesh(maxh=0.1))
#create finite element space
self._fes = ngs.H1(self._mesh,
order=2,
dirichlet=".*",
autoupdate=True)
# test and trail function
u = self._fes.TrialFunction()
v = self._fes.TestFunction()
# create bilinear form and enable static condensation
self._a = ngs.BilinearForm(self._fes, condense=True)
self._a += ngs.grad(u) * ngs.grad(v) * ngs.dx
# creat linear functional and apply RHS
self._f = ngs.LinearForm(self._fes)
self._f += (
-(18 * ngs.x * ngs.x - 6) *
ngs.exp(-1.5 * (ngs.x * ngs.x + ngs.y * ngs.y)) -
(18 * ngs.y * ngs.y - 6) *
ngs.exp(-1.5 * (ngs.x * ngs.x + ngs.y * ngs.y)) - 6 *
(6 * ngs.x**2 + 12 * ngs.x + 5) * ngs.exp(-3 *
((ngs.x + 1)**2 +
(ngs.y + 1)**2)) - 6 *
(6 * ngs.y**2 + 12 * ngs.y + 5) * ngs.exp(-3 *
((ngs.x + 1)**2 +
(ngs.y + 1)**2)) - 6 *
(6 * ngs.x**2 - 12 * ngs.x + 5) * ngs.exp(-3 *
((ngs.x - 1)**2 +
(ngs.y + 1)**2)) - 6 *
(6 * ngs.y**2 + 12 * ngs.y + 5) * ngs.exp(-3 *
((ngs.x - 1)**2 +
(ngs.y + 1)**2)) - 6 *
(6 * ngs.x**2 + 12 * ngs.x + 5) * ngs.exp(-3 *
((ngs.x + 1)**2 +
(ngs.y - 1)**2)) - 6 *
(6 * ngs.y**2 - 12 * ngs.y + 5) * ngs.exp(-3 *
((ngs.x + 1)**2 +
(ngs.y - 1)**2)) - 6 *
(6 * ngs.x**2 - 12 * ngs.x + 5) * ngs.exp(-3 *
((ngs.x - 1)**2 +
(ngs.y - 1)**2)) - 6 *
(6 * ngs.y**2 - 12 * ngs.y + 5) * ngs.exp(-3 * (
(ngs.x - 1)**2 + (ngs.y - 1)**2))) * v * ngs.dx
# preconditioner: multigrid - what prerequisits must the problem have?
self._c = ngs.Preconditioner(self._a, "multigrid")
# create grid function that holds the solution and set the boundary to 0
self._gfu = ngs.GridFunction(self._fes, autoupdate=True) # solution
self._g = self._ngs_ex
self._gfu.Set(self._g, definedon=self._mesh.Boundaries(".*"))
# draw grid function in gui
if self.show_gui:
ngs.Draw(self._gfu)
# create Hcurl space for flux calculation and estimate error
self._space_flux = ngs.HDiv(self._mesh, order=2, autoupdate=True)
self._gf_flux = ngs.GridFunction(self._space_flux,
"flux",
autoupdate=True)
# TaskManager starts threads that (standard thread nr is numer of cores)
#with ngs.TaskManager():
# this is the adaptive loop
while self._fes.ndof < self.max_ndof:
self._solveStep()
self._estimateError()
self._mesh.Refine()
# since the adaptive loop stopped with a mesh refinement, the gfu must be
# calculated one last time
self._solveStep()
if self.show_gui:
ngs.Draw(self._gfu)
# set measured exectution time
self._exec_time = time.time() - tstart
# set measured used memory
memstop = process.memory_info().vms - memstart
self._mem_consumption = memstop
# enable garbage collector
# --------------------------------------------------------------------#
gc.enable()
gc.collect()
from ngsolve import *
import netgen.geom2d as geom2dim
import matplotlib.pyplot as plt
import numpy as np
#### CODE ####
# Setup the mesh
default = input("Use default settings (h=0.1,k=3)? (y/n): ")
if default == 'y' or default == 'Y':
h = 1e-1
k = 3
else:
h = float(input("mesh_size -> h= "))
k = int(input("order -> k= "))
geo = geom2dim.SplineGeometry()
geo.AddRectangle((0, 0), (1, 1), bcs=['b', 'r', 't', 'l'], leftdomain=1)
geo.SetMaterial(1, "d1")
mesh = Mesh(geo.GenerateMesh(maxh=h)) # standard mesh available
print('#' * 40)
print("Mesh generated:")
print('#' * 40)
print("Number of vertices: ", mesh.nv)
print("Number of elements: ", mesh.ne)
print("Mesh size: ", h)
Draw(mesh)
####### Setup #######
print('#' * 40)
print("Solving PDE...")
