def test_global_quad_basis_span_2d_2():
# ...
nderiv = 2
stmts = construct_logical_expressions(u, nderiv)
expressions = [dx(u), dx(dy(u)), dy(dy(u))]
stmts += [ComputePhysicalBasis(i) for i in expressions]
# ...
# ...
stmts += [Reduction('+', ComputePhysicalBasis(dx(u)*dx(v)))]
# ...
# ...
loop = Loop((l_quad, a_basis), index_quad, stmts)
# ...
# ...
stmts = [loop]
loop = Loop(l_basis, index_dof, stmts)
# ...
# ...
stmts = [loop]
loop = Loop((g_quad, g_basis, g_span), index_element, stmts)
# ...
stmt = parse(loop, settings={'dim': domain.dim, 'nderiv': nderiv})
print(pycode(stmt))
print()
def test_terminal_expr_bilinear_3d_1():
domain = Domain('Omega', dim=3)
M = Mapping('M', 3)
mapped_domain = M(domain)
V = ScalarFunctionSpace('V', domain)
VM = ScalarFunctionSpace('VM', mapped_domain)
u, v = elements_of(V, names='u,v')
um, vm = elements_of(VM, names='u,v')
int_0 = lambda expr: integral(domain, expr)
int_1 = lambda expr: integral(mapped_domain, expr)
J = M.det_jacobian
det = dx1(M[0])*dx2(M[1])*dx3(M[2]) - dx1(M[0])*dx2(M[2])*dx3(M[1]) - dx1(M[1])*dx2(M[0])*dx3(M[2])\
+ dx1(M[1])*dx2(M[2])*dx3(M[0]) + dx1(M[2])*dx2(M[0])*dx3(M[1]) - dx1(M[2])*dx2(M[1])*dx3(M[0])
a1 = BilinearForm((u, v), int_0(dot(grad(u), grad(v))))
a2 = BilinearForm((um, vm), int_1(dot(grad(um), grad(vm))))
a3 = BilinearForm((u, v), int_0(J * dot(grad(u), grad(v))))
e1 = TerminalExpr(a1)
e2 = TerminalExpr(a2)
e3 = TerminalExpr(a3)
assert e1[0].expr == dx1(u) * dx1(v) + dx2(u) * dx2(v) + dx3(u) * dx3(v)
assert e2[0].expr == dx(um) * dx(vm) + dy(um) * dy(vm) + dz(um) * dz(vm)
assert e3[0].expr.factor() == (dx1(u) * dx1(v) + dx2(u) * dx2(v) +
dx3(u) * dx3(v)) * det
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_tensorize_2d():
domain = Domain('Omega', dim=DIM)
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 = 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 = rot(w1)*rot(t1) + div(w1)*div(t1)
expr = rot(w1) * rot(t1) #+ div(w1)*div(t1)
a = BilinearForm((w1, t1), expr, name='a')
print(a)
print(tensorize(a))
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_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_global_quad_basis_span_2d_matrix_2():
# ...
nderiv = 1
stmts = construct_logical_expressions(u, nderiv)
expressions = [dx(v), dy(v), dx(u), dy(u)]
stmts += [ComputePhysicalBasis(i) for i in expressions]
# ...
# ...
loop = Loop((l_quad, a_basis, GeometryExpressions(M, nderiv)), index_quad, stmts)
# ...
# ...
loop = Reduce('+', ComputeKernelExpr(dx(u)*dx(v)), ElementOf(l_mat), loop)
# ...
# ... loop over trials
stmts = [loop]
loop = Loop(l_basis, index_dof_trial, stmts)
# ...
# ... loop over tests
stmts = [loop]
loop = Loop(l_basis_v, index_dof_test, stmts)
# ...
# ...
body = (Reset(l_mat), loop)
stmts = Block(body)
# ...
# ...
loop = Loop((g_quad, g_basis, g_basis_v, g_span), index_element, stmts)
# ...
# ...
body = (Reset(g_mat), Reduce('+', l_mat, g_mat, loop))
stmt = Block(body)
# ...
stmt = parse(stmt, settings={'dim': domain.dim, 'nderiv': nderiv, 'mapping': M})
print(pycode(stmt))
print()
def test_loop_local_dof_quad_2d_2():
# ...
args = [dx(u), dx(dy(u)), dy(dy(u)), dx(u) + dy(u)]
stmts = [ComputePhysicalBasis(i) for i in args]
# ...
# ...
loop = Loop((l_quad, a_basis), index_quad, stmts)
# ...
# ...
stmts = [loop]
loop = Loop(l_basis, index_dof, stmts)
# ...
stmt = parse(loop, settings={'dim': domain.dim, 'nderiv': 3})
print()
print(pycode(stmt))
print()
def test_identity_mapping_2d_2():
dim = 2
M = IdentityMapping('F', dim=dim)
domain = M(Domain('Omega', dim=dim))
V = ScalarFunctionSpace('V', domain, kind='h1')
u = element_of(V, name='u')
# ...
assert (LogicalExpr(dx(u), domain) == dx1(u))
assert (LogicalExpr(dy(u), domain) == dx2(u))
def test_global_quad_basis_span_2d_vector_1():
# ...
nderiv = 2
stmts = construct_logical_expressions(v, nderiv)
expressions = [dx(v), dx(dy(v)), dy(dy(v))]
stmts += [ComputePhysicalBasis(i) for i in expressions]
# ...
# ...
loop = Loop((l_quad, a_basis), index_quad, stmts)
# ...
# ...
loop = Reduce('+', ComputeKernelExpr(dx(v)*cos(x+y)), ElementOf(l_vec), loop)
# ...
# ... loop over tests
stmts = [loop]
loop = Loop(l_basis_v, index_dof_test, stmts)
# ...
# ...
body = (Reset(l_vec), loop)
stmts = Block(body)
# ...
# ...
loop = Loop((g_quad, g_basis_v, g_span), index_element, stmts)
# ...
# ...
body = (Reset(g_vec), Reduce('+', l_vec, g_vec, loop))
stmt = Block(body)
# ...
stmt = parse(stmt, settings={'dim': domain.dim, 'nderiv': nderiv})
print(pycode(stmt))
print()
def test_identity_mapping_2d_2():
rdim = 2
x1, x2 = symbols('x1, x2')
domain = Domain('Omega', dim=rdim)
M = IdentityMapping('F', rdim)
V = ScalarFunctionSpace('V', domain)
u = element_of(V, name='u')
# ...
assert (LogicalExpr(M, dx(u)) == dx1(u))
assert (LogicalExpr(M, dy(u)) == dx2(u))
def test_identity_mapping_2d_2():
rdim = 2
x1, x2 = symbols('x1, x2')
M = IdentityMapping('F', rdim)
domain = M(Domain('Omega', dim=rdim))
V = ScalarFunctionSpace('V', domain, kind='h1')
u = element_of(V, name='u')
# ...
assert (LogicalExpr(dx(u), mapping=M, dim=rdim, subs=True) == dx1(u))
assert (LogicalExpr(dy(u), mapping=M, dim=rdim, subs=True) == dx2(u))
def test_basis_atom_2d_2():
expr = dy(dx(u))
lhs = BasisAtom(expr)
rhs = PhysicalBasisValue(expr)
settings = {'dim': domain.dim, 'nderiv': 1}
_parse = lambda expr: parse(expr, settings=settings)
u_xy = Symbol('u_xy')
u_x1x2 = Symbol('u_x1x2')
assert(lhs.atom == u)
assert(_parse(lhs) == u_xy)
assert(_parse(rhs) == u_x1x2)
def test_logical_expr_3d_1():
rdim = 3
M = Mapping('M', rdim)
domain = Domain('Omega', dim=rdim)
alpha = Constant('alpha')
V = ScalarFunctionSpace('V', domain)
u, v = [element_of(V, name=i) for i in ['u', 'v']]
det_M = DetJacobian(M)
#print('det = ', det_M)
det = Symbol('det')
# ...
expr = 2 * u + alpha * v
expr = LogicalExpr(M, expr)
#print(expr)
#print('')
# ...
# ...
expr = dx(u)
expr = LogicalExpr(M, expr)
#print(expr.subs(det_M, det))
#print('')
# ...
# ...
expr = dy(u)
expr = LogicalExpr(M, expr)
#print(expr.subs(det_M, det))
#print('')
# ...
# ...
expr = dx(det_M)
expr = LogicalExpr(M, expr)
expr = expr.subs(det_M, det)
expr = expand(expr)
#print(expr)
#print('')
# ...
# ...
expr = dx(dx(u))
expr = LogicalExpr(M, expr)
def test_logical_expr_3d_1():
dim = 3
M = Mapping('M', dim=dim)
domain = M(Domain('Omega', dim=dim))
alpha = Constant('alpha')
V = ScalarFunctionSpace('V', domain, kind='h1')
u, v = [element_of(V, name=i) for i in ['u', 'v']]
det_M = Jacobian(M).det()
#print('det = ', det_M)
det = Symbol('det')
# ...
expr = 2 * u + alpha * v
expr = LogicalExpr(expr, domain)
#print(expr)
#print('')
# ...
# ...
expr = dx(u)
expr = LogicalExpr(expr, domain)
#print(expr.subs(det_M, det))
#print('')
# ...
# ...
expr = dy(u)
expr = LogicalExpr(expr, domain)
#print(expr.subs(det_M, det))
#print('')
# ...
# ...
expr = dx(det_M)
expr = LogicalExpr(expr, domain)
expr = expr.subs(det_M, det)
#print(expr)
#print('')
# ...
# ...
expr = dx(dx(u))
expr = LogicalExpr(expr, domain)
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_global_quad_basis_span_2d_vector_2():
# ...
nderiv = 1
stmts = construct_logical_expressions(v, nderiv)
# expressions = [dx(v), v] # TODO Wrong result
expressions = [dx(v), dy(v)]
stmts += [ComputePhysicalBasis(i) for i in expressions]
# ...
# ... case with mapping <> identity
loop = Loop((l_quad, a_basis, GeometryExpressions(M, nderiv)), index_quad, stmts)
# ...
# ...
loop = Reduce('+', ComputeKernelExpr(dx(v)*cos(x+y)), ElementOf(l_vec), loop)
# ...
# ... loop over tests
stmts = [loop]
loop = Loop(l_basis_v, index_dof_test, stmts)
# ...
# ...
body = (Reset(l_vec), loop)
stmts = Block(body)
# ...
# ...
loop = Loop((g_quad, g_basis_v, g_span), index_element, stmts)
# ...
# ...
body = (Reset(g_vec), Reduce('+', l_vec, g_vec, loop))
stmt = Block(body)
# ...
stmt = parse(stmt, settings={'dim': domain.dim, 'nderiv': nderiv, 'mapping': M})
print(pycode(stmt))
print()
