def main(): parser = ArgumentParser(description=__doc__) parser.add_argument('--version', action='version', version = "%(prog)s") parser.add_argument('-o', metavar = 'filename', action = "store", dest = "output_filename", default = 'out.vtk', help = helps['filename']) parser.add_argument('-f', '--format', metavar='format', action='store', type=str, dest='format', default=None, help=helps['format']) parser.add_argument("-a", "--axis", metavar = 'axis', action = "store", dest = "axis", default = 'x', help = helps['axis']) parser.add_argument("-d", "--dims", metavar = 'dims', action = "store", dest = "dims", default = '[1.0, 1.0, 2.0, 2.0, 3.0]', help = helps['dims']) parser.add_argument("-s", "--shape", metavar = 'shape', action = "store", dest = "shape", default = '[11, 11, 11]', help = helps['shape']) parser.add_argument("-c", "--centre", metavar = 'centre', action = "store", dest = "centre", default = '[0.0, 0.0, 0.0]', help = helps['centre']) parser.add_argument("--force-hollow", action = "store_true", dest = "force_hollow", default = False, help = helps['force_hollow']) parser.add_argument("--is-open", action = "store_true", dest = "is_open", default = False, help = helps['is_open']) parser.add_argument("--open-angle", metavar = 'angle', type=float, action = "store", dest = "open_angle", default = '0.0', help = helps['open_angle']) parser.add_argument("--non-uniform", action = "store_true", dest = "non_uniform", default = False, help = helps['non_uniform']) options = parser.parse_args() import numpy as nm dims = eval("nm.array(%s, dtype = nm.float64)" % options.dims) shape = eval("nm.array(%s, dtype = nm.int32)" % options.shape) centre = eval("nm.array(%s, dtype = nm.float64)" % options.centre) print(dims) print(shape) print(centre) mesh = gen_cylinder_mesh(dims, shape, centre, axis=options.axis, force_hollow=options.force_hollow, is_open=options.is_open, open_angle=options.open_angle, non_uniform=options.non_uniform, name=options.output_filename) io = MeshIO.for_format(options.output_filename, format=options.format, writable=True) mesh.write(options.output_filename, io=io)
def main(): parser = ArgumentParser(description=__doc__) parser.add_argument('--version', action='version', version = "%(prog)s") parser.add_argument('-o', metavar = 'filename', action = "store", dest = "output_filename", default = 'out.vtk', help = help['filename']) parser.add_argument('-f', '--format', metavar='format', action='store', type=str, dest='format', default=None, help=help['format']) parser.add_argument("-a", "--axis", metavar = 'axis', action = "store", dest = "axis", default = 'x', help = help['axis']) parser.add_argument("-d", "--dims", metavar = 'dims', action = "store", dest = "dims", default = '[1.0, 1.0, 2.0, 2.0, 3.0]', help = help['dims']) parser.add_argument("-s", "--shape", metavar = 'shape', action = "store", dest = "shape", default = '[11, 11, 11]', help = help['shape']) parser.add_argument("-c", "--centre", metavar = 'centre', action = "store", dest = "centre", default = '[0.0, 0.0, 0.0]', help = help['centre']) parser.add_argument("--force-hollow", action = "store_true", dest = "force_hollow", default = False, help = help['force_hollow']) parser.add_argument("--is-open", action = "store_true", dest = "is_open", default = False, help = help['is_open']) parser.add_argument("--open-angle", metavar = 'angle', type=float, action = "store", dest = "open_angle", default = '0.0', help = help['open_angle']) parser.add_argument("--non-uniform", action = "store_true", dest = "non_uniform", default = False, help = help['non_uniform']) options = parser.parse_args() import numpy as nm dims = eval("nm.array(%s, dtype = nm.float64)" % options.dims) shape = eval("nm.array(%s, dtype = nm.int32)" % options.shape) centre = eval("nm.array(%s, dtype = nm.float64)" % options.centre) print(dims) print(shape) print(centre) mesh = gen_cylinder_mesh(dims, shape, centre, axis=options.axis, force_hollow=options.force_hollow, is_open=options.is_open, open_angle=options.open_angle, non_uniform=options.non_uniform, name=options.output_filename) io = MeshIO.for_format(options.output_filename, format=options.format, writable=True) mesh.write(options.output_filename, io=io)
def extract_times(filename): """ Read true time step data from individual time steps. Returns ------- steps : array The time steps. times : array The times of the time steps. nts : array The normalized times of the time steps, in [0, 1]. dts : array The true time deltas. """ io = MeshIO.any_from_filename(filename) steps, times, nts = io.read_times() dts = nm.ediff1d(times, to_end=0) return steps, times, nts, dts
def main(): parser = ArgumentParser(description=__doc__) parser.add_argument('--version', action='version', version='%(prog)s') parser.add_argument('-o', metavar='filename', action='store', dest='output_filename', default='out.vtk', help=helps['filename']) parser.add_argument('-f', '--format', metavar='format', action='store', type=str, dest='format', default=None, help=helps['format']) parser.add_argument('-d', '--dims', metavar='dims', action='store', dest='dims', default='[1.0, 1.0, 1.0]', help=helps['dims']) parser.add_argument('-s', '--shape', metavar='shape', action='store', dest='shape', default='[11, 11, 11]', help=helps['shape']) parser.add_argument('-c', '--centre', metavar='centre', action='store', dest='centre', default='[0.0, 0.0, 0.0]', help=helps['centre']) parser.add_argument('-2', '--2d', action='store_true', dest='is_2d', default=False, help=helps['2d']) options = parser.parse_args() dim = 2 if options.is_2d else 3 dims = nm.array(eval(options.dims), dtype=nm.float64)[:dim] shape = nm.array(eval(options.shape), dtype=nm.int32)[:dim] centre = nm.array(eval(options.centre), dtype=nm.float64)[:dim] output.prefix = 'blockgen:' output('dimensions:', dims) output('shape:', shape) output('centre:', centre) mesh = gen_block_mesh(dims, shape, centre, name=options.output_filename) io = MeshIO.for_format(options.output_filename, format=options.format, writable=True) mesh.write(options.output_filename, io=io)
def main(): parser = ArgumentParser(description=__doc__, formatter_class=RawDescriptionHelpFormatter) parser.add_argument('-s', '--scale', metavar='scale', action='store', dest='scale', default=None, help=helps['scale']) parser.add_argument('-c', '--center', metavar='center', action='store', dest='center', default=None, help=helps['center']) parser.add_argument('-r', '--refine', metavar='level', action='store', type=int, dest='refine', default=0, help=helps['refine']) parser.add_argument('-f', '--format', metavar='format', action='store', type=str, dest='format', default=None, help=helps['format']) parser.add_argument('-l', '--list', action='store_true', dest='list', help=helps['list']) parser.add_argument('-m', '--merge', action='store_true', dest='merge', help=helps['merge']) parser.add_argument('-t', '--tri-tetra', action='store_true', dest='tri_tetra', help=helps['tri-tetra']) parser.add_argument('filename_in') parser.add_argument('filename_out') options = parser.parse_args() if options.list: output('Supported readable mesh formats:') output('--------------------------------') output_mesh_formats('r') output('') output('Supported writable mesh formats:') output('--------------------------------') output_mesh_formats('w') sys.exit(0) scale = _parse_val_or_vec(options.scale, 'scale', parser) center = _parse_val_or_vec(options.center, 'center', parser) filename_in = options.filename_in filename_out = options.filename_out 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 = FEDomain(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 if options.tri_tetra > 0: conns = None for k, new_desc in [('3_8', '3_4'), ('2_4', '2_3')]: if k in mesh.descs: conns = mesh.get_conn(k) break if conns is not None: nelo = conns.shape[0] output('initial mesh: %d elements' % nelo) new_conns = elems_q2t(conns) nn = new_conns.shape[0] // nelo new_cgroups = nm.repeat(mesh.cmesh.cell_groups, nn) output('new mesh: %d elements' % new_conns.shape[0]) mesh = Mesh.from_data(mesh.name, mesh.coors, mesh.cmesh.vertex_groups, [new_conns], [new_cgroups], [new_desc]) if options.merge: desc = mesh.descs[0] coor, ngroups, conns = fix_double_nodes(mesh.coors, mesh.cmesh.vertex_groups, mesh.get_conn(desc), 1e-9) mesh = Mesh.from_data(mesh.name + '_merged', coor, ngroups, [conns], [mesh.cmesh.cell_groups], [desc]) io = MeshIO.for_format(filename_out, format=options.format, writable=True) cell_types = ', '.join(supported_cell_types[io.format]) output('writing [%s] %s...' % (cell_types, filename_out)) mesh.write(filename_out, io=io) output('...done')
def define(order=5, basis='lagrange', min_level=0, max_level=5, eps=1e-3): filename_mesh = UserMeshIO(mesh_hook) # Get the mesh bounding box. io = MeshIO.any_from_filename(base_mesh) bbox, dim = io.read_bounding_box(ret_dim=True) options = { 'nls': 'newton', 'ls': 'ls', 'post_process_hook': 'post_process', 'linearization': { 'kind': 'adaptive', 'min_level': min_level, # Min. refinement level applied everywhere. 'max_level': max_level, # Max. refinement level. 'eps': eps, # Relative error tolerance. }, } materials = { 'coef': ({ 'val': 1.0 }, ), } regions = { 'Omega': 'all', } regions.update(define_box_regions(dim, bbox[0], bbox[1], 1e-5)) fields = { 'temperature': ('real', 1, 'Omega', order, 'H1', basis), } variables = { 't': ('unknown field', 'temperature', 0), 's': ('test field', 'temperature', 't'), } amplitude = 1.0 def ebc_sin(ts, coor, **kwargs): x0 = 0.5 * (coor[:, 1].min() + coor[:, 1].max()) val = amplitude * nm.sin((coor[:, 1] - x0) * 2. * nm.pi) return val ebcs = { 't1': ('Left', { 't.0': 'ebc_sin' }), 't2': ('Right', { 't.0': -0.5 }), 't3': ('Top', { 't.0': 1.0 }), } functions = { 'ebc_sin': (ebc_sin, ), } equations = {'Temperature': """dw_laplace.10.Omega(coef.val, s, t) = 0"""} solvers = { 'ls': ('ls.scipy_direct', {}), 'newton': ('nls.newton', { 'i_max': 1, 'eps_a': 1e-10, }), } return locals()
from sfepy.discrete.fem.fields_base import create_expression_output aux = create_expression_output('ev_grad.ie.Elements( t )', 'grad', 'temperature', pb.fields, pb.get_materials(), pb.get_variables(), functions=pb.functions, mode='qp', verbose=False, min_level=0, max_level=5, eps=1e-3) out.update(aux) return out filename_mesh = UserMeshIO(mesh_hook) # Get the mesh bounding box. io = MeshIO.any_from_filename(base_mesh) bbox, dim = io.read_bounding_box(ret_dim=True) options = { 'nls' : 'newton', 'ls' : 'ls', 'post_process_hook' : 'post_process', 'linearization' : { 'kind' : 'adaptive', 'min_level' : 0, # Min. refinement level to achieve everywhere. 'max_level' : 5, # Max. refinement level. 'eps' : 1e-3, # Relative error tolerance. }, } materials = {
def get_step_range(self): if self.step_range is None: io = MeshIO.any_from_filename(self.filename) self.step_range = (0, io.read_last_step()) return self.step_range
def main(): parser = ArgumentParser(description=__doc__, formatter_class=RawDescriptionHelpFormatter) parser.add_argument('-s', '--scale', metavar='scale', action='store', dest='scale', default=None, help=helps['scale']) parser.add_argument('-c', '--center', metavar='center', action='store', dest='center', default=None, help=helps['center']) parser.add_argument('-r', '--refine', metavar='level', action='store', type=int, dest='refine', default=0, help=helps['refine']) parser.add_argument('-f', '--format', metavar='format', action='store', type=str, dest='format', default=None, help=helps['format']) parser.add_argument('-l', '--list', action='store_true', dest='list', help=helps['list']) parser.add_argument('-m', '--merge', action='store_true', dest='merge', help=helps['merge']) parser.add_argument('-t', '--tri-tetra', action='store_true', dest='tri_tetra', help=helps['tri-tetra']) parser.add_argument('-2', '--2d', action='store_true', dest='force_2d', help=helps['2d']) parser.add_argument('--save-per-mat', action='store_true', dest='save_per_mat', help=helps['save-per-mat']) parser.add_argument('--remesh', metavar='options', action='store', dest='remesh', default=None, help=helps['remesh']) parser.add_argument('filename_in') parser.add_argument('filename_out') options = parser.parse_args() if options.list: output('Supported readable mesh formats:') output('--------------------------------') output_mesh_formats('r') output('') output('Supported writable mesh formats:') output('--------------------------------') output_mesh_formats('w') sys.exit(0) scale = _parse_val_or_vec(options.scale, 'scale', parser) center = _parse_val_or_vec(options.center, 'center', parser) filename_in = options.filename_in filename_out = options.filename_out if options.remesh: import tempfile import shlex import subprocess dirname = tempfile.mkdtemp() is_surface = options.remesh.startswith('q') if is_surface: mesh = Mesh.from_file(filename_in) domain = FEDomain(mesh.name, mesh) region = domain.create_region('surf', 'vertices of surface', 'facet') surf_mesh = Mesh.from_region(region, mesh, localize=True, is_surface=True) filename = op.join(dirname, 'surf.mesh') surf_mesh.write(filename, io='auto') else: import shutil shutil.copy(filename_in, dirname) filename = op.join(dirname, op.basename(filename_in)) qopts = ''.join(options.remesh.split()) # Remove spaces. command = 'tetgen -BFENkACp%s %s' % (qopts, filename) args = shlex.split(command) subprocess.call(args) root, ext = op.splitext(filename) mesh = Mesh.from_file(root + '.1.vtk') remove_files(dirname) else: mesh = Mesh.from_file(filename_in) if options.force_2d: data = list(mesh._get_io_data()) data[0] = data[0][:, :2] mesh = Mesh.from_data(mesh.name, *data) 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 = FEDomain(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 if options.tri_tetra > 0: mesh = triangulate(mesh, verbose=True) if options.merge: desc = mesh.descs[0] coor, ngroups, conns = fix_double_nodes(mesh.coors, mesh.cmesh.vertex_groups, mesh.get_conn(desc)) mesh = Mesh.from_data(mesh.name + '_merged', coor, ngroups, [conns], [mesh.cmesh.cell_groups], [desc]) if options.save_per_mat: desc = mesh.descs[0] conns, cgroups = mesh.get_conn(desc), mesh.cmesh.cell_groups coors, ngroups = mesh.coors, mesh.cmesh.vertex_groups mat_ids = nm.unique(cgroups) for mat_id in mat_ids: idxs = nm.where(cgroups == mat_id)[0] imesh = Mesh.from_data(mesh.name + '_matid_%d' % mat_id, coors, ngroups, [conns[idxs]], [cgroups[idxs]], [desc]) fbase, fext = op.splitext(filename_out) ifilename_out = '%s_matid_%d%s' % (fbase, mat_id, fext) io = MeshIO.for_format(ifilename_out, format=options.format, writable=True) output('writing %s...' % ifilename_out) imesh.write(ifilename_out, io=io) output('...done') io = MeshIO.for_format(filename_out, format=options.format, writable=True) cell_types = ', '.join(supported_cell_types[io.format]) output('writing [%s] %s...' % (cell_types, filename_out)) mesh.write(filename_out, io=io) output('...done')
def main(): parser = ArgumentParser(description=__doc__, formatter_class=RawDescriptionHelpFormatter) parser.add_argument('-s', '--scale', metavar='scale', action='store', dest='scale', default=None, help=helps['scale']) parser.add_argument('-c', '--center', metavar='center', action='store', dest='center', default=None, help=helps['center']) parser.add_argument('-r', '--refine', metavar='level', action='store', type=int, dest='refine', default=0, help=helps['refine']) parser.add_argument('-f', '--format', metavar='format', action='store', type=str, dest='format', default=None, help=helps['format']) parser.add_argument('-l', '--list', action='store_true', dest='list', help=helps['list']) parser.add_argument('-m', '--merge', action='store_true', dest='merge', help=helps['merge']) parser.add_argument('-t', '--tri-tetra', action='store_true', dest='tri_tetra', help=helps['tri-tetra']) parser.add_argument('-2', '--2d', action='store_true', dest='force_2d', help=helps['2d']) parser.add_argument('--save-per-mat', action='store_true', dest='save_per_mat', help=helps['save-per-mat']) parser.add_argument('--remesh', metavar='options', action='store', dest='remesh', default=None, help=helps['remesh']) parser.add_argument('filename_in') parser.add_argument('filename_out') options = parser.parse_args() if options.list: output('Supported readable mesh formats:') output('--------------------------------') output_mesh_formats('r') output('') output('Supported writable mesh formats:') output('--------------------------------') output_mesh_formats('w') sys.exit(0) scale = _parse_val_or_vec(options.scale, 'scale', parser) center = _parse_val_or_vec(options.center, 'center', parser) filename_in = options.filename_in filename_out = options.filename_out if options.remesh: import tempfile import shlex import subprocess dirname = tempfile.mkdtemp() is_surface = options.remesh.startswith('q') if is_surface: mesh = Mesh.from_file(filename_in) domain = FEDomain(mesh.name, mesh) region = domain.create_region('surf', 'vertices of surface', 'facet') surf_mesh = Mesh.from_region(region, mesh, localize=True, is_surface=True) filename = op.join(dirname, 'surf.mesh') surf_mesh.write(filename, io='auto') else: import shutil shutil.copy(filename_in, dirname) filename = op.join(dirname, op.basename(filename_in)) qopts = ''.join(options.remesh.split()) # Remove spaces. command = 'tetgen -BFENkACp%s %s' % (qopts, filename) args = shlex.split(command) subprocess.call(args) root, ext = op.splitext(filename) mesh = Mesh.from_file(root + '.1.vtk') remove_files(dirname) else: mesh = Mesh.from_file(filename_in) if options.force_2d: data = list(mesh._get_io_data()) data[0] = data[0][:, :2] mesh = Mesh.from_data(mesh.name, *data) 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 = FEDomain(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 if options.tri_tetra > 0: conns = None for k, new_desc in [('3_8', '3_4'), ('2_4', '2_3')]: if k in mesh.descs: conns = mesh.get_conn(k) break if conns is not None: nelo = conns.shape[0] output('initial mesh: %d elements' % nelo) new_conns = elems_q2t(conns) nn = new_conns.shape[0] // nelo new_cgroups = nm.repeat(mesh.cmesh.cell_groups, nn) output('new mesh: %d elements' % new_conns.shape[0]) mesh = Mesh.from_data(mesh.name, mesh.coors, mesh.cmesh.vertex_groups, [new_conns], [new_cgroups], [new_desc]) if options.merge: desc = mesh.descs[0] coor, ngroups, conns = fix_double_nodes(mesh.coors, mesh.cmesh.vertex_groups, mesh.get_conn(desc), 1e-9) mesh = Mesh.from_data(mesh.name + '_merged', coor, ngroups, [conns], [mesh.cmesh.cell_groups], [desc]) if options.save_per_mat: desc = mesh.descs[0] conns, cgroups = mesh.get_conn(desc), mesh.cmesh.cell_groups coors, ngroups = mesh.coors, mesh.cmesh.vertex_groups mat_ids = nm.unique(cgroups) for mat_id in mat_ids: idxs = nm.where(cgroups == mat_id)[0] imesh = Mesh.from_data(mesh.name + '_matid_%d' % mat_id, coors, ngroups, [conns[idxs]], [cgroups[idxs]], [desc]) fbase, fext = op.splitext(filename_out) ifilename_out = '%s_matid_%d%s' % (fbase, mat_id, fext) io = MeshIO.for_format(ifilename_out, format=options.format, writable=True) output('writing %s...' % ifilename_out) imesh.write(ifilename_out, io=io) output('...done') io = MeshIO.for_format(filename_out, format=options.format, writable=True) cell_types = ', '.join(supported_cell_types[io.format]) output('writing [%s] %s...' % (cell_types, filename_out)) mesh.write(filename_out, io=io) output('...done')
def read_mesh(filenames, step=None, print_info=True, ret_n_steps=False): _, ext = osp.splitext(filenames[0]) if ext in ['.vtk', '.vtu']: fstep = 0 if step is None else step fname = filenames[fstep] key = (fname, fstep) if key not in cache: cache[key] = pv.UnstructuredGrid(fname) mesh = cache[key] cache['n_steps'] = len(filenames) elif ext in ['.xdmf', '.xdmf3']: import meshio from meshio._common import meshio_to_vtk_type fname = filenames[0] key = (fname, step) if key not in cache: reader = meshio.xdmf.TimeSeriesReader(fname) points, _cells = reader.read_points_cells() cells, cell_type, offset = make_cells_from_conn( _cells, meshio_to_vtk_type, ) grids = {} time = [] for _step in range(reader.num_steps): grid = pv.UnstructuredGrid(offset, cells, cell_type, points) t, pd, cd = reader.read_data(_step) for dk, dv in pd.items(): val = numpy_to_vtk(dv) val.SetName(dk) grid.GetPointData().AddArray(val) for dk, dv in cd.items(): val = numpy_to_vtk(nm.vstack(dv).squeeze()) val.SetName(dk) grid.GetCellData().AddArray(val) grids[t] = grid time.append(t) time.sort() for _step, t in enumerate(time): cache[(fname, _step)] = grids[t] cache[(fname, None)] = cache[(fname, 0)] cache['n_steps'] = reader.num_steps mesh = cache[key] elif ext in ['.h5', '.h5x']: vtk_cell_types = { '1_1': 1, '1_2': 3, '2_2': 3, '3_2': 3, '2_3': 5, '2_4': 9, '3_4': 10, '3_8': 12 } # Custom sfepy format. fname = filenames[0] key = (fname, step) if key not in cache: from sfepy.discrete.fem.meshio import MeshIO io = MeshIO.any_from_filename(fname) mesh = io.read() desc = mesh.descs[0] nv, dim = mesh.coors.shape points = nm.c_[mesh.coors, nm.zeros((nv, 3 - dim))] cells, cell_type, offset = make_cells_from_conn( {desc: mesh.get_conn(desc)}, vtk_cell_types, ) steps, times, nts = io.read_times() for ii, _step in enumerate(steps): grid = pv.UnstructuredGrid(offset, cells, cell_type, points) datas = io.read_data(_step) for dk, data in datas.items(): vval = data.data if 1 < len(data.dofs) < 3: vval = nm.c_[vval, nm.zeros((len(vval), 3 - len(data.dofs)))] if data.mode == 'vertex': val = numpy_to_vtk(vval) val.SetName(dk) grid.GetPointData().AddArray(val) else: val = numpy_to_vtk(vval[:, 0, :, 0]) val.SetName(dk) grid.GetCellData().AddArray(val) cache[(fname, ii)] = grid cache[(fname, None)] = cache[(fname, 0)] cache['n_steps'] = len(steps) mesh = cache[key] else: raise ValueError('unknown file format! (%s)' % ext) if print_info: arrs = {'s': [], 'v': [], 'o': []} for aname in mesh.array_names: if len(mesh[aname].shape) == 1 or mesh[aname].shape[1] == 1: arrs['s'].append(aname) elif mesh[aname].shape[1] == 3: arrs['v'].append(aname) else: arrs['o'].append(aname + '(%d)' % mesh[aname].shape[1]) step_info = ' (step %d)' % step if step else '' print('mesh from %s%s:' % (fname, step_info)) print(' points: %d' % mesh.n_points) print(' cells: %d' % mesh.n_cells) print(' bounds: %s' % list( zip(nm.min(mesh.points, axis=0), nm.max(mesh.points, axis=0)))) if len(arrs['s']) > 0: print(' scalars: %s' % ', '.join(arrs['s'])) if len(arrs['v']) > 0: print(' vectors: %s' % ', '.join(arrs['v'])) if len(arrs['o']) > 0: print(' others: %s' % ', '.join(arrs['o'])) print(' steps: %d' % cache['n_steps']) if ret_n_steps: return mesh, cache['n_steps'] else: return mesh
def main(): parser = ArgumentParser(description=__doc__, formatter_class=RawDescriptionHelpFormatter) parser.add_argument('-s', '--scale', metavar='scale', action='store', dest='scale', default=None, help=help['scale']) parser.add_argument('-c', '--center', metavar='center', action='store', dest='center', default=None, help=help['center']) parser.add_argument('-r', '--refine', metavar='level', action='store', type=int, dest='refine', default=0, help=help['refine']) parser.add_argument('-f', '--format', metavar='format', action='store', type=str, dest='format', default=None, help=help['format']) parser.add_argument('-l', '--list', action='store_true', dest='list', help=help['list']) parser.add_argument('filename_in') parser.add_argument('filename_out') options = parser.parse_args() if options.list: output('Supported readable mesh formats:') output('--------------------------------') output_mesh_formats('r') output('') output('Supported writable mesh formats:') output('--------------------------------') output_mesh_formats('w') sys.exit(0) scale = _parse_val_or_vec(options.scale, 'scale', parser) center = _parse_val_or_vec(options.center, 'center', parser) filename_in = options.filename_in filename_out = options.filename_out 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 = FEDomain(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) cell_types = ', '.join(supported_cell_types[io.format]) output('writing [%s] %s...' % (cell_types, filename_out)) mesh.write(filename_out, io=io) output('...done')
pb.get_variables(), functions=pb.functions, mode='qp', verbose=False, min_level=0, max_level=5, eps=1e-3) out.update(aux) return out filename_mesh = UserMeshIO(mesh_hook) # Get the mesh bounding box. io = MeshIO.any_from_filename(base_mesh) bbox, dim = io.read_bounding_box(ret_dim=True) options = { 'nls': 'newton', 'ls': 'ls', 'post_process_hook': 'post_process', 'linearization': { 'kind': 'adaptive', 'min_level': 0, # Min. refinement level to achieve everywhere. 'max_level': 5, # Max. refinement level. 'eps': 1e-3, # Relative error tolerance. }, } materials = {
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('Supported readable mesh formats:') output('--------------------------------') output_mesh_formats('r') output('') output('Supported writable mesh formats:') output('--------------------------------') output_mesh_formats('w') 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 = FEDomain(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) cell_types = ', '.join(supported_cell_types[io.format]) output('writing [%s] %s...' % (cell_types, filename_out)) mesh.write(filename_out, io=io) output('...done')
def main(): parser = ArgumentParser(description=__doc__) parser.add_argument('--version', action='version', version='%(prog)s') parser.add_argument('-o', metavar='filename', action='store', dest='output_filename', default='out.vtk', help=help['filename']) parser.add_argument('-f', '--format', metavar='format', action='store', type=str, dest='format', default=None, help=help['format']) parser.add_argument('-d', '--dims', metavar='dims', action='store', dest='dims', default='[1.0, 1.0, 1.0]', help=help['dims']) parser.add_argument('-s', '--shape', metavar='shape', action='store', dest='shape', default='[11, 11, 11]', help=help['shape']) parser.add_argument('-c', '--centre', metavar='centre', action='store', dest='centre', default='[0.0, 0.0, 0.0]', help=help['centre']) parser.add_argument('-2', '--2d', action='store_true', dest='is_2d', default=False, help=help['2d']) options = parser.parse_args() dim = 2 if options.is_2d else 3 dims = nm.array(eval(options.dims), dtype=nm.float64)[:dim] shape = nm.array(eval(options.shape), dtype=nm.int32)[:dim] centre = nm.array(eval(options.centre), dtype=nm.float64)[:dim] output.prefix = 'blockgen:' output('dimensions:', dims) output('shape:', shape) output('centre:', centre) mesh = gen_block_mesh(dims, shape, centre, name=options.output_filename) io = MeshIO.for_format(options.output_filename, format=options.format, writable=True) mesh.write(options.output_filename, io=io)
def read_common(self, filename): self.io = MeshIO.any_from_filename(filename) self.steps, self.times, _ = self.io.read_times() self.mesh = Mesh.from_file(filename) self.n_nod, self.dim = self.mesh.coors.shape
def extract_time_history(filename, extract, verbose=True): """Extract time history of a variable from a multi-time-step results file. Parameters ---------- filename : str The name of file to extract from. extract : str The description of what to extract in a string of comma-separated description items. A description item consists of: name of the variable to extract, mode ('e' for elements, 'n' for nodes), ids of the nodes or elements (given by the mode). Example: 'u n 10 15, p e 0' means variable 'u' in nodes 10, 15 and variable 'p' in element 0. verbose : bool Verbosity control. Returns ------- ths : dict The time histories in a dict with variable names as keys. If a nodal variable is requested in elements, its value is a dict of histories in the element nodes. ts : TimeStepper instance The time stepping information. """ output('extracting selected data...', verbose=verbose) output('selection:', extract, verbose=verbose) ## # Parse extractions. pes = OneTypeList(Struct) for chunk in extract.split(','): aux = chunk.strip().split() pes.append(Struct(var = aux[0], mode = aux[1], indx = map(int, aux[2:]), igs = None)) ## # Verify array limits, set igs for element data, shift indx. mesh = Mesh.from_file(filename) n_el, n_els, offs = mesh.n_el, mesh.n_els, mesh.el_offsets for pe in pes: if pe.mode == 'n': for ii in pe.indx: if (ii < 0) or (ii >= mesh.n_nod): raise ValueError('node index 0 <= %d < %d!' % (ii, mesh.n_nod)) if pe.mode == 'e': pe.igs = [] for ii, ie in enumerate(pe.indx[:]): if (ie < 0) or (ie >= n_el): raise ValueError('element index 0 <= %d < %d!' % (ie, n_el)) ig = (ie < n_els).argmax() pe.igs.append(ig) pe.indx[ii] = ie - offs[ig] ## print pes ## # Extract data. # Assumes only one element group (ignores igs)! io = MeshIO.any_from_filename(filename) ths = {} for pe in pes: mode, nname = io.read_data_header(pe.var) output(mode, nname, verbose=verbose) if ((pe.mode == 'n' and mode == 'vertex') or (pe.mode == 'e' and mode == 'cell')): th = io.read_time_history(nname, pe.indx) elif pe.mode == 'e' and mode == 'vertex': conn = mesh.conns[0] th = {} for iel in pe.indx: ips = conn[iel] th[iel] = io.read_time_history(nname, ips) else: raise ValueError('cannot extract cell data %s in nodes!' % pe.var) ths[pe.var] = th output('...done', verbose=verbose) ts = TimeStepper(*io.read_time_stepper()) return ths, ts
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 dump_to_vtk(filename, output_filename_trunk=None, step0=0, steps=None, fields=None, linearization=None): """Dump a multi-time-step results file into a sequence of VTK files.""" def _save_step(suffix, out, mesh): if linearization is not None: output('linearizing...') out = _linearize(out, fields, linearization) output('...done') for key, val in out.iteritems(): lmesh = val.get('mesh', mesh) lmesh.write(output_filename_trunk + '_' + key + suffix, io='auto', out={key : val}) if hasattr(val, 'levels'): output('max. refinement per group:', val.levels) else: mesh.write(output_filename_trunk + suffix, io='auto', out=out) output('dumping to VTK...') io = MeshIO.any_from_filename(filename) mesh = Mesh.from_file(filename, io=io) if output_filename_trunk is None: output_filename_trunk = get_trunk(filename) try: ts = TimeStepper(*io.read_time_stepper()) all_steps, times, nts, dts = extract_times(filename) except ValueError: output('no time stepping info found, assuming single step') out = io.read_data(0) if out is not None: _save_step('.vtk', out, mesh) ret = None else: ts.times = times ts.n_step = times.shape[0] if steps is None: ii0 = nm.searchsorted(all_steps, step0) iterator = ((all_steps[ii], times[ii]) for ii in xrange(ii0, len(times))) else: iterator = [(step, ts.times[step]) for step in steps] max_step = all_steps.max() for step, time in iterator: output(ts.format % (step, max_step)) out = io.read_data(step) if out is None: break _save_step('.' + ts.suffix % step + '.vtk', out, mesh) ret = ts.suffix output('...done') return ret
def main(): parser = ArgumentParser(description=__doc__) parser.add_argument('--version', action='version', version="%(prog)s") parser.add_argument('-o', metavar='filename', action="store", dest="output_filename", default='out.vtk', help=helps['filename']) parser.add_argument('-f', '--format', metavar='format', action='store', type=str, dest='format', default=None, help=helps['format']) parser.add_argument("-a", "--axis", metavar='axis', action="store", dest="axis", default='x', help=helps['axis']) parser.add_argument("-d", "--dims", metavar='dims', action="store", dest="dims", default='[1.0, 1.0, 2.0, 2.0, 3.0]', help=helps['dims']) parser.add_argument("-s", "--shape", metavar='shape', action="store", dest="shape", default='[11, 11, 11]', help=helps['shape']) parser.add_argument("-c", "--centre", metavar='centre', action="store", dest="centre", default='[0.0, 0.0, 0.0]', help=helps['centre']) parser.add_argument("--force-hollow", action="store_true", dest="force_hollow", default=False, help=helps['force_hollow']) parser.add_argument("--is-open", action="store_true", dest="is_open", default=False, help=helps['is_open']) parser.add_argument("--open-angle", metavar='angle', type=float, action="store", dest="open_angle", default='0.0', help=helps['open_angle']) parser.add_argument("--non-uniform", action="store_true", dest="non_uniform", default=False, help=helps['non_uniform']) options = parser.parse_args() dims = nm.array(eval(options.dims), dtype=nm.float64) shape = nm.array(eval(options.shape), dtype=nm.int32) centre = nm.array(eval(options.centre), dtype=nm.float64) output.prefix = 'cylindergen:' output('dimensions:', dims) output('shape:', shape) output('centre:', centre) output('output file:', options.output_filename) check_format_suffix(options.format, op.splitext(options.output_filename)[1][1:]) mesh = gen_cylinder_mesh(dims, shape, centre, axis=options.axis, force_hollow=options.force_hollow, is_open=options.is_open, open_angle=options.open_angle, non_uniform=options.non_uniform, name=options.output_filename) io = MeshIO.any_from_filename(options.output_filename, file_format=options.format, mode='w') mesh.write(options.output_filename, io=io)