Ejemplo n.º 1
0
def test_cli():
    input_mesh = helpers.tri_mesh
    infile = tempfile.NamedTemporaryFile().name
    meshio.write(infile, input_mesh, file_format="gmsh4-ascii")

    outfile = tempfile.NamedTemporaryFile().name

    meshio.cli.main(
        [
            infile,
            outfile,
            "--input-format",
            "gmsh-ascii",
            "--output-format",
            "vtk-binary",
        ]
    )

    mesh = meshio.read(outfile, file_format="vtk-binary")

    atol = 1.0e-15
    assert numpy.allclose(input_mesh.points, mesh.points, atol=atol, rtol=0.0)

    for cell_type, data in input_mesh.cells.items():
        assert numpy.allclose(data, mesh.cells[cell_type])
    return
Ejemplo n.º 2
0
def generate_mesh(geo_object, optimize=True, return_msh_fh=False, verbose=False):
    import meshio
    import os
    import subprocess
    import tempfile

    geo_handle = tempfile.NamedTemporaryFile(suffix='.geo', delete=True)
    geo_handle.write(geo_object.get_code())
    geo_handle.flush()

    msh_handle  = tempfile.NamedTemporaryFile(suffix='.msh', delete=True)

    cmd = ['gmsh', '-3', geo_handle.name, '-o', msh_handle.name]
    if optimize:
        cmd += ['-optimize']
    out = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
    if verbose:
        print(out)
    
    if return_msh_fh:
        return msh_handle

    points, cells, _, _, _ = meshio.read(msh_handle.name)

    return points, cells
Ejemplo n.º 3
0
def gmsh(geo_object, optimize=True, verbose=10, name="", ident=0):
    '''
    Run gmsh, return resulting mesh.
    '''
    import meshio
    import os
    import subprocess
    import tempfile

    handle, filename = tempfile.mkstemp(suffix='.geo')
    os.write(handle, geo_object.get_code())
    os.close(handle)

    handle, outname = tempfile.mkstemp(suffix='.msh')

    cmd = ['gmsh', '-3', filename, '-o', outname, '-v', str(verbose)]
           
    if optimize:
        cmd += ['-optimize']
    out = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
    if verbose:
        print(out)

    dat = meshio.read(outname)
    return gmsh2mesh(name=name, ident=ident, point=dat[0], **dat[1])
Ejemplo n.º 4
0
def test_reference_file_readonly(filename, md5, ref_sum, ref_num_cells):
    filename = helpers.download(filename, md5)

    mesh = meshio.read(filename)
    tol = 1.0e-2
    s = mesh.points.sum()
    assert abs(s - ref_sum) < tol * ref_sum
    assert {k: len(v) for k, v in mesh.cells.items()} == ref_num_cells
    assert {
        k: len(v["gmsh:physical"]) for k, v in mesh.cell_data.items()
    } == ref_num_cells
Ejemplo n.º 5
0
def test_reference_file(filename, md5, ref_sum, ref_num_cells, write_binary):
    filename = helpers.download(filename, md5)

    mesh = meshio.read(filename)
    tol = 1.0e-2
    s = numpy.sum(mesh.points)
    assert abs(s - ref_sum) < tol * ref_sum
    assert len(mesh.cells["triangle"]) == ref_num_cells
    writer = partial(meshio.vtk_io.write, write_binary=write_binary)
    helpers.write_read(writer, meshio.vtk_io.read, mesh, 1.0e-15)
    return
Ejemplo n.º 6
0
def generate(verbose=False):
    cache_file = "cruc_cache.msh"
    if os.path.isfile(cache_file):
        print("Using mesh from cache '{}'.".format(cache_file))
        mesh = meshio.read(cache_file)
        out = mesh.points, mesh.cells, mesh.point_data, mesh.cell_data, mesh.field_data
    else:
        out = pygmsh.generate_mesh(_define(), verbose=verbose)
        points, cells, point_data, cell_data, _ = out
        meshio.write_points_cells(
            cache_file, points, cells, point_data=point_data, cell_data=cell_data
        )
    return out
Ejemplo n.º 7
0
def read_write():
    X, cells = generate_mesh()

    formats = [
        "ansys-ascii",
        "ansys-binary",
        "exodus",
        "dolfin-xml",
        "gmsh-ascii",
        "gmsh-binary",
        "med",
        "medit",
        "permas",
        "moab",
        "off",
        "stl-ascii",
        "stl-binary",
        "vtk-ascii",
        "vtk-binary",
        "vtu-ascii",
        "vtu-binary",
        "xdmf",
    ]

    filename = "foo"
    print()
    print("format        write (s)    read(s)")
    print()
    for fmt in formats:
        t = time.time()
        meshio.write(filename, X, cells, file_format=fmt)
        elapsed_write = time.time() - t

        t = time.time()
        meshio.read(filename, file_format=fmt)
        elapsed_read = time.time() - t
        print("{0: <12}  {1:e} {2:e}".format(fmt, elapsed_write, elapsed_read))

    return
Ejemplo n.º 8
0
	def writeVTKFile(self,fn="",sub=False):
		
		"""Writes mesh into vtk file.
		
		Uses *meshIO* (https://github.com/nschloe/meshio), to convert the mesh saved
		in ``fnMesh`` to a .vtk file. 
		
		If ``sub==True``, will start a seperate subprocess and submit 
		``pyfrp_meshIO_script.py`` to it. This can be sometimes useful, since PyFRAP
		sometimes tends to crash otherwise.
		
		If no output path is given via ``fn``, will use same path as ``fnMesh``.
		
		.. note:: *meshIO* only gets imported inside this function, making PyFRAP running
		   even without the package installed. However, this feature will only run with
		   *meshIO*.
		
		Keyword Args:
			fn (str): Optional output path.
			sub (bool): Subprocess flag.
		
		Returns:
			str: Used output path.
		
		"""
		
		
		if not os.path.isfile(self.fnMesh):
			printWarning("Filepath to meshfile has not been specified yet. Cannot write VTK file.")
		
		if fn=="":
			fn=self.fnMesh.replace('.msh','.vtk')
		
		if sub:
			
			cmd = "python pyfrp_meshIO_script.py "+ self.fnMesh
			
			import shlex
			import subprocess
			args = shlex.split(cmd)
			
			p = subprocess.Popen(args)
			p.wait()
		else:
			#MeshIO
			import meshio
			
			points, cells, point_data, cell_data, field_data = meshio.read(self.fnMesh)
			meshio.write(fn,points,cells,point_data=point_data,cell_data=cell_data,field_data=field_data)
			
		return fn
Ejemplo n.º 9
0
def test_reference_file(filename, md5, ref_sum, ref_num_cells, write_binary):
    filename = helpers.download(filename, md5)

    mesh = meshio.read(filename)
    tol = 1.0e-2
    s = mesh.points.sum()
    assert abs(s - ref_sum) < tol * ref_sum
    assert {k: len(v) for k, v in mesh.cells.items()} == ref_num_cells
    assert {
        k: len(v["gmsh:physical"]) for k, v in mesh.cell_data.items()
    } == ref_num_cells

    writer = partial(meshio.msh_io.write, fmt_version="2", write_binary=write_binary)
    helpers.write_read(writer, meshio.msh_io.read, mesh, 1.0e-15)
