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_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_evaluation_2d_1(): domain = Domain('Omega', dim=2) B_neumann = Boundary(r'\Gamma_1', domain) V = FunctionSpace('V', domain) W = VectorFunctionSpace('W', domain) p, q = [TestFunction(V, name=i) for i in ['p', 'q']] u, v = [VectorTestFunction(W, name=i) for i in ['u', 'v']] alpha = Constant('alpha') x, y = V.coordinates F = Field('F', space=V) a1 = BilinearForm((p, q), dot(grad(p), grad(q))) m = BilinearForm((p, q), p * q) a2 = BilinearForm((p, q), a1(p, q) + alpha * m(p, q)) a3 = BilinearForm((u, v), rot(u) * rot(v) + alpha * div(u) * div(v)) a11 = BilinearForm((v, u), inner(grad(v), grad(u))) a12 = BilinearForm((v, p), div(v) * p) a4 = BilinearForm(((v, q), (u, p)), a11(v, u) - a12(v, p) + a12(u, q)) l0 = LinearForm(p, F * p) l_neu = LinearForm(p, p * trace_1(grad(F), B_neumann)) l = LinearForm(p, l0(p) + l_neu(p)) # ... print(a1) print(evaluate(a1)) print('') # ... # ... print(a2) print(evaluate(a2)) print('') # ... # ... print(a3) print(evaluate(a3)) print('') # ... # ... print(a4) print(evaluate(a4)) print('') # ... # ... print(l) print(evaluate(l)) print('')
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_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_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_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_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_tensorize_2d_2_mapping(): DIM = 2 M = Mapping('M', DIM) domain = Domain('Omega', dim=DIM) V = VectorFunctionSpace('V', domain) u, v = elements_of(V, names='u, v') c = Constant('c') int_0 = lambda expr: integral(domain, expr) a = BilinearForm((u, v), int_0(c * div(v) * div(u) + curl(v) * curl(u))) expr = TensorExpr(a, mapping=M) print(expr)
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]))
def test_compiler_3d_2(): 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 v = element_of(X, name='v0, v1, v2, v3') u = element_of(X, name='u0, u1, u2, u3') beta = Field(V, 'beta') # # ... Dot operator # expr = dot(u1, v1) # print(ExteriorCalculusExpr(expr, tests=[v1])) # # expr = dot(u2, v2) # print(ExteriorCalculusExpr(expr, tests=[v2])) # # expr = dot(grad(v0), u1) # print(ExteriorCalculusExpr(expr, tests=[v0])) # # expr = dot(grad(u0), v1) # print(ExteriorCalculusExpr(expr, tests=[v1])) # # expr = dot(curl(u1), v2) # print(ExteriorCalculusExpr(expr, tests=[v2])) # # expr = dot(curl(v1), u2) # print(ExteriorCalculusExpr(expr, tests=[v1])) # # ... # ... Mul operator expr = u[0] * v[0] print(ExteriorCalculusExpr(expr, tests=[v[0]])) expr = u[0] * div(v[2]) print(ExteriorCalculusExpr(expr, tests=[v[2]])) expr = v[0] * div(u[2]) print(ExteriorCalculusExpr(expr, tests=[v[0]]))
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_linearize_form_2d_3(): """steady Euler equation.""" domain = Domain('Omega', dim=2) x, y = domain.coordinates U = VectorFunctionSpace('U', domain) W = FunctionSpace('W', domain) v = VectorTestFunction(U, name='v') phi = TestFunction(W, name='phi') q = TestFunction(W, name='q') U_0 = VectorField(U, name='U_0') Rho_0 = Field(W, name='Rho_0') P_0 = Field(W, name='P_0') # ... expr = div(Rho_0 * U_0) * phi l1 = LinearForm(phi, expr) expr = Rho_0 * dot(convect(U_0, grad(U_0)), v) + dot(grad(P_0), v) l2 = LinearForm(v, expr) expr = dot(U_0, grad(P_0)) * q + P_0 * div(U_0) * q l3 = LinearForm(q, expr) # ... a1 = linearize(l1, [Rho_0, U_0], trials=['d_rho', 'd_u']) print(a1) print('') a2 = linearize(l2, [Rho_0, U_0, P_0], trials=['d_rho', 'd_u', 'd_p']) print(a2) print('') a3 = linearize(l3, [P_0, U_0], trials=['d_p', 'd_u']) print(a3) print('') l = LinearForm((phi, v, q), l1(phi) + l2(v) + l3(q)) a = linearize(l, [Rho_0, U_0, P_0], trials=['d_rho', 'd_u', 'd_p']) print(a) export(a, 'steady_euler.png')
def test_curldiv_2d(): domain = Square() W1 = VectorFunctionSpace('W1', domain) T1 = VectorFunctionSpace('T1', domain) w1 = VectorTestFunction(W1, name='w1') t1 = VectorTestFunction(T1, name='t1') mu = Constant('mu') # ... a = BilinearForm((w1, t1), rot(w1) * rot(t1) + mu * div(w1) * div(t1), name='a') print(a) print(atomize(a)) print(evaluate(a))
def test_logical_expr_3d_4(): dim = 3 domain = Domain('Omega', dim=dim) M = Mapping('M', dim=3) mapped_domain = M(domain) V = VectorFunctionSpace('V', domain, kind='hdiv') VM = VectorFunctionSpace('VM', mapped_domain, kind='hdiv') u, v = elements_of(V, names='u,v') um, vm = elements_of(VM, names='u,v') J = M.jacobian a = div(um) * div(vm) e = LogicalExpr(a, mapping=M, dim=dim) assert e == J.det()**-2 * div(u) * div(v)
def test_tensorize_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, 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) print(expr)
def test_bilinear_form_2d_3(): domain = Domain('Omega', dim=2) x, y = domain.coordinates V = VectorFunctionSpace('V', domain) W = FunctionSpace('W', domain) v = VectorTestFunction(V, name='v') u = VectorTestFunction(V, name='u') p = TestFunction(W, name='p') q = TestFunction(W, name='q') a = BilinearForm((u, v), inner(grad(v), grad(u))) b = BilinearForm((v, p), div(v) * p) A = BilinearForm(((u, p), (v, q)), a(v, u) - b(v, p) + b(u, q)) export(A, 'stokes_2d.png')
def test_tensorize_2d_stokes(): domain = Domain('Omega', dim=DIM) # ... abstract model V = VectorFunctionSpace('V', domain) W = FunctionSpace('W', domain) v = VectorTestFunction(V, name='v') u = VectorTestFunction(V, name='u') p = TestFunction(W, name='p') q = TestFunction(W, name='q') a = BilinearForm((v, u), inner(grad(v), grad(u)), name='a') b = BilinearForm((v, p), div(v) * p, name='b') A = BilinearForm(((v, q), (u, p)), a(v, u) - b(v, p) + b(u, q), name='A') # ... print(A) print(tensorize(A)) print('')
def test_terminal_expr_bilinear_2d_4(): domain = Domain('Omega', dim=2) x, y = domain.coordinates V = VectorFunctionSpace('V', domain) W = ScalarFunctionSpace('W', domain) v = element_of(V, name='v') u = element_of(V, name='u') p = element_of(W, name='p') q = element_of(W, name='q') int_0 = lambda expr: integral(domain, expr) # stokes a = BilinearForm((u, v), int_0(inner(grad(v), grad(u)))) b = BilinearForm((v, p), int_0(div(v) * p)) a = BilinearForm(((u, p), (v, q)), a(v, u) - b(v, p) + b(u, q)) print(TerminalExpr(a)) print('')
def test_latex_2d_4(): DIM = 2 domain = Domain('Omega', dim=DIM) # ... abstract model V = VectorFunctionSpace('V', domain) W = ScalarFunctionSpace('W', domain) v = element_of(V, name='v') u = element_of(V, name='u') p = element_of(W, name='p') q = element_of(W, name='q') int_0 = lambda expr: integral(domain, expr) a = BilinearForm((v, u), int_0(inner(grad(v), grad(u)))) b = BilinearForm((v, p), int_0(div(v) * p)) A = BilinearForm(((v, q), (u, p)), a(v, u) - b(v, p) + b(u, q)) # ... print(latex(A)) # print(latex(tensorize(A))) print('')
def test_calculus_2d_5(): DIM = 2 domain = Domain('Omega', dim=DIM) V = VectorFunctionSpace('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)) assert (div(minus(u + v)) == div(minus(u)) + div(minus(v))) # ... # ... plus operator assert (plus(u + v) == plus(u) + plus(v)) assert (plus(a * u) == a * plus(u)) assert (div(plus(u + v)) == div(plus(u)) + div(plus(v)))
def test_bilinearity_2d_2(): domain = Domain('Omega', dim=DIM) V1 = FunctionSpace('V1', domain) V2 = FunctionSpace('V2', domain) U1 = FunctionSpace('U1', domain) U2 = FunctionSpace('U2', domain) W1 = VectorFunctionSpace('W1', domain) W2 = VectorFunctionSpace('W2', domain) T1 = VectorFunctionSpace('T1', domain) T2 = VectorFunctionSpace('T2', domain) v1 = TestFunction(V1, name='v1') v2 = TestFunction(V2, name='v2') u1 = TestFunction(U1, name='u1') u2 = TestFunction(U2, name='u2') w1 = VectorTestFunction(W1, name='w1') w2 = VectorTestFunction(W2, name='w2') t1 = VectorTestFunction(T1, name='t1') t2 = VectorTestFunction(T2, name='t2') V = ProductSpace(V1, V2) U = ProductSpace(U1, U2) x, y = V1.coordinates alpha = Constant('alpha') F = Field('F', space=V1) # ... a1 = BilinearForm((v1, u1), u1 * v1, check=True) a = BilinearForm((v2, u2), a1(v2, u2), check=True) # ... # ... a = BilinearForm((v1, u1), dot(grad(v1), grad(u1)), check=True) # ... # ... a1 = BilinearForm((v1, u1), dot(grad(v1), grad(u1)), check=True) a = BilinearForm((v2, u2), a1(v2, u2), check=True) # ... # ... a1 = BilinearForm((v1, u1), u1 * v1) a2 = BilinearForm((v1, u1), dx(u1) * dx(v1), check=True) a = BilinearForm((v2, u2), a1(v2, u2) + a2(v2, u2), check=True) # ... # ... a1 = BilinearForm((v1, u1), u1 * v1, check=True) a2 = BilinearForm((v1, u1), dx(u1) * dx(v1), check=True) # ... # ... a1 = BilinearForm((v1, u1), u1 * v1, check=True) a2 = BilinearForm((v1, u1), dx(u1) * dx(v1), check=True) a = BilinearForm(((v1, v2), (u1, u2)), a1(v1, u2) + a2(v2, u1), check=True) # ... # ... a = BilinearForm((w1, t1), rot(w1) * rot(t1) + div(w1) * div(t1), check=True) # ... # ... a1 = BilinearForm((v1, u1), u1 * v1, check=True) a2 = BilinearForm((v1, u1), dx(u1) * dx(v1), check=True) a3 = BilinearForm((w1, t1), rot(w1) * rot(t1) + div(w1) * div(t1), check=True) a4 = BilinearForm((w1, u1), div(w1) * u1, check=True) a = BilinearForm(((w2, v2), (t2, u2)), a3(w2, t2) + a2(v2, u2) + a4(w2, u2), check=True) # ... # ... a1 = BilinearForm((v1, u1), laplace(u1) * laplace(v1), check=True) # ... # ... a1 = BilinearForm((v1, u1), inner(hessian(u1), hessian(v1)), check=True) # ... # ... stokes V = VectorFunctionSpace('V', domain) W = FunctionSpace('W', domain) v = VectorTestFunction(V, name='v') u = VectorTestFunction(V, name='u') p = TestFunction(W, name='p') q = TestFunction(W, name='q') a = BilinearForm((v, u), inner(grad(v), grad(u)), check=True) b = BilinearForm((v, p), div(v) * p, check=True) A = BilinearForm(((v, q), (u, p)), a(v, u) - b(v, p) + b(u, q), check=True) # ... ################################ # non bilinear forms ################################ # ... with pytest.raises(UnconsistentLinearExpressionError): a = BilinearForm((v1, u1), dot(grad(v1), grad(u1)) + v1, check=True) # ... # ... with pytest.raises(UnconsistentLinearExpressionError): a = BilinearForm((v1, u1), v1**2 * u1, check=True) # ... # ... with pytest.raises(UnconsistentLinearExpressionError): a = BilinearForm((v1, u1), dot(grad(v1), grad(v1)), check=True)
def test_linearity_2d_2(): domain = Domain('Omega', dim=DIM) V1 = FunctionSpace('V1', domain) V2 = FunctionSpace('V2', domain) U1 = FunctionSpace('U1', domain) U2 = FunctionSpace('U2', domain) W1 = VectorFunctionSpace('W1', domain) W2 = VectorFunctionSpace('W2', domain) T1 = VectorFunctionSpace('T1', domain) T2 = VectorFunctionSpace('T2', domain) v1 = TestFunction(V1, name='v1') v2 = TestFunction(V2, name='v2') u1 = TestFunction(U1, name='u1') u2 = TestFunction(U2, name='u2') w1 = VectorTestFunction(W1, name='w1') w2 = VectorTestFunction(W2, name='w2') t1 = VectorTestFunction(T1, name='t1') t2 = VectorTestFunction(T2, name='t2') V = ProductSpace(V1, V2) U = ProductSpace(U1, U2) x, y = V1.coordinates alpha = Constant('alpha') F = Field('F', space=V1) # ... l1 = LinearForm(v1, x * y * v1, check=True) l = LinearForm(v2, l1(v2), check=True) # ... # ... l1 = LinearForm(v1, x * y * v1, check=True) l2 = LinearForm(v2, cos(x + y) * v2, check=True) l = LinearForm((u1, u2), l1(u1) + l2(u2), check=True) # ... # ... l1 = LinearForm(v1, x * y * v1, check=True) l2 = LinearForm(v2, cos(x + y) * v2, check=True) l = LinearForm((u1, u2), l1(u1) + alpha * l2(u2), check=True) # ... # ... l1 = LinearForm(v1, x * y * v1, check=True) l2 = LinearForm(w1, div(w1), check=True) l = LinearForm((v2, w2), l1(v2) + l2(w2), check=True) # ... ################################ # non bilinear forms ################################ # ... with pytest.raises(UnconsistentLinearExpressionError): l = LinearForm(v1, x * y * v1**2, check=True) # ... # ... with pytest.raises(UnconsistentLinearExpressionError): l = LinearForm(v1, x * y, check=True)
def test_calls_2d(): domain = Domain('Omega', dim=DIM) V1 = FunctionSpace('V1', domain) V2 = FunctionSpace('V2', domain) U1 = FunctionSpace('U1', domain) U2 = FunctionSpace('U2', domain) W1 = VectorFunctionSpace('W1', domain) W2 = VectorFunctionSpace('W2', domain) T1 = VectorFunctionSpace('T1', domain) T2 = VectorFunctionSpace('T2', domain) v1 = TestFunction(V1, name='v1') v2 = TestFunction(V2, name='v2') u1 = TestFunction(U1, name='u1') u2 = TestFunction(U2, name='u2') w1 = VectorTestFunction(W1, name='w1') w2 = VectorTestFunction(W2, name='w2') t1 = VectorTestFunction(T1, name='t1') t2 = VectorTestFunction(T2, name='t2') V = ProductSpace(V1, V2) U = ProductSpace(U1, U2) x, y = V1.coordinates alpha = Constant('alpha') F = Field('F', space=V1) # ... a1 = BilinearForm((v1, u1), u1 * v1, name='a1') print(a1) print(atomize(a1)) print(evaluate(a1)) print('') expr = a1(v2, u2) a = BilinearForm((v2, u2), expr, name='a') print(a) print(atomize(a)) print(evaluate(a)) print('') # ... # ... a = BilinearForm((v1, u1), dot(grad(v1), grad(u1)), name='a') print(a) print(atomize(a)) print(evaluate(a)) print('') # ... # ... a1 = BilinearForm((v1, u1), dot(grad(v1), grad(u1)), name='a1') expr = a1(v2, u2) a = BilinearForm((v2, u2), expr, name='a') print(a) print(atomize(a)) print(evaluate(a)) print('') # ... # ... a1 = BilinearForm((v1, u1), u1 * v1, name='a1') a2 = BilinearForm((v1, u1), dx(u1) * dx(v1), name='a2') expr = a1(v2, u2) + a2(v2, u2) a = BilinearForm((v2, u2), expr, name='a') print(a) print(atomize(a)) print(evaluate(a)) print('') # ... # ... a1 = BilinearForm((v1, u1), u1 * v1, name='a1') a2 = BilinearForm((v1, u1), dx(u1) * dx(v1), name='a2') expr = a1(v1, u2) print('> before = ', expr) expr = expr.subs(u2, u1) print('> after = ', expr) print('') expr = a1(v1, u2) + a1(v2, u2) print('> before = ', expr) expr = expr.subs(u2, u1) print('> after = ', expr) print('') # ... # ... a1 = BilinearForm((v1, u1), u1 * v1, name='a1') a2 = BilinearForm((v1, u1), dx(u1) * dx(v1), name='a2') expr = a1(v1, u2) + a2(v2, u1) a = BilinearForm(((v1, v2), (u1, u2)), expr, name='a') print(a) print(atomize(a)) print(evaluate(a)) print('') # ... # ... a = BilinearForm((w1, t1), rot(w1) * rot(t1) + div(w1) * div(t1), name='a') print(a) print(atomize(a)) print(evaluate(a)) # ... # ... a1 = BilinearForm((v1, u1), u1 * v1, name='a1') a2 = BilinearForm((v1, u1), dx(u1) * dx(v1), name='a2') a3 = BilinearForm((w1, t1), rot(w1) * rot(t1) + div(w1) * div(t1), name='a3') a4 = BilinearForm((w1, u1), div(w1) * u1, name='a4') expr = a3(w2, t2) + a2(v2, u2) + a4(w2, u2) a = BilinearForm(((w2, v2), (t2, u2)), expr, name='a') print(a) print(atomize(a)) print(evaluate(a)) # ... # ... a1 = BilinearForm((v1, u1), laplace(u1) * laplace(v1), name='a1') print(a1) print(atomize(a1)) print(evaluate(a1)) print('') # ... # ... a1 = BilinearForm((v1, u1), inner(hessian(u1), hessian(v1)), name='a1') print('================================') print(a1) print(atomize(a1)) print(evaluate(a1)) print('') # ... # ... l1 = LinearForm(v1, x * y * v1, name='11') expr = l1(v2) l = LinearForm(v2, expr, name='1') print(l) print(atomize(l)) print(evaluate(l)) # ... # ... l1 = LinearForm(v1, x * y * v1, name='l1') l2 = LinearForm(v2, cos(x + y) * v2, name='l2') expr = l1(u1) + l2(u2) l = LinearForm((u1, u2), expr, name='1') print(l) print(atomize(l)) print(evaluate(l)) # ... # ... l1 = LinearForm(v1, x * y * v1, name='l1') l2 = LinearForm(v2, cos(x + y) * v2, name='l2') expr = l1(u1) + alpha * l2(u2) l = LinearForm((u1, u2), expr, name='1') print(l) print(atomize(l)) print(evaluate(l)) # ... # ... l1 = LinearForm(v1, x * y * v1, name='l1') l2 = LinearForm(w1, div(w1), name='l2') expr = l1(v2) + l2(w2) l = LinearForm((v2, w2), expr, name='1') print(l) print(atomize(l)) print(evaluate(l)) # ... # ... I1 = Integral(x * y, domain, name='I1') print(I1) print(atomize(I1)) print(evaluate(I1)) # ... # ... expr = F - cos(2 * pi * x) * cos(3 * pi * y) expr = dot(grad(expr), grad(expr)) I2 = Integral(expr, domain, name='I2') print(I2) print(atomize(I2)) print(evaluate(I2)) # ... # ... expr = F - cos(2 * pi * x) * cos(3 * pi * y) expr = dot(grad(expr), grad(expr)) I2 = Integral(expr, domain, name='I2') print(I2) print(atomize(I2)) print(evaluate(I2)) # ... # ... stokes V = VectorFunctionSpace('V', domain) W = FunctionSpace('W', domain) v = VectorTestFunction(V, name='v') u = VectorTestFunction(V, name='u') p = TestFunction(W, name='p') q = TestFunction(W, name='q') a = BilinearForm((v, u), inner(grad(v), grad(u)), name='a') b = BilinearForm((v, p), div(v) * p, name='b') A = BilinearForm(((v, q), (u, p)), a(v, u) - b(v, p) + b(u, q), name='A') print(A) print(atomize(A)) print(evaluate(A))
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)