def test_build_mesh(): """ Create a few meshes, extract the vertices and cells from them and pass them to build_mesh() to rebuild the mesh. Then check that the result is the same as the original. """ def assert_mesh_builds_correctly(mesh): coords = mesh.coordinates() cells = mesh.cells() mesh_new = build_mesh(coords, cells) assert np.allclose(coords, mesh_new.coordinates()) assert np.allclose(cells, mesh_new.cells()) mesh1 = df.RectangleMesh(df.Point(0, 0), df.Point(20, 10), 12, 8) assert_mesh_builds_correctly(mesh1) mesh2_temp = mshr.Circle(df.Point(2.0, -3.0), 10) mesh2 = mshr.generate_mesh(mesh2_temp, 10) assert_mesh_builds_correctly(mesh2) mesh3 = df.BoxMesh(df.Point(0, 0, 0), df.Point(20, 10, 5), 12, 8, 3) assert_mesh_builds_correctly(mesh3) mesh4_temp = mshr.Sphere(df.Point(2.0, 3.0, -4.0), 10) mesh4 = mshr.generate_mesh(mesh4_temp, 10) assert_mesh_builds_correctly(mesh4)
def test_mesh_diameter(self): mesh = UnitSquareMesh(10, 7) d = mesh_diameter(mesh) self.assertAlmostEqual(d, 2.0**0.5) mesh = UnitCubeMesh(3, 4, 5) d = mesh_diameter(mesh) self.assertAlmostEqual(d, 3.0**0.5) try: import mshr except ImportError: warning("mshr not available; skipping some tests of " "'mesh_diameter'...") else: b0 = mshr.Rectangle(Point(0.0, 0.0), Point(0.5, 1.0)) b1 = mshr.Rectangle(Point(0.0, 0.0), Point(1.0, 0.5)) lshape = b0 + b1 mesh = mshr.generate_mesh(lshape, 10) d = mesh_diameter(mesh) self.assertAlmostEqual(d, 2.0**0.5) s = mshr.Sphere(Point(100.0, -666666.6, 1e10), 4.0, 5) mesh = mshr.generate_mesh(s, 5) d = mesh_diameter(mesh) self.assertAlmostEqual(d, 8.0, 0)
def __init__(self, domain, domain1, domain2, mesh_resolution, boundaries, polynomial_degree, adjust): self.domain = domain self.domain1 = domain1 self.domain2 = domain2 self.left = domain1 - domain2 self.right = domain2 - domain1 self.overlap_domain = domain - (self.left + self.right) self.mesh_resolution = mesh_resolution self.mesh = mshr.generate_mesh(domain, mesh_resolution) self.mesh1 = mshr.generate_mesh(domain1, mesh_resolution / 2) self.mesh2 = mshr.generate_mesh(domain2, mesh_resolution / 2) self.overlap_mesh = mshr.generate_mesh(self.overlap_domain, mesh_resolution) self.insides = boundaries[0] self.left_robin = boundaries[1] self.right_robin = boundaries[2] self.adjustment = adjust self.p = polynomial_degree self.VO = FunctionSpace(self.overlap_mesh, "Lagrange", self.p) self.K, self.M, self.V = self.assemble_matrices(self.mesh) self.K1, self.M1, self.V1 = self.assemble_matrices(self.mesh1) self.K2, self.M2, self.V2 = self.assemble_matrices(self.mesh2)
def get_geometry(domain_part): nx = 5 ny = 10 low_resolution = 5 high_resolution = 5 n_vertices = 20 if domain_part is DomainPart.LEFT: nx = nx * 3 elif domain_part is DomainPart.RIGHT: ny = ny * 2 elif domain_part is DomainPart.CIRCULAR: n_vertices = n_vertices elif domain_part is DomainPart.RECTANGLE: n_vertices = n_vertices else: raise Exception("invalid domain_part: {}".format(domain_part)) if domain_part is DomainPart.LEFT or domain_part is DomainPart.RIGHT: if domain_part is DomainPart.LEFT: p0 = Point(x_left, y_bottom) p1 = Point(x_coupling, y_top) elif domain_part is DomainPart.RIGHT: p0 = Point(x_coupling, y_bottom) p1 = Point(x_right, y_top) else: raise Exception("invalid control flow!") mesh = RectangleMesh(p0, p1, nx, ny) coupling_boundary = StraightBoundary() remaining_boundary = ExcludeStraightBoundary() elif domain_part is DomainPart.CIRCULAR or domain_part is DomainPart.RECTANGLE: p0 = Point(x_left, y_bottom) p1 = Point(x_right, y_top) whole_domain = mshr.Rectangle(p0, p1) if domain_part is DomainPart.CIRCULAR: circular_domain = mshr.Circle(midpoint, radius, n_vertices) mesh = mshr.generate_mesh(circular_domain, high_resolution, "cgal") elif domain_part is DomainPart.RECTANGLE: circular_domain = mshr.Circle(midpoint, radius, n_vertices) mesh = mshr.generate_mesh(whole_domain - circular_domain, low_resolution, "cgal") else: raise Exception("invalid control flow!") coupling_boundary = CircleBoundary() remaining_boundary = ExcludeCircleBoundary() else: raise Exception("invalid control flow!") return mesh, coupling_boundary, remaining_boundary
def shape(self, mesh, size=50): """Build mesh.""" vf = np.vectorize(self.f) x = mesh.coordinates()[:, 0] y = mesh.coordinates()[:, 1] a = np.arctan2(y, x) x, y = [x * vf(a), y * vf(a)] mesh.coordinates()[:] = np.array([x, y]).transpose() boundary = BoundaryMesh(mesh, 'exterior') boundary.init() lst = [0] vs = list(vertices(boundary)) while True: v = vs[lst[-1]] neighbors = set() for e in edges(v): neighbors.update(e.entities(0)) neighbors.remove(v.index()) neighbors = list(neighbors) k = 0 if len(lst) > 1: if neighbors[0] == lst[-2]: k = 1 lst.append(neighbors[k]) if lst[-1] == lst[0]: break lst = lst[:-1] points = boundary.coordinates()[lst] points = [Point(*p) for p in points] try: polygon = Polygon(points) except: polygon = Polygon(points[::-1]) return generate_mesh(polygon, size)
def test_CarstensenKlose(p, N): from dolfintape.demo_problems.exact_solutions import pLaplace_CarstensenKlose from dolfintape.mesh_fixup import mesh_fixup import mshr label = 'CarstensenKlose_%s_%02d' % (p, N) # Build mesh on L-shaped domain (-1, 1)^2 \ (0, 1)*(-1, 0) b0 = mshr.Rectangle(Point(-1.0, -1.0), Point(1.0, 1.0)) b1 = mshr.Rectangle(Point(0.0, -1.0), Point(1.0, 0.0)) mesh = mshr.generate_mesh(b0 - b1, N) mesh = mesh_fixup(mesh) print("num cells %s" % mesh.num_cells()) plot_cutoff_distribution(p, mesh, label) # Fetch exact solution and rhs of p-Laplacian u, f = pLaplace_CarstensenKlose(p=p, eps=0.0, delta=7.0/8, domain=mesh, degree=4) # There are some problems with quadrature element, # see https://bitbucket.org/fenics-project/ffc/issues/84, # so precompute (f, vh) for vh from P1 f = project(f, FunctionSpace(mesh, 'Lagrange', 1), form_compiler_parameters= {'quadrature_degree': f.ufl_element().degree()}) f.set_allow_extrapolation(True) # Now the heavy lifting result = compute_liftings(label, p, mesh, f, u) uh, glob, loc, ee, fe = result[0:5] # Report format_result('Carstensen--Klose', p, mesh.num_cells(), *result[5:]) plot_liftings(glob, loc, ee, fe, label) save_functions(uh, glob, loc, ee, fe, label) list_timings(TimingClear_clear, [TimingType_wall])
def box_mesh_with_hole(point1=Point(0, 0, 0), point2=Point(2, 1, 1), cyl_cent1=Point(1, -10, 0.5), cyl_cent2=Point(1, 10, 0.5), cyl_rad=0.25, numpts=15): """ generates a 3D box mesh with tetrahedral elements with a cylindrical hole in it input ------ point1: Point coordinates in 3D corner_min of box point2: Point coordinates in 3D corner_max of box cyl_cent1: Point coordinates in 3D of center1 of Cylinder cyl_cent2: Point coordinates in 3D of center1 of Cylinder cyl_rad: Radius of cylinder npts: Number of discretization points output: ------ mesh: 3D FEniCS mesh with a cylindrical hole """ Router = mshr.Box(point1, point2) Rinner = mshr.Cylinder(cyl_cent1, cyl_cent2, cyl_rad, cyl_rad) domain = Router - Rinner mesh = mshr.generate_mesh(domain, numpts) print_mesh_stats(mesh) return mesh
def rectangle_mesh_with_hole(point1=Point(0, 0), point2=Point(3, 1), hole_cent=Point(1.5, 0.5), hole_rad=0.25, npts=15): """ generates a triangulated Rectangular domain with a circular hole input ------ point1: Point coordinates in 3D corner_min of box point2: Point coordinates in 3D corner_max of box cyl_cent1: Point coordinates in 3D of center1 of Cylinder cyl_cent2: Point coordinates in 3D of center1 of Cylinder cyl_rad: Radius of cylinder npts: number of discretization points output: ------ mesh: 2D FEniCS mesh with circular hole """ Router = mshr.Rectangle(point1, point2) Rinner = mshr.Circle(hole_cent, hole_rad) domain = Router - Rinner mesh = mshr.generate_mesh(domain, npts) print_mesh_stats(mesh) return mesh
def method(res=50, diameter=1., length=5., **kwargs): ''' Function That Generates a mesh for a barbell capilar, Meshing method is mshr. Note: The generarted mesh is stored in "BERNAISE/meshes/". ''' info("Generating mesh using the mshr tool.") inletdiameter = diameter * 5. inletlength = diameter * 4. # Define coners of "capilar" a = df.Point(-diameter / 2., -length / 2 - inletlength / 2.) b = df.Point(diameter / 2., length / 2 + inletlength / 2.) capilar = mshr.Rectangle(a, b) # Define coners of "leftbell c = df.Point(-inletdiameter / 2., -length / 2 - inletlength) d = df.Point(inletdiameter / 2., -length / 2) leftbell = mshr.Rectangle(c, d) # Define coners of "rightbell" e = df.Point(-inletdiameter / 2., length / 2) f = df.Point(inletdiameter / 2., length / 2 + inletlength) rightbell = mshr.Rectangle(e, f) domain = capilar + leftbell + rightbell mesh = mshr.generate_mesh(domain, res) meshpath = os.path.join( MESHES_DIR, "BarbellCapilarDolfin_d" + str(diameter) + "_l" + str(length) + "_res" + str(res)) store_mesh_HDF5(mesh, meshpath)
def generate_mesh(): # Define domain x_min = 0 x_max = 5 y_min = 0 y_max = 1.5 xc = 0.7 yc = 0.5 * (y_min + y_max) r = 0.2 circle = mshr.Circle(Point(xc, yc), r) domain = mshr.Rectangle(Point(x_min, y_min), Point(x_max, y_max)) - circle # Create resolution mesh_res = 64 # Create mesh mesh = mshr.generate_mesh(domain, mesh_res) # Save mesh File(os.path.join(DATA_DIR, 'mesh.xml.gz')) << mesh # Save dof coordinates V = FunctionSpace(mesh, 'P', 1) dof_coordinates = V.tabulate_dof_coordinates() np.save(os.path.join(DATA_DIR, 'coordinates.npy'), dof_coordinates) # Save dof triangles vertex2dof = vertex_to_dof_map(V) vertex2dof_vec = np.vectorize(lambda v: vertex2dof[v]) dof_triangles = vertex2dof_vec(mesh.cells()) np.save(os.path.join(DATA_DIR, 'triangles.npy'), dof_triangles)
def run(self): domain = self._create_domain() mesh = generate_mesh(domain, MESH_PTS) # fe.plot(mesh) # plt.show() self._create_boundary_expression() Omega = fe.FiniteElement("Lagrange", mesh.ufl_cell(), 1) R = fe.FiniteElement("Real", mesh.ufl_cell(), 0) W = fe.FunctionSpace(mesh, Omega*R) Theta, c = fe.TrialFunction(W) v, d = fe.TestFunctions(W) sigma = self.conductivity LHS = (sigma * fe.inner(fe.grad(Theta), fe.grad(v)) + c*v + Theta*d) * fe.dx RHS = self.boundary_exp * v * fe.ds w = fe.Function(W) fe.solve(LHS == RHS, w) Theta, c = w.split() print(c(0, 0)) # fe.plot(Theta, "solution", mode='color', vmin=-3, vmax=3) # plt.show() plot(fe.interpolate(Theta, fe.FunctionSpace(mesh, Omega)), mode='color') plt.show()
def mesh_Square(n=10, method='regular'): if method == 'mshr': dom = mshr.Rectangle(Point(-1., -1.), Point(1., 1.)) mesh = mshr.generate_mesh(dom, n, "cgal") elif method == 'regular': mesh = RectangleMesh(Point(-1., -1.), Point(1., 1.), n, n) return mesh
def solve_poisson_equation(u_e, alpha, title_name): domain = Circle(Point(0, 0), 1) mesh = generate_mesh(domain, 30) V = FunctionSpace(mesh, 'P', 2) u_d = Expression(ccode(u_e), degree=2) bc = DirichletBC(V, u_d, check_boundary) u = TrialFunction(V) v = TestFunction(V) f = -calculate_laplacian(u_e) + alpha * u_e f = Expression(ccode(f), degree=2) g = calculate_normal_derivative(u_e) g = Expression(ccode(g), degree=2) a = dot(grad(u), grad(v)) * dx + alpha * u * v * dx L = f * v * dx + g * v * ds u = Function(V) solve(a == L, u, bc) u_e = u_d error_L2 = errornorm(u_e, u, 'L2') vertex_values_u = u.compute_vertex_values(mesh) vertex_values_u_e = u_e.compute_vertex_values(mesh) error_max = np.max(np.abs(vertex_values_u_e - vertex_values_u)) print('Max error = %.3g, L2 error = %.3g' % (error_max, error_L2)) image = plot_solutions(u_e, u, mesh) imageio.imsave(f'poisson_{title_name}.png', image)
def generate_mesh(name, par=40, refinement=False): info("Generating mesh {} ...".format(name)) # construct mesh geometry = mshr.Rectangle(Point(0.0, 0.0), Point(gL, gW)) \ - mshr.Circle(Point(gX, gY), g_radius, 20) \ - mshr.Rectangle(Point(gX, gY - 0.5*gEH), Point(gX + g_radius + gEL, gY + 0.5*gEH)) mesh = mshr.generate_mesh(geometry, par) if refinement: parameters["refinement_algorithm"] = "plaza_with_parent_facets" for k in range(2): # 2 cf = MeshFunction('bool', mesh, 2) cf.set_all(False) z = 0.2 #0.15 # 0.08 for c in cells(mesh): if c.midpoint().distance(Point(gX, gY)) < (0.05 + k * z): cf[c] = True elif (c.midpoint()[0] <= gX + g_radius + gEL + k*z and c.midpoint()[0] >= gX - k*z\ and c.midpoint()[1] <= gY + 0.5*gEH + k*z and c.midpoint()[1] >= gY - 0.5*gEH - k*z): cf[c] = True mesh = refine(mesh, cf) mesh.init() # Save mesh if __version__[:4] == '2018': hdf5 = HDF5File(MPI.comm_world, name, 'w') else: hdf5 = HDF5File(mpi_comm_world(), name, 'w') hdf5.write(mesh, "/mesh") return mesh
def main(): "Generates the mesh" import mshr as m import dolfin as d import matplotlib.pyplot as plt d.set_log_level(13) # PROGRESS r_1 = 0.5 # inner r_2 = 2.0 # outer res = 10 # resolution circle_inner = m.Circle(d.Point(0.0, 0.0), r_1) circle_outer = m.Circle(d.Point(0.0, 0.0), r_2) domain = circle_outer - circle_inner domain.set_subdomain(1, circle_inner) domain.set_subdomain(2, circle_outer) mesh = m.generate_mesh(domain, res) print("max edge length:", mesh.hmax()) mesh_file_pvd = d.File("mesh.pvd") mesh_file_pvd.write(mesh) plt.figure() d.plot(mesh, title="Mesh") plt.show()
def make_metamaterial_mesh( L0, c1, c2, pore_radial_resolution, min_feature_size, resolution, n_cells, porosity, ): material_domain = None base_pore_points = None for i in range(n_cells): for j in range(n_cells): c1_ = c1[i, j] if isinstance(c1, np.ndarray) else c1 c2_ = c2[i, j] if isinstance(c2, np.ndarray) else c2 if isinstance(c1, np.ndarray) or base_pore_points is None: base_pore_points, radii, thetas = build_base_pore( L0, c1_, c2_, pore_radial_resolution, porosity) verify_params(base_pore_points, radii, L0, min_feature_size) cell = make_cell(i, j, L0, base_pore_points) material_domain = (cell if material_domain is None else cell + material_domain) return fa.Mesh(mshr.generate_mesh(material_domain, resolution * n_cells))
def create_simple_mesh(Rint, Rout, resolution): # Create circles as Circle(Center, Radius) outer_circle = mshr.Circle(df.Point(0, 0), Rout) inner_circle = mshr.Circle(df.Point(0, 0), Rint) domain = outer_circle - inner_circle mesh = mshr.generate_mesh(domain, resolution) return mesh
def build_mesh(self, resolution=20): from mshr import Rectangle, Circle, generate_mesh domain = Rectangle(Point(0.0, 0.0), Point(self.L, self.L)) - Circle( Point(0.0, 0.0), self.radius ) return generate_mesh(domain, resolution)
def build_mesh(self): self.length = 100 self.height = 100 plate = mshr.Rectangle(fe.Point(0, 0), fe.Point(self.length, self.height)) notch = mshr.Polygon([ fe.Point(0, self.height / 2 + 1), fe.Point(0, self.height / 2 - 1), fe.Point(6, self.height / 2) ]) self.mesh = mshr.generate_mesh(plate - notch, 30) length = self.length height = self.height class Lower(fe.SubDomain): def inside(self, x, on_boundary): return on_boundary and fe.near(x[1], 0) class Upper(fe.SubDomain): def inside(self, x, on_boundary): return on_boundary and fe.near(x[1], height) class Corner(fe.SubDomain): def inside(self, x, on_boundary): return fe.near(x[0], 0) and fe.near(x[1], 0) self.lower = Lower() self.upper = Upper() self.corner = Corner()
def create_coronal_section_mesh(self, model_z_n=0): brain_slice = self.image_manipulation_obj.\ get_brain_slice_from_model_z_n(model_z_n) x_size = 65 self.boundary_points = brain_slice.\ generate_boundary_points_ccw(x_size) domain_vertices = [] for x, y in zip(self.boundary_points[0], self.boundary_points[1]): domain_vertices.append(fe.Point(x, y)) self.geometry = mesher.Polygon(domain_vertices) self.mesh = mesher.generate_mesh(self.geometry, 16) self.compute_mesh_volume() self.original_volume = self.mesh_volume print('Original volume', self.original_volume) self.generate_holes() #self.compute_hole_fractional_volume() self.puncture_mesh() self.compute_mesh_volume() domain_volume = self.mesh_volume print('New volume', domain_volume) self.hole_fractional_volume = 1 - domain_volume / self.original_volume print('Hole fractional volume:', self.hole_fractional_volume) print('# holes:', self.n_holes) print('Estimated hole fractional volume:',\ self.compute_hole_fractional_volume())
def generate_rectangle_mesh(mesh_resolution): # Generate domain and mesh xmin, xmax = -2, 2 ymin, ymax = -2, 2 mesh = generate_mesh(Rectangle(Point(xmin, ymin), Point(xmax, ymax)), mesh_resolution) return mesh
def build_mesh(self): length = 60 height = 30 radius = 5 plate = mshr.Rectangle(fe.Point(0, 0), fe.Point(length, height)) circle1 = mshr.Circle(fe.Point(length/3, height/3), radius) circle2 = mshr.Circle(fe.Point(length*2/3, height*2/3), radius) material_domain = plate - circle1 - circle2 self.mesh = mshr.generate_mesh(material_domain, 50) # Add dolfin-adjoint dependency self.mesh = create_overloaded_object(self.mesh) class Left(fe.SubDomain): def inside(self, x, on_boundary): return on_boundary and fe.near(x[0], 0) class Right(fe.SubDomain): def inside(self, x, on_boundary): return on_boundary and fe.near(x[0], length) class Corner(fe.SubDomain): def inside(self, x, on_boundary): return fe.near(x[0], 0) and fe.near(x[1], 0) self.left = Left() self.right = Right() self.corner = Corner()
def mesh_Triangle(n=10): dom = mshr.Polygon( [Point(0., -1.), Point(sqrt(3) / 2, 1. / 2), Point(-sqrt(3) / 2, 1. / 2)]) mesh = mshr.generate_mesh(dom, n, "cgal") return mesh
def create_cocontinuous_mesh(self): if self.use_previously_stored_mesh: self.mesh = fe.Mesh(self.mesh_fname) print('Mesh has been loaded from file') return p = self.L * np.ones(3) geo = mesher.Box(fe.Point(0,0,0), fe.Point(p)) net = self.extrude_base_net() columns = self.create_cylindrical_columns() net += columns if self.keep_only_network: geo = net else: geo -= net print('Finished creating the geometry') self.mesh = mesher.generate_mesh(geo, self.mesh_density); print('Writing mesh to file') mesh_file = fe.File(self.mesh_fname) mesh_file << self.mesh print('Finished writing mesh to file')
def generate_mesh(self, typ, order, resolution): self._mesh = mshr.generate_mesh(self._domain, resolution) self.input['mesh'] = self._mesh self._V = FEN.FunctionSpace(self._mesh, typ, order) self.input['V'] = self._V self._u = FEN.TrialFunction(self._V) self._v = FEN.TestFunction(self._V)
def __init__(self, x0, y0, z0, R, n): class SphereSurface(SubDomain): def inside(self, x, on_boundary): return on_boundary class X_Symmetric(SubDomain): def inside(self, x, on_boundary): return near(x[0], x0) class Y_Symmetric(SubDomain): def inside(self, x, on_boundary): return near(x[1], y0) class Z_Symmetric(SubDomain): def inside(self, x, on_boundary): return near(x[2], z0) self.geometry = Sphere(Point(x0, y0, z0), R, segments=n) - Box(Point(x0 + R, y0, z0 - R), Point(x0 - R, y0 - R, z0 + R)) - Box(Point(x0 - R, y0 + R, z0), Point(x0 + R, y0, z0 - R)) - Box(Point(x0, y0, z0), Point(x0 - R, y0 + R, z0 + R)) self.mesh = generate_mesh(self.geometry, n) self.domains = MeshFunction("size_t", self.mesh, self.mesh.topology().dim()) self.domains.set_all(0) self.dx = Measure('dx', domain=self.mesh, subdomain_data=self.domains) self.boundaries = MeshFunction("size_t", self.mesh, self.mesh.topology().dim()-1) self.boundaries.set_all(0) self.sphereSurface = SphereSurface() self.sphereSurface.mark(self.boundaries, 1) self.x_symmetric = X_Symmetric() self.x_symmetric.mark(self.boundaries, 2) self.y_symmetric = Y_Symmetric() self.y_symmetric.mark(self.boundaries, 3) self.z_symmetric = Z_Symmetric() self.z_symmetric.mark(self.boundaries, 4) self.ds = Measure('ds', domain=self.mesh, subdomain_data=self.boundaries) self.dS = Measure('dS', domain=self.mesh, subdomain_data=self.boundaries)
def initialise(dem, bounds, res): """ Function to initialise the model space :param dem: 0 = no input DEM; 1 = input DEM :param bounds: west, south, east, north - if no DEM [0, 0, lx, ly]; if DEM [west, south, east, north] :param res: model resolution along the y-axis. :return model_space, u_n, mesh, V, bc: """ if dem == 0: lx = bounds[1] ly = bounds[3] # Create mesh and define function space domain = Rectangle(Point(0, 0), Point(lx / ly, ly / ly)) mesh = generate_mesh(domain, res) V = FunctionSpace(mesh, 'P', 1) # Define initial value u_D = Constant(0) eps = 10 / ly u_n = interpolate(u_D, V) u_n.vector().set_local(u_n.vector().get_local() + eps * np.random.random(u_n.vector().size())) if dem == 1: u_n, lx, ly, mesh, V = read_dem(bounds, res) # boundary conditions class East(SubDomain): def inside(self, x, on_boundary): return near(x[0], lx / ly) class West(SubDomain): def inside(self, x, on_boundary): return near(x[0], 0.0) class North(SubDomain): def inside(self, x, on_boundary): return near(x[1], ly / ly) class South(SubDomain): def inside(self, x, on_boundary): return near(x[1], 0.0) # Should make this into an option! bc = [DirichletBC(V, u_n, West()), DirichletBC(V, u_n, East())] # def boundary(x, on_boundary): # return on_boundary # bc = DirichletBC(V, u_n, boundary) model_space = [lx, ly, res] return model_space, u_n, mesh, V, bc
def spherical_shell(dim, radii, n_refinements=0): """ Creates the mesh of a spherical shell using the mshr module. """ assert isinstance(dim, int) assert dim == 2 or dim == 3 assert isinstance(radii, (list, tuple)) and len(radii) == 2 ri, ro = radii assert isinstance(ri, float) and ri > 0. assert isinstance(ro, float) and ro > 0. assert ri < ro assert isinstance(n_refinements, int) and n_refinements >= 0 # mesh generation if dim == 2: center = dlfn.Point(0., 0.) elif dim == 3: center = dlfn.Point(0., 0., 0.) if dim == 2: domain = Circle(center, ro)\ - Circle(center, ri) mesh = generate_mesh(domain, 75) elif dim == 3: domain = Sphere(center, ro) \ - Sphere(center, ri) mesh = generate_mesh(domain, 15) # mesh refinement for i in range(n_refinements): mesh = dlfn.refine(mesh) # MeshFunction for boundaries ids facet_marker = dlfn.MeshFunction("size_t", mesh, mesh.topology().dim() - 1) facet_marker.set_all(0) # mark boundaries BoundaryMarkers = SphericalAnnulusBoundaryMarkers gamma_inner = CircularBoundary(mesh=mesh, radius=ri) gamma_inner.mark(facet_marker, BoundaryMarkers.interior_boundary.value) gamma_outer = CircularBoundary(mesh=mesh, radius=ro) gamma_outer.mark(facet_marker, BoundaryMarkers.exterior_boundary.value) return mesh, facet_marker
def create_mesh_with_holes(Rint, Rout, Rhole, resolution): # Create circles as Circle(Center, Radius) outer_circle = mshr.Circle(df.Point(0,0), Rout) inner_circle = mshr.Circle(df.Point(0,0), Rint) hole = mshr.Circle(df.Point(0, 0.5*(Rint+Rout)), Rhole) domain = outer_circle - inner_circle - hole mesh = mshr.generate_mesh(domain, resolution) return mesh
def puncture_mesh(self): for p in self.hole_coordinates: circle = mesher.Circle(fe.Point(p), self.hole_radius) self.geometry -= circle self.mesh = mesher.generate_mesh(self.geometry, self.mesh_density) print('Done with the mesh generation')
def get_mesh(k): h = 0.5**k # cell_size = 2 * pi / num_boundary_points c = mshr.Circle(dolfin.Point(0., 0., 0.), 1, int(2*pi / h)) # cell_size = 2 * bounding_box_radius / res m = mshr.generate_mesh(c, 2.0 / h) coords = m.coordinates() coords = numpy.c_[coords, numpy.zeros(len(coords))] return pyfvm.meshTri.meshTri(coords, m.cells())
def get_mesh(k): h = 0.5**(k+2) c = mshr.Sphere(dolfin.Point(0., 0., 0.), 1.0, int(2*pi / h)) m = mshr.generate_mesh(c, 2.0 / h) return pyfvm.meshTetra.meshTetra( m.coordinates(), m.cells(), mode='geometric' )
def make_spherical_mesh(size, resolution): #Defining the domain for the mesh using the Sphere function from mshr domain = mshr.Sphere(origin, size) #Meshing the sphere generated with resolution 10 (cells per dimension) initial_mesh = mshr.generate_mesh(domain, resolution) return initial_mesh
def build_mesh(self): self.length = 8. self.height = 2. self.notch_length = 0.2 self.notch_height = 0.4 domain = mshr.Polygon([fe.Point(0., 0.), fe.Point(self.length/2. - self.notch_length/2., 0.), fe.Point(self.length/2., self.notch_height), fe.Point(self.length/2. + self.notch_length/2., 0.), fe.Point(self.length, 0.), fe.Point(self.length, self.height), fe.Point(self.length/2. + self.notch_length/2., self.height), fe.Point(self.length/2., self.height), fe.Point(self.length/2. - self.notch_length/2., self.height), fe.Point(0., self.height)]) # resolution = 100 if self.local_refinement_iteration == 0 else 200 # self.mesh = mshr.generate_mesh(domain, resolution) self.mesh = mshr.generate_mesh(domain, 100) for i in range(self.local_refinement_iteration): cell_markers = fe.MeshFunction('bool', self.mesh, self.mesh.topology().dim()) cell_markers.set_all(False) for cell in fe.cells(self.mesh): p = cell.midpoint() if p[0] > 14./32.*self.length and p[0] < 18./32.*self.length and p[1] < self.height - self.notch_height: cell_markers[cell] = True self.mesh = fe.refine(self.mesh, cell_markers) length = self.length height = self.height notch_length = self.notch_length class Upper(fe.SubDomain): def inside(self, x, on_boundary): # return on_boundary return on_boundary and fe.near(x[1], height) class LeftCorner(fe.SubDomain): def inside(self, x, on_boundary): return fe.near(x[0], 0.) and fe.near(x[1], 0.) class RightCorner(fe.SubDomain): def inside(self, x, on_boundary): return fe.near(x[0], length) and fe.near(x[1], 0.) class MiddlePoint(fe.SubDomain): def inside(self, x, on_boundary): # return fe.near(x[0], length/2.) and fe.near(x[1], height) return x[0] > length/2. - notch_length/2. and x[0] < length/2. + notch_length/2. and fe.near(x[1], height) self.upper = Upper() self.left = LeftCorner() self.right = RightCorner() self.middle = MiddlePoint()
def create_cylinder(): """ Geometry of a cylinder """ R = 1.0 # Inner radius H = 0.3 # Thickness L = 10.0 # Length geometry = mshr.Cylinder(Point(0.0,0.0,0.0),Point(0.0,0.0,L),R+H,R+H,30) - \ mshr.Cylinder(Point(0.0,0.0,0.0),Point(0.0,0.0,L),R,R,30) mesh = mshr.generate_mesh(geometry, 30) return mesh
def get(self): """ Generate polygon from top and bottom curves. """ radius, N = self.pad(self.values) radius = evaluate(radius)[0] points = [Point(*(radius(theta)*np.array([cos(theta), sin(theta)]))) for theta in np.linspace(0, 2*np.pi, N+2)] if abs(radius(0)-radius(2*np.pi)) < 1E-4: points.pop() try: # may fail if not counterclockwise vertices poly = Polygon(points) except: poly = Polygon(points[::-1]) return generate_mesh(poly, 1)
def get(self): """Built-in polygonal mesh.""" params = self.pad(self.values) if params[1]: vertices = convex_hull(params[0]) else: vertices = params[0] vertices = [Point(*p) for p in vertices] size = params[2] try: # may fail if not counterclockwise vertices poly = Polygon(vertices) except: poly = Polygon(vertices[::-1]) return generate_mesh(poly, size)
def test(n): domain = Rectangle(Point(0, 0), Point(2, 3)) mesh = generate_mesh(domain, n) # Cell-cell connectivity will be defined over facet tdim = mesh.topology().dim() mesh.init(tdim, tdim-1) mesh.init(tdim-1, tdim) c2f = mesh.topology()(tdim, tdim-1) f2c = mesh.topology()(tdim-1, tdim) c2c = lambda c: set(np.hstack([f2c(f) for f in c2f(c)])) def cells_in_radius(c0, mesh, cell_connectivity, radius): x0 = c0.midpoint() c0 = c0.index() N = set([c0]) # cells in the patch C = cell_connectivity(c0) # where to look elements of the patch C.remove(c0) while C: c = C.pop() x = Cell(mesh, c).midpoint() if x.distance(x0) < radius: N.add(c) new = cell_connectivity(c) - N C.update(new) return N f = CellFunction('size_t', mesh, 0) # c0 = Cell(mesh, choice(range(mesh.num_cells()))) # for c in cells_in_radius(c0, mesh, c2c, 0.4): # f[int(c)] = 1 # f[c0] = 2 # plot(f, interactive=True) t = Timer('dt') c0 = choice(range(mesh.num_cells())) c0 = Cell(mesh, c0) t.start() print '\tPatch size', len(cells_in_radius(c0, mesh, c2c, 0.4)) dt = t.stop() return mesh.num_cells(), dt
def __init__(self, model_name="cylinder_demo3d"): pyurdme.URDMEModel.__init__(self, model_name) # System constants D_const = 0.1 # Define Species A = pyurdme.Species(name="A", diffusion_constant=D_const) B = pyurdme.Species(name="B", diffusion_constant=D_const) self.add_species([A, B]) # Define Geometry pt1 = dolfin.Point(MAX_X_DIM, 0, 0) pt2 = dolfin.Point(MIN_X_DIM, 0, 0) cylinder = mshr.Cylinder(pt1, pt2, 1.0, 1.0) self.mesh = pyurdme.URDMEMesh(mesh=mshr.generate_mesh(cylinder, 32)) # Define Subdomains self.add_subdomain(Edge1(), 2) self.add_subdomain(Edge2(), 3) data = self.get_solver_datastructure() vol = data['vol'] sd = data['sd'] left = numpy.sum(vol[sd == 2]) right = numpy.sum(vol[sd == 3]) k_react = pyurdme.Parameter(name="k_react", expression=1.0) k_creat1 = pyurdme.Parameter(name="k_creat1", expression=100/left) k_creat2 = pyurdme.Parameter(name="k_creat2", expression=100/right) self.add_parameter([k_react, k_creat1,k_creat2]) # Define Reactions R1 = pyurdme.Reaction(name="R1", reactants=None, products={A:1}, rate=k_creat1, restrict_to=2) R2 = pyurdme.Reaction(name="R2", reactants=None, products={B:1}, rate=k_creat2, restrict_to=3) R3 = pyurdme.Reaction(name="R3", reactants={A:1, B:1}, products=None, rate=k_react) self.add_reaction([R1, R2, R3]) # Define simulation timespan self.timespan(range(200))
def create_toy_mesh(): box = mshr.Box(dolfin.Point(-3, -1, -0.5), dolfin.Point(3, 1, 0.5)) c1 = mshr.Cylinder(dolfin.Point(0, 0, -2), dolfin.Point(0, 0, 2), 0.6, 0.6) b1 = mshr.Box(dolfin.Point(-2.5, -0.5, -2), dolfin.Point(-1.5, 0.5, 2)) # "triangle" t1 = mshr.Polygon( [ dolfin.Point(2.5, -0.5, 0), dolfin.Point(2.5, 0.5, 0), dolfin.Point(1.5, -0.5, 0), ] ) g3d = mshr.Extrude2D(t1, -2) g3d = mshr.CSGTranslation(g3d, dolfin.Point(0, 0, 1)) m = mshr.generate_mesh(box - c1 - b1 - g3d, 40, "cgal") return m.coordinates(), m.cells()
def get(self): """ Generate polygon from top and bottom curves. """ m, M, top, bottom, var, N = self.pad(self.values) top = evaluate(top)[0] bottom = evaluate(bottom)[0] if var == 'x': points = [Point(x, top(x)) for x in np.linspace(m, M, N+2)] else: points = [Point(top(x), x) for x in np.linspace(m, M, N+2)] if abs(top(M)-bottom(M)) < 1E-4: points.pop() if var == 'x': points += [Point(x, bottom(x)) for x in np.linspace(M, m, N+2)] else: points += [Point(bottom(x), x) for x in np.linspace(M, m, N+2)] if abs(top(m)-bottom(m)) < 1E-4: points.pop() try: # may fail if not counterclockwise vertices poly = Polygon(points) except: poly = Polygon(points[::-1]) return generate_mesh(poly, 1)
def kernel_collision(mesh, filter_radius): """ Calculate the kernel support using the dolfin collision function More inefficient than the current DFS """ # Build circle or kernel support domain = mshr.Circle(Point(0.,0.), filter_radius) circle_mesh = mshr.generate_mesh(domain, 60, "cgal") # Build bounding box trees for background mesh tree_A = BoundingBoxTree() tree_A.build(mesh) # Bounding box for the circle tree_circle = BoundingBoxTree() for c in cells(mesh): cell_centroid = c.midpoint() circle_mesh.translate(cell_centroid) # Rebuild the tree tree_circle.build(circle_mesh) entities_AB, entities_B = tree_A.compute_collisions(tree_circle)
import mshr from dolfin import * # issue 37 g = mshr.Rectangle(Point(0.0, 0.0), Point(2.2, .41)) - mshr.Circle(Point(.2, .2), .05, 40) m = mshr.generate_mesh(g, 50) # issue 41 (failed only in parallel) c = mshr.Extrude2D(mshr.Circle(Point(0, 0, 0), 1), 1) m = mshr.generate_mesh(c, 10)
def get(self): """Use mshr Cylinder, though centers seem to not work.""" h, b, t, n, k = self.pad(self.values) from mshr import Cylinder c = Cylinder(Point(0, 0, 0), Point(0, 0, h), b, t, n) return generate_mesh(c, k)
# 25, 25, 25 # ) # mesh = pyfvm.meshTetra.meshTetra(vertices, cells) # vertices, cells = meshzoo.rectangle.create_mesh( # 0.0, 2.0, # 0.0, 1.0, # 401, 201, # zigzag=True # ) # mesh = pyfvm.meshTri.meshTri(vertices, cells) import mshr import dolfin h = 2.5e-2 # cell_size = 2 * pi / num_boundary_points c = mshr.Circle(dolfin.Point(0., 0., 0.), 1, int(2*pi / h)) # cell_size = 2 * bounding_box_radius / res m = mshr.generate_mesh(c, 2.0 / h) coords = m.coordinates() coords = numpy.c_[coords, numpy.zeros(len(coords))] mesh = pyfvm.meshTri.meshTri(coords, m.cells()) linear_system = pyfvm.discretize(Poisson(), mesh) ml = pyamg.ruge_stuben_solver(linear_system.matrix) x = ml.solve(linear_system.rhs, tol=1e-10) # from scipy.sparse import linalg # x = linalg.spsolve(linear_system.matrix, linear_system.rhs) mesh.write('out.vtu', point_data={'x': x})
from block import block_mat, block_vec, block_bc from dolfin import * from xii import * import mshr N = 10 EPS = 1E-3 R = 0.25 box_domain = mshr.Box(dolfin.Point(0, 0, 0), dolfin.Point(1, 1, 1)) _mesh = mshr.generate_mesh(box_domain, N) stokes_subdomain = dolfin.CompiledSubDomain( "sqrt((x[0]-0.5) * (x[0]-0.5) + (x[1]-0.5) * (x[1]-0.5)) < R", R=R ) subdomains = MeshFunction('size_t', _mesh, _mesh.topology().dim(), 0) # Awkward marking for cell in cells(_mesh): x = cell.midpoint().array() if stokes_subdomain.inside(x, False): subdomains[cell] = 1 else: subdomains[cell] = 0 submeshes, interface, _ = mortar_meshes(subdomains, range(2), strict=True, tol=EPS) stokes_domain = submeshes[0] porous_domain = submeshes[1]
from dolfin import * import mshr # The ellipse is completely contained in the circle and will not be # visible in the resulting mesh, but it is so small that with # mesh_resolution = 10 that when converting it to a polygon the number # of segments in the polygon will be 0 (ie. the polygon is degenerate) # if not handled correctly. c = mshr.Circle(Point(0, 0), 1.5) e = mshr.Ellipse(Point(.05, 0), .01, .05) mesh = mshr.generate_mesh(c+e, 10)
# Copyright (C) 2015 Benjamin Kehlet # # This file is part of mshr. # # mshr is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # mshr 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with mshr. If not, see <http://www.gnu.org/licenses/>. # This demo illustrates how a 2D geometry can be extruded to 3D. from dolfin import * import mshr g2d = mshr.Circle(Point(0,0), 1.2) + mshr.Circle(Point(0, 1.2), 1.2) # Any simple 2D geometry can be extruded to 3D g3d = mshr.Extrude2D(g2d, .2) # The z "thickness" m = mshr.generate_mesh(g3d, 15) plot(m, interactive=True)
def Regular(n, size=50): """Build mesh for a regular polygon with n sides.""" points = [(np.cos(2*np.pi*i/n), np.sin(2*np.pi*i/n)) for i in range(n)] polygon = Polygon([Point(*p) for p in points]) return generate_mesh(polygon, size)
import numpy as np import pylab from dolfin import * #### Rotating cylinders #### # physical values u0 = Constant(0) u1 = Constant(1) # Create mesh c1 = mshh.Circle(Point(0, 0, 0), 1.0) c2 = mshh.Circle(Point(0, 0, 0), 3.0) geometry = c2-c1 mesh = mshh.generate_mesh(geometry, 8) # function spaces and functions V = FunctionSpace(mesh, "Lagrange", 1) u = TrialFunction(V) v = TestFunction(V) class Inner(SubDomain): def inside(self, x, on_boundry): return on_boundry class Outer(SubDomain): def inside(self, x, on_boundry): return (sqrt(x[0]*x[0] + x[1]*x[1]) > 1.5) and on_boundry out_circ = Outer()
def generate_tower_mesh(quality=20): otri = mshr.Polygon([Point(0, 0), Point(1, 0), Point(0.5, 1)]) itri = mshr.Polygon([Point(0.2, 0.0), Point(0.8, 0.0), Point(0.5, 0.75)]) domain = otri - itri return mshr.generate_mesh(domain, quality)
def CircleMesh(p, r, s): """ mshr has no CircleMesh. """ return generate_mesh(Circle(p, r, max(int(4 * pi / s), 4)), int(2 / s))
# Define domain H = 0.41 L = 2.5 zero = Point(0.0, 0.0, 0.0) corner = Point(L, H, H) box = mshr.Box(zero, corner) cyl_offset = 0.5 right = Point(cyl_offset, 0.2, H) left = Point(cyl_offset, 0.2, 0) radius = 0.05 cylinder = mshr.Cylinder(left, right, radius, radius) geometry = box - cylinder # Build mesh mesh = mshr.generate_mesh(geometry, factor) print(mesh) plot(mesh, title="mesh", interactive=True) exit() # Construct facet markers bndry = FacetFunction("size_t", mesh) for f in facets(mesh): mp = f.midpoint() if near(mp[0], 0.0): bndry[f] = 1 # inflow elif near(mp[0], L): bndry[f] = 2 # outflow elif near(mp[1], 0.0) or near(mp[1], W): bndry[f] = 3 # walls elif mp.distance(center) <= radius: bndry[f] = 5 # cylinder
############################################################################################################# ### Test 1: Hexagon ############################################################################################################# for N in range(4,21): x = empty((N,)) y = empty((N,)) for n in range(N): x[n] = cos(2.*pi*n/N) y[n] = sin(2.*pi*n/N) interior_angles = 180.*(N - 2)/N if interior_angles > 90: interior_angles = 180 - interior_angles mesh = generate_mesh(Polygon([Point(xx,yy) for xx,yy in zip(x,y)]), N) markers1 = detect_colinearity(mesh, interior_angles - 1) markers2 = detect_colinearity(mesh, interior_angles + 1) # number of tags should be equal to the number of sides of the polygon plus the interior tag if len(unique(markers1.array())) != N+1: raise RuntimeError('Test failed: number of tags assigned by colinearity_detection is wrong') # number of tags should be equal to the number of sides of the polygon divided by 2 plus the interior tag # this is because colinearity is checked with respect to the first untagged facet found if len(unique(markers2.array())) != int(N/2)+1: raise RuntimeError('Test failed: number of tags assigned by colinearity_detection is wrong') #############################################################################################################
"report": True, "maximum_iterations": 10}} compiler_parameters = {"optimize": True, "cpp_optimize": True, "cpp_optimize_flags": "-O3 -ffast-math -march=native"} output = File("solutions/laplace-young2/sol5.pvd") # Mesh properties (for ellipse and rectangle) a = 1.0; b = 1.0; xn = 100 yn = 100 # Ellipse (figure 1) domain = mshr.Ellipse(Point(0.0, 0.0), a, b, xn) mesh = mshr.generate_mesh(domain, 50, "cgal") # Droplet #u_0 = Expression('''0.5*sqrt(1 - x[0]*x[0]/(a*a) - x[1]*x[1]/(b*b) + 0.01 )''', a = a, b = b) # Wrinkled disc u_0 = Expression('''0.5*(1 - 0.5*sin(2*x[0]*x[0]/(b*b) + 10*x[1]*x[1]/(a*a)) )''', a = a, b = b) # Triangular pizza mesh (Figure 2/3/4) # a = 1.0; # b = 3.0; # triangle = mshr.Polygon([Point(-a, 0.0), Point(a, 0.0), Point(0.0, b)]) # half_circle = mshr.Ellipse(Point(0.0, 0.0), a, a, xn) - \ # mshr.Rectangle(Point(-a, 0.0), Point(a,a)) # domain = triangle + half_circle # mesh = mshr.generate_mesh(domain, xn, "cgal") # u_0 = Expression('''0.3*(1 - 0.5*x[0]*x[0]
Top = 1.0 Bottom = -1.0 lb_corner = Point( Left, Bottom ) rt_corner = Point( Right, Top ) t2 = mshr.Polygon( points ) ## number of elements N = 1 ## L-shaped domain domain = mshr.Rectangle( lb_corner, rt_corner ) - t2 mesh = mshr.generate_mesh( domain, N ) # Global mesh refinement #markers = CellFunction("bool", mesh) #markers.set_all(True) #mesh = refine(mesh, markers, redistribute=False) initRef = 0 for i in range(initRef): mesh = refine( mesh ) nelem = mesh.num_cells() print 'Mesh with ', nelem , 'elements was generated.'
from dolfin import * import mshr domain = mshr.Circle(Point(0.,0), 1.0) circle_mesh = mshr.generate_mesh(domain, 20) def boundary_projection(f, V): u, v = TrialFunction(V), TestFunction(V) #ds = Measure("ds", domain=circle_mesh) #dx = Measure("dx", domain=circle_mesh) a = inner(u,v) * ds + Constant(0)*inner(u,v)*dx # ensure existing diagonal L = inner(f, v) * ds # solve A, b = assemble_system(a, L) A.ident_zeros() #fix interior dofs Pf = Function(V) solve(A, Pf.vector(), b) return Pf def nodal_normal(V): n_ufl = FacetNormal(V.mesh()) return boundary_projection(n_ufl, V) def nodal_tangent(V): #import IPython; IPython.embed() n_ufl = FacetNormal(V.mesh()) t_ufl = cross(as_vector((0,0,1)), as_vector((n_ufl[0], n_ufl[1], 0)))
#Choose a domain domain = 0 #Choose a domain 0 = unit circle, 1 = Unit square, 2 = Square centred at 0 width 1, 4 = curved square, 5 = non symmetric domain, 6 = oval #Choose an initial guess, i.e. u_0 prob = 0 # Function spaces for the solution and Hessian solution_space = "CG" Hessian_solution_space = "CG" e_L2 = []; e_H1 = []; e_H2 = []; e_D2 = []; ndof = []; one = []; # Create the triangulation of the computational domain if domain==0: dom = mshr.Circle(Point(0.0,0.0),1.0,60) mesh = mshr.generate_mesh(dom,20,"cgal") parameters['allow_extrapolation'] = True PENALTY = False #toggling boundary condition penalty parameter plot(mesh,interactive = True) elif domain==1: mesh = UnitSquareMesh(50, 50) PENALTY = 1 #toggling boundary condition penalty parameter elif domain==2: mesh = RectangleMesh(-0.5,-0.5,0.5,0.5,50,50,'left') parameters['allow_extrapolation'] = True PENALTY = True #toggling boundary condition penalty parameter elif domain==3: mesh = RectangleMesh(0.5,0.5,1.0,1.0,4, 4,'left') parameters['allow_extrapolation'] = True PENALTY = 1 #toggling boundary condition penalty parameter elif domain==4:
from dolfin import * import numpy as np from math import log as ln, sinh, pi A = 5.0 # big circle radius B = 1.0 # small circle radius C = 1.0 # distance between centers # Create mesh import mshr as mshh big_circle = mshh.Circle(Point(0, 0, 0), A) small_circle = mshh.Circle(Point(-1.0, 0, 0), B) geometry = big_circle - small_circle mesh1 = mshh.generate_mesh(geometry, 10) mesh2 = mshh.generate_mesh(geometry, 20) mesh3 = mshh.generate_mesh(geometry, 40) mesh4 = mshh.generate_mesh(geometry, 80) def solver(mesh, deg): # Physical parameters dpdx = Constant(-1) mu = Constant(100) V = FunctionSpace(mesh, "Lagrange", deg) u = TrialFunction(V) v = TestFunction(V) # Mark boundary subdomians class Sides(SubDomain):