def test_interpolation(self): from sfepy import data_dir from sfepy.discrete.fem import Mesh from sfepy.linalg import make_axis_rotation_matrix fname = in_dir(self.options.out_dir) meshes = { 'tp' : Mesh.from_file(data_dir + '/meshes/3d/block.mesh'), 'si' : Mesh.from_file(data_dir + '/meshes/3d/cylinder.mesh'), } datas = gen_datas(meshes) for field_name in ['scalar_si', 'vector_si', 'scalar_tp', 'vector_tp']: m1 = meshes[field_name[-2:]] for ia, angle in enumerate(nm.linspace(0.0, nm.pi, 11)): self.report('%s: %d. angle: %f' % (field_name, ia, angle)) shift = [0.0, 0.0, 0.0] mtx = make_axis_rotation_matrix([0, 1, 0], angle) m2 = m1.copy('rotated mesh') m2.transform_coors(mtx) data = datas[field_name] u1, u2 = do_interpolation(m2, m1, data, field_name) if ia == 0: u1.save_as_mesh(fname('test_mesh_interp_%s_u1.vtk' % field_name)) u2.save_as_mesh(fname('test_mesh_interp_%s_u2.%03d.vtk' % (field_name, ia))) return True
def test_write_read_meshes(self): """ Try to write and then read all supported formats. """ from sfepy.discrete.fem import Mesh from sfepy.discrete.fem.meshio import (supported_formats, supported_capabilities) conf_dir = op.dirname(__file__) mesh0 = Mesh.from_file(data_dir + '/meshes/various_formats/small3d.mesh', prefix_dir=conf_dir) oks = [] for suffix, format_ in six.iteritems(supported_formats): if isinstance(format_, tuple): continue if 'w' not in supported_capabilities[format_]: continue filename = op.join(self.options.out_dir, 'test_mesh_wr' + suffix) self.report('%s format: %s' % (suffix, filename)) mesh0.write(filename, io='auto') mesh1 = Mesh.from_file(filename) oks.extend(self._compare_meshes(mesh0, mesh1)) return sum(oks) == len(oks)
def test_write_read_meshes(self): """ Try to write and then read all supported formats. """ from sfepy.discrete.fem import Mesh from sfepy.discrete.fem.meshio import (supported_formats, supported_capabilities) conf_dir = op.dirname(__file__) mesh0 = Mesh.from_file(data_dir + '/meshes/various_formats/small3d.mesh', prefix_dir=conf_dir) oks = [] for suffix, format_ in supported_formats.iteritems(): if isinstance(format_, tuple): continue if 'w' not in supported_capabilities[format_]: continue filename = op.join(self.options.out_dir, 'test_mesh_wr' + suffix) self.report('%s format: %s' % (suffix, filename)) mesh0.write(filename, io='auto') mesh1 = Mesh.from_file(filename) oks.extend(self._compare_meshes(mesh0, mesh1)) return sum(oks) == len(oks)
def main(): parser = ArgumentParser(description=__doc__.rstrip(), formatter_class=RawDescriptionHelpFormatter) parser.add_argument('filename', help=helps['filename']) parser.add_argument('-d', '--detailed', action='store_true', dest='detailed', default=False, help=helps['detailed']) options = parser.parse_args() mesh = Mesh.from_file(options.filename) output(mesh.cmesh) output('element types:', mesh.descs) output('nodal BCs:', sorted(mesh.nodal_bcs.keys())) bbox = mesh.get_bounding_box() output('bounding box:\n%s' % '\n'.join('%s: [%14.7e, %14.7e]' % (name, bbox[0, ii], bbox[1, ii]) for ii, name in enumerate('xyz'[:mesh.dim]))) output('centre: [%s]' % ', '.join('%14.7e' % ii for ii in 0.5 * (bbox[0] + bbox[1]))) output('coordinates mean: [%s]' % ', '.join('%14.7e' % ii for ii in mesh.coors.mean(0))) if not options.detailed: return domain = FEDomain(mesh.name, mesh) for dim in range(1, mesh.cmesh.tdim + 1): volumes = mesh.cmesh.get_volumes(dim) output('volumes of %d %dD entities:\nmin: %.7e mean: %.7e median:' ' %.7e max: %.7e' % (mesh.cmesh.num[dim], dim, volumes.min(), volumes.mean(), nm.median(volumes), volumes.max())) euler = lambda mesh: nm.dot(mesh.cmesh.num, [1, -1, 1, -1]) ec = euler(mesh) output('Euler characteristic:', ec) graph = mesh.create_conn_graph(verbose=False) n_comp, _ = graph_components(graph.shape[0], graph.indptr, graph.indices) output('number of connected components:', n_comp) if mesh.dim > 1: region = domain.create_region('surf', 'vertices of surface', 'facet') surf_mesh = Mesh.from_region(region, mesh, localize=True, is_surface=True) FEDomain(surf_mesh.name, surf_mesh) # Calls CMesh.setup_entities(). sec = euler(surf_mesh) output('surface Euler characteristic:', sec) if mesh.dim == 3: output('surface genus:', (2.0 - sec) / 2.0) surf_graph = surf_mesh.create_conn_graph(verbose=False) n_comp, _ = graph_components(surf_graph.shape[0], surf_graph.indptr, surf_graph.indices) output('number of connected surface components:', n_comp)
def refine_region(domain0, region0, region1): """ Coarse cell sub_cells[ii, 0] in mesh0 is split into sub_cells[ii, 1:] in mesh1. The new fine cells are interleaved among the original coarse cells so that the indices of the coarse cells do not change. The cell groups are preserved. The vertex groups are preserved only in the coarse (non-refined) cells. """ if region1 is None: return domain0, None mesh0 = domain0.mesh mesh1 = Mesh.from_region(region1, mesh0) domain1 = FEDomain('d', mesh1) domain1r = domain1.refine() mesh1r = domain1r.mesh n_cell = region1.shape.n_cell n_sub = 4 if mesh0.cmesh.tdim == 2 else 8 sub_cells = nm.empty((n_cell, n_sub + 1), dtype=nm.uint32) sub_cells[:, 0] = region1.cells sub_cells[:, 1] = region1.cells aux = nm.arange((n_sub - 1) * n_cell, dtype=nm.uint32) sub_cells[:, 2:] = mesh0.n_el + aux.reshape((n_cell, -1)) coors0, vgs0, conns0, mat_ids0, descs0 = mesh0._get_io_data() coors, vgs, _conns, _mat_ids, descs = mesh1r._get_io_data() # Preserve vertex groups of non-refined cells. vgs[:len(vgs0)] = vgs0 def _interleave_refined(c0, c1): if c1.ndim == 1: c0 = c0[:, None] c1 = c1[:, None] n_row, n_col = c1.shape n_new = region0.shape.n_cell + n_row out = nm.empty((n_new, n_col), dtype=c0.dtype) out[region0.cells] = c0[region0.cells] out[region1.cells] = c1[::n_sub] aux = c1.reshape((-1, n_col * n_sub)) out[mesh0.n_el:] = aux[:, n_col:].reshape((-1, n_col)) return out conn = _interleave_refined(conns0[0], _conns[0]) mat_id = _interleave_refined(mat_ids0[0], _mat_ids[0]).squeeze() mesh = Mesh.from_data('a', coors, vgs, [conn], [mat_id], descs) domain = FEDomain('d', mesh) return domain, sub_cells
def refine_region(domain0, region0, region1): """ Coarse cell sub_cells[ii, 0] in mesh0 is split into sub_cells[ii, 1:] in mesh1. The new fine cells are interleaved among the original coarse cells so that the indices of the coarse cells do not change. The cell groups are preserved. The vertex groups are preserved only in the coarse (non-refined) cells. """ if region1 is None: return domain0, None mesh0 = domain0.mesh mesh1 = Mesh.from_region(region1, mesh0) domain1 = FEDomain('d', mesh1) domain1r = domain1.refine() mesh1r = domain1r.mesh n_cell = region1.shape.n_cell n_sub = 4 if mesh0.cmesh.tdim == 2 else 8 sub_cells = nm.empty((n_cell, n_sub + 1), dtype=nm.uint32) sub_cells[:, 0] = region1.cells sub_cells[:, 1] = region1.cells aux = nm.arange((n_sub - 1) * n_cell, dtype=nm.uint32) sub_cells[:, 2:] = mesh0.n_el + aux.reshape((n_cell, -1)) coors0, vgs0, conns0, mat_ids0, descs0 = mesh0._get_io_data() coors, vgs, _conns, _mat_ids, descs = mesh1r._get_io_data() # Preserve vertex groups of non-refined cells. vgs[:len(vgs0)] = vgs0 def _interleave_refined(c0, c1): if c1.ndim == 1: c0 = c0[:, None] c1 = c1[:, None] n_row, n_col = c1.shape n_new = region0.shape.n_cell + n_row out = nm.empty((n_new, n_col), dtype=c0.dtype) out[region0.cells] = c0[region0.cells] out[region1.cells] = c1[::n_sub] aux = c1.reshape((-1, n_col * n_sub)) out[mesh0.n_el:] = aux[:, n_col:].reshape((-1, n_col)) return out conn = _interleave_refined(conns0[0], _conns[0]) mat_id = _interleave_refined(mat_ids0[0], _mat_ids[0]).squeeze() mesh = Mesh.from_data('a', coors, vgs, [conn], [mat_id], descs) domain = FEDomain('d', mesh) return domain, sub_cells
def __init__(self, name, nurbs, bmesh, regions=None, **kwargs): """ Create an IGA domain. Parameters ---------- name : str The domain name. """ Domain.__init__(self, name, nurbs=nurbs, bmesh=bmesh, regions=regions, **kwargs) from sfepy.discrete.fem.geometry_element import create_geometry_elements from sfepy.discrete.fem import Mesh from sfepy.discrete.fem.utils import prepare_remap tconn = iga.get_bezier_topology(bmesh.conn, nurbs.degrees) itc = nm.unique(tconn) remap = prepare_remap(itc, bmesh.conn.max() + 1) ltcoors = bmesh.cps[itc] ltconn = remap[tconn] n_nod, dim = ltcoors.shape n_el = ltconn.shape[0] self.shape = Struct(n_nod=n_nod, dim=dim, tdim=0, n_el=n_el) desc = '%d_%d' % (dim, bmesh.conn.shape[1]) mat_id = nm.zeros(bmesh.conn.shape[0], dtype=nm.int32) eval_mesh = Mesh.from_data(self.name + '_eval', nurbs.cps, None, [nurbs.conn], [mat_id], [desc]) self.eval_mesh = eval_mesh desc = '%d_%d' % (dim, 2**dim) mat_id = nm.zeros(ltconn.shape[0], dtype=nm.int32) self.mesh = Mesh.from_data(self.name + '_topo', ltcoors, None, [ltconn], [mat_id], [desc]) self.cmesh = self.mesh.cmesh gels = create_geometry_elements() self.cmesh.set_local_entities(gels) self.cmesh.setup_entities() self.shape.tdim = self.cmesh.tdim self.gel = gels[desc] if regions is not None: self.vertex_set_bcs = {} for key, val in six.iteritems(self.regions): self.vertex_set_bcs[key] = remap[val] self.reset_regions()
def test_interpolation_two_meshes(self): from sfepy import data_dir from sfepy.discrete import Variables from sfepy.discrete.fem import Mesh, FEDomain, Field m1 = Mesh.from_file(data_dir + '/meshes/3d/block.mesh') m2 = Mesh.from_file(data_dir + '/meshes/3d/cube_medium_tetra.mesh') m2.coors[:] *= 2.0 bbox = m1.get_bounding_box() dd = bbox[1, :] - bbox[0, :] data = nm.sin(4.0 * nm.pi * m1.coors[:,0:1] / dd[0]) \ * nm.cos(4.0 * nm.pi * m1.coors[:,1:2] / dd[1]) variables1 = { 'u': ('unknown field', 'scalar_tp', 0), 'v': ('test field', 'scalar_tp', 'u'), } variables2 = { 'u': ('unknown field', 'scalar_si', 0), 'v': ('test field', 'scalar_si', 'u'), } d1 = FEDomain('d1', m1) omega1 = d1.create_region('Omega', 'all') field1 = Field.from_args('scalar_tp', nm.float64, (1, 1), omega1, approx_order=1) ff1 = {field1.name: field1} d2 = FEDomain('d2', m2) omega2 = d2.create_region('Omega', 'all') field2 = Field.from_args('scalar_si', nm.float64, (1, 1), omega2, approx_order=0) ff2 = {field2.name: field2} vv1 = Variables.from_conf(transform_variables(variables1), ff1) u1 = vv1['u'] u1.set_from_mesh_vertices(data) vv2 = Variables.from_conf(transform_variables(variables2), ff2) u2 = vv2['u'] # Performs interpolation, if other field differs from self.field # or, in particular, is defined on a different mesh. u2.set_from_other(u1, strategy='interpolation', close_limit=0.1) fname = in_dir(self.options.out_dir) u1.save_as_mesh(fname('test_mesh_interp_block_scalar.vtk')) u2.save_as_mesh(fname('test_mesh_interp_cube_scalar.vtk')) return True
def __init__(self, name, nurbs, bmesh, regions=None, **kwargs): """ Create an IGA domain. Parameters ---------- name : str The domain name. """ Domain.__init__(self, name, nurbs=nurbs, bmesh=bmesh, regions=regions, **kwargs) from sfepy.discrete.fem.geometry_element import create_geometry_elements from sfepy.discrete.fem import Mesh from sfepy.discrete.fem.utils import prepare_remap tconn = iga.get_bezier_topology(bmesh.conn, nurbs.degrees) itc = nm.unique(tconn) remap = prepare_remap(itc, bmesh.conn.max() + 1) ltcoors = bmesh.cps[itc] ltconn = remap[tconn] n_nod, dim = ltcoors.shape n_el = ltconn.shape[0] self.shape = Struct(n_nod=n_nod, dim=dim, tdim=0, n_el=n_el) desc = '%d_%d' % (dim, bmesh.conn.shape[1]) mat_id = nm.zeros(bmesh.conn.shape[0], dtype=nm.int32) eval_mesh = Mesh.from_data(self.name + '_eval', nurbs.cps, None, [nurbs.conn], [mat_id], [desc]) self.eval_mesh = eval_mesh desc = '%d_%d' % (dim, 2**dim) mat_id = nm.zeros(ltconn.shape[0], dtype=nm.int32) self.mesh = Mesh.from_data(self.name + '_topo', ltcoors, None, [ltconn], [mat_id], [desc]) self.cmesh = self.mesh.cmesh gels = create_geometry_elements() self.cmesh.set_local_entities(gels) self.cmesh.setup_entities() self.shape.tdim = self.cmesh.tdim self.gel = gels[desc] if regions is not None: self.vertex_set_bcs = {} for key, val in self.regions.iteritems(): self.vertex_set_bcs[key] = remap[val] self.reset_regions()
def test_interpolation_two_meshes(self): from sfepy import data_dir from sfepy.discrete import Variables from sfepy.discrete.fem import Mesh, FEDomain, Field m1 = Mesh.from_file(data_dir + '/meshes/3d/block.mesh') m2 = Mesh.from_file(data_dir + '/meshes/3d/cube_medium_tetra.mesh') m2.coors[:] *= 2.0 bbox = m1.get_bounding_box() dd = bbox[1,:] - bbox[0,:] data = nm.sin(4.0 * nm.pi * m1.coors[:,0:1] / dd[0]) \ * nm.cos(4.0 * nm.pi * m1.coors[:,1:2] / dd[1]) variables1 = { 'u' : ('unknown field', 'scalar_tp', 0), 'v' : ('test field', 'scalar_tp', 'u'), } variables2 = { 'u' : ('unknown field', 'scalar_si', 0), 'v' : ('test field', 'scalar_si', 'u'), } d1 = FEDomain('d1', m1) omega1 = d1.create_region('Omega', 'all') field1 = Field.from_args('scalar_tp', nm.float64, (1,1), omega1, approx_order=1) ff1 = {field1.name : field1} d2 = FEDomain('d2', m2) omega2 = d2.create_region('Omega', 'all') field2 = Field.from_args('scalar_si', nm.float64, (1,1), omega2, approx_order=0) ff2 = {field2.name : field2} vv1 = Variables.from_conf(transform_variables(variables1), ff1) u1 = vv1['u'] u1.set_from_mesh_vertices(data) vv2 = Variables.from_conf(transform_variables(variables2), ff2) u2 = vv2['u'] # Performs interpolation, if other field differs from self.field # or, in particular, is defined on a different mesh. u2.set_from_other(u1, strategy='interpolation', close_limit=0.1) fname = in_dir(self.options.out_dir) u1.save_as_mesh(fname('test_mesh_interp_block_scalar.vtk')) u2.save_as_mesh(fname('test_mesh_interp_cube_scalar.vtk')) return True
def test_write_read_meshes(self): """ Try to write and then read all supported formats. """ import numpy as nm from sfepy.discrete.fem import Mesh from sfepy.discrete.fem.meshio import supported_formats conf_dir = op.dirname(__file__) mesh0 = Mesh.from_file(data_dir + '/meshes/various_formats/small3d.mesh', prefix_dir=conf_dir) mesh0.cmesh.vertex_groups[:] =\ nm.random.randint(1, 10, size=mesh0.cmesh.n_coor) mesh0.cmesh.cell_groups[:] =\ nm.random.randint(1, 10, size=mesh0.cmesh.n_el) oks = [] for name, (cls, suffix, flag) in six.iteritems(supported_formats): if 'w' not in flag: continue suffix = suffix[0] # only the first of possible suffixes filename = op.join(self.options.out_dir, 'test_mesh_wr' + suffix) self.report('%s format: %s' % (suffix, filename)) try: mesh0.write(filename, io='auto') except RuntimeError: if cls == 'meshio': import traceback self.report('-> cannot write "%s" format into "%s",' ' skipping' % (name, filename)) tb = traceback.format_exc() self.report('reason:\n', tb) continue else: raise else: mesh1 = Mesh.from_file(filename) ok = self._compare_meshes(mesh0, mesh1, flag) self.report('->', sum(ok) == len(ok)) oks.extend(ok) return sum(oks) == len(oks)
def from_conf(conf, options): from sfepy import data_dir from sfepy.discrete.fem import Mesh, FEDomain from sfepy.discrete import Functions mesh = Mesh("test mesh", data_dir + "/meshes/various_formats/abaqus_tet.inp") mesh.nodal_bcs["set0"] = [0, 7] domain = FEDomain("test domain", mesh) conf_functions = {"get_vertices": (get_vertices,), "get_cells": (get_cells,)} functions = Functions.from_conf(transform_functions(conf_functions)) test = Test(conf=conf, options=options, domain=domain, functions=functions) return test
def refine_mesh(filename, level): """ Uniformly refine `level`-times a mesh given by `filename`. The refined mesh is saved to a file with name constructed from base name of `filename` and `level`-times appended `'_r'` suffix. Parameters ---------- filename : str The mesh file name. level : int The refinement level. """ import os from sfepy.base.base import output from sfepy.discrete.fem import Mesh, FEDomain if level > 0: mesh = Mesh.from_file(filename) domain = FEDomain(mesh.name, mesh) for ii in range(level): output('refine %d...' % ii) domain = domain.refine() output('... %d nodes %d elements' % (domain.shape.n_nod, domain.shape.n_el)) suffix = os.path.splitext(filename)[1] filename = domain.name + suffix domain.mesh.write(filename, io='auto') return filename
def main(): parser = OptionParser(usage=usage) (options, args) = parser.parse_args() if len(args) != 1: parser.print_help() sys.exit(1) mesh_dir = args[0] mesh_files = [] for (dirpath, dirnames, filenames) in os.walk(mesh_dir): for ii in filenames: _, ext = os.path.splitext(ii) if ext.lower() in ['.mesh', '.vtk']: mesh_files.append(dirpath + os.path.sep + ii) for ii in mesh_files: base, ext = os.path.splitext(ii) fname_out = base + '.png' if ext == '.mesh': fname_in = 'aux.vtk' mesh = Mesh.from_file(ii) mesh.write(fname_in, io='auto') else: fname_in = ii print('writing %s...' % fname_out) gen_shot(fname_in, fname_out)
def test_rcm(self): from sfepy import data_dir from sfepy.linalg import rcm, permute_in_place, save_sparse_txt from sfepy.discrete.fem import Mesh filename = data_dir + '/meshes/2d/special/square_triquad.mesh' self.report('testing reversed Cuthill-McKee permutation') conf_dir = op.dirname(__file__) mesh = Mesh.from_file(filename, prefix_dir=conf_dir) graph = mesh.create_conn_graph() graph0 = graph.copy() save_sparse_txt(op.join(self.options.out_dir, 'test_rcm_graph_orig'), graph, fmt='%d %d %d\n') perm = rcm(graph) permute_in_place(graph, perm) save_sparse_txt(op.join(self.options.out_dir, 'test_rcm_graph_rcm'), graph, fmt='%d %d %d\n') assert_((graph0.indptr != graph.indptr).any()) assert_((graph0.indices != graph.indices).any()) permute_in_place(graph, perm, inverse=True) save_sparse_txt(op.join(self.options.out_dir, 'test_rcm_graph_rcm_inv'), graph, fmt='%d %d %d\n') assert_((graph0.indptr == graph.indptr).all()) assert_((graph0.indices == graph.indices).all()) return True
def triangulate(mesh, verbose=False): """ Triangulate a 2D or 3D tensor product mesh: quadrilaterals->triangles, hexahedrons->tetrahedrons. Parameters ---------- mesh : Mesh The input mesh. Returns ------- mesh : Mesh The triangulated mesh. """ conns = None for k, new_desc in [('3_8', '3_4'), ('2_4', '2_3')]: if k in mesh.descs: conns = mesh.get_conn(k) break if conns is not None: nelo = conns.shape[0] output('initial mesh: %d elements' % nelo, verbose=verbose) new_conns = elems_q2t(conns) nn = new_conns.shape[0] // nelo new_cgroups = nm.repeat(mesh.cmesh.cell_groups, nn) output('new mesh: %d elements' % new_conns.shape[0], verbose=verbose) mesh = Mesh.from_data(mesh.name, mesh.coors, mesh.cmesh.vertex_groups, [new_conns], [new_cgroups], [new_desc]) return mesh
def test_spbox_2d(self): """ Check position of a given vertex in the deformed mesh. """ mesh = Mesh.from_file(data_dir + '/meshes/2d/square_tri1.mesh') spb = SplineBox([[-1, 1], [-1, 0.6]], mesh.coors, nsg=[2, 1]) spb.move_control_point(1, [0.1, -0.2]) spb.move_control_point(2, [0.2, -0.3]) spb.move_control_point(3, [0.0, -0.1]) pt0 = mesh.coors[175, :].copy() mesh.cmesh.coors[:] = spb.evaluate() pt1 = mesh.coors[175, :] expected_distance = 0.165892726387 actual_distance = nm.linalg.norm(pt0 - pt1) ok = nm.fabs(actual_distance - expected_distance)\ / expected_distance < tolerance if not ok: self.report('expected distance:') self.report(expected_distance) self.report('actual distance:') self.report(actual_distance) return ok
def from_conf(conf, options): from sfepy.discrete import FieldVariable, Variables, Problem from sfepy.discrete.fem import Mesh, FEDomain, Field mesh = Mesh.from_file(data_dir + '/meshes/2d/square_unit_tri.mesh') domain = FEDomain('domain', mesh) omega = domain.create_region('Omega', 'all') domain.create_region('Left', 'vertices in (x < -0.499)', 'facet') domain.create_region( 'LeftStrip', 'vertices in (x < -0.499)' ' & (y > -0.199) & (y < 0.199)', 'facet') domain.create_region('LeftFix', 'r.Left -v r.LeftStrip', 'facet') domain.create_region('Right', 'vertices in (x > 0.499)', 'facet') domain.create_region( 'RightStrip', 'vertices in (x > 0.499)' ' & (y > -0.199) & (y < 0.199)', 'facet') domain.create_region('RightFix', 'r.Right -v r.RightStrip', 'facet') fu = Field.from_args('fu', nm.float64, 'vector', omega, approx_order=2) u = FieldVariable('u', 'unknown', fu) fp = Field.from_args('fp', nm.float64, 'scalar', omega, approx_order=2) p = FieldVariable('p', 'unknown', fp) pb = Problem('test', domain=domain, fields=[fu, fp], auto_conf=False) test = Test(problem=pb, variables=Variables([u, p]), conf=conf, options=options) return test
def from_conf(conf, options): import sfepy from sfepy.discrete.fem import Mesh, FEDomain, Field mesh = Mesh.from_file('meshes/2d/rectangle_tri.mesh', prefix_dir=sfepy.data_dir) domain = FEDomain('domain', mesh) dim = domain.shape.dim min_x, max_x = domain.get_mesh_bounding_box()[:,0] eps = 1e-8 * (max_x - min_x) omega = domain.create_region('Omega', 'all') gamma1 = domain.create_region('Gamma1', 'vertices in x < %.10f' % (min_x + eps), 'facet') gamma2 = domain.create_region('Gamma2', 'vertices in x > %.10f' % (max_x - eps), 'facet') field = Field.from_args('fu', nm.float64, 'vector', omega, approx_order=2) test = Test(conf=conf, options=options, dim=dim, omega=omega, gamma1=gamma1, gamma2=gamma2, field=field) return test
def save_basis(nurbs, pars): """ Save a NURBS object basis on a FE mesh corresponding to the given parametrization in VTK files. Parameters ---------- nurbs : igakit.nurbs.NURBS instance The NURBS object. pars : sequence of array, optional The values of parameters in each parametric dimension. """ coors, conn, desc = create_linear_fe_mesh(nurbs, pars) mat_id = nm.zeros(conn.shape[0], dtype=nm.int32) mesh = Mesh.from_data('nurbs', coors, None, [conn], [mat_id], [desc]) n_dof = nurbs.weights.ravel().shape[0] variable = nm.zeros(n_dof, dtype=nm.float64) field = variable.reshape(nurbs.weights.shape) for ic in xrange(n_dof): variable[ic - 1] = 0.0 variable[ic] = 1.0 vals = nurbs.evaluate(field, *pars).reshape((-1)) out = {} out['bf'] = Struct(name='output_data', mode='vertex', data=vals[:, None]) mesh.write('iga_basis_%03d.vtk' % ic, io='auto', out=out)
def gen_two_bodies(dims0, shape0, centre0, dims1, shape1, centre1, shift1): from sfepy.discrete.fem import Mesh from sfepy.mesh.mesh_generators import gen_block_mesh m0 = gen_block_mesh(dims0, shape0, centre0) m1 = gen_block_mesh(dims1, shape1, centre1) coors = nm.concatenate((m0.coors, m1.coors + shift1), axis=0) desc = m0.descs[0] c0 = m0.get_conn(desc) c1 = m1.get_conn(desc) conn = nm.concatenate((c0, c1 + m0.n_nod), axis=0) ngroups = nm.zeros(coors.shape[0], dtype=nm.int32) ngroups[m0.n_nod:] = 1 mat_id = nm.zeros(conn.shape[0], dtype=nm.int32) mat_id[m0.n_el:] = 1 name = 'two_bodies.mesh' mesh = Mesh.from_data(name, coors, ngroups, [conn], [mat_id], m0.descs) mesh.write(name, io='auto') return mesh
def test_refine_3_8(self): mesh = Mesh.from_file(data_dir + '/meshes/elements/3_8_1.mesh') domain = refine(FEDomain('domain', mesh), self.options.out_dir, 1) ok = compare_mesh('3_8', domain.mesh.coors, domain.mesh.get_conn('3_8')) return ok
def main(): parser = ArgumentParser(description=__doc__) parser.add_argument('--version', action='version', version='%(prog)s') parser.add_argument('--eps', action='store', dest='eps', default=1e-12, help=helps['eps']) parser.add_argument('-o', '--filename-out', action='store', dest='filename_out', default=None, help=helps['filename-out']) parser.add_argument('filename') options = parser.parse_args() filename = options.filename mesh = Mesh.from_file(filename) mesh_out = extract_edges(mesh, eps=float(options.eps)) mesh_out = merge_lines(mesh_out) filename_out = options.filename_out if filename_out is None: filename_out = edit_filename(filename, prefix='edge_', new_ext='.vtk') output('Outline mesh - vertices: %d, edges: %d, output filename: %s' % (mesh_out[0].shape[0], mesh_out[2][0].shape[0], filename_out)) # hack to write '3_2' elements - edges io = VTKMeshIO(None) aux_mesh = Struct() aux_mesh._get_io_data = lambda: mesh_out aux_mesh.n_el = mesh_out[2][0].shape[0] io.write(filename_out, aux_mesh)
def test_rcm(self): from sfepy import data_dir from sfepy.linalg import rcm, permute_in_place, save_sparse_txt from sfepy.discrete.fem import Mesh filename = data_dir + '/meshes/2d/special/square_triquad.mesh' self.report('testing reversed Cuthill-McKee permutation') conf_dir = op.dirname(__file__) mesh = Mesh.from_file(filename, prefix_dir=conf_dir) graph = mesh.create_conn_graph() graph0 = graph.copy() save_sparse_txt(op.join(self.options.out_dir, 'test_rcm_graph_orig'), graph, fmt='%d %d %d\n') perm = rcm(graph) permute_in_place(graph, perm) save_sparse_txt(op.join(self.options.out_dir, 'test_rcm_graph_rcm'), graph, fmt='%d %d %d\n') assert_((graph0.indptr != graph.indptr).any()) assert_((graph0.indices != graph.indices).any()) permute_in_place(graph, perm, inverse=True) save_sparse_txt(op.join(self.options.out_dir, 'test_rcm_graph_rcm_inv'), graph, fmt='%d %d %d\n') assert_((graph0.indptr == graph.indptr).all()) assert_((graph0.indices == graph.indices).all()) return True
def _get_bqp(geometry, order): from sfepy.discrete import Integral from sfepy.discrete.fem.geometry_element import GeometryElement from sfepy.discrete.fem import Mesh, FEDomain, Field gel = GeometryElement(geometry) mesh = Mesh.from_data('aux', gel.coors, None, [gel.conn[None, :]], [[0]], [geometry]) domain = FEDomain('domain', mesh) omega = domain.create_region('Omega', 'all') surf = domain.create_region('Surf', 'vertices of surface', 'facet') field = Field.from_args('f', nm.float64, shape=1, region=omega, approx_order=1) field.setup_surface_data(surf) integral = Integral('aux', order=order) field.create_bqp('Surf', integral) sd = field.surface_data['Surf'] qp = field.qp_coors[(integral.order, sd.bkey)] output('geometry:', geometry, 'order:', order, 'num. points:', qp.vals.shape[1], 'true_order:', integral.qps[gel.surface_facet_name].order) output('min. weight:', qp.weights.min()) output('max. weight:', qp.weights.max()) return (gel, qp.vals.reshape((-1, mesh.dim)), nm.tile(qp.weights, qp.vals.shape[0]))
def test_read_meshes(self): """Try to read all listed meshes.""" from sfepy.discrete.fem import Mesh conf_dir = op.dirname(__file__) meshes = {} for ii, filename in enumerate(filename_meshes): self.report("%d. mesh: %s" % (ii + 1, filename)) mesh = Mesh.from_file(filename, prefix_dir=conf_dir) assert_(mesh.dim == (mesh.coors.shape[1])) assert_(mesh.n_nod == (mesh.coors.shape[0])) assert_(mesh.n_nod == (mesh.ngroups.shape[0])) assert_(mesh.n_el == sum(mesh.n_els)) for ig, conn in enumerate(mesh.conns): assert_(conn.shape[0] == len(mesh.mat_ids[ig])) assert_(conn.shape[0] == mesh.n_els[ig]) assert_(conn.shape[1] == mesh.n_e_ps[ig]) self.report("read ok") meshes[filename] = mesh self.meshes = meshes return True
def main(): parser = ArgumentParser(description=__doc__, formatter_class=RawDescriptionHelpFormatter) parser.add_argument('mesh_dir') options = parser.parse_args() mesh_dir = options.mesh_dir mesh_files = [] for (dirpath, dirnames, filenames) in os.walk(mesh_dir): for ii in filenames: _, ext = os.path.splitext(ii) if ext.lower() in ['.mesh', '.vtk']: mesh_files.append(dirpath + os.path.sep + ii) for ii in mesh_files: base, ext = os.path.splitext(ii) fname_out = base + '.png' if ext == '.mesh': fname_in = 'aux.vtk' mesh = Mesh.from_file(ii) mesh.write(fname_in, io='auto') else: fname_in = ii print(('writing %s...' % fname_out)) gen_shot(fname_in, fname_out)
def main(): parser = ArgumentParser(description=__doc__, formatter_class=RawDescriptionHelpFormatter) parser.add_argument('mesh_dir') options = parser.parse_args() mesh_dir = options.mesh_dir mesh_files = [] for (dirpath, dirnames, filenames) in os.walk(mesh_dir): for ii in filenames: _, ext = os.path.splitext(ii) if ext.lower() in ['.mesh', '.vtk']: mesh_files.append(dirpath + os.path.sep + ii) for ii in mesh_files: base, ext = os.path.splitext(ii) fname_out = base + '.png' if ext == '.mesh': fname_in = 'aux.vtk' mesh = Mesh.from_file(ii) mesh.write(fname_in, io='auto') else: fname_in = ii print(('writing %s...' % fname_out)) gen_shot(fname_in, fname_out)
def main(): parser = ArgumentParser(description=__doc__) parser.add_argument('--version', action='version', version='%(prog)s') parser.add_argument('filename') options = parser.parse_args() filename = options.filename mesh = Mesh.from_file(filename) output('Mesh:') output(' dimension: %d, vertices: %d, elements: %d' % (mesh.dim, mesh.n_nod, mesh.n_el)) domain = FEDomain('domain', mesh) output(domain.cmesh) domain.cmesh.cprint(1) dim = domain.cmesh.dim entities_opts = [ {'color' : 'k', 'label_global' : 12, 'label_local' : 8}, {'color' : 'b', 'label_global' : 12, 'label_local' : 8}, {'color' : 'g', 'label_global' : 12, 'label_local' : 8}, {'color' : 'r', 'label_global' : 12}, ] if dim == 2: entities_opts.pop(2) pc.plot_cmesh(None, domain.cmesh, wireframe_opts = {'color' : 'k'}, entities_opts=entities_opts) plt.show()
def test_refine_3_8(self): mesh = Mesh('3_8', data_dir + '/meshes/elements/3_8_1.mesh') domain = refine(FEDomain('domain', mesh), self.options.out_dir, 1) ok = compare_mesh('3_8', domain.mesh.coors, domain.mesh.conns[0]) return ok
def main(): parser = OptionParser(usage=usage) (options, args) = parser.parse_args() if len(args) != 1: parser.print_help() sys.exit(1) mesh_dir = args[0] mesh_files = [] for (dirpath, dirnames, filenames) in os.walk(mesh_dir): for ii in filenames: _, ext = os.path.splitext(ii) if ext.lower() in ['.mesh', '.vtk']: mesh_files.append(dirpath + os.path.sep + ii) for ii in mesh_files: base, ext = os.path.splitext(ii) fname_out = base + '.png' if ext == '.mesh': fname_in = 'aux.vtk' mesh = Mesh.from_file(ii) mesh.write(fname_in, io='auto') else: fname_in = ii print('writing %s...' % fname_out) gen_shot(fname_in, fname_out)
def save_basis(nurbs, pars): """ Save a NURBS object basis on a FE mesh corresponding to the given parametrization in VTK files. Parameters ---------- nurbs : igakit.nurbs.NURBS instance The NURBS object. pars : sequence of array, optional The values of parameters in each parametric dimension. """ coors, conn, desc = create_linear_fe_mesh(nurbs, pars) mat_id = nm.zeros(conn.shape[0], dtype=nm.int32) mesh = Mesh.from_data('nurbs', coors, None, [conn], [mat_id], [desc]) n_dof = nurbs.weights.ravel().shape[0] variable = nm.zeros(n_dof, dtype=nm.float64) field = variable.reshape(nurbs.weights.shape) for ic in xrange(n_dof): variable[ic - 1] = 0.0 variable[ic] = 1.0 vals = nurbs.evaluate(field, *pars).reshape((-1)) out = {} out['bf'] = Struct(name='output_data', mode='vertex', data=vals[:, None]) mesh.write('iga_basis_%03d.vtk' % ic, io='auto', out=out)
def test_read_meshes(self): """Try to read all listed meshes.""" from sfepy.discrete.fem import Mesh ok = True conf_dir = op.dirname(__file__) self.meshes = {} for ii, filename in enumerate(filename_meshes): self.report('%d. mesh: %s' % (ii + 1, filename)) try: mesh = Mesh.from_file(filename, prefix_dir=conf_dir) except Exception as exc: self.report(exc) self.report('read failed!') ok = False continue try: assert_(mesh.dim == (mesh.coors.shape[1])) assert_(mesh.n_nod == (mesh.coors.shape[0])) assert_(mesh.n_nod == (mesh.cmesh.vertex_groups.shape[0])) assert_(mesh.n_el == mesh.cmesh.num[mesh.cmesh.tdim]) except ValueError as exc: self.report(exc) self.report('read assertion failed!') ok = False continue self.report('read ok') self.meshes[filename] = mesh return ok
def main(): parser = ArgumentParser(description=__doc__.rstrip(), formatter_class=RawDescriptionHelpFormatter) parser.add_argument('filename', help=helps['filename']) parser.add_argument('-d', '--detailed', action='store_true', dest='detailed', default=False, help=helps['detailed']) options = parser.parse_args() mesh = Mesh.from_file(options.filename) output(mesh.cmesh) output('element types:', mesh.descs) output('nodal BCs:', sorted(mesh.nodal_bcs.keys())) bbox = mesh.get_bounding_box() output('bounding box: %s' % ', '.join('%s: [%s, %s]' % (name, bbox[0, ii], bbox[1, ii]) for ii, name in enumerate('xyz'[:mesh.dim]))) output('centre:', mesh.coors.mean(0)) if not options.detailed: return from sfepy.discrete.fem.geometry_element import create_geometry_elements gels = create_geometry_elements() mesh.cmesh.set_local_entities(gels) mesh.cmesh.setup_entities() for dim in range(1, mesh.cmesh.tdim + 1): volumes = mesh.cmesh.get_volumes(dim) output('volumes of %d %dD entities: min: %s mean: %s max: %s' % (mesh.cmesh.num[dim], dim, volumes.min(), volumes.mean(), volumes.max()))
def triangulate(mesh, verbose=False): """ Triangulate a 2D or 3D tensor product mesh: quadrilaterals->triangles, hexahedrons->tetrahedrons. Parameters ---------- mesh : Mesh The input mesh. Returns ------- mesh : Mesh The triangulated mesh. """ conns = None for k, new_desc in [('3_8', '3_4'), ('2_4', '2_3')]: if k in mesh.descs: conns = mesh.get_conn(k) break if conns is not None: nelo = conns.shape[0] output('initial mesh: %d elements' % nelo, verbose=verbose) new_conns = elems_q2t(conns) nn = new_conns.shape[0] // nelo new_cgroups = nm.repeat(mesh.cmesh.cell_groups, nn) output('new mesh: %d elements' % new_conns.shape[0], verbose=verbose) mesh = Mesh.from_data(mesh.name, mesh.coors, mesh.cmesh.vertex_groups, [new_conns], [new_cgroups], [new_desc]) return mesh
def refine_mesh(filename, level): """ Uniformly refine `level`-times a mesh given by `filename`. The refined mesh is saved to a file with name constructed from base name of `filename` and `level`-times appended `'_r'` suffix. Parameters ---------- filename : str The mesh file name. level : int The refinement level. """ import os from sfepy.base.base import output from sfepy.discrete.fem import Mesh, FEDomain if level > 0: mesh = Mesh.from_file(filename) domain = FEDomain(mesh.name, mesh) for ii in range(level): output('refine %d...' % ii) domain = domain.refine() output('... %d nodes %d elements' % (domain.shape.n_nod, domain.shape.n_el)) suffix = os.path.splitext(filename)[1] filename = domain.name + suffix domain.mesh.write(filename, io='auto') return filename
def test_spbox_2d(self): """ Check position of a given vertex in the deformed mesh. """ mesh = Mesh.from_file(data_dir + '/meshes/2d/square_tri1.mesh') spb = SplineBox([[-1, 1], [-1, 0.6]], mesh.coors, nsg=[2,1]) spb.move_control_point(1, [0.1, -0.2]) spb.move_control_point(2, [0.2, -0.3]) spb.move_control_point(3, [0.0, -0.1]) pt0 = mesh.coors[175,:].copy() mesh.cmesh.coors[:] = spb.evaluate() pt1 = mesh.coors[175,:] expected_distance = 0.165892726387 actual_distance = nm.linalg.norm(pt0 - pt1) ok = nm.fabs(actual_distance - expected_distance)\ / expected_distance < tolerance if not ok: self.report('expected distance:') self.report(expected_distance) self.report('actual distance:') self.report(actual_distance) return ok
def refine_2_3(mesh_in): """ Refines mesh out of triangles by cutting cutting each edge in half and making 4 new finer triangles out of one coarser one. """ cmesh = mesh_in.cmesh # Unique edge centres. e_centres = cmesh.get_centroids(cmesh.dim - 1) # New coordinates after the original ones. coors = nm.r_[mesh_in.coors, e_centres] o1 = mesh_in.n_nod cc = cmesh.get_conn(cmesh.dim, cmesh.dim - 1) conn = mesh_in.get_conn('2_3') n_el = conn.shape[0] e_nodes = cc.indices.reshape((n_el, 3)) + o1 c = nm.c_[conn, e_nodes].T new_conn = nm.vstack([ c[0], c[3], c[5], c[3], c[4], c[5], c[1], c[4], c[3], c[2], c[5], c[4] ]).T new_conn = new_conn.reshape((4 * n_el, 3)) new_mat_id = cmesh.cell_groups.repeat(4) mesh = Mesh.from_data(mesh_in.name + '_r', coors, None, [new_conn], [new_mat_id], mesh_in.descs) return mesh
def _get_bqp(geometry, order): from sfepy.discrete import Integral from sfepy.discrete.fem.geometry_element import GeometryElement from sfepy.discrete.fem import Mesh, FEDomain, Field gel = GeometryElement(geometry) mesh = Mesh.from_data('aux', gel.coors, None, [gel.conn[None, :]], [[0]], [geometry]) domain = FEDomain('domain', mesh) omega = domain.create_region('Omega', 'all') surf = domain.create_region('Surf', 'vertices of surface', 'facet') field = Field.from_args('f', nm.float64, shape=1, region=omega, approx_order=1) field.setup_surface_data(surf) integral = Integral('aux', order=order) field.create_bqp('Surf', integral) sd = field.surface_data['Surf'] qp = field.qp_coors[(integral.order, sd.bkey)] output('geometry:', geometry, 'order:', order, 'num. points:', qp.vals.shape[1], 'true_order:', integral.qps[gel.surface_facet_name].order) output('min. weight:', qp.weights.min()) output('max. weight:', qp.weights.max()) return (gel, qp.vals.reshape( (-1, mesh.dim)), nm.tile(qp.weights, qp.vals.shape[0]))
def from_conf(conf, options): import sfepy from sfepy.discrete.fem import Mesh, Domain, Field mesh = Mesh.from_file('meshes/2d/rectangle_tri.mesh', prefix_dir=sfepy.data_dir) domain = Domain('domain', mesh) dim = domain.shape.dim min_x, max_x = domain.get_mesh_bounding_box()[:,0] eps = 1e-8 * (max_x - min_x) omega = domain.create_region('Omega', 'all') gamma1 = domain.create_region('Gamma1', 'vertices in x < %.10f' % (min_x + eps), 'facet') gamma2 = domain.create_region('Gamma2', 'vertices in x > %.10f' % (max_x - eps), 'facet') field = Field.from_args('fu', nm.float64, 'vector', omega, approx_order=2) test = Test(conf=conf, options=options, dim=dim, omega=omega, gamma1=gamma1, gamma2=gamma2, field=field) return test
def prepare_variable(filename, n_components): from sfepy.discrete import FieldVariable from sfepy.discrete.fem import Mesh, FEDomain, Field mesh = Mesh.from_file(filename) bbox = mesh.get_bounding_box() dd = bbox[1, :] - bbox[0, :] data = (nm.sin(4.0 * nm.pi * mesh.coors[:, 0:1] / dd[0]) * nm.cos(4.0 * nm.pi * mesh.coors[:, 1:2] / dd[1])) domain = FEDomain('domain', mesh) omega = domain.create_region('Omega', 'all') field = Field.from_args('field', nm.float64, n_components, omega, approx_order=2) u = FieldVariable('u', 'parameter', field, primary_var_name='(set-to-None)') u.set_from_mesh_vertices(data * nm.arange(1, n_components + 1)[None, :]) return u
def refine_3_8(mesh_in, cmesh): """ Refines hexahedral mesh by cutting cutting each edge in half and making 8 new finer hexahedrons out of one coarser one. """ # Unique edge centres. e_centres = cmesh.get_centroids(cmesh.dim - 2) # Unique face centres. f_centres = cmesh.get_centroids(cmesh.dim - 1) # Unique element centres. coors = mesh_in.get_element_coors() centres = 0.125 * nm.sum(coors, axis=1) # New coordinates after the original ones. coors = nm.r_[mesh_in.coors, e_centres, f_centres, centres] o1 = mesh_in.n_nod o2 = o1 + e_centres.shape[0] o3 = o2 + f_centres.shape[0] ecc = cmesh.get_conn(cmesh.dim, cmesh.dim - 2) eoffs = ecc.offsets fcc = cmesh.get_conn(cmesh.dim, cmesh.dim - 1) foffs = fcc.offsets st = nm.vstack conns = [] mat_ids = [] for ig, conn in enumerate(mesh_in.conns): off0, off1 = mesh_in.el_offsets[ig : ig + 2] n_el = conn.shape[0] e_nodes = ecc.indices[eoffs[off0]:eoffs[off1]].reshape((n_el, 12)) + o1 f_nodes = fcc.indices[foffs[off0]:foffs[off1]].reshape((n_el, 6)) + o2 nodes = nm.arange(n_el) + off0 + o3 c = nm.c_[conn, e_nodes, f_nodes, nodes].T new_conn = st([c[0], c[8], c[20], c[11], c[16], c[22], c[26], c[21], c[1], c[9], c[20], c[8], c[17], c[24], c[26], c[22], c[2], c[10], c[20], c[9], c[18], c[25], c[26], c[24], c[3], c[11], c[20], c[10], c[19], c[21], c[26], c[25], c[4], c[15], c[23], c[12], c[16], c[21], c[26], c[22], c[5], c[12], c[23], c[13], c[17], c[22], c[26], c[24], c[6], c[13], c[23], c[14], c[18], c[24], c[26], c[25], c[7], c[14], c[23], c[15], c[19], c[25], c[26], c[21]]).T new_conn = new_conn.reshape((8 * n_el, 8)) conns.append(new_conn) new_mat_id = mesh_in.mat_ids[ig].repeat(8) mat_ids.append(new_mat_id) mesh = Mesh.from_data(mesh_in.name + '_r', coors, None, conns, mat_ids, mesh_in.descs ) return mesh
def from_conf(conf, options): from sfepy.discrete import Integral from sfepy.discrete.fem import Mesh, FEDomain domains = [] for filename in filename_meshes: mesh = Mesh.from_file(filename) domain = FEDomain('domain_%s' % mesh.name.replace(data_dir, ''), mesh) domain.create_region('Omega', 'all') domain.create_region('Gamma', 'vertices of surface', 'facet') domains.append(domain) integral = Integral('i', order=3) qp_coors, qp_weights = integral.get_qp('3_8') custom_integral = Integral('i', coors=qp_coors, weights=qp_weights, order='custom') test = Test(domains=domains, integral=integral, custom_integral=custom_integral, conf=conf, options=options) return test
def test_entity_volumes(self): import sfepy from sfepy.discrete.fem import Mesh, FEDomain from sfepy.discrete.common import Field from sfepy.discrete import Integral mesh = Mesh.from_file('meshes/3d/special/cross3d.mesh', prefix_dir=sfepy.data_dir) domain = FEDomain('domain', mesh) omega = domain.create_region('Omega', 'all') gamma = domain.create_region('Gamma', 'vertices of surface', 'facet') top = domain.create_region('Top', 'cell 2') vfield = Field.from_args('v', nm.float64, 'scalar', omega, approx_order=1) sfield = Field.from_args('s', nm.float64, 'scalar', gamma, approx_order=1) integral = Integral('i', order=3) vgeo, _ = vfield.get_mapping(omega, integral, 'volume') domain.create_surface_group(gamma) sgeo, _ = sfield.get_mapping(gamma, integral, 'surface') evols = mesh.cmesh.get_volumes(1) fvols = mesh.cmesh.get_volumes(2) # Approximate for non-planar faces. cvols = mesh.cmesh.get_volumes(3) ok = True _ok = abs(cvols.sum() - vgeo.volume.sum()) < 1e-15 self.report('total cell volume: %s (ok: %s)' % (cvols.sum(), _ok)) ok = _ok and ok top_evols = nm.array([ 1. , 1. , 1. , 1. , 0.7211102550927979, 0.7211102550927979, 0.7211102550927979, 0.7211102550927979, 1.16619037896906 , 1.16619037896906 , 1.16619037896906 , 1.16619037896906 ]) _ok = nm.allclose(top_evols, evols[top.edges], rtol=0.0, atol=1e-15) self.report('total top cell edge length: %s (ok: %s)' % (evols[top.edges].sum(), _ok)) ok = _ok and ok i1 = [5, 6, 8, 9] i2 = nm.setdiff1d(nm.arange(len(gamma.faces)), i1) aux = fvols[gamma.faces] - sgeo.volume.ravel() _ok = nm.allclose(aux[i1], 0.10560208437556773, rtol=0.0, atol=1e-15) ok = _ok and ok self.report('non-planar faces diff: %s (ok: %s)' % (aux[i1], _ok)) _ok = (nm.abs(aux[i2]) < 1e-15).all() self.report('max. planar faces diff: %s (ok: %s)' % (nm.abs(aux[i2]).max(), _ok)) ok = _ok and ok return ok
def refine_3_4(mesh_in, cmesh): """ Refines tetrahedra by cutting each edge in half and making 8 new finer tetrahedra out of one coarser one. Old nodal coordinates come first in `coors`, then the new ones. The new tetrahedra are similar to the old one, no degeneration is supposed to occur as at most 3 congruence classes of tetrahedra appear, even when re-applied iteratively (provided that `conns` are not modified between two applications - ordering of vertices in tetrahedra matters not only for positivity of volumes). References: - Juergen Bey: Simplicial grid refinement: on Freudenthal s algorithm and the optimal number of congruence classes, Numer.Math. 85 (2000), no. 1, 1--29, or - Juergen Bey: Tetrahedral grid refinement, Computing 55 (1995), no. 4, 355--378, or http://citeseer.ist.psu.edu/bey95tetrahedral.html """ # Unique edge centres. e_centres = cmesh.get_centroids(cmesh.dim - 2) # New coordinates after the original ones. coors = nm.r_[mesh_in.coors, e_centres] o1 = mesh_in.n_nod cc = cmesh.get_conn(cmesh.dim, cmesh.dim - 2) offs = cc.offsets conns = [] mat_ids = [] for ig, conn in enumerate(mesh_in.conns): off0, off1 = mesh_in.el_offsets[ig : ig + 2] n_el = conn.shape[0] e_nodes = cc.indices[offs[off0]:offs[off1]].reshape((n_el, 6)) + o1 c = nm.c_[conn, e_nodes].T new_conn = nm.vstack([c[0], c[4], c[6], c[7], c[4], c[1], c[5], c[8], c[6], c[5], c[2], c[9], c[7], c[8], c[9], c[3], c[4], c[6], c[7], c[8], c[4], c[6], c[8], c[5], c[6], c[7], c[8], c[9], c[6], c[5], c[9], c[8]]).T new_conn = new_conn.reshape((8 * n_el, 4)) conns.append(new_conn) new_mat_id = mesh_in.mat_ids[ig].repeat(8) mat_ids.append(new_mat_id) mesh = Mesh.from_data(mesh_in.name + '_r', coors, None, conns, mat_ids, mesh_in.descs ) return mesh
def solveLaplaceEquationTetrahedral(mesh, meshVTK, boundaryPoints, boundaryConditions): """ mesh: path to a 3D mesh / sfepy mesh """ if isinstance(mesh, str): mesh = Mesh.from_file(mesh) #Set domains domain = FEDomain('domain', mesh) omega = domain.create_region('Omega', 'all') boundary = domain.create_region( 'gamma', 'vertex %s' % ','.join(map(str, range(meshVTK.GetNumberOfPoints()))), 'facet') #set fields field = Field.from_args('fu', np.float64, 1, omega, approx_order=1) u = FieldVariable('u', 'unknown', field) v = FieldVariable('v', 'test', field, primary_var_name='u') m = Material('m', val=[1.]) #Define element integrals integral = Integral('i', order=3) #Equations defining t1 = Term.new('dw_laplace( v, u )', integral, omega, v=v, u=u) eq = Equation('balance', t1) eqs = Equations([eq]) heatBoundary = boundaryConditions points = boundaryPoints #Boundary conditions c = ClosestPointStupid(points, heatBoundary, meshVTK) def u_fun(ts, coors, bc=None, problem=None, c=c): c.distances = [] v = np.zeros(len(coors)) for i, p in enumerate(coors): v[i] = c.interpolate(p) #c.findClosestPoint(p) return v bc_fun = Function('u_fun', u_fun) fix1 = EssentialBC('fix_u', boundary, {'u.all': bc_fun}) #Solve problem ls = ScipyDirect({}) nls = Newton({}, lin_solver=ls) pb = Problem('heat', equations=eqs) pb.set_bcs(ebcs=Conditions([fix1])) pb.set_solver(nls) state = pb.solve(verbose=False, save_results=False) u = state.get_parts()['u'] return u
def test_refine_hexa(self): mesh = Mesh('mesh_hexa', data_dir + '/meshes/various_formats/abaqus_hex.inp') domain = FEDomain('domain', mesh) refine(domain, self.options.out_dir) return True
def test_refine_3_4(self): mesh = Mesh.from_file(data_dir + '/meshes/elements/3_4_1.mesh') domain = refine(FEDomain('domain', mesh), self.options.out_dir, 1) ok = compare_mesh('3_4', domain.mesh.coors, domain.mesh.get_conn('3_4')) return ok
def test_refine_hexa(self): filename = data_dir + '/meshes/various_formats/abaqus_hex.inp' mesh = Mesh.from_file(filename) domain = FEDomain('domain', mesh) refine(domain, self.options.out_dir) return True
def test_refine_hexa(self): filename = data_dir + '/meshes/various_formats/abaqus_hex.inp' mesh = Mesh.from_file(filename) domain = FEDomain('domain', mesh) refine(domain, self.options.out_dir) return True
def __init__(self, name, nurbs, bmesh, regions=None, **kwargs): """ Create an IGA domain. Parameters ---------- name : str The domain name. """ Domain.__init__(self, name, nurbs=nurbs, bmesh=bmesh, regions=regions, **kwargs) from sfepy.discrete.fem.geometry_element import create_geometry_elements from sfepy.discrete.fem import Mesh from sfepy.discrete.fem.extmods.cmesh import CMesh from sfepy.discrete.fem.utils import prepare_remap ac = nm.ascontiguousarray self.nurbs.cs = [ac(nm.array(cc, dtype=nm.float64)[:, None, ...]) for cc in self.nurbs.cs] self.nurbs.degrees = self.nurbs.degrees.astype(nm.int32) self.facets = iga.get_bezier_element_entities(nurbs.degrees) tconn = iga.get_bezier_topology(bmesh.conn, nurbs.degrees) itc = nm.unique(tconn) remap = prepare_remap(itc, bmesh.conn.max() + 1) ltcoors = bmesh.cps[itc] ltconn = remap[tconn] n_nod, dim = ltcoors.shape n_el = ltconn.shape[0] self.shape = Struct(n_nod=n_nod, dim=dim, tdim=0, n_el=n_el, n_gr=1) desc = '%d_%d' % (dim, 2**dim) mat_id = nm.zeros(ltconn.shape[0], dtype=nm.int32) self.mesh = Mesh.from_data(self.name + '_topo', ltcoors, None, [ltconn], [mat_id], [desc]) self.cmesh = CMesh.from_mesh(self.mesh) gels = create_geometry_elements() self.cmesh.set_local_entities(gels) self.cmesh.setup_entities() self.shape.tdim = self.cmesh.tdim self.gel = gels[desc] if regions is not None: self.vertex_set_bcs = {} for key, val in self.regions.iteritems(): self.vertex_set_bcs[key] = remap[val] self.cell_offsets = {0 : 0} self.reset_regions()
def test_invariance_qp(self): from sfepy import data_dir from sfepy.discrete import Variables, Integral from sfepy.discrete.fem import Mesh, Domain, Field from sfepy.terms import Term from sfepy.discrete.fem.mappings import get_physical_qps mesh = Mesh('source mesh', data_dir + '/meshes/3d/block.mesh') bbox = mesh.get_bounding_box() dd = bbox[1,:] - bbox[0,:] data = nm.sin(4.0 * nm.pi * mesh.coors[:,0:1] / dd[0]) \ * nm.cos(4.0 * nm.pi * mesh.coors[:,1:2] / dd[1]) variables = { 'u' : ('unknown field', 'scalar_tp', 0), 'v' : ('test field', 'scalar_tp', 'u'), } domain = Domain('domain', mesh) omega = domain.create_region('Omega', 'all') field = Field.from_args('scalar_tp', nm.float64, 1, omega, approx_order=1) ff = {field.name : field} vv = Variables.from_conf(transform_variables(variables), ff) u = vv['u'] u.set_from_mesh_vertices(data) integral = Integral('i', order=2) term = Term.new('ev_volume_integrate(u)', integral, omega, u=u) term.setup() val1, _ = term.evaluate(mode='qp') val1 = val1.ravel() qps = get_physical_qps(omega, integral) coors = qps.get_merged_values() val2 = u.evaluate_at(coors).ravel() self.report('max. difference:', nm.abs(val1 - val2).max()) ok = nm.allclose(val1, val2, rtol=0.0, atol=1e-12) self.report('invariance in qp: %s' % ok) return ok
def refine_3_4(mesh_in, cmesh): """ Refines tetrahedra by cutting each edge in half and making 8 new finer tetrahedra out of one coarser one. Old nodal coordinates come first in `coors`, then the new ones. The new tetrahedra are similar to the old one, no degeneration is supposed to occur as at most 3 congruence classes of tetrahedra appear, even when re-applied iteratively (provided that `conns` are not modified between two applications - ordering of vertices in tetrahedra matters not only for positivity of volumes). References: - Juergen Bey: Simplicial grid refinement: on Freudenthal s algorithm and the optimal number of congruence classes, Numer.Math. 85 (2000), no. 1, 1--29, or - Juergen Bey: Tetrahedral grid refinement, Computing 55 (1995), no. 4, 355--378, or http://citeseer.ist.psu.edu/bey95tetrahedral.html """ # Unique edge centres. e_centres = cmesh.get_centroids(cmesh.dim - 2) # New coordinates after the original ones. coors = nm.r_[mesh_in.coors, e_centres] o1 = mesh_in.n_nod cc = cmesh.get_conn(cmesh.dim, cmesh.dim - 2) offs = cc.offsets conns = [] mat_ids = [] for ig, conn in enumerate(mesh_in.conns): off0, off1 = mesh_in.el_offsets[ig:ig + 2] n_el = conn.shape[0] e_nodes = cc.indices[offs[off0]:offs[off1]].reshape((n_el, 6)) + o1 c = nm.c_[conn, e_nodes].T new_conn = nm.vstack([ c[0], c[4], c[6], c[7], c[4], c[1], c[5], c[8], c[6], c[5], c[2], c[9], c[7], c[8], c[9], c[3], c[4], c[6], c[7], c[8], c[4], c[6], c[8], c[5], c[6], c[7], c[8], c[9], c[6], c[5], c[9], c[8] ]).T new_conn = new_conn.reshape((8 * n_el, 4)) conns.append(new_conn) new_mat_id = mesh_in.mat_ids[ig].repeat(8) mat_ids.append(new_mat_id) mesh = Mesh.from_data(mesh_in.name + '_r', coors, None, conns, mat_ids, mesh_in.descs) return mesh
def from_conf( conf, options ): from sfepy import data_dir from sfepy.discrete.fem import Mesh, Domain from sfepy.discrete import Functions mesh = Mesh('test mesh', data_dir + '/meshes/various_formats/abaqus_tet.inp') mesh.nodal_bcs['set0'] = [0, 7] domain = Domain('test domain', mesh) conf_functions = { 'get_vertices' : (get_vertices,), 'get_cells' : (get_cells,), } functions = Functions.from_conf(transform_functions(conf_functions)) test = Test(conf=conf, options=options, domain=domain, functions=functions) return test
def main(): from sfepy import data_dir parser = OptionParser(usage=usage, version="%prog") parser.add_option("-s", "--show", action="store_true", dest="show", default=False, help=help["show"]) options, args = parser.parse_args() mesh = Mesh.from_file(data_dir + "/meshes/2d/rectangle_tri.mesh") domain = Domain("domain", mesh) min_x, max_x = domain.get_mesh_bounding_box()[:, 0] eps = 1e-8 * (max_x - min_x) omega = domain.create_region("Omega", "all") gamma1 = domain.create_region("Gamma1", "vertices in x < %.10f" % (min_x + eps), "facet") gamma2 = domain.create_region("Gamma2", "vertices in x > %.10f" % (max_x - eps), "facet") field = Field.from_args("fu", nm.float64, "vector", omega, approx_order=2) u = FieldVariable("u", "unknown", field) v = FieldVariable("v", "test", field, primary_var_name="u") m = Material("m", lam=1.0, mu=1.0) f = Material("f", val=[[0.02], [0.01]]) integral = Integral("i", order=3) t1 = Term.new("dw_lin_elastic_iso(m.lam, m.mu, v, u)", integral, omega, m=m, v=v, u=u) t2 = Term.new("dw_volume_lvf(f.val, v)", integral, omega, f=f, v=v) eq = Equation("balance", t1 + t2) eqs = Equations([eq]) fix_u = EssentialBC("fix_u", gamma1, {"u.all": 0.0}) bc_fun = Function("shift_u_fun", shift_u_fun, extra_args={"shift": 0.01}) shift_u = EssentialBC("shift_u", gamma2, {"u.0": bc_fun}) ls = ScipyDirect({}) nls_status = IndexedStruct() nls = Newton({}, lin_solver=ls, status=nls_status) pb = Problem("elasticity", equations=eqs, nls=nls, ls=ls) pb.save_regions_as_groups("regions") pb.time_update(ebcs=Conditions([fix_u, shift_u])) vec = pb.solve() print nls_status pb.save_state("linear_elasticity.vtk", vec) if options.show: view = Viewer("linear_elasticity.vtk") view(vector_mode="warp_norm", rel_scaling=2, is_scalar_bar=True, is_wireframe=True)
def refine_3_8(mesh_in): """ Refines hexahedral mesh by cutting cutting each edge in half and making 8 new finer hexahedrons out of one coarser one. """ cmesh = mesh_in.cmesh # Unique edge centres. e_centres = cmesh.get_centroids(cmesh.dim - 2) # Unique face centres. f_centres = cmesh.get_centroids(cmesh.dim - 1) # Unique element centres. centres = cmesh.get_centroids(cmesh.dim) # New coordinates after the original ones. coors = nm.r_[mesh_in.coors, e_centres, f_centres, centres] o1 = mesh_in.n_nod o2 = o1 + e_centres.shape[0] o3 = o2 + f_centres.shape[0] ecc = cmesh.get_conn(cmesh.dim, cmesh.dim - 2) fcc = cmesh.get_conn(cmesh.dim, cmesh.dim - 1) conn = mesh_in.get_conn('3_8') n_el = conn.shape[0] st = nm.vstack e_nodes = ecc.indices.reshape((n_el, 12)) + o1 f_nodes = fcc.indices.reshape((n_el, 6)) + o2 nodes = nm.arange(n_el) + o3 c = nm.c_[conn, e_nodes, f_nodes, nodes].T new_conn = st([ c[0], c[8], c[20], c[11], c[16], c[22], c[26], c[21], c[1], c[9], c[20], c[8], c[17], c[24], c[26], c[22], c[2], c[10], c[20], c[9], c[18], c[25], c[26], c[24], c[3], c[11], c[20], c[10], c[19], c[21], c[26], c[25], c[4], c[15], c[23], c[12], c[16], c[21], c[26], c[22], c[5], c[12], c[23], c[13], c[17], c[22], c[26], c[24], c[6], c[13], c[23], c[14], c[18], c[24], c[26], c[25], c[7], c[14], c[23], c[15], c[19], c[25], c[26], c[21] ]).T new_conn = new_conn.reshape((8 * n_el, 8)) new_mat_id = cmesh.cell_groups.repeat(8) mesh = Mesh.from_data(mesh_in.name + '_r', coors, None, [new_conn], [new_mat_id], mesh_in.descs) return mesh