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_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 = FunctionSpace('V', domain) u, v = [TestFunction(V, name=i) for i in ['u', 'v']] # ... expr = dot(grad(u), grad(v)) + f(x, y) * u * v a = BilinearForm((v, u), expr) print(a) print(evaluate(a, verbose=True)) print('') # ... # ... expr = f(x, y) * v l = LinearForm(v, expr) print(l) print(evaluate(l, verbose=True)) print('')
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_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_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_calls_2d_3(): domain = Square() V = FunctionSpace('V', domain) x, y = domain.coordinates pn = Field('pn', V) wn = Field('wn', V) dp = TestFunction(V, name='dp') dw = TestFunction(V, name='dw') tau = TestFunction(V, name='tau') sigma = TestFunction(V, name='sigma') Re = Constant('Re', real=True) dt = Constant('dt', real=True) alpha = Constant('alpha', real=True) l1 = LinearForm(tau, bracket(pn, wn) * tau - 1. / Re * dot(grad(tau), grad(wn))) # ... l = LinearForm((tau, sigma), dt * l1(tau)) print(evaluate(l, verbose=True))
def test_tensorize_2d_1_mapping(): DIM = 2 M = Mapping('Map', DIM) domain = Domain('Omega', dim=DIM) B1 = Boundary(r'\Gamma_1', domain) x, y = domain.coordinates kappa = Constant('kappa', is_real=True) mu = Constant('mu', is_real=True) V = ScalarFunctionSpace('V', domain) u, v = elements_of(V, names='u, v') int_0 = lambda expr: integral(domain, expr) # ... # a = BilinearForm((u,v), u*v) # a = BilinearForm((u,v), mu*u*v + dot(grad(u),grad(v))) a = BilinearForm((u, v), int_0(dot(grad(u), grad(v)))) # a = BilinearForm((u,v), dx(u)*v) # a = BilinearForm((u,v), laplace(u)*laplace(v)) expr = TensorExpr(a, mapping=M) print(expr)
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_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_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_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_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_system_2d(): domain = Square() V = FunctionSpace('V', domain) x, y = V.coordinates u, v, p, q = [TestFunction(V, name=i) for i in ['u', 'v', 'p', 'q']] a1, a2, b1, b2 = [Constant(i, real=True) for i in ['a1', 'a2', 'b1', 'b2']] # ... a = BilinearForm((v, u), dot(grad(u), grad(v))) m = BilinearForm((v, u), u * v) expr = a(p, u) + a1 * m(p, u) + b1 * m(p, v) + a( q, v) + a2 * m(q, u) + b2 * m(q, v) b = BilinearForm(((p, q), (u, v)), expr) print(evaluate(b, verbose=True)) # ... # ... f1 = x * y f2 = x + y l1 = LinearForm(p, f1 * p) l2 = LinearForm(q, f2 * q) expr = l1(p) + l2(q) l = LinearForm((p, q), expr) print(evaluate(l, verbose=True))
def test_target_mapping_2d_1(): rdim = 2 x1, x2 = symbols('x1, x2') constants = ['c1', 'c2', 'D', 'k'] c1, c2, D, k = [Constant(i) for i in constants] M = TargetMapping('M', rdim) assert (not (M[0] == x1)) assert (not (M[1] == x2)) assert (LogicalExpr(M[0], mapping=M, dim=rdim, subs=True) == -D * x1**2 + c1 + x1 * (-k + 1) * cos(x2)) assert (LogicalExpr(M[1], mapping=M, dim=rdim, subs=True) == c2 + x1 * (k + 1) * sin(x2)) assert (LogicalExpr(dx1(M[0]), mapping=M, dim=rdim, subs=True) == -2 * D * x1 + (-k + 1) * cos(x2)) assert (LogicalExpr(dx1(M[1]), mapping=M, dim=rdim, subs=True) == (k + 1) * sin(x2)) assert (LogicalExpr(dx2(M[0]), mapping=M, dim=rdim, subs=True) == -x1 * (-k + 1) * sin(x2)) assert (LogicalExpr(dx2(M[1]), mapping=M, dim=rdim, subs=True) == x1 * (k + 1) * cos(x2)) expected = Matrix( [[-2 * D * x1 + (-k + 1) * cos(x2), -x1 * (-k + 1) * sin(x2)], [(k + 1) * sin(x2), x1 * (k + 1) * cos(x2)]]) assert (not (Jacobian(M) == expected)) assert (expand(LogicalExpr(Jacobian(M), mapping=M, dim=rdim, subs=True)) == expand(expected))
def test_polar_mapping_2d_1(): rdim = 2 x1, x2 = symbols('x1, x2') constants = ['c1', 'c2', 'rmax', 'rmin'] c1, c2, rmax, rmin = [Constant(i) for i in constants] M = PolarMapping('M', rdim) assert (not (M[0] == x1)) assert (not (M[1] == x2)) assert (LogicalExpr(M[0], mapping=M, dim=rdim, subs=True) == c1 + (rmax * x1 + rmin * (-x1 + 1)) * cos(x2)) assert (LogicalExpr(M[1], mapping=M, dim=rdim, subs=True) == c2 + (rmax * x1 + rmin * (-x1 + 1)) * sin(x2)) assert (LogicalExpr(dx1(M[0]), mapping=M, dim=rdim, subs=True) == (rmax - rmin) * cos(x2)) assert (LogicalExpr(dx1(M[1]), mapping=M, dim=rdim, subs=True) == (rmax - rmin) * sin(x2)) expected = -(rmax * x1 + rmin * (-x1 + 1)) * sin(x2) assert (expand(LogicalExpr(dx2(M[0]), mapping=M, dim=rdim, subs=True)) == expand(expected)) assert (LogicalExpr(dx2(M[1]), mapping=M, dim=rdim, subs=True) == (rmax * x1 + rmin * (-x1 + 1)) * cos(x2)) expected = Matrix([[(rmax - rmin) * cos(x2), -(rmax * x1 + rmin * (-x1 + 1)) * sin(x2)], [(rmax - rmin) * sin(x2), (rmax * x1 + rmin * (-x1 + 1)) * cos(x2)]]) assert (expand(LogicalExpr(Jacobian(M), mapping=M, dim=rdim, subs=True)) == expand(expected))
def test_boundary_2d_2(): Omega_1 = InteriorDomain('Omega_1', dim=2) B1 = Boundary('B1', Omega_1) B2 = Boundary('B2', Omega_1) B3 = Boundary('B3', Omega_1) domain = Domain('Omega', interiors=[Omega_1], boundaries=[B1, B2, B3]) V = FunctionSpace('V', domain) v = TestFunction(V, name='v') u = TestFunction(V, name='u') x, y = V.coordinates alpha = Constant('alpha') # ... print('==== l0 ====') l0 = LinearForm(v, x * y * v, name='l0') print(evaluate(l0, verbose=VERBOSE)) print('') # ... # ... print('==== l1 ====') g = Tuple(x**2, y**2) l1 = LinearForm(v, v * trace_1(g, domain.boundary)) print(evaluate(l1, verbose=VERBOSE)) print('') # ... # ... print('==== l2 ====') B_neumann = Union(B1, B2) g = Tuple(x**2, y**2) l2 = LinearForm(v, v * trace_1(g, B_neumann), name='l2') print(evaluate(l2, verbose=VERBOSE)) print('') # ... # ... print('==== l3 ====') l3 = LinearForm(v, l2(v)) assert (l3(v).__str__ == l2(v).__str__) print(evaluate(l3, verbose=VERBOSE)) print('') # ... # ... print('==== l4 ====') l4 = LinearForm(v, l0(v) + l2(v)) print(evaluate(l4, verbose=VERBOSE)) print('')
def test_Inner(dim): domain = Domain('Omega', dim=dim) W = VectorFunctionSpace('W', domain) a, b, c = elements_of(W, names='a, b, c') r = Constant('r') # Commutativity assert inner(a, b) == inner(b, a) # Bilinearity: vector addition assert inner(a, b + c) == inner(a, b) + inner(a, c) assert inner(a + b, c) == inner(a, c) + inner(b, c) # Bilinearity: scalar multiplication assert inner(a, r * b) == r * inner(a, b) assert inner(r * a, b) == r * inner(a, b) # Special case: null vector assert inner(a, 0) == 0 assert inner(0, a) == 0 # Special case: two arguments are the same assert inner(a, a).is_real assert inner(a, a).is_positive
def test_target_mapping_2d_1(): dim = 2 x1, x2 = symbols('x1, x2') constants = ['c1', 'c2', 'D', 'k'] c1, c2, D, k = [Constant(i) for i in constants] M = TargetMapping('M', dim=dim) domain = M(Domain('Omega', dim=dim)) assert (not (M[0] == x1)) assert (not (M[1] == x2)) assert (LogicalExpr(M[0], domain) == -D * x1**2 + c1 + x1 * (-k + 1) * cos(x2)) assert (LogicalExpr(M[1], domain) == c2 + x1 * (k + 1) * sin(x2)) assert (LogicalExpr(dx1(M[0]), domain) == -2 * D * x1 + (-k + 1) * cos(x2)) assert (LogicalExpr(dx1(M[1]), domain) == (k + 1) * sin(x2)) assert (LogicalExpr(dx2(M[0]), domain) == -x1 * (-k + 1) * sin(x2)) assert (LogicalExpr(dx2(M[1]), domain) == x1 * (k + 1) * cos(x2)) expected = Matrix( [[-2 * D * x1 + (-k + 1) * cos(x2), -x1 * (-k + 1) * sin(x2)], [(k + 1) * sin(x2), x1 * (k + 1) * cos(x2)]]) assert (Jacobian(M) == expected)
def test_tensorize_2d_3(): domain = Domain('Omega', dim=2) V = ScalarFunctionSpace('V', domain) u, v = elements_of(V, names='u,v') bx = Constant('bx') by = Constant('by') b = Tuple(bx, by) expr = integral(domain, dot(b, grad(v)) * dot(b, grad(u))) a = BilinearForm((u, v), expr) print(TensorExpr(a)) print('')
def test_calculus_2d_4(): DIM = 2 domain = Domain('Omega', dim=DIM) V = ScalarFunctionSpace('V', domain, kind=None) u, v = elements_of(V, names='u, v') a = Constant('a', is_real=True) # ... jump operator assert (jump(u + v) == jump(u) + jump(v)) assert (jump(a * u) == a * jump(u)) # ... # ... avg operator assert (avg(u + v) == avg(u) + avg(v)) assert (avg(a * u) == a * avg(u)) # ... # ... Dn operator assert (Dn(u + v) == Dn(u) + Dn(v)) assert (Dn(a * u) == a * Dn(u)) # ... # ... minus operator assert (minus(u + v) == minus(u) + minus(v)) assert (minus(a * u) == a * minus(u)) # ... # ... plus operator assert (plus(u + v) == plus(u) + plus(v)) assert (plus(a * u) == a * plus(u))
def test_target_mapping_2d_1(): rdim = 2 x1, x2 = symbols('x1, x2') constants = ['c1', 'c2', 'D', 'k'] c1, c2, D, k = [Constant(i) for i in constants] M = TargetMapping('M', rdim) assert (not (M[0] == x1)) assert (not (M[1] == x2)) assert (LogicalExpr(M, M[0]) == -D * x1**2 + c1 + x1 * (-k + 1) * cos(x2)) assert (LogicalExpr(M, M[1]) == c2 + x1 * (k + 1) * sin(x2)) assert (LogicalExpr(M, dx1(M[0])) == -2 * D * x1 - k * x1 * cos(x2) + (-k + 1) * cos(x2)) assert (LogicalExpr(M, dx1(M[1])) == (k + 1) * sin(x2)) assert (LogicalExpr(M, dx2(M[0])) == x1 * (-k * cos(x2) - (-k + 1) * sin(x2))) assert (LogicalExpr(M, dx2(M[1])) == x1 * (k + 1) * cos(x2)) expected = Matrix([[ -2 * D * x1 - k * x1 * cos(x2) + (-k + 1) * cos(x2), x1 * (-k * cos(x2) - (-k + 1) * sin(x2)) ], [(k + 1) * sin(x2), x1 * (k + 1) * cos(x2)]]) assert (not (M.jacobian == expected)) assert (expand(LogicalExpr(M, M.jacobian)) == expand(expected))
def test_bilinear_form_2d_1(): 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) eps = Constant('eps', real=True) V = FunctionSpace('V', domain) u, u1, u2 = [TestFunction(V, name=i) for i in ['u', 'u1', 'u2']] v, v1, v2 = [TestFunction(V, name=i) for i in ['v', 'v1', 'v2']] # ... d_forms = {} d_forms['a1'] = BilinearForm((u, v), u * v) d_forms['a2'] = BilinearForm((u, v), u * v + dot(grad(u), grad(v))) d_forms['a3'] = BilinearForm((u, v), v * trace_1(grad(u), B1)) # Poisson with Nitsch method a0 = BilinearForm((u, v), dot(grad(u), grad(v))) a_B1 = BilinearForm( (u, v), -kappa * u * trace_1(grad(v), B1) - v * trace_1(grad(u), B1) + trace_0(u, B1) * trace_0(v, B1) / eps) a = BilinearForm((u, v), a0(u, v) + a_B1(u, v)) d_forms['a4'] = a # ... # ... calls d_calls = {} for name, a in d_forms.items(): d_calls[name] = a(u1, v1) # ... # ... export forms for name, expr in d_forms.items(): export(expr, 'biform_2d_{}.png'.format(name)) # ... # ... export calls for name, expr in d_calls.items(): export(expr, 'biform_2d_call_{}.png'.format(name))
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_bilinearity_2d_1(): domain = Square() x, y = domain.coordinates alpha = Constant('alpha') beta = Constant('beta') f1 = x * y f2 = x + y f = Tuple(f1, f2) V = FunctionSpace('V', domain) # TODO improve: naming are not given the same way G = Field('G', V) p, q = [TestFunction(V, name=i) for i in ['p', 'q']] ##################################### # linear expressions ##################################### # ... expr = p * q assert (is_bilinear_form(expr, (p, q))) # ... # ... expr = dot(grad(p), grad(q)) assert (is_bilinear_form(expr, (p, q))) # ... # ... expr = alpha * dot(grad(p), grad(q)) + beta * p * q + laplace(p) * laplace(q) assert (is_bilinear_form(expr, (p, q))) # ... ##################################### ##################################### # nonlinear expressions ##################################### # ... with pytest.raises(UnconsistentLinearExpressionError): expr = alpha * dot(grad(p**2), grad(q)) + beta * p * q is_bilinear_form(expr, (p, q))
def test_linear_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) g = Matrix((x, y)) l = LinearForm(v, int_0(dot(g, v))) assert (l.domain == domain.interior) assert (l(v1) == int_0(dot(g, v1))) # ... # ... g = Matrix((x, y)) l1 = LinearForm(v1, int_0(dot(g, v1))) l = LinearForm(v, l1(v)) assert (l.domain == domain.interior) assert (l(u1) == int_0(dot(g, u1))) # ... # ... g1 = Matrix((x, 0)) g2 = Matrix((0, y)) l1 = LinearForm(v1, int_0(dot(v1, g1))) l2 = LinearForm(v2, int_0(dot(v2, g2))) l = LinearForm(v, l1(v) + l2(v)) assert (l.domain == domain.interior) assert (l(u) == int_0(dot(u, g1)) + int_0(dot(u, g2)))
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_projection_2d(): domain = Domain('Omega', dim=DIM) V = FunctionSpace('V', domain) x, y = domain.coordinates alpha = Constant('alpha') u = Projection(x**2 + alpha * y, V, name='u')