def test_adjoint(): cell = triangle V1 = FiniteElement("CG", cell, 1) V2 = FiniteElement("CG", cell, 2) u = TrialFunction(V1) v = TestFunction(V2) assert u.number() > v.number() u2 = Argument(V1, 2) v2 = Argument(V2, 3) assert u2.number() < v2.number() a = u * v * dx a_arg_degrees = [arg.ufl_element().degree() for arg in extract_arguments(a)] assert a_arg_degrees == [2, 1] b = adjoint(a) b_arg_degrees = [arg.ufl_element().degree() for arg in extract_arguments(b)] assert b_arg_degrees == [1, 2] c = adjoint(a, (u2, v2)) c_arg_degrees = [arg.ufl_element().degree() for arg in extract_arguments(c)] assert c_arg_degrees == [1, 2] d = adjoint(b) d_arg_degrees = [arg.ufl_element().degree() for arg in extract_arguments(d)] assert d_arg_degrees == [2, 1]
def test_expr(): from ufl import triangle, FiniteElement, TestFunction, TrialFunction, Coefficient element = FiniteElement("CG", triangle, 1) v = TestFunction(element) u = TrialFunction(element) f = Coefficient(element) g = Coefficient(element) expr = (f+g)*u.dx(0)*(g-1)*v return expr
def test_expr(): from ufl import triangle, FiniteElement, TestFunction, TrialFunction, Coefficient element = FiniteElement("CG", triangle, 1) v = TestFunction(element) u = TrialFunction(element) f = Coefficient(element) g = Coefficient(element) expr = (f + g) * u.dx(0) * (g - 1) * v return expr
def test_lhs_rhs_simple(): """Test taking lhs/rhs of DOLFINX specific forms (constants without cell). """ mesh = RectangleMesh( MPI.COMM_WORLD, [numpy.array([0.0, 0.0, 0.0]), numpy.array([2.0, 1.0, 0.0])], [3, 5], CellType.triangle) V = FunctionSpace(mesh, "CG", 1) f = 2.0 g = 3.0 v = TestFunction(V) u = TrialFunction(V) F = inner(g * grad(f * v), grad(u)) * dx + f * v * dx a, L = system(F) Fl = lhs(F) Fr = rhs(F) assert (Fr) a0 = inner(grad(v), grad(u)) * dx n = assemble(a).norm("frobenius") # noqa nl = assemble(Fl).norm("frobenius") # noqa n0 = 6.0 * assemble(a0).norm("frobenius") # noqa assert round(n - n0, 7) == 0 assert round(n - nl, 7) == 0
def project(v, V, dx_, bcs=[], nm=None): w = TestFunction(V) Pv = TrialFunction(V) a, L = as_ufl(0), as_ufl(0) zerofnc = Function(V) for n in range(len(dx_)): # check if we have passed in a list of functions or a function if isinstance(v, list): fnc = v[n] else: fnc = v if not isinstance(fnc, constantvalue.Zero): a += inner(w, Pv) * dx_[n] L += inner(w, fnc) * dx_[n] else: a += inner(w, Pv) * dx_[n] L += inner(w, zerofnc) * dx_[n] # solve linear system for projection function = Function(V, name=nm) lp = LinearProblem(a, L, bcs=bcs, u=function) lp.solve() return function
def test_krylov_solver_lu(): mesh = UnitSquareMesh(MPI.COMM_WORLD, 12, 12) V = FunctionSpace(mesh, ("Lagrange", 1)) u, v = TrialFunction(V), TestFunction(V) a = inner(u, v) * dx L = inner(1.0, v) * dx A = assemble_matrix(a) A.assemble() b = assemble_vector(L) b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE) norm = 13.0 solver = PETSc.KSP().create(mesh.mpi_comm()) solver.setOptionsPrefix("test_lu_") opts = PETSc.Options("test_lu_") opts["ksp_type"] = "preonly" opts["pc_type"] = "lu" solver.setFromOptions() x = A.createVecRight() solver.setOperators(A) solver.solve(b, x) # *Tight* tolerance for LU solves assert x.norm(PETSc.NormType.N2) == pytest.approx(norm, abs=1.0e-12)
def test_nullspace_check(mesh, degree): V = VectorFunctionSpace(mesh, ('Lagrange', degree)) u, v = TrialFunction(V), TestFunction(V) E, nu = 2.0e2, 0.3 mu = E / (2.0 * (1.0 + nu)) lmbda = E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu)) def sigma(w, gdim): return 2.0 * mu * ufl.sym(grad(w)) + lmbda * ufl.tr( grad(w)) * ufl.Identity(gdim) a = inner(sigma(u, mesh.geometry.dim), grad(v)) * dx # Assemble matrix and create compatible vector A = assemble_matrix(a) A.assemble() # Create null space basis and test null_space = build_elastic_nullspace(V) assert null_space.in_nullspace(A, tol=1.0e-8) null_space.orthonormalize() assert null_space.in_nullspace(A, tol=1.0e-8) # Create incorrect null space basis and test null_space = build_broken_elastic_nullspace(V) assert not null_space.in_nullspace(A, tol=1.0e-8) null_space.orthonormalize() assert not null_space.in_nullspace(A, tol=1.0e-8)
def run_scalar_test(mesh, V, degree): """ Manufactured Poisson problem, solving u = x[1]**p, where p is the degree of the Lagrange function space. """ u, v = TrialFunction(V), TestFunction(V) a = inner(grad(u), grad(v)) * dx # Get quadrature degree for bilinear form integrand (ignores effect of non-affine map) a = inner(grad(u), grad(v)) * dx(metadata={"quadrature_degree": -1}) a.integrals()[0].metadata( )["quadrature_degree"] = ufl.algorithms.estimate_total_polynomial_degree(a) a = form(a) # Source term x = SpatialCoordinate(mesh) u_exact = x[1]**degree f = -div(grad(u_exact)) # Set quadrature degree for linear form integrand (ignores effect of non-affine map) L = inner(f, v) * dx(metadata={"quadrature_degree": -1}) L.integrals()[0].metadata( )["quadrature_degree"] = ufl.algorithms.estimate_total_polynomial_degree(L) L = form(L) u_bc = Function(V) u_bc.interpolate(lambda x: x[1]**degree) # Create Dirichlet boundary condition facetdim = mesh.topology.dim - 1 mesh.topology.create_connectivity(facetdim, mesh.topology.dim) bndry_facets = np.where( np.array(compute_boundary_facets(mesh.topology)) == 1)[0] bdofs = locate_dofs_topological(V, facetdim, bndry_facets) bc = dirichletbc(u_bc, bdofs) b = assemble_vector(L) apply_lifting(b, [a], bcs=[[bc]]) b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE) set_bc(b, [bc]) a = form(a) A = assemble_matrix(a, bcs=[bc]) A.assemble() # Create LU linear solver solver = PETSc.KSP().create(MPI.COMM_WORLD) solver.setType(PETSc.KSP.Type.PREONLY) solver.getPC().setType(PETSc.PC.Type.LU) solver.setOperators(A) uh = Function(V) solver.solve(b, uh.vector) uh.x.scatter_forward() M = (u_exact - uh)**2 * dx M = form(M) error = mesh.comm.allreduce(assemble_scalar(M), op=MPI.SUM) assert np.absolute(error) < 1.0e-14
def amg_solve(N, method): # Elasticity parameters E = 1.0e9 nu = 0.3 mu = E / (2.0 * (1.0 + nu)) lmbda = E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu)) # Stress computation def sigma(v): return 2.0 * mu * sym(grad(v)) + lmbda * tr(sym( grad(v))) * Identity(2) # Define problem mesh = create_unit_square(MPI.COMM_WORLD, N, N) V = VectorFunctionSpace(mesh, 'Lagrange', 1) u = TrialFunction(V) v = TestFunction(V) facetdim = mesh.topology.dim - 1 bndry_facets = locate_entities_boundary( mesh, facetdim, lambda x: np.full(x.shape[1], True)) bdofs = locate_dofs_topological(V.sub(0), V, facetdim, bndry_facets) bc = dirichletbc(PETSc.ScalarType(0), bdofs, V.sub(0)) # Forms a, L = inner(sigma(u), grad(v)) * dx, dot(ufl.as_vector( (1.0, 1.0)), v) * dx # Assemble linear algebra objects A = assemble_matrix(a, [bc]) A.assemble() b = assemble_vector(L) apply_lifting(b, [a], [[bc]]) b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE) set_bc(b, [bc]) # Create solution function u = Function(V) # Create near null space basis and orthonormalize null_space = build_nullspace(V, u.vector) # Attached near-null space to matrix A.set_near_nullspace(null_space) # Test that basis is orthonormal assert null_space.is_orthonormal() # Create PETSC smoothed aggregation AMG preconditioner, and # create CG solver solver = PETSc.KSP().create(mesh.comm) solver.setType("cg") # Set matrix operator solver.setOperators(A) # Compute solution and return number of iterations return solver.solve(b, u.vector)
def __init__(self, F, u, bc): V = u.function_space du = TrialFunction(V) self.L = form(F) self.a = form(derivative(F, u, du)) self.bc = bc self._F, self._J = None, None self.u = u
def __init__(self, F, u, bc): super().__init__() V = u.function_space du = TrialFunction(V) self.L = F self.a = derivative(F, u, du) self.bc = bc self._F, self._J = None, None
def mass_dg(cell, degree): m = Mesh(VectorElement('Q', cell, 1)) V = FunctionSpace(m, FiniteElement('DQ', cell, degree, variant='spectral')) u = TrialFunction(V) v = TestFunction(V) # In this case, the estimated quadrature degree will give the # correct number of quadrature points by luck. return u * v * dx
def test_mini(): m = Mesh(VectorElement('CG', triangle, 1)) P1 = FiniteElement('Lagrange', triangle, 1) B = FiniteElement("Bubble", triangle, 3) V = FunctionSpace(m, VectorElement(P1 + B)) u = TrialFunction(V) v = TestFunction(V) a = inner(grad(u), grad(v)) * dx count_flops(a)
def __init__(self, F, u, bc): V = u.function_space du = TrialFunction(V) self.L = F self.a = derivative(F, u, du) self.a_comp = dolfinx.fem.Form(self.a) self.bc = bc self._F, self._J = None, None self.u = u
def test_cell_error(cell, degree): """Test that tabulating the trace element deliberatly on the cell triggers `gem.Failure` to raise the TraceError exception. """ trace_element = FiniteElement("HDiv Trace", cell, degree) lambdar = TrialFunction(trace_element) gammar = TestFunction(trace_element) with pytest.raises(TraceError): compile_form(lambdar * gammar * dx)
def test_compute_form_adjoint(self): cell = triangle element = FiniteElement('Lagrange', cell, 1) u = TrialFunction(element) v = TestFunction(element) a = inner(grad(u), grad(v)) * dx assert compute_form_adjoint(a) == conj(inner(grad(v), grad(u))) * dx
def elasticity(cell, degree): m = Mesh(VectorElement('CG', cell, 1)) V = FunctionSpace(m, VectorElement('CG', cell, degree)) u = TrialFunction(V) v = TestFunction(V) def eps(u): return 0.5 * (grad(u) + grad(u).T) return inner(eps(u), eps(v)) * dx
def test_automatic_simplification(self): cell = triangle element = FiniteElement("Lagrange", cell, 1) v = TestFunction(element) u = TrialFunction(element) assert inner(u, v) == u * conj(v) assert dot(u, v) == u * v assert outer(u, v) == conj(u) * v
def test_gradient_error(cell, degree): """Test that tabulating gradient evaluations of the trace element triggers `gem.Failure` to raise the TraceError exception. """ trace_element = FiniteElement("HDiv Trace", cell, degree) lambdar = TrialFunction(trace_element) gammar = TestFunction(trace_element) with pytest.raises(TraceError): compile_form(inner(grad(lambdar('+')), grad(gammar('+'))) * dS)
def test_plus_minus_matrix(cell_type, pm1, pm2): """Test that ('+') and ('-') match up with the correct DOFs for DG functions""" results = [] spaces = [] orders = [] for count in range(3): for agree in [True, False]: # Two cell mesh with randomly numbered points mesh, order = two_unit_cells(cell_type, agree, return_order=True) V = FunctionSpace(mesh, ("DG", 1)) u, v = TrialFunction(V), TestFunction(V) # Assemble matrices with combinations of + and - for a few # different numberings a = inner(u(pm1), v(pm2)) * dS result = fem.assemble_matrix(a, []) result.assemble() spaces.append(V) results.append(result) orders.append(order) # Check that the above matrices all have the same values, but # permuted due to differently ordered dofs dofmap0 = spaces[0].mesh.geometry.dofmap for result, space in zip(results[1:], spaces[1:]): # Get the data relating to two results dofmap1 = space.mesh.geometry.dofmap dof_order = [] # For each cell for cell in range(2): # For each point in cell 0 in the the first mesh for dof0, point0 in zip(spaces[0].dofmap.cell_dofs(cell), dofmap0.links(cell)): # Find the point in the cell 0 in the second mesh for dof1, point1 in zip(space.dofmap.cell_dofs(cell), dofmap1.links(cell)): if np.allclose(spaces[0].mesh.geometry.x[point0], space.mesh.geometry.x[point1]): break else: # If no matching point found, fail assert False dof_order.append((dof0, dof1)) # For all dof pairs, check that entries in the matrix agree for a, b in dof_order: for c, d in dof_order: assert np.isclose(results[0][a, c], result[b, d])
def test_extract_elements_and_extract_unique_elements(forms): b = forms[2] integrals = b.integrals_by_type("cell") integrand = integrals[0].integrand() element1 = FiniteElement("CG", triangle, 1) element2 = FiniteElement("CG", triangle, 1) v = TestFunction(element1) u = TrialFunction(element2) a = u * v * dx assert extract_elements(a) == (element1, element2) assert extract_unique_elements(a) == (element1, )
def test_adjoint(): cell = triangle V1 = FiniteElement("CG", cell, 1) V2 = FiniteElement("CG", cell, 2) u = TrialFunction(V1) v = TestFunction(V2) assert u.number() > v.number() u2 = Argument(V1, 2) v2 = Argument(V2, 3) assert u2.number() < v2.number() a = u * v * dx a_arg_degrees = [ arg.ufl_element().degree() for arg in extract_arguments(a) ] assert a_arg_degrees == [2, 1] b = adjoint(a) b_arg_degrees = [ arg.ufl_element().degree() for arg in extract_arguments(b) ] assert b_arg_degrees == [1, 2] c = adjoint(a, (u2, v2)) c_arg_degrees = [ arg.ufl_element().degree() for arg in extract_arguments(c) ] assert c_arg_degrees == [1, 2] d = adjoint(b) d_arg_degrees = [ arg.ufl_element().degree() for arg in extract_arguments(d) ] assert d_arg_degrees == [2, 1]
def test_extract_forms(): """Test extraction on unique function spaces for rows and columns of a block system""" mesh = create_unit_square(MPI.COMM_WORLD, 32, 31) V0 = FunctionSpace(mesh, ("Lagrange", 1)) V1 = FunctionSpace(mesh, ("Lagrange", 2)) V2 = V0.clone() V3 = V1.clone() v0, u0 = TestFunction(V0), TrialFunction(V0) v1, u1 = TestFunction(V1), TrialFunction(V1) v2, u2 = TestFunction(V2), TrialFunction(V2) v3, u3 = TestFunction(V3), TrialFunction(V3) a = form([[inner(u0, v0) * dx, inner(u1, v1) * dx], [inner(u2, v2) * dx, inner(u3, v3) * dx]]) with pytest.raises(AssertionError): extract_function_spaces(a, 0) with pytest.raises(AssertionError): extract_function_spaces(a, 1) a = form([[inner(u0, v0) * dx, inner(u2, v1) * dx], [inner(u0, v2) * dx, inner(u2, v2) * dx]]) with pytest.raises(AssertionError): extract_function_spaces(a, 0) Vc = extract_function_spaces(a, 1) assert Vc[0] is V0._cpp_object assert Vc[1] is V2._cpp_object a = form([[inner(u0, v0) * dx, inner(u1, v0) * dx], [inner(u2, v1) * dx, inner(u3, v1) * dx]]) Vr = extract_function_spaces(a, 0) assert Vr[0] is V0._cpp_object assert Vr[1] is V1._cpp_object with pytest.raises(AssertionError): extract_function_spaces(a, 1)
def test_plus_minus_matrix(cell_type, pm1, pm2): """Test that ('+') and ('-') match up with the correct DOFs for DG functions""" results = [] spaces = [] orders = [] for count in range(3): for agree in [True, False]: mesh, order = two_unit_cells(cell_type, agree, return_order=True) V = FunctionSpace(mesh, ("DG", 1)) u, v = TrialFunction(V), TestFunction(V) a = inner(u(pm1), v(pm2)) * dS result = fem.assemble_matrix(a, []) result.assemble() spaces.append(V) results.append(result) orders.append(order) for i, j in combinations(zip(results, spaces, orders), 2): dof_order = [] for cell in range(2): for point in range(len(mesh.geometry.points)): point_n = j[2][point] cell_points = list(j[1].mesh.cells()[cell]) if point_n in cell_points: point_n_in_cell = cell_points.index(point_n) dofmap = j[1].dofmap.cell_dofs(cell) j_dof_n = dofmap[point_n_in_cell] else: j_dof_n = None point_n = i[2][point] cell_points = list(i[1].mesh.cells()[cell]) if point_n in cell_points: point_n_in_cell = cell_points.index(point_n) dofmap = i[1].dofmap.cell_dofs(cell) i_dof_n = dofmap[point_n_in_cell] else: i_dof_n = None if i_dof_n is None: assert j_dof_n is None else: dof_order.append((i_dof_n, j_dof_n)) for a, b in dof_order: for c, d in dof_order: assert np.isclose(i[0][a, c], j[0][b, d])
def test_expand_indices(): element = FiniteElement("Lagrange", triangle, 2) v = TestFunction(element) u = TrialFunction(element) def evaluate(form): return form.cell_integral()[0].integrand()((), { v: 3, u: 5 }) # TODO: How to define values of derivatives? a = div(grad(v)) * u * dx # a1 = evaluate(a) a = expand_derivatives(a) # a2 = evaluate(a) a = expand_indices(a)
def __init__(self, mesh, k: int, omega, c, c0, lumped): P = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), k) self.V = FunctionSpace(mesh, P) self.u, self.v = Function(self.V), Function(self.V) self.g1 = Function(self.V) self.g2 = Function(self.V) self.omega = omega self.c = c self.c0 = c0 n = FacetNormal(mesh) # Pieces for plane wave incident field x = ufl.geometry.SpatialCoordinate(mesh) cos_wave = ufl.cos(self.omega / self.c0 * x[0]) sin_wave = ufl.sin(self.omega / self.c0 * x[0]) plane_wave = self.g1 * cos_wave + self.g2 * sin_wave dv, p = TrialFunction(self.V), TestFunction(self.V) self.L1 = - inner(grad(self.u), grad(p)) * dx(degree=k) \ - (1 / self.c) * inner(self.v, p) * ds \ - (1 / self.c**2) * (-self.omega**2) * inner(plane_wave, p) * dx \ - inner(grad(plane_wave), grad(p)) * dx \ + inner(dot(grad(plane_wave), n), p) * ds # Vector to be re-used for assembly self.b = None # TODO: precompile/pre-process Form L self.lumped = lumped if self.lumped: a = (1 / self.c**2) * p * dx(degree=k) self.M = dolfinx.fem.assemble_vector(a) self.M.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE) else: a = (1 / self.c**2) * inner(dv, p) * dx(degree=k) M = dolfinx.fem.assemble_matrix(a) M.assemble() self.solver = PETSc.KSP().create(mesh.mpi_comm()) opts = PETSc.Options() opts["ksp_type"] = "cg" opts["ksp_rtol"] = 1.0e-8 self.solver.setFromOptions() self.solver.setOperators(M)
def test_remove_complex_nodes(self): cell = triangle element = FiniteElement("Lagrange", cell, 1) u = TrialFunction(element) v = TestFunction(element) f = Coefficient(element) a = conj(v) b = real(u) c = imag(f) d = conj(real(v))*imag(conj(u)) assert remove_complex_nodes(a) == v assert remove_complex_nodes(b) == u with pytest.raises(ufl.log.UFLException): remove_complex_nodes(c) with pytest.raises(ufl.log.UFLException): remove_complex_nodes(d)
def test_apply_algebra_lowering_complex(self): cell = triangle element = FiniteElement("Lagrange", cell, 1) v = TestFunction(element) u = TrialFunction(element) gv = grad(v) gu = grad(u) a = dot(gu, gv) b = inner(gv, gu) c = outer(gu, gv) lowered_a = apply_algebra_lowering(a) lowered_b = apply_algebra_lowering(b) lowered_c = apply_algebra_lowering(c) lowered_a_index = lowered_a.index() lowered_b_index = lowered_b.index() lowered_c_indices = lowered_c.indices() assert lowered_a == gu[lowered_a_index] * gv[lowered_a_index] assert lowered_b == gv[lowered_b_index] * conj(gu[lowered_b_index]) assert lowered_c == as_tensor(conj(gu[lowered_c_indices[0]]) * gv[lowered_c_indices[1]], (lowered_c_indices[0],) + (lowered_c_indices[1],))
def test_comparison_checker(self): cell = triangle element = FiniteElement("Lagrange", cell, 1) u = TrialFunction(element) v = TestFunction(element) a = conditional(ge(abs(u), imag(v)), u, v) b = conditional(le(sqrt(abs(u)), imag(v)), as_ufl(1), as_ufl(1j)) c = conditional(gt(abs(u), pow(imag(v), 0.5)), sin(u), cos(v)) d = conditional(lt(as_ufl(-1), as_ufl(1)), u, v) e = max_value(as_ufl(0), real(u)) f = min_value(sin(u), cos(v)) g = min_value(sin(pow(u, 3)), cos(abs(v))) assert do_comparison_check(a) == conditional(ge(real(abs(u)), real(imag(v))), u, v) with pytest.raises(ComplexComparisonError): b = do_comparison_check(b) with pytest.raises(ComplexComparisonError): c = do_comparison_check(c) assert do_comparison_check(d) == conditional(lt(real(as_ufl(-1)), real(as_ufl(1))), u, v) assert do_comparison_check(e) == max_value(real(as_ufl(0)), real(real(u))) assert do_comparison_check(f) == min_value(real(sin(u)), real(cos(v))) assert do_comparison_check(g) == min_value(real(sin(pow(u, 3))), real(cos(abs(v))))
# # UFL is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # UFL is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with UFL. If not, see <http://www.gnu.org/licenses/>. # # Modified by Martin Sandve Alnæs, 2009 # # Last changed: 2009-03-02 # # The bilinear form a(v, u) and linear form L(v) for Poisson's equation. from ufl import (Coefficient, FiniteElement, TestFunction, TrialFunction, dx, grad, inner, triangle) element = FiniteElement("Lagrange", triangle, 1) u = TrialFunction(element) v = TestFunction(element) f = Coefficient(element) a = inner(grad(v), grad(u)) * dx(degree=1) L = v * f * dx(degree=2)
E = 1.0e9 nu = 0.0 mu = E / (2.0 * (1.0 + nu)) lmbda = E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu)) def sigma(v): return 2.0 * mu * sym(grad(v)) + lmbda * tr(sym(grad(v))) * Identity( len(v)) # Create function space V = VectorFunctionSpace(mesh, ("Lagrange", 1)) # Define variational problem u = TrialFunction(V) v = TestFunction(V) a = form(inner(sigma(u), grad(v)) * dx) L = form(inner(f, v) * dx) # Set up boundary condition on inner surface bc = dirichletbc( np.array([0, 0, 0], dtype=PETSc.ScalarType), locate_dofs_geometrical( V, lambda x: np.logical_or(np.isclose(x[0], 0.0), np.isclose(x[1], 1.0))), V) # Assembly and solve # ------------------ # ::
# grid = create.grid("ALUConform", dune.grid.cartesianDomain([0, 0], [1, 1], [89, 89]), dimgrid=2) try: grid = create.grid("ALUConform", dune.grid.cartesianDomain([0, 0], [1, 1], [9, 9]), dimgrid=2) except: grid = create.grid("Yasp", dune.grid.cartesianDomain([0, 0], [1, 1], [9, 9]), dimgrid=2) d = 0.001 p = 1.7 uflSpace = Space((2, 2), 1) u = TrialFunction(uflSpace) v = TestFunction(uflSpace) x = SpatialCoordinate(uflSpace.cell()) rhs = (x[0] + x[1]) * v[0] a = (pow(d + inner(grad(u), grad(u)), (p - 2) / 2) * inner(grad(u), grad(v)) + grad(u[0])[0] * v[0]) * dx + 10 * inner(u, v) * ds b = rhs * dx + 10 * rhs * ds model = create.model("integrands", grid, a == b) def test(space): if test_numpy: numpySpace = create.space(space, grid, dimRange=1,