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 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 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 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 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 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 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 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_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__) 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) output('output file:', options.output_filename) check_format_suffix(options.format, op.splitext(options.output_filename)[1][1:]) mesh = gen_block_mesh(dims, shape, centre, 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)
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 = 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)