def test_newton_2d_1():
# ... abstract model
B1 = Boundary(r'\Gamma_1', domain)
V = ScalarFunctionSpace('V', domain)
x, y = domain.coordinates
Un = element_of(V, name='Un')
v = element_of(V, name='v')
int_0 = lambda expr: integral(domain, expr)
f = -4. * exp(-Un)
l = LinearForm(v, int_0(dot(grad(v), grad(Un)) - f * v))
u = element_of(V, name='u')
eq = NewtonIteration(l, Un, trials=u)
# ...
# ...
expected = int_0(-4.0 * u * v * exp(-Un) + dot(grad(u), grad(v)))
assert (eq.lhs.expr == expected)
# ...
# ...
bc = EssentialBC(u, 0, B1)
eq = NewtonIteration(l, Un, bc=bc, trials=u)
def test_latex_2d_3():
DIM = 2
domain = Domain('Omega', dim=DIM)
B1 = Boundary(r'\Gamma_1', domain)
B2 = Boundary(r'\Gamma_2', domain)
B3 = Boundary(r'\Gamma_3', domain)
V = ScalarFunctionSpace('V', domain)
x = V.coordinates
v = element_of(V, name='v')
u = element_of(V, name='u')
int_0 = lambda expr: integral(domain, expr)
int_1 = lambda expr: integral(B1, expr)
# ...
expr = dot(grad(v), grad(u))
a_0 = BilinearForm((v, u), int_0(expr))
expr = v * u
a_bnd = BilinearForm((v, u), int_1(expr))
expr = a_0(v, u) + a_bnd(v, u)
a = BilinearForm((v, u), expr)
print(latex(a_0))
print(latex(a_bnd))
print(latex(a))
# print(a)
print('')
def test_user_function_2d_1():
domain = Domain('Omega', dim=2)
x, y = domain.coordinates
kappa = Constant('kappa', is_real=True)
mu = Constant('mu', is_real=True)
# right hand side
f = Function('f')
V = ScalarFunctionSpace('V', domain)
u, v = [element_of(V, name=i) for i in ['u', 'v']]
int_0 = lambda expr: integral(domain, expr)
# ...
expr = dot(grad(u), grad(v)) + f(x, y) * u * v
a = BilinearForm((v, u), int_0(expr))
print(a)
print(TerminalExpr(a))
print('')
# ...
# ...
expr = f(x, y) * v
l = LinearForm(v, int_0(expr))
print(l)
print(TerminalExpr(l))
print('')
def test_linearize_form_2d_4():
domain = Domain('Omega', dim=2)
Gamma_N = Boundary(r'\Gamma_N', domain)
x, y = domain.coordinates
V = ScalarFunctionSpace('V', domain)
v = element_of(V, name='v')
u = element_of(V, name='u')
du = element_of(V, name='du')
int_0 = lambda expr: integral(domain, expr)
int_1 = lambda expr: integral(Gamma_N, expr)
# g = Matrix((cos(pi*x)*sin(pi*y),
# sin(pi*x)*cos(pi*y)))
expr = dot(grad(v), grad(u)) - 4. * exp(-u) * v # + v*trace_1(g, Gamma_N)
l = LinearForm(v, int_0(expr))
# linearising l around u, using du
a = linearize(l, u, trials=du)
assert a(du, v) == int_0(dot(grad(v), grad(du)) + 4. * exp(-u) * du * v)
def test_bilinear_expr_2d_1():
domain = Domain('Omega', dim=2)
x,y = domain.coordinates
kappa = Constant('kappa', is_real=True)
mu = Constant('mu' , is_real=True)
V = ScalarFunctionSpace('V', domain)
u,u1,u2 = [element_of(V, name=i) for i in ['u', 'u1', 'u2']]
v,v1,v2 = [element_of(V, name=i) for i in ['v', 'v1', 'v2']]
# ...
a = BilinearExpr((u,v), u*v)
print(a)
print(a.expr)
print(a(u1,v1))
# TODO
# print(a(u1+u2,v1+v2))
print('')
# ...
# ...
a1 = BilinearExpr((u,v), u*v)
a2 = BilinearExpr((u,v), dot(grad(u),grad(v)))
print(a1(u1,v1) + a2(u2,v2))
print('')
def test_calculus_2d_4():
DIM = 2
domain = Domain('Omega', dim=DIM)
V = ScalarFunctionSpace('V', domain, kind=None)
u, v = elements_of(V, names='u, v')
a = Constant('a', is_real=True)
# ... jump operator
assert (jump(u + v) == jump(u) + jump(v))
assert (jump(a * u) == a * jump(u))
# ...
# ... avg operator
assert (avg(u + v) == avg(u) + avg(v))
assert (avg(a * u) == a * avg(u))
# ...
# ... Dn operator
assert (Dn(u + v) == Dn(u) + Dn(v))
assert (Dn(a * u) == a * Dn(u))
# ...
# ... minus operator
assert (minus(u + v) == minus(u) + minus(v))
assert (minus(a * u) == a * minus(u))
# ...
# ... plus operator
assert (plus(u + v) == plus(u) + plus(v))
assert (plus(a * u) == a * plus(u))
def test_linear_expr_2d_1():
domain = Domain('Omega', dim=2)
x,y = domain.coordinates
kappa = Constant('kappa', is_real=True)
mu = Constant('mu' , is_real=True)
V = ScalarFunctionSpace('V', domain)
u,u1,u2 = [element_of(V, name=i) for i in ['u', 'u1', 'u2']]
v,v1,v2 = [element_of(V, name=i) for i in ['v', 'v1', 'v2']]
# ...
l = LinearExpr(v, x*y*v)
print(l)
print(l.expr)
print(l(v1))
# TODO
# print(l(v1+v2))
print('')
# ...
# ...
l = LinearExpr((v1,v2), x*v1 + y*v2)
print(l)
print(l.expr)
print(l(u1, u2))
# TODO
# print(l(u1+v1, u2+v2))
print('')
def test_bilinear_form_2d_3():
domain = Domain('Omega', dim=2)
B1 = Boundary(r'\Gamma_1', domain)
x,y = domain.coordinates
kappa = Constant('kappa', is_real=True)
mu = Constant('mu' , is_real=True)
V = ScalarFunctionSpace('V', domain)
u,u1,u2 = [element_of(V, name=i) for i in ['u', 'u1', 'u2']]
v,v1,v2 = [element_of(V, name=i) for i in ['v', 'v1', 'v2']]
int_0 = lambda expr: integral(domain , expr)
int_1 = lambda expr: integral(B1, expr)
# ...
a = BilinearForm((u,v), int_0(u*v))
assert(a.is_symmetric)
# ...
# ...
a = BilinearForm((u,v), int_0(dot(grad(u), grad(v))))
assert(a.is_symmetric)
def test_functional_2d_1():
domain = Domain('Omega', dim=2)
x,y = domain.coordinates
kappa = Constant('kappa', is_real=True)
mu = Constant('mu' , is_real=True)
V = ScalarFunctionSpace('V', domain)
F = element_of(V, name='F')
int_0 = lambda expr: integral(domain , expr)
# ...
expr = x*y
a = Functional(int_0(expr), domain)
print(a)
print(TerminalExpr(a))
print('')
# ...
# ...
expr = F - cos(2*pi*x)*cos(3*pi*y)
expr = dot(grad(expr), grad(expr))
a = Functional(int_0(expr), domain)
print(a)
print(TerminalExpr(a))
print('')
def test_linearize_form_2d_3():
"""steady Euler equation."""
domain = Domain('Omega', dim=2)
U = VectorFunctionSpace('U', domain)
W = ScalarFunctionSpace('W', domain)
# Test functions
v = element_of(U, name='v')
phi = element_of(W, name='phi')
q = element_of(W, name='q')
# Steady-state fields
U_0 = element_of(U, name='U_0')
Rho_0 = element_of(W, name='Rho_0')
P_0 = element_of(W, name='P_0')
# Trial functions (displacements from steady-state)
d_u = element_of(U, name='d_u')
d_rho = element_of(W, name='d_rho')
d_p = element_of(W, name='d_p')
# Shortcut
int_0 = lambda expr: integral(domain, expr)
# The Euler equations are a system of three non-linear equations; for each of
# them we create a linear form in the test functions (phi, v, q) respectively.
e1 = div(Rho_0 * U_0)
l1 = LinearForm(phi, int_0(e1 * phi))
e2 = Rho_0 * convect(U_0, U_0) + grad(P_0)
l2 = LinearForm(v, int_0(dot(e2, v)))
e3 = div(P_0 * U_0)
l3 = LinearForm(q, int_0(e3 * q))
# ...
# Linearize l1, l2 and l3 separately
a1 = linearize(l1, fields=[Rho_0, U_0], trials=[d_rho, d_u])
a2 = linearize(l2, fields=[Rho_0, U_0, P_0], trials=[d_rho, d_u, d_p])
a3 = linearize(l3, fields=[U_0, P_0], trials=[d_u, d_p])
# Check individual bilinear forms
d_e1 = div(U_0 * d_rho + Rho_0 * d_u)
d_e2 = d_rho * convect(U_0, U_0) + \
Rho_0 * convect(d_u, U_0) + \
Rho_0 * convect(U_0, d_u) + grad(d_p)
d_e3 = div(d_p * U_0 + P_0 * d_u)
assert a1([d_rho, d_u], phi) == int_0(d_e1 * phi)
assert a2([d_rho, d_u, d_p], v) == int_0(dot(d_e2, v))
assert a3([d_u, d_p], q) == int_0(d_e3 * q)
# Linearize linear form of system: l = l1 + l2 + l3
l = LinearForm((phi, v, q), l1(phi) + l2(v) + l3(q))
a = linearize(l, fields=[Rho_0, U_0, P_0], trials=[d_rho, d_u, d_p])
# Check composite linear form
assert a([d_rho, d_u, d_p], [phi, v, q]) == \
int_0(d_e1 * phi + dot(d_e2, v) + d_e3 * q)
def test_equation_2d_3():
V = ScalarFunctionSpace('V', domain)
v = element_of(V, name='v')
u = element_of(V, name='u')
x, y = domain.coordinates
B1 = Boundary(r'\Gamma_1', domain)
int_0 = lambda expr: integral(domain, expr)
int_1 = lambda expr: integral(B1, expr)
# ... bilinear/linear forms
a1 = BilinearForm((v, u), int_0(dot(grad(v), grad(u))))
a2 = BilinearForm((v, u), int_0(v * u))
l1 = LinearForm(v, int_0(x * y * v))
l2 = LinearForm(v, int_0(cos(x + y) * v))
# ...
# ...
bc = EssentialBC(u, 0, B1)
eq = Equation(a1, l1, tests=v, trials=u, bc=bc)
# ...
# ...
nn = NormalVector('nn')
bc = EssentialBC(dot(grad(u), nn), 0, B1)
eq = Equation(a1, l1, tests=v, trials=u, bc=bc)
def test_compiler_3d_stokes():
domain = Domain('Omega', dim=3)
# ...
# by setting the space type, we cannot evaluate grad of Hdiv function, then
# ArgumentTypeError will be raised.
# In order to avoid this problem, we need first to declare our space as an
# undefined type.
Hdiv = VectorFunctionSpace('V2', domain, kind='Hdiv')
L2 = ScalarFunctionSpace('V3', domain, kind='L2')
X = Hdiv * L2
u, p = element_of(X, name='u, p')
v, q = element_of(X, name='v, q')
with pytest.raises(ArgumentTypeError):
expr = inner(grad(u), grad(v)) - div(v) * p + q * div(u)
# ...
# ...
Hdiv = VectorFunctionSpace('V2', domain)
L2 = ScalarFunctionSpace('V3', domain)
X = Hdiv * L2
u, p = element_of(X, name='u, p')
v, q = element_of(X, name='v, q')
expr = inner(grad(u), grad(v)) - div(v) * p + q * div(u)
atoms = {
u: DifferentialForm('u', index=2, dim=domain.dim),
v: DifferentialForm('v', index=2, dim=domain.dim),
p: DifferentialForm('p', index=3, dim=domain.dim),
q: DifferentialForm('q', index=3, dim=domain.dim)
}
newexpr = ExteriorCalculusExpr(expr, tests=[v, q], atoms=atoms)
print('===== BEFORE =====')
print(newexpr)
newexpr = augmented_expression(newexpr,
tests=[v, q],
atoms=atoms,
weak=False)
print('===== AFTER =====')
print(newexpr)
def test_compiler_3d_2():
domain = Domain('Omega', dim=3)
H1 = ScalarFunctionSpace('V0', domain, kind='H1')
Hcurl = VectorFunctionSpace('V1', domain, kind='Hcurl')
Hdiv = VectorFunctionSpace('V2', domain, kind='Hdiv')
L2 = ScalarFunctionSpace('V3', domain, kind='L2')
V = VectorFunctionSpace('V', domain)
X = H1 * Hcurl * Hdiv * L2
v = element_of(X, name='v0, v1, v2, v3')
u = element_of(X, name='u0, u1, u2, u3')
beta = Field(V, 'beta')
# # ... Dot operator
# expr = dot(u1, v1)
# print(ExteriorCalculusExpr(expr, tests=[v1]))
#
# expr = dot(u2, v2)
# print(ExteriorCalculusExpr(expr, tests=[v2]))
#
# expr = dot(grad(v0), u1)
# print(ExteriorCalculusExpr(expr, tests=[v0]))
#
# expr = dot(grad(u0), v1)
# print(ExteriorCalculusExpr(expr, tests=[v1]))
#
# expr = dot(curl(u1), v2)
# print(ExteriorCalculusExpr(expr, tests=[v2]))
#
# expr = dot(curl(v1), u2)
# print(ExteriorCalculusExpr(expr, tests=[v1]))
# # ...
# ... Mul operator
expr = u[0] * v[0]
print(ExteriorCalculusExpr(expr, tests=[v[0]]))
expr = u[0] * div(v[2])
print(ExteriorCalculusExpr(expr, tests=[v[2]]))
expr = v[0] * div(u[2])
print(ExteriorCalculusExpr(expr, tests=[v[0]]))
def test_compiler_3d_poisson():
domain = Domain('Omega', dim=3)
H1 = ScalarFunctionSpace('V0', domain, kind='H1')
Hcurl = VectorFunctionSpace('V1', domain, kind='Hcurl')
Hdiv = VectorFunctionSpace('V2', domain, kind='Hdiv')
L2 = ScalarFunctionSpace('V3', domain, kind='L2')
V = VectorFunctionSpace('V', domain)
X = Hdiv * L2
sigma, u = element_of(X, name='sigma, u')
tau, v = element_of(X, name='tau, v')
expr = dot(sigma, tau) + div(tau) * u + div(sigma) * v
print(ExteriorCalculusExpr(expr, tests=[tau, v]))
def test_logical_expr_2d_1():
rdim = 2
M = Mapping('M', rdim)
domain = M(Domain('Omega', dim=rdim))
alpha = Constant('alpha')
V = ScalarFunctionSpace('V', domain, kind='h1')
W = VectorFunctionSpace('V', domain, kind='h1')
u, v = [element_of(V, name=i) for i in ['u', 'v']]
w = element_of(W, name='w')
det_M = Jacobian(M).det()
#print('det = ', det_M)
det = Symbol('det')
# ...
expr = 2 * u + alpha * v
expr = LogicalExpr(expr, mapping=M, dim=rdim)
#print(expr)
#print('')
# ...
# ...
expr = dx(u)
expr = LogicalExpr(expr, mapping=M, dim=rdim)
#print(expr.subs(det_M, det))
#print('')
# ...
# ...
expr = dy(u)
expr = LogicalExpr(expr, mapping=M, dim=rdim)
#print(expr.subs(det_M, det))
#print('')
# ...
# ...
expr = dx(det_M)
expr = LogicalExpr(expr, mapping=M, dim=rdim)
expr = expr.subs(det_M, det)
expr = expand(expr)
#print(expr)
#print('')
# ...
# ...
expr = dx(dx(u))
expr = LogicalExpr(expr, mapping=M, dim=rdim)
#print(expr.subs(det_M, det))
#print('')
# ...
# ...
expr = dx(w[0])
expr = LogicalExpr(expr, mapping=M, dim=rdim)
def test_calculus_2d_1():
domain = Domain('Omega', dim=2)
V = ScalarFunctionSpace('V', domain)
W = VectorFunctionSpace('W', domain)
alpha, beta, gamma = [Constant(i) for i in ['alpha', 'beta', 'gamma']]
f, g, h = elements_of(V, names='f, g, h')
F, G, H = elements_of(W, names='F, G, H')
# ... scalar gradient properties
assert (grad(f + g) == grad(f) + grad(g))
assert (grad(alpha * h) == alpha * grad(h))
assert (grad(alpha * f + beta * g) == alpha * grad(f) + beta * grad(g))
assert (grad(f * g) == f * grad(g) + g * grad(f))
assert (grad(f / g) == -f * grad(g) / g**2 + grad(f) / g)
assert (expand(grad(f * g * h)) == f * g * grad(h) + f * h * grad(g) +
g * h * grad(f))
# ...
# ... vector gradient properties
assert (grad(F + G) == grad(F) + grad(G))
assert (grad(alpha * H) == alpha * grad(H))
assert (grad(alpha * F + beta * G) == alpha * grad(F) + beta * grad(G))
assert (grad(dot(F, G)) == convect(F, G) + convect(G, F) +
cross(F, curl(G)) - cross(curl(F), G))
# ...
# ... curl properties
assert (curl(f + g) == curl(f) + curl(g))
assert (curl(alpha * h) == alpha * curl(h))
assert (curl(alpha * f + beta * g) == alpha * curl(f) + beta * curl(g))
# ...
# ... laplace properties
assert (laplace(f + g) == laplace(f) + laplace(g))
assert (laplace(alpha * h) == alpha * laplace(h))
assert (laplace(alpha * f + beta * g) == alpha * laplace(f) +
beta * laplace(g))
# ...
# ... divergence properties
assert (div(F + G) == div(F) + div(G))
assert (div(alpha * H) == alpha * div(H))
assert (div(alpha * F + beta * G) == alpha * div(F) + beta * div(G))
assert (div(cross(F, G)) == -dot(F, curl(G)) + dot(G, curl(F)))
# ...
# ... rot properties
assert (rot(F + G) == rot(F) + rot(G))
assert (rot(alpha * H) == alpha * rot(H))
assert (rot(alpha * F + beta * G) == alpha * rot(F) + beta * rot(G))
def test_linearize_expr_2d_1():
domain = Domain('Omega', dim=2)
x,y = domain.coordinates
V1 = ScalarFunctionSpace('V1', domain)
W1 = VectorFunctionSpace('W1', domain)
v1 = element_of(V1, name='v1')
w1 = element_of(W1, name='w1')
alpha = Constant('alpha')
F = element_of(V1, name='F')
G = element_of(W1, 'G')
# ...
l = LinearExpr(v1, F**2*v1)
a = linearize(l, F, trials='u1')
print(a)
# ...
# ...
l = LinearExpr(v1, dot(grad(F), grad(F))*v1)
a = linearize(l, F, trials='u1')
print(a)
# ...
# ...
l = LinearExpr(v1, exp(-F)*v1)
a = linearize(l, F, trials='u1')
print(a)
# ...
# ...
l = LinearExpr(v1, cos(F)*v1)
a = linearize(l, F, trials='u1')
print(a)
# ...
# ...
l = LinearExpr(v1, cos(F**2)*v1)
a = linearize(l, F, trials='u1')
print(a)
# ...
# ...
l = LinearExpr(v1, F**2*dot(grad(F), grad(v1)))
a = linearize(l, F, trials='u1')
print(a)
# ...
# ...
l = LinearExpr(w1, dot(rot(G), grad(G))*w1)
a = linearize(l, G, trials='u1')
print(a)
def test_interface_2d_1():
# ...
def two_patches():
from sympde.topology import InteriorDomain
from sympde.topology import Connectivity, Interface
A = Square('A')
B = Square('B')
A = A.interior
B = B.interior
connectivity = Connectivity()
bnd_A_1 = Boundary(r'\Gamma_1', A, axis=0, ext=-1)
bnd_A_2 = Boundary(r'\Gamma_2', A, axis=0, ext=1)
bnd_A_3 = Boundary(r'\Gamma_3', A, axis=1, ext=-1)
bnd_A_4 = Boundary(r'\Gamma_4', A, axis=1, ext=1)
bnd_B_1 = Boundary(r'\Gamma_1', B, axis=0, ext=-1)
bnd_B_2 = Boundary(r'\Gamma_2', B, axis=0, ext=1)
bnd_B_3 = Boundary(r'\Gamma_3', B, axis=1, ext=-1)
bnd_B_4 = Boundary(r'\Gamma_4', B, axis=1, ext=1)
connectivity['I'] = Interface('I', bnd_A_2, bnd_B_1)
Omega = Domain('Omega',
interiors=[A, B],
boundaries=[
bnd_A_1, bnd_A_2, bnd_A_3, bnd_A_4, bnd_B_1,
bnd_B_2, bnd_B_3, bnd_B_4
],
connectivity=connectivity)
return Omega
# ...
# create a domain with an interface
domain = two_patches()
interfaces = domain.interfaces
V = ScalarFunctionSpace('V', domain)
u, v = elements_of(V, names='u, v')
print(integral(interfaces, u * v))
expr = integral(domain, dot(grad(v), grad(u)))
expr += integral(interfaces, -avg(Dn(u)) * jump(v) + avg(Dn(v)) * jump(u))
a = BilinearForm((u, v), expr)
print(a)
def test_identity_mapping_2d_2():
dim = 2
M = IdentityMapping('F', dim=dim)
domain = M(Domain('Omega', dim=dim))
V = ScalarFunctionSpace('V', domain, kind='h1')
u = element_of(V, name='u')
# ...
assert (LogicalExpr(dx(u), domain) == dx1(u))
assert (LogicalExpr(dy(u), domain) == dx2(u))
def test_logical_expr_3d_2():
dim = 3
domain = Domain('Omega', dim=dim)
M = Mapping('M', dim=dim)
mapped_domain = M(domain)
V = ScalarFunctionSpace('V', domain, kind='h1')
VM = ScalarFunctionSpace('VM', mapped_domain, kind='h1')
u, v = elements_of(V, names='u,v')
um, vm = elements_of(VM, names='u,v')
J = M.jacobian
a = dot(grad(um), grad(vm))
e = LogicalExpr(a, mapping=M, dim=dim)
assert e == dot(J.inv().T * grad(u), J.inv().T * grad(v))
def test_partial_derivatives_2():
print('============ test_partial_derivatives_2 ==============')
# ...
domain = Domain('Omega', dim=2)
M = Mapping('M', dim=2)
mapped_domain = M(domain)
V = ScalarFunctionSpace('V', mapped_domain)
F = element_of(V, name='F')
alpha = Constant('alpha')
beta = Constant('beta')
# ...
# ...
expr = alpha * dx(F)
indices = get_index_derivatives_atom(expr, F)[0]
assert (indices_as_str(indices) == 'x')
# ...
# ...
expr = dy(dx(F))
indices = get_index_derivatives_atom(expr, F)[0]
assert (indices_as_str(indices) == 'xy')
# ...
# ...
expr = alpha * dx(dy(dx(F)))
indices = get_index_derivatives_atom(expr, F)[0]
assert (indices_as_str(indices) == 'xxy')
# ...
# ...
expr = alpha * dx(dx(F)) + beta * dy(F) + dx(dy(F))
indices = get_index_derivatives_atom(expr, F)
indices = [indices_as_str(i) for i in indices]
assert (sorted(indices) == ['xx', 'xy', 'y'])
# ...
# ...
expr = alpha * dx(dx(F)) + beta * dy(F) + dx(dy(F))
d = get_max_partial_derivatives(expr, F)
assert (indices_as_str(d) == 'xxy')
d = get_max_partial_derivatives(expr)
assert (indices_as_str(d) == 'xxy')
def test_interface_integral_1():
# ...
A = Square('A')
B = Square('B')
domain = A.join(B,
name='domain',
bnd_minus=A.get_boundary(axis=0, ext=1),
bnd_plus=B.get_boundary(axis=0, ext=-1))
# ...
x, y = domain.coordinates
V = ScalarFunctionSpace('V', domain, kind=None)
assert (V.is_broken)
u, v = elements_of(V, names='u, v')
# ...
I = domain.interfaces
# ...
# expr = minus(Dn(u))
# print(expr)
# import sys; sys.exit(0)
# ... bilinear forms
# a = BilinearForm((u,v), integral(domain, u*v))
# a = BilinearForm((u,v), integral(domain, dot(grad(u),grad(v))))
# a = BilinearForm((u,v), integral(I, jump(u) * jump(v)))
# a = BilinearForm((u,v), integral(I, jump(Dn(u)) * jump(v)))
# a = BilinearForm((u,v), integral(domain, dot(grad(u),grad(v)))
# + integral(I, jump(u) * jump(v)))
# Nitsch
kappa = Constant('kappa')
expr_I = (-jump(u) * jump(Dn(v)) + kappa * jump(u) * jump(v) +
plus(Dn(u)) * minus(v) + minus(Dn(u)) * plus(v))
a = BilinearForm(
(u, v),
integral(domain, dot(grad(u), grad(v))) + integral(I, expr_I))
# # TODO BUG
# bnd_A = A.get_boundary(axis=0, ext=1)
#
# a = BilinearForm((u,v), integral(domain, dot(grad(u),grad(v)))
# + integral(I, jump(u) * jump(v))
# + integral(bnd_A, dx(u)*v))
expr = TerminalExpr(a)
print(expr)
def test_essential_bc_1():
domain = Domain('Omega', dim=2)
V = ScalarFunctionSpace('V', domain)
W = VectorFunctionSpace('W', domain)
v = element_of(V, name='v')
w = element_of(W, name='w')
B1 = Boundary(r'\Gamma_1', domain)
nn = NormalVector('nn')
# ... scalar case
bc = EssentialBC(v, 0, B1)
assert (bc.variable == v)
assert (bc.order == 0)
assert (bc.normal_component == False)
assert (bc.index_component == None)
# ...
# ... scalar case
bc = EssentialBC(dot(grad(v), nn), 0, B1)
assert (bc.variable == v)
assert (bc.order == 1)
assert (bc.normal_component == False)
assert (bc.index_component == None)
# ...
# ... vector case
bc = EssentialBC(w, 0, B1)
assert (bc.variable == w)
assert (bc.order == 0)
assert (bc.normal_component == False)
assert (bc.index_component == [0, 1])
# ...
# ... vector case
bc = EssentialBC(dot(w, nn), 0, B1)
assert (bc.variable == w)
assert (bc.order == 0)
assert (bc.normal_component == True)
assert (bc.index_component == None)
# ...
# ... vector case
bc = EssentialBC(w[0], 0, B1)
assert (bc.variable == w)
assert (bc.order == 0)
assert (bc.normal_component == False)
assert (bc.index_component == [0])
def test_linearize_form_2d_1():
domain = Domain('Omega', dim=2)
V = ScalarFunctionSpace('V', domain)
W = VectorFunctionSpace('W', domain)
v, F, u = elements_of(V, names='v, F, u')
w, G, m = elements_of(W, names='w, G, m')
int_0 = lambda expr: integral(domain, expr)
# ...
l = LinearForm(v, int_0(F**2 * v))
a = linearize(l, F, trials=u)
assert a(u, v) == int_0(2 * F * u * v)
# ...
# ...
l = LinearForm(v, int_0(dot(grad(F), grad(F)) * v))
a = linearize(l, F, trials=u)
assert a(u, v) == int_0(2 * dot(grad(F), grad(u)) * v)
# ...
# ...
l = LinearForm(v, int_0(exp(-F) * v))
a = linearize(l, F, trials=u)
assert a(u, v) == int_0(-exp(-F) * u * v)
# ...
# ...
l = LinearForm(v, int_0(cos(F) * v))
a = linearize(l, F, trials=u)
assert a(u, v) == int_0(-sin(F) * u * v)
# ...
# ...
l = LinearForm(v, int_0(cos(F**2) * v))
a = linearize(l, F, trials=u)
assert a(u, v) == int_0(-2 * F * sin(F**2) * u * v)
# ...
# ...
l = LinearForm(v, int_0(F**2 * dot(grad(F), grad(v))))
a = linearize(l, F, trials=u)
assert a(u, v) == int_0(2 * F * u * dot(grad(F), grad(v)) +
F**2 * dot(grad(u), grad(v)))
# ...
# ...
l = LinearForm(w, int_0(dot(rot(G), grad(G)) * w))
a = linearize(l, G, trials=m)
assert a(m, w) == int_0((dot(rot(m), grad(G)) + dot(rot(G), grad(m))) * w)
def test_interface_integral_3():
# ...
A = Square('A')
B = Square('B')
C = Square('C')
AB = A.join(B,
name='AB',
bnd_minus=A.get_boundary(axis=0, ext=1),
bnd_plus=B.get_boundary(axis=0, ext=-1))
domain = AB.join(C,
name='domain',
bnd_minus=B.get_boundary(axis=0, ext=1),
bnd_plus=C.get_boundary(axis=0, ext=-1))
# ...
x, y = domain.coordinates
V = ScalarFunctionSpace('V', domain, kind=None)
assert (V.is_broken)
u, v = elements_of(V, names='u, v')
# ...
I = domain.interfaces
# print(I)
# print(integral(I, jump(u) * jump(v)))
# a = BilinearForm((u,v), integral(domain, u*v))
# a = BilinearForm((u,v), integral(domain, dot(grad(u),grad(v))))
# a = BilinearForm((u,v), integral(I, jump(u) * jump(v)))
a = BilinearForm((u, v),
integral(domain, dot(grad(u), grad(v))) +
integral(I,
jump(u) * jump(v)))
expr = TerminalExpr(a)
print(expr)
# ...
# ... linear forms
b = LinearForm(
v,
integral(domain,
sin(x + y) * v) + integral(I,
cos(x + y) * jump(v)))
expr = TerminalExpr(b)
print(expr)
def test_space_2d_2():
DIM = 2
domain = Domain('Omega', dim=DIM)
H1 = ScalarFunctionSpace('V0', domain, kind='H1')
Hcurl = VectorFunctionSpace('V1', domain, kind='Hcurl')
Hdiv = VectorFunctionSpace('V2', domain, kind='Hdiv')
L2 = ScalarFunctionSpace('V3', domain, kind='L2')
V = ScalarFunctionSpace('V', domain, kind=None)
W = VectorFunctionSpace('W', domain, kind=None)
assert (H1.kind == H1Space)
assert (Hcurl.kind == HcurlSpace)
assert (Hdiv.kind == HdivSpace)
assert (L2.kind == L2Space)
assert (V.kind == UndefinedSpace)
assert (W.kind == UndefinedSpace)
assert (H1.regularity > L2.regularity)
assert (H1.regularity > Hcurl.regularity)
assert (Hcurl.regularity > L2.regularity)
def test_identity_mapping_2d_2():
rdim = 2
x1, x2 = symbols('x1, x2')
M = IdentityMapping('F', rdim)
domain = M(Domain('Omega', dim=rdim))
V = ScalarFunctionSpace('V', domain, kind='h1')
u = element_of(V, name='u')
# ...
assert (LogicalExpr(dx(u), mapping=M, dim=rdim, subs=True) == dx1(u))
assert (LogicalExpr(dy(u), mapping=M, dim=rdim, subs=True) == dx2(u))
def test_identity_mapping_2d_2():
rdim = 2
x1, x2 = symbols('x1, x2')
domain = Domain('Omega', dim=rdim)
M = IdentityMapping('F', rdim)
V = ScalarFunctionSpace('V', domain)
u = element_of(V, name='u')
# ...
assert (LogicalExpr(M, dx(u)) == dx1(u))
assert (LogicalExpr(M, dy(u)) == dx2(u))
def test_logical_expr_3d_1():
rdim = 3
M = Mapping('M', rdim)
domain = Domain('Omega', dim=rdim)
alpha = Constant('alpha')
V = ScalarFunctionSpace('V', domain)
u, v = [element_of(V, name=i) for i in ['u', 'v']]
det_M = DetJacobian(M)
#print('det = ', det_M)
det = Symbol('det')
# ...
expr = 2 * u + alpha * v
expr = LogicalExpr(M, expr)
#print(expr)
#print('')
# ...
# ...
expr = dx(u)
expr = LogicalExpr(M, expr)
#print(expr.subs(det_M, det))
#print('')
# ...
# ...
expr = dy(u)
expr = LogicalExpr(M, expr)
#print(expr.subs(det_M, det))
#print('')
# ...
# ...
expr = dx(det_M)
expr = LogicalExpr(M, expr)
expr = expr.subs(det_M, det)
expr = expand(expr)
#print(expr)
#print('')
# ...
# ...
expr = dx(dx(u))
expr = LogicalExpr(M, expr)
def test_logical_expr_3d_1():
dim = 3
M = Mapping('M', dim=dim)
domain = M(Domain('Omega', dim=dim))
alpha = Constant('alpha')
V = ScalarFunctionSpace('V', domain, kind='h1')
u, v = [element_of(V, name=i) for i in ['u', 'v']]
det_M = Jacobian(M).det()
#print('det = ', det_M)
det = Symbol('det')
# ...
expr = 2 * u + alpha * v
expr = LogicalExpr(expr, domain)
#print(expr)
#print('')
# ...
# ...
expr = dx(u)
expr = LogicalExpr(expr, domain)
#print(expr.subs(det_M, det))
#print('')
# ...
# ...
expr = dy(u)
expr = LogicalExpr(expr, domain)
#print(expr.subs(det_M, det))
#print('')
# ...
# ...
expr = dx(det_M)
expr = LogicalExpr(expr, domain)
expr = expr.subs(det_M, det)
#print(expr)
#print('')
# ...
# ...
expr = dx(dx(u))
expr = LogicalExpr(expr, domain)
