def test_conditional(mode, compile_args):
cell = ufl.triangle
element = ufl.FiniteElement("Lagrange", cell, 1)
u, v = ufl.TrialFunction(element), ufl.TestFunction(element)
x = ufl.SpatialCoordinate(cell)
condition = ufl.Or(ufl.ge(ufl.real(x[0] + x[1]), 0.1),
ufl.ge(ufl.real(x[1] + x[1]**2), 0.1))
c1 = ufl.conditional(condition, 2.0, 1.0)
a = c1 * ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx
x1x2 = ufl.real(x[0] + ufl.as_ufl(2) * x[1])
c2 = ufl.conditional(ufl.ge(x1x2, 0), 6.0, 0.0)
b = c2 * ufl.conj(v) * ufl.dx
forms = [a, b]
compiled_forms, module = ffcx.codegeneration.jit.compile_forms(
forms,
parameters={'scalar_type': mode},
cffi_extra_compile_args=compile_args)
form0 = compiled_forms[0][0].create_cell_integral(-1)
form1 = compiled_forms[1][0].create_cell_integral(-1)
ffi = cffi.FFI()
c_type, np_type = float_to_type(mode)
A1 = np.zeros((3, 3), dtype=np_type)
w1 = np.array([1.0, 1.0, 1.0], dtype=np_type)
c = np.array([], dtype=np.float64)
coords = np.array([0.0, 0.0, 1.0, 0.0, 0.0, 1.0], dtype=np.float64)
form0.tabulate_tensor(
ffi.cast('{type} *'.format(type=c_type), A1.ctypes.data),
ffi.cast('{type} *'.format(type=c_type), w1.ctypes.data),
ffi.cast('{type} *'.format(type=c_type), c.ctypes.data),
ffi.cast('double *', coords.ctypes.data), ffi.NULL, ffi.NULL, 0)
expected_result = np.array([[2, -1, -1], [-1, 1, 0], [-1, 0, 1]],
dtype=np_type)
assert np.allclose(A1, expected_result)
A2 = np.zeros(3, dtype=np_type)
w2 = np.array([1.0, 1.0, 1.0], dtype=np_type)
coords = np.array([0.0, 0.0, 1.0, 0.0, 0.0, 1.0], dtype=np.float64)
form1.tabulate_tensor(
ffi.cast('{type} *'.format(type=c_type), A2.ctypes.data),
ffi.cast('{type} *'.format(type=c_type), w2.ctypes.data),
ffi.cast('{type} *'.format(type=c_type), c.ctypes.data),
ffi.cast('double *', coords.ctypes.data), ffi.NULL, ffi.NULL, 0)
expected_result = np.ones(3, dtype=np_type)
assert np.allclose(A2, expected_result)
def test_remove_complex_nodes(self):
cell = triangle
element = FiniteElement("Lagrange", cell, 1)
u = TrialFunction(element)
v = TestFunction(element)
f = Coefficient(element)
a = conj(v)
b = real(u)
c = imag(f)
d = conj(real(v))*imag(conj(u))
assert remove_complex_nodes(a) == v
assert remove_complex_nodes(b) == u
with pytest.raises(ufl.log.UFLException):
remove_complex_nodes(c)
with pytest.raises(ufl.log.UFLException):
remove_complex_nodes(d)
def test_complex_degree_handling(self):
cell = triangle
element = FiniteElement("Lagrange", cell, 3)
v = TestFunction(element)
a = conj(v)
b = imag(v)
c = real(v)
assert estimate_total_polynomial_degree(a) == 3
assert estimate_total_polynomial_degree(b) == 3
assert estimate_total_polynomial_degree(c) == 3
def test_comparison_checker(self):
cell = triangle
element = FiniteElement("Lagrange", cell, 1)
u = TrialFunction(element)
v = TestFunction(element)
a = conditional(ge(abs(u), imag(v)), u, v)
b = conditional(le(sqrt(abs(u)), imag(v)), as_ufl(1), as_ufl(1j))
c = conditional(gt(abs(u), pow(imag(v), 0.5)), sin(u), cos(v))
d = conditional(lt(as_ufl(-1), as_ufl(1)), u, v)
e = max_value(as_ufl(0), real(u))
f = min_value(sin(u), cos(v))
g = min_value(sin(pow(u, 3)), cos(abs(v)))
assert do_comparison_check(a) == conditional(ge(real(abs(u)), real(imag(v))), u, v)
with pytest.raises(ComplexComparisonError):
b = do_comparison_check(b)
with pytest.raises(ComplexComparisonError):
c = do_comparison_check(c)
assert do_comparison_check(d) == conditional(lt(real(as_ufl(-1)), real(as_ufl(1))), u, v)
assert do_comparison_check(e) == max_value(real(as_ufl(0)), real(real(u)))
assert do_comparison_check(f) == min_value(real(sin(u)), real(cos(v)))
assert do_comparison_check(g) == min_value(real(sin(pow(u, 3))), real(cos(abs(v))))