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_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_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 = Matrix((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_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_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_latex_2d_3(): DIM = 2 domain = Domain('Omega', dim=DIM) B1 = Boundary(r'\Gamma_1', domain) B2 = Boundary(r'\Gamma_2', domain) B3 = Boundary(r'\Gamma_3', domain) V = ScalarFunctionSpace('V', domain) x = V.coordinates v = element_of(V, name='v') u = element_of(V, name='u') int_0 = lambda expr: integral(domain, expr) int_1 = lambda expr: integral(B1, expr) # ... expr = dot(grad(v), grad(u)) a_0 = BilinearForm((v, u), int_0(expr)) expr = v * u a_bnd = BilinearForm((v, u), int_1(expr)) expr = a_0(v, u) + a_bnd(v, u) a = BilinearForm((v, u), expr) print(latex(a_0)) print(latex(a_bnd)) print(latex(a)) # print(a) print('')
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_newton_2d_1(): # ... abstract model B1 = Boundary(r'\Gamma_1', domain) V = ScalarFunctionSpace('V', domain) x, y = domain.coordinates Un = element_of(V, name='Un') v = element_of(V, name='v') int_0 = lambda expr: integral(domain, expr) f = -4. * exp(-Un) l = LinearForm(v, int_0(dot(grad(v), grad(Un)) - f * v)) u = element_of(V, name='u') eq = NewtonIteration(l, Un, trials=u) # ... # ... expected = int_0(-4.0 * u * v * exp(-Un) + dot(grad(u), grad(v))) assert (eq.lhs.expr == expected) # ... # ... bc = EssentialBC(u, 0, B1) eq = NewtonIteration(l, Un, bc=bc, trials=u)
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_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 = Tuple(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_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_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_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_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_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])
def test_space_2d_1(): DIM = 2 domain = Domain('Omega', dim=DIM) V1 = ScalarFunctionSpace('V1', domain) V2 = ScalarFunctionSpace('V2', domain) V3 = ScalarFunctionSpace('V3', domain) U1 = ScalarFunctionSpace('U1', domain) U2 = ScalarFunctionSpace('U2', domain) U3 = VectorFunctionSpace('U3', domain) # ... V = V1 * V2 * V3 assert (V.ldim == DIM) assert (V.shape == 3) assert (V.name == 'V1V2V3') # ... # ... U = U1 * U2 * U3 assert (U.ldim == DIM) assert (U.shape == 4) assert (U.name == 'U1U2U3') # ... # ... v1, v2, v3 = element_of(V, 'v1, v2, v3') assert (isinstance(v1, ScalarTestFunction)) assert (isinstance(v2, ScalarTestFunction)) assert (isinstance(v3, ScalarTestFunction)) assert (v1.space is V1) assert (v2.space is V2) assert (v3.space is V3) assert (v1.name == 'v1') assert (v2.name == 'v2') assert (v3.name == 'v3') # ... # ... u1, u2, u3 = element_of(U, 'u1, u2, u3') assert (isinstance(u1, ScalarTestFunction)) assert (isinstance(u2, ScalarTestFunction)) assert (isinstance(u3, VectorTestFunction)) assert (u1.name == 'u1') assert (u2.name == 'u2') assert (u3.name == 'u3')
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_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_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_logical_expr_2d_3(): dim = 2 A = Square('A') B = Square('B') M1 = Mapping('M1', dim=dim) M2 = Mapping('M2', dim=dim) D1 = M1(A) D2 = M2(B) domain = D1.join(D2, name='domain', bnd_minus=D1.get_boundary(axis=0, ext=1), bnd_plus=D2.get_boundary(axis=0, ext=-1)) V = VectorFunctionSpace('V', domain, kind='hcurl') u, v = [element_of(V, name=i) for i in ['u', 'v']] int_0 = lambda expr: integral(domain, expr) expr = LogicalExpr(int_0(dot(u, v)), domain) assert str( expr.args[0] ) == 'Integral(A, Dot((Jacobian(M1)**(-1)).T * u, (Jacobian(M1)**(-1)).T * v)*sqrt(det(Jacobian(M1).T * Jacobian(M1))))' assert str( expr.args[1] ) == 'Integral(B, Dot((Jacobian(M2)**(-1)).T * u, (Jacobian(M2)**(-1)).T * v)*sqrt(det(Jacobian(M2).T * Jacobian(M2))))'
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_derivatives_2d_with_mapping(): dim = 2 M = Mapping('M', dim=dim) O = M(Domain('Omega', dim=dim)) V = ScalarFunctionSpace('V', O, kind='h1') u = element_of(V, 'u') det_jac = Jacobian(M).det() J = Symbol('J') expr = M assert SymbolicExpr(expr) == Symbol('M') expr = M[0] assert SymbolicExpr(expr) == Symbol('x') expr = M[1] assert SymbolicExpr(expr) == Symbol('y') expr = dx2(M[0]) assert SymbolicExpr(expr) == Symbol('x_x2') expr = dx1(M[1]) assert SymbolicExpr(expr) == Symbol('y_x1') expr = LogicalExpr(dx(u), O).subs(det_jac, J) expected = '(u_x1 * y_x2 - u_x2 * y_x1)/J' difference = SymbolicExpr(expr) - sympify(expected) assert difference.simplify() == 0
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_latex_ec_3d_1(): n = 3 # ... u_0 = DifferentialForm('u_0', index=0, dim=n) v_0 = DifferentialForm('v_0', index=0, dim=n) u_1 = DifferentialForm('u_1', index=1, dim=n) v_1 = DifferentialForm('v_1', index=1, dim=n) u_2 = DifferentialForm('u_2', index=2, dim=n) v_2 = DifferentialForm('v_2', index=2, dim=n) u_3 = DifferentialForm('u_3', index=3, dim=n) v_3 = DifferentialForm('v_3', index=3, dim=n) # ... # ... domain = Domain('Omega', dim=3) V = VectorFunctionSpace('V', domain) beta = element_of(V, 'beta') # ... print(latex(u_0)) print(latex(d(u_0))) print(latex(d(delta(u_3)))) print(latex(d(delta(u_2)) + delta(d(u_2)))) print(latex(wedge(u_0, u_1))) print(latex(ip(beta, u_1))) print(latex(hodge(u_1))) print(latex(jp(beta, u_1)))
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_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]))