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_terminal_expr_bilinear_3d_1(): domain = Domain('Omega', dim=3) M = Mapping('M', 3) mapped_domain = M(domain) V = ScalarFunctionSpace('V', domain) VM = ScalarFunctionSpace('VM', mapped_domain) u, v = elements_of(V, names='u,v') um, vm = elements_of(VM, names='u,v') int_0 = lambda expr: integral(domain, expr) int_1 = lambda expr: integral(mapped_domain, expr) J = M.det_jacobian det = dx1(M[0])*dx2(M[1])*dx3(M[2]) - dx1(M[0])*dx2(M[2])*dx3(M[1]) - dx1(M[1])*dx2(M[0])*dx3(M[2])\ + dx1(M[1])*dx2(M[2])*dx3(M[0]) + dx1(M[2])*dx2(M[0])*dx3(M[1]) - dx1(M[2])*dx2(M[1])*dx3(M[0]) a1 = BilinearForm((u, v), int_0(dot(grad(u), grad(v)))) a2 = BilinearForm((um, vm), int_1(dot(grad(um), grad(vm)))) a3 = BilinearForm((u, v), int_0(J * dot(grad(u), grad(v)))) e1 = TerminalExpr(a1) e2 = TerminalExpr(a2) e3 = TerminalExpr(a3) assert e1[0].expr == dx1(u) * dx1(v) + dx2(u) * dx2(v) + dx3(u) * dx3(v) assert e2[0].expr == dx(um) * dx(vm) + dy(um) * dy(vm) + dz(um) * dz(vm) assert e3[0].expr.factor() == (dx1(u) * dx1(v) + dx2(u) * dx2(v) + dx3(u) * dx3(v)) * det
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_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_tensorize_2d_1_mapping(): DIM = 2 M = Mapping('Map', DIM) domain = Domain('Omega', dim=DIM) B1 = Boundary(r'\Gamma_1', domain) x, y = domain.coordinates kappa = Constant('kappa', is_real=True) mu = Constant('mu', is_real=True) V = ScalarFunctionSpace('V', domain) u, v = elements_of(V, names='u, v') int_0 = lambda expr: integral(domain, expr) # ... # a = BilinearForm((u,v), u*v) # a = BilinearForm((u,v), mu*u*v + dot(grad(u),grad(v))) a = BilinearForm((u, v), int_0(dot(grad(u), grad(v)))) # a = BilinearForm((u,v), dx(u)*v) # a = BilinearForm((u,v), laplace(u)*laplace(v)) expr = TensorExpr(a, mapping=M) print(expr)
def test_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_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_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_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_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_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_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_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_area_2d_1(): domain = Domain('Omega', dim=2) x, y = domain.coordinates mu = Constant('mu', is_real=True) e = ElementDomain(domain) area = Area(e) V = ScalarFunctionSpace('V', domain) u, v = [element_of(V, name=i) for i in ['u', 'v']] int_0 = lambda expr: integral(domain, expr) # ... a = BilinearForm((v, u), int_0(area * u * v)) print(TerminalExpr(a))
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_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_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_1(): domain = Domain('Omega', dim=2) B1 = Boundary(r'\Gamma_1', domain) x, y = domain.coordinates kappa = Constant('kappa', is_real=True) mu = Constant('mu', is_real=True) eps = Constant('eps', real=True) V = FunctionSpace('V', domain) u, u1, u2 = [TestFunction(V, name=i) for i in ['u', 'u1', 'u2']] v, v1, v2 = [TestFunction(V, name=i) for i in ['v', 'v1', 'v2']] # ... d_forms = {} d_forms['a1'] = BilinearForm((u, v), u * v) d_forms['a2'] = BilinearForm((u, v), u * v + dot(grad(u), grad(v))) d_forms['a3'] = BilinearForm((u, v), v * trace_1(grad(u), B1)) # Poisson with Nitsch method a0 = BilinearForm((u, v), dot(grad(u), grad(v))) a_B1 = BilinearForm( (u, v), -kappa * u * trace_1(grad(v), B1) - v * trace_1(grad(u), B1) + trace_0(u, B1) * trace_0(v, B1) / eps) a = BilinearForm((u, v), a0(u, v) + a_B1(u, v)) d_forms['a4'] = a # ... # ... calls d_calls = {} for name, a in d_forms.items(): d_calls[name] = a(u1, v1) # ... # ... export forms for name, expr in d_forms.items(): export(expr, 'biform_2d_{}.png'.format(name)) # ... # ... export calls for name, expr in d_calls.items(): export(expr, 'biform_2d_call_{}.png'.format(name))
def test_stabilization_2d_1(): domain = Domain('Omega', dim=2) x, y = domain.coordinates kappa = Constant('kappa', is_real=True) mu = Constant('mu', is_real=True) b1 = 1. b2 = 0. b = Matrix((b1, b2)) # right hand side f = x * y e = ElementDomain() area = Area(e) V = ScalarFunctionSpace('V', domain) u, v = [element_of(V, name=i) for i in ['u', 'v']] int_0 = lambda expr: integral(domain, expr) # ... expr = kappa * dot(grad(u), grad(v)) + dot(b, grad(u)) * v a = BilinearForm((v, u), int_0(expr)) # ... # ... expr = f * v l = LinearForm(v, int_0(expr)) # ... # ... expr = (-kappa * laplace(u) + dot(b, grad(u))) * dot(b, grad(v)) s1 = BilinearForm((v, u), int_0(expr)) expr = -f * dot(b, grad(v)) l1 = LinearForm(v, int_0(expr)) # ... # ... expr = (-kappa * laplace(u) + dot(b, grad(u))) * (dot(b, grad(v)) - kappa * laplace(v)) s2 = BilinearForm((v, u), int_0(expr)) expr = -f * (dot(b, grad(v)) - kappa * laplace(v)) l2 = LinearForm(v, int_0(expr)) # ... # ... expr = (-kappa * laplace(u) + dot(b, grad(u))) * (dot(b, grad(v)) + kappa * laplace(v)) s3 = BilinearForm((v, u), int_0(expr)) expr = -f * (dot(b, grad(v)) + kappa * laplace(v)) l3 = LinearForm(v, int_0(expr)) # ... # ... expr = a(v, u) + mu * area * s1(v, u) a1 = BilinearForm((v, u), expr) # ... # ... expr = a(v, u) + mu * area * s2(v, u) a2 = BilinearForm((v, u), expr) # ... # ... expr = a(v, u) + mu * area * s3(v, u) a3 = BilinearForm((v, u), expr) # ... print(a1) print(TerminalExpr(a1)) print('') print(a2) print(TerminalExpr(a2)) print('') print(a3) print(TerminalExpr(a3)) print('')
def test_linearity_bilinear_form_2d_1(): from sympde.expr.errors import UnconsistentLinearExpressionError domain = Domain('Omega', dim=2) B1 = Boundary(r'\Gamma_1', domain) x, y = domain.coordinates kappa = Constant('kappa', is_real=True) mu = Constant('mu', is_real=True) eps = Constant('eps', real=True) nn = NormalVector('nn') V = ScalarFunctionSpace('V', domain) u, u1, u2 = elements_of(V, names='u, u1, u2') v, v1, v2 = elements_of(V, names='v, v1, v2') # ... int_0 = lambda expr: integral(domain, expr) int_1 = lambda expr: integral(B1, expr) # The following integral expressions are bilinear, hence it must be possible # to create BilinearForm objects from them _ = BilinearForm((u, v), int_0(u * v)) _ = BilinearForm((u, v), int_0(dot(grad(u), grad(v)))) _ = BilinearForm((u, v), int_0(u * v + dot(grad(u), grad(v)))) _ = BilinearForm( (u, v), int_0(u * v + dot(grad(u), grad(v))) + int_1(v * dot(grad(u), nn))) _ = BilinearForm(((u1, u2), (v1, v2)), int_0(u1 * v1 + u2 * v2)) a1 = BilinearForm((u1, v1), int_0(u1 * v1)) _ = BilinearForm((u, v), a1(u, v)) a1 = BilinearForm((u1, v1), int_0(u1 * v1)) a2 = BilinearForm((u2, v2), int_0(dot(grad(u2), grad(v2)))) _ = BilinearForm((u, v), a1(u, v) + a2(u, v)) a1 = BilinearForm((u1, v1), int_0(u1 * v1)) a2 = BilinearForm((u2, v2), int_0(dot(grad(u2), grad(v2)))) _ = BilinearForm((u, v), a1(u, v) + kappa * a2(u, v)) a1 = BilinearForm((u1, v1), int_0(u1 * v1)) a2 = BilinearForm((u2, v2), int_0(dot(grad(u2), grad(v2)))) a3 = BilinearForm((u, v), int_1(v * dot(grad(u), nn))) _ = BilinearForm((u, v), a1(u, v) + kappa * a2(u, v) + mu * a3(u, v)) # ... Poisson with Nitsch method a0 = BilinearForm((u, v), int_0(dot(grad(u), grad(v)))) a_B1 = BilinearForm((u, v), int_1(-kappa * u * dot(grad(v), nn) - v * dot(grad(u), nn) + u * v / eps)) _ = BilinearForm((u, v), a0(u, v) + a_B1(u, v)) # ... # The following integral expressions are not bilinear, hence BilinearForm must # raise an exception with pytest.raises(UnconsistentLinearExpressionError): _ = BilinearForm((u, v), int_0(x * y * dot(grad(u), grad(v)) + 1)) with pytest.raises(UnconsistentLinearExpressionError): _ = BilinearForm((u, v), int_0(x * dot(grad(u), grad(v**2)))) with pytest.raises(UnconsistentLinearExpressionError): _ = BilinearForm((u, v), int_0(u * v) + int_1(v * exp(u)))
def test_bilinear_form_2d_1(): domain = Domain('Omega', dim=2) B1 = Boundary(r'\Gamma_1', domain) x, y = domain.coordinates kappa = Constant('kappa', is_real=True) mu = Constant('mu', is_real=True) nn = NormalVector('nn') 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.domain == domain.interior) assert (a(u1, v1) == int_0(u1 * v1)) # ... # ... a = BilinearForm((u, v), int_0(u * v + dot(grad(u), grad(v)))) assert (a.domain == domain.interior) assert (a(u1, v1) == int_0(u1 * v1) + int_0(dot(grad(u1), grad(v1)))) # ... # ... a = BilinearForm((u, v), int_1(v * dot(grad(u), nn))) assert (a.domain == B1) assert (a(u1, v1) == int_1(v1 * trace_1(grad(u1), B1))) # ... # ... a = BilinearForm((u, v), int_0(u * v) + int_1(v * dot(grad(u), nn))) # TODO a.domain are not ordered assert (len(a.domain.args) == 2) for i in a.domain.args: assert (i in [domain.interior, B1]) assert (a(u1, v1) == int_0(u1 * v1) + int_1(v1 * trace_1(grad(u1), B1))) # ... # ... a1 = BilinearForm((u1, v1), int_0(u1 * v1)) a = BilinearForm((u, v), a1(u, v)) assert (a.domain == domain.interior) assert (a(u2, v2) == int_0(u2 * v2)) # ... # ... a1 = BilinearForm((u1, v1), int_0(u1 * v1)) a2 = BilinearForm((u2, v2), int_0(dot(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(u * v) + int_0(kappa * dot(grad(u), grad(v))))
def test_terminal_expr_bilinear_2d_3(): domain = Square() V = ScalarFunctionSpace('V', domain) B = domain.boundary v = element_of(V, name='v') u = element_of(V, name='u') kappa = Constant('kappa', is_real=True) mu = Constant('mu', is_real=True) nn = NormalVector('nn') int_0 = lambda expr: integral(domain, expr) int_1 = lambda expr: integral(B, expr) # nitsche a0 = BilinearForm((u, v), int_0(dot(grad(v), grad(u)))) a_B = BilinearForm((u,v), int_1(-u*dot(grad(v), nn) \ -v*dot(grad(u), nn) \ +kappa*u*v)) a = BilinearForm((u, v), a0(u, v) + a_B(u, v)) print(TerminalExpr(a)) print('') a = BilinearForm( (u, v), int_0(u * v + dot(grad(u), grad(v))) + int_1(v * dot(grad(u), nn))) print(TerminalExpr(a)) print('') # ... # ... a = BilinearForm((u, v), int_0(u * v)) print(TerminalExpr(a)) print('') # ... # ... a1 = BilinearForm((u, v), int_0(u * v)) a = BilinearForm((u, v), a1(u, v)) print(TerminalExpr(a)) print('') # ... # ... a1 = BilinearForm((u, v), int_0(u * v)) a2 = BilinearForm((u, v), int_0(dot(grad(u), grad(v)))) a = BilinearForm((u, v), a1(u, v) + a2(u, v)) print(TerminalExpr(a)) print('') # ... # ... a1 = BilinearForm((u, v), int_0(u * v)) a2 = BilinearForm((u, v), int_0(dot(grad(u), grad(v)))) a = BilinearForm((u, v), a1(u, v) + kappa * a2(u, v)) print(TerminalExpr(a)) print('') # ... # ... a1 = BilinearForm((u, v), int_0(u * v)) a2 = BilinearForm((u, v), int_0(dot(grad(u), grad(v)))) a3 = BilinearForm((u, v), int_1(v * dot(grad(u), nn))) a = BilinearForm((u, v), a1(u, v) + kappa * a2(u, v) + mu * a3(u, v)) print(TerminalExpr(a)) print('')
def test_terminal_expr_bilinear_2d_1(): domain = Domain('Omega', dim=2) B1 = Boundary(r'\Gamma_1', domain) x, y = domain.coordinates kappa = Constant('kappa', is_real=True) mu = Constant('mu', is_real=True) eps = Constant('eps', real=True) nn = NormalVector('nn') 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)) print(a) print(TerminalExpr(a)) print('') # ... # ... a = BilinearForm((u, v), int_0(dot(grad(u), grad(v)))) print(a) print(TerminalExpr(a)) print('') # ... # ... a = BilinearForm((u, v), int_0(u * v + dot(grad(u), grad(v)))) print(a) print(TerminalExpr(a)) print('') # ... # ... a = BilinearForm( (u, v), int_0(u * v + dot(grad(u), grad(v))) + int_1(v * dot(grad(u), nn))) print(a) print(TerminalExpr(a)) print('') # ... # ... a = BilinearForm(((u1, u2), (v1, v2)), int_0(u1 * v1 + u2 * v2)) print(a) print(TerminalExpr(a)) print('') # ... # ... a1 = BilinearForm((u1, v1), int_0(u1 * v1)) a = BilinearForm((u, v), a1(u, v)) print(a) print(TerminalExpr(a)) print('') # ... # ... a1 = BilinearForm((u1, v1), int_0(u1 * v1)) a2 = BilinearForm((u2, v2), int_0(dot(grad(u2), grad(v2)))) a = BilinearForm((u, v), a1(u, v) + a2(u, v)) print(a) print(TerminalExpr(a)) print('') # ... # ... a1 = BilinearForm((u1, v1), int_0(u1 * v1)) a2 = BilinearForm((u2, v2), int_0(dot(grad(u2), grad(v2)))) a = BilinearForm((u, v), a1(u, v) + kappa * a2(u, v)) print(a) print(TerminalExpr(a)) print('') # ... # ... a1 = BilinearForm((u1, v1), int_0(u1 * v1)) a2 = BilinearForm((u2, v2), int_0(dot(grad(u2), grad(v2)))) a3 = BilinearForm((u, v), int_1(v * dot(grad(u), nn))) a = BilinearForm((u, v), a1(u, v) + kappa * a2(u, v) + mu * a3(u, v)) print(a) print(TerminalExpr(a)) print('') # ... # ... Poisson with Nitsch method a0 = BilinearForm((u, v), int_0(dot(grad(u), grad(v)))) a_B1 = BilinearForm((u, v), int_1(-kappa * u * dot(grad(v), nn) - v * dot(grad(u), nn) + u * v / eps)) a = BilinearForm((u, v), a0(u, v) + a_B1(u, v)) print(a) print(TerminalExpr(a)) print('')
def eval(cls, expr, domain, **options): """.""" from sympde.expr.evaluation import TerminalExpr, DomainExpression from sympde.expr.expr import BilinearForm, LinearForm, BasicForm, Norm from sympde.expr.expr import Integral types = (ScalarFunction, VectorFunction, DifferentialOperator, Trace, Integral) mapping = domain.mapping dim = domain.dim assert mapping # TODO this is not the dim of the domain l_coords = ['x1', 'x2', 'x3'][:dim] ph_coords = ['x', 'y', 'z'] if not has(expr, types): if has(expr, DiffOperator): return cls(expr, domain, evaluate=False) else: syms = symbols(ph_coords[:dim]) if isinstance(mapping, InterfaceMapping): mapping = mapping.minus # here we assume that the two mapped domains # are identical in the interface so we choose one of them Ms = [mapping[i] for i in range(dim)] expr = expr.subs(list(zip(syms, Ms))) if mapping.is_analytical: expr = expr.subs(list(zip(Ms, mapping.expressions))) return expr if isinstance(expr, Symbol) and expr.name in l_coords: return expr if isinstance(expr, Symbol) and expr.name in ph_coords: return mapping[ph_coords.index(expr.name)] elif isinstance(expr, Add): args = [cls.eval(a, domain) for a in expr.args] v = S.Zero for i in args: v += i n, d = v.as_numer_denom() return n / d elif isinstance(expr, Mul): args = [cls.eval(a, domain) for a in expr.args] v = S.One for i in args: v *= i return v elif isinstance(expr, _logical_partial_derivatives): if mapping.is_analytical: Ms = [mapping[i] for i in range(dim)] expr = expr.subs(list(zip(Ms, mapping.expressions))) return expr elif isinstance(expr, IndexedVectorFunction): el = cls.eval(expr.base, domain) el = TerminalExpr(el, domain=domain.logical_domain) return el[expr.indices[0]] elif isinstance(expr, MinusInterfaceOperator): mapping = mapping.minus newexpr = PullBack(expr.args[0], mapping) test = newexpr.test newexpr = newexpr.expr.subs(test, MinusInterfaceOperator(test)) return newexpr elif isinstance(expr, PlusInterfaceOperator): mapping = mapping.plus newexpr = PullBack(expr.args[0], mapping) test = newexpr.test newexpr = newexpr.expr.subs(test, PlusInterfaceOperator(test)) return newexpr elif isinstance(expr, (VectorFunction, ScalarFunction)): return PullBack(expr, mapping).expr elif isinstance(expr, Transpose): arg = cls(expr.arg, domain) return Transpose(arg) elif isinstance(expr, grad): arg = expr.args[0] if isinstance(mapping, InterfaceMapping): if isinstance(arg, MinusInterfaceOperator): a = arg.args[0] mapping = mapping.minus elif isinstance(arg, PlusInterfaceOperator): a = arg.args[0] mapping = mapping.plus else: raise TypeError(arg) arg = type(arg)(cls.eval(a, domain)) else: arg = cls.eval(arg, domain) return mapping.jacobian.inv().T * grad(arg) elif isinstance(expr, curl): arg = expr.args[0] if isinstance(mapping, InterfaceMapping): if isinstance(arg, MinusInterfaceOperator): arg = arg.args[0] mapping = mapping.minus elif isinstance(arg, PlusInterfaceOperator): arg = arg.args[0] mapping = mapping.plus else: raise TypeError(arg) if isinstance(arg, VectorFunction): arg = PullBack(arg, mapping) else: arg = cls.eval(arg, domain) if isinstance(arg, PullBack) and isinstance( arg.kind, HcurlSpaceType): J = mapping.jacobian arg = arg.test if isinstance(expr.args[0], (MinusInterfaceOperator, PlusInterfaceOperator)): arg = type(expr.args[0])(arg) if expr.is_scalar: return (1 / J.det()) * curl(arg) return (J / J.det()) * curl(arg) else: raise NotImplementedError('TODO') elif isinstance(expr, div): arg = expr.args[0] if isinstance(mapping, InterfaceMapping): if isinstance(arg, MinusInterfaceOperator): arg = arg.args[0] mapping = mapping.minus elif isinstance(arg, PlusInterfaceOperator): arg = arg.args[0] mapping = mapping.plus else: raise TypeError(arg) if isinstance(arg, (ScalarFunction, VectorFunction)): arg = PullBack(arg, mapping) else: arg = cls.eval(arg, domain) if isinstance(arg, PullBack) and isinstance( arg.kind, HdivSpaceType): J = mapping.jacobian arg = arg.test if isinstance(expr.args[0], (MinusInterfaceOperator, PlusInterfaceOperator)): arg = type(expr.args[0])(arg) return (1 / J.det()) * div(arg) elif isinstance(arg, PullBack): return SymbolicTrace(mapping.jacobian.inv().T * grad(arg.test)) else: raise NotImplementedError('TODO') elif isinstance(expr, laplace): arg = expr.args[0] v = cls.eval(grad(arg), domain) v = mapping.jacobian.inv().T * grad(v) return SymbolicTrace(v) # elif isinstance(expr, hessian): # arg = expr.args[0] # if isinstance(mapping, InterfaceMapping): # if isinstance(arg, MinusInterfaceOperator): # arg = arg.args[0] # mapping = mapping.minus # elif isinstance(arg, PlusInterfaceOperator): # arg = arg.args[0] # mapping = mapping.plus # else: # raise TypeError(arg) # v = cls.eval(grad(expr.args[0]), domain) # v = mapping.jacobian.inv().T*grad(v) # return v elif isinstance(expr, (dot, inner, outer)): args = [cls.eval(arg, domain) for arg in expr.args] return type(expr)(*args) elif isinstance(expr, _diff_ops): raise NotImplementedError('TODO') # TODO MUST BE MOVED AFTER TREATING THE CASES OF GRAD, CURL, DIV IN FEEC elif isinstance(expr, (Matrix, ImmutableDenseMatrix)): n_rows, n_cols = expr.shape lines = [] for i_row in range(0, n_rows): line = [] for i_col in range(0, n_cols): line.append(cls.eval(expr[i_row, i_col], domain)) lines.append(line) return type(expr)(lines) elif isinstance(expr, dx): if expr.atoms(PlusInterfaceOperator): mapping = mapping.plus elif expr.atoms(MinusInterfaceOperator): mapping = mapping.minus arg = expr.args[0] arg = cls(arg, domain, evaluate=True) if isinstance(arg, PullBack): arg = TerminalExpr(arg, domain=domain.logical_domain) elif isinstance(arg, MatrixElement): arg = TerminalExpr(arg, domain=domain.logical_domain) # ... if dim == 1: lgrad_arg = LogicalGrad_1d(arg) if not isinstance(lgrad_arg, (list, tuple, Tuple, Matrix)): lgrad_arg = Tuple(lgrad_arg) elif dim == 2: lgrad_arg = LogicalGrad_2d(arg) elif dim == 3: lgrad_arg = LogicalGrad_3d(arg) grad_arg = Covariant(mapping, lgrad_arg) expr = grad_arg[0] return expr elif isinstance(expr, dy): if expr.atoms(PlusInterfaceOperator): mapping = mapping.plus elif expr.atoms(MinusInterfaceOperator): mapping = mapping.minus arg = expr.args[0] arg = cls(arg, domain, evaluate=True) if isinstance(arg, PullBack): arg = TerminalExpr(arg, domain=domain.logical_domain) elif isinstance(arg, MatrixElement): arg = TerminalExpr(arg, domain=domain.logical_domain) # ..p if dim == 1: lgrad_arg = LogicalGrad_1d(arg) elif dim == 2: lgrad_arg = LogicalGrad_2d(arg) elif dim == 3: lgrad_arg = LogicalGrad_3d(arg) grad_arg = Covariant(mapping, lgrad_arg) expr = grad_arg[1] return expr elif isinstance(expr, dz): if expr.atoms(PlusInterfaceOperator): mapping = mapping.plus elif expr.atoms(MinusInterfaceOperator): mapping = mapping.minus arg = expr.args[0] arg = cls(arg, domain, evaluate=True) if isinstance(arg, PullBack): arg = TerminalExpr(arg, domain=domain.logical_domain) elif isinstance(arg, MatrixElement): arg = TerminalExpr(arg, domain=domain.logical_domain) # ... if dim == 1: lgrad_arg = LogicalGrad_1d(arg) elif dim == 2: lgrad_arg = LogicalGrad_2d(arg) elif dim == 3: lgrad_arg = LogicalGrad_3d(arg) grad_arg = Covariant(mapping, lgrad_arg) expr = grad_arg[2] return expr elif isinstance(expr, (Symbol, Indexed)): return expr elif isinstance(expr, NormalVector): return expr elif isinstance(expr, Pow): b = expr.base e = expr.exp expr = Pow(cls(b, domain), cls(e, domain)) return expr elif isinstance(expr, Trace): e = cls.eval(expr.expr, domain) bd = expr.boundary.logical_domain order = expr.order return Trace(e, bd, order) elif isinstance(expr, Integral): domain = expr.domain mapping = domain.mapping assert domain is not None if expr.is_domain_integral: J = mapping.jacobian det = sqrt((J.T * J).det()) else: axis = domain.axis J = JacobianSymbol(mapping, axis=axis) det = sqrt((J.T * J).det()) body = cls.eval(expr.expr, domain) * det domain = domain.logical_domain return Integral(body, domain) elif isinstance(expr, BilinearForm): tests = [get_logical_test_function(a) for a in expr.test_functions] trials = [ get_logical_test_function(a) for a in expr.trial_functions ] body = cls.eval(expr.expr, domain) return BilinearForm((trials, tests), body) elif isinstance(expr, LinearForm): tests = [get_logical_test_function(a) for a in expr.test_functions] body = cls.eval(expr.expr, domain) return LinearForm(tests, body) elif isinstance(expr, Norm): kind = expr.kind exponent = expr.exponent e = cls.eval(expr.expr, domain) domain = domain.logical_domain norm = Norm(e, domain, kind, evaluate=False) norm._exponent = exponent return norm elif isinstance(expr, DomainExpression): domain = expr.target J = domain.mapping.jacobian newexpr = cls.eval(expr.expr, domain) newexpr = TerminalExpr(newexpr, domain=domain) domain = domain.logical_domain det = TerminalExpr(sqrt((J.T * J).det()), domain=domain) return DomainExpression(domain, ImmutableDenseMatrix([[newexpr * det]])) elif isinstance(expr, Function): args = [cls.eval(a, domain) for a in expr.args] return type(expr)(*args) return cls(expr, domain, evaluate=False)