def from_conf(conf,
variables,
regions,
materials,
integrals,
user=None,
verbose=True):
objs = OneTypeList(Equation)
conf = copy(conf)
ii = 0
for name, desc in conf.iteritems():
if verbose:
output('equation "%s":' % name)
output(desc)
eq = Equation.from_desc(name,
desc,
variables,
regions,
materials,
integrals,
user=user)
objs.append(eq)
ii += 1
obj = Equations(objs)
return obj
def reset_regions(self):
"""
Reset the list of regions associated with the domain.
"""
self.regions = OneTypeList(Region)
self._region_stack = []
self._bnf = create_bnf(self._region_stack)
def semideep_copy(self):
"""Copy materials, while external data (e.g. region) remain shared."""
others = copy(self)
others.update(OneTypeList(Material))
for mat in self:
other = mat.copy(name=mat.name)
other.reset()
others.append(other)
return others
def from_conf(conf):
objs = OneTypeList(Function)
for key, fc in conf.iteritems():
fun = Function(name = fc.name,
function = fc.function,
is_constant = False,
extra_args = {})
objs.append(fun)
obj = Functions(objs)
return obj
def from_file_hdf5(filename, var_names):
"""TODO: do not read entire file, provide data on demand."""
io = HDF5MeshIO(filename)
ts = TimeStepper(*io.read_time_stepper())
steps = nm.arange(ts.n_step, dtype=nm.int32)
ths = io.read_variables_time_history(var_names, ts)
objs = OneTypeList(History)
for name, th in ths.iteritems():
hist = History(name, steps=steps, times=ts.times, th=th)
objs.append(hist)
obj = Histories(objs, dt=ts.dt, name=' '.join(var_names))
return obj
def from_conf(conf, functions, wanted=None):
"""
Construct Materials instance from configuration.
"""
if wanted is None:
wanted = list(conf.keys())
objs = OneTypeList(Material)
for key, mc in six.iteritems(conf):
if key not in wanted: continue
mat = Material.from_conf(mc, functions)
objs.append(mat)
obj = Materials(objs)
return obj
def from_conf(conf):
objs = OneTypeList(Integral)
for desc in conf.itervalues():
if hasattr(desc, 'vals'):
aux = Integral(desc.name,
coors=desc.vals,
weights=desc.weights)
else:
aux = Integral(desc.name, order=desc.order)
objs.append(aux)
obj = Integrals(objs)
return obj
def read_spline_box_hdf5(filename):
if not pt.isHDF5File(filename):
raise ValueError, 'not a HDF5 file! (%s)' % filename
fd = pt.openFile(filename, mode='r')
boxes = fd.listNodes('/box')
n_box = len(boxes)
dim = len(fd.listNodes(boxes[0].ax))
sp_boxes = SplineBoxes(dim=dim,
n_box=n_box,
n_vertex=0,
spbs=OneTypeList(SplineBox))
for box in boxes:
spb = SplineBox()
sp_boxes.spbs.append(spb)
spb.ib = int(box._v_name)
spb.cpi = nm.asarray(box.cpi.read()) - 1
spb.gpi = nm.asarray(box.gpi.read()) - 1
spb.cxyz = nm.asarray(box.cxyz.read()).transpose()
spb.cxyz0 = spb.cxyz.copy()
spb.ax = []
for axi in fd.listNodes(box.ax):
spb.ax.append(nm.asarray(axi.bsc.read()))
sp_boxes.n_vertex = max(sp_boxes.n_vertex, nm.amax(spb.gpi) + 1)
print nm.amin(spb.gpi), nm.amax(spb.gpi)
##
# Fix cpi by rebuilding :).
off = 0
n0, n1, n2 = spb.cpi.shape
aux = nm.arange(n0 * n1).reshape(n1, n0).transpose()
for ii in xrange(n2):
spb.cpi[:, :, ii] = aux + off
off += n0 * n1
fd.close()
for perm in cycle([n_box] * 2):
if perm[0] == perm[1]: continue
gpi1 = sp_boxes.spbs[perm[0]].gpi
gpi2 = sp_boxes.spbs[perm[1]].gpi
assert_(len(nm.intersect1d(gpi1, gpi2)) == 0)
return sp_boxes
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 create_evaluable(expression, fields, materials, variables, integrals,
regions=None,
ebcs=None, epbcs=None, lcbcs=None, ts=None, functions=None,
auto_init=False, mode='eval', extra_args=None,
verbose=True, kwargs=None):
"""
Create evaluable object (equations and corresponding variables)
from the `expression` string.
Parameters
----------
expression : str
The expression to evaluate.
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.
integrals : Integrals instance
The integrals to be used.
regions : Region instance or list of Region instances
The region(s) to be used. If not given, the regions defined
within the fields domain are used.
ebcs : Conditions instance, optional
The essential (Dirichlet) boundary conditions for 'weak'
mode.
epbcs : Conditions instance, optional
The periodic boundary conditions for 'weak'
mode.
lcbcs : Conditions instance, optional
The linear combination boundary conditions for 'weak'
mode.
ts : TimeStepper instance, optional
The time stepper.
functions : Functions instance, optional
The user functions for boundary conditions, materials
etc.
auto_init : bool
Set values of all variables to all zeros.
mode : one of 'eval', 'el_avg', 'qp', 'weak'
The evaluation mode - 'weak' means the finite element
assembling, 'qp' requests the values in quadrature points,
'el_avg' element averages and 'eval' means integration over
each term region.
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.
Returns
-------
equation : Equation instance
The equation that is ready to be evaluated.
variables : Variables instance
The variables used in the equation.
"""
if kwargs is None:
kwargs = {}
if regions is not None:
if isinstance(regions, Region):
regions = [regions]
regions = OneTypeList(Region, regions)
else:
regions = fields[fields.keys()[0]].domain.regions
# Create temporary variables.
aux_vars = Variables(variables)
if extra_args is None:
extra_args = kwargs
else:
extra_args = copy(extra_args)
extra_args.update(kwargs)
if ts is not None:
extra_args.update({'ts' : ts})
equations = Equations.from_conf({'tmp' : expression},
aux_vars, regions, materials, integrals,
user=extra_args, verbose=verbose)
equations.collect_conn_info()
# The true variables used in the expression.
variables = equations.variables
if auto_init:
for var in variables:
var.init_data(step=0)
if mode == 'weak':
equations.time_update(ts, ebcs, epbcs, lcbcs, functions,
verbose=verbose)
else:
setup_extra_data(equations.conn_info)
return equations, variables
