def plot_control_mesh(ax, control_points, label=False):
"""
Plot the control mesh of a NURBS given by its control points.
"""
dim = control_points.shape[-1]
ax = _get_axes(ax, dim)
shape = control_points.shape
conn, desc = get_tensor_product_conn(nm.array(shape[:-1]))
gel = GeometryElement(desc)
coors = control_points.reshape((-1, dim))
ax = pd.plot_mesh(ax, coors, conn, gel.edges)
pd.plot_points(ax, coors)
if label:
for ii, cc in enumerate(coors):
if dim == 3:
cx, cy, cz = cc
ax.text(cx, cy, cz, '%d' % ii,
color='g', fontsize=12, weight='bold')
else:
cx, cy = cc
ax.text(cx, cy, '%d' % ii,
color='g', fontsize=12, weight='bold')
return ax
def plot_control_mesh(ax, control_points, label=False):
"""
Plot the control mesh of a NURBS given by its control points.
"""
dim = control_points.shape[-1]
ax = _get_axes(ax, dim)
shape = control_points.shape
conn, desc = get_tensor_product_conn(nm.array(shape[:-1]))
gel = GeometryElement(desc)
coors = control_points.reshape((-1, dim))
ax = pd.plot_mesh(ax, coors, conn, gel.edges)
pd.plot_points(ax, coors)
if label:
for ii, cc in enumerate(coors):
if dim == 3:
cx, cy, cz = cc
ax.text(cx, cy, cz, '%d' % ii,
color='g', fontsize=12, weight='bold')
else:
cx, cy = cc
ax.text(cx, cy, '%d' % ii,
color='g', fontsize=12, weight='bold')
return ax
def plot_geometry(ax, gel):
"""
Plot a geometry element as a wireframe.
"""
ax = plot_mesh(ax, gel.coors, [gel.conn], gel.edges)
ax = plot_global_dofs(ax, gel.coors, [gel.conn])
return ax
def plot_geometry(ax, gel, show=False):
"""
Plot a geometry element as a wireframe.
"""
ax = plot_mesh(ax, gel.coors, [gel.conn], gel.edges, show=False)
ax = plot_global_dofs(ax, gel.coors, [gel.conn], show=show)
return ax
def plot_geometry(ax, gel):
"""
Plot a geometry element as a wireframe.
"""
ax = plot_mesh(ax, gel.coors, [gel.conn], gel.edges)
ax = plot_global_dofs(ax, gel.coors, [gel.conn])
return ax
def plot_geometry(ax, gel, show=False):
"""
Plot a geometry element as a wireframe.
"""
ax = plot_mesh(ax, gel.coors, [gel.conn], gel.edges, show=False)
ax = plot_global_dofs(ax, gel.coors, [gel.conn], show=show)
return ax
def plot_bezier_mesh(ax, control_points, conn, degrees, label=False):
"""
Plot the Bezier mesh of a NURBS given by its control points and
connectivity.
"""
dim = control_points.shape[-1]
ax = _get_axes(ax, dim)
edges = _get_edges(conn.shape[1], nm.asarray(degrees) + 1)
ax = pd.plot_mesh(ax, control_points, conn, edges)
pd.plot_points(ax, control_points)
if label:
ax = pd.plot_global_dofs(ax, control_points, conn)
return ax
def plot_bezier_mesh(ax, control_points, conn, degrees, label=False):
"""
Plot the Bezier mesh of a NURBS given by its control points and
connectivity.
"""
dim = control_points.shape[-1]
ax = _get_axes(ax, dim)
edges = _get_edges(conn.shape[1], nm.asarray(degrees) + 1)
ax = pd.plot_mesh(ax, control_points, conn, edges)
pd.plot_points(ax, control_points)
if label:
ax = pd.plot_global_dofs(ax, control_points, conn)
return ax
def plot_control_mesh(ax, control_points, label=False):
"""
Plot the control mesh of a NURBS given by its control points.
"""
dim = control_points.shape[-1]
ax = _get_axes(ax, dim)
shape = control_points.shape
conn, desc = get_tensor_product_conn(nm.array(shape[:-1]))
gel = GeometryElement(desc)
coors = control_points.reshape((-1, dim))
ax = pd.plot_mesh(ax, coors, conn, gel.edges)
pd.plot_points(ax, coors)
if label:
for ii, cc in enumerate(coors):
ax.text(*cc, s="%d" % ii, color="g", fontsize=12, weight="bold")
return ax
def plot_parametric_mesh(ax, knots):
"""
Plot the parametric mesh of a NURBS given by its knots.
"""
knots = _get_knots_tuple(knots)
dim = len(knots)
ax = _get_axes(ax, dim)
uknots = [nm.unique(ii) for ii in knots]
shape = [len(ii) for ii in uknots]
ngrid = nm.mgrid[[slice(ii) for ii in shape]]
coors = nm.r_[[uknots[ii][ig].ravel() for ii, ig in enumerate(ngrid)]].T
conn, desc = get_tensor_product_conn(nm.array(shape))
gel = GeometryElement(desc)
ax = pd.plot_mesh(ax, coors, conn, gel.edges)
pd.plot_points(ax, coors)
return ax
def plot_parametric_mesh(ax, knots):
"""
Plot the parametric mesh of a NURBS given by its knots.
"""
knots = _get_knots_tuple(knots)
dim = len(knots)
ax = _get_axes(ax, dim)
uknots = [nm.unique(ii) for ii in knots]
shape = [len(ii) for ii in uknots]
ngrid = nm.mgrid[[slice(ii) for ii in shape]]
coors = nm.r_[[uknots[ii][ig].ravel() for ii, ig in enumerate(ngrid)]].T
conn, desc = get_tensor_product_conn(nm.array(shape))
gel = GeometryElement(desc)
ax = pd.plot_mesh(ax, coors, conn, gel.edges)
pd.plot_points(ax, coors)
return ax
def main():
parser = OptionParser(usage=usage, version='%prog')
parser.add_option('-b', '--basis', metavar='name',
action='store', dest='basis',
default='lagrange', help=help['basis'])
parser.add_option('-d', '--derivative', metavar='d', type=int,
action='store', dest='derivative',
default=0, help=help['derivative'])
parser.add_option('-n', '--max-order', metavar='order', type=int,
action='store', dest='max_order',
default=2, help=help['max_order'])
parser.add_option('-g', '--geometry', metavar='name',
action='store', dest='geometry',
default='2_4', help=help['geometry'])
parser.add_option('-m', '--mesh', metavar='mesh',
action='store', dest='mesh',
default=None, help=help['mesh'])
parser.add_option('', '--permutations', metavar='permutations',
action='store', dest='permutations',
default=None, help=help['permutations'])
parser.add_option('', '--dofs', metavar='dofs',
action='store', dest='dofs',
default=None, help=help['dofs'])
parser.add_option('-l', '--lin-options', metavar='options',
action='store', dest='lin_options',
default='min_level=2,max_level=5,eps=1e-3',
help=help['lin_options'])
parser.add_option('', '--plot-dofs',
action='store_true', dest='plot_dofs',
default=False, help=help['plot_dofs'])
options, args = parser.parse_args()
if len(args) == 1:
output_dir = args[0]
else:
parser.print_help(),
return
output('polynomial space:', options.basis)
output('max. order:', options.max_order)
lin = Struct(kind='adaptive', min_level=2, max_level=5, eps=1e-3)
for opt in options.lin_options.split(','):
key, val = opt.split('=')
setattr(lin, key, eval(val))
if options.mesh is None:
dim, n_ep = int(options.geometry[0]), int(options.geometry[2])
output('reference element geometry:')
output(' dimension: %d, vertices: %d' % (dim, n_ep))
gel = GeometryElement(options.geometry)
gps = PolySpace.any_from_args(None, gel, 1,
base=options.basis)
ps = PolySpace.any_from_args(None, gel, options.max_order,
base=options.basis)
n_digit, _format = get_print_info(ps.n_nod, fill='0')
name_template = os.path.join(output_dir, 'bf_%s.vtk' % _format)
for ip in get_dofs(options.dofs, ps.n_nod):
output('shape function %d...' % ip)
def eval_dofs(iels, rx):
if options.derivative == 0:
bf = ps.eval_base(rx).squeeze()
rvals = bf[None, :, ip:ip+1]
else:
bfg = ps.eval_base(rx, diff=True)
rvals = bfg[None, ..., ip]
return rvals
def eval_coors(iels, rx):
bf = gps.eval_base(rx).squeeze()
coors = nm.dot(bf, gel.coors)[None, ...]
return coors
(level, coors, conn,
vdofs, mat_ids) = create_output(eval_dofs, eval_coors, 1,
ps, min_level=lin.min_level,
max_level=lin.max_level,
eps=lin.eps)
out = {
'bf' : Struct(name='output_data',
mode='vertex', data=vdofs,
var_name='bf', dofs=None)
}
mesh = Mesh.from_data('bf_mesh', coors, None, [conn], [mat_ids],
[options.geometry])
name = name_template % ip
mesh.write(name, out=out)
output('...done (%s)' % name)
else:
mesh = Mesh.from_file(options.mesh)
output('mesh geometry:')
output(' dimension: %d, vertices: %d, elements: %d'
% (mesh.dim, mesh.n_nod, mesh.n_el))
domain = Domain('domain', mesh)
if options.permutations:
permutations = [int(ii) for ii in options.permutations.split(',')]
output('using connectivity permutations:', permutations)
for group in domain.iter_groups():
perms = group.gel.get_conn_permutations()[permutations]
offsets = nm.arange(group.shape.n_el) * group.shape.n_ep
group.conn[:] = group.conn.take(perms + offsets[:, None])
domain.setup_facets()
omega = domain.create_region('Omega', 'all')
field = Field.from_args('f', nm.float64, shape=1, region=omega,
approx_order=options.max_order,
poly_space_base=options.basis)
var = FieldVariable('u', 'unknown', field, 1)
if options.plot_dofs:
import sfepy.postprocess.plot_dofs as pd
group = domain.groups[0]
ax = pd.plot_mesh(None, mesh.coors, mesh.conns[0], group.gel.edges)
ax = pd.plot_global_dofs(ax, field.get_coor(), field.aps[0].econn)
ax = pd.plot_local_dofs(ax, field.get_coor(), field.aps[0].econn)
pd.plt.show()
output('dofs: %d' % var.n_dof)
vec = nm.empty(var.n_dof, dtype=var.dtype)
n_digit, _format = get_print_info(var.n_dof, fill='0')
name_template = os.path.join(output_dir, 'dof_%s.vtk' % _format)
for ip in get_dofs(options.dofs, var.n_dof):
output('dof %d...' % ip)
vec.fill(0.0)
vec[ip] = 1.0
var.data_from_any(vec)
if options.derivative == 0:
out = var.create_output(vec, linearization=lin)
else:
out = create_expression_output('ev_grad.ie.Elements(u)',
'u', 'f', {'f' : field}, None,
Variables([var]),
mode='qp', verbose=False,
min_level=lin.min_level,
max_level=lin.max_level,
eps=lin.eps)
name = name_template % ip
out['u'].mesh.write(name, out=out)
output('...done (%s)' % name)
def save_basis_on_mesh(mesh,
options,
output_dir,
lin,
permutations=None,
suffix=''):
if permutations is not None:
mesh = mesh.copy()
for ig, conn in enumerate(mesh.conns):
gel = GeometryElement(mesh.descs[ig])
perms = gel.get_conn_permutations()[permutations]
n_el, n_ep = conn.shape
offsets = nm.arange(n_el) * n_ep
conn[:] = conn.take(perms + offsets[:, None])
domain = Domain('domain', mesh)
omega = domain.create_region('Omega', 'all')
field = Field.from_args('f',
nm.float64,
shape=1,
region=omega,
approx_order=options.max_order,
poly_space_base=options.basis)
var = FieldVariable('u', 'unknown', field, 1)
if options.plot_dofs:
import sfepy.postprocess.plot_dofs as pd
group = domain.groups[0]
ax = pd.plot_mesh(None, mesh.coors, mesh.conns[0], group.gel.edges)
ax = pd.plot_global_dofs(ax, field.get_coor(), field.aps[0].econn)
ax = pd.plot_local_dofs(ax, field.get_coor(), field.aps[0].econn)
if options.dofs is not None:
ax = pd.plot_nodes(ax, field.get_coor(), field.aps[0].econn,
field.aps[0].interp.poly_spaces['v'].nodes,
get_dofs(options.dofs, var.n_dof))
pd.plt.show()
output('dofs: %d' % var.n_dof)
vec = nm.empty(var.n_dof, dtype=var.dtype)
n_digit, _format = get_print_info(var.n_dof, fill='0')
name_template = os.path.join(output_dir,
'dof_%s%s.vtk' % (_format, suffix))
for ip in get_dofs(options.dofs, var.n_dof):
output('dof %d...' % ip)
vec.fill(0.0)
vec[ip] = 1.0
var.set_data(vec)
if options.derivative == 0:
out = var.create_output(vec, linearization=lin)
else:
out = create_expression_output('ev_grad.ie.Elements(u)',
'u',
'f', {'f': field},
None,
Variables([var]),
mode='qp',
verbose=False,
min_level=lin.min_level,
max_level=lin.max_level,
eps=lin.eps)
name = name_template % ip
ensure_path(name)
out['u'].mesh.write(name, out=out)
output('...done (%s)' % name)
def save_basis_on_mesh(mesh, options, output_dir, lin,
permutations=None, suffix=''):
if permutations is not None:
mesh = mesh.copy()
for ig, conn in enumerate(mesh.conns):
gel = GeometryElement(mesh.descs[ig])
perms = gel.get_conn_permutations()[permutations]
n_el, n_ep = conn.shape
offsets = nm.arange(n_el) * n_ep
conn[:] = conn.take(perms + offsets[:, None])
domain = Domain('domain', mesh)
omega = domain.create_region('Omega', 'all')
field = Field.from_args('f', nm.float64, shape=1, region=omega,
approx_order=options.max_order,
poly_space_base=options.basis)
var = FieldVariable('u', 'unknown', field, 1)
if options.plot_dofs:
import sfepy.postprocess.plot_dofs as pd
group = domain.groups[0]
ax = pd.plot_mesh(None, mesh.coors, mesh.conns[0], group.gel.edges)
ax = pd.plot_global_dofs(ax, field.get_coor(), field.aps[0].econn)
ax = pd.plot_local_dofs(ax, field.get_coor(), field.aps[0].econn)
if options.dofs is not None:
ax = pd.plot_nodes(ax, field.get_coor(), field.aps[0].econn,
field.aps[0].interp.poly_spaces['v'].nodes,
get_dofs(options.dofs, var.n_dof))
pd.plt.show()
output('dofs: %d' % var.n_dof)
vec = nm.empty(var.n_dof, dtype=var.dtype)
n_digit, _format = get_print_info(var.n_dof, fill='0')
name_template = os.path.join(output_dir,
'dof_%s%s.vtk' % (_format, suffix))
for ip in get_dofs(options.dofs, var.n_dof):
output('dof %d...' % ip)
vec.fill(0.0)
vec[ip] = 1.0
var.set_data(vec)
if options.derivative == 0:
out = var.create_output(vec, linearization=lin)
else:
out = create_expression_output('ev_grad.ie.Elements(u)',
'u', 'f', {'f' : field}, None,
Variables([var]),
mode='qp', verbose=False,
min_level=lin.min_level,
max_level=lin.max_level,
eps=lin.eps)
name = name_template % ip
ensure_path(name)
out['u'].mesh.write(name, out=out)
output('...done (%s)' % name)
def main():
parser = OptionParser(usage=usage, version='%prog')
parser.add_option('-b',
'--basis',
metavar='name',
action='store',
dest='basis',
default='lagrange',
help=help['basis'])
parser.add_option('-d',
'--derivative',
metavar='d',
type=int,
action='store',
dest='derivative',
default=0,
help=help['derivative'])
parser.add_option('-n',
'--max-order',
metavar='order',
type=int,
action='store',
dest='max_order',
default=2,
help=help['max_order'])
parser.add_option('-g',
'--geometry',
metavar='name',
action='store',
dest='geometry',
default='2_4',
help=help['geometry'])
parser.add_option('-m',
'--mesh',
metavar='mesh',
action='store',
dest='mesh',
default=None,
help=help['mesh'])
parser.add_option('',
'--permutations',
metavar='permutations',
action='store',
dest='permutations',
default=None,
help=help['permutations'])
parser.add_option('',
'--dofs',
metavar='dofs',
action='store',
dest='dofs',
default=None,
help=help['dofs'])
parser.add_option('-l',
'--lin-options',
metavar='options',
action='store',
dest='lin_options',
default='min_level=2,max_level=5,eps=1e-3',
help=help['lin_options'])
parser.add_option('',
'--plot-dofs',
action='store_true',
dest='plot_dofs',
default=False,
help=help['plot_dofs'])
options, args = parser.parse_args()
if len(args) == 1:
output_dir = args[0]
else:
parser.print_help(),
return
output('polynomial space:', options.basis)
output('max. order:', options.max_order)
lin = Struct(kind='adaptive', min_level=2, max_level=5, eps=1e-3)
for opt in options.lin_options.split(','):
key, val = opt.split('=')
setattr(lin, key, eval(val))
if options.mesh is None:
dim, n_ep = int(options.geometry[0]), int(options.geometry[2])
output('reference element geometry:')
output(' dimension: %d, vertices: %d' % (dim, n_ep))
gel = GeometryElement(options.geometry)
gps = PolySpace.any_from_args(None, gel, 1, base=options.basis)
ps = PolySpace.any_from_args(None,
gel,
options.max_order,
base=options.basis)
n_digit, _format = get_print_info(ps.n_nod, fill='0')
name_template = os.path.join(output_dir, 'bf_%s.vtk' % _format)
for ip in get_dofs(options.dofs, ps.n_nod):
output('shape function %d...' % ip)
def eval_dofs(iels, rx):
if options.derivative == 0:
bf = ps.eval_base(rx).squeeze()
rvals = bf[None, :, ip:ip + 1]
else:
bfg = ps.eval_base(rx, diff=True)
rvals = bfg[None, ..., ip]
return rvals
def eval_coors(iels, rx):
bf = gps.eval_base(rx).squeeze()
coors = nm.dot(bf, gel.coors)[None, ...]
return coors
(level, coors, conn, vdofs,
mat_ids) = create_output(eval_dofs,
eval_coors,
1,
ps,
min_level=lin.min_level,
max_level=lin.max_level,
eps=lin.eps)
out = {
'bf':
Struct(name='output_data',
mode='vertex',
data=vdofs,
var_name='bf',
dofs=None)
}
mesh = Mesh.from_data('bf_mesh', coors, None, [conn], [mat_ids],
[options.geometry])
name = name_template % ip
mesh.write(name, out=out)
output('...done (%s)' % name)
else:
mesh = Mesh.from_file(options.mesh)
output('mesh geometry:')
output(' dimension: %d, vertices: %d, elements: %d' %
(mesh.dim, mesh.n_nod, mesh.n_el))
domain = Domain('domain', mesh)
if options.permutations:
permutations = [int(ii) for ii in options.permutations.split(',')]
output('using connectivity permutations:', permutations)
for group in domain.iter_groups():
perms = group.gel.get_conn_permutations()[permutations]
offsets = nm.arange(group.shape.n_el) * group.shape.n_ep
group.conn[:] = group.conn.take(perms + offsets[:, None])
domain.setup_facets()
omega = domain.create_region('Omega', 'all')
field = Field.from_args('f',
nm.float64,
shape=1,
region=omega,
approx_order=options.max_order,
poly_space_base=options.basis)
var = FieldVariable('u', 'unknown', field, 1)
if options.plot_dofs:
import sfepy.postprocess.plot_dofs as pd
group = domain.groups[0]
ax = pd.plot_mesh(None, mesh.coors, mesh.conns[0], group.gel.edges)
ax = pd.plot_global_dofs(ax, field.get_coor(), field.aps[0].econn)
ax = pd.plot_local_dofs(ax, field.get_coor(), field.aps[0].econn)
if options.dofs is not None:
ax = pd.plot_nodes(ax, field.get_coor(), field.aps[0].econn,
field.aps[0].interp.poly_spaces['v'].nodes,
get_dofs(options.dofs, var.n_dof))
pd.plt.show()
output('dofs: %d' % var.n_dof)
vec = nm.empty(var.n_dof, dtype=var.dtype)
n_digit, _format = get_print_info(var.n_dof, fill='0')
name_template = os.path.join(output_dir, 'dof_%s.vtk' % _format)
for ip in get_dofs(options.dofs, var.n_dof):
output('dof %d...' % ip)
vec.fill(0.0)
vec[ip] = 1.0
var.set_data(vec)
if options.derivative == 0:
out = var.create_output(vec, linearization=lin)
else:
out = create_expression_output('ev_grad.ie.Elements(u)',
'u',
'f', {'f': field},
None,
Variables([var]),
mode='qp',
verbose=False,
min_level=lin.min_level,
max_level=lin.max_level,
eps=lin.eps)
name = name_template % ip
out['u'].mesh.write(name, out=out)
output('...done (%s)' % name)