def test_tetgen(): from meshpy.tet import MeshInfo, build mesh_info = MeshInfo() mesh_info.set_points([ (0, 0, 0), (2, 0, 0), (2, 2, 0), (0, 2, 0), (0, 0, 12), (2, 0, 12), (2, 2, 12), (0, 2, 12), ]) mesh_info.set_facets([ [0, 1, 2, 3], [4, 5, 6, 7], [0, 4, 5, 1], [1, 5, 6, 2], [2, 6, 7, 3], [3, 7, 4, 0], ]) build(mesh_info)
def main(): #Test1: mesh testing MeshPoints = [] MeshFacets = [] with open('MeshFacets', 'rb') as input: MeshFacets = pickle.load(input) with open('MeshPoints', 'rb') as input: MeshPoints = pickle.load(input) mesh_info = MeshInfo() mesh_info.regions.resize(1) mesh_info.regions[0] = [ MeshPoints[0][0], MeshPoints[0][1], MeshPoints[0][2], # point in volume -> first box 0, # region tag (user-defined number) 1, # max tet volume in region ] print "Building mesh from {} facets and {} points".format(len(MeshFacets), len(MeshPoints)) try: mesh = build(mesh_info, options=Options(switches="pqT", epsilon=0.01), volume_constraints=True) except: pass try: mesh = build(mesh_info, options=Options(switches="pqT", epsilon=0.0001), volume_constraints=True) except: pass print "Created mesh with {} points, {} faces and {} elements.".format(len(mesh.points), len(mesh.faces), len(mesh.elements))
def tets_from_vertices_faces(vertices, faces, volume=None): """ Generate tetrahedron points and elements with MeshPy (TetGen). Parameters ---------- vertices : list List of lists of vertex co-ordinates for the input surface mesh. faces : list List of lists of face indices for the input surface mesh. volume : float Volume constraint for each tetrahedron element. Returns ------- list Points of the tetrahedrons. list Indices of points for each tetrahedron element. """ try: info = MeshInfo() info.set_points(vertices) info.set_facets(faces) tets = build(info, max_volume=volume) points = [list(i) for i in list(tets.points)] elements = [list(i) for i in list(tets.elements)] return points, elements except: print('***** MeshPy failed *****')
def create_beam(vol): # build using MeshPy from meshpy.tet import MeshInfo, build mesh_info = MeshInfo() mesh_info.set_points([ (0, 0, 0), (0, 1, 0), (0, 1, 1), (0, 0, 1), (5, 0, 0), (5, 1, 0), (5, 1, 1), (5, 0, 1), ]) mesh_info.set_facets([ [0, 1, 2, 3], [4, 5, 6, 7], [0, 1, 5, 4], [1, 2, 6, 5], [0, 3, 7, 4], [3, 2, 6, 7], ]) mesh = build(mesh_info, max_volume=vol) return fmsh.MeshPyTet(mesh)
def generateCubeMesh(): mesh_info = MeshInfo() mesh_info.set_points([ (0, 0, 0), (1, 0, 0), (1, 1, 0), (0, 1, 0), (0, 0, 1), (1, 0, 1), (1, 1, 1), (0, 1, 1), ]) mesh_info.set_facets([ [0, 1, 2, 3], [4, 5, 6, 7], [0, 4, 5, 1], [1, 5, 6, 2], [2, 6, 7, 3], [3, 7, 4, 0], ]) mesh = build(mesh_info) cellList = [] vertexList = [] mupifMesh = Mesh.UnstructuredMesh() print("Mesh Points:") for i, p in enumerate(mesh.points): print(i, p) vertexList.extend([Vertex.Vertex(i, i, p)]) print("Point numbers in tetrahedra:") for i, t in enumerate(mesh.elements): print(i, t) cellList.extend([Cell.Tetrahedron_3d_lin(mupifMesh, i, i, t)]) mupifMesh.setup(vertexList, cellList) return(mupifMesh)
def mesh(self): mesh_info = MeshInfo() mesh_info.set_points(transpose([self.flat_x,self.flat_y,self.flat_z])) mesh = build(mesh_info) print 'yo' for i, t in enumerate(mesh.elements): print i, t
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_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 make_cylinder_mesh(radius=0.5, height=1, radial_subdivisions=10, height_subdivisions=1, max_volume=None, periodic=False, boundary_tagger=(lambda fvi, el, fn, all_v: [])): from meshpy.tet import MeshInfo, build from meshpy.geometry import make_cylinder points, facets, facet_holestarts, facet_markers = \ make_cylinder(radius, height, radial_subdivisions, height_subdivisions) assert len(facets) == len(facet_markers) if periodic: return _make_z_periodic_mesh( points, facets, facet_holestarts, facet_markers, height=height, max_volume=max_volume, boundary_tagger=boundary_tagger) else: mesh_info = MeshInfo() mesh_info.set_points(points) mesh_info.set_facets_ex(facets, facet_holestarts, facet_markers) generated_mesh = build(mesh_info, max_volume=max_volume) from hedge.mesh import make_conformal_mesh_ext from hedge.mesh.element import Tetrahedron vertices = numpy.asarray(generated_mesh.points, dtype=float, order="C") return make_conformal_mesh_ext( vertices, [Tetrahedron(i, el_idx, vertices) for i, el_idx in enumerate(generated_mesh.elements)], boundary_tagger)
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(): mesh_info = MeshInfo() mesh_info.set_points([ (0, 0, 0), (2, 0, 0), (2, 2, 0), (0, 2, 0), (0, 0, 12), (2, 0, 12), (2, 2, 12), (0, 2, 12), ]) mesh_info.set_facets([ [0, 1, 2, 3], [4, 5, 6, 7], [0, 4, 5, 1], [1, 5, 6, 2], [2, 6, 7, 3], [3, 7, 4, 0], ]) mesh_info.save_nodes("bar") mesh_info.save_poly("bar") mesh = build(mesh_info) mesh.save_nodes("barout") mesh.save_elements("barout") mesh.save_faces("barout") mesh.write_vtk("test.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(open("cylinder.neu", "w"), { 1: ("minus_z", 1), 2: ("outer", 2), 3: ("plus_z", 3), })
def PlotTets(): # Get the mesh from meshpy.tet import MeshInfo, build mesh_info = MeshInfo() mesh_info.set_points([(-1, -1, -1), (1, -1, -1), (-1, 1, -1), (-1, -1, 1)]) mesh_info.set_facets([[0, 2, 1], [0, 1, 3], [0, 3, 2], [2, 1, 3]]) mesh = build(mesh_info, max_volume=0.0002) points = np.asarray(mesh.points) elements = np.asarray(mesh.elements) faces = np.asarray(mesh.faces) # mesh.save_faces('/home/roman/Desktop/test.dat') C = 2 nsize = int((C + 2) * (C + 3) * (C + 4) / 6.) Bases = np.zeros((points.shape[0], nsize)) for i in range(0, points.shape[0]): Bases[i, :] = Tet.hpBases(C, points[i, 0], points[i, 1], points[i, 2])[0] mydict = { 'points': points, 'elements': elements, 'faces': faces, 'Bases': Bases } io.savemat( '/home/roman/Desktop/orthopoly/bases_tet_p' + str(C + 1) + '.mat', mydict)
def main(): mesh_info = MeshInfo() mesh_info.set_points([ (0,0,0), (2,0,0), (2,2,0), (0,2,0), (0,0,12), (2,0,12), (2,2,12), (0,2,12), ]) mesh_info.set_facets([ [0,1,2,3], [4,5,6,7], [0,4,5,1], [1,5,6,2], [2,6,7,3], [3,7,4,0], ]) mesh_info.save_nodes("bar") mesh_info.save_poly("bar") mesh = build(mesh_info) mesh.save_nodes("barout") mesh.save_elements("barout") mesh.save_faces("barout") mesh.write_vtk("test.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_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 create_beam(vol): # build using MeshPy from meshpy.tet import MeshInfo,build mesh_info = MeshInfo() mesh_info.set_points([ (0,0,0), (0,1,0), (0,1,1), (0,0,1), (5,0,0), (5,1,0), (5,1,1), (5,0,1), ]) mesh_info.set_facets([ [0,1,2,3], [4,5,6,7], [0,1,5,4], [1,2,6,5], [0,3,7,4], [3,2,6,7], ]) mesh = build(mesh_info,max_volume=vol) return fmsh.MeshPyTet(mesh)
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(): 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 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 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 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 main(): import numpy from math import pi, cos, sin from meshpy.tet import MeshInfo, build from meshpy.geometry import GeometryBuilder, Marker, \ generate_extrusion, make_box from meshpy.naca import generate_naca geob = GeometryBuilder() box_marker = Marker.FIRST_USER_MARKER wing_length = 2 wing_subdiv = 5 rz_points = [ (0, -wing_length * 1.05), (0.7, -wing_length * 1.05), ] + [(r, x) for x, r in zip( numpy.linspace(-wing_length, 0, wing_subdiv, endpoint=False), numpy.linspace(0.8, 1, wing_subdiv, endpoint=False))] + [(1, 0)] + [ (r, x) for x, r in zip( numpy.linspace(wing_length, 0, wing_subdiv, endpoint=False), numpy.linspace(0.8, 1, wing_subdiv, endpoint=False)) ][::-1] + [(0.7, wing_length * 1.05), (0, wing_length * 1.05)] geob.add_geometry(*generate_extrusion( rz_points=rz_points, base_shape=generate_naca("0012", verbose=False, number_of_points=20), ring_markers=(wing_subdiv * 2 + 4) * [box_marker])) from meshpy.tools import make_swizzle_matrix swizzle_matrix = make_swizzle_matrix("z:x,y:y,x:z") geob.apply_transform(lambda p: numpy.dot(swizzle_matrix, p)) def deform_wing(p): x, y, z = p return numpy.array([ x, y + 0.1 * abs(x / wing_length)**2, z + 0.8 * abs(x / wing_length)**1.2 ]) geob.apply_transform(deform_wing) points, facets, _, facet_markers = make_box( numpy.array([-wing_length - 1, -1, -1.5]), numpy.array([wing_length + 1, 1, 3])) geob.add_geometry(points, facets, facet_markers=facet_markers) mesh_info = MeshInfo() geob.set(mesh_info) mesh_info.set_holes([(0, 0, 0.5)]) mesh = build(mesh_info) print "%d elements" % len(mesh.elements) mesh.write_vtk("airfoil3d.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 brep2lar(larBrep): V,FV = larBrep mesh_info = MeshInfo() mesh_info.set_points(V) mesh_info.set_facets(FV) mesh = build(mesh_info) W = [v for h,v in enumerate(mesh.points)] CW = [tet for k,tet in enumerate(mesh.elements)] FW = sorted(set(AA(tuple)(CAT(AA(faces)(CW))))) EW = sorted(set(AA(tuple)(CAT(AA(edges)(FW))))) return W,CW,FW,EW
def brep2lar(larBrep): V, FV = larBrep mesh_info = MeshInfo() mesh_info.set_points(V) mesh_info.set_facets(FV) mesh = build(mesh_info) W = [v for h, v in enumerate(mesh.points)] CW = [tet for k, tet in enumerate(mesh.elements)] FW = sorted(set(AA(tuple)(CAT(AA(faces)(CW))))) EW = sorted(set(AA(tuple)(CAT(AA(edges)(FW))))) return W, CW, FW, EW
def test_tetgen_points(): from meshpy.tet import MeshInfo, build, Options import numpy as np points = np.random.randn(10000, 3) mesh_info = MeshInfo() mesh_info.set_points(points) options = Options("") mesh = build(mesh_info, options=options) print(len(mesh.points)) print(len(mesh.elements))
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 _make_z_periodic_mesh(points, facets, facet_holestarts, facet_markers, height, max_volume, boundary_tagger): from meshpy.tet import MeshInfo, build from meshpy.geometry import Marker mesh_info = MeshInfo() mesh_info.set_points(points) mesh_info.set_facets_ex(facets, facet_holestarts, facet_markers) mesh_info.pbc_groups.resize(1) pbcg = mesh_info.pbc_groups[0] pbcg.facet_marker_1 = Marker.MINUS_Z pbcg.facet_marker_2 = Marker.PLUS_Z pbcg.set_transform(translation=[0, 0, height]) def zper_boundary_tagger(fvi, el, fn, all_v): # we only ask about *boundaries* # we should not try to have the user tag # the (periodicity-induced) interior faces face_marker = fvi2fm[frozenset(fvi)] if face_marker == Marker.MINUS_Z: return ["minus_z"] if face_marker == Marker.PLUS_Z: return ["plus_z"] result = boundary_tagger(fvi, el, fn, all_v) if face_marker == Marker.SHELL: result.append("shell") return result generated_mesh = build(mesh_info, max_volume=max_volume) fvi2fm = generated_mesh.face_vertex_indices_to_face_marker from hedge.mesh import make_conformal_mesh_ext from hedge.mesh.element import Tetrahedron vertices = numpy.asarray(generated_mesh.points, dtype=float, order="C") return make_conformal_mesh_ext( vertices, [Tetrahedron(i, el_idx, vertices) for i, el_idx in enumerate(generated_mesh.elements)], zper_boundary_tagger, periodicity=[None, None, ("minus_z", "plus_z")])
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 optparse import OptionParser description = "generate a vtk mesh from a superfish input file" parser = OptionParser(description=description) parser.add_option( "--point-dist", dest="point_dist", default=0.3, type="float", help="Spacing of intermediate points in circular arcs") parser.add_option( "--inverse", dest="generate_inverse", action="store_true", help="Whether to mesh the inverse of the gun (useless, but fun)") parser.add_option( "--radial-subdiv", dest="radial_subdiv", action="store", type="int", default=16, help="How many radial subdivisions") parser.add_option( "--tube-radius", dest="tube_radius", action="store", type="float", default=0.1, help="Radius of the interior tube") options, args = parser.parse_args() from superfish import parse_superfish_format rz = parse_superfish_format(args[0], options.point_dist) build_kwargs = {} if options.generate_inverse: from rzmesh import inverse_mesh_info_from_rz mesh_info = inverse_mesh_info_from_rz(rz, options.radial_subdiv) elif options.tube_radius: from rzmesh import make_mesh_info_with_inner_tube mesh_info = make_mesh_info_with_inner_tube(rz, options.tube_radius, options.radial_subdiv) build_kwargs["volume_constraints"] = True else: from rzmesh import make_mesh_info mesh_info = make_mesh_info_with_inner_tube(rz, options.radial_subdiv) #mesh_info.save_poly("gun") #mesh_info.save_nodes("gun") from meshpy.tet import build mesh = build(mesh_info, verbose=True, **build_kwargs) print "%d elements" % len(mesh.elements) mesh.write_vtk("gun.vtk")
def main(): from ply import parse_ply import sys data = parse_ply(sys.argv[1]) from meshpy.geometry import GeometryBuilder builder = GeometryBuilder() builder.add_geometry(points=[pt[:3] for pt in data["vertex"].data], facets=[fd[0] for fd in data["face"].data]) builder.wrap_in_box(1) from meshpy.tet import MeshInfo, build mi = MeshInfo() builder.set(mi) mi.set_holes([builder.center()]) mesh = build(mi) print("%d elements" % len(mesh.elements)) mesh.write_vtk("out.vtk")
def main(): from ply import parse_ply import sys data = parse_ply(sys.argv[1]) from meshpy.geometry import GeometryBuilder builder = GeometryBuilder() builder.add_geometry( points=[pt[:3] for pt in data["vertex"].data], facets=[fd[0] for fd in data["face"].data]) builder.wrap_in_box(1) from meshpy.tet import MeshInfo, build mi = MeshInfo() builder.set(mi) mi.set_holes([builder.center()]) mesh = build(mi) print("%d elements" % len(mesh.elements)) mesh.write_vtk("out.vtk")
def main(): import numpy from math import pi, cos, sin from meshpy.tet import MeshInfo, build from meshpy.geometry import GeometryBuilder, Marker, make_box geob = GeometryBuilder() box_marker = Marker.FIRST_USER_MARKER extent_small = 0.1*numpy.ones(3, dtype=numpy.float64) points, facets, _, _ = \ make_box(-extent_small, extent_small) geob.add_geometry(points, facets, facet_markers=box_marker) # make small "separator box" for region attribute geob.wrap_in_box(0.3) points, facets, _, facet_markers = \ make_box(numpy.array([-1,-1,-1]), numpy.array([1,1,5])) geob.add_geometry(points, facets, facet_markers=facet_markers) mesh_info = MeshInfo() geob.set(mesh_info) mesh_info.set_holes([(0,0,0)]) # region attributes mesh_info.regions.resize(1) mesh_info.regions[0] = ( # point in region list(extent_small*2) + [ # region number 1, # max volume in region 0.0001]) mesh = build(mesh_info, max_volume=0.02, volume_constraints=True, attributes=True) print ("%d elements" % len(mesh.elements)) mesh.write_vtk("box-in-box.vtk")
def brep2lar(model,cycles,holes): V,FV,EV = model FE = crossRelation(V,FV,EV) mesh_info = MeshInfo() mesh_info.set_points(V) mesh_info.set_facets_ex(cycles) #mesh_info.set_holes(holes) mesh = build(mesh_info,options=Options("pqYY")) W = [v for h,v in enumerate(mesh.points)] CW = [tet for k,tet in enumerate(mesh.elements)] def simplify(fun): def simplify0(simplices): cellDict = defaultdict(tuple) for cell in CAT(AA(fun)(simplices)): cellDict[tuple(sorted(cell))] = tuple(cell) return cellDict.values() return simplify0 FW = sorted(simplify(faces)(CW)) EW = sorted(simplify(edges)(FW)) return W,CW,FW,EW
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 build_tetmesh(domain, sphere_pieces, boundaries, config): """Handles calling TetGen to construct the tetrahedral mesh. :param domain Domain: spatial domain for mesh. :param sphere_pieces list: list of SpherePiece objects. :param boundaries list: list of boundaryPLC objects. :param config Config: configuration for mesh build. :return mesh: tetrahedral mesh. :rtype: MeshInfo. """ logger.info('Building tetrahedral mesh') boundaries = duplicate_lower_boundaries(domain, boundaries) points = build_point_list(domain, sphere_pieces, boundaries) # Fix boundary points to exactly zero for i in range(3): points[(np.isclose(points[:, i], 0.), i)] = 0. facets, markers = build_facet_list(sphere_pieces, boundaries) holes = build_hole_list(sphere_pieces) rad_edge = config.tetgen_rad_edge_ratio min_angle = config.tetgen_min_angle max_volume = config.tetgen_max_volume options = tet.Options('pq{}/{}nzfennYCV'.format(rad_edge, min_angle)) options.quiet = False mesh = tet.MeshInfo() mesh.set_points(points) mesh.set_facets(facets.tolist(), markers=markers.tolist()) mesh.set_holes(holes) with redirect_tetgen_output(): return tet.build(mesh, options=options, verbose=True, max_volume=max_volume)
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 triangulate(x, y, z, true_x=None, true_y=None, true_z=None): """Triangulate a point cloud. Given a 3-D point cloud, defined by x, y, z, perform a Delauny triangulation and return a list of elements. :param x: (Cartesian) x value. :param y: (Cartesian) y value. :param z: (Cartesian) z value. :returns: A list-of-lists containing connectivity of the resulting mesh. """ print("COMPUTING DELAUNEY TRIANGULATION") # Set up the simplex vertices. pts = np.array((x, y, z)).T # Do the triangulation with MeshPy. # Currently, this seems like the fastest way. mesh_info = MeshInfo() mesh_info.set_points(pts) opts = Options("Q") mesh = build(mesh_info, options=opts) return mesh.elements
def make_ball_mesh(r=0.5, subdivisions=10, max_volume=None, boundary_tagger=(lambda fvi, el, fn, all_v: [])): from meshpy.tet import MeshInfo, build from meshpy.geometry import make_ball points, facets, facet_holestarts, facet_markers = \ make_ball(r, subdivisions) mesh_info = MeshInfo() mesh_info.set_points(points) mesh_info.set_facets_ex(facets, facet_holestarts, facet_markers) generated_mesh = build(mesh_info, max_volume=max_volume) vertices = numpy.asarray(generated_mesh.points, dtype=float, order="C") from hedge.mesh.element import Tetrahedron from hedge.mesh import make_conformal_mesh_ext return make_conformal_mesh_ext( vertices, [Tetrahedron(i, el_idx, vertices) for i, el_idx in enumerate(generated_mesh.elements)], boundary_tagger)
def brep2lar(model, cycles, holes): V, FV, EV = model FE = crossRelation(V, FV, EV) mesh_info = MeshInfo() mesh_info.set_points(V) mesh_info.set_facets_ex(cycles) #mesh_info.set_holes(holes) mesh = build(mesh_info, options=Options("pqYY")) W = [v for h, v in enumerate(mesh.points)] CW = [tet for k, tet in enumerate(mesh.elements)] def simplify(fun): def simplify0(simplices): cellDict = defaultdict(tuple) for cell in CAT(AA(fun)(simplices)): cellDict[tuple(sorted(cell))] = tuple(cell) return cellDict.values() return simplify0 FW = sorted(simplify(faces)(CW)) EW = sorted(simplify(edges)(FW)) return W, CW, FW, EW
def main(): import numpy from meshpy.tet import MeshInfo, build from meshpy.geometry import GeometryBuilder, Marker, make_box geob = GeometryBuilder() box_marker = Marker.FIRST_USER_MARKER extent_small = 0.3*numpy.ones(3, dtype=numpy.float64) points, facets, _, _ = \ make_box(-extent_small, extent_small) geob.add_geometry(points, facets, facet_markers=box_marker) points, facets, _, facet_markers = \ make_box(numpy.array([-1, -1, -1]), numpy.array([1, 1, 5])) geob.add_geometry(points, facets, facet_markers=facet_markers) mesh_info = MeshInfo() geob.set(mesh_info) #mesh_info.set_holes([(0, 0, 0)]) # region attributes mesh_info.regions.resize(1) mesh_info.regions[0] = ( # point in region [0, 0, 0] + [ # region number 1, # max volume in region 0.001]) mesh = build(mesh_info, max_volume=0.06, volume_constraints=True, attributes=True) print(("%d elements" % len(mesh.elements))) mesh.write_vtk("box-in-box.vtk")
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 make_tetgen_mesh(vert_list, face_list): # Make the tetgen mesh mesh_info = MeshInfo() # Points mesh_info.set_points(vert_list) # Faces mesh_info.set_facets(face_list) # --- TEMP --- ''' # Make an object from the surface we are planning to tetrahedronalize mesh_new = bpy.data.meshes.new("pre_tet_mesh") mesh_new.from_pydata(vert_list,[],face_list) mesh_new.validate(verbose=False) # Important! and i dont know why mesh_new.update() obj_new = bpy.data.objects.new("pre_tet",mesh_new) context.scene.objects.link(obj_new) # return ''' # --- FIN TEMP --- # Tetrahedralize # Options: # neighout = Write out neighbors # facesout = Write out faces # edgesout = Write out edges # regionattrib = Write out element_attributes = unique id for every tet in a distinct volume # nobisect = Dont alter surface print("> Starting TetGen") opts = Options(switches='pq', neighout = True, facesout = True, edgesout = True, regionattrib = True, verbose = True, docheck = True) mesh_built = build(mesh_info, options=opts) print("> Finished TetGen successfully") return mesh_built
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 save_mesh(filepath, mesh, boundary_condition, use_graphics, fem_dimensions, mass_density, poisson_ratio, young_modulus, meshpy ): """Write mesh data out to ply file If graphics are checked to be exported, it will prep any UVs and normals it can and prepare a full list of faces FEM3D meshes have their mesh run through MeshPy which is a Python interface for TetGen """ file = open(filepath, "w", encoding="utf8", newline="\n") fwrite = file.write verts = [] faces = [] elements = [] uvcoords = {} normals = {} has_uv = bool(mesh.uv_textures) and mesh.uv_textures.active if has_uv and use_graphics: mesh.calc_tessface() uv_data = mesh.tessface_uv_textures.active.data for i, polygon in enumerate(mesh.polygons): uv = uv_data[i].uv1, uv_data[i].uv2, uv_data[i].uv3, uv_data[i].uv4 for j, vert in enumerate(polygon.vertices): uvcoord = uv[j][0], uv[j][1] normal = mesh.vertices[vert].normal[:] vertcoord = mesh.vertices[vert].co[:] if vertcoord not in uvcoords: uvcoords[vertcoord] = uvcoord if vertcoord not in normals: normals[vertcoord] = normal if fem_dimensions == '3': from meshpy.tet import MeshInfo, build, Options bpy.ops.object.mode_set(mode='OBJECT', toggle=False) bpy.context.scene.update() # get list of verts and faces direct from mesh mesh_verts = [] for vert in mesh.vertices: mesh_verts.append(vert.co[:]) mesh_faces = [] for face in mesh.polygons: mesh_faces.append(face.vertices[:]) args = meshpy mesh_info = MeshInfo() mesh_info.set_points(mesh_verts) mesh_info.set_facets(mesh_faces) tets = build(mesh_info, Options(args), verbose=True, attributes=False, volume_constraints=False, max_volume=None, diagnose=False, insert_points=None) # Ply prep by creating updated vert list and face list using tets.points and tets.elements for point in tets.points: verts.append((point[0], point[1], point[2])) for tet in tets.elements: elements.append((tet[0], tet[1], tet[2], tet[3])) for face in tets.faces: faces.append((face[2], face[1], face[0])) else: for vert in mesh.vertices: verts.append((vert.co[0], vert.co[1], vert.co[2])) for face in mesh.polygons: if len(face.vertices) == 3: faces.append((face.vertices[0], face.vertices[1], face.vertices[2])) else: faces.append((face.vertices[0], face.vertices[1], face.vertices[2])) faces.append((face.vertices[0], face.vertices[2], face.vertices[3])) fwrite("ply\n") fwrite("format ascii 1.0\n") fwrite("comment Created by OpenSurgSim FEM exporter for Blender\n") fwrite("comment MeshPy options '%s'\n" % meshpy) fwrite("element vertex %d\n" % len(verts)) fwrite("property double x\n" "property double y\n" "property double z\n") if use_graphics: if fem_dimensions != '1': if normals: fwrite("property double nx\n" "property double ny\n" "property double nz\n") if has_uv: fwrite("property double s\n" "property double t\n") fwrite("element face %d\n" % len(faces)) fwrite("property list uint uint vertex_indices\n") if fem_dimensions == '1': fwrite("element 1d_element %d\n" % len(mesh.vertices)-1) fwrite("property list uint uint vertex_indices\n") elif fem_dimensions == '2': fwrite("element 2d_element %d\n" % len(faces)) fwrite("property list uint uint vertex_indices\n") elif fem_dimensions == '3': fwrite("element 3d_element %d\n" % len(elements)) fwrite("property list uint uint vertex_indices\n") fwrite("element material 1\n") fwrite("property double mass_density\n") fwrite("property double poisson_ratio\n") fwrite("property double young_modulus\n") if boundary_condition is not None: fwrite("element boundary_condition %d\n" % len(boundary_condition)) fwrite("property uint vertex_index\n") fwrite("end_header\n") if fem_dimensions != '1': if use_graphics: for vert in verts: fwrite("%.6f %.6f %.6f" % vert[:]) if vert in normals: fwrite(" %.6f %.6f %.6f" % normals[vert][:]) if has_uv and vert in uvcoords: fwrite(" %.6f %.6f" % uvcoords[vert][:]) fwrite("\n") for face in faces: fwrite("3 %d %d %d\n" % face[:]) else: for vert in verts: fwrite("%.6f %.6f %.6f\n" % vert[:]) else: for vert in mesh.vertices: fwrite("%.6f %.6f %.6f\n" % vert.co[:]) if fem_dimensions is '1': for i in len(mesh.vertices)-1: fwrite("2 %d %d\n" % list(i, i+1)) elif fem_dimensions is '2': for face in faces: fwrite("3 %d %d %d\n" % face[:]) elif fem_dimensions is '3': for tet in elements: fwrite("4 %d %d %d %d\n" % tet[:]) fwrite("%s %s %s\n" % (mass_density, poisson_ratio, young_modulus)) if boundary_condition is not None: for index in boundary_condition: fwrite("%d\n" % index) file.close() print("writing %r done" % filepath) return {'FINISHED'}
def make_box_mesh(a=(0, 0, 0), b=(1, 1, 1), max_volume=None, periodicity=None, boundary_tagger=(lambda fvi, el, fn, all_v: []), return_meshpy_mesh=False): """Return a mesh for a brick from the origin to `dimensions`. *max_volume* specifies the maximum volume for each tetrahedron. *periodicity* is either None, or a triple of bools, indicating whether periodic BCs are to be applied along that axis. See :func:`make_conformal_mesh` for the meaning of *boundary_tagger*. A few stock boundary tags are provided for easy application of boundary conditions, namely plus_[xyz] and minus_[xyz] tag the appropriate faces of the brick. """ def count(iterable): result = 0 for i in iterable: result += 1 return result from meshpy.tet import MeshInfo, build from meshpy.geometry import make_box points, facets, _, facet_markers = make_box(a, b) mesh_info = MeshInfo() mesh_info.set_points(points) mesh_info.set_facets(facets, facet_markers) if periodicity is None: periodicity = (False, False, False) axes = ["x", "y", "z"] per_count = count(p for p in periodicity if p) marker_to_tag = {} mesh_periodicity = [] periodic_tags = set() if per_count: mesh_info.pbc_groups.resize(per_count) pbc_group_number = 0 for axis, axis_per in enumerate(periodicity): minus_marker = 1+2*axis plus_marker = 2+2*axis minus_tag = "minus_"+axes[axis] plus_tag = "plus_"+axes[axis] marker_to_tag[minus_marker] = minus_tag marker_to_tag[plus_marker] = plus_tag if axis_per: pbcg = mesh_info.pbc_groups[pbc_group_number] pbc_group_number += 1 pbcg.facet_marker_1 = minus_marker pbcg.facet_marker_2 = plus_marker translation = [0, 0, 0] translation[axis] = b[axis]-a[axis] pbcg.set_transform(translation=translation) mesh_periodicity.append((minus_tag, plus_tag)) periodic_tags.add(minus_tag) periodic_tags.add(plus_tag) else: mesh_periodicity.append(None) generated_mesh = build(mesh_info, max_volume=max_volume) fvi2fm = generated_mesh.face_vertex_indices_to_face_marker def wrapped_boundary_tagger(fvi, el, fn, all_v): face_tag = marker_to_tag[fvi2fm[frozenset(fvi)]] if face_tag in periodic_tags: return [face_tag] else: return [face_tag] + boundary_tagger(fvi, el, fn, all_v) from hedge.mesh import make_conformal_mesh_ext from hedge.mesh.element import Tetrahedron vertices = numpy.asarray(generated_mesh.points, dtype=float, order="C") result = make_conformal_mesh_ext( vertices, [Tetrahedron(i, el_idx, vertices) for i, el_idx in enumerate(generated_mesh.elements)], wrapped_boundary_tagger, periodicity=mesh_periodicity) if return_meshpy_mesh: return result, generated_mesh else: return result
(b,b,b), (b,b,a), (b,a,a),(b,a,b),(a,b,b), (a,b,a), (a,a,a),(a,a,b) ]) mesh_info.set_facets([ [0,1,2,3], [0,1,5,4], [0,4,7,3], [6,2,1,5], [6,2,3,7], [6,7,4,5]]) addpoints = [(0.0,0.0,0.0), (0.375,0.375,0.375)] # addpoints = [array([0.0,0.0,0.0]), array(0.375,0.375,0.375)] opts = Options("VO9pa0.04") # Overriding 'pq' mesh = build(mesh_info,options=opts, insert_points = addpoints) # mesh = build(mesh_info,max_volume = 0.1) vols = [] tets = [] points = [] print "Mesh Points:" for i, p in enumerate(mesh.points): points.append(array(mesh.points[i])) print i, p # print "Point numbers in tetrahedra:" for i, tet in enumerate(mesh.elements): tets.append(tet) vpoints = array([mesh.points[iv] for iv in tet]) vols.append(volTet2(vpoints)) vols = array(vols) vols.sort()
def ProcessGlobalAction(ActionType, GlobalAction, NumberedPoints, Elements, Points): ExtendedData = {'ElementPropertyIndex' : {}} if ActionType == 'SpecialEntities': Filters = json.loads(GlobalAction['Filters']) if not 'SpecialEntities' in ExtendedData: ExtendedData['SpecialEntities'] = [] for Element in Elements: if Element and Element['filter'] in Filters: ExtendedData['SpecialEntities'].append(Element) return ExtendedData, False if ActionType == 'Nonlinear': Output = {} #for key in GlobalAction: # if 'ElementPropertyMaxIndex' in ExtendedData: # ExtendedData['ElementPropertyMaxIndex'] += 1 # else: # ExtendedData['ElementPropertyMaxIndex'] = 1 # propertyindex = ExtendedData['ElementPropertyMaxIndex'] # ExtendedData['ElementPropertyIndex'][key] = propertyindex # ExtendedData['NonlinearPropertyIndex'][key] = nonlinearindex # # # ExtendedData['ElementPropertyIndex'][key] = workingindex #In this same notation we can get the index when writing elements # Output[index] = "" return ExtendedData, Output #Here we have Output ready to be printed and ExtendedData, a mapper to Output if ActionType == 'ElementProperties': Output = {} for key in GlobalAction: if 'ElementPropertyMaxIndex' in ExtendedData: ExtendedData['ElementPropertyMaxIndex'] += 1 else: ExtendedData['ElementPropertyMaxIndex'] = 1 workingindex = ExtendedData['ElementPropertyMaxIndex'] ExtendedData['ElementPropertyIndex'][key] = workingindex #In this same notation we can get the index when writing elements Output[workingindex] = GlobalAction[key] return ExtendedData, Output #Here we have Output ready to be printed and ExtendedData, a mapper to Output if ActionType == 'Orphans': Output = [] for Number, Point in NumberedPoints['points'].iteritems(): ElementAmount = len(Point['elementnumbers']) if ElementAmount < 2: print "Orphan node {}!".format(Number) Output.append({'element_type': 'POINT', 'position': Point['point'], 'layer': 'Errors', 'nodenumber': Number}) return {'information':'addObjects'}, Output#Here we have Output ready to be printed and ExtendedData, a mapper to Output if ActionType == 'Meshing': EntityModelData = json.loads(GlobalAction['EntityModelData']) if 'EntityModelData' in GlobalAction else {} ExtendedModelData = json.loads(GlobalAction['ExtendedModelData']) if 'ExtendedModelData' in GlobalAction else {} Semantic = json.loads(GlobalAction['Semantic']) if 'Semantic' in GlobalAction else {} if 'exclude filters' in Semantic: if not 'ExcludeFilters' in ExtendedData: ExtendedData['ExcludeFilters'] = [] ExtendedData['ExcludeFilters'] = ExtendedData['ExcludeFilters'] + Semantic['exclude filters'] Boundaries = [] Output = [] Geometry = json.loads(GlobalAction['Geometry']) if 'Geometry' in GlobalAction else {} Parameters = json.loads(GlobalAction['Parameters']) if 'Parameters' in GlobalAction else {} AdditionalPointsFilters = Geometry['points'] if 'points' in Geometry else [] for Filter in Geometry['boundaries']: print "Using filter {} as finite element domain boundary.".format(Filter) for Element in Elements: if Element and Element['filter'] == Filter and Element['elementclass'] in ['FACE_3NODES', 'FACE_4NODES', 'POLYLINE', 'PLINE_5NODES']: Boundaries.append(Element) AdditionalPoints = [] for Filter in AdditionalPointsFilters: print "Using filter {} as additional points container.".format(Filter) for Element in Elements: if Element and Element['filter'] == Filter and Element['elementclass'] in ['FACE_3NODES', 'FACE_4NODES', 'POLYLINE', 'LINE_2NODES']: AdditionalPoints.extend( Element['points'] ) print "Assembling FE domain" mesh_info = MeshInfo() #additional_points = MeshInfo() #additional_points.set_points(list(set(AdditionalPoints))) MeshPoints = [] MeshFacets = [] MeshPointsIndex = {} PointIndex = 0 for BoundaryElement in Boundaries: ElementPoints = BoundaryElement['points'] MeshFacet = [] if Parameters['type'] == 'divide_4p_faces': for point in [ElementPoints[0],ElementPoints[1],ElementPoints[2]]: if not point in MeshPointsIndex: MeshPointsIndex[point] = PointIndex MeshPoints.append(False) MeshPoints[PointIndex] = NumberedPoints['points'][point]['point'] PointIndex += 1 MeshFacet.append(MeshPointsIndex[point]) MeshFacets.append(MeshFacet) MeshFacet = [] if ElementPoints[2] != ElementPoints[3]: for point in [ElementPoints[0],ElementPoints[2],ElementPoints[3]]: if not point in MeshPointsIndex: MeshPointsIndex[point] = PointIndex MeshPoints.append(False) MeshPoints[PointIndex] = NumberedPoints['points'][point]['point'] PointIndex += 1 MeshFacet.append(MeshPointsIndex[point]) MeshFacets.append(MeshFacet) else: for point in ElementPoints: if not point in MeshPointsIndex: MeshPointsIndex[point] = PointIndex MeshPoints.append(False) MeshPoints[PointIndex] = NumberedPoints['points'][point]['point'] PointIndex += 1 if not MeshPointsIndex[point] in MeshFacet: MeshFacet.append(MeshPointsIndex[point]) else: print "Mesh error or 3-point 3DFACE." MeshFacets.append(MeshFacet) MeshFacet = [] for point in list(set(AdditionalPoints)): if not point in MeshPointsIndex: #See whether the point is already indexed by its native number MeshPointsIndex[point] = PointIndex MeshPoints.append(False) MeshPoints[PointIndex] = NumberedPoints['points'][point]['point'] PointIndex += 1 saveobject(MeshFacets, r'MeshFacets') saveobject(MeshPoints, r'MeshPoints') mesh_info.set_facets(MeshFacets) mesh_info.set_points(MeshPoints) #insertaddpoints #points = np.array([list(x) for x in MeshPoints]) #qhull = scipy.spatial.Delaunay(points) #mesh_info.Options(switches='pq') #mesh_info.set_points([ # (0,0,0), (12,0,0), (12,12,0), (0,12,0), # (0,0,12), (12,0,12), (12,12,12), (0,12,12), # ]) #mesh_info.set_facets([ # [0,1,2,3], # [4,5,6,7], # [0,4,5,1], # [1,5,6,2], # [2,6,7,3], # [3,7,4,0], # ]) #opts = Options(switches='pq') #opts.maxvolume = 0.0001 #opts.parse_switches() mesh_info.regions.resize(1) mesh_info.regions[0] = [ MeshPoints[0][0], MeshPoints[0][1], MeshPoints[0][2], # point in volume -> first box 0, # region tag (user-defined number) Parameters['maxvolume'], # max tet volume in region ] mesh = build(mesh_info, options=Options(switches="pqT", epsilon=Parameters['tolerance']), volume_constraints=True) print "Created mesh with {} points, {} faces and {} elements.".format(len(mesh.points), len(mesh.faces), len(mesh.elements)) #mesh = build(mesh_info, options=Options(switches="pTi", epsilon=Parameters['tolerance'], insertaddpoints=True), volume_constraints=True, insert_points=additional_points) #mesh.write_vtk("test.vtk") #mesh.points #mesh.elements #mesh.faces filename = "test" #mesh.save_elements(filename) #mesh.save_nodes(filename) #mesh.save_elements(filename) #mesh.save_faces(filename) #mesh.save_edges(filename) #mesh.save_neighbors(filename) #mesh.save_poly(filename) #for element in qhull.simplices: # Position = [list(qhull.points[x]) for x in element] # Output.append({'element_type': '3DFACE', 'position': Position, 'layer': 'Elements'}) #NumberedPoints['points'][compoundObject['points'][0]]['point'] if not Boundaries: return False, False Precision = int(GlobalAction['Precision']) if 'Precision' in GlobalAction else 4 if Semantic['output'].lower() == 'graphics': for face in mesh.faces: Position = [mesh.points[x] for x in face] Output.append({'element_type': '3DFACE', 'position': Position, 'layer': 'Faces'}) for element in mesh.elements: Position = [mesh.points[x] for x in element] Output.append({'element_type': '3DFACE', 'position': Position, 'layer': 'Elements'}) return {'information':'addObjects'}, Output elif Semantic['output'].lower() == 'fea': Points = {} for NumberedPoint in NumberedPoints['points']: Points[NumberedPoints['points'][NumberedPoint]['point']] = NumberedPoint NodeNumber = NumberedPoints['maximumNode'] for element in mesh.elements: Position = [mesh.points[x] for x in element] for i, point in enumerate(Position): Position[i] = [round(x, Precision) for x in point] #else: # if tuple([round(x, PrepPrecision) for x in Coords]) in [(4.95,-17.69,58.9), (4.96,-17.69,58.9)]: # pass # object['points'][i] = tuple([round(x, PrepPrecision) for x in Coords]) # if not object['points'][i] in GlobalPointIndex: # GlobalPointIndex.append(object['points'][i]) ElementPoints = [] ElementNumber = len(Elements) for point in Position: #Update NumberedPoints and construct all necessary data for Elements point = NeighborhoodRaw(tuple(point), Precision, Points) if not tuple(point) in Points: NodeNumber += 1 Points[tuple(point)] = NodeNumber #PointsNumbered.append(None) NumberedPoints['points'][NodeNumber] = {'point': tuple(point), 'elementnumbers': []} NumberedPoints['maximumNode'] = NodeNumber CurrentPointNumber = Points[tuple(point)] ElementPoints.append(CurrentPointNumber) NumberedPoints['points'][CurrentPointNumber]['elementnumbers'].append(ElementNumber) #Update Points if possible #Update Elements Element = { 'points' : ElementPoints, 'elementclass' : 'SOLID_4NODES', 'elementnum': ElementNumber, #??? 'filter': Semantic['filter'], 'entity_model_data': EntityModelData, 'extended_model_data': ExtendedModelData, 'generation_order': None, } Elements.append(None) Elements[ElementNumber] = Element return ExtendedData, False if ActionType == 'AddShells': ExtendedData = {} EntityModelData = json.loads(GlobalAction['EntityModelData']) if 'EntityModelData' in GlobalAction else {} ExtendedModelData = json.loads(GlobalAction['ExtendedModelData']) if 'ExtendedModelData' in GlobalAction else {} Filters = json.loads(GlobalAction['Filters']) if 'Filters' in GlobalAction else {} for Element in Elements: if not Element or not Element['filter'] in Filters: continue if Element['generation_order'] == 0 and Element['entity_model_data']['layer'] != "Concrete bases crown": ElementPoints = [Element['points'][0], Element['points'][1], Element['points'][2]] ElementNumber = len(Elements) NewElement = { 'points' : ElementPoints, 'elementclass' : 'FACE_3NODES', 'elementnum': ElementNumber, #??? 'filter': GlobalAction['AssignedFilter'], 'entity_model_data': EntityModelData, 'extended_model_data': ExtendedModelData, 'generation_order': None, } Elements.append(None) Elements[ElementNumber] = NewElement if Element['elementclass'] == 'SOLID_8NODES': ElementPoints = [Element['points'][0], Element['points'][2], Element['points'][3]] ElementNumber = len(Elements) NewElement = { 'points' : ElementPoints, 'elementclass' : 'FACE_3NODES', 'elementnum': ElementNumber, #??? 'filter': GlobalAction['AssignedFilter'], 'entity_model_data': EntityModelData, 'extended_model_data': ExtendedModelData, 'generation_order': None, } Elements.append(None) Elements[ElementNumber] = NewElement if Element['elementclass'] == 'SOLID_10NODES': pass pass return {}, {} return False