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())
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:
iterator = ts.iter_from(step0)
else:
iterator = [(step, ts.times[step]) for step in steps]
for step, time in iterator:
output(ts.format % (step, ts.n_step - 1))
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_times(filename):
"""
Read true time step data from individual time steps.
Returns
-------
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)
times, nts = io.read_times()
dts = nm.ediff1d(times, to_end=0)
return times, nts, dts
def dump_to_vtk(filename, output_filename_trunk=None, step0=0, steps=None):
"""Dump a multi-time-step results file into a sequence of VTK files."""
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())
except:
output('no time stepping info found, assuming single step')
out = io.read_data(0)
if out is not None:
mesh.write(output_filename_trunk + '.vtk', io='auto', out=out)
ret = None
else:
if steps is None:
iterator = ts.iter_from(step0)
else:
iterator = [(step, ts.times[step]) for step in steps]
for step, time in iterator:
output(ts.format % (step, ts.n_step - 1))
out = io.read_data(step)
if out is None: break
mesh.write('.'.join((output_filename_trunk,
ts.suffix % step, 'vtk')),
io='auto', out=out)
ret = ts.suffix
output('...done')
return ret
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 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
from sfepy.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 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
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 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 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
