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_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_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_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_latex_2d_2():
DIM = 2
domain = Domain('Omega', dim=DIM)
V = VectorFunctionSpace('V', domain)
x, y = V.coordinates
v = element_of(V, name='v')
u = element_of(V, name='u')
# F = element_of(V, name='F')
int_0 = lambda expr: integral(domain, expr)
assert (latex(v) == r'\mathbf{v}')
assert (latex(inner(
grad(v), grad(u))) == r'\nabla{\mathbf{u}} : \nabla{\mathbf{v}}')
a = BilinearForm((v, u), int_0(inner(grad(v), grad(u))))
print(latex(a))
# assert(latex(a) == r'\int_{0}^{1}\int_{0}^{1} \nabla{\mathbf{v}} : \nabla{\mathbf{u}} dxdy')
b = LinearForm(v, int_0(sin(pi * x) * cos(pi * y) * div(v)))
print(latex(b))
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_latex_2d_5():
DIM = 2
domain = Domain('Omega', dim=DIM)
# ... abstract model
W1 = VectorFunctionSpace('W1', domain)
w1 = element_of(W1, name='w1')
F = element_of(W1, 'F')
int_0 = lambda expr: integral(domain, expr)
# ...
l1 = LinearForm(w1, int_0(dot(w1, F)))
print(latex(l1))
print('')
# ...
# ...
l2 = LinearForm(w1, int_0(rot(w1) * rot(F) + div(w1) * div(F)))
print(latex(l2))
print('')
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_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_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_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_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_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_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_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_space_2d_1():
DIM = 2
domain = Domain('Omega', dim=DIM)
V1 = ScalarFunctionSpace('V1', domain)
V2 = ScalarFunctionSpace('V2', domain)
V3 = ScalarFunctionSpace('V3', domain)
U1 = ScalarFunctionSpace('U1', domain)
U2 = ScalarFunctionSpace('U2', domain)
U3 = VectorFunctionSpace('U3', domain)
# ...
V = V1 * V2 * V3
assert (V.ldim == DIM)
assert (V.shape == 3)
assert (V.name == 'V1V2V3')
# ...
# ...
U = U1 * U2 * U3
assert (U.ldim == DIM)
assert (U.shape == 4)
assert (U.name == 'U1U2U3')
# ...
# ...
v1, v2, v3 = element_of(V, 'v1, v2, v3')
assert (isinstance(v1, ScalarTestFunction))
assert (isinstance(v2, ScalarTestFunction))
assert (isinstance(v3, ScalarTestFunction))
assert (v1.space is V1)
assert (v2.space is V2)
assert (v3.space is V3)
assert (v1.name == 'v1')
assert (v2.name == 'v2')
assert (v3.name == 'v3')
# ...
# ...
u1, u2, u3 = element_of(U, 'u1, u2, u3')
assert (isinstance(u1, ScalarTestFunction))
assert (isinstance(u2, ScalarTestFunction))
assert (isinstance(u3, VectorTestFunction))
assert (u1.name == 'u1')
assert (u2.name == 'u2')
assert (u3.name == 'u3')
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_equation_2d_5():
domain = Square()
x, y = domain.coordinates
f0 = Matrix([
2 * pi**2 * sin(pi * x) * sin(pi * y),
2 * pi**2 * sin(pi * x) * sin(pi * y)
])
f1 = cos(pi * x) * cos(pi * y)
W = VectorFunctionSpace('W', domain)
V = ScalarFunctionSpace('V', domain)
X = ProductSpace(W, V)
F = element_of(W, name='F')
G = element_of(V, name='G')
u, v = [element_of(W, name=i) for i in ['u', 'v']]
p, q = [element_of(V, name=i) for i in ['p', 'q']]
int_0 = lambda expr: integral(domain, expr)
a0 = BilinearForm((v, u), int_0(inner(grad(v), grad(u))))
print(' a0 done.')
a1 = BilinearForm((q, p), int_0(p * q))
print(' a1 done.')
a = BilinearForm(((v, q), (u, p)), a0(v, u) + a1(q, p))
print(' a done.')
l0 = LinearForm(v, int_0(dot(f0, v)))
l1 = LinearForm(q, int_0(f1 * q))
l = LinearForm((v, q), l0(v) + l1(q))
print('****************************')
bc = EssentialBC(u, 0, domain.boundary)
equation = Equation(a, l, tests=[v, q], trials=[u, p], bc=bc)
# ...
print('=======')
print(equation.lhs.expr)
print('')
# ...
# ...
print('=======')
print(equation.rhs.expr)
print('')
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_logical_expr_2d_3():
dim = 2
A = Square('A')
B = Square('B')
M1 = Mapping('M1', dim=dim)
M2 = Mapping('M2', dim=dim)
D1 = M1(A)
D2 = M2(B)
domain = D1.join(D2,
name='domain',
bnd_minus=D1.get_boundary(axis=0, ext=1),
bnd_plus=D2.get_boundary(axis=0, ext=-1))
V = VectorFunctionSpace('V', domain, kind='hcurl')
u, v = [element_of(V, name=i) for i in ['u', 'v']]
int_0 = lambda expr: integral(domain, expr)
expr = LogicalExpr(int_0(dot(u, v)), domain)
assert str(
expr.args[0]
) == 'Integral(A, Dot((Jacobian(M1)**(-1)).T * u, (Jacobian(M1)**(-1)).T * v)*sqrt(det(Jacobian(M1).T * Jacobian(M1))))'
assert str(
expr.args[1]
) == 'Integral(B, Dot((Jacobian(M2)**(-1)).T * u, (Jacobian(M2)**(-1)).T * v)*sqrt(det(Jacobian(M2).T * Jacobian(M2))))'
def test_projector_2d_1():
DIM = 2
domain = Domain('Omega', dim=DIM)
V = ScalarFunctionSpace('V', domain, kind=None)
W = VectorFunctionSpace('W', domain, kind=None)
v, w = element_of(V * W, ['v', 'w'])
# ...
P_V = Projector(V)
assert (P_V.space == V)
Pv = P_V(v)
assert (isinstance(Pv, ScalarTestFunction))
assert (Pv == v)
assert (grad(Pv**2) == 2 * v * grad(v))
Pdiv_w = P_V(div(w))
assert (isinstance(Pdiv_w, ScalarTestFunction))
# ...
# ...
P_W = Projector(W)
assert (P_W.space == W)
Pw = P_W(w)
assert (isinstance(Pw, VectorTestFunction))
assert (Pw == w)
Pgrad_v = P_W(grad(v))
assert (isinstance(Pgrad_v, VectorTestFunction))
assert (P_W(Pgrad_v) == Pgrad_v)
def test_derivatives_2d_with_mapping():
dim = 2
M = Mapping('M', dim=dim)
O = M(Domain('Omega', dim=dim))
V = ScalarFunctionSpace('V', O, kind='h1')
u = element_of(V, 'u')
det_jac = Jacobian(M).det()
J = Symbol('J')
expr = M
assert SymbolicExpr(expr) == Symbol('M')
expr = M[0]
assert SymbolicExpr(expr) == Symbol('x')
expr = M[1]
assert SymbolicExpr(expr) == Symbol('y')
expr = dx2(M[0])
assert SymbolicExpr(expr) == Symbol('x_x2')
expr = dx1(M[1])
assert SymbolicExpr(expr) == Symbol('y_x1')
expr = LogicalExpr(dx(u), O).subs(det_jac, J)
expected = '(u_x1 * y_x2 - u_x2 * y_x1)/J'
difference = SymbolicExpr(expr) - sympify(expected)
assert difference.simplify() == 0
def test_derivatives_2d_without_mapping():
O = Domain('Omega', dim=2)
V = ScalarFunctionSpace('V', O)
u = element_of(V, 'u')
expr = u
assert SymbolicExpr(expr) == Symbol('u')
expr = dx(u)
assert SymbolicExpr(expr) == Symbol('u_x')
expr = dx(dx(u))
assert SymbolicExpr(expr) == Symbol('u_xx')
expr = dx(dy(u))
assert SymbolicExpr(expr) == Symbol('u_xy')
expr = dy(dx(u))
assert SymbolicExpr(expr) == Symbol('u_xy')
expr = dy(dx(dz(u)))
assert SymbolicExpr(expr) == Symbol('u_xyz')
expr = dy(dy(dx(u)))
assert SymbolicExpr(expr) == Symbol('u_xyy')
expr = dy(dz(dy(u)))
assert SymbolicExpr(expr) == Symbol('u_yyz')
def test_latex_ec_3d_1():
n = 3
# ...
u_0 = DifferentialForm('u_0', index=0, dim=n)
v_0 = DifferentialForm('v_0', index=0, dim=n)
u_1 = DifferentialForm('u_1', index=1, dim=n)
v_1 = DifferentialForm('v_1', index=1, dim=n)
u_2 = DifferentialForm('u_2', index=2, dim=n)
v_2 = DifferentialForm('v_2', index=2, dim=n)
u_3 = DifferentialForm('u_3', index=3, dim=n)
v_3 = DifferentialForm('v_3', index=3, dim=n)
# ...
# ...
domain = Domain('Omega', dim=3)
V = VectorFunctionSpace('V', domain)
beta = element_of(V, 'beta')
# ...
print(latex(u_0))
print(latex(d(u_0)))
print(latex(d(delta(u_3))))
print(latex(d(delta(u_2)) + delta(d(u_2))))
print(latex(wedge(u_0, u_1)))
print(latex(ip(beta, u_1)))
print(latex(hodge(u_1)))
print(latex(jp(beta, u_1)))
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_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_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]))
