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 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 do_interpolation(m2, m1, data, field_name, force=False): """Interpolate data from m1 to m2. """ from sfepy.discrete import Variables from sfepy.discrete.fem import FEDomain, Field fields = { 'scalar_si': ((1, 1), 'Omega', 2), 'vector_si': ((3, 1), 'Omega', 2), 'scalar_tp': ((1, 1), 'Omega', 1), 'vector_tp': ((3, 1), 'Omega', 1), } d1 = FEDomain('d1', m1) omega1 = d1.create_region('Omega', 'all') f = fields[field_name] field1 = Field.from_args('f', nm.float64, f[0], d1.regions[f[1]], approx_order=f[2]) ff = {field1.name: field1} vv = Variables.from_conf(transform_variables(variables), ff) u1 = vv['u'] u1.set_from_mesh_vertices(data) d2 = FEDomain('d2', m2) omega2 = d2.create_region('Omega', 'all') field2 = Field.from_args('f', nm.float64, f[0], d2.regions[f[1]], approx_order=f[2]) ff2 = {field2.name: field2} vv2 = Variables.from_conf(transform_variables(variables), ff2) u2 = vv2['u'] if not force: # 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.5) else: coors = u2.field.get_coor() vals = u1.evaluate_at(coors, close_limit=0.5) u2.set_data(vals) return u1, u2
def prepare_dgfield(approx_order, mesh): domain = FEDomain("test_domain", mesh) omega = domain.create_region('Omega', 'all') regions = {} if mesh.dim > 1: left = domain.create_region('left', 'vertices in x == 0', 'edge') right = domain.create_region('right', 'vertices in x == 1', 'edge') bottom = domain.create_region('bottom', 'vertices in y == 0', 'edge') top = domain.create_region('top', 'vertices in y == 1', 'edge') regions.update({"top": top, "bottom": bottom}) else: left = domain.create_region('left', 'vertices in x == 0', 'vertex') right = domain.create_region('right', 'vertices in x == 1', 'vertex') regions.update({"left": left, "right": right, "omega" : omega}) field = DGField('dgfu', nm.float64, 'scalar', omega, approx_order=approx_order) return field, regions
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 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_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 _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_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 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 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 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 main(): parser = ArgumentParser(description=__doc__, formatter_class=RawDescriptionHelpFormatter) parser.add_argument('--version', action='version', version='%(prog)s') parser.add_argument('-d', '--dims', metavar='dims', action='store', dest='dims', default='[1.0, 1.0]', help=helps['dims']) parser.add_argument('-c', '--centre', metavar='centre', action='store', dest='centre', default='[0.0, 0.0]', help=helps['centre']) parser.add_argument('-s', '--shape', metavar='shape', action='store', dest='shape', default='[11, 11]', help=helps['shape']) parser.add_argument('--show', action="store_true", dest='show', default=False, help=helps['show']) options = parser.parse_args() dims = nm.array(eval(options.dims), dtype=nm.float64) centre = nm.array(eval(options.centre), dtype=nm.float64) shape = nm.array(eval(options.shape), dtype=nm.int32) output('dimensions:', dims) output('centre: ', centre) output('shape: ', shape) mesh = gen_block_mesh(dims, shape, centre, name='block-fem') fe_domain = FEDomain('domain', mesh) pb, state = run(fe_domain, 1) pb.save_state('laplace_shifted_periodic.vtk', state) if options.show: from sfepy.postprocess.viewer import Viewer from sfepy.postprocess.domain_specific import DomainSpecificPlot view = Viewer('laplace_shifted_periodic.vtk') view(rel_scaling=1, domain_specific={ 'u': DomainSpecificPlot('plot_warp_scalar', ['rel_scaling=1']) }, is_scalar_bar=True, is_wireframe=True, opacity=0.3)
def test_projection_iga_fem(self): from sfepy.discrete import FieldVariable from sfepy.discrete.fem import FEDomain, Field from sfepy.discrete.iga.domain import IGDomain from sfepy.mesh.mesh_generators import gen_block_mesh from sfepy.discrete.iga.domain_generators import gen_patch_block_domain from sfepy.discrete.projections import (make_l2_projection, make_l2_projection_data) shape = [10, 12, 12] dims = [5, 6, 6] centre = [0, 0, 0] degrees = [2, 2, 2] nurbs, bmesh, regions = gen_patch_block_domain(dims, shape, centre, degrees, cp_mode='greville', name='iga') ig_domain = IGDomain('iga', nurbs, bmesh, regions=regions) ig_omega = ig_domain.create_region('Omega', 'all') ig_field = Field.from_args('iga', nm.float64, 1, ig_omega, approx_order='iga', poly_space_base='iga') ig_u = FieldVariable('ig_u', 'parameter', ig_field, primary_var_name='(set-to-None)') mesh = gen_block_mesh(dims, shape, centre, name='fem') fe_domain = FEDomain('fem', mesh) fe_omega = fe_domain.create_region('Omega', 'all') fe_field = Field.from_args('fem', nm.float64, 1, fe_omega, approx_order=2) fe_u = FieldVariable('fe_u', 'parameter', fe_field, primary_var_name='(set-to-None)') def _eval_data(ts, coors, mode, **kwargs): return nm.prod(coors**2, axis=1)[:, None, None] make_l2_projection_data(ig_u, _eval_data) make_l2_projection(fe_u, ig_u) # This calls ig_u.evaluate_at(). coors = 0.5 * nm.random.rand(20, 3) * dims ig_vals = ig_u.evaluate_at(coors) fe_vals = fe_u.evaluate_at(coors) ok = nm.allclose(ig_vals, fe_vals, rtol=0.0, atol=1e-12) if not ok: self.report('iga-fem projection failed!') self.report('coors:') self.report(coors) self.report('iga fem diff:') self.report(nm.c_[ig_vals, fe_vals, nm.abs(ig_vals - fe_vals)]) return ok
def from_conf(conf, options): mesh = Mesh.from_file('meshes/2d/square_unit_tri.mesh', prefix_dir=sfepy.data_dir) domain = FEDomain('domain', mesh) omega = domain.create_region('Omega', 'all') field = Field.from_args('linear', nm.float64, 'scalar', omega, approx_order=1) test = Test(conf=conf, options=options, omega=omega, field=field) return test
def test_evaluate_at(self): from sfepy import data_dir from sfepy.discrete.fem import Mesh from sfepy.discrete import Variables from sfepy.discrete.fem import FEDomain, Field meshes = { 'tp': Mesh.from_file(data_dir + '/meshes/3d/block.mesh'), } datas = gen_datas(meshes) fields = { 'scalar_tp': ((1, 1), 'Omega', 1), 'vector_tp': ((3, 1), 'Omega', 1), } ok = True for field_name in ['scalar_tp', 'vector_tp']: d = FEDomain('d', meshes['tp']) d.create_region('Omega', 'all') f = fields[field_name] field = Field.from_args('f', nm.complex128, f[0], d.regions[f[1]], approx_order=f[2]) ff = {field.name: field} vv = Variables.from_conf(transform_variables(variables), ff) u = vv['u'] bbox = d.get_mesh_bounding_box() t = nm.expand_dims(nm.linspace(0, 1, 100), 1) coors = nm.expand_dims(bbox[1] - bbox[0], 0) * t + bbox[0] data_r = datas[field_name] data_i = 2. / (1 + datas[field_name]) u.set_from_mesh_vertices(data_r) vals_r = u.evaluate_at(coors) u.set_from_mesh_vertices(data_i) vals_i = u.evaluate_at(coors) u.set_from_mesh_vertices(data_r + data_i * 1j) vals = u.evaluate_at(coors) _ok = nm.allclose(vals_r + vals_i * 1j, vals, rtol=0.0, atol=1e-12) _ok = _ok and nm.abs(vals).sum() > 1 self.report('evaluating complex field %s: %s' % (field_name, _ok)) ok = ok and _ok return ok
def test_normals(self): """ Check orientations of surface normals on the reference elements. """ import sfepy from sfepy.discrete import Integral from sfepy.discrete.fem import Mesh, FEDomain from sfepy.discrete.fem.poly_spaces import PolySpace from sfepy.discrete.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 = FEDomain('domain', mesh) surface = domain.create_region('Surface', 'vertices of surface', 'facet') domain.create_surface_group(surface) sd = domain.surface_groups[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 make_domain(dims, shape, transform=None): """ Generate a 2D rectangle domain in 3D space, define regions. """ xmin = (-0.5 + 1e-12) * dims[0] xmax = (0.5 - 1e-12) * dims[0] mesh = make_mesh(dims, shape, transform=transform) domain = FEDomain('domain', mesh) domain.create_region('Omega', 'all') domain.create_region('Gamma1', 'vertices in (x < %.14f)' % xmin, 'facet') domain.create_region('Gamma2', 'vertices in (x > %.14f)' % xmax, 'facet') return domain
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 = 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_projection_tri_quad(self): from sfepy.discrete.projections import make_l2_projection source = FieldVariable('us', 'unknown', self.field) coors = self.field.get_coor() vals = nm.sin(2.0 * nm.pi * coors[:, 0] * coors[:, 1]) source.set_data(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 = FEDomain('domain', mesh) omega = domain.create_region('Omega', 'all') field = Field.from_args('bilinear', nm.float64, 'scalar', omega, approx_order=1) target = FieldVariable('ut', 'unknown', field) 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 import data_dir from sfepy.discrete.fem import Mesh, FEDomain from sfepy.discrete import Functions mesh = Mesh.from_file(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 mesh_hook(mesh, mode): """ Load and refine a mesh here. """ if mode == 'read': mesh = Mesh.from_file(base_mesh) domain = FEDomain(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 linear_projection(pb, cval): from sfepy.discrete import (FieldVariable, Material, Integral, Equation, Equations, Problem) from sfepy.discrete.fem import Mesh, FEDomain, Field from sfepy.terms import Term from sfepy.solvers.ls import ScipyDirect from sfepy.solvers.nls import Newton from sfepy.base.base import IndexedStruct mesh = Mesh.from_file(pb.conf.filename_mesh) domain = FEDomain('domain', mesh) omega = domain.create_region('Omega', 'all') field = Field.from_args('scf', nm.float64, 'scalar', omega, approx_order=1) g = FieldVariable('g', 'unknown', field) f = FieldVariable('f', 'test', field, primary_var_name='g') integral = Integral('i', order=2) m = Material('m', function=set_grad) t1 = Term.new('dw_volume_dot(f, g)', integral, omega, f=f, g=g) t2 = Term.new('dw_volume_lvf(m.cs, f)', integral, omega, m=m, f=f) eq = Equation('balance', t1 - t2) eqs = Equations([eq]) ls = ScipyDirect({}) nls_status = IndexedStruct() nls = Newton({'eps_a': 1e-15}, lin_solver=ls, status=nls_status) pb = Problem('elasticity', equations=eqs) pb.set_solver(nls) out = nm.empty((g.n_dof, cval.shape[2]), dtype=nm.float64) for ii in range(cval.shape[2]): pb.data = nm.ascontiguousarray(cval[:, :, ii, :]) pb.time_update() state = pb.solve() out[:, ii] = state.get_parts()['g'] return out
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 = FEDomain('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_laplace_shifted_periodic(self): import numpy as nm from sfepy.mesh.mesh_generators import gen_block_mesh from sfepy.discrete.fem import FEDomain from examples.diffusion.laplace_shifted_periodic import run dims = [2.0, 1.0] shape = [21, 11] centre = [0.0, 0.0] mesh = gen_block_mesh(dims, shape, centre, name='block-fem') fe_domain = FEDomain('domain', mesh) pb, state = run(fe_domain, 3) gamma3 = pb.domain.regions['Gamma3'] gamma4 = pb.domain.regions['Gamma4'] field = pb.fields['fu'] # Check that the shift equals to one. i3 = field.get_dofs_in_region(gamma3, merge=True) i4 = field.get_dofs_in_region(gamma4, merge=True) i_corners = nm.array([0, shape[0] - 1]) ii = nm.setdiff1d(nm.arange(len(i3)), i_corners) vals = state() shift = vals[i3] - vals[i4] ok = (shift[i_corners] == 0.0).all() ok = ok and nm.allclose(shift[ii], 1.0, rtol=0.0, atol=1e-14) if not ok: self.report('wrong shift:', shift) return ok
def save_basis_on_mesh(mesh, options, output_dir, lin, permutations=None, suffix=''): if permutations is not None: mesh = mesh.copy() gel = GeometryElement(mesh.descs[0]) perms = gel.get_conn_permutations()[permutations] conn = mesh.cmesh.get_cell_conn() n_el, n_ep = conn.num, gel.n_vertex offsets = nm.arange(n_el) * n_ep conn.indices[:] = conn.indices.take((perms + offsets[:, None]).ravel()) domain = FEDomain('domain', mesh) 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) if options.plot_dofs: import sfepy.postprocess.plot_dofs as pd import sfepy.postprocess.plot_cmesh as pc ax = pc.plot_wireframe(None, mesh.cmesh) ax = pd.plot_global_dofs(ax, field.get_coor(), field.econn) ax = pd.plot_local_dofs(ax, field.get_coor(), field.econn) if options.dofs is not None: ax = pd.plot_nodes(ax, field.get_coor(), field.econn, field.poly_space.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%s.vtk' % (_format, suffix)) 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 ensure_path(name) out['u'].mesh.write(name, out=out) output('...done (%s)' % name)