Ejemplo n.º 10
0
def test_reference_file_with_mixed_cells():
    filename = "med/cylinder.med"
    md5 = "e36b365542c72ef470b83fc21f4dad58"
    filename = helpers.download(filename, md5)
    mesh = meshio.read(filename)

    # Points
    assert numpy.isclose(mesh.points.sum(), 16.53169892762988)

    # Cells
    ref_num_cells = {"pyramid": 18, "quad": 18, "line": 17, "tetra": 63, "triangle": 4}
    assert {k: len(v) for k, v in mesh.cells.items()} == ref_num_cells

    # Point tags
    assert mesh.point_data["point_tags"].sum() == 52
    ref_point_tags_info = {2: ["Side"], 3: ["Side", "Top"], 4: ["Top"]}
    assert mesh.point_tags == ref_point_tags_info

    # Cell tags
    ref_sum_cell_tags = {
        "pyramid": -116,
        "quad": -75,
        "line": -48,
        "tetra": -24,
        "triangle": -30,
    }
    assert {
        k: v["cell_tags"].sum() for k, v in mesh.cell_data.items()
    } == ref_sum_cell_tags
    ref_cell_tags_info = {
        -6: ["Top circle"],
        -7: ["Top", "Top and down"],
        -8: ["Top and down"],
        -9: ["A", "B"],
        -10: ["B"],
        -11: ["B", "C"],
        -12: ["C"],
    }
    assert mesh.cell_tags == ref_cell_tags_info

    helpers.write_read(meshio.med_io.write, meshio.med_io.read, mesh, 1.0e-15)
Ejemplo n.º 11
0
def test_reference_file_with_point_cell_data():
    filename = "med/box.med"
    md5 = "0867fb11bd14b83ad11ab20e2b1fd57d"
    filename = helpers.download(filename, md5)
    mesh = meshio.read(filename)

    # Points
    assert numpy.isclose(mesh.points.sum(), 12)

    # Cells
    assert {k: len(v) for k, v in mesh.cells.items()} == {"hexahedron": 1}

    # Point data
    data_u = mesh.point_data["resu____DEPL"]
    assert data_u.shape == (8, 3)
    assert numpy.isclose(data_u.sum(), 12)

    # Cell data
    # ELNO (1 data point for every node of each element)
    data_eps = mesh.cell_data["hexahedron"]["resu____EPSI_ELNO"]
    assert data_eps.shape == (1, 8, 6)  # (n_cells, n_nodes_per_element, n_components)
    data_eps_mean = numpy.mean(data_eps, axis=1)[0]
    eps_ref = numpy.array([1, 0, 0, 0.5, 0.5, 0])
    assert numpy.allclose(data_eps_mean, eps_ref)

    data_sig = mesh.cell_data["hexahedron"]["resu____SIEF_ELNO"]
    assert data_sig.shape == (1, 8, 6)  # (n_cells, n_nodes_per_element, n_components)
    data_sig_mean = numpy.mean(data_sig, axis=1)[0]
    sig_ref = numpy.array(
        [7328.44611253, 2645.87030114, 2034.06063679, 1202.6, 569.752, 0]
    )
    assert numpy.allclose(data_sig_mean, sig_ref)

    data_psi = mesh.cell_data["hexahedron"]["resu____ENEL_ELNO"]
    assert data_psi.shape == (1, 8)  # (n_cells, n_nodes_per_element, ) with 1 cut off

    # ELEM (1 data point for each element)
    data_psi_elem = mesh.cell_data["hexahedron"]["resu____ENEL_ELEM"]
    assert numpy.isclose(numpy.mean(data_psi, axis=1)[0], data_psi_elem[0])

    helpers.write_read(meshio.med_io.write, meshio.med_io.read, mesh, 1.0e-15)
Ejemplo n.º 12
0
def generate_mesh(geo_object, optimize=True):
    import meshio
    import os
    import subprocess
    import tempfile

    handle, filename = tempfile.mkstemp(suffix='.geo')
    os.write(handle, geo_object.get_code())
    os.close(handle)

    handle, outname = tempfile.mkstemp(suffix='.msh')

    cmd = ['gmsh', '-3', filename, '-o', outname]
    if optimize:
        cmd += ['-optimize']
    out = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
    print(out)

    points, cells, _, _, _ = meshio.read(outname)

    return points, cells
Ejemplo n.º 13
0
def _write_read(filename, mesh):
    '''Write and read a file, and make sure the data is the same as before.
    '''
    try:
        input_point_data = mesh['point_data']
    except KeyError:
        input_point_data = {}

    try:
        input_cell_data = mesh['cell_data']
    except KeyError:
        input_cell_data = {}

    meshio.write(
        filename,
        mesh['points'], mesh['cells'],
        point_data=input_point_data,
        cell_data=input_cell_data
        )
    points, cells, point_data, cell_data, _ = meshio.read(filename)

    # Numpy's array_equal is too strict here, cf.
    # <https://mail.scipy.org/pipermail/numpy-discussion/2015-December/074410.html>.
    # Use allclose.

    # We cannot compare the exact rows here since the order of the points might
    # have changes. Just compare the sums
    assert numpy.allclose(mesh['points'], points)

    for key, data in mesh['cells'].items():
        assert numpy.allclose(data, cells[key])
    for key, data in input_point_data.items():
        assert numpy.allclose(data, point_data[key])
    for key, data in input_cell_data.items():
        assert numpy.allclose(data, cell_data[key])

    os.remove(filename)

    return
Ejemplo n.º 14
0
def test_reference_file():
    this_dir = os.path.dirname(os.path.abspath(__file__))
    filename = os.path.join(this_dir, "meshes", "flac3d",
                            "flac3d_mesh_ex.f3grid")
    mesh = meshio.read(filename)

    # Points
    assert numpy.isclose(mesh.points.sum(), 306.9999999999999)

    # Cells
    ref_num_cells = {"tetra": 3, "pyramid": 15, "wedge": 15, "hexahedron": 75}
    assert {k: len(v) for k, v in mesh.cells.items()} == ref_num_cells

    # Cell data
    ref_sum_cell_data = {
        "tetra": 9,
        "pyramid": 36,
        "wedge": 54,
        "hexahedron": 171
    }
    assert {k: v["flac3d:zone"].sum()
            for k, v in mesh.cell_data.items()} == ref_sum_cell_data
Ejemplo n.º 15
0
def read(filename):
    '''Reads an unstructured mesh with added data.

    :param filenames: The files to read from.
    :type filenames: str
    :returns mesh{2,3}d: The mesh data.
    :returns point_data: Point data read from file.
    :type point_data: dict
    :returns field_data: Field data read from file.
    :type field_data: dict
    '''
    points, cells_nodes, point_data, cell_data, field_data = \
        meshio.read(filename)

    if 'triangle' in cells_nodes:
        return pyfvm.meshTri.meshTri(points, cells_nodes['triangle']), \
               point_data, field_data
    elif 'tetra' in cells_nodes:
        return pyfvm.meshTetra.meshTetra(points, cells_nodes['tetra']), \
               point_data, field_data
    else:
        raise RuntimeError('Unknown mesh type.')
