def test_subdomain_facet_assembly():
def subdomain(x):
return np.logical_and(
np.logical_and(x[0] > .25, x[0] < .75),
np.logical_and(x[1] > .25, x[1] < .75),
)
m, e = MeshTri().refined(4), ElementTriP2()
cbasis = CellBasis(m, e)
cbasis_p0 = cbasis.with_element(ElementTriP0())
sfbasis = FacetBasis(m, e, facets=m.facets_around(subdomain, flip=True))
sfbasis_p0 = sfbasis.with_element(ElementTriP0())
sigma = cbasis_p0.zeros() + 1
@BilinearForm
def laplace(u, v, w):
return dot(w.sigma * grad(u), grad(v))
A = laplace.assemble(cbasis, sigma=cbasis_p0.interpolate(sigma))
u0 = cbasis.zeros()
u0[cbasis.get_dofs(elements=subdomain)] = 1
u0_dofs = cbasis.get_dofs() + cbasis.get_dofs(elements=subdomain)
A, b = enforce(A, D=u0_dofs, x=u0)
u = solve(A, b)
@Functional
def measure_current(w):
return dot(w.n, w.sigma * grad(w.u))
meas = measure_current.assemble(sfbasis,
sigma=sfbasis_p0.interpolate(sigma),
u=sfbasis.interpolate(u))
assert_almost_equal(meas, 9.751915526759191)
def runTest(self):
m = self.mesh().refined(4)
basis = InteriorBasis(m, self.elem)
boundary_basis = FacetBasis(m, self.elem)
boundary_dofs = boundary_basis.get_dofs().flatten()
def dirichlet(x):
"""return a harmonic function"""
return ((x[0] + 1.j * x[1])**2).real
u = basis.zeros()
A = laplace.assemble(basis)
u[boundary_dofs] = projection(dirichlet,
boundary_basis,
I=boundary_dofs)
u = solve(*enforce(A, x=u, D=boundary_dofs))
@Functional
def gradu(w):
gradu = w['sol'].grad
return dot(gradu, gradu)
self.assertAlmostEqual(
gradu.assemble(basis, sol=basis.interpolate(u)),
8 / 3,
delta=1e-10,
)
def test_solving_inhomogeneous_laplace(mesh_elem, impose):
"""Adapted from example 14."""
mesh, elem = mesh_elem
m = mesh().refined(4)
basis = Basis(m, elem)
boundary_basis = FacetBasis(m, elem)
boundary_dofs = boundary_basis.get_dofs().flatten()
def dirichlet(x):
"""return a harmonic function"""
return ((x[0] + 1.j * x[1])**2).real
u = basis.zeros()
A = laplace.assemble(basis)
u[boundary_dofs] = projection(dirichlet, boundary_basis, I=boundary_dofs)
u = solve(*impose(A, x=u, D=boundary_dofs))
@Functional
def gradu(w):
gradu = w['sol'].grad
return dot(gradu, gradu)
np.testing.assert_almost_equal(gradu.assemble(basis,
sol=basis.interpolate(u)),
8 / 3,
decimal=9)
def runTest(self):
m = MeshTri()
fbasis1 = FacetBasis(m, ElementTriP1() * ElementTriP1(),
facets=m.facets_satisfying(lambda x: x[0] == 0))
fbasis2 = FacetBasis(m, ElementTriP1(),
facets=lambda x: x[0] == 0)
fbasis3 = FacetBasis(m, ElementTriP1(), facets='left')
@BilinearForm
def uv1(u, p, v, q, w):
return u * v + p * q
@BilinearForm
def uv2(u, v, w):
return u * v
A = asm(uv1, fbasis1)
B = asm(uv2, fbasis2)
C = asm(uv2, fbasis2)
assert_allclose(A[0].todense()[0, ::2],
B[0].todense()[0])
assert_allclose(A[0].todense()[0, ::2],
C[0].todense()[0])
def runTest(self):
m = self.mesh().refined()
e = self.elem()
fb = FacetBasis(m, e)
x = fb.global_coordinates().value
eps = 1e-6
for itr in range(m.p.shape[0]):
case = (x[itr] < eps) * (x[itr] > -eps)
for jtr in range(m.p.shape[0]):
normals = fb.normals.value[jtr][case]
if itr == jtr:
self.assertTrue((normals == -1).all())
else:
self.assertTrue((np.abs(normals) < 1e-14).all())
def test_trace(mtype, e1, e2, flat):
m = mtype().refined(3)
# use the boundary where last coordinate is zero
basis = FacetBasis(m, e1, facets=m.facets_satisfying(lambda x: x[-1] == 0.0))
xfun = projection(lambda x: x[0], CellBasis(m, e1))
nbasis, y = basis.trace(xfun, lambda p: p[0] if flat else p[:-1], target_elem=e2)
@Functional
def integ(w):
return w.y
# integrate f(x) = x_1 over trace mesh
assert_almost_equal(integ.assemble(nbasis, y=nbasis.interpolate(y)), .5)
def test_oriented_interface_integral2(m, e, facets, normal):
fb = FacetBasis(m, e, facets=m.facets_satisfying(facets, normal=normal))
assert_almost_equal(
Functional(lambda w: dot(w.fun.grad, w.n)).assemble(fb, fun=m.p[0]),
1.0,
)
def test_oriented_interface_integral(m, e, facets, fun):
fb = FacetBasis(m, e, facets=facets)
assert_almost_equal(
Functional(lambda w: dot(w.fun.grad, w.n)).assemble(fb, fun=fun(m)),
1.0,
)
def test_subdomain_facet_assembly_2():
m = MeshTri().refined(4).with_subdomains({'all': lambda x: x[0] * 0 + 1})
e = ElementTriP1()
@Functional
def boundary_integral(w):
return dot(w.n, grad(w.u))
sfbasis = FacetBasis(m, e, facets=m.facets_around('all'))
fbasis = FacetBasis(m, e)
assert_almost_equal(
boundary_integral.assemble(sfbasis, u=m.p[0] * m.p[1]),
boundary_integral.assemble(fbasis, u=m.p[0] * m.p[1]),
)
def runTest(self):
@Functional
def hydrostatic_pressure(w):
return w.n * w.x[1]
np.testing.assert_allclose(
hydrostatic_pressure.assemble(FacetBasis(MeshTri(),
ElementTriP1())), [0, 1])
def runTest(self):
m = self.initialize_meshes()
e = self.element()
fb = FacetBasis(m, e)
x = fb.mapping.G(fb.X, find=fb.find)
Y0 = fb.mapping.invF(x, tind=fb.mesh.f2t[0, fb.find])
assert self.within_refelem(Y0)
def test_oriented_gauss_integral(m, e):
facets = m.facets_around('mid')
fb = FacetBasis(m, e, facets=facets)
cb = CellBasis(m, e, elements='mid')
assert_almost_equal(
Functional(lambda w: w.x[0] * w.n[0]).assemble(fb),
Functional(lambda w: 1. + 0. * w.x[0]).assemble(cb),
decimal=5,
)
def runTest(self):
mtype, etype = self.case
m = mtype().refined(3)
bnd = m.facets_satisfying(lambda x: x[0] == 1.0)
fb = FacetBasis(m, etype(), facets=bnd)
@BilinearForm
def uv(u, v, w):
x, y, z = w.x
return x**2 * y**2 * z**2 * u * v
B = asm(uv, fb)
ones = np.ones(B.shape[0])
self.assertAlmostEqual(ones @ (B @ ones), 0.11111111, places=5)
def runTest(self):
m = MeshLine(np.linspace(0., 1.)).refined(2)
ib = InteriorBasis(m, self.e)
fb = FacetBasis(m, self.e)
@LinearForm
def boundary_flux(v, w):
return v * (w.x[0] == 1.)
L = asm(laplace, ib)
b = asm(boundary_flux, fb)
D = m.nodes_satisfying(lambda x: x == 0.0)
I = ib.complement_dofs(D) # noqa E741
u = solve(*condense(L, b, I=I)) # noqa E741
np.testing.assert_array_almost_equal(u[ib.nodal_dofs[0]], m.p[0], -10)
def runTest(self):
m = MeshLine(np.linspace(0., 1.)).refined(2)
ib = InteriorBasis(m, self.e)
fb = FacetBasis(m, self.e)
@LinearForm
def boundary_flux(v, w):
return v * (w.x[0] == 1) - v * (w.x[0] == 0)
L = asm(laplace, ib)
M = asm(mass, ib)
b = asm(boundary_flux, fb)
u = solve(L + 1e-6 * M, b)
np.testing.assert_array_almost_equal(u[ib.nodal_dofs[0]], m.p[0] - .5,
-4)
def runTest(self):
m = MeshLine(np.linspace(0., 1.))
m.refine(2)
e = ElementLineP1()
ib = InteriorBasis(m, e)
fb = FacetBasis(m, e)
@linear_form
def boundary_flux(v, dv, w):
return v * (w.x[0] == 1) - v * (w.x[0] == 0)
L = asm(laplace, ib)
M = asm(mass, ib)
b = asm(boundary_flux, fb)
u = solve(L + 1e-6 * M, b)
self.assertTrue(np.sum(np.abs(u - m.p[0, :] + 0.5)) < 1e-4)
def runTest(self):
cases = [(MeshHex, ElementHex1), (MeshTet, ElementTetP1),
(MeshTet, ElementTetP0)]
for (mtype, etype) in cases:
m = mtype().refined(3)
fb = FacetBasis(m, etype())
@BilinearForm
def uv(u, v, w):
x, y, z = w.x
return x**2 * y**2 * z**2 * u * v
B = asm(uv, fb)
ones = np.ones(B.shape[0])
self.assertAlmostEqual(ones @ (B @ ones), 0.3333333333, places=5)
def runTest(self):
m = MeshLine(np.linspace(0., 1.)).refined(2)
ib = InteriorBasis(m, self.e)
m.define_boundary('left', lambda x: x[0] == 0.0)
m.define_boundary('right', lambda x: x[0] == 1.0)
fb = FacetBasis(m, self.e, facets=m.boundaries['right'])
@LinearForm
def boundary_flux(v, w):
return -w.x[0] * v
L = asm(laplace, ib)
b = asm(boundary_flux, fb)
D = ib.find_dofs()['left'].all()
I = ib.complement_dofs(D) # noqa E741
u = solve(*condense(L, b, I=I)) # noqa E741
np.testing.assert_array_almost_equal(u[ib.nodal_dofs[0]], -m.p[0], -10)
def runTest(self):
m = MeshLine(np.linspace(0., 1.))
m.refine(2)
e = ElementLineP1()
ib = InteriorBasis(m, e)
fb = FacetBasis(m, e)
@linear_form
def boundary_flux(v, dv, w):
return -v * (w.x[0] == 1.)
L = asm(laplace, ib)
b = asm(boundary_flux, fb)
D = m.nodes_satisfying(lambda x: x == 0.0)
I = ib.complement_dofs(D) # noqa E741
u = solve(*condense(L, b, I=I)) # noqa E741
self.assertTrue(np.sum(np.abs(u + m.p[0, :])) < 1e-10)
global_basis = Basis(mesh, element)
inner_conductor_basis = Basis(mesh,
element,
elements=mesh.subdomains['inner_conductor'])
outer_conductor_basis = Basis(mesh,
element,
elements=mesh.subdomains['outer_conductor'])
inner_insulator_basis = Basis(mesh,
element,
elements=mesh.subdomains['inner_insulator'])
outer_insulator_basis = Basis(mesh,
element,
elements=mesh.subdomains['outer_insulator'])
inner_conductor_outer_surface_basis = FacetBasis(
mesh, element, facets=mesh.boundaries['inner_conductor_outer_surface'])
outer_conductor_inner_surface_basis = FacetBasis(
mesh, element, facets=mesh.boundaries['outer_conductor_inner_surface'])
dofs = {
'boundary':
global_basis.get_dofs(mesh.boundaries['boundary']),
'inner_conductor_outer_surface':
global_basis.get_dofs(mesh.boundaries['inner_conductor_outer_surface']),
'outer_conductor_inner_surface':
global_basis.get_dofs(mesh.boundaries['outer_conductor_inner_surface'])
}
# functional to compute the integral of a load vector over the domain
load_integral = solve(asm(mass, global_basis), asm(unit_load, global_basis))
# relative permittivity of polytetrafluoroethylene
eps_ptfe = 2.1
# relative permittivity of fluorinated ethylene propylene
eps_fep = 2.1
global_basis = InteriorBasis(mesh, element)
inner_conductor_basis = InteriorBasis(
mesh, element, elements=mesh.subdomains['inner_conductor'])
outer_conductor_basis = InteriorBasis(
mesh, element, elements=mesh.subdomains['outer_conductor'])
inner_insulator_basis = InteriorBasis(
mesh, element, elements=mesh.subdomains['inner_insulator'])
outer_insulator_basis = InteriorBasis(
mesh, element, elements=mesh.subdomains['outer_insulator'])
inner_conductor_outer_surface_basis = FacetBasis(
mesh, element, facets=mesh.boundaries['inner_conductor_outer_surface'])
outer_conductor_inner_surface_basis = FacetBasis(
mesh, element, facets=mesh.boundaries['outer_conductor_inner_surface'])
dofs = {
'boundary':
global_basis.get_dofs(mesh.boundaries['boundary']),
'inner_conductor_outer_surface':
global_basis.get_dofs(mesh.boundaries['inner_conductor_outer_surface']),
'outer_conductor_inner_surface':
global_basis.get_dofs(mesh.boundaries['outer_conductor_inner_surface'])
}
# functional to compute the integral of a load vector over the domain
load_integral = solve(asm(mass, global_basis), asm(unit_load, global_basis))
def createBasis(self):
m = MeshHex().refined(3)
self.fbasis = FacetBasis(m, ElementHex2())
self.boundary_area = 6.000
def createBasis(self):
m = MeshQuad().refined(6)
self.fbasis = FacetBasis(m, self.elem)
self.boundary_area = 4.0000