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_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_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_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_bilinear_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']] # ... a = BilinearExpr((u,v), u*v) print(a) print(a.expr) print(a(u1,v1)) # TODO # print(a(u1+u2,v1+v2)) print('') # ... # ... a1 = BilinearExpr((u,v), u*v) a2 = BilinearExpr((u,v), dot(grad(u),grad(v))) print(a1(u1,v1) + a2(u2,v2)) 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_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_bilinear_form_2d_3(): 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 = 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']] int_0 = lambda expr: integral(domain , expr) int_1 = lambda expr: integral(B1, expr) # ... a = BilinearForm((u,v), int_0(u*v)) assert(a.is_symmetric) # ... # ... a = BilinearForm((u,v), int_0(dot(grad(u), grad(v)))) assert(a.is_symmetric)
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_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_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_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_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_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_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_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_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_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_identity_mapping_2d_2(): dim = 2 M = IdentityMapping('F', dim=dim) domain = M(Domain('Omega', dim=dim)) V = ScalarFunctionSpace('V', domain, kind='h1') u = element_of(V, name='u') # ... assert (LogicalExpr(dx(u), domain) == dx1(u)) assert (LogicalExpr(dy(u), domain) == dx2(u))
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_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_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_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_linearize_form_2d_1(): domain = Domain('Omega', dim=2) V = ScalarFunctionSpace('V', domain) W = VectorFunctionSpace('W', domain) v, F, u = elements_of(V, names='v, F, u') w, G, m = elements_of(W, names='w, G, m') int_0 = lambda expr: integral(domain, expr) # ... l = LinearForm(v, int_0(F**2 * v)) a = linearize(l, F, trials=u) assert a(u, v) == int_0(2 * F * u * v) # ... # ... l = LinearForm(v, int_0(dot(grad(F), grad(F)) * v)) a = linearize(l, F, trials=u) assert a(u, v) == int_0(2 * dot(grad(F), grad(u)) * v) # ... # ... l = LinearForm(v, int_0(exp(-F) * v)) a = linearize(l, F, trials=u) assert a(u, v) == int_0(-exp(-F) * u * v) # ... # ... l = LinearForm(v, int_0(cos(F) * v)) a = linearize(l, F, trials=u) assert a(u, v) == int_0(-sin(F) * u * v) # ... # ... l = LinearForm(v, int_0(cos(F**2) * v)) a = linearize(l, F, trials=u) assert a(u, v) == int_0(-2 * F * sin(F**2) * u * v) # ... # ... l = LinearForm(v, int_0(F**2 * dot(grad(F), grad(v)))) a = linearize(l, F, trials=u) assert a(u, v) == int_0(2 * F * u * dot(grad(F), grad(v)) + F**2 * dot(grad(u), grad(v))) # ... # ... l = LinearForm(w, int_0(dot(rot(G), grad(G)) * w)) a = linearize(l, G, trials=m) assert a(m, w) == int_0((dot(rot(m), grad(G)) + dot(rot(G), grad(m))) * w)
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_space_2d_2(): DIM = 2 domain = Domain('Omega', dim=DIM) 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) assert (H1.kind == H1Space) assert (Hcurl.kind == HcurlSpace) assert (Hdiv.kind == HdivSpace) assert (L2.kind == L2Space) assert (V.kind == UndefinedSpace) assert (W.kind == UndefinedSpace) assert (H1.regularity > L2.regularity) assert (H1.regularity > Hcurl.regularity) assert (Hcurl.regularity > L2.regularity)
def test_identity_mapping_2d_2(): rdim = 2 x1, x2 = symbols('x1, x2') M = IdentityMapping('F', rdim) domain = M(Domain('Omega', dim=rdim)) V = ScalarFunctionSpace('V', domain, kind='h1') u = element_of(V, name='u') # ... assert (LogicalExpr(dx(u), mapping=M, dim=rdim, subs=True) == dx1(u)) assert (LogicalExpr(dy(u), mapping=M, dim=rdim, subs=True) == dx2(u))
def test_identity_mapping_2d_2(): rdim = 2 x1, x2 = symbols('x1, x2') domain = Domain('Omega', dim=rdim) M = IdentityMapping('F', rdim) V = ScalarFunctionSpace('V', domain) u = element_of(V, name='u') # ... assert (LogicalExpr(M, dx(u)) == dx1(u)) assert (LogicalExpr(M, dy(u)) == dx2(u))
def test_logical_expr_3d_1(): rdim = 3 M = Mapping('M', rdim) domain = Domain('Omega', dim=rdim) alpha = Constant('alpha') V = ScalarFunctionSpace('V', domain) u, v = [element_of(V, name=i) for i in ['u', 'v']] det_M = DetJacobian(M) #print('det = ', det_M) det = Symbol('det') # ... expr = 2 * u + alpha * v expr = LogicalExpr(M, expr) #print(expr) #print('') # ... # ... expr = dx(u) expr = LogicalExpr(M, expr) #print(expr.subs(det_M, det)) #print('') # ... # ... expr = dy(u) expr = LogicalExpr(M, expr) #print(expr.subs(det_M, det)) #print('') # ... # ... expr = dx(det_M) expr = LogicalExpr(M, expr) expr = expr.subs(det_M, det) expr = expand(expr) #print(expr) #print('') # ... # ... expr = dx(dx(u)) expr = LogicalExpr(M, expr)
def test_logical_expr_3d_1(): dim = 3 M = Mapping('M', dim=dim) domain = M(Domain('Omega', dim=dim)) alpha = Constant('alpha') V = ScalarFunctionSpace('V', domain, kind='h1') u, v = [element_of(V, name=i) for i in ['u', 'v']] det_M = Jacobian(M).det() #print('det = ', det_M) det = Symbol('det') # ... expr = 2 * u + alpha * v expr = LogicalExpr(expr, domain) #print(expr) #print('') # ... # ... expr = dx(u) expr = LogicalExpr(expr, domain) #print(expr.subs(det_M, det)) #print('') # ... # ... expr = dy(u) expr = LogicalExpr(expr, domain) #print(expr.subs(det_M, det)) #print('') # ... # ... expr = dx(det_M) expr = LogicalExpr(expr, domain) expr = expr.subs(det_M, det) #print(expr) #print('') # ... # ... expr = dx(dx(u)) expr = LogicalExpr(expr, domain)