Ejemplo n.º 16
0
def _write_read(filename, mesh):
    '''Write and read a file, and make sure the data is the same as before.
    '''
    try:
        input_point_data = mesh['point_data']
    except KeyError:
        input_point_data = {}

    try:
        input_cell_data = mesh['cell_data']
    except KeyError:
        input_cell_data = {}

    meshio.write(
        filename,
        mesh['points'], mesh['cells'],
        point_data=input_point_data,
        cell_data=input_cell_data
        )
    points, cells, point_data, cell_data, _ = meshio.read(filename)

    # Numpy's array_equal is too strict here, cf.
    # <https://mail.scipy.org/pipermail/numpy-discussion/2015-December/074410.html>.
    # Use allclose.

    # We cannot compare the exact rows here since the order of the points might
    # have changes. Just compare the sums
    assert numpy.allclose(mesh['points'], points)

    for key, data in mesh['cells'].items():
        assert numpy.allclose(data, cells[key])
    for key, data in input_point_data.items():
        assert numpy.allclose(data, point_data[key])
    for key, data in input_cell_data.items():
        assert numpy.allclose(data, cell_data[key])

    os.remove(filename)

    return
Ejemplo n.º 17
0
def _write_read(filename, mesh):
    '''Write and read a file, and make sure the data is the same as before.
    '''
    meshio.write(
        filename,
        mesh['points'], mesh['cells'],
        point_data=mesh['point_data'],
        cell_data=mesh['cell_data']
        )
    points, cells, point_data, cell_data, _ = meshio.read(filename)

    # We cannot compare the exact rows here since the order of the points might
    # have changes. Just compare the sums
    assert numpy.allclose(mesh['points'], points)

    for key, data in mesh['cells'].items():
        assert numpy.array_equal(data, cells[key])
    for key, data in mesh['point_data'].items():
        assert numpy.array_equal(data, point_data[key])
    for key, data in mesh['cell_data'].items():
        assert numpy.array_equal(data, cell_data[key])
    return
Ejemplo n.º 18
0
    def __check_data(self, filename):
        """Read data using meshio to get min and max and make sure
        levels are within data bounds.

        Input:
        ------
            filename: string, path to mesh vtk file to check

        Return:
        -------
            arbmin: float, value that is lower than minimum data
            arbmax: float, value that is greater than the max data
            mins: list of floats, minimum x, y, z values of the
                geometry [xmin, ymin, zmin]
            maxs: list of floats, maximum x, y, z values of the
                geometry [xmax, ymax, zmax]
        """
        # read in Cartesian mesh file
        mf = meshio.read(filename)

        # get min and max data values
        mindata = min(mf.cell_data['hexahedron'][self.data])
        maxdata = max(mf.cell_data['hexahedron'][self.data])
        arbmin = mindata - 10  # lower than lowest data
        arbmax = maxdata + 10  # higher than highest data
        all_levels = list(self.levels)
        for level in all_levels:
            if (level <= mindata) or (level >= maxdata):
                warnings.warn("Level {} is out of data bounds.".format(level))
                self.levels.remove(level)
        if len(self.levels) == 0:
            raise RuntimeError("No data exists within provided levels.")

        # get extents of the geometric space (min/max x, y, z values)
        mins = mf.points.min(axis=0)
        maxs = mf.points.max(axis=0)

        return arbmin, arbmax, mins, maxs
Ejemplo n.º 19
0
def generate_from_inr(
    inr_filename,
    lloyd=False,
    odt=False,
    perturb=True,
    exude=True,
    edge_size=0.0,
    facet_angle=0.0,
    facet_size=0.0,
    facet_distance=0.0,
    cell_radius_edge_ratio=0.0,
    cell_size=0.0,
    verbose=True,
    seed=0,
):
    fh, outfile = tempfile.mkstemp(suffix=".mesh")
    os.close(fh)

    _generate_from_inr(
        inr_filename,
        outfile,
        lloyd=lloyd,
        odt=odt,
        perturb=perturb,
        exude=exude,
        edge_size=edge_size,
        facet_angle=facet_angle,
        facet_size=facet_size,
        facet_distance=facet_distance,
        cell_radius_edge_ratio=cell_radius_edge_ratio,
        cell_size=cell_size,
        verbose=verbose,
        seed=seed,
    )

    mesh = meshio.read(outfile)
    os.remove(outfile)
    return mesh
Ejemplo n.º 20
0
def test_fem():
    mesh_path = "tests/data/msh/test.msh"

    element_type = "triangle"
    integration_points = 1
    load_condition = "plane stress"  # "plane stress" or "plane strain"
    thickness = 0.5
    steel = base.Material("steel", 3e7, 0.25, load_condition)

    mesh = meshio.read(mesh_path)
    elements = mesh.cells_dict[element_type]
    nodal_coord = mesh.points[:, :2]
    num_elements = elements.shape[0]
    num_nodes = nodal_coord.shape[0]
    material_map = mesh.cell_data_dict["gmsh:physical"][
        element_type] - 1  # element-material map

    left_side = bc.DirichletBC("left side", mesh, [0, 1], 0.0)
    br_corner = bc.DirichletBC("bottom right corner", mesh, [1], 0.0)
    tr_corner = bc.NeumannBC("top right corner", mesh, [1], -1000.0)

    E_array = vector.compute_E_array(num_elements, material_map,
                                     mesh.field_data, steel)
    R = np.zeros(num_nodes * 2)
    K = vector.assembly(num_elements, num_nodes, elements, nodal_coord,
                        E_array, thickness)

    K, R = bc.sp_apply_dirichlet(num_nodes, K, R, left_side, br_corner)
    R = bc.apply_neumann(R, tr_corner)

    D = linalg.spsolve(K, R)

    D_true = np.array([
        0.0, 0.0, 1.90773874e-05, 0.0, 8.73032981e-06, -7.41539125e-05, 0.0,
        0.0
    ])
    # np.testing.assert_allclose(D_true, D)  # FIXME some zeros are 1.0e-20 why??
    np.testing.assert_almost_equal(D_true, D)
Ejemplo n.º 21
0
def test_f(filename, control_values):
    filename = download_mesh(filename)
    mesh = meshplex.read(filename)

    mu = 1.0e-2
    V = -1.0
    g = 1.0

    keo = pyfvm.get_fvm_matrix(mesh, edge_kernels=[Energy(mu)])

    # compute the Ginzburg-Landau residual
    m2 = meshio.read(filename)
    psi = m2.point_data["psi"][:, 0] + 1j * m2.point_data["psi"][:, 1]
    cv = mesh.control_volumes
    # One divides by the control volumes here. No idea why this has been done in pynosh.
    # Perhaps to make sure that even the small control volumes have a significant
    # contribution to the residual?
    r = keo * psi / cv + psi * (V + g * abs(psi)**2)

    # scale with D for compliance with the Nosh (C++) tests
    if mesh.control_volumes is None:
        mesh.compute_control_volumes()
    r *= mesh.control_volumes

    tol = 1.0e-13
    # For C++ Nosh compatibility:
    # Compute 1-norm of vector (Re(psi[0]), Im(psi[0]), Re(psi[1]), ... )
    alpha = numpy.linalg.norm(r.real, ord=1) + numpy.linalg.norm(r.imag, ord=1)
    assert abs(control_values[0] - alpha) < tol
    assert abs(control_values[1] - numpy.linalg.norm(r, ord=2)) < tol
    # For C++ Nosh compatibility:
    # Compute inf-norm of vector (Re(psi[0]), Im(psi[0]), Re(psi[1]), ... )
    alpha = max(
        numpy.linalg.norm(r.real, ord=numpy.inf),
        numpy.linalg.norm(r.imag, ord=numpy.inf),
    )
    assert abs(control_values[2] - alpha) < tol
    return
