def create_mesh(ng_comm, maxh=0.2, nrefinements=0):
sequential = ng_comm.size == 1
output_directory = 'outputs'
if sequential:
path_to_mesh = Path(output_directory + '/mesh.vol')
if path_to_mesh.exists():
print(
'Sequential: Loading mesh from {0}.'.format(output_directory))
mesh = ng.Mesh(output_directory + '/mesh.vol')
else:
print('Sequential: Creating and saving mesh to {0}.'.format(
output_directory))
ngmesh = unit_square.GenerateMesh(maxh=maxh)
for k in range(nrefinements):
ngmesh.Refine()
ngmesh.Save(output_directory + '/mesh.vol')
mesh = ng.Mesh(ngmesh)
else:
if ng_comm.rank == 0:
print('Rank {0}: Loading mesh from {1}.'.format(
ng_comm.rank, output_directory))
mesh = ng.Mesh(output_directory + '/mesh.vol')
return mesh
def loadMeshFile():
filename, filt = QtWidgets.QFileDialog.getOpenFileName(caption = "Load Mesh",
filter = "Netgen mesh file (*.vol *.vol.gz);; Neutral format (*.mesh *.emt);; Surface format (*.surf);; Universal format (*.unv);; Olaf format (*.emt);; TET format (*.tet);; STL format (*.stl *.stlb);; Pro/ENGINEER neutral format (*.fnf)")
if filename:
if filename.endswith(".vol") or filename.endswith(".vol.gz"):
mesh = ngsolve.Mesh(filename)
else:
from netgen.meshing import ImportMesh
mesh = ngsolve.Mesh(ImportMesh(filename))
ngsolve.Draw(mesh)
if not self._flags.noConsole:
self.console.pushVariables({"mesh" : mesh})
def load_mesh(config: ConfigParser) -> Mesh:
"""
Loads an NGSolve mesh from a .sol file whose file path is specified in the given config file.
Args:
config: A ConfigParser object containing the information from the config file.
Returns:
mesh: The NGSolve mesh pointed to in the config file.
"""
assert type(config) is ConfigParser
try:
mesh_filename = config['MESH']['filename']
except:
raise ValueError(
'No default available for MESH, filename. Please specify a value in the config file.'
)
# Check that the file exists.
if not os.path.isfile(mesh_filename):
raise FileNotFoundError(
'The given mesh file \"{}\" does not exist.'.format(mesh_filename))
# Mesh can be a Netgen mesh or a GMSH mesh.
if mesh_filename.endswith('.msh'):
ngmesh = ReadGmsh(mesh_filename)
mesh = ngs.Mesh(ngmesh)
elif mesh_filename.endswith('.vol'):
ngmesh = ngmsh.Mesh()
ngmesh.Load(mesh_filename)
mesh = ngs.Mesh(ngmesh)
else:
raise TypeError(
'Only .vol (Netgen) and .msh (GMSH) meshes can be used.'
'Your specified filename was \"{}\"'.format(mesh_filename))
# Suppressing the warning about using the default value for curved_elements.
curved_elements = config.get_item(['MESH', 'curved_elements'],
bool,
quiet=True)
if curved_elements:
interp_ord = config.get_item(
['FINITE ELEMENT SPACE', 'interpolant_order'], int)
mesh.Curve(interp_ord)
return mesh
def presets_load_coefficientfunction_into_gridfunction():
# 2D
mesh_2d = ngs.Mesh(unit_square.GenerateMesh(maxh=0.1))
fes_scalar_2d = ngs.H1(mesh_2d, order=2)
fes_vector_2d = ngs.HDiv(mesh_2d, order=2)
fes_mixed_2d = ngs.FESpace([fes_vector_2d, fes_scalar_2d])
# 3D
geo_3d = CSGeometry()
geo_3d.Add(OrthoBrick(Pnt(-1, 0, 0), Pnt(1, 1, 1)).bc('outer'))
mesh_3d = ngs.Mesh(geo_3d.GenerateMesh(maxh=0.3))
fes_scalar_3d = ngs.H1(mesh_3d, order=2)
fes_vector_3d = ngs.HDiv(mesh_3d, order=2)
fes_mixed_3d = ngs.FESpace([fes_vector_3d, fes_scalar_3d])
return mesh_2d, fes_scalar_2d, fes_vector_2d, fes_mixed_2d, mesh_3d, fes_scalar_3d, fes_vector_3d, fes_mixed_3d
def ngsolve_vector_array_factory(length, dim, seed):
if dim not in NGSOLVE_spaces:
mesh = ngmsh.Mesh(dim=1)
if dim > 0:
pids = []
for i in range(dim + 1):
pids.append(
mesh.Add(ngmsh.MeshPoint(ngmsh.Pnt(i / dim, 0, 0))))
for i in range(dim):
mesh.Add(ngmsh.Element1D([pids[i], pids[i + 1]], index=1))
NGSOLVE_spaces[dim] = NGSolveVectorSpace(
ngs.L2(ngs.Mesh(mesh), order=0))
U = NGSOLVE_spaces[dim].zeros(length)
np.random.seed(seed)
for v, a in zip(U._list, np.random.random((length, dim))):
v.to_numpy()[:] = a
if np.random.randint(2):
UU = NGSOLVE_spaces[dim].zeros(length)
for v, a in zip(UU._list, np.random.random((length, dim))):
v.real_part.to_numpy()[:] = a
for u, uu in zip(U._list, UU._list):
u.imag_part = uu.real_part
return U
def _generate_DIM_mesh(self) -> None:
"""
Function to get the nonconformal mesh. This mesh is a simple rectangle or rectangular prism, is constructed of
quadrilateral/hexahedral elements and has exterior boundaries "left", "right", "top", "bottom" (and
"front" and "back" for 3D). See get_Netgen_nonconformal in mesh_helpers for more details.
"""
self.ngmesh = mesh_helpers.get_Netgen_nonconformal(
self.N_mesh, self.scale, self.offset, self.dim)
self.mesh = ngs.Mesh(self.ngmesh)
# Also create a refined mesh to calculate Grad(phi) and |Grad(phi)| on before projecting onto the coarse
# simulation mesh.
self.ngmesh_refined = mesh_helpers.get_Netgen_nonconformal(
self.N, self.scale, self.offset, self.dim)
self.mesh_refined = ngs.Mesh(self.ngmesh_refined)
def test_h1_real():
"""Test h1 amg for real example."""
with ngs.TaskManager():
mesh = ngs.Mesh(unit_square.GenerateMesh(maxh=0.2))
fes = ngs.H1(mesh, dirichlet=[1, 2, 3], order=1)
u = fes.TrialFunction()
v = fes.TestFunction()
# rhs
f = ngs.LinearForm(fes)
f += ngs.SymbolicLFI(v)
f.Assemble()
# lhs
a = ngs.BilinearForm(fes, symmetric=True)
a += ngs.SymbolicBFI(grad(u) * grad(v))
c = ngs.Preconditioner(a, 'h1amg2')
a.Assemble()
solver = ngs.CGSolver(mat=a.mat, pre=c.mat)
gfu = ngs.GridFunction(fes)
gfu.vec.data = solver * f.vec
assert_greater(solver.GetSteps(), 0)
assert_less_equal(solver.GetSteps(), 4)
def Hex():
m = Mesh()
m.dim = 3
pnums = []
pnums.append (m.Add (MeshPoint (Pnt(0,0,0))))
pnums.append (m.Add (MeshPoint (Pnt(1,0,0))))
pnums.append (m.Add (MeshPoint (Pnt(1,1,0))))
pnums.append (m.Add (MeshPoint (Pnt(0,1,0))))
pnums.append (m.Add (MeshPoint (Pnt(0,0,1))))
pnums.append (m.Add (MeshPoint (Pnt(1,0,1))))
pnums.append (m.Add (MeshPoint (Pnt(1,1,1))))
pnums.append (m.Add (MeshPoint (Pnt(0,1,1))))
for i in range(1,7):
m.Add (FaceDescriptor(surfnr=i,domin=1,bc=i))
m.SetBCName(i, str(i))
m.SetMaterial(1, "mat")
m.Add (Element2D (1,[pnums[0],pnums[1], pnums[2], pnums[3]]))
m.Add (Element2D (2,[pnums[0],pnums[1], pnums[5], pnums[4]]))
m.Add (Element2D (3,[pnums[1],pnums[2], pnums[6], pnums[5]]))
m.Add (Element2D (4,[pnums[2],pnums[3], pnums[7], pnums[6]]))
m.Add (Element2D (5,[pnums[3],pnums[0], pnums[4], pnums[7]]))
m.Add (Element2D (6,[pnums[4],pnums[5], pnums[6], pnums[7]]))
m.Add (Element3D (1,pnums))
return ngsolve.Mesh(m)
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 test_code_generation():
mesh = ngs.Mesh(unit_square.GenerateMesh(maxh=0.2))
for order in range(10):
functions = [f(ngs.x + 1j * ngs.y, order) for f in fs_ng]
for f in functions:
f_err = f - f.Compile(True, wait=True)
f_err = f_err * ngs.Conj(f_err)
error = ngs.Integrate(f_err, mesh)
assert abs(error) < 1e-13
def _create_ngsolve_space(dim):
if dim not in _NGSOLVE_spaces:
mesh = ngmsh.Mesh(dim=1)
if dim > 0:
pids = []
for i in range(dim + 1):
pids.append(mesh.Add(ngmsh.MeshPoint(ngmsh.Pnt(i / dim, 0, 0))))
for i in range(dim):
mesh.Add(ngmsh.Element1D([pids[i], pids[i + 1]], index=1))
_NGSOLVE_spaces[dim] = NGSolveVectorSpace(ngs.L2(ngs.Mesh(mesh), order=0))
return _NGSOLVE_spaces[dim]
def test_evaluate():
from netgen.geom2d import unit_square
import ngsolve as ngs
import numpy as np
mesh = ngs.Mesh(unit_square.GenerateMesh(maxh=0.2))
pnts = np.linspace(0.1, 0.9, 9)
cf = ngs.CoefficientFunction((ngs.x, ngs.y))
cf2 = ngs.CoefficientFunction((ngs.y, ngs.x * 1J))
mips = mesh(pnts, 0.5)
vals = cf(mips)
vals2 = cf2(mips)
assert np.linalg.norm(vals - np.array(list(zip(pnts, [0.5] * 10)))) < 1e-10
assert np.linalg.norm(
vals2 - np.array(list(zip([0.5 + 0J] * 10, pnts * 1J)))) < 1e-10
assert ngs.x(mesh(0.5, 0.5)) - 0.5 < 1e-10
def test_parallel():
mesh = ngs.Mesh(unit_square.GenerateMesh(maxh=0.2))
fes = ngs.L2(mesh, order=5, complex=True)
g1 = ngs.GridFunction(fes)
g2 = ngs.GridFunction(fes)
for order in range(10):
functions = [(f(ngs.x + 1j * ngs.y, order)) for f in fs_ng]
for f in functions:
g1.Set(f)
with ngs.TaskManager():
g2.Set(f)
error = ngs.Integrate(g1 - g2, mesh)
assert error == 0j
def test_bessel():
mesh = ngs.Mesh(unit_square.GenerateMesh(maxh=0.2))
for order in range(10):
functions = [(f1(ngs.x + 1j * ngs.y, order), f2)
for f1, f2 in zip(fs_ng, fs_py)]
for f_ng, f_py in functions:
for x in numpy.linspace(0.1, 0.9, 20):
for y in numpy.linspace(0.1, 0.9, 20):
z = x + 1j * y
v1 = f_ng(mesh(x, y))
v2 = f_py(order, z)
error = abs(f_ng(mesh(x, y)) - f_py(order, z))
if abs(v2) > 1:
error = abs(error / v2)
assert error < 1e-13
def test_errfns():
efng = [ng_sp.erf, ng_sp.erfc, ng_sp.wofz, ng_sp.erfcx, ng_sp.erfi]
efsc = [sp.erf, sp.erfc, sp.wofz, sp.erfcx, sp.erfi]
mesh = ngs.Mesh(unit_square.GenerateMesh(maxh=0.2))
functions = [(f1(ngs.x + 1j*ngs.y), f2)
for f1, f2 in zip(efng, efsc)]
for f_ng, f_py in functions:
for x in numpy.linspace(0.1, 0.9, 20):
for y in numpy.linspace(0.1, 0.9, 20):
v1 = f_ng(mesh(x, y))
v2 = f_py(x+1j*y)
error = abs(v1 - v2)
if abs(v2) > 1:
error = abs(error/v2)
assert error < 1e-13
def Make1DMesh(n, mapping=None, periodic=False):
"""
Generate an equidistant 1D mesh with N cells
Parameters
----------
n : int
Number of cells.
mapping: lamda
Mapping to transform the generated points. If None, the identity mapping is used.
periodic: bool
If True, the endpoints are identified to generate a periodic mesh.
Returns
-------
(ngsolve.mesh)
Returns generated 1D NGSolve mesh
"""
mesh = Mesh(dim=1)
pids = []
for i in range(n + 1):
x = i / n
if mapping:
x = mapping(x)
pids.append(mesh.Add(MeshPoint(Pnt(x, 0, 0))))
idx_inner = mesh.AddRegion("dom", dim=1)
idx_left = mesh.AddRegion("left", dim=0)
idx_right = mesh.AddRegion("right", dim=0)
for i in range(n):
mesh.Add(Element1D([pids[i], pids[i + 1]], index=idx_inner))
mesh.Add(Element0D(pids[0], index=idx_left))
mesh.Add(Element0D(pids[n], index=idx_right))
if periodic:
mesh.AddPointIdentification(pids[0], pids[n], 1, 2)
ngsmesh = ngsolve.Mesh(mesh)
return ngsmesh
def MakeStructured2DMesh(quads=True,
nx=10,
ny=10,
secondorder=False,
periodic_x=False,
periodic_y=False,
mapping=None):
"""
Generate a structured 2D mesh
Parameters
----------
quads : bool
If True, a quadrilateral mesh is generated. If False, the quads are split to triangles.
nx : int
Number of cells in x-direction.
ny : int
Number of cells in y-direction.
periodic_x: bool
If True, the left and right boundaries are identified to generate a periodic mesh in x-direction.
periodic_y: bool
If True, the top and bottom boundaries are identified to generate a periodic mesh in y-direction.
mapping: lamda
Mapping to transform the generated points. If None, the identity mapping is used.
Returns
-------
(ngsolve.mesh)
Returns generated 2D NGSolve mesh
"""
mesh = Mesh()
mesh.dim = 2
pids = []
if periodic_y:
slavei = []
masteri = []
if periodic_x:
slavej = []
masterj = []
for i in range(ny + 1):
for j in range(nx + 1):
x, y = j / nx, i / ny
# if mapping:
# x,y = mapping(x,y)
pids.append(mesh.Add(MeshPoint(Pnt(x, y, 0))))
if periodic_y:
if i == 0:
slavei.append(pids[-1])
if i == ny:
masteri.append(pids[-1])
if periodic_x:
if j == 0:
slavej.append(pids[-1])
if j == nx:
masterj.append(pids[-1])
if periodic_y:
for i in range(len(slavei)):
mesh.AddPointIdentification(masteri[i],
slavei[i],
identnr=1,
type=2)
if periodic_x:
for j in range(len(slavej)):
mesh.AddPointIdentification(masterj[j],
slavej[j],
identnr=2,
type=2)
mesh.Add(FaceDescriptor(surfnr=1, domin=1, bc=1))
for i in range(ny):
for j in range(nx):
base = i * (nx + 1) + j
if quads:
pnum = [base, base + 1, base + nx + 2, base + nx + 1]
elpids = [pids[p] for p in pnum]
el = Element2D(1, elpids)
if not mapping:
el.curved = False
mesh.Add(el)
else:
pnum1 = [base, base + 1, base + nx + 1]
pnum2 = [base + 1, base + nx + 2, base + nx + 1]
elpids1 = [pids[p] for p in pnum1]
elpids2 = [pids[p] for p in pnum2]
mesh.Add(Element2D(1, elpids1))
mesh.Add(Element2D(1, elpids2))
for i in range(nx):
mesh.Add(Element1D([pids[i], pids[i + 1]], index=1))
for i in range(ny):
mesh.Add(
Element1D([pids[i * (nx + 1) + nx], pids[(i + 1) * (nx + 1) + nx]],
index=2))
for i in range(nx):
mesh.Add(
Element1D([pids[ny * (nx + 1) + i + 1], pids[ny * (nx + 1) + i]],
index=3))
for i in range(ny):
mesh.Add(
Element1D([pids[(i + 1) * (nx + 1)], pids[i * (nx + 1)]], index=4))
mesh.SetBCName(0, "bottom")
mesh.SetBCName(1, "right")
mesh.SetBCName(2, "top")
mesh.SetBCName(3, "left")
mesh.Compress()
if secondorder:
mesh.SecondOrder()
if mapping:
for p in mesh.Points():
x, y, z = p.p
x, y = mapping(x, y)
p[0] = x
p[1] = y
ngsmesh = ngsolve.Mesh(mesh)
return ngsmesh
def MakeStructured3DMesh(hexes=True,
nx=10,
ny=None,
nz=None,
secondorder=False,
periodic_x=False,
periodic_y=False,
periodic_z=False,
mapping=None,
cuboid_mapping=False):
"""
Generate a structured quadrilateral 2D mesh
Parameters
----------
hexes: bool
If True, a mesh consisting of hexahedra is generated.
nx : int
Number of cells in x-direction.
ny : int
Number of cells in y-direction.
nz : int
Number of cells in z-direction.
periodic_x: bool
If True, the left and right boundaries are identified to generate a periodic mesh in x-direction.
periodic_y: bool
If True, the top and bottom boundaries are identified to generate a periodic mesh in y-direction.
periodic_z: bool
If True, the top and bottom boundaries are identified to generate a periodic mesh in z-direction.
mapping: lambda
Mapping to transform the generated points. If None, the identity mapping is used.
cuboid_mapping: bool
If True, a straight geometry is assumed.
Returns
-------
(ngsolve.mesh)
Returns generated 3D NGSolve mesh
"""
if nz == None:
if ny == None:
nz = nx
else:
raise (
"MakeStructured3DMesh: No default value for nz if nx and ny are provided"
)
if ny == None:
ny = nx
netmesh = Mesh()
netmesh.dim = 3
if cuboid_mapping:
P1 = (0, 0, 0)
P2 = (1, 1, 1)
if mapping:
P1 = mapping(*P1)
P2 = mapping(*P2)
cube = OrthoBrick(Pnt(P1[0], P1[1], P1[2]), Pnt(P2[0], P2[1],
P2[2])).bc(1)
geom = CSGeometry()
geom.Add(cube)
netmesh.SetGeometry(geom)
pids = []
if periodic_x:
slavei = []
masteri = []
if periodic_y:
slavej = []
masterj = []
if periodic_z:
slavek = []
masterk = []
for i in range(nx + 1):
for j in range(ny + 1):
for k in range(nz + 1):
# x,y,z = mapping(i / nx, j / ny, k / nz)
x, y, z = i / nx, j / ny, k / nz
# if mapping:
# x,y,z = mapping(x,y,z)
pids.append(netmesh.Add(MeshPoint(Pnt(x, y, z))))
if periodic_x:
if i == 0:
slavei.append(pids[-1])
if i == nx:
masteri.append(pids[-1])
if periodic_y:
if j == 0:
slavej.append(pids[-1])
if j == ny:
masterj.append(pids[-1])
if periodic_z:
if k == 0:
slavek.append(pids[-1])
if k == nz:
masterk.append(pids[-1])
if periodic_x:
for i in range(len(slavei)):
netmesh.AddPointIdentification(masteri[i],
slavei[i],
identnr=1,
type=2)
if periodic_y:
for j in range(len(slavej)):
netmesh.AddPointIdentification(masterj[j],
slavej[j],
identnr=2,
type=2)
if periodic_z:
for k in range(len(slavek)):
netmesh.AddPointIdentification(masterk[k],
slavek[k],
identnr=3,
type=2)
for i in range(nx):
for j in range(ny):
for k in range(nz):
base = i * (ny + 1) * (nz + 1) + j * (nz + 1) + k
baseup = base + (ny + 1) * (nz + 1)
pnum = [
base, base + 1, base + (nz + 1) + 1, base + (nz + 1),
baseup, baseup + 1, baseup + (nz + 1) + 1,
baseup + (nz + 1)
]
if hexes:
elpids = [pids[p] for p in pnum]
el = Element3D(1, elpids)
if not mapping:
el.curved = False
netmesh.Add(el)
else:
# a poor mans kuhn triangulation of a cube
for qarr in [[0, 4, 5, 6], [0, 6, 7, 4], [0, 3, 7, 6],
[0, 1, 6, 5], [0, 1, 2, 6], [0, 3, 6, 2]]:
elpids = [pids[p] for p in [pnum[q] for q in qarr]]
netmesh.Add(Element3D(1, elpids))
def AddSurfEls(p1, dxi, nxi, deta, neta, facenr):
def add_seg(i, j, os):
base = p1 + i * dxi + j * deta
pnum = [base, base + os]
elpids = [pids[p] for p in pnum]
netmesh.Add(Element1D(elpids, index=facenr))
for i in range(nxi):
for j in [0, neta]:
add_seg(i, j, dxi)
for i in [0, nxi]:
for j in range(neta):
add_seg(i, j, deta)
for i in range(nxi):
for j in range(neta):
base = p1 + i * dxi + j * deta
pnum = [base, base + dxi, base + dxi + deta, base + deta]
if hexes:
elpids = [pids[p] for p in pnum]
netmesh.Add(Element2D(facenr, elpids))
else:
qarrs = [[0, 1, 2], [0, 2, 3]]
for qarr in qarrs:
elpids = [pids[p] for p in [pnum[q] for q in qarr]]
netmesh.Add(Element2D(facenr, elpids))
#order is important!
netmesh.Add(FaceDescriptor(surfnr=4, domin=1, bc=1))
netmesh.Add(FaceDescriptor(surfnr=2, domin=1, bc=2))
netmesh.Add(FaceDescriptor(surfnr=5, domin=1, bc=3))
netmesh.Add(FaceDescriptor(surfnr=3, domin=1, bc=4))
netmesh.Add(FaceDescriptor(surfnr=0, domin=1, bc=5))
netmesh.Add(FaceDescriptor(surfnr=1, domin=1, bc=6))
# y-z-plane, smallest x-coord: ("back")
AddSurfEls(0, 1, nz, nz + 1, ny, facenr=1) # y-z-plane
# x-z-plane, smallest y-coord: ("left")
AddSurfEls(0, (ny + 1) * (nz + 1), nx, 1, nz, facenr=2)
# y-z-plane, largest x-coord: ("front")
AddSurfEls((nx + 1) * (ny + 1) * (nz + 1) - 1,
-(nz + 1),
ny,
-1,
nz,
facenr=3)
# x-z-plane, largest y-coord: ("right")
AddSurfEls((nx + 1) * (ny + 1) * (nz + 1) - 1,
-1,
nz,
-(ny + 1) * (nz + 1),
nx,
facenr=4)
# x-y-plane, smallest z-coord: ("bottom")
AddSurfEls(0, nz + 1, ny, (ny + 1) * (nz + 1), nx, facenr=5)
# x-y-plane, largest z-coord: ("top")
AddSurfEls((nx + 1) * (ny + 1) * (nz + 1) - 1,
-(ny + 1) * (nz + 1),
nx,
-(nz + 1),
ny,
facenr=6)
if cuboid_mapping:
netmesh.SetBCName(0, "back")
netmesh.SetBCName(1, "left")
netmesh.SetBCName(2, "front")
netmesh.SetBCName(3, "right")
netmesh.SetBCName(4, "bottom")
netmesh.SetBCName(5, "top")
netmesh.Compress()
if secondorder:
netmesh.SecondOrder()
if mapping:
for p in netmesh.Points():
x, y, z = p.p
x, y, z = mapping(x, y, z)
p[0] = x
p[1] = y
p[2] = z
ngsmesh = ngsolve.Mesh(netmesh)
# ngsmesh.ngmesh.Save("tmp.vol.gz")
# ngsmesh = ngsolve.Mesh("tmp.vol.gz")
return ngsmesh
ns = []
errs = []
err2s = []
import netgen.csg
import ngsolve as ngs
cube = netgen.csg.OrthoBrick(netgen.csg.Pnt(0, 0, 0), netgen.csg.Pnt(1, 1, 1))
geo = netgen.csg.CSGeometry()
geo.Add(cube)
bempp.api.global_parameters.hmat.eps = 1E-05
bempp.api.global_parameters.hmat.max_rank = 4096
for n in range(1, 12):
mesh = ngs.Mesh(geo.GenerateMesh(maxh=1 / n))
epsilon = 1.
mu = 1.
mu_inv = 1. / mu
omega = k / np.sqrt(mu * epsilon)
def incident_field(x):
return np.array([np.exp(1j * k * x[2]), 0. * x[2], 0. * x[2]])
def curl_incident_field(x):
return np.array([0. * x[2], np.exp(1j * k * x[2]), 0. * x[2]])
def tangential_trace(x, n, domain_index, result):
result[:] = np.cross(incident_field(x), n, axis=0)
def MakeStructuredSurfaceMesh(quads=True,
nx=10,
ny=10,
mapping=None,
secondorder=False,
bbbpts=None,
bbbnames=None,
flip_triangles=False):
"""
Generate a structured 2D surface mesh in 3D
Parameters
----------
quads : bool
If True, a quadrilateral mesh is generated. If False, the quads are split to triangles.
nx : int
Number of cells in x-direction.
ny : int
Number of cells in y-direction.
mapping : lamda
Mapping to transform the generated points. If None, the identity mapping is used.
secondorder : bool
If True, use quadratic elements, else linear elements are used.
bbbpts : list
List of points which should be handled as BBBND and are named with bbbnames. The mesh (nx, ny and mapping) must be constructed in such a way that the bbbpts coincide with generated points. Otherwise an Exception is thrown.
bbbnames : list
List of bbbnd names as strings. Size must coincide with size of bbbpts. Otherwise an Exception is thrown.
flip_triangles : bool
If set tot True together with quads=False the quads are cut the other way round
Returns
-------
(ngsolve.mesh)
Returns generated NGSolve mesh
"""
mesh = Mesh(dim=3)
if (bbbpts and bbbnames) and len(bbbpts) != len(bbbnames):
raise Exception(
"Lenght of bbbnames does not coincide with length of bbbpts!")
found = []
indbbbpts = []
if bbbpts:
for i in range(len(bbbpts)):
found.append(False)
indbbbpts.append(None)
pids = []
for i in range(ny + 1):
for j in range(nx + 1):
x, y, z = j / nx, i / ny, 0
pids.append(mesh.Add(MeshPoint(Pnt(x, y, z))))
mesh.Add(FaceDescriptor(surfnr=1, domin=1, bc=1))
for i in range(ny):
for j in range(nx):
base = i * (nx + 1) + j
if quads:
pnum = [base, base + 1, base + nx + 2, base + nx + 1]
elpids = [pids[p] for p in pnum]
el = Element2D(1, elpids)
if not mapping:
el.curved = False
mesh.Add(el)
else:
if flip_triangles:
pnum1 = [base, base + 1, base + nx + 2]
pnum2 = [base, base + nx + 2, base + nx + 1]
else:
pnum1 = [base, base + 1, base + nx + 1]
pnum2 = [base + 1, base + nx + 2, base + nx + 1]
elpids1 = [pids[p] for p in pnum1]
elpids2 = [pids[p] for p in pnum2]
mesh.Add(Element2D(1, elpids1))
mesh.Add(Element2D(1, elpids2))
for i in range(nx):
mesh.Add(Element1D([pids[i], pids[i + 1]], index=1))
for i in range(ny):
mesh.Add(
Element1D([pids[i * (nx + 1) + nx], pids[(i + 1) * (nx + 1) + nx]],
index=2))
for i in range(nx):
mesh.Add(
Element1D([pids[ny * (nx + 1) + i + 1], pids[ny * (nx + 1) + i]],
index=3))
for i in range(ny):
mesh.Add(
Element1D([pids[(i + 1) * (nx + 1)], pids[i * (nx + 1)]], index=4))
mesh.SetCD2Name(1, "bottom")
mesh.SetCD2Name(2, "right")
mesh.SetCD2Name(3, "top")
mesh.SetCD2Name(4, "left")
if secondorder:
mesh.SecondOrder()
if mapping:
for p in mesh.Points():
x, y, z = p.p
x, y, z = mapping(x, y, z)
p[0], p[1], p[2] = x, y, z
for k in range(len(found)):
i = 0
for p in mesh.Points():
if abs(p.p[0] - bbbpts[k][0]) + abs(p.p[1] - bbbpts[k][1]) + abs(
p.p[2] - bbbpts[k][2]) < 1e-6:
indbbbpts[k] = pids[i]
found[k] = True
i += 1
for k in range(len(found)):
if found[k] == False:
raise Exception("bbbpnt[", k, "] not in structured mesh!")
for i in range(len(indbbbpts)):
mesh.Add(Element0D(indbbbpts[i], index=i + 1))
mesh.SetCD3Name(i + 1, bbbnames[i])
mesh.Compress()
ngsmesh = ngsolve.Mesh(mesh)
return ngsmesh
def MakeStructured2DMesh(quads=True,
nx=10,
ny=10,
secondorder=False,
periodic_x=False,
periodic_y=False,
mapping=None,
bbpts=None,
bbnames=None,
flip_triangles=False):
"""
Generate a structured 2D mesh
Parameters
----------
quads : bool
If True, a quadrilateral mesh is generated. If False, the quads are split to triangles.
nx : int
Number of cells in x-direction.
ny : int
Number of cells in y-direction.
secondorder : bool
If True, second order curved elements are used.
periodic_x: bool
If True, the left and right boundaries are identified to generate a periodic mesh in x-direction.
periodic_y: bool
If True, the top and bottom boundaries are identified to generate a periodic mesh in y-direction.
mapping: lamda
Mapping to transform the generated points. If None, the identity mapping is used.
bbpts : list
List of points which should be handled as BBND and are named with bbnames. The mesh (nx, ny and mapping) must be constructed in such a way that the bbpts coincide with generated points. Otherwise an Exception is thrown.
bbnames : list
List of bbnd names as strings. Size must coincide with size of bbpts. Otherwise an Exception is thrown.
flip_triangles : bool
If set tot True together with quads=False the quads are cut the other way round
Returns
-------
(ngsolve.mesh)
Returns generated 2D NGSolve mesh
"""
mesh = Mesh()
mesh.dim = 2
if (bbpts and bbnames) and len(bbpts) != len(bbnames):
raise Exception(
"Lenght of bbnames does not coincide with length of bbpts!")
found = []
indbbpts = []
if bbpts:
for i in range(len(bbpts)):
found.append(False)
indbbpts.append(None)
pids = []
if periodic_y:
slavei = []
masteri = []
if periodic_x:
slavej = []
masterj = []
for i in range(ny + 1):
for j in range(nx + 1):
x, y = j / nx, i / ny
# if mapping:
# x,y = mapping(x,y)
pids.append(mesh.Add(MeshPoint(Pnt(x, y, 0))))
if periodic_y:
if i == 0:
slavei.append(pids[-1])
if i == ny:
masteri.append(pids[-1])
if periodic_x:
if j == 0:
slavej.append(pids[-1])
if j == nx:
masterj.append(pids[-1])
if periodic_y:
for i in range(len(slavei)):
mesh.AddPointIdentification(masteri[i],
slavei[i],
identnr=1,
type=2)
if periodic_x:
for j in range(len(slavej)):
mesh.AddPointIdentification(masterj[j],
slavej[j],
identnr=2,
type=2)
# mesh.Add(FaceDescriptor(surfnr=1,domin=1,bc=1))
idx_dom = mesh.AddRegion("dom", dim=2)
idx_bottom = mesh.AddRegion("bottom", dim=1)
idx_right = mesh.AddRegion("right", dim=1)
idx_top = mesh.AddRegion("top", dim=1)
idx_left = mesh.AddRegion("left", dim=1)
for i in range(ny):
for j in range(nx):
base = i * (nx + 1) + j
if quads:
pnum = [base, base + 1, base + nx + 2, base + nx + 1]
elpids = [pids[p] for p in pnum]
el = Element2D(idx_dom, elpids)
if not mapping:
el.curved = False
mesh.Add(el)
else:
if flip_triangles:
pnum1 = [base, base + 1, base + nx + 2]
pnum2 = [base, base + nx + 2, base + nx + 1]
else:
pnum1 = [base, base + 1, base + nx + 1]
pnum2 = [base + 1, base + nx + 2, base + nx + 1]
elpids1 = [pids[p] for p in pnum1]
elpids2 = [pids[p] for p in pnum2]
mesh.Add(Element2D(idx_dom, elpids1))
mesh.Add(Element2D(idx_dom, elpids2))
for i in range(nx):
mesh.Add(Element1D([pids[i], pids[i + 1]], index=idx_bottom))
for i in range(ny):
mesh.Add(
Element1D([pids[i * (nx + 1) + nx], pids[(i + 1) * (nx + 1) + nx]],
index=idx_right))
for i in range(nx):
mesh.Add(
Element1D([pids[ny * (nx + 1) + i + 1], pids[ny * (nx + 1) + i]],
index=idx_top))
for i in range(ny):
mesh.Add(
Element1D([pids[(i + 1) * (nx + 1)], pids[i * (nx + 1)]],
index=idx_left))
# mesh.SetBCName(0, "bottom")
# mesh.SetBCName(1, "right")
# mesh.SetBCName(2, "top")
# mesh.SetBCName(3, "left")
mesh.Compress()
if secondorder:
mesh.SecondOrder()
if mapping:
for p in mesh.Points():
x, y, z = p.p
x, y = mapping(x, y)
p[0] = x
p[1] = y
for k in range(len(found)):
i = 0
for p in mesh.Points():
if abs(p.p[0] - bbpts[k][0]) + abs(p.p[1] - bbpts[k][1]) < 1e-6:
indbbpts[k] = pids[i]
found[k] = True
i += 1
for k in range(len(found)):
if found[k] == False:
raise Exception("bbpnt[", k, "] not in structured mesh!")
for i in range(len(indbbpts)):
mesh.Add(Element0D(indbbpts[i], index=i + 1))
mesh.SetCD2Name(i + 1, bbnames[i])
ngsmesh = ngsolve.Mesh(mesh)
return ngsmesh
xs = []
for i in range(0, n_elems + 1):
pnt_x = x_min + length * i / n_elems
xs.append(pnt_x)
pnums.append(m.Add(ngm.MeshPoint(ngm.Pnt(pnt_x, 0, 0))))
for i in range(0, n_elems):
m.Add(ngm.Element1D([pnums[i], pnums[i + 1]], index=1))
m.SetMaterial(1, 'material')
m.Add(ngm.Element0D(pnums[0], index=1))
m.Add(ngm.Element0D(pnums[n_elems], index=2))
## NGSolve
mesh = ngs.Mesh(m)
fes = ngs.H1(mesh, order=1, dirichlet=[1, 2], complex=True)
u = fes.TrialFunction()
v = fes.TestFunction()
## Potentials
### Potential barrier
barrier_w = 2
barrier_h = 1
potential = ngs.CoefficientFunction(
ngs.IfPos(x, barrier_h, 0) - ngs.IfPos(x - barrier_w, barrier_h, 0))
### Square potential
# potential = ngs.CoefficientFunction(1/2*x*x-10)
mesh.Add(Element2D(1, [pnts[0]] + pnts[2:4]))
mesh.Add(Element3D(1, pnts))
return mesh
def Prism():
mesh = Mesh(3)
mesh.AddRegion("", 2)
mesh.AddRegion("", 3)
pnts = [
mesh.Add(MeshPoint(Pnt(0, 0, 0))),
mesh.Add(MeshPoint(Pnt(1, 0, 0))),
mesh.Add(MeshPoint(Pnt(0, 1, 0))),
mesh.Add(MeshPoint(Pnt(0, 0, 1))),
mesh.Add(MeshPoint(Pnt(1, 0, 1))),
mesh.Add(MeshPoint(Pnt(0, 1, 1)))
]
mesh.Add(Element2D(1, list(reversed(pnts[:3]))))
mesh.Add(Element2D(1, pnts[3:]))
mesh.Add(Element2D(1, pnts[:2] + list(reversed(pnts[3:5]))))
mesh.Add(Element2D(1, pnts[1:3] + list(reversed(pnts[4:6]))))
mesh.Add(Element2D(1, [pnts[2], pnts[0], pnts[3], pnts[5]]))
mesh.Add(Element3D(1, list(reversed(pnts[:3])) + list(reversed(pnts[3:]))))
return mesh
if __name__ == "__main__":
mesh = Prism()
import ngsolve
ngsolve.Draw(ngsolve.Mesh(mesh))
return 1 / (1 + ng.exp(-x))
# vectorize the logistic function for component-wise application
vσ = np.vectorize(σ)
# NNet coefficient function
u_net = W3.dot(vσ(W2.dot(vσ(Wx.dot(ng.x) + Wy.dot(ng.y) + b1)) + b2)) + b3
# unit square domain
#mesh = Mesh(unit_square.GenerateMesh(maxh=0.2))
ngmesh = unit_square.GenerateMesh(maxh=0.2)
ngmesh.Refine()
#ngmesh.Refine()
mesh = ng.Mesh(ngmesh)
mesh.ngmesh.SetGeometry(unit_square)
ng.Draw(mesh)
uₕ = poisson_solve()
ΔFEM = uₕ - uexact
ΔNET = u_net - uexact
FEM_error = ng.sqrt(ng.Integrate(ng.InnerProduct(ΔFEM, ΔFEM), mesh))
NET_error = ng.sqrt(ng.Integrate(ng.InnerProduct(ΔNET, ΔNET), mesh))
print('FEM error = ', FEM_error)
print('NET_error = ', NET_error)
ng.Draw(uₕ)
ng.Draw(u_net, mesh, "u_net")
import ngsolve as ngs
import netgen
from netgen.meshing import *
from netgen.geom2d import unit_square
#import netgen.libngpy as libng
from netgen.csg import *
geo = CSGeometry()
block = OrthoBrick(Pnt(0, -a, -b), Pnt(L, a, b))
geo.Add(block)
#Draw (geo)
mesh = ngs.Mesh(geo.GenerateMesh(maxh=h))
mesh.Curve(1)
if False: #set this to true, if you want to visualize the mesh inside netgen/ngsolve
# import netgen
import netgen.gui
ngs.Draw(mesh)
netgen.Redraw()
#%%+++++++++++++++++++++++++++++++++++++++++++++++++++++
#Use fem to import FEM model and create FFRFreducedOrder object
fem.ImportMeshFromNGsolve(mesh,
density=rho,
youngsModulus=Emodulus,
poissonsRatio=nu)
fem.SaveToFile(fileName)
import ngsolve as ngs
import netgen
from netgen.meshing import *
from netgen.geom2d import unit_square
#import netgen.libngpy as libng
from netgen.csg import *
geo = CSGeometry()
#plate
block = OrthoBrick(Pnt(0, -0.5 * h, -0.5 * w), Pnt(L, 0.5 * h, 0.5 * w))
geo.Add(block)
mesh = ngs.Mesh(geo.GenerateMesh(maxh=meshH))
mesh.Curve(1)
if False: #set this to true, if you want to visualize the mesh inside netgen/ngsolve
# import netgen
import netgen.gui
ngs.Draw(mesh)
netgen.Redraw()
#%%+++++++++++++++++++++++++++++++++++++++++++++++++++++
#Use femInterface to import femInterface model and create FFRFreducedOrder object
eigenModesComputed = False
femInterface.ImportMeshFromNGsolve(mesh,
density=rho,
youngsModulus=Emodulus,
poissonsRatio=nu,
return F * reaction_rate * li_factor
def charge_flux_prefactor_anode(concentration):
"""Return prefactor for Butler-Volmer relation in anode
params: concentration - Lithium concentration
"""
# TODO: use power empirical constants here instead of sqrt
solubility_difference = ngs.IfPos(solubility_limit_anode - concentration,
solubility_limit_anode - concentration, 0)
li_factor = sqrt(solubility_difference) * sqrt(concentration)
return F * reaction_rate * li_factor
mesh = ngs.Mesh('mesh.vol')
n_lithium_space = ngs.H1(mesh, order=1)
potential_space = ngs.H1(mesh, order=1, dirichlet='anode')
V = ngs.FESpace([n_lithium_space, potential_space])
print(V.ndof)
u, p = V.TrialFunction()
v, q = V.TestFunction()
# Coefficient functions
cf_diffusivity = ngs.CoefficientFunction([diffusivity[mat] for mat in mesh.GetMaterials()])
cf_conductivity = ngs.CoefficientFunction([conductivity[mat] for mat in mesh.GetMaterials()])
cf_valence = ngs.CoefficientFunction([valence[mat] for mat in mesh.GetMaterials()])
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
self._mesh = ngs.Mesh(unit_square.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 += (-4) * 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()
"""Solve simple laplace equation on a square."""
# pylint: disable=no-member
from ctypes import CDLL
import ngsolve as ngs
from ngsolve import grad
from netgen.geom2d import unit_square
CDLL('libh1amg.so')
with ngs.TaskManager():
mesh = ngs.Mesh(unit_square.GenerateMesh(maxh=0.2))
fes = ngs.H1(mesh, dirichlet=[1, 2, 3], order=1)
u = fes.TrialFunction()
v = fes.TestFunction()
# rhs
f = ngs.LinearForm(fes)
f += ngs.SymbolicLFI(v)
# lhs
a = ngs.BilinearForm(fes, symmetric=True)
a += ngs.SymbolicBFI(grad(u) * grad(v))
c = ngs.Preconditioner(a, 'h1amg', test=True)
gfu = ngs.GridFunction(fes)
"""
A small script that loads the results of sequential and parallel FEAST
using NGSolve.
"""
import ngsolve as ng
if __name__ == '__main__':
try:
# Load the mesh from file.
mesh = ng.Mesh('outputs/mesh.vol')
# Create our H1 finite element space.
order = 2
dirichlet = 'top|right|bottom|left'
X = ng.H1(mesh, order=order, dirichlet=dirichlet, complex=True)
# Create an index array for the gridfunctions.
idx = list(range(0, 3))
gf_sequential = []
gf_mpi = []
middlename = 'gridfunction'
for k in range(len(idx)):
# Create two grid functions: One for the sequential solve, and one
# for the MPI solve.
sequential_name = 'sequential_' + middlename + '_{0:02d}'
gf_sequential += [
ng.GridFunction(X, name=sequential_name.format(idx[k]))
