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 = 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 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 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 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)