Ejemplo n.º 22
0
def test_volume_from_surface():
    this_dir = pathlib.Path(__file__).resolve().parent
    # mesh = pygalmesh.generate_volume_mesh_from_surface_mesh(
    #     this_dir / "meshes" / "elephant.vtu",
    #     facet_angle=25.0,
    #     facet_size=0.15,
    #     facet_distance=0.008,
    #     cell_radius_edge_ratio=3.0,
    #     verbose=False,
    # )
    with tempfile.TemporaryDirectory() as tmp:
        out_filename = str(pathlib.Path(tmp) / "out.vtk")
        pygalmesh._cli.volume_from_surface([
            str(this_dir / "meshes" / "elephant.vtu"),
            out_filename,
            "--facet-angle",
            "0.5",
            "--facet-size",
            "0.15",
            "--facet-distance",
            "0.008",
            "--cell-radius-edge-ratio",
            "3.0",
            "--quiet",
        ])
        mesh = meshio.read(out_filename)

    tol = 2.0e-2
    assert abs(max(mesh.points[:, 0]) - 0.357612477657) < tol
    assert abs(min(mesh.points[:, 0]) + 0.358747130015) < tol
    assert abs(max(mesh.points[:, 1]) - 0.496137874959) < tol
    assert abs(min(mesh.points[:, 1]) + 0.495301051456) < tol
    assert abs(max(mesh.points[:, 2]) - 0.298780230629) < tol
    assert abs(min(mesh.points[:, 2]) + 0.300472866512) < tol

    vol = sum(
        helpers.compute_volumes(mesh.points, mesh.get_cells_type("tetra")))
    assert abs(vol - 0.044164693065) < tol
Ejemplo n.º 23
0
def get_mesh(self, indices=[]):
    """Return the pyvista mesh object (or submesh).

    Parameters
    ----------
    self : MeshVTK
        a MeshVTK object
    indices : list
        list of the points to extract (optional)

    Returns
    -------
    mesh : pyvista.core.pointset.UnstructuredGrid
        a pyvista UnstructuredGrid object
    """

    # Already available => Return
    if self.mesh is not None:
        return self.mesh

    # Read mesh file
    else:
        if self.format != "vtk":
            # Write vtk files with meshio
            mesh = read(self.path + "/" + self.name + "." + self.format)
            mesh.write(self.path + "/" + self.name + ".vtk")

        # Read .vtk file with pyvista
        mesh = pv.read(self.path + "/" + self.name + ".vtk")

        # Extract submesh
        if indices != []:
            mesh = mesh.extract_points(indices)

        if self.is_pyvista_mesh:
            self.mesh = mesh

        return mesh
Ejemplo n.º 24
0
def test_extrude():
    p = pygalmesh.Polygon2D([[-0.5, -0.3], [0.5, -0.3], [0.0, 0.5]])
    domain = pygalmesh.Extrude(p, [0.0, 0.3, 1.0])
    pygalmesh.generate_mesh(domain,
                            'out.mesh',
                            cell_size=0.1,
                            edge_size=0.1,
                            verbose=False)

    vertices, cells, _, _, _ = meshio.read('out.mesh')

    tol = 1.0e-3
    assert abs(max(vertices[:, 0]) - 0.5) < tol
    assert abs(min(vertices[:, 0]) + 0.5) < tol
    assert abs(max(vertices[:, 1]) - 0.8) < tol
    assert abs(min(vertices[:, 1]) + 0.3) < tol
    assert abs(max(vertices[:, 2]) - 1.0) < tol
    assert abs(min(vertices[:, 2]) + 0.0) < tol

    vol = sum(compute_volumes(vertices, cells['tetra']))
    assert abs(vol - 0.4) < tol

    return
Ejemplo n.º 25
0
def test_scaling():
    alpha = 1.3
    s = pygalmesh.Scale(pygalmesh.Cuboid([0, 0, 0], [1, 2, 3]), alpha)
    pygalmesh.generate_mesh(s,
                            'out.mesh',
                            cell_size=0.2,
                            edge_size=0.1,
                            verbose=False)

    vertices, cells, _, _, _ = meshio.read('out.mesh')

    tol = 1.0e-3
    assert abs(max(vertices[:, 0]) - 1 * alpha) < tol
    assert abs(min(vertices[:, 0]) + 0.0) < tol
    assert abs(max(vertices[:, 1]) - 2 * alpha) < tol
    assert abs(min(vertices[:, 1]) + 0.0) < tol
    assert abs(max(vertices[:, 2]) - 3 * alpha) < tol
    assert abs(min(vertices[:, 2]) + 0.0) < tol

    vol = sum(compute_volumes(vertices, cells['tetra']))
    assert abs(vol - 6.0 * alpha**3) < tol

    return
Ejemplo n.º 26
0
def test_ring_extrude():
    p = pygalmesh.Polygon2D([[0.5, -0.3], [1.5, -0.3], [1.0, 0.5]])
    edge_size = 0.1
    domain = pygalmesh.RingExtrude(p, edge_size)
    pygalmesh.generate_mesh(domain,
                            "out.mesh",
                            cell_size=0.1,
                            edge_size=edge_size,
                            verbose=False)

    mesh = meshio.read("out.mesh")

    tol = 1.0e-3
    assert abs(max(mesh.points[:, 0]) - 1.5) < tol
    assert abs(min(mesh.points[:, 0]) + 1.5) < tol
    assert abs(max(mesh.points[:, 1]) - 1.5) < tol
    assert abs(min(mesh.points[:, 1]) + 1.5) < tol
    assert abs(max(mesh.points[:, 2]) - 0.5) < tol
    assert abs(min(mesh.points[:, 2]) + 0.3) < tol

    vol = sum(compute_volumes(mesh.points, mesh.cells["tetra"]))
    assert abs(vol - 2 * numpy.pi * 0.4) < 0.05
    return
Ejemplo n.º 27
0
def cmd_gen_dmap(ctx, config):
    """Generate domain/pixel map from msh file"""

    import meshio
    mesh = meshio.read(ctx.obj['mesh_filename'])
    domains = dict()
    for nam, val in mesh.field_data.iteritems():
        domains[nam] = val[0]
    import pixsim.geometry as geometry
    pixcoll = geometry.make_pixels_center(**ctx.obj['cfg'][config])

    import numpy as np
    arrs = list()
    for pix in pixcoll:
        name, hdim, center, shape = pix.info()
        print name
        dom = domains[name]
        pid = int(name[5:]) # assuming name = pixel#
        arrs.append([dom, pid, center])

    arr = [Array(name='domain_map', typename='tuples', data=np.asarray(arrs))]
    res = Result(name='domain_map', typename='geometry', data=arr)
    save_result(ctx, res)
