def main():
parser = OptionParser( usage = usage, version = "%prog" )
parser.add_option( "-o", "", metavar = 'filename',
action = "store", dest = "output_filename",
default = 'out.vtk', help = help['filename'] )
parser.add_option('-f', '--format', metavar='format',
action='store', type='string', dest='format',
default=None, help=help['format'])
parser.add_option( "-d", "--dims", metavar = 'dims',
action = "store", dest = "dims",
default = '[1.0, 1.0, 1.0]', help = help['dims'] )
parser.add_option( "-s", "--shape", metavar = 'shape',
action = "store", dest = "shape",
default = '[11, 11, 11]', help = help['shape'] )
parser.add_option( "-c", "--centre", metavar = 'centre',
action = "store", dest = "centre",
default = '[0.0, 0.0, 0.0]', help = help['centre'] )
(options, args) = 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_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 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 main():
parser = OptionParser( usage = usage, version = "%prog" )
parser.add_option( "-o", "", metavar = 'filename',
action = "store", dest = "output_filename",
default = 'out.vtk', help = help['filename'] )
parser.add_option('-f', '--format', metavar='format',
action='store', type='string', dest='format',
default=None, help=help['format'])
parser.add_option( "-a", "--axis", metavar = 'axis',
action = "store", dest = "axis",
default = 'x', help = help['axis'] )
parser.add_option( "-d", "--dims", metavar = 'dims',
action = "store", dest = "dims",
default = '[1.0, 1.0, 2.0, 2.0, 3.0]',
help = help['dims'] )
parser.add_option( "-s", "--shape", metavar = 'shape',
action = "store", dest = "shape",
default = '[11, 11, 11]', help = help['shape'] )
parser.add_option( "-c", "--centre", metavar = 'centre',
action = "store", dest = "centre",
default = '[0.0, 0.0, 0.0]', help = help['centre'] )
parser.add_option( "", "--force-hollow",
action = "store_true", dest = "force_hollow",
default = False, help = help['force_hollow'] )
parser.add_option( "", "--is-open",
action = "store_true", dest = "is_open",
default = False, help = help['is_open'] )
parser.add_option( "", "--open-angle", metavar = 'angle', type='float',
action = "store", dest = "open_angle",
default = '0.0', help = help['open_angle'] )
parser.add_option( "", "--non-uniform",
action = "store_true", dest = "non_uniform",
default = False, help = help['non_uniform'] )
(options, args) = 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 = OptionParser(usage=usage)
parser.add_option("-s", "--scale", metavar='scale',
action="store", dest="scale",
default=None, help=help['scale'])
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_writable_meshes()
sys.exit(0)
if len(args) != 2:
parser.print_help()
sys.exit(1)
scale = options.scale
if scale is not None:
try:
try:
scale = float(scale)
except ValueError:
scale = [float(ii) for ii in scale.split(',')]
scale = nm.array(scale, dtype=nm.float64, ndmin=1)
except:
output('bad scale! (%s)' % scale)
parser.print_help()
sys.exit(1)
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)
io = MeshIO.for_format(filename_out, format=options.format,
writable=True)
output('writing %s...' % filename_out)
mesh.write(filename_out, io=io)
output('...done')
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 main():
parser = OptionParser(usage=usage, version='%prog')
parser.add_option('-o', '', metavar='filename',
action='store', dest='output_filename',
default='out.vtk', help=help['filename'])
parser.add_option('-f', '--format', metavar='format',
action='store', type='string', dest='format',
default=None, help=help['format'])
parser.add_option('-d', '--dims', metavar='dims',
action='store', dest='dims',
default='[1.0, 1.0, 1.0]', help=help['dims'])
parser.add_option('-s', '--shape', metavar='shape',
action='store', dest='shape',
default='[11, 11, 11]', help=help['shape'])
parser.add_option('-c', '--centre', metavar='centre',
action='store', dest='centre',
default='[0.0, 0.0, 0.0]', help=help['centre'])
parser.add_option('-2', '--2d',
action='store_true', dest='is_2d',
default=False, help=help['2d'])
(options, args) = 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 = OptionParser(usage=usage)
parser.add_option('-s', '--scale', metavar='scale',
action='store', dest='scale',
default=None, help=help['scale'])
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_writable_meshes()
sys.exit(0)
if len(args) != 2:
parser.print_help()
sys.exit(1)
scale = options.scale
if scale is not None:
try:
try:
scale = float(scale)
except ValueError:
scale = [float(ii) for ii in scale.split(',')]
scale = nm.array(scale, dtype=nm.float64, ndmin=1)
except:
output('bad scale! (%s)' % scale)
parser.print_help()
sys.exit(1)
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 options.refine > 0:
domain = Domain(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)
output('writing %s...' % filename_out)
mesh.write(filename_out, io=io)
output('...done')
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 main():
parser = OptionParser(usage=usage, version="%prog")
parser.add_option("-o",
"",
metavar='filename',
action="store",
dest="output_filename",
default='out.vtk',
help=help['filename'])
parser.add_option('-f',
'--format',
metavar='format',
action='store',
type='string',
dest='format',
default=None,
help=help['format'])
parser.add_option("-a",
"--axis",
metavar='axis',
action="store",
dest="axis",
default='x',
help=help['axis'])
parser.add_option("-d",
"--dims",
metavar='dims',
action="store",
dest="dims",
default='[1.0, 1.0, 2.0, 2.0, 3.0]',
help=help['dims'])
parser.add_option("-s",
"--shape",
metavar='shape',
action="store",
dest="shape",
default='[11, 11, 11]',
help=help['shape'])
parser.add_option("-c",
"--centre",
metavar='centre',
action="store",
dest="centre",
default='[0.0, 0.0, 0.0]',
help=help['centre'])
parser.add_option("",
"--force-hollow",
action="store_true",
dest="force_hollow",
default=False,
help=help['force_hollow'])
parser.add_option("",
"--is-open",
action="store_true",
dest="is_open",
default=False,
help=help['is_open'])
parser.add_option("",
"--open-angle",
metavar='angle',
type='float',
action="store",
dest="open_angle",
default='0.0',
help=help['open_angle'])
parser.add_option("",
"--non-uniform",
action="store_true",
dest="non_uniform",
default=False,
help=help['non_uniform'])
(options, args) = 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 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 main():
parser = OptionParser(usage=usage, version='%prog')
parser.add_option('-o',
'',
metavar='filename',
action='store',
dest='output_filename',
default='out.vtk',
help=help['filename'])
parser.add_option('-f',
'--format',
metavar='format',
action='store',
type='string',
dest='format',
default=None,
help=help['format'])
parser.add_option('-d',
'--dims',
metavar='dims',
action='store',
dest='dims',
default='[1.0, 1.0, 1.0]',
help=help['dims'])
parser.add_option('-s',
'--shape',
metavar='shape',
action='store',
dest='shape',
default='[11, 11, 11]',
help=help['shape'])
parser.add_option('-c',
'--centre',
metavar='centre',
action='store',
dest='centre',
default='[0.0, 0.0, 0.0]',
help=help['centre'])
parser.add_option('-2',
'--2d',
action='store_true',
dest='is_2d',
default=False,
help=help['2d'])
(options, args) = 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 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 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_writable_meshes()
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 = Domain(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)
output('writing %s...' % filename_out)
mesh.write(filename_out, io=io)
output('...done')
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 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 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 = 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_writable_meshes()
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 = Domain(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)
output('writing %s...' % filename_out)
mesh.write(filename_out, io=io)
output('...done')
