def linearize(self, dofs, min_level=0, max_level=1, eps=1e-4):
"""
Linearize the solution for post-processing.
Parameters
----------
dofs : array, shape (n_nod, n_component)
The array of DOFs reshaped so that each column corresponds
to one component.
min_level : int
The minimum required level of mesh refinement.
max_level : int
The maximum level of mesh refinement.
eps : float
The relative tolerance parameter of mesh adaptivity.
Returns
-------
mesh : Mesh instance
The adapted, nonconforming, mesh.
vdofs : array
The DOFs defined in vertices of `mesh`.
levels : array of ints
The refinement level used for each element group.
"""
assert_(dofs.ndim == 2)
n_nod, dpn = dofs.shape
assert_(n_nod == self.n_nod)
assert_(dpn == self.shape[0])
vertex_coors = self.coors[:self.n_vertex_dof, :]
ap = self.ap
ps = ap.interp.poly_spaces['v']
gps = ap.interp.gel.interp.poly_spaces['v']
vertex_conn = ap.econn[:, :self.gel.n_vertex]
eval_dofs = get_eval_dofs(dofs, ap.econn, ps, ori=ap.ori)
eval_coors = get_eval_coors(vertex_coors, vertex_conn, gps)
(level, coors, conn, vdofs,
mat_ids) = create_output(eval_dofs,
eval_coors,
vertex_conn.shape[0],
ps,
min_level=min_level,
max_level=max_level,
eps=eps)
mesh = Mesh.from_data('linearized_mesh', coors, None, [conn],
[mat_ids], self.domain.mesh.descs)
return mesh, vdofs, level
def linearize(self, dofs, min_level=0, max_level=1, eps=1e-4):
"""
Linearize the solution for post-processing.
Parameters
----------
dofs : array, shape (n_nod, n_component)
The array of DOFs reshaped so that each column corresponds
to one component.
min_level : int
The minimum required level of mesh refinement.
max_level : int
The maximum level of mesh refinement.
eps : float
The relative tolerance parameter of mesh adaptivity.
Returns
-------
mesh : Mesh instance
The adapted, nonconforming, mesh.
vdofs : array
The DOFs defined in vertices of `mesh`.
levels : array of ints
The refinement level used for each element group.
"""
assert_(dofs.ndim == 2)
n_nod, dpn = dofs.shape
assert_(n_nod == self.n_nod)
assert_(dpn == self.shape[0])
vertex_coors = self.coors[:self.n_vertex_dof, :]
ap = self.ap
ps = ap.interp.poly_spaces['v']
gps = ap.interp.gel.interp.poly_spaces['v']
vertex_conn = ap.econn[:, :self.gel.n_vertex]
eval_dofs = get_eval_dofs(dofs, ap.econn, ps, ori=ap.ori)
eval_coors = get_eval_coors(vertex_coors, vertex_conn, gps)
(level, coors, conn,
vdofs, mat_ids) = create_output(eval_dofs, eval_coors,
vertex_conn.shape[0], ps,
min_level=min_level,
max_level=max_level, eps=eps)
mesh = Mesh.from_data('linearized_mesh', coors, None, [conn], [mat_ids],
self.domain.mesh.descs)
return mesh, vdofs, level
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
ensure_path(name)
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))
if options.permutations:
if options.permutations == 'all':
from sfepy.linalg import cycle
gel = GeometryElement(mesh.descs[0])
n_perms = gel.get_conn_permutations().shape[0]
all_permutations = [ii for ii in cycle(mesh.n_el * [n_perms])]
else:
all_permutations = [int(ii)
for ii in options.permutations.split(',')]
all_permutations = nm.array(all_permutations)
np = len(all_permutations)
all_permutations.shape = (np / mesh.n_el, mesh.n_el)
output('using connectivity permutations:\n', all_permutations)
else:
all_permutations = [None]
for ip, permutations in enumerate(all_permutations):
if permutations is None:
suffix = ''
else:
suffix = '_' + '_'.join('%d' % ii for ii in permutations)
save_basis_on_mesh(mesh, options, output_dir, lin, permutations,
suffix)
def linearize(self, dofs, min_level=0, max_level=1, eps=1e-4):
"""
Linearize the solution for post-processing.
Parameters
----------
dofs : array, shape (n_nod, n_component)
The array of DOFs reshaped so that each column corresponds
to one component.
min_level : int
The minimum required level of mesh refinement.
max_level : int
The maximum level of mesh refinement.
eps : float
The relative tolerance parameter of mesh adaptivity.
Returns
-------
mesh : Mesh instance
The adapted, nonconforming, mesh.
vdofs : array
The DOFs defined in vertices of `mesh`.
levels : array of ints
The refinement level used for each element group.
"""
assert_(dofs.ndim == 2)
n_nod, dpn = dofs.shape
assert_(n_nod == self.n_nod)
assert_(dpn == self.shape[0])
vertex_coors = self.coors[:self.n_vertex_dof, :]
coors = []
vdofs = []
conns = []
mat_ids = []
levels = []
offset = 0
for ig, ap in self.aps.iteritems():
ps = ap.interp.poly_spaces['v']
gps = ap.interp.gel.interp.poly_spaces['v']
group = self.domain.groups[ig]
vertex_conn = ap.econn[:, :group.shape.n_ep]
eval_dofs = get_eval_dofs(dofs, ap.econn, ps, ori=ap.ori)
eval_coors = get_eval_coors(vertex_coors, vertex_conn, gps)
(level, _coors, conn,
_vdofs, _mat_ids) = create_output(eval_dofs, eval_coors,
group.shape.n_el, ps,
min_level=min_level,
max_level=max_level, eps=eps)
_mat_ids[:] = self.domain.mesh.mat_ids[ig][0]
coors.append(_coors)
vdofs.append(_vdofs)
conns.append(conn + offset)
mat_ids.append(_mat_ids)
levels.append(level)
offset += _coors.shape[0]
coors = nm.concatenate(coors, axis=0)
vdofs = nm.concatenate(vdofs, axis=0)
mesh = Mesh.from_data('linearized_mesh', coors, None, conns, mat_ids,
self.domain.mesh.descs)
return mesh, vdofs, levels
def create_expression_output(expression, name, primary_field_name,
fields, materials, variables,
functions=None, mode='eval', term_mode=None,
extra_args=None, verbose=True, kwargs=None,
min_level=0, max_level=1, eps=1e-4):
"""
Create output mesh and data for the expression using the adaptive
linearizer.
Parameters
----------
expression : str
The expression to evaluate.
name : str
The name of the data.
primary_field_name : str
The name of field that defines the element groups and polynomial
spaces.
fields : dict
The dictionary of fields used in `variables`.
materials : Materials instance
The materials used in the expression.
variables : Variables instance
The variables used in the expression.
functions : Functions instance, optional
The user functions for materials etc.
mode : one of 'eval', 'el_avg', 'qp'
The evaluation mode - 'qp' requests the values in quadrature points,
'el_avg' element averages and 'eval' means integration over
each term region.
term_mode : str
The term call mode - some terms support different call modes
and depending on the call mode different values are
returned.
extra_args : dict, optional
Extra arguments to be passed to terms in the expression.
verbose : bool
If False, reduce verbosity.
kwargs : dict, optional
The variables (dictionary of (variable name) : (Variable
instance)) to be used in the expression.
min_level : int
The minimum required level of mesh refinement.
max_level : int
The maximum level of mesh refinement.
eps : float
The relative tolerance parameter of mesh adaptivity.
Returns
-------
out : dict
The output dictionary.
"""
field = fields[primary_field_name]
vertex_coors = field.coors[:field.n_vertex_dof, :]
coors = []
vdofs = []
conns = []
mat_ids = []
levels = []
offset = 0
for ig, ap in field.aps.iteritems():
ps = ap.interp.poly_spaces['v']
gps = ap.interp.gel.interp.poly_spaces['v']
group = field.domain.groups[ig]
vertex_conn = ap.econn[:, :group.shape.n_ep]
eval_dofs = get_eval_expression(expression, ig,
fields, materials, variables,
functions=functions,
mode=mode, extra_args=extra_args,
verbose=verbose, kwargs=kwargs)
eval_coors = get_eval_coors(vertex_coors, vertex_conn, gps)
(level, _coors, conn,
_vdofs, _mat_ids) = create_output(eval_dofs, eval_coors,
group.shape.n_el, ps,
min_level=min_level,
max_level=max_level, eps=eps)
_mat_ids[:] = field.domain.mesh.mat_ids[ig][0]
coors.append(_coors)
vdofs.append(_vdofs)
conns.append(conn + offset)
mat_ids.append(_mat_ids)
levels.append(level)
offset += _coors.shape[0]
coors = nm.concatenate(coors, axis=0)
vdofs = nm.concatenate(vdofs, axis=0)
mesh = Mesh.from_data('linearized_mesh', coors, None, conns, mat_ids,
field.domain.mesh.descs)
out = {}
out[name] = Struct(name='output_data', mode='vertex',
data=vdofs, var_name=name, dofs=None,
mesh=mesh, levels=levels)
out = convert_complex_output(out)
return out
def create_expression_output(expression, name, primary_field_name,
fields, materials, variables,
functions=None, mode='eval', term_mode=None,
extra_args=None, verbose=True, kwargs=None,
min_level=0, max_level=1, eps=1e-4):
"""
Create output mesh and data for the expression using the adaptive
linearizer.
Parameters
----------
expression : str
The expression to evaluate.
name : str
The name of the data.
primary_field_name : str
The name of field that defines the element groups and polynomial
spaces.
fields : dict
The dictionary of fields used in `variables`.
materials : Materials instance
The materials used in the expression.
variables : Variables instance
The variables used in the expression.
functions : Functions instance, optional
The user functions for materials etc.
mode : one of 'eval', 'el_avg', 'qp'
The evaluation mode - 'qp' requests the values in quadrature points,
'el_avg' element averages and 'eval' means integration over
each term region.
term_mode : str
The term call mode - some terms support different call modes
and depending on the call mode different values are
returned.
extra_args : dict, optional
Extra arguments to be passed to terms in the expression.
verbose : bool
If False, reduce verbosity.
kwargs : dict, optional
The variables (dictionary of (variable name) : (Variable
instance)) to be used in the expression.
min_level : int
The minimum required level of mesh refinement.
max_level : int
The maximum level of mesh refinement.
eps : float
The relative tolerance parameter of mesh adaptivity.
Returns
-------
out : dict
The output dictionary.
"""
field = fields[primary_field_name]
vertex_coors = field.coors[:field.n_vertex_dof, :]
ps = field.poly_space
gps = field.gel.poly_space
vertex_conn = field.econn[:, :field.gel.n_vertex]
eval_dofs = get_eval_expression(expression,
fields, materials, variables,
functions=functions,
mode=mode, extra_args=extra_args,
verbose=verbose, kwargs=kwargs)
eval_coors = get_eval_coors(vertex_coors, vertex_conn, gps)
(level, coors, conn,
vdofs, mat_ids) = create_output(eval_dofs, eval_coors,
vertex_conn.shape[0], ps,
min_level=min_level,
max_level=max_level, eps=eps)
mesh = Mesh.from_data('linearized_mesh', coors, None, [conn], [mat_ids],
field.domain.mesh.descs)
out = {}
out[name] = Struct(name='output_data', mode='vertex',
data=vdofs, var_name=name, dofs=None,
mesh=mesh, level=level)
out = convert_complex_output(out)
return out
def linearize(self, dofs, min_level=0, max_level=1, eps=1e-4):
"""
Linearize the solution for post-processing.
Parameters
----------
dofs : array, shape (n_nod, n_component)
The array of DOFs reshaped so that each column corresponds
to one component.
min_level : int
The minimum required level of mesh refinement.
max_level : int
The maximum level of mesh refinement.
eps : float
The relative tolerance parameter of mesh adaptivity.
Returns
-------
mesh : Mesh instance
The adapted, nonconforming, mesh.
vdofs : array
The DOFs defined in vertices of `mesh`.
levels : array of ints
The refinement level used for each element group.
"""
assert_(dofs.ndim == 2)
n_nod, dpn = dofs.shape
assert_(n_nod == self.n_nod)
assert_(dpn == self.shape[0])
vertex_coors = self.coors[:self.n_vertex_dof, :]
coors = []
vdofs = []
conns = []
mat_ids = []
levels = []
offset = 0
for ig, ap in self.aps.iteritems():
ps = ap.interp.poly_spaces['v']
gps = ap.interp.gel.interp.poly_spaces['v']
group = self.domain.groups[ig]
vertex_conn = ap.econn[:, :group.shape.n_ep]
eval_dofs = get_eval_dofs(dofs, ap.econn, ps, ori=ap.ori)
eval_coors = get_eval_coors(vertex_coors, vertex_conn, gps)
(level, _coors, conn,
_vdofs, _mat_ids) = create_output(eval_dofs, eval_coors,
group.shape.n_el, ps,
min_level=min_level,
max_level=max_level, eps=eps)
_mat_ids[:] = self.domain.mesh.mat_ids[ig][0]
coors.append(_coors)
vdofs.append(_vdofs)
conns.append(conn + offset)
mat_ids.append(_mat_ids)
levels.append(level)
offset += _coors.shape[0]
coors = nm.concatenate(coors, axis=0)
vdofs = nm.concatenate(vdofs, axis=0)
mesh = Mesh.from_data('linearized_mesh', coors, None, conns, mat_ids,
self.domain.mesh.descs)
return mesh, vdofs, levels
def create_expression_output(
expression,
name,
primary_field_name,
fields,
materials,
variables,
functions=None,
mode="eval",
term_mode=None,
extra_args=None,
verbose=True,
kwargs=None,
min_level=0,
max_level=1,
eps=1e-4,
):
"""
Create output mesh and data for the expression using the adaptive
linearizer.
Parameters
----------
expression : str
The expression to evaluate.
name : str
The name of the data.
primary_field_name : str
The name of field that defines the element groups and polynomial
spaces.
fields : dict
The dictionary of fields used in `variables`.
materials : Materials instance
The materials used in the expression.
variables : Variables instance
The variables used in the expression.
functions : Functions instance, optional
The user functions for materials etc.
mode : one of 'eval', 'el_avg', 'qp'
The evaluation mode - 'qp' requests the values in quadrature points,
'el_avg' element averages and 'eval' means integration over
each term region.
term_mode : str
The term call mode - some terms support different call modes
and depending on the call mode different values are
returned.
extra_args : dict, optional
Extra arguments to be passed to terms in the expression.
verbose : bool
If False, reduce verbosity.
kwargs : dict, optional
The variables (dictionary of (variable name) : (Variable
instance)) to be used in the expression.
min_level : int
The minimum required level of mesh refinement.
max_level : int
The maximum level of mesh refinement.
eps : float
The relative tolerance parameter of mesh adaptivity.
Returns
-------
out : dict
The output dictionary.
"""
field = fields[primary_field_name]
vertex_coors = field.coors[: field.n_vertex_dof, :]
coors = []
vdofs = []
conns = []
mat_ids = []
levels = []
offset = 0
for ig, ap in field.aps.iteritems():
ps = ap.interp.poly_spaces["v"]
gps = ap.interp.gel.interp.poly_spaces["v"]
group = field.domain.groups[ig]
vertex_conn = ap.econn[:, : group.shape.n_ep]
eval_dofs = get_eval_expression(
expression,
ig,
fields,
materials,
variables,
functions=functions,
mode=mode,
extra_args=extra_args,
verbose=verbose,
kwargs=kwargs,
)
eval_coors = get_eval_coors(vertex_coors, vertex_conn, gps)
(level, _coors, conn, _vdofs, _mat_ids) = create_output(
eval_dofs, eval_coors, group.shape.n_el, ps, min_level=min_level, max_level=max_level, eps=eps
)
_mat_ids[:] = field.domain.mesh.mat_ids[ig][0]
coors.append(_coors)
vdofs.append(_vdofs)
conns.append(conn + offset)
mat_ids.append(_mat_ids)
levels.append(level)
offset += _coors.shape[0]
coors = nm.concatenate(coors, axis=0)
vdofs = nm.concatenate(vdofs, axis=0)
mesh = Mesh.from_data("linearized_mesh", coors, None, conns, mat_ids, field.domain.mesh.descs)
out = {}
out[name] = Struct(
name="output_data", mode="vertex", data=vdofs, var_name=name, dofs=None, mesh=mesh, levels=levels
)
out = convert_complex_output(out)
return out