Ejemplo n.º 28
0
    def encodes(self, x):
        # get sitk objs
        im_path, segm_path = x
        folder  = Path(segm_path).parent.name
        ras_adj = int(folder) in range(50455, 50464)

        mr         = sitk.ReadImage(im_path, sitk.sitkFloat32)
        segm       = meshio.read(segm_path)
        mask_arr   = seg2mask(mr, segm, ras_adj)

        # resize so isotropic spacing
        orig_sp = mr.GetSpacing()
        orig_sz = mr.GetSize()
        new_sz = [int(round(osz*ospc/self.new_sp)) for osz,ospc in zip(orig_sz, orig_sp)]

        im = torch.swapaxes(torch.tensor(sitk.GetArrayFromImage(mr)), 0, 2)
        mk = torch.tensor(mask_arr).float()

        while im.ndim < 5: 
            im = im.unsqueeze(0)
            mk = mk.unsqueeze(0)

        return F.interpolate(im, size = new_sz, mode = 'trilinear', align_corners=False).squeeze(),                 F.interpolate(mk, size = new_sz, mode = 'nearest').squeeze().long()
Ejemplo n.º 29
0
def test_torus():
    major_radius = 1.0
    minor_radius = 0.5
    s0 = frentos.Torus(major_radius, minor_radius)
    frentos.generate_mesh(s0, 'out.mesh', cell_size=0.1, verbose=False)

    vertices, cells, _, _, _ = meshio.read('out.mesh')

    tol = 1.0e-2
    radii_sum = major_radius + minor_radius
    assert abs(max(vertices[:, 0]) - radii_sum) < tol
    assert abs(min(vertices[:, 0]) + radii_sum) < tol
    assert abs(max(vertices[:, 1]) - radii_sum) < tol
    assert abs(min(vertices[:, 1]) + radii_sum) < tol
    assert abs(max(vertices[:, 2]) - minor_radius) < tol
    assert abs(min(vertices[:, 2]) + minor_radius) < tol

    vol = sum(compute_volumes(vertices, cells['tetra']))
    ref_vol = (numpy.pi * minor_radius * minor_radius) * \
        (2 * numpy.pi * major_radius)
    assert abs(vol - ref_vol) < 1.0e-1

    return
Ejemplo n.º 30
0
def test_tetrahedron():
    s0 = pygalmesh.Tetrahedron([0.0, 0.0, 0.0], [1.0, 0.0, 0.0],
                               [0.0, 1.0, 0.0], [0.0, 0.0, 1.0])
    pygalmesh.generate_mesh(s0,
                            'out.mesh',
                            cell_size=0.1,
                            edge_size=0.1,
                            verbose=False)

    vertices, cells, _, _, _ = meshio.read('out.mesh')

    tol = 1.0e-4
    assert abs(max(vertices[:, 0]) - 1.0) < tol
    assert abs(min(vertices[:, 0]) + 0.0) < tol
    assert abs(max(vertices[:, 1]) - 1.0) < tol
    assert abs(min(vertices[:, 1]) + 0.0) < tol
    assert abs(max(vertices[:, 2]) - 1.0) < tol
    assert abs(min(vertices[:, 2]) + 0.0) < tol

    vol = sum(compute_volumes(vertices, cells['tetra']))
    assert abs(vol - 1.0 / 6.0) < tol

    return
Ejemplo n.º 31
0
def create_mesh(lcar):
    geom = pygmsh.Geometry()

    cache_file = 'karman.msh'
    if os.path.isfile(cache_file):
        print('Using mesh from cache \'{}\'.'.format(cache_file))
        points, cells, _, _, _ = meshio.read(cache_file)
    else:
        # slightly off-center circle
        circle = geom.add_circle([0.1, 1.0e-2, 0.0],
                                 0.5 * obstacle_diameter,
                                 lcar,
                                 make_surface=False)

        geom.add_rectangle(x0, x1, y0, y1, 0.0, lcar, holes=[circle])

        points, cells, _, _, _ = pygmsh.generate_mesh(geom)

        meshio.write(cache_file, points, cells)

    # https://fenicsproject.org/qa/12891/initialize-mesh-from-vertices-connectivities-at-once
    meshio.write('test.xml', points, cells)
    return Mesh('test.xml')
Ejemplo n.º 32
0
def read(filename, file_format=None, **kwargs):
    """Read unstructured mesh from file.

    Parameters
    ----------
    filename : str
        Input file name.
    file_format : str or None, optional, default None
        Input file format.

    Returns
    -------
    toughio.Mesh
        Imported mesh.

    """
    # Check file format
    if not isinstance(filename, str):
        raise TypeError()
    fmt = file_format if file_format else _filetype_from_filename(filename)

    # Call custom readers
    format_to_reader = {
        "tough": (tough, (), {}),
        "avsucd": (avsucd, (), {}),
        "flac3d": (flac3d, (), {}),
        "pickle": (pickle, (), {}),
        "tecplot": (tecplot, (), {}),
    }
    if fmt in format_to_reader.keys():
        interface, args, default_kwargs = format_to_reader[fmt]
        _kwargs = default_kwargs.copy()
        _kwargs.update(kwargs)
        return interface.read(filename, *args, **_kwargs)
    else:
        mesh = meshio.read(filename, file_format)
        return from_meshio(mesh)
Ejemplo n.º 33
0
def read_and_convert_mesh(file_locations):
    # Convert the mesh to xdmf format
    msh = meshio.read(file_locations.path_to_msh_file)

    # Create directory if doesn't exist
    if not os.path.isdir(file_locations.mesh_folder):
        os.makedirs(file_locations.mesh_folder)

    # Write all triangles
    meshio.write(
        file_locations.mesh_folder + "mesh.xdmf",
        meshio.Mesh(points=msh.points,
                    cells={"triangle": msh.cells["triangle"]}))

    # Write the triangle subdomains
    meshio.write(
        file_locations.mesh_folder + "subdomains.xdmf",
        meshio.Mesh(points=msh.points,
                    cells={"triangle": msh.cells["triangle"]},
                    cell_data={
                        "triangle": {
                            "name_to_read":
                            msh.cell_data["triangle"]["gmsh:physical"]
                        }
                    }))

    # Write the lines
    meshio.write(
        file_locations.mesh_folder + "lines.xdmf",
        meshio.Mesh(points=msh.points,
                    cells={"line": msh.cells["line"]},
                    cell_data={
                        "line": {
                            "name_to_read":
                            msh.cell_data["line"]["gmsh:physical"]
                        }
                    }))
