def make_mesh_info_with_inner_tube(rz, tube_r, radial_subdiv, max_inner_volume=1e-4): # chop off points with zero radius while rz[0][0] == 0: rz.pop(0) while rz[-1][0] == 0: rz.pop(-1) # construct outer cylinder first_z = rz[0][1] last_z = rz[-1][1] rz.insert(0, (tube_r, first_z)) rz.append((tube_r, last_z)) from meshpy.tet import MeshInfo from meshpy.geometry import EXT_OPEN, generate_surface_of_revolution outer_points, outer_facets, outer_facet_holestarts, outer_facet_markers = \ generate_surface_of_revolution(rz, closure=EXT_OPEN, radial_subdiv=radial_subdiv) outer_point_indices = tuple(range(len(outer_points))) inner_points, inner_facets, inner_facet_holestarts, inner_facet_markers = \ generate_surface_of_revolution( [(0,first_z), (tube_r, first_z), (tube_r, last_z), (0, last_z)], point_idx_offset=len(outer_points), radial_subdiv=radial_subdiv, ring_point_indices=[ None, outer_point_indices[:radial_subdiv], outer_point_indices[-radial_subdiv:], None, ] ) points = outer_points + inner_points facets = outer_facets + inner_facets facet_holestarts = outer_facet_holestarts + inner_facet_holestarts facet_markers = outer_facet_markers + inner_facet_markers mesh_info = MeshInfo() mesh_info.set_points(points) mesh_info.set_facets_ex(facets, facet_holestarts, facet_markers) # set regional max. volume mesh_info.regions.resize(1) mesh_info.regions[0] = [0, 0,(first_z+last_z)/2, 0, max_inner_volume] return mesh_info
def main(): from math import pi, cos, sin from meshpy.tet import MeshInfo, build from meshpy.geometry import \ generate_surface_of_revolution, EXT_OPEN, \ GeometryBuilder r = 3 points = 10 dphi = pi/points def truncate(r): if abs(r) < 1e-10: return 0 else: return r rz = [(truncate(r*sin(i*dphi)), r*cos(i*dphi)) for i in range(points+1)] geob = GeometryBuilder() geob.add_geometry(*generate_surface_of_revolution(rz, closure=EXT_OPEN, radial_subdiv=10)) mesh_info = MeshInfo() geob.set(mesh_info) mesh = build(mesh_info) mesh.write_vtk("ball.vtk")
def main(): from math import pi, cos, sin from meshpy.tet import MeshInfo, build from meshpy.geometry import \ generate_surface_of_revolution, EXT_OPEN, \ GeometryBuilder r = 1 l = 1 rz = [(0, 0), (r, 0), (r, l), (0, l)] geob = GeometryBuilder() geob.add_geometry(*generate_surface_of_revolution( rz, radial_subdiv=20, ring_markers=[1, 2, 3])) mesh_info = MeshInfo() geob.set(mesh_info) mesh = build(mesh_info, max_volume=0.01) mesh.write_vtk("cylinder.vtk") mesh.write_neu(file("cylinder.neu", "w"), { 1: ("minus_z", 1), 2: ("outer", 2), 3: ("plus_z", 3), })
def create_ball_mesh(num_longi_points=10): radius = 5.0 radial_subdiv = 2 * num_longi_points dphi = np.pi / num_longi_points # Make sure the nodes meet at the poles of the ball. def truncate(r): if abs(r) < 1e-10: return 0 else: return r # Compute the volume of a canonical tetrahedron # with edgelength radius*dphi. a = radius * dphi canonical_tet_volume = np.sqrt(2.0) / 12 * a**3 # Build outline for surface of revolution. rz = [(truncate(radius * np.sin(i * dphi)), radius * np.cos(i * dphi)) for i in range(num_longi_points + 1)] geob = GeometryBuilder() geob.add_geometry(*generate_surface_of_revolution( rz, closure=EXT_OPEN, radial_subdiv=radial_subdiv)) mesh_info = MeshInfo() geob.set(mesh_info) meshpy_mesh = build(mesh_info, max_volume=canonical_tet_volume) return np.array(meshpy_mesh.points), np.array(meshpy_mesh.elements)
def main(): from math import pi, cos, sin from meshpy.tet import MeshInfo, build from meshpy.geometry import \ generate_surface_of_revolution, EXT_OPEN, \ GeometryBuilder r = 1 l = 1 rz = [(0,0), (r,0), (r,l), (0,l)] geob = GeometryBuilder() geob.add_geometry(*generate_surface_of_revolution(rz, radial_subdiv=20, ring_markers=[1,2,3])) mesh_info = MeshInfo() geob.set(mesh_info) mesh = build(mesh_info, max_volume=0.01) mesh.write_vtk("cylinder.vtk") mesh.write_neu(open("cylinder.neu", "w"), { 1: ("minus_z", 1), 2: ("outer", 2), 3: ("plus_z", 3), })
def make_inverse_mesh_info(rz, radial_subdiv): # chop off points with zero radius while rz[0][0] == 0: rz.pop(0) while rz[-1][0] == 0: rz.pop(-1) # construct outer cylinder ((min_r, max_r), (min_z, max_z)) = bounding_box(rz) if rz[0][1] < rz[-1][1]: # built in positive z direction rz.extend([ (max_r+2, max_z), (max_r+2, min_z), ]) else: rz.extend([ (max_r+2, min_z), (max_r+2, max_z), ]) from meshpy.tet import MeshInfo from meshpy.geometry import EXT_CLOSED_IN_RZ, \ generate_surface_of_revolution points, facets, facet_holestarts, facet_markers = \ generate_surface_of_revolution(rz, closure=EXT_CLOSED_IN_RZ, radial_subdiv=radial_subdiv) mesh_info = MeshInfo() mesh_info.set_points(points) mesh_info.set_facets_ex(facets, facet_holestarts, facet_markers) return mesh_info
def main(): from math import pi, cos, sin from meshpy.tet import MeshInfo, build from meshpy.geometry import ( generate_surface_of_revolution, EXT_OPEN, GeometryBuilder, ) r = 3 points = 10 dphi = pi / points def truncate(r): if abs(r) < 1e-10: return 0 else: return r rz = [(truncate(r * sin(i * dphi)), r * cos(i * dphi)) for i in range(points + 1)] geob = GeometryBuilder() geob.add_geometry(*generate_surface_of_revolution( rz, closure=EXT_OPEN, radial_subdiv=10)) mesh_info = MeshInfo() geob.set(mesh_info) mesh = build(mesh_info) mesh.write_vtk("ball.vtk")
def create_mesh(big_r=1.0, small_r=0.5, num_points=10): dphi = 2 * np.pi / num_points # Compute the volume of a canonical tetrahedron # with edgelength radius2*dphi. a = small_r * dphi canonical_tet_volume = np.sqrt(2.0) / 12 * a ** 3 radial_subdiv = int(2 * np.pi * big_r / a) rz = [ (big_r + small_r * np.cos(i * dphi), 0.5 * small_r * np.sin(i * dphi)) for i in range(num_points) ] geob = GeometryBuilder() geob.add_geometry( *generate_surface_of_revolution( rz, closure=EXT_CLOSED_IN_RZ, radial_subdiv=radial_subdiv ) ) mesh_info = MeshInfo() geob.set(mesh_info) meshpy_mesh = build(mesh_info, max_volume=canonical_tet_volume) return np.array(meshpy_mesh.points), np.array(meshpy_mesh.elements)
def main(): from math import pi, cos, sin from meshpy.tet import MeshInfo, build from meshpy.geometry import ( generate_surface_of_revolution, EXT_CLOSED_IN_RZ, GeometryBuilder, ) big_r = 3 little_r = 2.9 points = 50 dphi = 2 * pi / points rz = [(big_r + little_r * cos(i * dphi), little_r * sin(i * dphi)) for i in range(points)] geob = GeometryBuilder() geob.add_geometry(*generate_surface_of_revolution( rz, closure=EXT_CLOSED_IN_RZ, radial_subdiv=20)) mesh_info = MeshInfo() geob.set(mesh_info) mesh_info.save_nodes("torus") mesh_info.save_poly("torus") mesh = build(mesh_info) mesh.write_vtk("torus.vtk") mesh.save_elements("torus_mesh") mesh.save_nodes("torus_mesh") mesh.write_neu(open("torus.neu", "w"), {1: ("pec", 0)})
def main(): from math import pi, cos, sin from meshpy.tet import MeshInfo, build from meshpy.geometry import generate_surface_of_revolution,\ EXT_CLOSED_IN_RZ, GeometryBuilder big_r = 3 little_r = 2.9 points = 50 dphi = 2*pi/points rz = [(big_r+little_r*cos(i*dphi), little_r*sin(i*dphi)) for i in range(points)] geob = GeometryBuilder() geob.add_geometry(*generate_surface_of_revolution(rz, closure=EXT_CLOSED_IN_RZ, radial_subdiv=20)) mesh_info = MeshInfo() geob.set(mesh_info) mesh_info.save_nodes("torus") mesh_info.save_poly("torus") mesh = build(mesh_info) mesh.write_vtk("torus.vtk") mesh.save_elements("torus_mesh") mesh.save_nodes("torus_mesh") mesh.write_neu(file("torus.neu", "w"), {1: ("pec", 0)})
def ball(h): from meshpy.geometry import ( EXT_OPEN, GeometryBuilder, generate_surface_of_revolution, ) from meshpy.tet import MeshInfo, build r = 3 polar_subdivision = int(math.pi / h) dphi = math.pi / polar_subdivision def truncate(val): return 0 if abs(val) < 1e-10 else val rz = [ [truncate(r * math.sin(i * dphi)), r * math.cos(i * dphi)] for i in range(polar_subdivision + 1) ] geob = GeometryBuilder() radial_subdivision = int(2 * math.pi / h) geob.add_geometry( *generate_surface_of_revolution( rz, closure=EXT_OPEN, radial_subdiv=radial_subdivision ) ) mesh_info = MeshInfo() geob.set(mesh_info) mesh = build(mesh_info) return numpy.array(mesh.points), numpy.array(mesh.elements)
def main(): import numpy as np from math import pi, cos, sin from meshpy.tet import MeshInfo, build from meshpy.geometry import \ GeometryBuilder, generate_surface_of_revolution, EXT_CLOSED_IN_RZ big_r = 3 little_r = 1.5 points = 50 dphi = 2*pi/points rz = np.array([[big_r+little_r*cos(i*dphi), little_r*sin(i*dphi)] for i in range(points)]) geo = GeometryBuilder() geo.add_geometry( *generate_surface_of_revolution(rz, closure=EXT_CLOSED_IN_RZ, radial_subdiv=20)) mesh_info = MeshInfo() geo.set(mesh_info) mesh = build(mesh_info) def tet_face_vertices(vertices): return [(vertices[0], vertices[1], vertices[2]), (vertices[0], vertices[1], vertices[3]), (vertices[0], vertices[2], vertices[3]), (vertices[1], vertices[2], vertices[3]), ] face_map = {} for el_id, el in enumerate(mesh.elements): for fid, face_vertices in enumerate(tet_face_vertices(el)): face_map.setdefault(frozenset(face_vertices), []).append((el_id, fid)) adjacency = {} for face_vertices, els_faces in face_map.items(): if len(els_faces) == 2: (e1, f1), (e2, f2) = els_faces adjacency.setdefault(e1, []).append(e2) adjacency.setdefault(e2, []).append(e1) from pymetis import part_graph cuts, part_vert = part_graph(17, adjacency) try: import pyvtk except ImportError: print("Test succeeded, but could not import pyvtk to visualize result") else: vtkelements = pyvtk.VtkData( pyvtk.UnstructuredGrid(mesh.points, tetra=mesh.elements), "Mesh", pyvtk.CellData(pyvtk.Scalars(part_vert, name="partition"))) vtkelements.tofile('split.vtk')
def test_tet_mesh(visualize=False): pytest.importorskip("meshpy") from math import pi, cos, sin from meshpy.tet import MeshInfo, build from meshpy.geometry import \ GeometryBuilder, generate_surface_of_revolution, EXT_CLOSED_IN_RZ pytest.importorskip("meshpy") big_r = 3 little_r = 1.5 points = 50 dphi = 2 * pi / points rz = np.array( [[big_r + little_r * cos(i * dphi), little_r * sin(i * dphi)] for i in range(points)]) geo = GeometryBuilder() geo.add_geometry(*generate_surface_of_revolution( rz, closure=EXT_CLOSED_IN_RZ, radial_subdiv=20)) mesh_info = MeshInfo() geo.set(mesh_info) mesh = build(mesh_info) def tet_face_vertices(vertices): return [ (vertices[0], vertices[1], vertices[2]), (vertices[0], vertices[1], vertices[3]), (vertices[0], vertices[2], vertices[3]), (vertices[1], vertices[2], vertices[3]), ] face_map = {} for el_id, el in enumerate(mesh.elements): for fid, face_vertices in enumerate(tet_face_vertices(el)): face_map.setdefault(frozenset(face_vertices), []).append( (el_id, fid)) adjacency = {} for face_vertices, els_faces in face_map.items(): if len(els_faces) == 2: (e1, f1), (e2, f2) = els_faces adjacency.setdefault(e1, []).append(e2) adjacency.setdefault(e2, []).append(e1) cuts, part_vert = pymetis.part_graph(17, adjacency) if visualize: import pyvtk vtkelements = pyvtk.VtkData( pyvtk.UnstructuredGrid(mesh.points, tetra=mesh.elements), "Mesh", pyvtk.CellData(pyvtk.Scalars(part_vert, name="partition"))) vtkelements.tofile('split.vtk')
def test_tet_mesh(visualize=False): from math import pi, cos, sin from meshpy.tet import MeshInfo, build from meshpy.geometry import GeometryBuilder, generate_surface_of_revolution, EXT_CLOSED_IN_RZ pytest.importorskip("meshpy") big_r = 3 little_r = 1.5 points = 50 dphi = 2*pi/points rz = np.array([[big_r+little_r*cos(i*dphi), little_r*sin(i*dphi)] for i in range(points)]) geo = GeometryBuilder() geo.add_geometry( *generate_surface_of_revolution(rz, closure=EXT_CLOSED_IN_RZ, radial_subdiv=20)) mesh_info = MeshInfo() geo.set(mesh_info) mesh = build(mesh_info) def tet_face_vertices(vertices): return [(vertices[0], vertices[1], vertices[2]), (vertices[0], vertices[1], vertices[3]), (vertices[0], vertices[2], vertices[3]), (vertices[1], vertices[2], vertices[3]), ] face_map = {} for el_id, el in enumerate(mesh.elements): for fid, face_vertices in enumerate(tet_face_vertices(el)): face_map.setdefault(frozenset(face_vertices), []).append((el_id, fid)) adjacency = {} for face_vertices, els_faces in face_map.items(): if len(els_faces) == 2: (e1, f1), (e2, f2) = els_faces adjacency.setdefault(e1, []).append(e2) adjacency.setdefault(e2, []).append(e1) import ipdb; ipdb.set_trace() cuts, part_vert = pymetis.part_graph(17, adjacency) if visualize: import pyvtk vtkelements = pyvtk.VtkData( pyvtk.UnstructuredGrid(mesh.points, tetra=mesh.elements), "Mesh", pyvtk.CellData(pyvtk.Scalars(part_vert, name="partition"))) vtkelements.tofile('split.vtk')
def make_mesh_info(rz, radial_subdiv): from meshpy.tet import MeshInfo from meshpy.geometry import EXT_OPEN, generate_surface_of_revolution points, facets, facet_holestarts, facet_markers = \ generate_surface_of_revolution(rz, closure=EXT_OPEN, radial_subdiv=radial_subdiv) mesh_info = MeshInfo() mesh_info.set_points(points) mesh_info.set_facets_ex(facets, facet_holestarts, facet_markers) return mesh_info
def main(): from meshpy.tet import MeshInfo, build from meshpy.geometry import generate_surface_of_revolution, GeometryBuilder simple_rz = [(0, 0), (1, 1), (1, 2), (0, 3)] geob = GeometryBuilder() geob.add_geometry(*generate_surface_of_revolution(simple_rz)) mesh_info = MeshInfo() geob.set(mesh_info) # mesh_info.save_nodes("test") # mesh_info.save_poly("test") # mesh_info.load_poly("test") mesh = build(mesh_info) mesh.write_vtk("my_mesh.vtk")
def main(): from meshpy.tet import MeshInfo, build from meshpy.geometry import generate_surface_of_revolution, GeometryBuilder simple_rz = [ (0, 0), (1, 1), (1, 2), (0, 3), ] geob = GeometryBuilder() geob.add_geometry(*generate_surface_of_revolution(simple_rz)) mesh_info = MeshInfo() geob.set(mesh_info) # mesh_info.save_nodes("test") # mesh_info.save_poly("test") # mesh_info.load_poly("test") mesh = build(mesh_info) mesh.write_vtk("my_mesh.vtk")
def createSphere(center, R, m, n, mv=1): """ The function computes the panelisation of a sphere using the predefined tools available in the Python module meshpy. INPUTS: - R: radius of the sphere (m) - m: number of radial subdivisions of the mesh (integer) - n: number of circumferential subdivisions of the mesh (integer) - mv: maxium valume of an element in the thetrahedral mesh (the mesh is actually 3D but we only extract the surface panels) OUTPUTS: - verts: coordinates of each vertices of the panelisation - faces: triplets of indices representing the vertices of each triangular panel - tris: triplets explicitly representing the coordinates of the vertices of each triangular face. """ rz = [] rz.append((0, R)) for i in xrange(1, n): rz.append((R * np.sin(i * np.pi / n), R * np.cos(i * np.pi / n))) rz.append((0, -R)) geob = GeometryBuilder() geob.add_geometry(*generate_surface_of_revolution(rz, radial_subdiv=m)) mesh_info = MeshInfo() geob.set(mesh_info) mesh = build(mesh_info, max_volume=mv) verts = np.array(mesh.points) faces = np.array(mesh.faces) tris = verts[faces] bars = [] return verts, bars, faces # , tris
def test_torus(): from math import pi, cos, sin from meshpy.tet import MeshInfo, build from meshpy.geometry import generate_surface_of_revolution, \ EXT_CLOSED_IN_RZ, GeometryBuilder big_r = 3 little_r = 2.9 points = 50 dphi = 2*pi/points rz = [(big_r+little_r*cos(i*dphi), little_r*sin(i*dphi)) for i in range(points)] geob = GeometryBuilder() geob.add_geometry(*generate_surface_of_revolution(rz, closure=EXT_CLOSED_IN_RZ, radial_subdiv=20)) mesh_info = MeshInfo() geob.set(mesh_info) build(mesh_info)
def test_torus(): from math import pi, cos, sin from meshpy.tet import MeshInfo, build from meshpy.geometry import generate_surface_of_revolution, \ EXT_CLOSED_IN_RZ, GeometryBuilder big_r = 3 little_r = 2.9 points = 50 dphi = 2 * pi / points rz = [(big_r + little_r * cos(i * dphi), little_r * sin(i * dphi)) for i in range(points)] geob = GeometryBuilder() geob.add_geometry(*generate_surface_of_revolution( rz, closure=EXT_CLOSED_IN_RZ, radial_subdiv=20)) mesh_info = MeshInfo() geob.set(mesh_info) build(mesh_info)
def create_ball_mesh(num_longi_points=10): radius = 5.0 radial_subdiv = 2 * num_longi_points dphi = np.pi / num_longi_points # Make sure the nodes meet at the poles of the ball. def truncate(r): if abs(r) < 1e-10: return 0 else: return r # Compute the volume of a canonical tetrahedron # with edgelength radius*dphi. a = radius * dphi canonical_tet_volume = np.sqrt(2.0) / 12 * a ** 3 # Build outline for surface of revolution. rz = [ (truncate(radius * np.sin(i * dphi)), radius * np.cos(i * dphi)) for i in range(num_longi_points + 1) ] geob = GeometryBuilder() geob.add_geometry( *generate_surface_of_revolution( rz, closure=EXT_OPEN, radial_subdiv=radial_subdiv ) ) mesh_info = MeshInfo() geob.set(mesh_info) meshpy_mesh = build(mesh_info, max_volume=canonical_tet_volume) return np.array(meshpy_mesh.points), np.array(meshpy_mesh.elements)
def area_of_tri(nodes): v1 = np.array(nodes[0].coord[:2]) - np.array(nodes[1].coord[:2]) v2 = np.array(nodes[0].coord[:2]) - np.array(nodes[2].coord[:2]) area = np.cross(v1, v2) / 2. return area if __name__ == "__main__": #mesh r = 1 l = 2 rz = [(0, 0), (r, 0), (r, l), (0, l)] geob = GeometryBuilder() geob.add_geometry(*generate_surface_of_revolution( rz, radial_subdiv=20, ring_markers=[1, 2, 3])) mesh_info = MeshInfo() geob.set(mesh_info) mesh = build(mesh_info, max_volume=0.01) E = 210e6 nu = 0.3 P = 2000 points = np.array(mesh.points) cells = np.array(mesh.elements) face_cells = np.array(mesh.faces) z_face0_cells = [ c for c in face_cells if np.isclose(points[c][:, 2], 0).all() ] z_face2_cells = [ c for c in face_cells if np.isclose(points[c][:, 2], 2).all()
def make_extrusion_with_fine_core(rz, inner_r, max_volume_inner=1e-4, max_volume_outer=5e-2, radial_subdiv=20): min_z = min(rz_pt[1] for rz_pt in rz) max_z = max(rz_pt[1] for rz_pt in rz) from meshpy.tet import MeshInfo, build from meshpy.geometry import generate_surface_of_revolution MINUS_Z_MARKER = 1 PLUS_Z_MARKER = 2 inner_points, inner_facets, inner_holes, inner_markers = \ generate_surface_of_revolution( [ (0, min_z), (inner_r, min_z), (inner_r, max_z), (0, max_z), ], ring_markers=[ MINUS_Z_MARKER, 0, PLUS_Z_MARKER ], radial_subdiv=radial_subdiv, ) inner_point_indices = tuple(range(len(inner_points))) outer_points, outer_facets, outer_holes, outer_markers = \ generate_surface_of_revolution( [(inner_r,min_z)] + rz + [(inner_r, max_z)], ring_markers=[MINUS_Z_MARKER] + [0]*(len(rz)-1) + [PLUS_Z_MARKER], point_idx_offset=len(inner_points), radial_subdiv=radial_subdiv, ring_point_indices= [ inner_point_indices[:radial_subdiv] ] + [None]*len(rz) + [inner_point_indices[radial_subdiv:]] ) mesh_info = MeshInfo() mesh_info.set_points(inner_points + outer_points) mesh_info.set_facets_ex( inner_facets + outer_facets, inner_holes + outer_holes, inner_markers + outer_markers, ) # set regional max. volume mesh_info.regions.resize(2) mesh_info.regions[0] = [0, 0, (max_z+min_z)/2, 0, max_volume_inner] mesh_info.regions[1] = [inner_r+(rz[0][0]-inner_r)/2, 0, (max_z+min_z)/2, 0, max_volume_outer] # add periodicity mesh_info.pbc_groups.resize(1) pbcg = mesh_info.pbc_groups[0] pbcg.facet_marker_1 = MINUS_Z_MARKER pbcg.facet_marker_2 = PLUS_Z_MARKER pbcg.set_transform(translation=[0,0,max_z-min_z]) mesh = build(mesh_info, verbose=True, volume_constraints=True) #print "%d elements" % len(mesh.elements) #mesh.write_vtk("gun.vtk") fvi2fm = mesh.face_vertex_indices_to_face_marker def zper_boundary_tagger(fvi, el, fn, points): face_marker = fvi2fm[frozenset(fvi)] if face_marker == MINUS_Z_MARKER: return ["minus_z"] elif face_marker == PLUS_Z_MARKER: return ["plus_z"] else: return ["shell"] vertices = numpy.asarray(mesh.points, dtype=float, order="C") from hedge.mesh import make_conformal_mesh_ext from hedge.mesh.element import Tetrahedron return make_conformal_mesh_ext( vertices, [Tetrahedron(i, el_idx, vertices) for i, el_idx in enumerate(mesh.elements)], zper_boundary_tagger, periodicity=[None, None, ("minus_z", "plus_z")])
def make_extrusion_with_fine_core(rz, inner_r, max_volume_inner=1e-4, max_volume_outer=5e-2, radial_subdiv=20): min_z = min(rz_pt[1] for rz_pt in rz) max_z = max(rz_pt[1] for rz_pt in rz) from meshpy.tet import MeshInfo, build from meshpy.geometry import generate_surface_of_revolution MINUS_Z_MARKER = 1 PLUS_Z_MARKER = 2 inner_points, inner_facets, inner_holes, inner_markers = \ generate_surface_of_revolution( [ (0, min_z), (inner_r, min_z), (inner_r, max_z), (0, max_z), ], ring_markers=[ MINUS_Z_MARKER, 0, PLUS_Z_MARKER ], radial_subdiv=radial_subdiv, ) inner_point_indices = tuple(range(len(inner_points))) outer_points, outer_facets, outer_holes, outer_markers = \ generate_surface_of_revolution( [(inner_r,min_z)] + rz + [(inner_r, max_z)], ring_markers=[MINUS_Z_MARKER] + [0]*(len(rz)-1) + [PLUS_Z_MARKER], point_idx_offset=len(inner_points), radial_subdiv=radial_subdiv, ring_point_indices= [ inner_point_indices[:radial_subdiv] ] + [None]*len(rz) + [inner_point_indices[radial_subdiv:]] ) mesh_info = MeshInfo() mesh_info.set_points(inner_points + outer_points) mesh_info.set_facets_ex( inner_facets + outer_facets, inner_holes + outer_holes, inner_markers + outer_markers, ) # set regional max. volume mesh_info.regions.resize(2) mesh_info.regions[0] = [0, 0, (max_z + min_z) / 2, 0, max_volume_inner] mesh_info.regions[1] = [ inner_r + (rz[0][0] - inner_r) / 2, 0, (max_z + min_z) / 2, 0, max_volume_outer ] # add periodicity mesh_info.pbc_groups.resize(1) pbcg = mesh_info.pbc_groups[0] pbcg.facet_marker_1 = MINUS_Z_MARKER pbcg.facet_marker_2 = PLUS_Z_MARKER pbcg.set_transform(translation=[0, 0, max_z - min_z]) mesh = build(mesh_info, verbose=True, volume_constraints=True) #print "%d elements" % len(mesh.elements) #mesh.write_vtk("gun.vtk") fvi2fm = mesh.face_vertex_indices_to_face_marker def zper_boundary_tagger(fvi, el, fn, points): face_marker = fvi2fm[frozenset(fvi)] if face_marker == MINUS_Z_MARKER: return ["minus_z"] elif face_marker == PLUS_Z_MARKER: return ["plus_z"] else: return ["shell"] vertices = numpy.asarray(mesh.points, dtype=float, order="C") from hedge.mesh import make_conformal_mesh_ext from hedge.mesh.element import Tetrahedron return make_conformal_mesh_ext( vertices, [ Tetrahedron(i, el_idx, vertices) for i, el_idx in enumerate(mesh.elements) ], zper_boundary_tagger, periodicity=[None, None, ("minus_z", "plus_z")])