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_bilinear_expr_2d_2():
domain = Domain('Omega', dim=2)
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']]
# ...
a = BilinearExpr((u,v), dot(u,v))
print(a)
print(a.expr)
print(a(u1,v1))
# TODO
# print(a(u1+u2,v1+v2))
print('')
# ...
# ...
a1 = BilinearExpr((u,v), dot(u,v))
a2 = BilinearExpr((u,v), inner(grad(u),grad(v)))
print(a1(u1,v1) + a2(u2,v2))
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 = FunctionSpace('V', domain)
u, v = [TestFunction(V, name=i) for i in ['u', 'v']]
# ...
expr = dot(grad(u), grad(v)) + f(x, y) * u * v
a = BilinearForm((v, u), expr)
print(a)
print(evaluate(a, verbose=True))
print('')
# ...
# ...
expr = f(x, y) * v
l = LinearForm(v, expr)
print(l)
print(evaluate(l, verbose=True))
print('')
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_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_partial_derivatives_1():
print('============ test_partial_derivatives_1 ==============')
# ...
domain = Domain('Omega', dim=2)
x,y = domain.coordinates
V = ScalarFunctionSpace('V', domain)
F,u,v,w = [ScalarField(V, name=i) for i in ['F', 'u', 'v', 'w']]
uvw = Tuple(u,v,w)
alpha = Constant('alpha')
beta = Constant('beta')
# ...
# ...
assert(dx(x**2) == 2*x)
assert(dy(x**2) == 0)
assert(dz(x**2) == 0)
assert(dx(x*F) == F + x*dx(F))
assert(dx(uvw) == Matrix([[dx(u), dx(v), dx(w)]]))
assert(dx(uvw) + dy(uvw) == Matrix([[dx(u) + dy(u),
dx(v) + dy(v),
dx(w) + dy(w)]]))
expected = Matrix([[alpha*dx(u) + beta*dy(u),
alpha*dx(v) + beta*dy(v),
alpha*dx(w) + beta*dy(w)]])
assert(alpha * dx(uvw) + beta * dy(uvw) == expected)
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_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_calls_2d_3():
domain = Square()
V = FunctionSpace('V', domain)
x, y = domain.coordinates
pn = Field('pn', V)
wn = Field('wn', V)
dp = TestFunction(V, name='dp')
dw = TestFunction(V, name='dw')
tau = TestFunction(V, name='tau')
sigma = TestFunction(V, name='sigma')
Re = Constant('Re', real=True)
dt = Constant('dt', real=True)
alpha = Constant('alpha', real=True)
l1 = LinearForm(tau,
bracket(pn, wn) * tau - 1. / Re * dot(grad(tau), grad(wn)))
# ...
l = LinearForm((tau, sigma), dt * l1(tau))
print(evaluate(l, verbose=True))
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_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_linear_expr_2d_2():
domain = Domain('Omega', dim=2)
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']]
g = Tuple(x, y)
l = LinearExpr(v, dot(g, v))
print(l)
print(l.expr)
print(l(v1))
# TODO
# print(l(v1+v2))
print('')
# ...
# ...
g1 = Tuple(x, 0)
g2 = Tuple(0, y)
l = LinearExpr((v1, v2), dot(g1, v1) + dot(g2, v2))
print(l)
print(l.expr)
print(l(u1, u2))
# TODO
# print(l(u1+v1, u2+v2))
print('')
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_zero_derivative():
assert grad(1) == 0 # native int
assert grad(2.3) == 0 # native float
assert grad(4 + 5j) == 0 # native complex
assert grad(Integer(1)) == 0 # sympy Integer
assert grad(Float(2.3)) == 0 # sympy Float
assert grad(Rational(6, 7)) == 0 # sympy Rational
assert grad(Constant('a')) == 0 # sympde Constant
assert laplace(1) == 0 # native int
assert laplace(2.3) == 0 # native float
assert laplace(4 + 5j) == 0 # native complex
assert laplace(Integer(1)) == 0 # sympy Integer
assert laplace(Float(2.3)) == 0 # sympy Float
assert laplace(Rational(6, 7)) == 0 # sympy Rational
assert laplace(Constant('a')) == 0 # sympde Constant
assert hessian(1) == 0 # native int
assert hessian(2.3) == 0 # native float
assert hessian(4 + 5j) == 0 # native complex
assert hessian(Integer(1)) == 0 # sympy Integer
assert hessian(Float(2.3)) == 0 # sympy Float
assert hessian(Rational(6, 7)) == 0 # sympy Rational
assert hessian(Constant('a')) == 0 # sympde Constant
# 2D convection of constant scalar field
domain = Domain('Omega', dim=2)
W = VectorFunctionSpace('W', domain)
F = element_of(W, name='F')
assert convect(F, 1) == 0 # native int
assert convect(F, 2.3) == 0 # native float
assert convect(F, 4 + 5j) == 0 # native complex
assert convect(F, Integer(1)) == 0 # sympy Integer
assert convect(F, Float(2.3)) == 0 # sympy Float
assert convect(F, Rational(6, 7)) == 0 # sympy Rational
assert convect(F, Constant('a')) == 0 # sympde Constant
# 3D convection of constant scalar field
domain = Domain('Omega', dim=3)
Z = VectorFunctionSpace('Z', domain)
G = element_of(Z, name='G')
assert convect(G, 1) == 0 # native int
assert convect(G, 2.3) == 0 # native float
assert convect(G, 4 + 5j) == 0 # native complex
assert convect(G, Integer(1)) == 0 # sympy Integer
assert convect(G, Float(2.3)) == 0 # sympy Float
assert convect(G, Rational(6, 7)) == 0 # sympy Rational
assert convect(G, Constant('a')) == 0 # sympde Constant
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_system_2d():
domain = Square()
V = FunctionSpace('V', domain)
x, y = V.coordinates
u, v, p, q = [TestFunction(V, name=i) for i in ['u', 'v', 'p', 'q']]
a1, a2, b1, b2 = [Constant(i, real=True) for i in ['a1', 'a2', 'b1', 'b2']]
# ...
a = BilinearForm((v, u), dot(grad(u), grad(v)))
m = BilinearForm((v, u), u * v)
expr = a(p, u) + a1 * m(p, u) + b1 * m(p, v) + a(
q, v) + a2 * m(q, u) + b2 * m(q, v)
b = BilinearForm(((p, q), (u, v)), expr)
print(evaluate(b, verbose=True))
# ...
# ...
f1 = x * y
f2 = x + y
l1 = LinearForm(p, f1 * p)
l2 = LinearForm(q, f2 * q)
expr = l1(p) + l2(q)
l = LinearForm((p, q), expr)
print(evaluate(l, verbose=True))
def test_target_mapping_2d_1():
rdim = 2
x1, x2 = symbols('x1, x2')
constants = ['c1', 'c2', 'D', 'k']
c1, c2, D, k = [Constant(i) for i in constants]
M = TargetMapping('M', rdim)
assert (not (M[0] == x1))
assert (not (M[1] == x2))
assert (LogicalExpr(M[0], mapping=M, dim=rdim, subs=True) == -D * x1**2 +
c1 + x1 * (-k + 1) * cos(x2))
assert (LogicalExpr(M[1], mapping=M, dim=rdim,
subs=True) == c2 + x1 * (k + 1) * sin(x2))
assert (LogicalExpr(dx1(M[0]), mapping=M, dim=rdim,
subs=True) == -2 * D * x1 + (-k + 1) * cos(x2))
assert (LogicalExpr(dx1(M[1]), mapping=M, dim=rdim,
subs=True) == (k + 1) * sin(x2))
assert (LogicalExpr(dx2(M[0]), mapping=M, dim=rdim,
subs=True) == -x1 * (-k + 1) * sin(x2))
assert (LogicalExpr(dx2(M[1]), mapping=M, dim=rdim,
subs=True) == x1 * (k + 1) * cos(x2))
expected = Matrix(
[[-2 * D * x1 + (-k + 1) * cos(x2), -x1 * (-k + 1) * sin(x2)],
[(k + 1) * sin(x2), x1 * (k + 1) * cos(x2)]])
assert (not (Jacobian(M) == expected))
assert (expand(LogicalExpr(Jacobian(M), mapping=M, dim=rdim,
subs=True)) == expand(expected))
def test_polar_mapping_2d_1():
rdim = 2
x1, x2 = symbols('x1, x2')
constants = ['c1', 'c2', 'rmax', 'rmin']
c1, c2, rmax, rmin = [Constant(i) for i in constants]
M = PolarMapping('M', rdim)
assert (not (M[0] == x1))
assert (not (M[1] == x2))
assert (LogicalExpr(M[0], mapping=M, dim=rdim, subs=True) == c1 +
(rmax * x1 + rmin * (-x1 + 1)) * cos(x2))
assert (LogicalExpr(M[1], mapping=M, dim=rdim, subs=True) == c2 +
(rmax * x1 + rmin * (-x1 + 1)) * sin(x2))
assert (LogicalExpr(dx1(M[0]), mapping=M, dim=rdim,
subs=True) == (rmax - rmin) * cos(x2))
assert (LogicalExpr(dx1(M[1]), mapping=M, dim=rdim,
subs=True) == (rmax - rmin) * sin(x2))
expected = -(rmax * x1 + rmin * (-x1 + 1)) * sin(x2)
assert (expand(LogicalExpr(dx2(M[0]), mapping=M, dim=rdim,
subs=True)) == expand(expected))
assert (LogicalExpr(dx2(M[1]), mapping=M, dim=rdim,
subs=True) == (rmax * x1 + rmin * (-x1 + 1)) * cos(x2))
expected = Matrix([[(rmax - rmin) * cos(x2),
-(rmax * x1 + rmin * (-x1 + 1)) * sin(x2)],
[(rmax - rmin) * sin(x2),
(rmax * x1 + rmin * (-x1 + 1)) * cos(x2)]])
assert (expand(LogicalExpr(Jacobian(M), mapping=M, dim=rdim,
subs=True)) == expand(expected))
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_Inner(dim):
domain = Domain('Omega', dim=dim)
W = VectorFunctionSpace('W', domain)
a, b, c = elements_of(W, names='a, b, c')
r = Constant('r')
# Commutativity
assert inner(a, b) == inner(b, a)
# Bilinearity: vector addition
assert inner(a, b + c) == inner(a, b) + inner(a, c)
assert inner(a + b, c) == inner(a, c) + inner(b, c)
# Bilinearity: scalar multiplication
assert inner(a, r * b) == r * inner(a, b)
assert inner(r * a, b) == r * inner(a, b)
# Special case: null vector
assert inner(a, 0) == 0
assert inner(0, a) == 0
# Special case: two arguments are the same
assert inner(a, a).is_real
assert inner(a, a).is_positive
def test_target_mapping_2d_1():
dim = 2
x1, x2 = symbols('x1, x2')
constants = ['c1', 'c2', 'D', 'k']
c1, c2, D, k = [Constant(i) for i in constants]
M = TargetMapping('M', dim=dim)
domain = M(Domain('Omega', dim=dim))
assert (not (M[0] == x1))
assert (not (M[1] == x2))
assert (LogicalExpr(M[0],
domain) == -D * x1**2 + c1 + x1 * (-k + 1) * cos(x2))
assert (LogicalExpr(M[1], domain) == c2 + x1 * (k + 1) * sin(x2))
assert (LogicalExpr(dx1(M[0]), domain) == -2 * D * x1 + (-k + 1) * cos(x2))
assert (LogicalExpr(dx1(M[1]), domain) == (k + 1) * sin(x2))
assert (LogicalExpr(dx2(M[0]), domain) == -x1 * (-k + 1) * sin(x2))
assert (LogicalExpr(dx2(M[1]), domain) == x1 * (k + 1) * cos(x2))
expected = Matrix(
[[-2 * D * x1 + (-k + 1) * cos(x2), -x1 * (-k + 1) * sin(x2)],
[(k + 1) * sin(x2), x1 * (k + 1) * cos(x2)]])
assert (Jacobian(M) == expected)
def test_tensorize_2d_3():
domain = Domain('Omega', dim=2)
V = ScalarFunctionSpace('V', domain)
u, v = elements_of(V, names='u,v')
bx = Constant('bx')
by = Constant('by')
b = Tuple(bx, by)
expr = integral(domain, dot(b, grad(v)) * dot(b, grad(u)))
a = BilinearForm((u, v), expr)
print(TensorExpr(a))
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_target_mapping_2d_1():
rdim = 2
x1, x2 = symbols('x1, x2')
constants = ['c1', 'c2', 'D', 'k']
c1, c2, D, k = [Constant(i) for i in constants]
M = TargetMapping('M', rdim)
assert (not (M[0] == x1))
assert (not (M[1] == x2))
assert (LogicalExpr(M, M[0]) == -D * x1**2 + c1 + x1 * (-k + 1) * cos(x2))
assert (LogicalExpr(M, M[1]) == c2 + x1 * (k + 1) * sin(x2))
assert (LogicalExpr(M, dx1(M[0])) == -2 * D * x1 - k * x1 * cos(x2) +
(-k + 1) * cos(x2))
assert (LogicalExpr(M, dx1(M[1])) == (k + 1) * sin(x2))
assert (LogicalExpr(M,
dx2(M[0])) == x1 * (-k * cos(x2) - (-k + 1) * sin(x2)))
assert (LogicalExpr(M, dx2(M[1])) == x1 * (k + 1) * cos(x2))
expected = Matrix([[
-2 * D * x1 - k * x1 * cos(x2) + (-k + 1) * cos(x2),
x1 * (-k * cos(x2) - (-k + 1) * sin(x2))
], [(k + 1) * sin(x2), x1 * (k + 1) * cos(x2)]])
assert (not (M.jacobian == expected))
assert (expand(LogicalExpr(M, M.jacobian)) == expand(expected))
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_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_bilinearity_2d_1():
domain = Square()
x, y = domain.coordinates
alpha = Constant('alpha')
beta = Constant('beta')
f1 = x * y
f2 = x + y
f = Tuple(f1, f2)
V = FunctionSpace('V', domain)
# TODO improve: naming are not given the same way
G = Field('G', V)
p, q = [TestFunction(V, name=i) for i in ['p', 'q']]
#####################################
# linear expressions
#####################################
# ...
expr = p * q
assert (is_bilinear_form(expr, (p, q)))
# ...
# ...
expr = dot(grad(p), grad(q))
assert (is_bilinear_form(expr, (p, q)))
# ...
# ...
expr = alpha * dot(grad(p),
grad(q)) + beta * p * q + laplace(p) * laplace(q)
assert (is_bilinear_form(expr, (p, q)))
# ...
#####################################
#####################################
# nonlinear expressions
#####################################
# ...
with pytest.raises(UnconsistentLinearExpressionError):
expr = alpha * dot(grad(p**2), grad(q)) + beta * p * q
is_bilinear_form(expr, (p, q))
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_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_projection_2d():
domain = Domain('Omega', dim=DIM)
V = FunctionSpace('V', domain)
x, y = domain.coordinates
alpha = Constant('alpha')
u = Projection(x**2 + alpha * y, V, name='u')