def test_calculus_3d():
domain = Domain('Omega', dim=3)
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')
# ... 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))
# ...
# ... 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))
#assert( curl(cross(F,G)) == F*div(G) - G*div(F) - convect(F, G) + convect(G, F) )
#assert( curl(f*F) == f*curl(F) + cross(grad(f), F) )
# ...
# ... 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))
#assert( laplace(f*g) == f*laplace(g) + g*laplace(f) + 2*dot(grad(f), grad(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)) )
#assert( div(f*F) == f*div(F) + dot(F, grad(f)))
# ...
# ...
assert (curl(grad(h)) == 0)
assert (div(curl(H)) == 0)
def test_tensorize_2d_2():
domain = Domain('Omega', dim=2)
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, domain=domain)
print(expr)
def test_tensorize_3d():
V = FunctionSpace('V', domain)
U = FunctionSpace('U', domain)
W1 = VectorFunctionSpace('W1', domain)
T1 = VectorFunctionSpace('T1', domain)
v = TestFunction(V, name='v')
u = TestFunction(U, name='u')
w1 = VectorTestFunction(W1, name='w1')
t1 = VectorTestFunction(T1, name='t1')
x,y,z = domain.coordinates
alpha = Constant('alpha')
# ...
expr = dot(grad(v), grad(u))
a = BilinearForm((v,u), expr, name='a')
print(a)
print(tensorize(a))
print('')
# ...
# ...
expr = x*dx(v)*dx(u) + y*dy(v)*dy(u)
a = BilinearForm((v,u), expr, name='a')
print(a)
print(tensorize(a))
print('')
# ...
# ...
expr = sin(x)*dx(v)*dx(u)
a = BilinearForm((v,u), expr, name='a')
print(a)
print(tensorize(a))
print('')
# ...
# ...
expr = dot(curl(w1), curl(t1)) + div(w1)*div(t1)
a = BilinearForm((w1, t1), expr, name='a')
print(a)
print(tensorize(a))
print('')
def test_compiler_3d_1():
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
v0, v1, v2, v3 = element_of(X, name='v0, v1, v2, v3')
beta = element_of(V, 'beta')
# # ...
# expr = grad(v0)
# expected = d(DifferentialForm('v0', index=0, dim=domain.dim))
#
# assert(ExteriorCalculusExpr(expr) == expected)
# # ...
#
# # ...
# expr = curl(v1)
# expected = d(DifferentialForm('v1', index=1, dim=domain.dim))
#
# assert(ExteriorCalculusExpr(expr) == expected)
# # ...
#
# # ...
# expr = div(v2)
# expected = d(DifferentialForm('v2', index=2, dim=domain.dim))
#
# assert(ExteriorCalculusExpr(expr) == expected)
# # ...
#
# # ...
# expr = grad(v0)
# expected = - delta(DifferentialForm('v0', index=3, dim=domain.dim))
#
# assert(ExteriorCalculusExpr(expr, tests=[v0]) == expected)
# # ...
#
# # ...
# expr = curl(v1)
# expected = delta(DifferentialForm('v1', index=2, dim=domain.dim))
#
# assert(ExteriorCalculusExpr(expr, tests=[v1]) == expected)
# # ...
#
# # ...
# expr = div(v2)
# expected = -delta(DifferentialForm('v2', index=1, dim=domain.dim))
#
# assert(ExteriorCalculusExpr(expr, tests=[v2]) == expected)
# # ...
#
# # ...
# expr = dot(beta, v1)
# expected = ip(beta, DifferentialForm('v1', index=1, dim=domain.dim))
#
# assert(ExteriorCalculusExpr(expr) == expected)
# # ...
#
# # ...
# expr = cross(beta, v2)
# expected = ip(beta, DifferentialForm('v2', index=2, dim=domain.dim))
#
# assert(ExteriorCalculusExpr(expr) == expected)
# # ...
#
# # ...
# expr = beta*v3
# expected = ip(beta, DifferentialForm('v3', index=3, dim=domain.dim))
#
# assert(ExteriorCalculusExpr(expr) == expected)
# # ...
#
# # ...
# expr = dot(beta, v1)
# expected = jp(beta, DifferentialForm('v1', index=3, dim=domain.dim))
#
# assert(ExteriorCalculusExpr(expr, tests=[v1]) == expected)
# # ...
#
# # ...
# expr = cross(beta, v2)
# expected = -jp(beta, DifferentialForm('v2', index=2, dim=domain.dim))
#
# assert(ExteriorCalculusExpr(expr, tests=[v2]) == expected)
# # ...
#
# # ...
# expr = beta*v3
# expected = jp(beta, DifferentialForm('v3', index=1, dim=domain.dim))
#
# assert(ExteriorCalculusExpr(expr, tests=[v3]) == expected)
# # ...
# ..................................................
# LIE DERIVATIVES
# ..................................................
# ...
expr = dot(beta, grad(v0))
expected = ld(beta, DifferentialForm('v0', index=0, dim=domain.dim))
assert (ExteriorCalculusExpr(expr) == expected)
# ...
# ...
expr = grad(dot(beta, v1)) + cross(curl(v1), beta)
expected = ld(beta, DifferentialForm('v1', index=1, dim=domain.dim))
assert (ExteriorCalculusExpr(expr) == expected)
# ...
# ...
expr = curl(cross(v2, beta)) + div(v2) * beta
expected = ld(beta, DifferentialForm('v2', index=2, dim=domain.dim))
#assert(ExteriorCalculusExpr(expr) == expected)
# ...
# ...
expr = div(beta * v3)
expected = ld(beta, DifferentialForm('v3', index=3, dim=domain.dim))
assert (ExteriorCalculusExpr(expr) == expected)
def test_calculus_3d_3():
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 = ScalarFunctionSpace('V', domain, kind=None)
W = VectorFunctionSpace('W', domain, kind=None)
X = ProductSpace(H1, Hcurl, Hdiv, L2)
v0, v1, v2, v3 = element_of(X, ['v0', 'v1', 'v2', 'v3'])
v = element_of(V, 'v')
w = element_of(W, 'w')
# ... consistency of grad operator
# we can apply grad on an undefined space type or H1
expr = grad(v0)
expr = grad(v)
expr = grad(w)
# wa cannot apply grad to a function in Hcurl
with pytest.raises(ArgumentTypeError):
expr = grad(v1)
# wa cannot apply grad to a function in Hdiv
with pytest.raises(ArgumentTypeError):
expr = grad(v2)
# wa cannot apply grad to a function in L2
with pytest.raises(ArgumentTypeError):
expr = grad(v3)
# ...
# ... consistency of curl operator
# we can apply curl on an undefined space type, H1 or Hcurl
expr = curl(v0)
expr = curl(v1)
expr = curl(v)
expr = curl(w)
# wa cannot apply curl to a function in Hdiv
with pytest.raises(ArgumentTypeError):
expr = curl(v2)
# wa cannot apply curl to a function in L2
with pytest.raises(ArgumentTypeError):
expr = curl(v3)
# ...
# ... consistency of div operator
# we can apply div on an undefined space type, H1 or Hdiv
expr = div(v0)
expr = div(v2)
expr = div(v)
expr = div(w)
# wa cannot apply div to a function in Hcurl
with pytest.raises(ArgumentTypeError):
expr = div(v1)
# wa cannot apply div to a function in L2
with pytest.raises(ArgumentTypeError):
expr = div(v3)
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))
# ...
# ... Poisson's bracket properties
assert bracket(alpha * f, g) == alpha * bracket(f, g)
assert bracket(f, alpha * g) == alpha * bracket(f, g)
assert bracket(f + h, g) == bracket(f, g) + bracket(h, g)
assert bracket(f, g + h) == bracket(f, g) + bracket(f, h)
assert bracket(f, f) == 0
assert bracket(f, g) == -bracket(g, f)
assert bracket(f, g * h) == g * bracket(f, h) + bracket(f, g) * h