def setup_output_info(self, problem, options):
"""Modifies both problem and options!"""
if options.output_filename_trunk is None:
if self.conf.get('filename_mesh') is not None:
filename_mesh = self.conf.filename_mesh
if isinstance(filename_mesh, MeshIO):
ofn_trunk = filename_mesh.get_filename_trunk()
else:
ofn_trunk = io.get_trunk(filename_mesh)
elif self.conf.get('filename_domain') is not None:
ofn_trunk = io.get_trunk(self.conf.filename_domain)
else:
raise ValueError('missing filename_mesh or filename_domain!')
options.output_filename_trunk = ofn_trunk
else:
ofn_trunk = options.output_filename_trunk
if hasattr(options, 'output_format') \
and (options.output_format is not None):
output_format = options.output_format
else:
output_format = self.app_options.output_format
problem.setup_output(output_filename_trunk=ofn_trunk,
output_dir=self.app_options.output_dir,
output_format=output_format,
file_per_var=self.app_options.file_per_var,
linearization=self.app_options.linearization)
def setup_output_info(self, problem, options):
"""Modifies both problem and options!"""
if options.output_filename_trunk is None:
if self.conf.get('filename_mesh') is not None:
filename_mesh = self.conf.filename_mesh
if isinstance(filename_mesh, MeshIO):
ofn_trunk = filename_mesh.get_filename_trunk()
else:
ofn_trunk = io.get_trunk(filename_mesh)
elif self.conf.get('filename_domain') is not None:
ofn_trunk = io.get_trunk(self.conf.filename_domain)
else:
raise ValueError('missing filename_mesh or filename_domain!')
options.output_filename_trunk = ofn_trunk
else:
ofn_trunk = options.output_filename_trunk
if hasattr(options, 'output_format') \
and (options.output_format is not None):
output_format = options.output_format
else:
output_format = self.app_options.output_format
problem.setup_output(output_filename_trunk=ofn_trunk,
output_dir=self.app_options.output_dir,
output_format=output_format,
file_per_var=self.app_options.file_per_var,
linearization=self.app_options.linearization)
def setup_default_output(self, conf=None, options=None):
"""
Provide default values to `Problem.setup_output()`
from `conf.options` and `options`.
"""
conf = get_default(conf, self.conf)
if options and getattr(options, 'output_filename_trunk', None):
default_output_dir, of = op.split(options.output_filename_trunk)
default_trunk = io.get_trunk(of)
else:
default_trunk = None
default_output_dir = conf.options.get('output_dir', None)
if options and getattr(options, 'output_format', None):
default_output_format = options.output_format
else:
default_output_format = conf.options.get('output_format', None)
default_file_per_var = conf.options.get('file_per_var', None)
default_float_format = conf.options.get('float_format', None)
default_linearization = Struct(kind='strip')
self.setup_output(output_filename_trunk=default_trunk,
output_dir=default_output_dir,
file_per_var=default_file_per_var,
output_format=default_output_format,
float_format=default_float_format,
linearization=default_linearization)
def setup_output_info(self, problem, options):
"""Modifies both problem and options!"""
if options.output_filename_trunk is None:
filename_mesh = self.conf.filename_mesh
if isinstance(filename_mesh, MeshIO):
ofn_trunk = filename_mesh.get_filename_trunk()
else:
ofn_trunk = io.get_trunk(filename_mesh)
options.output_filename_trunk = ofn_trunk
else:
ofn_trunk = options.output_filename_trunk
if hasattr(options, "output_format") and (options.output_format is not None):
output_format = options.output_format
else:
output_format = self.app_options.output_format
problem.setup_output(
output_filename_trunk=ofn_trunk,
output_dir=self.app_options.output_dir,
output_format=output_format,
file_per_var=self.app_options.file_per_var,
linearization=self.app_options.linearization,
)
def setup_default_output(self, conf=None, options=None):
"""
Provide default values to `ProblemDefinition.setup_output()`
from `conf.options` and `options`.
"""
conf = get_default(conf, self.conf)
if options and options.output_filename_trunk:
default_output_dir, of = op.split(options.output_filename_trunk)
default_trunk = io.get_trunk(of)
else:
default_trunk = None
default_output_dir = get_default_attr(conf.options,
'output_dir', None)
if options and options.output_format:
default_output_format = options.output_format
else:
default_output_format = get_default_attr(conf.options,
'output_format', None)
default_file_per_var = get_default_attr(conf.options,
'file_per_var', None)
default_float_format = get_default_attr(conf.options,
'float_format', None)
default_linearization = Struct(kind='strip')
self.setup_output(output_filename_trunk=default_trunk,
output_dir=default_output_dir,
file_per_var=default_file_per_var,
output_format=default_output_format,
float_format=default_float_format,
linearization=default_linearization)
def setup_default_output(self, conf=None, options=None):
"""
Provide default values to `Problem.setup_output()`
from `conf.options` and `options`.
"""
conf = get_default(conf, self.conf)
if options and getattr(options, "output_filename_trunk", None):
default_output_dir, of = op.split(options.output_filename_trunk)
default_trunk = io.get_trunk(of)
else:
default_trunk = None
default_output_dir = conf.options.get("output_dir", None)
if options and getattr(options, "output_format", None):
default_output_format = options.output_format
else:
default_output_format = conf.options.get("output_format", None)
default_file_per_var = conf.options.get("file_per_var", None)
default_float_format = conf.options.get("float_format", None)
default_linearization = Struct(kind="strip")
self.setup_output(
output_filename_trunk=default_trunk,
output_dir=default_output_dir,
file_per_var=default_file_per_var,
output_format=default_output_format,
float_format=default_float_format,
linearization=default_linearization,
)
def from_conf(conf, init_fields=True, init_variables=True, init_equations=True, init_solvers=True):
mesh = Mesh.from_file(conf.filename_mesh)
eldesc_dir = op.join(install_dir, "eldesc")
domain = Domain.from_mesh(mesh, eldesc_dir)
domain.setup_groups()
domain.fix_element_orientation()
domain.setup_neighbour_lists()
obj = ProblemDefinition(conf=conf, domain=domain, eldesc_dir=eldesc_dir)
# Default output file trunk and format.
obj.ofn_trunk = io.get_trunk(conf.filename_mesh)
obj.output_format = "vtk"
obj.set_regions(conf.regions, conf.materials, conf.funmod)
if init_fields:
obj.set_fields(conf.fields)
if init_variables:
obj.set_variables(conf.variables)
if init_equations:
obj.set_equations(conf.equations)
if init_solvers:
obj.set_solvers(conf.solvers, conf.options)
obj.ts = None
return obj
def setup_output(
self,
output_filename_trunk=None,
output_dir=None,
output_format=None,
float_format=None,
file_per_var=None,
linearization=None,
):
"""
Sets output options to given values, or uses the defaults for
each argument that is None.
"""
self.output_modes = {"vtk": "sequence", "h5": "single"}
self.ofn_trunk = get_default(output_filename_trunk, io.get_trunk(self.domain.name))
self.set_output_dir(output_dir)
self.output_format = get_default(output_format, "vtk")
self.float_format = get_default(float_format, None)
self.file_per_var = get_default(file_per_var, False)
self.linearization = get_default(linearization, Struct(kind="strip"))
if (self.output_format == "h5") and (self.linearization.kind == "adaptive"):
self.linearization.kind = None
def solve_optimize(conf, options):
opts = conf.options
trunk = io.get_trunk(conf.filename_mesh)
data = {}
dpb = Problem.from_conf(conf, init_equations=False)
equations = getattr(conf, '_'.join(('equations_direct', opts.problem)))
dpb.set_equations(equations)
dpb.name = 'direct'
dpb.time_update(None)
apb = dpb.copy('adjoint')
equations = getattr(
conf, '_'.join(
('equations_adjoint', opts.problem, opts.objective_function)))
apb.set_equations(equations)
apb.time_update(None)
apb.ebcs.zero_dofs()
apb.update_equations(None, ebcs=apb.ebcs)
ls_conf = dpb.get_solver_conf(opts.ls)
dnls_conf = dpb.get_solver_conf(opts.nls_direct)
anls_conf = dpb.get_solver_conf(opts.nls_adjoint)
opt_conf = dpb.get_solver_conf(opts.optimizer)
dpb.init_solvers(ls_conf=ls_conf, nls_conf=dnls_conf)
apb.init_solvers(ls_conf=ls_conf, nls_conf=anls_conf)
shape_opt = so.ShapeOptimFlowCase.from_conf(conf, dpb, apb)
design0 = shape_opt.dsg_vars.val
shape_opt.cache = Struct(design=design0 + 100, state=None, i_mesh=-1)
opt_status = IndexedStruct()
optimizer = Solver.any_from_conf(opt_conf,
obj_fun=so.obj_fun,
obj_fun_grad=so.obj_fun_grad,
status=opt_status,
obj_args=(shape_opt, opts))
##
# State problem solution for the initial design.
vec_dp0 = so.solve_problem_for_design(dpb, design0, shape_opt, opts)
dpb.save_state(trunk + '_direct_initial.vtk', vec_dp0)
##
# Optimize.
des = optimizer(design0)
print opt_status
##
# Save final state (for "optimal" design).
dpb.domain.mesh.write(trunk + '_opt.mesh', io='auto')
dpb.save_state(trunk + '_direct_current.vtk', shape_opt.cache.state)
print des
def dump_to_vtk( filename, options, steps = None ):
output( 'dumping to VTK...' )
mesh = Mesh.from_file( filename )
io = HDF5MeshIO( filename )
ts = TimeStepper( *io.read_time_stepper() )
if options.output_filename_trunk:
ofn_trunk = options.output_filename_trunk
else:
ofn_trunk = get_trunk( filename )
if steps is None:
iterator = ts.iter_from( options.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( ofn_trunk + ts.suffix % step + '.vtk',
io = 'auto', out = out )
output( '...done' )
return ts.suffix
def setup_output(self,
output_filename_trunk=None,
output_dir=None,
output_format=None,
float_format=None,
file_per_var=None,
linearization=None):
"""
Sets output options to given values, or uses the defaults for
each argument that is None.
"""
self.output_modes = {'vtk': 'sequence', 'h5': 'single'}
self.ofn_trunk = get_default(output_filename_trunk,
io.get_trunk(self.domain.name))
self.set_output_dir(output_dir)
self.output_format = get_default(output_format, 'vtk')
self.float_format = get_default(float_format, None)
self.file_per_var = get_default(file_per_var, False)
self.linearization = get_default(linearization, Struct(kind='strip'))
if ((self.output_format == 'h5')
and (self.linearization.kind == 'adaptive')):
self.linearization.kind = None
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 solve_optimize(conf, options):
opts = conf.options
trunk = io.get_trunk(conf.filename_mesh)
data = {}
dpb = ProblemDefinition.from_conf(conf, init_equations=False)
equations = getattr(conf, "_".join(("equations_direct", opts.problem)))
dpb.set_equations(equations)
dpb.name = "direct"
dpb.time_update(None)
apb = dpb.copy("adjoint")
equations = getattr(conf, "_".join(("equations_adjoint", opts.problem, opts.objective_function)))
apb.set_equations(equations)
apb.time_update(None)
apb.ebcs.zero_dofs()
apb.update_equations(None, ebcs=apb.ebcs)
ls_conf = dpb.get_solver_conf(opts.ls)
dnls_conf = dpb.get_solver_conf(opts.nls_direct)
anls_conf = dpb.get_solver_conf(opts.nls_adjoint)
opt_conf = dpb.get_solver_conf(opts.optimizer)
dpb.init_solvers(ls_conf=ls_conf, nls_conf=dnls_conf)
apb.init_solvers(ls_conf=ls_conf, nls_conf=anls_conf)
shape_opt = so.ShapeOptimFlowCase.from_conf(conf, dpb, apb)
design0 = shape_opt.dsg_vars.val
shape_opt.cache = Struct(design=design0 + 100, state=None, i_mesh=-1)
opt_status = IndexedStruct()
optimizer = Solver.any_from_conf(
opt_conf, obj_fun=so.obj_fun, obj_fun_grad=so.obj_fun_grad, status=opt_status, obj_args=(shape_opt, opts)
)
##
# State problem solution for the initial design.
vec_dp0 = so.solve_problem_for_design(dpb, design0, shape_opt, opts)
dpb.save_state(trunk + "_direct_initial.vtk", vec_dp0)
##
# Optimize.
des = optimizer(design0)
print opt_status
##
# Save final state (for "optimal" design).
dpb.domain.mesh.write(trunk + "_opt.mesh", io="auto")
dpb.save_state(trunk + "_direct_current.vtk", shape_opt.cache.state)
print des
def solve_adjoint(conf, options, dpb, vec_dp, data):
"""
Solve the adjoint (linear) problem.
"""
opts = conf.options
if dpb:
apb = dpb.copy('adjoint')
else:
apb = ProblemDefinition.from_conf(conf)
equations = getattr(conf, '_'.join(('equations_adjoint',
opts.problem,
opts.objective_function)))
apb.set_equations(equations)
apb.time_update(None)
apb.ebcs.zero_dofs()
apb.update_equations(None, ebcs=apb.ebcs)
var_data = dpb.equations.get_state_parts(vec_dp)
var_data = remap_dict(var_data, opts.var_map)
nls_conf = apb.get_solver_conf(opts.nls_adjoint)
vec_ap = apb.solve(nls_conf=nls_conf, var_data=var_data)
trunk = io.get_trunk(conf.filename_mesh)
apb.save_state(trunk + '_adjoint.vtk', vec_ap)
shape_opt = so.ShapeOptimFlowCase.from_conf(conf, dpb, apb)
## print shape_opt
## pause()
if options.test is not None:
##
# Test shape sensitivity.
if shape_opt.test_terms_if_test:
so.test_terms([options.test], opts.term_delta, shape_opt,
var_data, vec_ap)
shape_opt.check_sensitivity([options.test], opts.delta,
var_data, vec_ap)
##
# Compute objective function.
val = shape_opt.obj_fun(vec_dp)
print 'actual obj_fun:', val
## pause()
##
# Compute shape sensitivity.
vec_sa = shape_opt.sensitivity(var_data, vec_ap)
print 'actual sensitivity:', vec_sa
def solve_adjoint(conf, options, dpb, state_dp, data):
"""
Solve the adjoint (linear) problem.
"""
opts = conf.options
if dpb:
apb = dpb.copy('adjoint')
else:
apb = Problem.from_conf(conf, init_equations=False)
equations = getattr(
conf, '_'.join(
('equations_adjoint', opts.problem, opts.objective_function)))
apb.set_equations(equations)
apb.time_update(None)
apb.ebcs.zero_dofs()
apb.update_equations(None, ebcs=apb.ebcs)
var_data = state_dp.get_parts()
var_data = remap_dict(var_data, opts.var_map)
nls_conf = apb.get_solver_conf(opts.nls_adjoint)
state_ap = apb.solve(nls_conf=nls_conf, var_data=var_data)
trunk = io.get_trunk(conf.filename_mesh)
apb.save_state(trunk + '_adjoint.vtk', state_ap)
shape_opt = so.ShapeOptimFlowCase.from_conf(conf, dpb, apb)
if options.test is not None:
##
# Test shape sensitivity.
if shape_opt.test_terms_if_test:
so.test_terms([options.test], opts.term_delta, shape_opt, var_data,
state_ap)
shape_opt.check_sensitivity([options.test], opts.delta, var_data,
state_ap)
##
# Compute objective function.
val = shape_opt.obj_fun(state_dp)
print 'actual obj_fun:', val
##
# Compute shape sensitivity.
vec_sa = shape_opt.sensitivity(var_data, state_ap)
print 'actual sensitivity:', vec_sa
def solve_direct( conf, options ):
"""
Solve the direct (nonlinear) problem.
"""
opts = conf.options
if hasattr( opts, 'problem' ):
if opts.problem == 'navier_stokes':
dpb, vec_dp, data = solve_navier_stokes( conf, options )
else:
output( 'unknown problem type (%s), using generic solver.'\
% opts.problem )
dpb, vec_dp, data = solve_generic_direct( conf, options )
else: # Generic direct problem.
dpb, vec_dp, data = solve_generic_direct( conf, options )
trunk = io.get_trunk( conf.filename_mesh )
dpb.save_state( trunk + '_direct.vtk', vec_dp )
## print dpb.materials['stabil']
## pause()
if options.dump_filename is not None:
import tables as pt
import numarray as nar
fd = pt.openFile( options.dump_filename, mode = 'w',
title = "Dump file" )
out = vec_dp.create_output_dict()
for key, val in out.iteritems():
fd.createArray( fd.root, key, nar.asarray( val.data ),
'%s data' % val.mode )
fd.close()
if options.pert_mesh_filename is not None:
coors0 = dpb.get_mesh_coors()
# !!!
# 'u' is here for displacements of le.py!
vec_u = dpb.variables.get_state_part_view( vec_dp, 'u' ).copy()
vec_u = vec_u.reshape( coors0.shape )
coors = coors0 + vec_u
dpb.set_mesh_coors( coors )
dpb.domain.mesh.write( options.pert_mesh_filename, io = 'auto' )
return dpb, vec_dp, data
def setup_output_info(self, problem, options):
"""Modifies both problem and options!"""
if options.output_filename_trunk is None:
ofn_trunk = io.get_trunk(self.conf.filename_mesh)
options.output_filename_trunk = ofn_trunk
else:
ofn_trunk = options.output_filename_trunk
if hasattr(options, 'output_format') \
and (options.output_format is not None):
output_format = options.output_format
else:
output_format = self.app_options.output_format
problem.setup_output(output_filename_trunk=ofn_trunk,
output_dir=self.app_options.output_dir,
output_format=output_format,
file_per_var=self.app_options.file_per_var)
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 solve_direct(conf, options):
"""
Solve the direct (nonlinear) problem.
"""
opts = conf.options
if hasattr(opts, 'problem'):
if opts.problem == 'navier_stokes':
dpb, state_dp, data = solve_navier_stokes(conf, options)
else:
output( 'unknown problem type (%s), using generic solver.'\
% opts.problem )
dpb, state_dp, data = solve_generic_direct(conf, options)
else: # Generic direct problem.
dpb, state_dp, data = solve_generic_direct(conf, options)
trunk = io.get_trunk(conf.filename_mesh)
dpb.save_state(trunk + '_direct.vtk', state_dp)
if options.dump_filename is not None:
import tables as pt
import numarray as nar
fd = pt.openFile(options.dump_filename, mode='w', title="Dump file")
out = state_dp.create_output_dict()
for key, val in out.iteritems():
fd.createArray(fd.root, key, nar.asarray(val.data),
'%s data' % val.mode)
fd.close()
if options.pert_mesh_filename is not None:
coors0 = dpb.get_mesh_coors()
# !!!
# 'u' is here for displacements of le.py!
vec_u = state_dp('u').copy()
vec_u = vec_u.reshape(coors0.shape)
coors = coors0 + vec_u
dpb.set_mesh_coors(coors)
dpb.domain.mesh.write(options.pert_mesh_filename, io='auto')
return dpb, state_dp, data
def __init__( self, conf, options, output_prefix, **kwargs ):
"""`kwargs` are passed to ProblemDefinition.from_conf()
Command-line options have precedence over conf.options."""
Application.__init__( self, conf, options, output_prefix )
self.setup_options()
if options.output_filename_trunk is None:
ofn_trunk = op.join( self.app_options.output_dir,
io.get_trunk( conf.filename_mesh ) )
options.output_filename_trunk = ofn_trunk
else:
ofn_trunk = options.output_filename_trunk
self.problem = ProblemDefinition.from_conf( conf, **kwargs )
self.problem.ofn_trunk = ofn_trunk
self.problem.output_dir = self.app_options.output_dir
if hasattr( options, 'output_format' ):
self.problem.output_format = options.output_format
else:
self.problem.output_format = self.app_options.output_format
def setup_output(self, output_filename_trunk=None, output_dir=None,
output_format=None, float_format=None,
file_per_var=None, linearization=None):
"""
Sets output options to given values, or uses the defaults for
each argument that is None.
"""
self.output_modes = {'vtk' : 'sequence', 'h5' : 'single'}
self.ofn_trunk = get_default(output_filename_trunk,
io.get_trunk(self.domain.name))
self.set_output_dir(output_dir)
self.output_format = get_default(output_format, 'vtk')
self.float_format = get_default(float_format, None)
self.file_per_var = get_default(file_per_var, False)
self.linearization = get_default(linearization, Struct(kind='strip'))
if ((self.output_format == 'h5') and
(self.linearization.kind == 'adaptive')):
self.linearization.kind = None
def solve_direct(conf, options):
"""
Solve the direct (nonlinear) problem.
"""
opts = conf.options
if hasattr(opts, "problem"):
if opts.problem == "navier_stokes":
dpb, state_dp, data = solve_navier_stokes(conf, options)
else:
output("unknown problem type (%s), using generic solver." % opts.problem)
dpb, state_dp, data = solve_generic_direct(conf, options)
else: # Generic direct problem.
dpb, state_dp, data = solve_generic_direct(conf, options)
trunk = io.get_trunk(conf.filename_mesh)
dpb.save_state(trunk + "_direct.vtk", state_dp)
if options.dump_filename is not None:
import tables as pt
import numarray as nar
fd = pt.openFile(options.dump_filename, mode="w", title="Dump file")
out = state_dp.create_output_dict()
for key, val in out.iteritems():
fd.createArray(fd.root, key, nar.asarray(val.data), "%s data" % val.mode)
fd.close()
if options.pert_mesh_filename is not None:
coors0 = dpb.get_mesh_coors()
# !!!
# 'u' is here for displacements of le.py!
vec_u = state_dp("u").copy()
vec_u = vec_u.reshape(coors0.shape)
coors = coors0 + vec_u
dpb.set_mesh_coors(coors)
dpb.domain.mesh.write(options.pert_mesh_filename, io="auto")
return dpb, state_dp, data
def main():
parser = OptionParser(usage = usage, version = "%prog " + sfepy.__version__)
parser.add_option( "-o", "", metavar = 'filename',
action = "store", dest = "output_filename_trunk",
default = None, help = help['filename'] )
parser.add_option( "-d", "--dump",
action = "store_true", dest = "dump",
default = False, help = help['dump'] )
parser.add_option( "", "--same-dir",
action = "store_true", dest = "same_dir",
default = False, help = help['same_dir'] )
parser.add_option( "-f", "--from", type = int, metavar = 'ii',
action = "store", dest = "step_from",
default = 0, help = help['from'] )
parser.add_option( "-t", "--to", type = int, metavar = 'ii',
action = "store", dest = "step_to",
default = None, help = help['to'] )
parser.add_option( "-s", "--step", type = int, metavar = 'ii',
action = "store", dest = "step_by",
default = 1, help = help['step'] )
parser.add_option( "-e", "--extract", metavar = 'list',
action = "store", dest = "extract",
default = None, help = help['extract'] )
parser.add_option( "-a", "--average",
action = "store_true", dest = "average",
default = False, help = help['average'] )
(options, args) = parser.parse_args()
if (len( args ) == 1):
filename_in = args[0];
else:
parser.print_help(),
return
if options.dump:
trunk = get_default(options.output_filename_trunk,
get_trunk(filename_in))
if options.same_dir:
trunk = os.path.join(os.path.dirname(filename_in),
os.path.basename(trunk))
if options.step_to is None:
dump_to_vtk(filename_in,
output_filename_trunk=trunk,
step0=options.step_from)
else:
dump_to_vtk(filename_in,
output_filename_trunk=trunk,
steps=nm.arange(options.step_from,
options.step_to + 1,
options.step_by, dtype=nm.int))
if options.extract:
ths, ts = extract_time_history(filename_in, options.extract)
## print ths
if options.average:
ths = average_vertex_var_in_cells( ths )
## print ths
if options.output_filename_trunk:
save_time_history(ths, ts, options.output_filename_trunk + '.h5')
else:
print dict_to_struct(ths, flag=(1, 1, 1)).str_all()
def main():
parser = ArgumentParser(description=__doc__, formatter_class=RawDescriptionHelpFormatter)
parser.add_argument("--version", action="version", version="%(prog)s " + sfepy.__version__)
parser.add_argument("--debug", action="store_true", dest="debug", default=False, help=helps["debug"])
parser.add_argument(
"-o", metavar="filename", action="store", dest="output_filename_trunk", default=None, help=helps["filename"]
)
parser.add_argument("-d", "--dump", action="store_true", dest="dump", default=False, help=helps["dump"])
parser.add_argument("--same-dir", action="store_true", dest="same_dir", default=False, help=helps["same_dir"])
parser.add_argument(
"-l",
"--linearization",
metavar="options",
action="store",
dest="linearization",
default=None,
help=helps["linearization"],
)
parser.add_argument("--times", action="store_true", dest="times", default=False, help=helps["times"])
parser.add_argument(
"-f", "--from", type=int, metavar="ii", action="store", dest="step_from", default=0, help=helps["from"]
)
parser.add_argument(
"-t", "--to", type=int, metavar="ii", action="store", dest="step_to", default=None, help=helps["to"]
)
parser.add_argument(
"-s", "--step", type=int, metavar="ii", action="store", dest="step_by", default=1, help=helps["step"]
)
parser.add_argument(
"-e", "--extract", metavar="list", action="store", dest="extract", default=None, help=helps["extract"]
)
parser.add_argument("-a", "--average", action="store_true", dest="average", default=False, help=helps["average"])
parser.add_argument("input_file", nargs="?", default=None)
parser.add_argument("results_file")
options = parser.parse_args()
if options.debug:
from sfepy.base.base import debug_on_error
debug_on_error()
filename_in = options.input_file
filename_results = options.results_file
if filename_in is None:
linearize = False
else:
linearize = True
options.dump = True
if options.times:
steps, times, nts, dts = th.extract_times(filename_results)
for ii, time in enumerate(times):
step = steps[ii]
print("%d %e %e %e" % (step, time, nts[ii], dts[ii]))
if options.dump:
trunk = get_default(options.output_filename_trunk, get_trunk(filename_results))
if options.same_dir:
trunk = os.path.join(os.path.dirname(filename_results), os.path.basename(trunk))
args = {}
if linearize:
problem = create_problem(filename_in)
linearization = Struct(kind="adaptive", min_level=0, max_level=2, eps=1e-2)
aux = problem.conf.options.get("linearization", None)
linearization.update(aux)
if options.linearization is not None:
aux = parse_linearization(options.linearization)
linearization.update(aux)
args.update({"fields": problem.fields, "linearization": linearization})
if options.step_to is None:
args.update({"step0": options.step_from})
else:
args.update({"steps": nm.arange(options.step_from, options.step_to + 1, options.step_by, dtype=nm.int)})
th.dump_to_vtk(filename_results, output_filename_trunk=trunk, **args)
if options.extract:
ths, ts = th.extract_time_history(filename_results, options.extract)
if options.average:
ths = th.average_vertex_var_in_cells(ths)
if options.output_filename_trunk:
th.save_time_history(ths, ts, options.output_filename_trunk + ".h5")
else:
print(dict_to_struct(ths, flag=(1, 1, 1)).str_all())
def main():
parser = ArgumentParser(description=__doc__,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('--version',
action='version',
version='%(prog)s ' + sfepy.__version__)
parser.add_argument('--debug',
action='store_true',
dest='debug',
default=False,
help=helps['debug'])
parser.add_argument('-o',
metavar='filename',
action='store',
dest='output_filename_trunk',
default=None,
help=helps['filename'])
parser.add_argument('-d',
'--dump',
action='store_true',
dest='dump',
default=False,
help=helps['dump'])
parser.add_argument('--same-dir',
action='store_true',
dest='same_dir',
default=False,
help=helps['same_dir'])
parser.add_argument('-l',
'--linearization',
metavar='options',
action='store',
dest='linearization',
default=None,
help=helps['linearization'])
parser.add_argument('--times',
action='store_true',
dest='times',
default=False,
help=helps['times'])
parser.add_argument('-f',
'--from',
type=int,
metavar='ii',
action='store',
dest='step_from',
default=0,
help=helps['from'])
parser.add_argument('-t',
'--to',
type=int,
metavar='ii',
action='store',
dest='step_to',
default=None,
help=helps['to'])
parser.add_argument('-s',
'--step',
type=int,
metavar='ii',
action='store',
dest='step_by',
default=1,
help=helps['step'])
parser.add_argument('-e',
'--extract',
metavar='list',
action='store',
dest='extract',
default=None,
help=helps['extract'])
parser.add_argument('-a',
'--average',
action='store_true',
dest='average',
default=False,
help=helps['average'])
parser.add_argument('input_file', nargs='?', default=None)
parser.add_argument('results_file')
options = parser.parse_args()
if options.debug:
from sfepy.base.base import debug_on_error
debug_on_error()
filename_in = options.input_file
filename_results = options.results_file
if filename_in is None:
linearize = False
else:
linearize = True
options.dump = True
if options.times:
steps, times, nts, dts = th.extract_times(filename_results)
for ii, time in enumerate(times):
step = steps[ii]
print('%d %e %e %e' % (step, time, nts[ii], dts[ii]))
if options.dump:
trunk = get_default(options.output_filename_trunk,
get_trunk(filename_results))
if options.same_dir:
trunk = os.path.join(os.path.dirname(filename_results),
os.path.basename(trunk))
args = {}
if linearize:
problem = create_problem(filename_in)
linearization = Struct(kind='adaptive',
min_level=0,
max_level=2,
eps=1e-2)
aux = problem.conf.options.get('linearization', None)
linearization.update(aux)
if options.linearization is not None:
aux = parse_linearization(options.linearization)
linearization.update(aux)
args.update({
'fields': problem.fields,
'linearization': linearization
})
if options.step_to is None:
args.update({'step0': options.step_from})
else:
args.update({
'steps':
nm.arange(options.step_from,
options.step_to + 1,
options.step_by,
dtype=nm.int)
})
th.dump_to_vtk(filename_results, output_filename_trunk=trunk, **args)
if options.extract:
ths, ts = th.extract_time_history(filename_results, options.extract)
if options.average:
ths = th.average_vertex_var_in_cells(ths)
if options.output_filename_trunk:
th.save_time_history(ths, ts,
options.output_filename_trunk + '.h5')
else:
print(dict_to_struct(ths, flag=(1, 1, 1)).str_all())
def main():
parser = OptionParser(usage=usage, version="%prog " + sfepy.__version__)
parser.add_option('-o', '', metavar='filename',
action='store', dest='output_filename_trunk',
default=None, help=help['filename'])
parser.add_option('-d', '--dump', action='store_true', dest='dump',
default=False, help=help['dump'])
parser.add_option('', '--same-dir', action='store_true', dest='same_dir',
default=False, help=help['same_dir'])
parser.add_option('-l', '--linearization', metavar='options',
action='store', dest='linearization',
default=None, help=help['linearization'])
parser.add_option('', '--times', action='store_true', dest='times',
default=False, help=help['times'])
parser.add_option('-f', '--from', type=int, metavar='ii',
action='store', dest='step_from',
default=0, help=help['from'])
parser.add_option('-t', '--to', type=int, metavar='ii',
action='store', dest='step_to',
default=None, help=help['to'])
parser.add_option('-s', '--step', type=int, metavar='ii',
action='store', dest='step_by',
default=1, help=help['step'])
parser.add_option('-e', '--extract', metavar='list',
action='store', dest='extract',
default=None, help=help['extract'])
parser.add_option('-a', '--average', action='store_true', dest='average',
default=False, help=help['average'])
(options, args) = parser.parse_args()
nargs = len(args)
if nargs == 1:
filename_results = args[0]
linearize = False
elif nargs == 2:
filename_in, filename_results = args
linearize = True
options.dump = True
else:
parser.print_help()
return
if options.times:
steps, times, nts, dts = th.extract_times(filename_results)
for ii, time in enumerate(times):
step = steps[ii]
print('%d %e %e %e' % (step, time, nts[ii], dts[ii]))
if options.dump:
trunk = get_default(options.output_filename_trunk,
get_trunk(filename_results))
if options.same_dir:
trunk = os.path.join(os.path.dirname(filename_results),
os.path.basename(trunk))
args = {}
if linearize:
problem = create_problem(filename_in)
linearization = Struct(kind='adaptive', min_level=0,
max_level=2, eps=1e-2)
aux = problem.conf.options.get('linearization', None)
linearization.update(aux)
if options.linearization is not None:
aux = parse_linearization(options.linearization)
linearization.update(aux)
args.update({'fields' : problem.fields,
'linearization' : linearization})
if options.step_to is None:
args.update({'step0' : options.step_from})
else:
args.update({'steps' : nm.arange(options.step_from,
options.step_to + 1,
options.step_by, dtype=nm.int)})
th.dump_to_vtk(filename_results, output_filename_trunk=trunk, **args)
if options.extract:
ths, ts = th.extract_time_history(filename_results, options.extract)
if options.average:
ths = th.average_vertex_var_in_cells(ths)
if options.output_filename_trunk:
th.save_time_history(ths, ts, options.output_filename_trunk + '.h5')
else:
print(dict_to_struct(ths, flag=(1, 1, 1)).str_all())
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 = OptionParser(usage=usage, version="%prog " + sfepy.__version__)
parser.add_option('-o',
'',
metavar='filename',
action='store',
dest='output_filename_trunk',
default=None,
help=help['filename'])
parser.add_option('-d',
'--dump',
action='store_true',
dest='dump',
default=False,
help=help['dump'])
parser.add_option('',
'--same-dir',
action='store_true',
dest='same_dir',
default=False,
help=help['same_dir'])
parser.add_option('-l',
'--linearization',
metavar='options',
action='store',
dest='linearization',
default=None,
help=help['linearization'])
parser.add_option('',
'--times',
action='store_true',
dest='times',
default=False,
help=help['times'])
parser.add_option('-f',
'--from',
type=int,
metavar='ii',
action='store',
dest='step_from',
default=0,
help=help['from'])
parser.add_option('-t',
'--to',
type=int,
metavar='ii',
action='store',
dest='step_to',
default=None,
help=help['to'])
parser.add_option('-s',
'--step',
type=int,
metavar='ii',
action='store',
dest='step_by',
default=1,
help=help['step'])
parser.add_option('-e',
'--extract',
metavar='list',
action='store',
dest='extract',
default=None,
help=help['extract'])
parser.add_option('-a',
'--average',
action='store_true',
dest='average',
default=False,
help=help['average'])
(options, args) = parser.parse_args()
nargs = len(args)
if nargs == 1:
filename_results = args[0]
linearize = False
elif nargs == 2:
filename_in, filename_results = args
linearize = True
options.dump = True
else:
parser.print_help()
return
if options.times:
steps, times, nts, dts = th.extract_times(filename_results)
for ii, time in enumerate(times):
step = steps[ii]
print '%d %e %e %e' % (step, time, nts[ii], dts[ii])
if options.dump:
trunk = get_default(options.output_filename_trunk,
get_trunk(filename_results))
if options.same_dir:
trunk = os.path.join(os.path.dirname(filename_results),
os.path.basename(trunk))
args = {}
if linearize:
problem = create_problem(filename_in)
linearization = Struct(kind='adaptive',
min_level=0,
max_level=2,
eps=1e-2)
aux = problem.conf.options.get('linearization', None)
linearization.update(aux)
if options.linearization is not None:
aux = parse_linearization(options.linearization)
linearization.update(aux)
args.update({
'fields': problem.fields,
'linearization': linearization
})
if options.step_to is None:
args.update({'step0': options.step_from})
else:
args.update({
'steps':
nm.arange(options.step_from,
options.step_to + 1,
options.step_by,
dtype=nm.int)
})
th.dump_to_vtk(filename_results, output_filename_trunk=trunk, **args)
if options.extract:
ths, ts = th.extract_time_history(filename_results, options.extract)
if options.average:
ths = th.average_vertex_var_in_cells(ths)
if options.output_filename_trunk:
th.save_time_history(ths, ts,
options.output_filename_trunk + '.h5')
else:
print dict_to_struct(ths, flag=(1, 1, 1)).str_all()
