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_boundary_2d_2():
Omega_1 = InteriorDomain('Omega_1', dim=2)
B1 = Boundary('B1', Omega_1)
B2 = Boundary('B2', Omega_1)
B3 = Boundary('B3', Omega_1)
domain = Domain('Omega', interiors=[Omega_1], boundaries=[B1, B2, B3])
V = FunctionSpace('V', domain)
v = TestFunction(V, name='v')
u = TestFunction(V, name='u')
x, y = V.coordinates
alpha = Constant('alpha')
# ...
print('==== l0 ====')
l0 = LinearForm(v, x * y * v, name='l0')
print(evaluate(l0, verbose=VERBOSE))
print('')
# ...
# ...
print('==== l1 ====')
g = Tuple(x**2, y**2)
l1 = LinearForm(v, v * trace_1(g, domain.boundary))
print(evaluate(l1, verbose=VERBOSE))
print('')
# ...
# ...
print('==== l2 ====')
B_neumann = Union(B1, B2)
g = Tuple(x**2, y**2)
l2 = LinearForm(v, v * trace_1(g, B_neumann), name='l2')
print(evaluate(l2, verbose=VERBOSE))
print('')
# ...
# ...
print('==== l3 ====')
l3 = LinearForm(v, l2(v))
assert (l3(v).__str__ == l2(v).__str__)
print(evaluate(l3, verbose=VERBOSE))
print('')
# ...
# ...
print('==== l4 ====')
l4 = LinearForm(v, l0(v) + l2(v))
print(evaluate(l4, verbose=VERBOSE))
print('')
def test_boundary_3():
Omega_1 = InteriorDomain('Omega_1', dim=2)
Gamma_1 = Boundary(r'\Gamma_1', Omega_1, axis=0, ext=-1)
Gamma_4 = Boundary(r'\Gamma_4', Omega_1, axis=1, ext=1)
Omega = Domain('Omega',
interiors=[Omega_1],
boundaries=[Gamma_1, Gamma_4])
assert(Omega.get_boundary(axis=0, ext=-1) == Gamma_1)
assert(Omega.get_boundary(axis=1, ext=1) == Gamma_4)
def test_boundary_1():
Omega_1 = InteriorDomain('Omega_1', dim=2)
Gamma_1 = Boundary('Gamma_1', Omega_1)
Gamma_2 = Boundary('Gamma_2', Omega_1)
Omega = Domain('Omega',
interiors=[Omega_1],
boundaries=[Gamma_1, Gamma_2])
assert(Omega.boundary == Union(Gamma_1, Gamma_2))
assert(Omega.boundary.complement(Gamma_1) == Gamma_2)
assert(Omega.boundary - Gamma_1 == Gamma_2)
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
def test_domain_1():
Omega_1 = InteriorDomain('Omega_1', dim=2)
Omega_2 = InteriorDomain('Omega_2', dim=2)
Gamma_1 = Boundary('Gamma_1', Omega_1)
Gamma_2 = Boundary('Gamma_2', Omega_2)
Gamma_3 = Boundary('Gamma_3', Omega_2)
Omega = Domain('Omega',
interiors=[Omega_1, Omega_2],
boundaries=[Gamma_1, Gamma_2, Gamma_3])
assert( Omega.dim == 2 )
assert( len(Omega.interior) == 2 )
assert( len(Omega.boundary) == 3 )
def test_bilinear_form_2d_4():
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 = VectorFunctionSpace('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(dot(u, v)))
assert (a.is_symmetric)
# ...
# ...
a = BilinearForm((u, v), int_0(inner(grad(u), grad(v))))
assert (a.is_symmetric)
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_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_tensorize_2d_1_mapping():
DIM = 2
M = Mapping('Map', DIM)
domain = Domain('Omega', dim=DIM)
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, v = elements_of(V, names='u, v')
int_0 = lambda expr: integral(domain, expr)
# ...
# a = BilinearForm((u,v), u*v)
# a = BilinearForm((u,v), mu*u*v + dot(grad(u),grad(v)))
a = BilinearForm((u, v), int_0(dot(grad(u), grad(v))))
# a = BilinearForm((u,v), dx(u)*v)
# a = BilinearForm((u,v), laplace(u)*laplace(v))
expr = TensorExpr(a, mapping=M)
print(expr)
def test_terminal_expr_linear_2d_2():
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 = VectorFunctionSpace('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)
g = Matrix((x, y))
l = LinearForm(v, int_0(dot(g, v)))
print(TerminalExpr(l))
print('')
# ...
# ...
g = Matrix((x, y))
l = LinearForm(v, int_0(dot(g, v) + div(v)))
print(TerminalExpr(l))
print('')
def test_equation_2d_4():
V = VectorFunctionSpace('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(inner(grad(v), grad(u))))
f = Tuple(x * y, sin(pi * x) * sin(pi * y))
l1 = LinearForm(v, int_0(dot(f, v)))
# ...
# ...
bc = EssentialBC(u, 0, B1)
eq = Equation(a1, l1, tests=v, trials=u, bc=bc)
# ...
# ...
bc = EssentialBC(u[0], 0, B1)
eq = Equation(a1, l1, tests=v, trials=u, bc=bc)
# ...
# ...
nn = NormalVector('nn')
bc = EssentialBC(dot(u, nn), 0, B1)
eq = Equation(a1, l1, tests=v, trials=u, bc=bc)
def test_terminal_expr_bilinear_2d_2():
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)
nn = NormalVector('nn')
V = VectorFunctionSpace('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(dot(u, v)))
print(TerminalExpr(a))
print('')
# ...
a = BilinearForm((u, v), int_0(inner(grad(u), grad(v))))
print(TerminalExpr(a))
print('')
# ...
# ...
a = BilinearForm((u, v), int_0(dot(u, v) + inner(grad(u), grad(v))))
print(TerminalExpr(a))
print('')
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_evaluation_2d_1():
domain = Domain('Omega', dim=2)
B_neumann = Boundary(r'\Gamma_1', domain)
V = FunctionSpace('V', domain)
W = VectorFunctionSpace('W', domain)
p, q = [TestFunction(V, name=i) for i in ['p', 'q']]
u, v = [VectorTestFunction(W, name=i) for i in ['u', 'v']]
alpha = Constant('alpha')
x, y = V.coordinates
F = Field('F', space=V)
a1 = BilinearForm((p, q), dot(grad(p), grad(q)))
m = BilinearForm((p, q), p * q)
a2 = BilinearForm((p, q), a1(p, q) + alpha * m(p, q))
a3 = BilinearForm((u, v), rot(u) * rot(v) + alpha * div(u) * div(v))
a11 = BilinearForm((v, u), inner(grad(v), grad(u)))
a12 = BilinearForm((v, p), div(v) * p)
a4 = BilinearForm(((v, q), (u, p)), a11(v, u) - a12(v, p) + a12(u, q))
l0 = LinearForm(p, F * p)
l_neu = LinearForm(p, p * trace_1(grad(F), B_neumann))
l = LinearForm(p, l0(p) + l_neu(p))
# ...
print(a1)
print(evaluate(a1))
print('')
# ...
# ...
print(a2)
print(evaluate(a2))
print('')
# ...
# ...
print(a3)
print(evaluate(a3))
print('')
# ...
# ...
print(a4)
print(evaluate(a4))
print('')
# ...
# ...
print(l)
print(evaluate(l))
print('')
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_topology_1():
# ... create a domain with 2 subdomains A and B
A = InteriorDomain('A', dim=2)
B = InteriorDomain('B', dim=2)
connectivity = Connectivity()
bnd_A_1 = Boundary('Gamma_1', A)
bnd_A_2 = Boundary('Gamma_2', A)
bnd_A_3 = Boundary('Gamma_3', A)
bnd_B_1 = Boundary('Gamma_1', B)
bnd_B_2 = Boundary('Gamma_2', B)
bnd_B_3 = Boundary('Gamma_3', B)
connectivity['I'] = (bnd_A_1, bnd_B_2)
Omega = Domain('Omega',
interiors=[A, B],
boundaries=[bnd_A_2, bnd_A_3, bnd_B_1, bnd_B_3],
connectivity=connectivity)
interfaces = Omega.interfaces
assert(isinstance(interfaces, Interface))
# export
Omega.export('omega.h5')
# ...
# read it again and check that it has the same description as Omega
D = Domain.from_file('omega.h5')
assert( D.todict() == Omega.todict() )
def test_bilinear_form_2d_2():
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 = VectorFunctionSpace('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(dot(u, v)))
assert (a.domain == domain.interior)
assert (a(u1, v1) == int_0(dot(u1, v1)))
# ...
# ...
a = BilinearForm((u, v), int_0(dot(u, v) + inner(grad(u), grad(v))))
assert (a.domain == domain.interior)
assert (a(u1, v1) == int_0(dot(u1, v1)) + int_0(inner(grad(u1), grad(v1))))
# ...
# ...
a1 = BilinearForm((u1, v1), int_0(dot(u1, v1)))
a = BilinearForm((u, v), a1(u, v))
assert (a.domain == domain.interior)
assert (a(u2, v2) == int_0(dot(u2, v2)))
# ...
# ...
a1 = BilinearForm((u1, v1), int_0(dot(u1, v1)))
a2 = BilinearForm((u2, v2), int_0(inner(grad(u2), grad(v2))))
a = BilinearForm((u, v), a1(u, v) + kappa * a2(u, v))
assert (a.domain == domain.interior)
assert (a(u,
v) == int_0(dot(u, v)) + int_0(kappa * inner(grad(u), grad(v))))
def test_bilinear_form_2d_1():
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)
eps = Constant('eps', real=True)
V = FunctionSpace('V', domain)
u, u1, u2 = [TestFunction(V, name=i) for i in ['u', 'u1', 'u2']]
v, v1, v2 = [TestFunction(V, name=i) for i in ['v', 'v1', 'v2']]
# ...
d_forms = {}
d_forms['a1'] = BilinearForm((u, v), u * v)
d_forms['a2'] = BilinearForm((u, v), u * v + dot(grad(u), grad(v)))
d_forms['a3'] = BilinearForm((u, v), v * trace_1(grad(u), B1))
# Poisson with Nitsch method
a0 = BilinearForm((u, v), dot(grad(u), grad(v)))
a_B1 = BilinearForm(
(u, v), -kappa * u * trace_1(grad(v), B1) - v * trace_1(grad(u), B1) +
trace_0(u, B1) * trace_0(v, B1) / eps)
a = BilinearForm((u, v), a0(u, v) + a_B1(u, v))
d_forms['a4'] = a
# ...
# ... calls
d_calls = {}
for name, a in d_forms.items():
d_calls[name] = a(u1, v1)
# ...
# ... export forms
for name, expr in d_forms.items():
export(expr, 'biform_2d_{}.png'.format(name))
# ...
# ... export calls
for name, expr in d_calls.items():
export(expr, 'biform_2d_call_{}.png'.format(name))
def test_linear_form_2d_2():
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 = VectorFunctionSpace('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)
g = Matrix((x, y))
l = LinearForm(v, int_0(dot(g, v)))
assert (l.domain == domain.interior)
assert (l(v1) == int_0(dot(g, v1)))
# ...
# ...
g = Matrix((x, y))
l1 = LinearForm(v1, int_0(dot(g, v1)))
l = LinearForm(v, l1(v))
assert (l.domain == domain.interior)
assert (l(u1) == int_0(dot(g, u1)))
# ...
# ...
g1 = Matrix((x, 0))
g2 = Matrix((0, y))
l1 = LinearForm(v1, int_0(dot(v1, g1)))
l2 = LinearForm(v2, int_0(dot(v2, g2)))
l = LinearForm(v, l1(v) + l2(v))
assert (l.domain == domain.interior)
assert (l(u) == int_0(dot(u, g1)) + int_0(dot(u, g2)))
def test_tensorize_2d_2():
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 = VectorFunctionSpace('V', domain)
u, v = elements_of(V, names='u, v')
int_0 = lambda expr: integral(domain, expr)
# ...
# a = BilinearForm((u,v), dot(u,v))
a = BilinearForm((u, v), int_0(curl(u) * curl(v) + div(u) * div(v)))
expr = TensorExpr(a)
print(expr)
def test_linear_form_2d_1():
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)
eps = Constant('eps', real=True)
V = FunctionSpace('V', domain)
u, u1, u2 = [TestFunction(V, name=i) for i in ['u', 'u1', 'u2']]
v, v1, v2 = [TestFunction(V, name=i) for i in ['v', 'v1', 'v2']]
g = Tuple(x**2, y**2)
# ...
d_forms = {}
d_forms['l1'] = LinearForm(v, x * y * v)
d_forms['l2'] = LinearForm(v, v * trace_1(g, B1))
d_forms['l3'] = LinearForm(v, v * trace_1(g, B1) + x * y * v)
# nitsche
f = Function('f')
g = Function('g')
l0 = LinearForm(v, f(x, y) * v)
l_B1 = LinearForm(
v,
g(x, y) * trace_0(v, B1) / eps -
kappa * g(x, y) * trace_1(grad(v), B1))
d_forms['l4'] = LinearForm(v, l0(v) + l_B1(v))
# ...
# ...
for name, expr in d_forms.items():
export(expr, 'linform_2d_{}.png'.format(name))
def test_linear_form_2d_1():
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)
nn = NormalVector('nn')
V = ScalarFunctionSpace('V', domain)
W = VectorFunctionSpace('W', 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)
l = LinearForm(v, int_0(x * y * v))
assert (l.domain == domain.interior)
assert (l(v1) == int_0(x * y * v1))
# ...
# ...
g = Tuple(x**2, y**2)
l = LinearForm(v, int_1(v * dot(g, nn)))
print(l)
assert (l.domain == B1)
assert (l(v1) == int_1(v1 * trace_1(g, B1)))
# ...
# ...
g = Tuple(x**2, y**2)
l = LinearForm(v, int_1(v * dot(g, nn)) + int_0(x * y * v))
assert (len(l.domain.args) == 2)
for i in l.domain.args:
assert (i in [domain.interior, B1])
assert (l(v1) == int_1(v1 * trace_1(g, B1)) + int_0(x * y * v1))
# ...
# ...
l1 = LinearForm(v1, int_0(x * y * v1))
l = LinearForm(v, l1(v))
assert (l.domain == domain.interior)
assert (l(u1) == int_0(x * y * u1))
# ...
# ...
g = Tuple(x, y)
l1 = LinearForm(u1, int_0(x * y * u1))
l2 = LinearForm(u2, int_0(dot(grad(u2), g)))
l = LinearForm(v, l1(v) + l2(v))
assert (l.domain == domain.interior)
assert (l(v1) == int_0(x * y * v1) + int_0(dot(grad(v1), g)))
# ...
# ...
pn, wn = [element_of(V, name=i) for i in ['pn', 'wn']]
tau = element_of(V, name='tau')
sigma = element_of(V, name='sigma')
Re = Constant('Re', real=True)
dt = Constant('dt', real=True)
alpha = Constant('alpha', real=True)
l1 = LinearForm(
tau, int_0(bracket(pn, wn) * tau - 1. / Re * dot(grad(tau), grad(wn))))
l = LinearForm((tau, sigma), dt * l1(tau))
assert (l.domain == domain.interior)
assert (l(u1,
u2).expand() == int_0(-1.0 * dt * dot(grad(u1), grad(wn)) / Re) +
int_0(dt * u1 * bracket(pn, wn)))
def test_linearity_linear_form_2d_1():
from sympde.expr.errors import UnconsistentLinearExpressionError
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)
nn = NormalVector('nn')
V = ScalarFunctionSpace('V', domain)
W = VectorFunctionSpace('W', domain)
v, v1, v2 = elements_of(V, names='v, v1, v2')
w = element_of(W, name='w')
# ...
int_0 = lambda expr: integral(domain, expr)
int_1 = lambda expr: integral(B1, expr)
# The following integral expressions are linear, hence it must be possible
# to create LinearForm objects from them
_ = LinearForm(v, int_0(x * y * v))
_ = LinearForm(v, int_0(x * y * v + v))
g = Matrix((x**2, y**2))
_ = LinearForm(v, int_0(v * dot(g, nn)))
g = Matrix((x**2, y**2))
_ = LinearForm(v, int_1(v * dot(g, nn)) + int_0(x * y * v))
l1 = LinearForm(v1, int_0(x * y * v1))
_ = LinearForm(v, l1(v))
g = Matrix((x, y))
l1 = LinearForm(v1, int_0(x * y * v1))
l2 = LinearForm(v2, int_0(dot(grad(v2), g)))
_ = LinearForm(v, l1(v) + l2(v))
l1 = LinearForm(v1, int_0(x * y * v1))
l2 = LinearForm(v1, int_0(v1))
_ = LinearForm(v, l1(v) + kappa * l2(v))
g = Matrix((x**2, y**2))
l1 = LinearForm(v1, int_0(x * y * v1))
l2 = LinearForm(v1, int_0(v1))
l3 = LinearForm(v, int_1(v * dot(g, nn)))
_ = LinearForm(v, l1(v) + kappa * l2(v) + mu * l3(v))
l1 = LinearForm(w, int_0(5 * w * x))
l2 = LinearForm(w, int_1(w * y))
_ = LinearForm(w, l1(w) + kappa * l2(w))
l0 = LinearForm(v, int_0(x * y * v))
l1 = LinearForm(w, int_0(w[0] * y))
l2 = LinearForm(w, int_1(w[1] * x))
l3 = LinearForm(w, kappa * l1(w) + mu * l2(w))
_ = LinearForm((v, w), l0(v) + l3(w))
# The following integral expressions are not linear, hence LinearForm must
# raise an exception
with pytest.raises(UnconsistentLinearExpressionError):
_ = LinearForm(v, int_0(x * y * v + 1))
with pytest.raises(UnconsistentLinearExpressionError):
_ = LinearForm(v, int_0(x * v**2))
with pytest.raises(UnconsistentLinearExpressionError):
_ = LinearForm(v, int_0(x * y * v) + int_1(v * exp(v)))
with pytest.raises(UnconsistentLinearExpressionError):
_ = LinearForm(w, int_0(w * w))
with pytest.raises(UnconsistentLinearExpressionError):
_ = LinearForm(w, int_0(w[0] * w[1]))
with pytest.raises(UnconsistentLinearExpressionError):
_ = LinearForm((v, w), int_0(x * w[0]) + int_1(v * w[1]))
def test_terminal_expr_linear_2d_1():
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)
nn = NormalVector('nn')
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)
l = LinearForm(v, int_0(x * y * v))
print(TerminalExpr(l))
print('')
# ...
# ...
l = LinearForm(v, int_0(x * y * v + v))
print(TerminalExpr(l))
print('')
# ...
# ...
g = Matrix((x**2, y**2))
l = LinearForm(v, int_1(v * dot(g, nn)))
print(TerminalExpr(l))
print('')
# ...
# ...
g = Matrix((x**2, y**2))
l = LinearForm(v, int_1(v * dot(g, nn)) + int_0(x * y * v))
print(TerminalExpr(l))
print('')
# ...
# ...
l1 = LinearForm(v1, int_0(x * y * v1))
l = LinearForm(v, l1(v))
print(TerminalExpr(l))
print('')
# ...
# ...
g = Matrix((x, y))
l1 = LinearForm(v1, int_0(x * y * v1))
l2 = LinearForm(v2, int_0(dot(grad(v2), g)))
l = LinearForm(v, l1(v) + l2(v))
print(TerminalExpr(l))
print('')
# ...
# ...
l1 = LinearForm(v1, int_0(x * y * v1))
l2 = LinearForm(v1, int_0(v1))
l = LinearForm(v, l1(v) + kappa * l2(v))
print(TerminalExpr(l))
print('')
# ...
# ...
g = Matrix((x**2, y**2))
l1 = LinearForm(v1, int_0(x * y * v1))
l2 = LinearForm(v1, int_0(v1))
l3 = LinearForm(v, int_1(v * dot(g, nn)))
l = LinearForm(v, l1(v) + kappa * l2(v) + mu * l3(v))
print(TerminalExpr(l))
print('')
def test_linearity_bilinear_form_2d_1():
from sympde.expr.errors import UnconsistentLinearExpressionError
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)
eps = Constant('eps', real=True)
nn = NormalVector('nn')
V = ScalarFunctionSpace('V', domain)
u, u1, u2 = elements_of(V, names='u, u1, u2')
v, v1, v2 = elements_of(V, names='v, v1, v2')
# ...
int_0 = lambda expr: integral(domain, expr)
int_1 = lambda expr: integral(B1, expr)
# The following integral expressions are bilinear, hence it must be possible
# to create BilinearForm objects from them
_ = BilinearForm((u, v), int_0(u * v))
_ = BilinearForm((u, v), int_0(dot(grad(u), grad(v))))
_ = BilinearForm((u, v), int_0(u * v + dot(grad(u), grad(v))))
_ = BilinearForm(
(u, v),
int_0(u * v + dot(grad(u), grad(v))) + int_1(v * dot(grad(u), nn)))
_ = BilinearForm(((u1, u2), (v1, v2)), int_0(u1 * v1 + u2 * v2))
a1 = BilinearForm((u1, v1), int_0(u1 * v1))
_ = BilinearForm((u, v), a1(u, v))
a1 = BilinearForm((u1, v1), int_0(u1 * v1))
a2 = BilinearForm((u2, v2), int_0(dot(grad(u2), grad(v2))))
_ = BilinearForm((u, v), a1(u, v) + a2(u, v))
a1 = BilinearForm((u1, v1), int_0(u1 * v1))
a2 = BilinearForm((u2, v2), int_0(dot(grad(u2), grad(v2))))
_ = BilinearForm((u, v), a1(u, v) + kappa * a2(u, v))
a1 = BilinearForm((u1, v1), int_0(u1 * v1))
a2 = BilinearForm((u2, v2), int_0(dot(grad(u2), grad(v2))))
a3 = BilinearForm((u, v), int_1(v * dot(grad(u), nn)))
_ = BilinearForm((u, v), a1(u, v) + kappa * a2(u, v) + mu * a3(u, v))
# ... Poisson with Nitsch method
a0 = BilinearForm((u, v), int_0(dot(grad(u), grad(v))))
a_B1 = BilinearForm((u, v),
int_1(-kappa * u * dot(grad(v), nn) -
v * dot(grad(u), nn) + u * v / eps))
_ = BilinearForm((u, v), a0(u, v) + a_B1(u, v))
# ...
# The following integral expressions are not bilinear, hence BilinearForm must
# raise an exception
with pytest.raises(UnconsistentLinearExpressionError):
_ = BilinearForm((u, v), int_0(x * y * dot(grad(u), grad(v)) + 1))
with pytest.raises(UnconsistentLinearExpressionError):
_ = BilinearForm((u, v), int_0(x * dot(grad(u), grad(v**2))))
with pytest.raises(UnconsistentLinearExpressionError):
_ = BilinearForm((u, v), int_0(u * v) + int_1(v * exp(u)))
def test_equation_2d_1():
V = ScalarFunctionSpace('V', domain)
U = ScalarFunctionSpace('U', domain)
v = element_of(V, name='v')
u = element_of(U, name='u')
x, y = domain.coordinates
alpha = Constant('alpha')
kappa = Constant('kappa', real=True)
eps = Constant('eps', real=True)
nn = NormalVector('nn')
B1 = Boundary(r'\Gamma_1', domain)
B2 = Boundary(r'\Gamma_2', domain)
B3 = Boundary(r'\Gamma_3', domain)
int_0 = lambda expr: integral(domain, expr)
int_1 = lambda expr: integral(B1, expr)
int_2 = lambda expr: integral(B2, expr)
# ... bilinear/linear forms
expr = dot(grad(v), grad(u))
a1 = BilinearForm((v, u), int_0(expr))
expr = v * u
a2 = BilinearForm((v, u), int_0(expr))
expr = v * u
a_B1 = BilinearForm((v, u), int_1(expr))
expr = x * y * v
l1 = LinearForm(v, int_0(expr))
expr = cos(x + y) * v
l2 = LinearForm(v, int_0(expr))
expr = x * y * v
l_B2 = LinearForm(v, int_2(expr))
# ...
# # ...
# with pytest.raises(UnconsistentLhsError):
# equation = Equation(a1, l1(v))
#
# with pytest.raises(UnconsistentLhsError):
# equation = Equation(l1(v), l1(v))
#
# with pytest.raises(UnconsistentLhsError):
# equation = Equation(a1(v,u) + alpha*a2(v,u), l1(v))
# # ...
#
# # ...
# with pytest.raises(UnconsistentRhsError):
# equation = Equation(a1(v,u), l1)
#
# with pytest.raises(UnconsistentRhsError):
# equation = Equation(a1(v,u), a1(v,u))
#
# with pytest.raises(UnconsistentRhsError):
# equation = Equation(a1(v,u), l1(v) + l2(v))
# # ...
# ...
equation = Equation(a1, l1, tests=v, trials=u)
# ...
# ...
a = BilinearForm((v, u), a1(v, u) + alpha * a2(v, u))
equation = Equation(a, l1, tests=v, trials=u)
# ...
# ...
a = BilinearForm((v, u), a1(v, u) + a_B1(v, u))
equation = Equation(a, l1, tests=v, trials=u)
# ...
# ...
a = BilinearForm((v, u), a1(v, u) + a_B1(v, u))
l = LinearForm(v, l1(v) + l2(v))
equation = Equation(a, l, tests=v, trials=u)
# ...
# ...
a = BilinearForm((v, u), a1(v, u) + a_B1(v, u))
l = LinearForm(v, l1(v) + alpha * l_B2(v))
equation = Equation(a, l, tests=v, trials=u)
# ...
# ... using bc
equation = Equation(a1, l1, tests=v, trials=u, bc=EssentialBC(u, 0, B1))
# ...
# ... Poisson with Nitsch method
g = cos(pi * x) * cos(pi * y)
a0 = BilinearForm((u, v), int_0(dot(grad(u), grad(v))))
a_B1 = BilinearForm((u, v), -int_1(kappa * u * dot(grad(v), nn) -
v * dot(grad(u), nn) + u * v / eps))
a = BilinearForm((u, v), a0(u, v) + a_B1(u, v))
l = LinearForm(v, int_0(g * v / eps) - int_1(kappa * v * g))
equation = Equation(a, l, tests=v, trials=u)
def test_bilinear_form_2d_1():
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)
nn = NormalVector('nn')
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.domain == domain.interior)
assert (a(u1, v1) == int_0(u1 * v1))
# ...
# ...
a = BilinearForm((u, v), int_0(u * v + dot(grad(u), grad(v))))
assert (a.domain == domain.interior)
assert (a(u1, v1) == int_0(u1 * v1) + int_0(dot(grad(u1), grad(v1))))
# ...
# ...
a = BilinearForm((u, v), int_1(v * dot(grad(u), nn)))
assert (a.domain == B1)
assert (a(u1, v1) == int_1(v1 * trace_1(grad(u1), B1)))
# ...
# ...
a = BilinearForm((u, v), int_0(u * v) + int_1(v * dot(grad(u), nn)))
# TODO a.domain are not ordered
assert (len(a.domain.args) == 2)
for i in a.domain.args:
assert (i in [domain.interior, B1])
assert (a(u1, v1) == int_0(u1 * v1) + int_1(v1 * trace_1(grad(u1), B1)))
# ...
# ...
a1 = BilinearForm((u1, v1), int_0(u1 * v1))
a = BilinearForm((u, v), a1(u, v))
assert (a.domain == domain.interior)
assert (a(u2, v2) == int_0(u2 * v2))
# ...
# ...
a1 = BilinearForm((u1, v1), int_0(u1 * v1))
a2 = BilinearForm((u2, v2), int_0(dot(grad(u2), grad(v2))))
a = BilinearForm((u, v), a1(u, v) + kappa * a2(u, v))
assert (a.domain == domain.interior)
assert (a(u, v) == int_0(u * v) + int_0(kappa * dot(grad(u), grad(v))))
def test_terminal_expr_bilinear_2d_1():
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)
eps = Constant('eps', real=True)
nn = NormalVector('nn')
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))
print(a)
print(TerminalExpr(a))
print('')
# ...
# ...
a = BilinearForm((u, v), int_0(dot(grad(u), grad(v))))
print(a)
print(TerminalExpr(a))
print('')
# ...
# ...
a = BilinearForm((u, v), int_0(u * v + dot(grad(u), grad(v))))
print(a)
print(TerminalExpr(a))
print('')
# ...
# ...
a = BilinearForm(
(u, v),
int_0(u * v + dot(grad(u), grad(v))) + int_1(v * dot(grad(u), nn)))
print(a)
print(TerminalExpr(a))
print('')
# ...
# ...
a = BilinearForm(((u1, u2), (v1, v2)), int_0(u1 * v1 + u2 * v2))
print(a)
print(TerminalExpr(a))
print('')
# ...
# ...
a1 = BilinearForm((u1, v1), int_0(u1 * v1))
a = BilinearForm((u, v), a1(u, v))
print(a)
print(TerminalExpr(a))
print('')
# ...
# ...
a1 = BilinearForm((u1, v1), int_0(u1 * v1))
a2 = BilinearForm((u2, v2), int_0(dot(grad(u2), grad(v2))))
a = BilinearForm((u, v), a1(u, v) + a2(u, v))
print(a)
print(TerminalExpr(a))
print('')
# ...
# ...
a1 = BilinearForm((u1, v1), int_0(u1 * v1))
a2 = BilinearForm((u2, v2), int_0(dot(grad(u2), grad(v2))))
a = BilinearForm((u, v), a1(u, v) + kappa * a2(u, v))
print(a)
print(TerminalExpr(a))
print('')
# ...
# ...
a1 = BilinearForm((u1, v1), int_0(u1 * v1))
a2 = BilinearForm((u2, v2), int_0(dot(grad(u2), grad(v2))))
a3 = BilinearForm((u, v), int_1(v * dot(grad(u), nn)))
a = BilinearForm((u, v), a1(u, v) + kappa * a2(u, v) + mu * a3(u, v))
print(a)
print(TerminalExpr(a))
print('')
# ...
# ... Poisson with Nitsch method
a0 = BilinearForm((u, v), int_0(dot(grad(u), grad(v))))
a_B1 = BilinearForm((u, v),
int_1(-kappa * u * dot(grad(v), nn) -
v * dot(grad(u), nn) + u * v / eps))
a = BilinearForm((u, v), a0(u, v) + a_B1(u, v))
print(a)
print(TerminalExpr(a))
print('')
def test_find_2d_1():
V = ScalarFunctionSpace('V', domain)
U = ScalarFunctionSpace('U', domain)
v = element_of(V, name='v')
u = element_of(U, name='u')
x,y = domain.coordinates
alpha = Constant('alpha')
kappa = Constant('kappa', real=True)
eps = Constant('eps', real=True)
B1 = Boundary(r'\Gamma_1', domain)
B2 = Boundary(r'\Gamma_2', domain)
B3 = Boundary(r'\Gamma_3', domain)
int_0 = lambda expr: integral(domain , expr)
int_1 = lambda expr: integral(B1, expr)
int_2 = lambda expr: integral(B2, expr)
# ... bilinear/linear forms
expr = dot(grad(v), grad(u))
a1 = BilinearForm((v,u), int_0(expr))
expr = v*u
a2 = BilinearForm((v,u), int_0(expr))
expr = v*u
a_B1 = BilinearForm((v, u), int_1(expr))
expr = x*y*v
l1 = LinearForm(v, int_0(expr))
expr = cos(x+y)*v
l2 = LinearForm(v, int_0(expr))
expr = x*y*v
l_B2 = LinearForm(v, int_1(expr))
# ...
# ...
equation = find(u, forall=v, lhs=a1(u,v), rhs=l1(v))
# ...
# ...
a = BilinearForm((v,u), a1(v,u) + alpha*a2(v,u))
equation = find(u, forall=v, lhs=a(u,v), rhs=l1(v))
# ...
# ...
a = BilinearForm((v,u), a1(v,u) + a_B1(v,u))
equation = find(u, forall=v, lhs=a(u,v), rhs=l1(v))
# ...
# ...
a = BilinearForm((v,u), a1(v,u) + a_B1(v,u))
l = LinearForm(v, l1(v) + l2(v))
equation = find(u, forall=v, lhs=a(u,v), rhs=l(v))
# ...
# ...
a = BilinearForm((v,u), a1(v,u) + a_B1(v,u))
l = LinearForm(v, l1(v) + alpha*l_B2(v))
equation = find(u, forall=v, lhs=a(u,v), rhs=l(v))
# ...
# ... using bc
equation = find(u, forall=v, lhs=a(u,v), rhs=l(v), bc=EssentialBC(u, 0, B1))
