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_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_calculus_2d_2():
domain = Domain('Omega', dim=2)
W = VectorFunctionSpace('W', domain)
alpha, beta, gamma = [Constant(i) for i in ['alpha', 'beta', 'gamma']]
F, G, H = elements_of(W, names='F, G, H')
# ... vector gradient properties
assert (convect(F + G, H) == convect(F, H) + convect(G, H))
assert (convect(alpha * F, H) == alpha * convect(F, H))
assert (convect(F, alpha * H) == alpha * convect(F, H))
def test_linearize_form_2d_3():
"""steady Euler equation."""
domain = Domain('Omega', dim=2)
x, y = domain.coordinates
U = VectorFunctionSpace('U', domain)
W = FunctionSpace('W', domain)
v = VectorTestFunction(U, name='v')
phi = TestFunction(W, name='phi')
q = TestFunction(W, name='q')
U_0 = VectorField(U, name='U_0')
Rho_0 = Field(W, name='Rho_0')
P_0 = Field(W, name='P_0')
# ...
expr = div(Rho_0 * U_0) * phi
l1 = LinearForm(phi, expr)
expr = Rho_0 * dot(convect(U_0, grad(U_0)), v) + dot(grad(P_0), v)
l2 = LinearForm(v, expr)
expr = dot(U_0, grad(P_0)) * q + P_0 * div(U_0) * q
l3 = LinearForm(q, expr)
# ...
a1 = linearize(l1, [Rho_0, U_0], trials=['d_rho', 'd_u'])
print(a1)
print('')
a2 = linearize(l2, [Rho_0, U_0, P_0], trials=['d_rho', 'd_u', 'd_p'])
print(a2)
print('')
a3 = linearize(l3, [P_0, U_0], trials=['d_p', 'd_u'])
print(a3)
print('')
l = LinearForm((phi, v, q), l1(phi) + l2(v) + l3(q))
a = linearize(l, [Rho_0, U_0, P_0], trials=['d_rho', 'd_u', 'd_p'])
print(a)
export(a, 'steady_euler.png')
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
# Poisson's bracket in 2D
domain = Domain('Omega', dim=2)
V = ScalarFunctionSpace('V', domain)
u = element_of(V, name='V')
assert bracket(u, 1) == 0 # native int
assert bracket(u, 2.3) == 0 # native float
assert bracket(u, 4 + 5j) == 0 # native complex
assert bracket(u, Integer(1)) == 0 # sympy Integer
assert bracket(u, Float(2.3)) == 0 # sympy Float
assert bracket(u, Rational(6, 7)) == 0 # sympy Rational
assert bracket(u, Constant('a')) == 0 # sympde Constant
assert bracket(1, u) == 0 # native int
assert bracket(2.3, u) == 0 # native float
assert bracket(4 + 5j, u) == 0 # native complex
assert bracket(Integer(1), u) == 0 # sympy Integer
assert bracket(Float(2.3), u) == 0 # sympy Float
assert bracket(Rational(6, 7), u) == 0 # sympy Rational
assert bracket(Constant('a'), u) == 0 # sympde Constant