Ejemplo n.º 34
0
    def read(cls, *args, **kwargs):
        """Wrapper for `meshio.read`.

        For gmsh:
        - remaps `gmsh:physical` -> `physical`
        - remaps `gmsh:geometrical` -> `geometrical`
        """
        from meshio import read
        mesh = read(*args, **kwargs)

        cell_data = {}
        for key, value in mesh.cell_data.items():
            if key in ('gmsh:physical', 'gmsh:geometrical'):
                key = key.replace('gmsh:', '')

            cell_data[key] = value

        point_data = {}
        for key, value in mesh.point_data.items():
            if key in ('gmsh:physical', 'gmsh:geometrical'):
                key = key.replace('gmsh:', '')

            point_data[key] = value

        ret = cls(
            mesh.points,
            mesh.cells,
            point_data=point_data,
            cell_data=cell_data,
            field_data=mesh.field_data,
            point_sets=mesh.point_sets,
            cell_sets=mesh.cell_sets,
            gmsh_periodic=mesh.gmsh_periodic,
            info=mesh.info,
        )
        ret.prune_z_0()
        return ret
Ejemplo n.º 35
0
def import_grid(filename):
    """
    Import a grid.

    This routine uses the meshio library to export grids.
    A number of types are supported, including vtk, vtu,
    gmsh, dolphin xml. For a full list see

    https://github.com/nschloe/meshio

    """
    from bempp.api.grid.grid import Grid

    mesh = _meshio.read(filename)

    vertices = mesh.points.T
    elements = mesh.cells_dict["triangle"].T.astype("uint32")

    try:
        domain_indices = mesh.cell_data_dict["gmsh:physical"]["triangle"]
    except:
        domain_indices = None

    return Grid(vertices, elements, domain_indices=domain_indices)
Ejemplo n.º 36
0
    def generate_mesh(self, verbose=False):
        import meshio
        import os
        import subprocess
        import tempfile
        
        gmsh_executable = 'gmsh'
        
        handle, filename = tempfile.mkstemp(suffix='.geo')
        os.write(handle, self.get_code().encode())
        os.close(handle)

        handle, outname = tempfile.mkstemp(suffix='.msh')
        cmd = [gmsh_executable, '-2', filename, '-o', outname]
        try:
            out = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
        except:
            out = os.system(" ".join(cmd))
        if verbose:
            print(out.decode())
        #points,cells = meshio.read(outname)
        mesh = meshio.read(outname)
        #return points, cells
        return mesh.points, mesh.cells["triangle"]
Ejemplo n.º 37
0
def write_mesh_to_xdmf(meshfile, xdmfdir):
    import meshio
    # Read the .mesh file into meshio 
    mesh = meshio.read(meshfile)

    # Extract subdomains and boundaries between regions
    # into appropriate containers
    points = mesh.points
    tetra  = {"tetra": mesh.cells_dict["tetra"]}
    triangles = {"triangle": mesh.cells_dict["triangle"]} 
    subdomains = {"subdomains": [mesh.cell_data_dict["medit:ref"]["tetra"]]}
    boundaries = {"boundaries": [mesh.cell_data_dict["medit:ref"]["triangle"]]}
    
    # Write the mesh to xdmfdir/mesh.xdmf 
    xdmf = meshio.Mesh(points, tetra) 
    meshio.write("%s/mesh.xdmf" % xdmfdir, xdmf)
    
    # Write the subdomains of the mesh 
    xdmf = meshio.Mesh(points, tetra, cell_data=subdomains)
    meshio.write("%s/subdomains.xdmf" % xdmfdir, xdmf)
    
    # Write the boundaries/interfaces of the mesh
    xdmf = meshio.Mesh(points, triangles,cell_data=boundaries)
    meshio.write("%s/boundaries.xdmf" % xdmfdir, xdmf)
Ejemplo n.º 38
0
def test_reference_file_with_entities(
    filename, ref_sum, ref_num_cells, ref_num_cells_in_cell_sets, binary
):
    this_dir = pathlib.Path(__file__).resolve().parent
    filename = this_dir / "meshes" / "msh" / filename

    mesh = meshio.read(filename)
    tol = 1.0e-2
    s = mesh.points.sum()
    assert abs(s - ref_sum) < tol * ref_sum
    assert {k: len(v) for k, v in mesh.cells_dict.items()} == ref_num_cells
    assert {
        k: len(v) for k, v in mesh.cell_data_dict["gmsh:physical"].items()
    } == ref_num_cells

    writer = partial(meshio.gmsh.write, fmt_version="4.1", binary=binary)

    num_cells = {k: 0 for k in ref_num_cells_in_cell_sets}
    for vv in mesh.cell_sets_dict.values():
        for k, v in vv.items():
            num_cells[k] += len(v)
    assert num_cells == ref_num_cells_in_cell_sets

    helpers.write_read(writer, meshio.gmsh.read, mesh, 1.0e-15)
Ejemplo n.º 39
0
def generate_surface_mesh(
    domain,
    bounding_sphere_radius=0.0,
    angle_bound=0.0,
    radius_bound=0.0,
    distance_bound=0.0,
    verbose=True,
):
    fh, outfile = tempfile.mkstemp(suffix=".off")
    os.close(fh)

    _generate_surface_mesh(
        domain,
        outfile,
        bounding_sphere_radius=bounding_sphere_radius,
        angle_bound=angle_bound,
        radius_bound=radius_bound,
        distance_bound=distance_bound,
        verbose=verbose,
    )

    mesh = meshio.read(outfile)
    os.remove(outfile)
    return mesh
Ejemplo n.º 40
0
def test_ring_extrude():
    p = pygalmesh.Polygon2D([[0.5, -0.3], [1.5, -0.3], [1.0, 0.5]])
    edge_size = 0.1
    domain = pygalmesh.RingExtrude(p, edge_size)
    pygalmesh.generate_mesh(domain,
                            'out.mesh',
                            cell_size=0.1,
                            edge_size=edge_size,
                            verbose=False)

    vertices, cells, _, _, _ = meshio.read('out.mesh')

    tol = 1.0e-3
    assert abs(max(vertices[:, 0]) - 1.5) < tol
    assert abs(min(vertices[:, 0]) + 1.5) < tol
    assert abs(max(vertices[:, 1]) - 1.5) < tol
    assert abs(min(vertices[:, 1]) + 1.5) < tol
    assert abs(max(vertices[:, 2]) - 0.5) < tol
    assert abs(min(vertices[:, 2]) + 0.3) < tol

    vol = sum(compute_volumes(vertices, cells['tetra']))
    assert abs(vol - 2 * numpy.pi * 0.4) < 0.05

    return
Ejemplo n.º 41
0
    def test_segment_domain(self):
        for element, element_type, meshfile in [
            (Segment, 'line', '1D_linear.vtk'),
            (Segment3, 'line3', '1D_quadratic.vtk')
        ]:
            m = meshio.read(os.path.join(meshfolder, meshfile))
            mesh = Mesh(m.points[:, 0])

            if type(m.cells) == dict:
                cells = m.cells[element_type]
            else:
                cells = m.cells_dict[element_type]

            # Creation with name
            domain = mesh.add_domain("segments", element(Caribou._1D), cells)
            self.assertEqual(domain.number_of_elements(), 10)
            self.assertMatrixEqual(domain.element_indices(0), cells[0])
            self.assertMatrixEqual(domain.element_indices(9), cells[9])

            # Creation without name
            domain = mesh.add_domain(element(Caribou._1D), cells)
            self.assertEqual(domain.number_of_elements(), 10)
            self.assertMatrixEqual(domain.element_indices(0), cells[0])
            self.assertMatrixEqual(domain.element_indices(9), cells[9])
