def test_write_read_meshes(self): """ Try to write and then read all supported formats. """ from sfepy.fem import Mesh from sfepy.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 test_write_read_meshes(self): """ Try to write and then read all supported formats. """ from sfepy.fem import Mesh from sfepy.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 from_conf(conf, options): import sfepy from sfepy.fem import Mesh, Domain, H1NodalVolumeField 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 = H1NodalVolumeField('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 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 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.fem import Mesh, Domain if level > 0: mesh = Mesh.from_file(filename) domain = Domain(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_read_meshes(self): """Try to read all listed meshes.""" from sfepy.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 test_read_meshes( self ): """Try to read all listed meshes.""" from sfepy.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 from_conf(conf, options): import sfepy from sfepy.fem import Mesh, Domain, H1NodalVolumeField 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 = H1NodalVolumeField('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 test_rcm(self): from sfepy import data_dir from sfepy.linalg import rcm, permute_in_place, save_sparse_txt from sfepy.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 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.fem import Mesh, Domain if level > 0: mesh = Mesh.from_file(filename) domain = Domain(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 from_conf(conf, options): mesh = Mesh.from_file("meshes/2d/square_unit_tri.mesh", prefix_dir=sfepy.data_dir) domain = Domain("domain", mesh) omega = domain.create_region("Omega", "all") field = H1NodalVolumeField("linear", nm.float64, "scalar", omega, approx_order=1) test = Test(conf=conf, options=options, omega=omega, field=field) 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", "nodes in x < %.10f" % (min_x + eps)) gamma2 = domain.create_region("Gamma2", "nodes in x > %.10f" % (max_x - eps)) field = Field("fu", nm.float64, "vector", omega, space="H1", poly_space_base="lagrange", approx_order=2) u = FieldVariable("u", "unknown", field, mesh.dim) v = FieldVariable("v", "test", field, mesh.dim, 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 = ProblemDefinition("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 from_conf(conf, options): mesh = Mesh.from_file('meshes/2d/square_unit_tri.mesh', prefix_dir=sfepy.data_dir) domain = Domain('domain', mesh) omega = domain.create_region('Omega', 'all') field = Field('linear', nm.float64, 'scalar', omega, space='H1', poly_space_base='lagrange', approx_order=1) test = Test(conf=conf, options=options, omega=omega, field=field) return test
def from_conf(conf, options): mesh = Mesh.from_file('meshes/2d/square_unit_tri.mesh', prefix_dir=sfepy.data_dir) domain = Domain('domain', mesh) omega = domain.create_region('Omega', 'all') field = H1NodalVolumeField('linear', nm.float64, 'scalar', omega, approx_order=1) test = Test(conf=conf, options=options, omega=omega, field=field) return test
def main(): parser = OptionParser(usage=usage) parser.add_option("-s", "--scale", metavar='scale', action="store", dest="scale", default=None, help=help['scale']) parser.add_option("-f", "--format", metavar='format', action="store", type='string', dest="format", default=None, help=help['format']) parser.add_option("-l", "--list", action="store_true", dest="list", help=help['list']) (options, args) = parser.parse_args() if options.list: output_writable_meshes() sys.exit(0) if len(args) != 2: parser.print_help() sys.exit(1) scale = options.scale if scale is not None: try: try: scale = float(scale) except ValueError: scale = [float(ii) for ii in scale.split(',')] scale = nm.array(scale, dtype=nm.float64, ndmin=1) except: output('bad scale! (%s)' % scale) parser.print_help() sys.exit(1) filename_in, filename_out = args mesh = Mesh.from_file(filename_in) if scale is not None: if len(scale) == 1: tr = nm.eye(mesh.dim, dtype=nm.float64) * scale elif len(scale) == mesh.dim: tr = nm.diag(scale) else: raise ValueError('bad scale! (%s)' % scale) mesh.transform_coors(tr) io = MeshIO.for_format(filename_out, format=options.format, writable=True) output('writing %s...' % filename_out) mesh.write(filename_out, io=io) output('...done')
def test_normals(self): """ Check orientations of surface normals on the reference elements. """ import sfepy from sfepy.fem import Mesh, Domain, Integral from sfepy.fem.poly_spaces import PolySpace from sfepy.fem.mappings import SurfaceMapping from sfepy.linalg import normalize_vectors ok = True for geom in ['2_3', '2_4', '3_4', '3_8']: mesh = Mesh.from_file('meshes/elements/%s_1.mesh' % geom, prefix_dir=sfepy.data_dir) domain = Domain('domain', mesh) surface = domain.create_region('Surface', 'vertices of surface', 'facet') domain.create_surface_group(surface) sd = domain.surface_groups[0][surface.name] coors = domain.get_mesh_coors() gel = domain.geom_els[geom].surface_facet ps = PolySpace.any_from_args('aux', gel, 1) mapping = SurfaceMapping(coors, sd.get_connectivity(), ps) integral = Integral('i', order=1) vals, weights = integral.get_qp(gel.name) # Evaluate just in the first quadrature point... geo = mapping.get_mapping(vals[:1], weights[:1]) expected = expected_normals[geom].copy() normalize_vectors(expected) _ok = nm.allclose(expected, geo.normal[:, 0, :, 0], rtol=0.0, atol=1e-14) self.report('%s: %s' % (geom, _ok)) if not _ok: self.report('expected:') self.report(expected) self.report('actual:') self.report(geo.normal[:, 0, :, 0]) ok = ok and _ok return ok
def test_read_meshes( self ): """Try to read all listed meshes.""" from sfepy.fem import Mesh meshes = {} for ii, filename in enumerate( filename_meshes ): self.report( '%d. mesh: %s' % (ii + 1, filename) ) mesh = Mesh.from_file( filename ) self.report( 'read ok' ) meshes[filename] = mesh self.meshes = meshes return True
def test_normals(self): """ Check orientations of surface normals on the reference elements. """ import sfepy from sfepy.fem import Mesh, Domain, Integral from sfepy.fem.poly_spaces import PolySpace from sfepy.fem.mappings import SurfaceMapping from sfepy.linalg import normalize_vectors ok = True for geom in ['2_3', '2_4', '3_4', '3_8']: mesh = Mesh.from_file('meshes/elements/%s_1.mesh' % geom, prefix_dir=sfepy.data_dir) domain = Domain('domain', mesh) surface = domain.create_region('Surface', 'nodes of surface') domain.create_surface_group(surface) sd = domain.surface_groups[0][surface.name] coors = domain.get_mesh_coors() gel = domain.geom_els[geom].surface_facet ps = PolySpace.any_from_args('aux', gel, 1) mapping = SurfaceMapping(coors, sd.get_connectivity(), ps) integral = Integral('i', order=1) vals, weights = integral.get_qp(gel.name) # Evaluate just in the first quadrature point... geo = mapping.get_mapping(vals[:1], weights[:1]) expected = expected_normals[geom].copy() normalize_vectors(expected) _ok = nm.allclose(expected, geo.normal[:, 0, :, 0], rtol=0.0, atol=1e-14) self.report('%s: %s' % (geom, _ok)) if not _ok: self.report('expected:') self.report(expected) self.report('actual:') self.report(geo.normal[:, 0, :, 0]) ok = ok and _ok return ok
def mesh(): if len(sys.argv) == 3: geom_filename = sys.argv[1] vtk_filename = sys.argv[2] else: print "Usage: %s <gmsh_filename> <mesh_filename>" % sys.argv[0] return os.system("gmsh -0 %s -o tmp/x.geo" % geom_filename) g = geom.read_gmsh("tmp/x.geo") g.printinfo() geom.write_tetgen(g, "tmp/t.poly") geom.runtetgen("tmp/t.poly", a=0.03, Q=1.0, quadratic=False, tetgenpath=tetgen_path) m = Mesh.from_file("tmp/t.1.node") m.write(vtk_filename, io="auto")
def test_projection_tri_quad(self): from sfepy.fem.projections import make_l2_projection source = FieldVariable('us', 'unknown', self.field, 1) coors = self.field.get_coor() vals = nm.sin(2.0 * nm.pi * coors[:, 0] * coors[:, 1]) source.data_from_any(vals) name = op.join(self.options.out_dir, 'test_projection_tri_quad_source.vtk') source.save_as_mesh(name) mesh = Mesh.from_file('meshes/2d/square_quad.mesh', prefix_dir=sfepy.data_dir) domain = Domain('domain', mesh) omega = domain.create_region('Omega', 'all') field = H1NodalVolumeField('bilinear', nm.float64, 'scalar', omega, approx_order=1) target = FieldVariable('ut', 'unknown', field, 1) make_l2_projection(target, source) name = op.join(self.options.out_dir, 'test_projection_tri_quad_target.vtk') target.save_as_mesh(name) bbox = self.field.domain.get_mesh_bounding_box() x = nm.linspace(bbox[0, 0] + 0.001, bbox[1, 0] - 0.001, 20) y = nm.linspace(bbox[0, 1] + 0.001, bbox[1, 1] - 0.001, 20) xx, yy = nm.meshgrid(x, y) test_coors = nm.c_[xx.ravel(), yy.ravel()].copy() vec1 = source.evaluate_at(test_coors) vec2 = target.evaluate_at(test_coors) ok = (nm.abs(vec1 - vec2) < 0.01).all() return ok
def from_conf(conf, options): from sfepy.fem import Mesh, Domain, Integral domains = [] for filename in filename_meshes: mesh = Mesh.from_file(filename) domain = Domain('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) test = Test(domains=domains, integral=integral, conf=conf, options=options) return test
def test_projection_tri_quad(self): from sfepy.fem.projections import make_l2_projection source = FieldVariable('us', 'unknown', self.field, 1) coors = self.field.get_coor() vals = nm.sin(2.0 * nm.pi * coors[:,0] * coors[:,1]) source.data_from_any(vals) name = op.join(self.options.out_dir, 'test_projection_tri_quad_source.vtk') source.save_as_mesh(name) mesh = Mesh.from_file('meshes/2d/square_quad.mesh', prefix_dir=sfepy.data_dir) domain = Domain('domain', mesh) omega = domain.create_region('Omega', 'all') field = Field('bilinear', nm.float64, 'scalar', omega, space='H1', poly_space_base='lagrange', approx_order=1) target = FieldVariable('ut', 'unknown', field, 1) make_l2_projection(target, source) name = op.join(self.options.out_dir, 'test_projection_tri_quad_target.vtk') target.save_as_mesh(name) bbox = self.field.domain.get_mesh_bounding_box() x = nm.linspace(bbox[0, 0] + 0.001, bbox[1, 0] - 0.001, 20) y = nm.linspace(bbox[0, 1] + 0.001, bbox[1, 1] - 0.001, 20) xx, yy = nm.meshgrid(x, y) test_coors = nm.c_[xx.ravel(), yy.ravel()].copy() vec1 = source.evaluate_at(test_coors) vec2 = target.evaluate_at(test_coors) ok = (nm.abs(vec1 - vec2) < 0.01).all() return ok
def mesh_hook(mesh, mode): """ Load and refine a mesh here. """ if mode == 'read': mesh = Mesh.from_file(base_mesh) domain = Domain(mesh.name, mesh) for ii in range(3): output('refine %d...' % ii) domain = domain.refine() output('... %d nodes %d elements' % (domain.shape.n_nod, domain.shape.n_el)) domain.mesh.name = '2_4_2_refined' return domain.mesh elif mode == 'write': pass
def from_conf(conf, options): from sfepy.fem import Mesh, Domain, Integral domains = [] for filename in filename_meshes: mesh = Mesh.from_file(filename) domain = Domain('domain_%s' % mesh.name.replace(data_dir, ''), mesh) domain.create_region('Omega', 'all') domain.create_region('Gamma', 'nodes of surface') domains.append(domain) integrals = {'Omega' : Integral('iv', kind='v', order=3), 'Gamma' : Integral('is', kind='s', order=3)} test = Test(domains=domains, integrals=integrals, conf=conf, options=options) return test
def mesh_hook(mesh, mode): """ Load and refine a mesh here. """ if mode == 'read': mesh = Mesh.from_file(base_mesh) domain = Domain(mesh.name, mesh) for ii in range(3): output('refine %d...' % ii) domain = domain.refine() output('... %d nodes %d elements' % (domain.shape.n_nod, domain.shape.n_el)) domain.mesh.name = '2_4_2_refined' return domain.mesh elif mode == 'write': pass
def mesh(): if len( sys.argv ) == 3: geom_filename = sys.argv[1] vtk_filename = sys.argv[2] if len( sys.argv ) == 2: geom_filename = sys.argv[1] vtk_filename = "tmp/t.1.vtk" else: geom_filename = "database/box.geo" vtk_filename = "tmp/t.1.vtk" os.system( "gmsh -0 %s -o tmp/x.geo" % geom_filename ) g=geom.read_gmsh("tmp/x.geo") g.printinfo() geom.write_tetgen(g,"tmp/t.poly") geom.runtetgen("tmp/t.poly",a=0.03,Q=1.0,quadratic=False, tetgenpath = tetgen_path) m = Mesh.from_file("tmp/t.1.node") m.write( vtk_filename, io = "auto" )
def from_conf(conf, options): from sfepy.fem import Mesh, Domain, Integral domains = [] for filename in filename_meshes: mesh = Mesh.from_file(filename) domain = Domain('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) test = Test(domains=domains, integral=integral, conf=conf, options=options) return test
def test_rcm(self): from sfepy import data_dir from sfepy.linalg import rcm, permute_in_place, save_sparse_txt from sfepy.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 main(): parser = OptionParser(usage=usage, version='%prog') options, args = parser.parse_args() if len(args) == 1: filename = args[0] else: parser.print_help(), return mesh = Mesh.from_file(filename) output('Mesh:') output(' dimension: %d, vertices: %d, elements: %d' % (mesh.dim, mesh.n_nod, mesh.n_el)) domain = Domain('domain', mesh) output(domain.cmesh) domain.cmesh.cprint(1) dim = domain.cmesh.dim ax = pc.plot_wireframe(None, domain.cmesh) ax = pc.plot_entities(ax, domain.cmesh, 0, 'k') ax = pc.label_global_entities(ax, domain.cmesh, 0, 'k', 12) ax = pc.label_local_entities(ax, domain.cmesh, 0, 'k', 8) ax = pc.plot_entities(ax, domain.cmesh, 1, 'b') ax = pc.label_global_entities(ax, domain.cmesh, 1, 'b', 12) ax = pc.label_local_entities(ax, domain.cmesh, 1, 'b', 8) if dim == 3: ax = pc.plot_entities(ax, domain.cmesh, 2, 'g') ax = pc.label_global_entities(ax, domain.cmesh, 2, 'g', 12) ax = pc.label_local_entities(ax, domain.cmesh, 2, 'g', 8) ax = pc.plot_entities(ax, domain.cmesh, dim, 'r') ax = pc.label_global_entities(ax, domain.cmesh, dim, 'r', 12) pc.plt.show()
def main(): parser = OptionParser(usage=usage, version='%prog') options, args = parser.parse_args() if len(args) == 1: filename = args[0] else: parser.print_help(), return mesh = Mesh.from_file(filename) output('Mesh:') output(' dimension: %d, vertices: %d, elements: %d' % (mesh.dim, mesh.n_nod, mesh.n_el)) domain = Domain('domain', mesh) output(domain.cmesh) domain.cmesh.cprint(1) dim = domain.cmesh.dim ax = pc.plot_wireframe(None, domain.cmesh) ax = pc.plot_entities(ax, domain.cmesh, 0, 'k') ax = pc.label_global_entities(ax, domain.cmesh, 0, 'k', 12) ax = pc.label_local_entities(ax, domain.cmesh, 0, 'k', 8) ax = pc.plot_entities(ax, domain.cmesh, 1, 'b') ax = pc.label_global_entities(ax, domain.cmesh, 1, 'b', 12) ax = pc.label_local_entities(ax, domain.cmesh, 1, 'b', 8) if dim == 3: ax = pc.plot_entities(ax, domain.cmesh, 2, 'g') ax = pc.label_global_entities(ax, domain.cmesh, 2, 'g', 12) ax = pc.label_local_entities(ax, domain.cmesh, 2, 'g', 8) ax = pc.plot_entities(ax, domain.cmesh, dim, 'r') ax = pc.label_global_entities(ax, domain.cmesh, dim, 'r', 12) pc.plt.show()
def test_projection_tri_quad(self): from sfepy.fem.projections import make_l2_projection source = FieldVariable("us", "unknown", self.field, 1) coors = self.field.get_coor() vals = nm.sin(2.0 * nm.pi * coors[:, 0] * coors[:, 1]) source.data_from_any(vals) name = op.join(self.options.out_dir, "test_projection_tri_quad_source.vtk") source.save_as_mesh(name) mesh = Mesh.from_file("meshes/2d/square_quad.mesh", prefix_dir=sfepy.data_dir) domain = Domain("domain", mesh) omega = domain.create_region("Omega", "all") field = H1NodalVolumeField("bilinear", nm.float64, "scalar", omega, approx_order=1) target = FieldVariable("ut", "unknown", field, 1) make_l2_projection(target, source) name = op.join(self.options.out_dir, "test_projection_tri_quad_target.vtk") target.save_as_mesh(name) bbox = self.field.domain.get_mesh_bounding_box() x = nm.linspace(bbox[0, 0] + 0.001, bbox[1, 0] - 0.001, 20) y = nm.linspace(bbox[0, 1] + 0.001, bbox[1, 1] - 0.001, 20) xx, yy = nm.meshgrid(x, y) test_coors = nm.c_[xx.ravel(), yy.ravel()].copy() vec1 = source.evaluate_at(test_coors) vec2 = target.evaluate_at(test_coors) ok = (nm.abs(vec1 - vec2) < 0.01).all() return ok
def main(): parser = OptionParser(usage=usage, version='%prog') parser.add_option('-b', '--basis', metavar='name', action='store', dest='basis', default='lagrange', help=help['basis']) parser.add_option('-d', '--derivative', metavar='d', type=int, action='store', dest='derivative', default=0, help=help['derivative']) parser.add_option('-n', '--max-order', metavar='order', type=int, action='store', dest='max_order', default=2, help=help['max_order']) parser.add_option('-g', '--geometry', metavar='name', action='store', dest='geometry', default='2_4', help=help['geometry']) parser.add_option('-m', '--mesh', metavar='mesh', action='store', dest='mesh', default=None, help=help['mesh']) parser.add_option('', '--permutations', metavar='permutations', action='store', dest='permutations', default=None, help=help['permutations']) parser.add_option('', '--dofs', metavar='dofs', action='store', dest='dofs', default=None, help=help['dofs']) parser.add_option('-l', '--lin-options', metavar='options', action='store', dest='lin_options', default='min_level=2,max_level=5,eps=1e-3', help=help['lin_options']) parser.add_option('', '--plot-dofs', action='store_true', dest='plot_dofs', default=False, help=help['plot_dofs']) options, args = parser.parse_args() if len(args) == 1: output_dir = args[0] else: parser.print_help(), return output('polynomial space:', options.basis) output('max. order:', options.max_order) lin = Struct(kind='adaptive', min_level=2, max_level=5, eps=1e-3) for opt in options.lin_options.split(','): key, val = opt.split('=') setattr(lin, key, eval(val)) if options.mesh is None: dim, n_ep = int(options.geometry[0]), int(options.geometry[2]) output('reference element geometry:') output(' dimension: %d, vertices: %d' % (dim, n_ep)) gel = GeometryElement(options.geometry) gps = PolySpace.any_from_args(None, gel, 1, base=options.basis) ps = PolySpace.any_from_args(None, gel, options.max_order, base=options.basis) n_digit, _format = get_print_info(ps.n_nod, fill='0') name_template = os.path.join(output_dir, 'bf_%s.vtk' % _format) for ip in get_dofs(options.dofs, ps.n_nod): output('shape function %d...' % ip) def eval_dofs(iels, rx): if options.derivative == 0: bf = ps.eval_base(rx).squeeze() rvals = bf[None, :, ip:ip + 1] else: bfg = ps.eval_base(rx, diff=True) rvals = bfg[None, ..., ip] return rvals def eval_coors(iels, rx): bf = gps.eval_base(rx).squeeze() coors = nm.dot(bf, gel.coors)[None, ...] return coors (level, coors, conn, vdofs, mat_ids) = create_output(eval_dofs, eval_coors, 1, ps, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) out = { 'bf': Struct(name='output_data', mode='vertex', data=vdofs, var_name='bf', dofs=None) } mesh = Mesh.from_data('bf_mesh', coors, None, [conn], [mat_ids], [options.geometry]) name = name_template % ip ensure_path(name) mesh.write(name, out=out) output('...done (%s)' % name) else: mesh = Mesh.from_file(options.mesh) output('mesh geometry:') output(' dimension: %d, vertices: %d, elements: %d' % (mesh.dim, mesh.n_nod, mesh.n_el)) if options.permutations: if options.permutations == 'all': from sfepy.linalg import cycle gel = GeometryElement(mesh.descs[0]) n_perms = gel.get_conn_permutations().shape[0] all_permutations = [ii for ii in cycle(mesh.n_el * [n_perms])] else: all_permutations = [ int(ii) for ii in options.permutations.split(',') ] all_permutations = nm.array(all_permutations) np = len(all_permutations) all_permutations.shape = (np / mesh.n_el, mesh.n_el) output('using connectivity permutations:\n', all_permutations) else: all_permutations = [None] for ip, permutations in enumerate(all_permutations): if permutations is None: suffix = '' else: suffix = '_' + '_'.join('%d' % ii for ii in permutations) save_basis_on_mesh(mesh, options, output_dir, lin, permutations, suffix)
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', 'nodes in x < %.10f' % (min_x + eps)) gamma2 = domain.create_region('Gamma2', 'nodes in x > %.10f' % (max_x - eps)) field = Field('fu', nm.float64, 'vector', omega, space='H1', poly_space_base='lagrange', approx_order=2) u = FieldVariable('u', 'unknown', field, mesh.dim) v = FieldVariable('v', 'test', field, mesh.dim, 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 = ProblemDefinition('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 main(): parser = OptionParser(usage=usage, version='%prog') parser.add_option('-b', '--basis', metavar='name', action='store', dest='basis', default='lagrange', help=help['basis']) parser.add_option('-d', '--derivative', metavar='d', type=int, action='store', dest='derivative', default=0, help=help['derivative']) parser.add_option('-n', '--max-order', metavar='order', type=int, action='store', dest='max_order', default=2, help=help['max_order']) parser.add_option('-g', '--geometry', metavar='name', action='store', dest='geometry', default='2_4', help=help['geometry']) parser.add_option('-m', '--mesh', metavar='mesh', action='store', dest='mesh', default=None, help=help['mesh']) parser.add_option('', '--permutations', metavar='permutations', action='store', dest='permutations', default=None, help=help['permutations']) parser.add_option('', '--dofs', metavar='dofs', action='store', dest='dofs', default=None, help=help['dofs']) parser.add_option('-l', '--lin-options', metavar='options', action='store', dest='lin_options', default='min_level=2,max_level=5,eps=1e-3', help=help['lin_options']) parser.add_option('', '--plot-dofs', action='store_true', dest='plot_dofs', default=False, help=help['plot_dofs']) options, args = parser.parse_args() if len(args) == 1: output_dir = args[0] else: parser.print_help(), return output('polynomial space:', options.basis) output('max. order:', options.max_order) lin = Struct(kind='adaptive', min_level=2, max_level=5, eps=1e-3) for opt in options.lin_options.split(','): key, val = opt.split('=') setattr(lin, key, eval(val)) if options.mesh is None: dim, n_ep = int(options.geometry[0]), int(options.geometry[2]) output('reference element geometry:') output(' dimension: %d, vertices: %d' % (dim, n_ep)) gel = GeometryElement(options.geometry) gps = PolySpace.any_from_args(None, gel, 1, base=options.basis) ps = PolySpace.any_from_args(None, gel, options.max_order, base=options.basis) n_digit, _format = get_print_info(ps.n_nod, fill='0') name_template = os.path.join(output_dir, 'bf_%s.vtk' % _format) for ip in get_dofs(options.dofs, ps.n_nod): output('shape function %d...' % ip) def eval_dofs(iels, rx): if options.derivative == 0: bf = ps.eval_base(rx).squeeze() rvals = bf[None, :, ip:ip + 1] else: bfg = ps.eval_base(rx, diff=True) rvals = bfg[None, ..., ip] return rvals def eval_coors(iels, rx): bf = gps.eval_base(rx).squeeze() coors = nm.dot(bf, gel.coors)[None, ...] return coors (level, coors, conn, vdofs, mat_ids) = create_output(eval_dofs, eval_coors, 1, ps, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) out = { 'bf': Struct(name='output_data', mode='vertex', data=vdofs, var_name='bf', dofs=None) } mesh = Mesh.from_data('bf_mesh', coors, None, [conn], [mat_ids], [options.geometry]) name = name_template % ip mesh.write(name, out=out) output('...done (%s)' % name) else: mesh = Mesh.from_file(options.mesh) output('mesh geometry:') output(' dimension: %d, vertices: %d, elements: %d' % (mesh.dim, mesh.n_nod, mesh.n_el)) domain = Domain('domain', mesh) if options.permutations: permutations = [int(ii) for ii in options.permutations.split(',')] output('using connectivity permutations:', permutations) for group in domain.iter_groups(): perms = group.gel.get_conn_permutations()[permutations] offsets = nm.arange(group.shape.n_el) * group.shape.n_ep group.conn[:] = group.conn.take(perms + offsets[:, None]) domain.setup_facets() omega = domain.create_region('Omega', 'all') field = Field.from_args('f', nm.float64, shape=1, region=omega, approx_order=options.max_order, poly_space_base=options.basis) var = FieldVariable('u', 'unknown', field, 1) if options.plot_dofs: import sfepy.postprocess.plot_dofs as pd group = domain.groups[0] ax = pd.plot_mesh(None, mesh.coors, mesh.conns[0], group.gel.edges) ax = pd.plot_global_dofs(ax, field.get_coor(), field.aps[0].econn) ax = pd.plot_local_dofs(ax, field.get_coor(), field.aps[0].econn) if options.dofs is not None: ax = pd.plot_nodes(ax, field.get_coor(), field.aps[0].econn, field.aps[0].interp.poly_spaces['v'].nodes, get_dofs(options.dofs, var.n_dof)) pd.plt.show() output('dofs: %d' % var.n_dof) vec = nm.empty(var.n_dof, dtype=var.dtype) n_digit, _format = get_print_info(var.n_dof, fill='0') name_template = os.path.join(output_dir, 'dof_%s.vtk' % _format) for ip in get_dofs(options.dofs, var.n_dof): output('dof %d...' % ip) vec.fill(0.0) vec[ip] = 1.0 var.set_data(vec) if options.derivative == 0: out = var.create_output(vec, linearization=lin) else: out = create_expression_output('ev_grad.ie.Elements(u)', 'u', 'f', {'f': field}, None, Variables([var]), mode='qp', verbose=False, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) name = name_template % ip out['u'].mesh.write(name, out=out) output('...done (%s)' % name)
def read_common(self, filename): self.io = MeshIO.any_from_filename(filename) self.step_range = (0, self.io.read_last_step()) self.mesh = mesh = Mesh.from_file(filename) self.n_nod, self.dim = self.mesh.coors.shape
def main(): parser = OptionParser(usage=usage, version='%prog') parser.add_option('-b', '--basis', metavar='name', action='store', dest='basis', default='lagrange', help=help['basis']) parser.add_option('-d', '--derivative', metavar='d', type=int, action='store', dest='derivative', default=0, help=help['derivative']) parser.add_option('-n', '--max-order', metavar='order', type=int, action='store', dest='max_order', default=2, help=help['max_order']) parser.add_option('-g', '--geometry', metavar='name', action='store', dest='geometry', default='2_4', help=help['geometry']) parser.add_option('-m', '--mesh', metavar='mesh', action='store', dest='mesh', default=None, help=help['mesh']) parser.add_option('', '--permutations', metavar='permutations', action='store', dest='permutations', default=None, help=help['permutations']) parser.add_option('', '--dofs', metavar='dofs', action='store', dest='dofs', default=None, help=help['dofs']) parser.add_option('-l', '--lin-options', metavar='options', action='store', dest='lin_options', default='min_level=2,max_level=5,eps=1e-3', help=help['lin_options']) parser.add_option('', '--plot-dofs', action='store_true', dest='plot_dofs', default=False, help=help['plot_dofs']) options, args = parser.parse_args() if len(args) == 1: output_dir = args[0] else: parser.print_help(), return output('polynomial space:', options.basis) output('max. order:', options.max_order) lin = Struct(kind='adaptive', min_level=2, max_level=5, eps=1e-3) for opt in options.lin_options.split(','): key, val = opt.split('=') setattr(lin, key, eval(val)) if options.mesh is None: dim, n_ep = int(options.geometry[0]), int(options.geometry[2]) output('reference element geometry:') output(' dimension: %d, vertices: %d' % (dim, n_ep)) gel = GeometryElement(options.geometry) gps = PolySpace.any_from_args(None, gel, 1, base=options.basis) ps = PolySpace.any_from_args(None, gel, options.max_order, base=options.basis) n_digit, _format = get_print_info(ps.n_nod, fill='0') name_template = os.path.join(output_dir, 'bf_%s.vtk' % _format) for ip in get_dofs(options.dofs, ps.n_nod): output('shape function %d...' % ip) def eval_dofs(iels, rx): if options.derivative == 0: bf = ps.eval_base(rx).squeeze() rvals = bf[None, :, ip:ip+1] else: bfg = ps.eval_base(rx, diff=True) rvals = bfg[None, ..., ip] return rvals def eval_coors(iels, rx): bf = gps.eval_base(rx).squeeze() coors = nm.dot(bf, gel.coors)[None, ...] return coors (level, coors, conn, vdofs, mat_ids) = create_output(eval_dofs, eval_coors, 1, ps, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) out = { 'bf' : Struct(name='output_data', mode='vertex', data=vdofs, var_name='bf', dofs=None) } mesh = Mesh.from_data('bf_mesh', coors, None, [conn], [mat_ids], [options.geometry]) name = name_template % ip mesh.write(name, out=out) output('...done (%s)' % name) else: mesh = Mesh.from_file(options.mesh) output('mesh geometry:') output(' dimension: %d, vertices: %d, elements: %d' % (mesh.dim, mesh.n_nod, mesh.n_el)) domain = Domain('domain', mesh) if options.permutations: permutations = [int(ii) for ii in options.permutations.split(',')] output('using connectivity permutations:', permutations) for group in domain.iter_groups(): perms = group.gel.get_conn_permutations()[permutations] offsets = nm.arange(group.shape.n_el) * group.shape.n_ep group.conn[:] = group.conn.take(perms + offsets[:, None]) domain.setup_facets() omega = domain.create_region('Omega', 'all') field = Field.from_args('f', nm.float64, shape=1, region=omega, approx_order=options.max_order, poly_space_base=options.basis) var = FieldVariable('u', 'unknown', field, 1) if options.plot_dofs: import sfepy.postprocess.plot_dofs as pd group = domain.groups[0] ax = pd.plot_mesh(None, mesh.coors, mesh.conns[0], group.gel.edges) ax = pd.plot_global_dofs(ax, field.get_coor(), field.aps[0].econn) ax = pd.plot_local_dofs(ax, field.get_coor(), field.aps[0].econn) pd.plt.show() output('dofs: %d' % var.n_dof) vec = nm.empty(var.n_dof, dtype=var.dtype) n_digit, _format = get_print_info(var.n_dof, fill='0') name_template = os.path.join(output_dir, 'dof_%s.vtk' % _format) for ip in get_dofs(options.dofs, var.n_dof): output('dof %d...' % ip) vec.fill(0.0) vec[ip] = 1.0 var.data_from_any(vec) if options.derivative == 0: out = var.create_output(vec, linearization=lin) else: out = create_expression_output('ev_grad.ie.Elements(u)', 'u', 'f', {'f' : field}, None, Variables([var]), mode='qp', verbose=False, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) name = name_template % ip out['u'].mesh.write(name, out=out) output('...done (%s)' % name)
def read_common(self, filename): self.io = MeshIO.any_from_filename(filename) self.step_range = (0, self.io.read_last_step()) self.mesh = mesh = Mesh.from_file(filename) self.n_nod, self.dim = self.mesh.coors.shape
def main(): parser = OptionParser(usage=usage, version="%prog " + sfepy.__version__) parser.add_option("-m", "--mesh", action="store_true", dest="save_mesh", default=True, help="save surface mesh [default: %default]") parser.add_option("-n", "--no-surface", action="store_true", dest="no_surface", default=False, help="do not output surface [default: %default]") (options, args) = parser.parse_args() if (len(args) == 2): filename_in = args[0] filename_out = args[1] else: parser.print_help(), return if (filename_in == '-'): file_in = sys.stdin else: file_in = open(filename_in, "r") mesh = Mesh.from_file(filename_in) if (filename_in != '-'): file_in.close() domain = Domain('domain', mesh) domain.setup_groups() if domain.has_faces(): domain.fix_element_orientation() domain.setup_facets(create_edges=False) lst, surf_faces = domain.surface_faces() surf_mesh = Mesh.from_surface(surf_faces, mesh) if options.save_mesh: aux = edit_filename(filename_in, prefix='surf_', new_ext='.mesh') surf_mesh.write(aux, io='auto') if options.no_surface: return gr_s = surface_graph(surf_faces, mesh.n_nod) ## import sfepy.base.plotutils as plu ## plu.spy( gr_s ) ## plu.pylab.show() n_comp, comps = surface_components(gr_s, surf_faces) # print 'components:', n_comp ccs, comps = comps, nm.zeros((0, 1), nm.int32) for cc in ccs: comps = nm.concatenate((comps, cc[:, nm.newaxis]), 0) out = nm.concatenate((lst, comps), 1) if (filename_out == '-'): file_out = sys.stdout else: file_out = open(filename_out, "w") for row in out: file_out.write('%d %d %d %d\n' % (row[0], row[1], row[2], row[3])) if (filename_out != '-'): file_out.close()
def main(): parser = OptionParser(usage = usage, version = "%prog " + sfepy.__version__) parser.add_option( "--mesh", action = "store_true", dest = "mesh", default = False, help = help['mesh'] ) parser.add_option( "--2d", action = "store_true", dest = "dim2", default = False, help = help['dim'] ) parser.add_option( "-o", "", metavar = 'filename', action = "store", dest = "output_filename_trunk", default = "mesh", help = help['filename'] ) parser.add_option( "--oscillator", action = "store_true", dest = "oscillator", default = False, help = help['oscillator'] ) parser.add_option( "--well", action = "store_true", dest = "well", default = False, help = help['well'] ) parser.add_option( "--hydrogen", action = "store_true", dest = "hydrogen", default = False, help = help['hydrogen'] ) parser.add_option( "--boron", action = "store_true", dest = "boron", default = False, help = help['boron'] ) parser.add_option( "--dft", action = "store_true", dest = "dft", default = False, help = help['dft'] ) parser.add_option( "-p", "--plot", action = "store_true", dest = "plot", default = False, help = help['plot'] ) options, args = parser.parse_args() if len( args ) == 1: filename_in = args[0]; auto_mesh_name = False elif len( args ) == 0: auto_mesh_name = True if options.oscillator: filename_in = fix_path("examples/quantum/oscillator.py") elif options.well: filename_in = fix_path("examples/quantum/well.py") elif options.hydrogen: filename_in = fix_path("examples/quantum/hydrogen.py") elif options.boron: filename_in = fix_path("examples/quantum/boron.py") elif options.mesh: output('generating mesh...') try: os.makedirs("tmp") except OSError, e: if e.errno != 17: # [Errno 17] File exists raise if options.dim2: output("dimension: 2") gp = fix_path('meshes/quantum/square.geo') os.system("cp %s tmp/mesh.geo" % gp) os.system("gmsh -2 tmp/mesh.geo -format mesh") mtv = fix_path('script/mesh_to_vtk.py') os.system("%s tmp/mesh.mesh tmp/mesh.vtk" % mtv) else: output("dimension: 3") import sfepy.geom as geom from sfepy.fem.mesh import Mesh try: from site_cfg import tetgen_path except ImportError: tetgen_path = '/usr/bin/tetgen' gp = fix_path('meshes/quantum/box.geo') os.system("gmsh -0 %s -o tmp/x.geo" % gp) g = geom.read_gmsh("tmp/x.geo") g.printinfo() geom.write_tetgen(g, "tmp/t.poly") geom.runtetgen("tmp/t.poly", a=0.03, Q=1.0, quadratic=False, tetgenpath=tetgen_path) m = Mesh.from_file("tmp/t.1.node") m.write("tmp/mesh.vtk", io="auto") output("...mesh written to tmp/mesh.vtk") return elif options.dft: output('the --dft option requires input file') return else: parser.print_help() return
def test_cmesh_counts(self): from sfepy.fem import Mesh from sfepy.fem.geometry_element import create_geometry_elements from sfepy.fem.extmods.cmesh import CMesh, get_cmem_usage gels = create_geometry_elements() ok = True for filename in self.filename_meshes: basename = os.path.basename(filename) enum, esizes = expected[basename] self.report('mesh: %s' % basename) mesh = Mesh.from_file(filename) cmesh = CMesh.from_mesh(mesh) cmesh.set_local_entities(gels) cmesh.setup_entities() self.report('dim:', cmesh.dim) self.report('n_cell: %d, n_face: %d, n_edge: %d, n_vertex: %d' % tuple(cmesh.num)) _ok = (enum == cmesh.num).all() if not _ok: self.report('%s == %s failed!' % (enum, cmesh.num)) ok = ok and _ok dim = cmesh.dim for ir in range(dim + 1): for ic in range(dim + 1): cmesh.setup_connectivity(ir, ic) mem_usage1 = get_cmem_usage()[0] if (ir == dim) and (ic == 0): continue cmesh.free_connectivity(ir, ic) mem_usage2 = get_cmem_usage()[0] cmesh.setup_connectivity(ir, ic) mem_usage3 = get_cmem_usage()[0] conn = cmesh.get_conn(ir, ic) self.report('(%d, %d) : (%d, %d)' % (ir, ic, conn.num, conn.n_incident)) sizes = nm.array([conn.num, conn.n_incident]) _ok = (esizes[ir, ic] == sizes).all() if not _ok: self.report('%s == %s failed!' % (esizes, sizes)) ok = ok and _ok _ok1 = mem_usage3 == mem_usage1 _ok2 = mem_usage3 > mem_usage2 if not (_ok1 and _ok2): self.report('unexpected memory usage! (%s)' % (mem_usage1, mem_usage2, mem_usage3)) ok = ok and (_ok1 and _ok2) return ok
def main(): parser = OptionParser(usage=usage, version='%prog') parser.add_option('-b', '--basis', metavar='name', action='store', dest='basis', default='lagrange', help=help['basis']) parser.add_option('-n', '--max-order', metavar='order', type=int, action='store', dest='max_order', default=10, help=help['max_order']) parser.add_option('-m', '--matrix', metavar='type', action='store', dest='matrix_type', default='laplace', help=help['matrix_type']) parser.add_option('-g', '--geometry', metavar='name', action='store', dest='geometry', default='2_4', help=help['geometry']) options, args = parser.parse_args() dim, n_ep = int(options.geometry[0]), int(options.geometry[2]) output('reference element geometry:') output(' dimension: %d, vertices: %d' % (dim, n_ep)) n_c = {'laplace': 1, 'elasticity': dim}[options.matrix_type] output('matrix type:', options.matrix_type) output('number of variable components:', n_c) output('polynomial space:', options.basis) output('max. order:', options.max_order) mesh = Mesh.from_file(data_dir + '/meshes/elements/%s_1.mesh' % options.geometry) domain = Domain('domain', mesh) omega = domain.create_region('Omega', 'all') orders = nm.arange(1, options.max_order + 1, dtype=nm.int) conds = [] order_fix = 0 if options.geometry in ['2_4', '3_8'] else 1 for order in orders: output('order:', order, '...') field = Field.from_args('fu', nm.float64, n_c, omega, approx_order=order, space='H1', poly_space_base=options.basis) to = field.approx_order quad_order = 2 * (max(to - order_fix, 0)) output('quadrature order:', quad_order) integral = Integral('i', order=quad_order) qp, _ = integral.get_qp(options.geometry) output('number of quadrature points:', qp.shape[0]) u = FieldVariable('u', 'unknown', field, n_c) v = FieldVariable('v', 'test', field, n_c, primary_var_name='u') m = Material('m', lam=1.0, mu=1.0) if options.matrix_type == 'laplace': term = Term.new('dw_laplace(m.mu, v, u)', integral, omega, m=m, v=v, u=u) n_zero = 1 else: assert_(options.matrix_type == 'elasticity') term = Term.new('dw_lin_elastic_iso(m.lam, m.mu, v, u)', integral, omega, m=m, v=v, u=u) n_zero = (dim + 1) * dim / 2 term.setup() output('assembling...') tt = time.clock() mtx, iels = term.evaluate(mode='weak', diff_var='u') output('...done in %.2f s' % (time.clock() - tt)) mtx = mtx[0][0, 0] try: assert_(nm.max(nm.abs(mtx - mtx.T)) < 1e-10) except: from sfepy.base.base import debug debug() output('matrix shape:', mtx.shape) eigs = eig(mtx, method='eig.sgscipy', eigenvectors=False) eigs.sort() # Zero 'true' zeros. eigs[:n_zero] = 0.0 ii = nm.where(eigs < 0.0)[0] if len(ii): output('matrix is not positive semi-definite!') ii = nm.where(eigs[n_zero:] < 1e-12)[0] if len(ii): output('matrix has more than %d zero eigenvalues!' % n_zero) output('smallest eigs:\n', eigs[:10]) ii = nm.where(eigs > 0.0)[0] emin, emax = eigs[ii[[0, -1]]] output('min:', emin, 'max:', emax) cond = emax / emin conds.append(cond) output('condition number:', cond) output('...done') plt.figure(1) plt.semilogy(orders, conds) plt.xticks(orders, orders) plt.xlabel('polynomial order') plt.ylabel('condition number') plt.grid() plt.figure(2) plt.loglog(orders, conds) plt.xticks(orders, orders) plt.xlabel('polynomial order') plt.ylabel('condition number') plt.grid() plt.show()
def main(): parser = OptionParser( usage = usage, version = "%prog " + version ) parser.add_option( "-m", "--mesh", action = "store_true", dest = "save_mesh", default = True, help = "save surface mesh [default: %default]" ) parser.add_option( "-n", "--no-surface", action = "store_true", dest = "no_surface", default = False, help = "do not output surface [default: %default]" ) (options, args) = parser.parse_args() if (len( args ) == 2): filename_in = args[0]; filename_out = args[1]; else: parser.print_help(), return if (filename_in == '-'): file_in = sys.stdin else: file_in = open( filename_in, "r" ); mesh = Mesh.from_file( filename_in ) if (filename_in != '-'): file_in.close() domain = Domain.from_mesh( mesh, op.join( init_sfepy.install_dir, 'eldesc' ) ) domain.setup_groups() if domain.has_faces(): domain.fix_element_orientation() domain.setup_neighbour_lists( create_edge_list = False ) lst, surf_faces = domain.surface_faces() surf_mesh = Mesh.from_surface( surf_faces, mesh ) if options.save_mesh: base, ext = op.splitext( op.basename( filename_in ) ) surf_mesh.write( "surf_" + base + '.mesh', io = 'auto' ) if options.no_surface: return n_nod = mesh.nod0.shape[0] gr_s = surface_graph( surf_faces, n_nod ) ## import sfepy.base.plotutils as plu ## plu.spy( gr_s ) ## plu.pylab.show() n_comp, comps = surface_components( gr_s, surf_faces ) # print 'components:', n_comp ccs, comps = comps, nm.zeros( (0,1), nm.int32 ) for cc in ccs: comps = nm.concatenate( (comps, cc[:,nm.newaxis]), 0 ) out = nm.concatenate( (lst, comps), 1 ) if (filename_out == '-'): file_out = sys.stdout else: file_out = open( filename_out, "w" ); for row in out: file_out.write( '%d %d %d %d\n' % (row[0], row[1], row[2], row[3]) ) if (filename_out != '-'): file_out.close()
def _gen_common_data(orders, gels, report): import sfepy from sfepy.base.base import Struct from sfepy.linalg import combine from sfepy.fem import Mesh, Domain, Field, FieldVariable, Integral from sfepy.fem.global_interp import get_ref_coors bases = ([ii for ii in combine([['2_4', '3_8'], ['lagrange', 'lobatto']])] + [ii for ii in combine([['2_3', '3_4'], ['lagrange']])]) for geom, poly_space_base in bases: report('geometry: %s, base: %s' % (geom, poly_space_base)) order = orders[geom] integral = Integral('i', order=order) aux = '' if geom in ['2_4', '3_8'] else 'z' mesh0 = Mesh.from_file('meshes/elements/%s_2%s.mesh' % (geom, aux), prefix_dir=sfepy.data_dir) gel = gels[geom] perms = gel.get_conn_permutations() qps, qp_weights = integral.get_qp(gel.surface_facet.name) zz = nm.zeros_like(qps[:, :1]) qps = nm.hstack(([qps] + [zz])) shift = shifts[geom] rcoors = nm.ascontiguousarray(qps + shift[:1, :] - shift[1:, :]) ccoors = nm.ascontiguousarray(qps + shift[:1, :] + shift[1:, :]) for ir, pr in enumerate(perms): for ic, pc in enumerate(perms): report('ir: %d, ic: %d' % (ir, ic)) report('pr: %s, pc: %s' % (pr, pc)) mesh = mesh0.copy() conn = mesh.conns[0] conn[0, :] = conn[0, pr] conn[1, :] = conn[1, pc] cache = Struct(mesh=mesh) domain = Domain('domain', mesh) omega = domain.create_region('Omega', 'all') region = domain.create_region('Facet', rsels[geom], 'facet') field = Field.from_args('f', nm.float64, shape=1, region=omega, approx_order=order, poly_space_base=poly_space_base) var = FieldVariable('u', 'unknown', field, 1) report('# dofs: %d' % var.n_dof) vec = nm.empty(var.n_dof, dtype=var.dtype) ap = field.aps[0] ps = ap.interp.poly_spaces['v'] dofs = field.get_dofs_in_region_group(region, 0, merge=False) edofs, fdofs = nm.unique(dofs[1]), nm.unique(dofs[2]) rrc, rcells, rstatus = get_ref_coors(field, rcoors, cache=cache) crc, ccells, cstatus = get_ref_coors(field, ccoors, cache=cache) assert_((rstatus == 0).all() and (cstatus == 0).all()) yield (geom, poly_space_base, qp_weights, mesh, ir, ic, ap, ps, rrc, rcells[0, 1], crc, ccells[0, 1], vec, edofs, fdofs)
def _gen_common_data(order, gels, report): import sfepy from sfepy.base.base import Struct from sfepy.linalg import combine from sfepy.fem import Mesh, Domain, Field, FieldVariable, Integral from sfepy.fem.global_interp import get_ref_coors integral = Integral('i', order=order) for geom, poly_space_base in combine([['2_4', '3_8'], ['lagrange', 'lobatto']]): report('geometry: %s, base: %s' % (geom, poly_space_base)) mesh0 = Mesh.from_file('meshes/elements/%s_2.mesh' % geom, prefix_dir=sfepy.data_dir) gel = gels[geom] perms = gel.get_conn_permutations() qps, qp_weights = integral.get_qp(gel.surface_facet.name) zz = nm.zeros_like(qps[:, :1]) qps = nm.hstack(([qps] + [zz])) rot = rots[geom] if rot is not None: pass shift = shifts[geom] rcoors = nm.ascontiguousarray(qps + shift[:1, :] - shift[1:, :]) ccoors = nm.ascontiguousarray(qps + shift[:1, :] + shift[1:, :]) for ir, pr in enumerate(perms): for ic, pc in enumerate(perms): report('ir: %d, ic: %d' % (ir, ic)) mesh = mesh0.copy() conn = mesh.conns[0] conn[0, :] = conn[0, pr] conn[1, :] = conn[1, pc] cache = Struct(mesh=mesh) domain = Domain('domain', mesh) omega = domain.create_region('Omega', 'all') region = domain.create_region('Facet', rsels[geom]) field = Field.from_args('f', nm.float64, shape=1, region=omega, approx_order=order, poly_space_base=poly_space_base) var = FieldVariable('u', 'unknown', field, 1) report('# dofs: %d' % var.n_dof) vec = nm.empty(var.n_dof, dtype=var.dtype) ap = field.aps[0] ps = ap.interp.poly_spaces['v'] dofs = field.get_dofs_in_region_group(region, 0, merge=False) edofs, fdofs = nm.unique(dofs[1]), nm.unique(dofs[2]) rrc, rcells, rstatus = get_ref_coors(field, rcoors, cache=cache) crc, ccells, cstatus = get_ref_coors(field, ccoors, cache=cache) yield (geom, poly_space_base, qp_weights, mesh, ir, ic, ap, ps, rrc, crc, vec, edofs, fdofs)
def main(): parser = OptionParser(usage=usage, version='%prog') parser.add_option('-b', '--basis', metavar='name', action='store', dest='basis', default='lagrange', help=help['basis']) parser.add_option('-d', '--derivative', metavar='d', type=int, action='store', dest='derivative', default=0, help=help['derivative']) parser.add_option('-n', '--max-order', metavar='order', type=int, action='store', dest='max_order', default=2, help=help['max_order']) parser.add_option('-g', '--geometry', metavar='name', action='store', dest='geometry', default='2_4', help=help['geometry']) parser.add_option('-m', '--mesh', metavar='mesh', action='store', dest='mesh', default=None, help=help['mesh']) parser.add_option('', '--permutations', metavar='permutations', action='store', dest='permutations', default=None, help=help['permutations']) parser.add_option('', '--dofs', metavar='dofs', action='store', dest='dofs', default=None, help=help['dofs']) parser.add_option('-l', '--lin-options', metavar='options', action='store', dest='lin_options', default='min_level=2,max_level=5,eps=1e-3', help=help['lin_options']) parser.add_option('', '--plot-dofs', action='store_true', dest='plot_dofs', default=False, help=help['plot_dofs']) options, args = parser.parse_args() if len(args) == 1: output_dir = args[0] else: parser.print_help(), return output('polynomial space:', options.basis) output('max. order:', options.max_order) lin = Struct(kind='adaptive', min_level=2, max_level=5, eps=1e-3) for opt in options.lin_options.split(','): key, val = opt.split('=') setattr(lin, key, eval(val)) if options.mesh is None: dim, n_ep = int(options.geometry[0]), int(options.geometry[2]) output('reference element geometry:') output(' dimension: %d, vertices: %d' % (dim, n_ep)) gel = GeometryElement(options.geometry) gps = PolySpace.any_from_args(None, gel, 1, base=options.basis) ps = PolySpace.any_from_args(None, gel, options.max_order, base=options.basis) n_digit, _format = get_print_info(ps.n_nod, fill='0') name_template = os.path.join(output_dir, 'bf_%s.vtk' % _format) for ip in get_dofs(options.dofs, ps.n_nod): output('shape function %d...' % ip) def eval_dofs(iels, rx): if options.derivative == 0: bf = ps.eval_base(rx).squeeze() rvals = bf[None, :, ip:ip+1] else: bfg = ps.eval_base(rx, diff=True) rvals = bfg[None, ..., ip] return rvals def eval_coors(iels, rx): bf = gps.eval_base(rx).squeeze() coors = nm.dot(bf, gel.coors)[None, ...] return coors (level, coors, conn, vdofs, mat_ids) = create_output(eval_dofs, eval_coors, 1, ps, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) out = { 'bf' : Struct(name='output_data', mode='vertex', data=vdofs, var_name='bf', dofs=None) } mesh = Mesh.from_data('bf_mesh', coors, None, [conn], [mat_ids], [options.geometry]) name = name_template % ip ensure_path(name) mesh.write(name, out=out) output('...done (%s)' % name) else: mesh = Mesh.from_file(options.mesh) output('mesh geometry:') output(' dimension: %d, vertices: %d, elements: %d' % (mesh.dim, mesh.n_nod, mesh.n_el)) if options.permutations: if options.permutations == 'all': from sfepy.linalg import cycle gel = GeometryElement(mesh.descs[0]) n_perms = gel.get_conn_permutations().shape[0] all_permutations = [ii for ii in cycle(mesh.n_el * [n_perms])] else: all_permutations = [int(ii) for ii in options.permutations.split(',')] all_permutations = nm.array(all_permutations) np = len(all_permutations) all_permutations.shape = (np / mesh.n_el, mesh.n_el) output('using connectivity permutations:\n', all_permutations) else: all_permutations = [None] for ip, permutations in enumerate(all_permutations): if permutations is None: suffix = '' else: suffix = '_' + '_'.join('%d' % ii for ii in permutations) save_basis_on_mesh(mesh, options, output_dir, lin, permutations, suffix)
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', 'nodes in x < %.10f' % (min_x + eps)) gamma2 = domain.create_region('Gamma2', 'nodes in x > %.10f' % (max_x - eps)) field = H1NodalVolumeField('fu', nm.float64, 'vector', omega, approx_order=2) u = FieldVariable('u', 'unknown', field, mesh.dim) v = FieldVariable('v', 'test', field, mesh.dim, 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 = ProblemDefinition('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 main(): parser = OptionParser(usage=usage) parser.add_option('-s', '--scale', metavar='scale', action='store', dest='scale', default=None, help=help['scale']) parser.add_option('-r', '--refine', metavar='level', action='store', type=int, dest='refine', default=0, help=help['refine']) parser.add_option('-f', '--format', metavar='format', action='store', type='string', dest='format', default=None, help=help['format']) parser.add_option('-l', '--list', action='store_true', dest='list', help=help['list']) (options, args) = parser.parse_args() if options.list: output_writable_meshes() sys.exit(0) if len(args) != 2: parser.print_help() sys.exit(1) scale = options.scale if scale is not None: try: try: scale = float(scale) except ValueError: scale = [float(ii) for ii in scale.split(',')] scale = nm.array(scale, dtype=nm.float64, ndmin=1) except: output('bad scale! (%s)' % scale) parser.print_help() sys.exit(1) filename_in, filename_out = args mesh = Mesh.from_file(filename_in) if scale is not None: if len(scale) == 1: tr = nm.eye(mesh.dim, dtype=nm.float64) * scale elif len(scale) == mesh.dim: tr = nm.diag(scale) else: raise ValueError('bad scale! (%s)' % scale) mesh.transform_coors(tr) if options.refine > 0: domain = Domain(mesh.name, mesh) output('initial mesh: %d nodes %d elements' % (domain.shape.n_nod, domain.shape.n_el)) for ii in range(options.refine): output('refine %d...' % ii) domain = domain.refine() output('... %d nodes %d elements' % (domain.shape.n_nod, domain.shape.n_el)) mesh = domain.mesh io = MeshIO.for_format(filename_out, format=options.format, writable=True) output('writing %s...' % filename_out) mesh.write(filename_out, io=io) output('...done')
def main(): parser = OptionParser(usage=usage) parser.add_option("-s", "--scale", metavar="scale", action="store", dest="scale", default=None, help=help["scale"]) parser.add_option( "-f", "--format", metavar="format", action="store", type="string", dest="format", default=None, help=help["format"], ) parser.add_option("-l", "--list", action="store_true", dest="list", help=help["list"]) (options, args) = parser.parse_args() if options.list: output_writable_meshes() sys.exit(0) if len(args) != 2: parser.print_help() sys.exit(1) scale = options.scale if scale is not None: try: try: scale = float(scale) except ValueError: scale = [float(ii) for ii in scale.split(",")] scale = nm.array(scale, dtype=nm.float64, ndmin=1) except: output("bad scale! (%s)" % scale) parser.print_help() sys.exit(1) filename_in, filename_out = args mesh = Mesh.from_file(filename_in) if scale is not None: if len(scale) == 1: tr = nm.eye(mesh.dim, dtype=nm.float64) * scale elif len(scale) == mesh.dim: tr = nm.diag(scale) else: raise ValueError("bad scale! (%s)" % scale) mesh.transform_coors(tr) io = "auto" if options.format: try: io = io_table[options.format](filename_out) except KeyError: output("unknown output mesh format! (%s)" % options.format) output_writable_meshes() sys.exit(1) if "w" not in supported_capabilities[options.format]: output("write support not implemented for output mesh format! (%s)" % options.format) output_writable_meshes() sys.exit(1) output("writing %s..." % filename_out) mesh.write(filename_out, io=io) output("...done")
def meshgen_from_goem(geo, a=None, quadratic=False, verbose=True, refine=False, polyfilename='./meshgen.poly', out='mesh', **kwargs): """ Runs mesh generator - tetgen for 3D or triangle for 2D meshes. Parameters ---------- geo : geometry geometry description a : int, optional a maximum area/volume constraint quadratic : bool, optional set True for quadratic elements verbose : bool, optional detailed information refine : bool, optional refines mesh Returns ------- mesh : mesh triangular or tetrahedral mesh """ import os.path as op import pexpect # write geometry to poly file geo.to_poly_file(polyfilename) if not refine: params = "-Apq" else: params = "-Arq" if verbose: params = params + " -Q" if a != None and not refine: params = params + " -a%f" % (a) if refine: params = params + " -a" if quadratic: params = params + " -o2" params = params + " %s" % (polyfilename) meshgen_call = {2: 'triangle', 3: 'tetgen'} cmd = "%s %s" % (meshgen_call[geo.dim], params) if verbose: print "Generating mesh using", cmd if geo.dim == 2: p=pexpect.run(cmd, timeout=None) bname, ext = op.splitext(polyfilename) mesh = Mesh.from_file(bname + '.1.node') mesh.write(bname + '.' + out) if geo.dim == 3: p=pexpect.spawn(cmd, timeout=None) if not refine: p.expect("Opening %s." % (polyfilename)) else: p.expect("Opening %s.node.\r\n" % (polyfilename)) p.expect("Opening %s.ele.\r\n" % (polyfilename)) p.expect("Opening %s.face.\r\n" % (polyfilename)) p.expect("Opening %s.vol." % (polyfilename)) assert p.before == "" p.expect(pexpect.EOF) if p.before != "\r\n": print p.before raise "Error when running mesh generator (see above for output): %s" % cmd
import numpy as np from sfepy.fem import (Mesh, Domain, Field, FieldVariable, Material, Integral, Equation, Equations, ProblemDefinition) from sfepy.terms import Term from sfepy.fem.conditions import Conditions, EssentialBC from sfepy.solvers.ls import ScipyDirect from sfepy.solvers.nls import Newton from sfepy.postprocess import Viewer mesh = Mesh.from_file('meshes/2d/square_tri2.mesh') domain = Domain('domain', mesh) omega = domain.create_region('Omega', 'all') left = domain.create_region('Left', 'vertices in x < -0.999', 'facet') right = domain.create_region('Right', 'vertices in x > 0.999', 'facet') bottom = domain.create_region('Bottom', 'vertices in y < -0.999', 'facet') top = domain.create_region('Top', 'vertices in y > 0.999', 'facet') domain.save_regions_as_groups('regions.vtk')
def test_linearization(self): from sfepy.base.base import Struct from sfepy.fem import Mesh, Domain, H1NodalVolumeField from sfepy import data_dir geometries = ['2_3', '2_4', '3_4', '3_8'] approx_orders = [1, 2] funs = [nm.cos, nm.sin, lambda x: x] ok = True for geometry in geometries: name = os.path.join(data_dir, 'meshes/elements/%s_1.mesh' % geometry) mesh = Mesh.from_file(name) domain = Domain('', mesh) domain = domain.refine() domain.mesh.write(self.join('linearizer-%s-0.mesh' % geometry)) omega = domain.create_region('Omega', 'all') for approx_order in approx_orders: for dpn in [1, mesh.dim]: self.report('geometry: %s, approx. order: %d, dpn: %d' % (geometry, approx_order, dpn)) field = H1NodalVolumeField('fu', nm.float64, dpn, omega, approx_order=approx_order) cc = field.get_coor() dofs = nm.zeros((field.n_nod, dpn), dtype=nm.float64) for ic in range(dpn): dofs[:, ic] = funs[ic](3 * (cc[:, 0] * cc[:, 1])) vmesh, vdofs, levels = field.linearize(dofs, min_level=0, max_level=3, eps=1e-2) level = levels[0] if approx_order == 1: _ok = level == 0 else: _ok = level > 0 self.report('max. refinement level: %d: %s' % (level, _ok)) ok = ok and _ok rdofs = nm.zeros((vmesh.n_nod, dpn), dtype=nm.float64) cc = vmesh.coors for ic in range(dpn): rdofs[:, ic] = funs[ic](3 * (cc[:, 0] * cc[:, 1])) _ok = nm.allclose(rdofs, vdofs, rtol=0.0, atol=0.03) self.report('interpolation: %s' % _ok) ok = ok and _ok out = { 'u': Struct(name='output_data', mode='vertex', data=vdofs, var_name='u', dofs=None) } name = self.join('linearizer-%s-%d-%d' % (geometry, approx_order, dpn)) vmesh.write(name + '.mesh') vmesh.write(name + '.vtk', out=out) return ok
def main(): parser = OptionParser(usage=usage, version="%prog") parser.add_option( "-b", "--basis", metavar="name", action="store", dest="basis", default="lagrange", help=help["basis"] ) parser.add_option( "-n", "--max-order", metavar="order", type=int, action="store", dest="max_order", default=10, help=help["max_order"], ) parser.add_option( "-m", "--matrix", metavar="type", action="store", dest="matrix_type", default="laplace", help=help["matrix_type"], ) parser.add_option( "-g", "--geometry", metavar="name", action="store", dest="geometry", default="2_4", help=help["geometry"] ) options, args = parser.parse_args() dim, n_ep = int(options.geometry[0]), int(options.geometry[2]) output("reference element geometry:") output(" dimension: %d, vertices: %d" % (dim, n_ep)) n_c = {"laplace": 1, "elasticity": dim}[options.matrix_type] output("matrix type:", options.matrix_type) output("number of variable components:", n_c) output("polynomial space:", options.basis) output("max. order:", options.max_order) mesh = Mesh.from_file(data_dir + "/meshes/elements/%s_1.mesh" % options.geometry) domain = Domain("domain", mesh) omega = domain.create_region("Omega", "all") orders = nm.arange(1, options.max_order + 1, dtype=nm.int) conds = [] order_fix = 0 if options.geometry in ["2_4", "3_8"] else 1 for order in orders: output("order:", order, "...") field = Field.from_args( "fu", nm.float64, n_c, omega, approx_order=order, space="H1", poly_space_base=options.basis ) to = field.approx_order quad_order = 2 * (max(to - order_fix, 0)) output("quadrature order:", quad_order) integral = Integral("i", order=quad_order) qp, _ = integral.get_qp(options.geometry) output("number of quadrature points:", qp.shape[0]) u = FieldVariable("u", "unknown", field, n_c) v = FieldVariable("v", "test", field, n_c, primary_var_name="u") m = Material("m", lam=1.0, mu=1.0) if options.matrix_type == "laplace": term = Term.new("dw_laplace(m.mu, v, u)", integral, omega, m=m, v=v, u=u) n_zero = 1 else: assert_(options.matrix_type == "elasticity") term = Term.new("dw_lin_elastic_iso(m.lam, m.mu, v, u)", integral, omega, m=m, v=v, u=u) n_zero = (dim + 1) * dim / 2 term.setup() output("assembling...") tt = time.clock() mtx, iels = term.evaluate(mode="weak", diff_var="u") output("...done in %.2f s" % (time.clock() - tt)) mtx = mtx[0][0, 0] try: assert_(nm.max(nm.abs(mtx - mtx.T)) < 1e-10) except: from sfepy.base.base import debug debug() output("matrix shape:", mtx.shape) eigs = eig(mtx, method="eig.sgscipy", eigenvectors=False) eigs.sort() # Zero 'true' zeros. eigs[:n_zero] = 0.0 ii = nm.where(eigs < 0.0)[0] if len(ii): output("matrix is not positive semi-definite!") ii = nm.where(eigs[n_zero:] < 1e-12)[0] if len(ii): output("matrix has more than %d zero eigenvalues!" % n_zero) output("smallest eigs:\n", eigs[:10]) ii = nm.where(eigs > 0.0)[0] emin, emax = eigs[ii[[0, -1]]] output("min:", emin, "max:", emax) cond = emax / emin conds.append(cond) output("condition number:", cond) output("...done") plt.figure(1) plt.semilogy(orders, conds) plt.xticks(orders, orders) plt.xlabel("polynomial order") plt.ylabel("condition number") plt.grid() plt.figure(2) plt.loglog(orders, conds) plt.xticks(orders, orders) plt.xlabel("polynomial order") plt.ylabel("condition number") plt.grid() plt.show()
def main(): parser = OptionParser(usage=usage) parser.add_option('-s', '--scale', metavar='scale', action='store', dest='scale', default=None, help=help['scale']) parser.add_option('-c', '--center', metavar='center', action='store', dest='center', default=None, help=help['center']) parser.add_option('-r', '--refine', metavar='level', action='store', type=int, dest='refine', default=0, help=help['refine']) parser.add_option('-f', '--format', metavar='format', action='store', type='string', dest='format', default=None, help=help['format']) parser.add_option('-l', '--list', action='store_true', dest='list', help=help['list']) (options, args) = parser.parse_args() if options.list: output_writable_meshes() sys.exit(0) if len(args) != 2: parser.print_help() sys.exit(1) scale = _parse_val_or_vec(options.scale, 'scale', parser) center = _parse_val_or_vec(options.center, 'center', parser) filename_in, filename_out = args mesh = Mesh.from_file(filename_in) if scale is not None: if len(scale) == 1: tr = nm.eye(mesh.dim, dtype=nm.float64) * scale elif len(scale) == mesh.dim: tr = nm.diag(scale) else: raise ValueError('bad scale! (%s)' % scale) mesh.transform_coors(tr) if center is not None: cc = 0.5 * mesh.get_bounding_box().sum(0) shift = center - cc tr = nm.c_[nm.eye(mesh.dim, dtype=nm.float64), shift[:, None]] mesh.transform_coors(tr) if options.refine > 0: domain = Domain(mesh.name, mesh) output('initial mesh: %d nodes %d elements' % (domain.shape.n_nod, domain.shape.n_el)) for ii in range(options.refine): output('refine %d...' % ii) domain = domain.refine() output('... %d nodes %d elements' % (domain.shape.n_nod, domain.shape.n_el)) mesh = domain.mesh io = MeshIO.for_format(filename_out, format=options.format, writable=True) output('writing %s...' % filename_out) mesh.write(filename_out, io=io) output('...done')