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_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_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_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_linearize_form_2d_4(): domain = Domain('Omega', dim=2) Gamma_N = Boundary(r'\Gamma_N', domain) x,y = domain.coordinates V = ScalarFunctionSpace('V', domain) v = element_of(V, name='v') u = element_of(V, name='u') du = element_of(V, name='du') int_0 = lambda expr: integral(domain , expr) int_1 = lambda expr: integral(Gamma_N, expr) g = Tuple(cos(pi*x)*sin(pi*y), sin(pi*x)*cos(pi*y)) expr = dot(grad(v), grad(u)) - 4.*exp(-u)*v # + v*trace_1(g, Gamma_N) l = LinearForm(v, int_0(expr) ) # linearising l around u, using du a = linearize(l, u, trials=du) assert a(du, v) == int_0(dot(grad(v), grad(du)) + 4.*exp(-u) * du * v)
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_equation_2d_4(): V = VectorFunctionSpace('V', domain) v = element_of(V, name='v') u = element_of(V, name='u') x, y = domain.coordinates B1 = Boundary(r'\Gamma_1', domain) int_0 = lambda expr: integral(domain, expr) int_1 = lambda expr: integral(B1, expr) # ... bilinear/linear forms a1 = BilinearForm((v, u), int_0(inner(grad(v), grad(u)))) f = Matrix([x * y, sin(pi * x) * sin(pi * y)]) l1 = LinearForm(v, int_0(dot(f, v))) # ... # ... bc = EssentialBC(u, 0, B1) eq = Equation(a1, l1, tests=v, trials=u, bc=bc) # ... # ... bc = EssentialBC(u[0], 0, B1) eq = Equation(a1, l1, tests=v, trials=u, bc=bc) # ... # ... nn = NormalVector('nn') bc = EssentialBC(dot(u, nn), 0, B1) eq = Equation(a1, l1, tests=v, trials=u, bc=bc)
def test_equation_2d_3(): V = ScalarFunctionSpace('V', domain) v = element_of(V, name='v') u = element_of(V, name='u') x, y = domain.coordinates B1 = Boundary(r'\Gamma_1', domain) int_0 = lambda expr: integral(domain, expr) int_1 = lambda expr: integral(B1, expr) # ... bilinear/linear forms a1 = BilinearForm((v, u), int_0(dot(grad(v), grad(u)))) a2 = BilinearForm((v, u), int_0(v * u)) l1 = LinearForm(v, int_0(x * y * v)) l2 = LinearForm(v, int_0(cos(x + y) * v)) # ... # ... bc = EssentialBC(u, 0, B1) eq = Equation(a1, l1, tests=v, trials=u, bc=bc) # ... # ... nn = NormalVector('nn') bc = EssentialBC(dot(grad(u), nn), 0, B1) eq = Equation(a1, l1, tests=v, trials=u, bc=bc)
def test_linearize_expr_2d_1(): domain = Domain('Omega', dim=2) x,y = domain.coordinates V1 = ScalarFunctionSpace('V1', domain) W1 = VectorFunctionSpace('W1', domain) v1 = element_of(V1, name='v1') w1 = element_of(W1, name='w1') alpha = Constant('alpha') F = element_of(V1, name='F') G = element_of(W1, 'G') # ... l = LinearExpr(v1, F**2*v1) a = linearize(l, F, trials='u1') print(a) # ... # ... l = LinearExpr(v1, dot(grad(F), grad(F))*v1) a = linearize(l, F, trials='u1') print(a) # ... # ... l = LinearExpr(v1, exp(-F)*v1) a = linearize(l, F, trials='u1') print(a) # ... # ... l = LinearExpr(v1, cos(F)*v1) a = linearize(l, F, trials='u1') print(a) # ... # ... l = LinearExpr(v1, cos(F**2)*v1) a = linearize(l, F, trials='u1') print(a) # ... # ... l = LinearExpr(v1, F**2*dot(grad(F), grad(v1))) a = linearize(l, F, trials='u1') print(a) # ... # ... l = LinearExpr(w1, dot(rot(G), grad(G))*w1) a = linearize(l, G, trials='u1') print(a)
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_linearize_2d_1(): domain = Domain('Omega', dim=DIM) x, y = domain.coordinates V1 = FunctionSpace('V1', domain) W1 = VectorFunctionSpace('W1', domain) v1 = TestFunction(V1, name='v1') w1 = VectorTestFunction(W1, name='w1') alpha = Constant('alpha') F = Field('F', space=V1) G = VectorField(W1, 'G') # ... l = LinearForm(v1, F**2 * v1, check=True) a = linearize(l, F, trials='u1') print(a) # ... # ... l = LinearForm(v1, dot(grad(F), grad(F)) * v1, check=True) a = linearize(l, F, trials='u1') print(a) # ... # ... l = LinearForm(v1, exp(-F) * v1, check=True) a = linearize(l, F, trials='u1') print(a) # ... # ... l = LinearForm(v1, cos(F) * v1, check=True) a = linearize(l, F, trials='u1') print(a) # ... # ... l = LinearForm(v1, cos(F**2) * v1, check=True) a = linearize(l, F, trials='u1') print(a) # ... # ... l = LinearForm(v1, F**2 * dot(grad(F), grad(v1)), check=True) a = linearize(l, F, trials='u1') print(a) # ... # ... l = LinearForm(w1, dot(rot(G), grad(G)) * w1, check=True) a = linearize(l, G, trials='u1') print(a)
def test_interface_2d_1(): # ... def two_patches(): from sympde.topology import InteriorDomain from sympde.topology import Connectivity, Interface A = Square('A') B = Square('B') A = A.interior B = B.interior connectivity = Connectivity() bnd_A_1 = Boundary(r'\Gamma_1', A, axis=0, ext=-1) bnd_A_2 = Boundary(r'\Gamma_2', A, axis=0, ext=1) bnd_A_3 = Boundary(r'\Gamma_3', A, axis=1, ext=-1) bnd_A_4 = Boundary(r'\Gamma_4', A, axis=1, ext=1) bnd_B_1 = Boundary(r'\Gamma_1', B, axis=0, ext=-1) bnd_B_2 = Boundary(r'\Gamma_2', B, axis=0, ext=1) bnd_B_3 = Boundary(r'\Gamma_3', B, axis=1, ext=-1) bnd_B_4 = Boundary(r'\Gamma_4', B, axis=1, ext=1) connectivity['I'] = Interface('I', bnd_A_2, bnd_B_1) Omega = Domain('Omega', interiors=[A, B], boundaries=[ bnd_A_1, bnd_A_2, bnd_A_3, bnd_A_4, bnd_B_1, bnd_B_2, bnd_B_3, bnd_B_4 ], connectivity=connectivity) return Omega # ... # create a domain with an interface domain = two_patches() interfaces = domain.interfaces V = ScalarFunctionSpace('V', domain) u, v = elements_of(V, names='u, v') print(integral(interfaces, u * v)) expr = integral(domain, dot(grad(v), grad(u))) expr += integral(interfaces, -avg(Dn(u)) * jump(v) + avg(Dn(v)) * jump(u)) a = BilinearForm((u, v), expr) print(a)
def test_interface_integral_1(): # ... A = Square('A') B = Square('B') domain = A.join(B, name='domain', bnd_minus=A.get_boundary(axis=0, ext=1), bnd_plus=B.get_boundary(axis=0, ext=-1)) # ... x, y = domain.coordinates V = ScalarFunctionSpace('V', domain, kind=None) assert (V.is_broken) u, v = elements_of(V, names='u, v') # ... I = domain.interfaces # ... # expr = minus(Dn(u)) # print(expr) # import sys; sys.exit(0) # ... bilinear forms # a = BilinearForm((u,v), integral(domain, u*v)) # a = BilinearForm((u,v), integral(domain, dot(grad(u),grad(v)))) # a = BilinearForm((u,v), integral(I, jump(u) * jump(v))) # a = BilinearForm((u,v), integral(I, jump(Dn(u)) * jump(v))) # a = BilinearForm((u,v), integral(domain, dot(grad(u),grad(v))) # + integral(I, jump(u) * jump(v))) # Nitsch kappa = Constant('kappa') expr_I = (-jump(u) * jump(Dn(v)) + kappa * jump(u) * jump(v) + plus(Dn(u)) * minus(v) + minus(Dn(u)) * plus(v)) a = BilinearForm( (u, v), integral(domain, dot(grad(u), grad(v))) + integral(I, expr_I)) # # TODO BUG # bnd_A = A.get_boundary(axis=0, ext=1) # # a = BilinearForm((u,v), integral(domain, dot(grad(u),grad(v))) # + integral(I, jump(u) * jump(v)) # + integral(bnd_A, dx(u)*v)) expr = TerminalExpr(a) print(expr)
def test_interface_integral_3(): # ... A = Square('A') B = Square('B') C = Square('C') AB = A.join(B, name='AB', bnd_minus=A.get_boundary(axis=0, ext=1), bnd_plus=B.get_boundary(axis=0, ext=-1)) domain = AB.join(C, name='domain', bnd_minus=B.get_boundary(axis=0, ext=1), bnd_plus=C.get_boundary(axis=0, ext=-1)) # ... x, y = domain.coordinates V = ScalarFunctionSpace('V', domain, kind=None) assert (V.is_broken) u, v = elements_of(V, names='u, v') # ... I = domain.interfaces # print(I) # print(integral(I, jump(u) * jump(v))) # a = BilinearForm((u,v), integral(domain, u*v)) # a = BilinearForm((u,v), integral(domain, dot(grad(u),grad(v)))) # a = BilinearForm((u,v), integral(I, jump(u) * jump(v))) a = BilinearForm((u, v), integral(domain, dot(grad(u), grad(v))) + integral(I, jump(u) * jump(v))) expr = TerminalExpr(a) print(expr) # ... # ... linear forms b = LinearForm( v, integral(domain, sin(x + y) * v) + integral(I, cos(x + y) * jump(v))) expr = TerminalExpr(b) print(expr)
def test_field_2d_1(): print('============ test_field_2d_1 =============') # x, y = domain.coordinates W = VectorFunctionSpace('W', domain) F = element_of(W, 'F') assert (dx(F) == Matrix([[dx(F[0]), dx(F[1])]])) # TODO not working yet => check it for VectorFunction also # print(dx(x*F)) expr = inner(grad(F), grad(F)) print(expr)
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_equation_2d_5(): domain = Square() x, y = domain.coordinates f0 = Matrix([ 2 * pi**2 * sin(pi * x) * sin(pi * y), 2 * pi**2 * sin(pi * x) * sin(pi * y) ]) f1 = cos(pi * x) * cos(pi * y) W = VectorFunctionSpace('W', domain) V = ScalarFunctionSpace('V', domain) X = ProductSpace(W, V) F = element_of(W, name='F') G = element_of(V, name='G') u, v = [element_of(W, name=i) for i in ['u', 'v']] p, q = [element_of(V, name=i) for i in ['p', 'q']] int_0 = lambda expr: integral(domain, expr) a0 = BilinearForm((v, u), int_0(inner(grad(v), grad(u)))) print(' a0 done.') a1 = BilinearForm((q, p), int_0(p * q)) print(' a1 done.') a = BilinearForm(((v, q), (u, p)), a0(v, u) + a1(q, p)) print(' a done.') l0 = LinearForm(v, int_0(dot(f0, v))) l1 = LinearForm(q, int_0(f1 * q)) l = LinearForm((v, q), l0(v) + l1(q)) print('****************************') bc = EssentialBC(u, 0, domain.boundary) equation = Equation(a, l, tests=[v, q], trials=[u, p], bc=bc) # ... print('=======') print(equation.lhs.expr) print('') # ... # ... print('=======') print(equation.rhs.expr) print('')
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_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_expr_mapping_2d(): F = Mapping('F', DIM) patch = Domain('Omega', dim=DIM) domain = F(patch) V = FunctionSpace('V', domain) v = TestFunction(V, name='v') u = TestFunction(V, name='u') x, y = V.coordinates a = BilinearForm((v, u), dot(grad(v), grad(u))) assert (a.mapping is F) l = LinearForm(v, x * y * v) assert (l.mapping is F)
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_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_terminal_expr_linear_2d_5(boundary=[r'\Gamma_1', r'\Gamma_3']): # ... abstract model domain = Square() V = ScalarFunctionSpace('V', domain) B_neumann = [domain.get_boundary(i) for i in boundary] if len(B_neumann) == 1: B_neumann = B_neumann[0] else: B_neumann = Union(*B_neumann) x, y = domain.coordinates nn = NormalVector('nn') F = element_of(V, name='F') v = element_of(V, name='v') u = element_of(V, name='u') int_0 = lambda expr: integral(domain, expr) int_1 = lambda expr: integral(B_neumann, expr) expr = dot(grad(v), grad(u)) a = BilinearForm((v, u), int_0(expr)) solution = cos(0.5 * pi * x) * cos(0.5 * pi * y) f = (1. / 2.) * pi**2 * solution expr = f * v l0 = LinearForm(v, int_0(expr)) expr = v * dot(grad(solution), nn) l_B_neumann = LinearForm(v, int_1(expr)) expr = l0(v) + l_B_neumann(v) l = LinearForm(v, expr) print(TerminalExpr(l)) print('')
def test_interface_integral_2(): # ... A = Square('A') B = Square('B') domain = A.join(B, name='domain', bnd_minus=A.get_boundary(axis=0, ext=1), bnd_plus=B.get_boundary(axis=0, ext=-1)) # ... x, y = domain.coordinates V = ScalarFunctionSpace('V', domain, kind=None) assert (V.is_broken) u, u1, u2, u3 = elements_of(V, names='u, u1, u2, u3') v, v1, v2, v3 = elements_of(V, names='v, v1, v2, v3') # ... I = domain.interfaces a = BilinearForm((u, v), integral(domain, dot(grad(u), grad(v)))) b = BilinearForm((u, v), integral(I, jump(u) * jump(v))) A = BilinearForm(((u1, u2), (v1, v2)), a(u1, v1) + a(u2, v2) + b(u1, v1) + b(u2, v2) + b(u1, v2)) B = BilinearForm( ((u1, u2, u3), (v1, v2, v3)), a(u1, v1) + a(u2, v2) + a(u3, v3) + b(u1, v1) + b(u2, v2) + b(u1, v2)) print(TerminalExpr(A)) print(TerminalExpr(B)) # ... # ... linear forms b = LinearForm(v, integral(I, jump(v))) b = LinearForm((v1, v2), b(v1) + b(v2)) expr = TerminalExpr(b) print(expr)
def test_tensorize_2d_1(): domain = Domain('Omega', dim=2) 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), int_0(mu*u*v + dot(grad(u),grad(v)))) # a = BilinearForm((u,v), dot(grad(u),grad(v))) # a = BilinearForm((u,v), dx(u)*v) # a = BilinearForm((u,v), laplace(u)*laplace(v)) expr = TensorExpr(a, domain=domain) print(expr)
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_logical_expr_3d_2(): dim = 3 domain = Domain('Omega', dim=dim) M = Mapping('M', dim=dim) mapped_domain = M(domain) V = ScalarFunctionSpace('V', domain, kind='h1') VM = ScalarFunctionSpace('VM', mapped_domain, kind='h1') u, v = elements_of(V, names='u,v') um, vm = elements_of(VM, names='u,v') J = M.jacobian a = dot(grad(um), grad(vm)) e = LogicalExpr(a, mapping=M, dim=dim) assert e == dot(J.inv().T * grad(u), J.inv().T * grad(v))
def test_calls_2d_2(): domain = Square() V = FunctionSpace('V', domain) x, y = V.coordinates u, v = [TestFunction(V, name=i) for i in ['u', 'v']] Un = Field('Un', V) # ... a = BilinearForm((v, u), dot(grad(u), grad(v))) expr = a(v, Un) print(evaluate(expr, verbose=True)) # ... # ... l = LinearForm(v, a(v, Un)) print(evaluate(l, verbose=True))
def test_essential_bc_1(): domain = Domain('Omega', dim=2) V = ScalarFunctionSpace('V', domain) W = VectorFunctionSpace('W', domain) v = element_of(V, name='v') w = element_of(W, name='w') B1 = Boundary(r'\Gamma_1', domain) nn = NormalVector('nn') # ... scalar case bc = EssentialBC(v, 0, B1) assert (bc.variable == v) assert (bc.order == 0) assert (bc.normal_component == False) assert (bc.index_component == None) # ... # ... scalar case bc = EssentialBC(dot(grad(v), nn), 0, B1) assert (bc.variable == v) assert (bc.order == 1) assert (bc.normal_component == False) assert (bc.index_component == None) # ... # ... vector case bc = EssentialBC(w, 0, B1) assert (bc.variable == w) assert (bc.order == 0) assert (bc.normal_component == False) assert (bc.index_component == [0, 1]) # ... # ... vector case bc = EssentialBC(dot(w, nn), 0, B1) assert (bc.variable == w) assert (bc.order == 0) assert (bc.normal_component == True) assert (bc.index_component == None) # ... # ... vector case bc = EssentialBC(w[0], 0, B1) assert (bc.variable == w) assert (bc.order == 0) assert (bc.normal_component == False) assert (bc.index_component == [0])