Ejemplo n.º 42
0
def save_boundary_vtk(ses, mshfile, outname, res_id):
    '''
    Save a boundary result into a VTK file.
    '''
    print 'Saving boundary results...'
    #res_id = input('Enter the boundary result ID: ')
    result = get_result(ses, id=res_id)
    if result is None:
        print 'No matching results for ID = {}'.format(res_id)
        return
    mesh = meshio.read(mshfile)
    barrs = result.array_data_by_name()

    from tvtk.api import tvtk, write_data
    pd = tvtk.PolyData()
    pd.points = mesh.points
    pd.polys = mesh.cells['triangle']
    pd.cell_data.add_array(mesh.cell_data['triangle']['gmsh:physical'])
    pd.cell_data.get_array(0).name = 'domains'
    for count, name in enumerate(['dirichlet', 'neumann']):
        pd.cell_data.add_array(barrs[name])
        pd.cell_data.get_array(count + 1).name = name
    outname = outname+'.vtk'
    write_data(pd, outname)
Ejemplo n.º 43
0
    def convert(self):
        msh = meshio.read("{}.msh".format(self.filename))
        # meshio.write("mesh.xdmf", meshio.Mesh(points=msh.points, cells={"tetra": msh.cells["tetra"]}))
        # meshio.write("mf.xdmf", meshio.Mesh(points=msh.points, cells={"triangle": msh.cells["triangle"]}, cell_data={"triangle": {"name_to_read": msh.cell_data["triangle"]["gmsh:physical"]}}))
        for cell in msh.cells:
            if cell.type == "triangle":
                triangle_cells = cell.data
            elif  cell.type == "tetra":
                tetra_cells = cell.data
        for key in msh.cell_data_dict["gmsh:physical"].keys():
            if key == "triangle":
                triangle_data = msh.cell_data_dict["gmsh:physical"][key]
            elif key == "tetra":
                tetra_data = msh.cell_data_dict["gmsh:physical"][key]
        triangle_mesh = meshio.Mesh(points=msh.points,
                                   cells=[("triangle", triangle_cells)],
                                   cell_data={"name_to_read":[triangle_data]})
        tetra_mesh =meshio.Mesh(points=msh.points,
                                   cells=[("tetra", tetra_cells)],
                                   cell_data={"name_to_read":[tetra_data]})
        meshio.write("{}_tetra.xdmf".format(self.filename), tetra_mesh)

        meshio.write("{}_triangle.xdmf".format(self.filename), triangle_mesh)
        mesh = Mesh()
        # with XDMFFile("mesh.xdmf") as infile:
        #     infile.read(mesh)
        mesh_file = XDMFFile(MPI.comm_world, "{}_triangle.xdmf".format(self.filename))
        mesh = Mesh()
        mesh_file.read(mesh);
        # mvc = MeshValueCollection("size_t", mesh, 2)
        mvc = MeshValueCollection("size_t", mesh, 3)
        mesh_file.read(mvc, "name_to_read")
        # with XDMFFile("mf.xdmf") as infile:
        #     infile.read(mvc, "name_to_read")
        mf = cpp.mesh.MeshFunctionSizet(mesh, mvc)
        File("{}_domains.pvd".format(self.filename)).write(mf)
Ejemplo n.º 44
0
def test_stretch():
    alpha = 2.0
    s = pygalmesh.Stretch(pygalmesh.Cuboid([0, 0, 0], [1, 2, 3]),
                          [alpha, 0.0, 0.0])
    pygalmesh.generate_mesh(s,
                            'out.mesh',
                            cell_size=0.2,
                            edge_size=0.2,
                            verbose=False)

    vertices, cells, _, _, _ = meshio.read('out.mesh')

    tol = 1.0e-3
    assert abs(max(vertices[:, 0]) - alpha) < tol
    assert abs(min(vertices[:, 0]) + 0.0) < tol
    assert abs(max(vertices[:, 1]) - 2.0) < tol
    assert abs(min(vertices[:, 1]) + 0.0) < tol
    assert abs(max(vertices[:, 2]) - 3.0) < tol
    assert abs(min(vertices[:, 2]) + 0.0) < tol

    vol = sum(compute_volumes(vertices, cells['tetra']))
    assert abs(vol - 12.0) < tol

    return
Ejemplo n.º 45
0
def test_cli():
    input_mesh = helpers.tri_mesh
    infile = tempfile.NamedTemporaryFile().name
    meshio.write(infile, input_mesh, file_format="gmsh-ascii")

    outfile = tempfile.NamedTemporaryFile().name

    meshio.cli.main([
        infile,
        outfile,
        "--input-format",
        "gmsh-ascii",
        "--output-format",
        "vtk-binary",
    ])

    mesh = meshio.read(outfile, file_format="vtk-binary")

    atol = 1.0e-15
    assert numpy.allclose(input_mesh.points, mesh.points, atol=atol, rtol=0.0)

    for cell_type, data in input_mesh.cells.items():
        assert numpy.allclose(data, mesh.cells[cell_type])
    return
Ejemplo n.º 46
0
def wing():

    # creation of a volumic wing with the extrusion of a 2d profile on a 
    # generatrix defined by a 3d-spline

    sys.path.append('./profiles')
    from splineProfileMultiParam import  Profile
    from scipy import interpolate
    from mpl_toolkits.mplot3d import Axes3D


    # creation of the geometry pygmsh
    geom = pg.built_in.Geometry()
    
    # control points of the generatrix
    x = [0.0, 0.1, 0.4, 0.6, 0.9]
    y = [0.0, 0.05, 0.09, 0.11, 0.4]
    z = [0.0, 0.3, 0.8, 1.2, 2.9]

    # tck, u represent the parametric 3d curve
    tck, u = interpolate.splprep([x,y,z], s=2)
    name = 'wingZero'
    Nslices = 100 # number of slices
    npt = 63 # points of the profile
    t = np.linspace(0., 1., Nslices) # parametric space
    pf = Profile(typ = 'fon',par = [0.82,0.21,0.13,0.08,0.029],npt = npt) # creation of the 2d profile
    fi = Frame(t[0], tck, type = 'Xnat')
    pol = pf.polyline()
    pol.to_frame(fi, scale = 0.5)
    li = pol.add_to_geom(geom)
    lloop = []
    for l in li : lloop.append(l)
    ll = geom.add_line_loop(lloop)
    li0 = li
    sf = geom.add_plane_surface(ll)
    phys = []
    geom.add_physical_surface(sf)
    phys.append(sf)
    for i in range(Nslices-1):
        si = t[i]
        sip1 = t[i+1]
        #pf = Profile(typ = 'fon',par = [0.82,0.21,0.13,0.08,0.029],npt = npt)
        fip1 = Frame(sip1, tck, type = 'Xnat')
        pol = pf.polyline()
        pol.to_frame(fip1, scale = 0.5*np.cos(sip1*0.4*np.pi))
        lip1 = pol.add_to_geom(geom)
        for j in range(len(li)):
            lij = li0[j]
            lip1j = lip1[j]
            lti = geom.add_line(lij.points[0], lip1j.points[0])
            ltip1 = geom.add_line(lij.points[1], lip1j.points[1])
            lloop = geom.add_line_loop([lti, lip1j, -ltip1, -lij])
            sf = geom.add_ruled_surface(lloop)
            phys.append(sf)
        li0 = lip1
    lloop = []
    for l in lip1 : lloop.append(-l)
    ll = geom.add_line_loop(lloop)
    li0 = li
    sf = geom.add_plane_surface(ll)
    phys.append(sf)
    physS = geom.add_surface_loop(phys)
    geom.add_physical_surface(phys, label = 'profile')
    write_geo(name, geom)
    import subprocess
    exe_gmsh = '/home/fon/gmsh-2.16.0-Linux/bin/gmsh'
    subprocess.call([exe_gmsh,name+'.geo','-2','-o',name+'.msh','>',name+'.mshlog'])
    X, cells, pt_data, cell_data, field_data = meshio.read(name+'.msh')
    box3D(10.,10., 10., [0])
    print X
    print cells['triangle']
    import readMSH as rmsh
    d = rmsh.read_msh_file(name)
    rmsh.write_fms_file(name,**d)
    d = read_msh_triangulation(name+'.msh')
    d.write_obj_file(name)
Ejemplo n.º 47
0
 def load_mshfile(self, mshfile):
     "Load self from a MSH file."
     self.points, self.elements,_,_,_ = meshio.read(mshfile)
Ejemplo n.º 48
0
def generate_mesh(
    geo_object,
    verbose=True,
    dim=3,
    prune_vertices=True,
    prune_z_0=False,
    remove_faces=False,
    gmsh_path=None,
    extra_gmsh_arguments=None,
    # for debugging purposes:
    geo_filename=None,
    mesh_file_type="msh",
):
    """Return a meshio.Mesh, storing the mesh points, cells, and data,
    generated by Gmsh from the `geo_object`, written to a temporary file,
    and reread by `meshio`.

    Gmsh's native "msh" format is ill-suited to fast I/O.  This can
    greatly reduce the performance of pygmsh.  As alternatives, try
    `mesh_file_type=`:

    - "vtk"`, though Gmsh doesn't write the physical tags
    to VTK <https://gitlab.onelab.info/gmsh/gmsh/issues/389> or

    - `"mesh"`, though this only supports a few basic elements - "line",
    "triangle", "quad", "tetra", "hexahedron" - and doesn't preserve
    the `$PhysicalNames`, just the `int` tags.

    """
    if extra_gmsh_arguments is None:
        extra_gmsh_arguments = []

    # For format "mesh", ask Gmsh to save the physical tags
    # http://gmsh.info/doc/texinfo/gmsh.html#index-Mesh_002eSaveElementTagType
    if mesh_file_type == "mesh":
        extra_gmsh_arguments += ["-string", "Mesh.SaveElementTagType=2;"]

    preserve_geo = geo_filename is not None
    if geo_filename is None:
        with tempfile.NamedTemporaryFile(suffix=".geo") as f:
            geo_filename = f.name

    with open(geo_filename, "w") as f:
        f.write(geo_object.get_code())

    # As of Gmsh 4.1.3, the mesh format options are
    # ```
    # auto, msh1, msh2, msh3, msh4, msh, unv, vtk, wrl, mail, stl, p3d, mesh, bdf, cgns,
    # med, diff, ir3, inp, ply2, celum, su2, x3d, dat, neu, m, key
    # ```
    # Pick the correct filename suffix.
    filename_suffix = "msh" if mesh_file_type[:3] == "msh" else mesh_file_type

    with tempfile.NamedTemporaryFile(suffix="." + filename_suffix) as handle:
        msh_filename = handle.name

    gmsh_executable = gmsh_path if gmsh_path is not None else _get_gmsh_exe()

    args = [
        "-{}".format(dim),
        geo_filename,
        "-format",
        mesh_file_type,
        "-bin",
        "-o",
        msh_filename,
    ] + extra_gmsh_arguments

    # https://stackoverflow.com/a/803421/353337
    p = subprocess.Popen(
        [gmsh_executable] + args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
    )
    if verbose:
        while True:
            line = p.stdout.readline()
            if not line:
                break
            print(line.decode("utf-8"), end="")

    p.communicate()
    assert p.returncode == 0, "Gmsh exited with error (return code {}).".format(
        p.returncode
    )

    mesh = meshio.read(msh_filename)

    if remove_faces:
        # Only keep the cells of highest topological dimension; discard faces
        # and such.
        two_d_cells = set(["triangle", "quad"])
        three_d_cells = set(
            ["tetra", "hexahedron", "wedge", "pyramid", "penta_prism", "hexa_prism"]
        )
        if any(k in mesh.cells for k in three_d_cells):
            keep_keys = three_d_cells.intersection(mesh.cells.keys())
        elif any(k in mesh.cells for k in two_d_cells):
            keep_keys = two_d_cells.intersection(mesh.cells.keys())
        else:
            keep_keys = mesh.cells.keys()

        mesh.cells = {key: mesh.cells[key] for key in keep_keys}
        mesh.cell_data = {key: mesh.cell_data[key] for key in keep_keys}

    if prune_vertices:
        # Make sure to include only those vertices which belong to a cell.
        ncells = numpy.concatenate([numpy.concatenate(c) for c in mesh.cells.values()])
        uvertices, uidx = numpy.unique(ncells, return_inverse=True)

        k = 0
        for key in mesh.cells.keys():
            n = numpy.prod(mesh.cells[key].shape)
            mesh.cells[key] = uidx[k : k + n].reshape(mesh.cells[key].shape)
            k += n

        mesh.points = mesh.points[uvertices]
        for key in mesh.point_data:
            mesh.point_data[key] = mesh.point_data[key][uvertices]

    # clean up
    os.remove(msh_filename)
    if preserve_geo:
        print("\ngeo file: {}".format(geo_filename))
    else:
        os.remove(geo_filename)

    if (
        prune_z_0
        and mesh.points.shape[1] == 3
        and numpy.all(numpy.abs(mesh.points[:, 2]) < 1.0e-13)
    ):
        mesh.points = mesh.points[:, :2]

    return mesh
Ejemplo n.º 49
0
# -*- coding: utf-8 -*-
"""
Load a GMSH mesh and plot contours for its height.
"""
import meshio
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.tri import Triangulation
from matplotlib import rcParams

rcParams['font.family'] = 'serif'
rcParams['font.size'] = 14
rcParams['image.cmap'] = "YlGnBu_r"

points, cells, point_data, cell_data, field_data = \
    meshio.read("../MESHES/DAM/dam.msh")

x = points[:, 0]
y = points[:, 1]
tri = Triangulation(x, y, cells['triangle'])
plt.tricontourf(tri, y, 12, shading="gourad")
plt.axis("image")
plt.show()