def get(self, variable, quantity_name, bf=None, integration=None, step=None, time_derivative=None):
"""
Get the named quantity related to the variable.
Notes
-----
This is a convenience wrapper of Variable.evaluate() that
initializes the arguments using the term data.
"""
name = variable.name
step = get_default(step, self.arg_steps[name])
time_derivative = get_default(time_derivative, self.arg_derivatives[name])
integration = get_default(integration, self.geometry_types[name])
data = variable.evaluate(
mode=quantity_name,
region=self.region,
integral=self.integral,
integration=integration,
step=step,
time_derivative=time_derivative,
is_trace=self.arg_traces[name],
bf=bf,
)
return data
def _standard_call(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None,
i_max=None, mtx=None, status=None, context=None,
**kwargs):
tt = time.clock()
conf = get_default(conf, self.conf)
mtx = get_default(mtx, self.mtx)
status = get_default(status, self.status)
context = get_default(context, self.context)
assert_(mtx.shape[0] == mtx.shape[1] == rhs.shape[0])
if x0 is not None:
assert_(x0.shape[0] == rhs.shape[0])
result = call(self, rhs, x0, conf, eps_a, eps_r, i_max, mtx, status,
context=context, **kwargs)
if isinstance(result, tuple):
result, n_iter = result
else:
n_iter = -1 # Number of iterations is undefined/unavailable.
ttt = time.clock() - tt
if status is not None:
status['time'] = ttt
status['n_iter'] = n_iter
return result
def save_results(self, eigs, mtx_phi, out=None,
mesh_results_name=None, eig_results_name=None):
mesh_results_name = get_default(mesh_results_name,
self.mesh_results_name)
eig_results_name = get_default(eig_results_name,
self.eig_results_name)
pb = self.problem
save = self.app_options.save_eig_vectors
n_eigs = self.app_options.n_eigs
out = get_default(out, {})
state = pb.create_state()
aux = {}
for ii in range(eigs.shape[0]):
if save is not None:
if (ii > save[0]) and (ii < (n_eigs - save[1])): continue
state.set_full(mtx_phi[:,ii])
aux = state.create_output_dict()
key = list(aux.keys())[0]
out[key+'%03d' % ii] = aux[key]
if aux.get('__mesh__') is not None:
out['__mesh__'] = aux['__mesh__']
pb.save_state(mesh_results_name, out=out)
fd = open(eig_results_name, 'w')
eigs.tofile(fd, ' ')
fd.close()
def setup_output(
self,
output_filename_trunk=None,
output_dir=None,
output_format=None,
float_format=None,
file_per_var=None,
linearization=None,
):
"""
Sets output options to given values, or uses the defaults for
each argument that is None.
"""
self.output_modes = {"vtk": "sequence", "h5": "single"}
self.ofn_trunk = get_default(output_filename_trunk, io.get_trunk(self.domain.name))
self.set_output_dir(output_dir)
self.output_format = get_default(output_format, "vtk")
self.float_format = get_default(float_format, None)
self.file_per_var = get_default(file_per_var, False)
self.linearization = get_default(linearization, Struct(kind="strip"))
if (self.output_format == "h5") and (self.linearization.kind == "adaptive"):
self.linearization.kind = None
def _petsc_call(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None,
i_max=None, mtx=None, status=None, comm=None,
context=None, **kwargs):
tt = time.clock()
conf = get_default(conf, self.conf)
mtx = get_default(mtx, self.mtx)
status = get_default(status, self.status)
context = get_default(context, self.context)
comm = get_default(comm, self.comm)
mshape = mtx.size if isinstance(mtx, self.petsc.Mat) else mtx.shape
rshape = [rhs.size] if isinstance(rhs, self.petsc.Vec) else rhs.shape
assert_(mshape[0] == mshape[1] == rshape[0])
if x0 is not None:
xshape = [x0.size] if isinstance(x0, self.petsc.Vec) else x0.shape
assert_(xshape[0] == rshape[0])
result = call(self, rhs, x0, conf, eps_a, eps_r, i_max, mtx, status,
comm, context=context, **kwargs)
ttt = time.clock() - tt
if status is not None:
status['time'] = ttt
status['n_iter'] = self.ksp.getIterationNumber()
return result
def __call__(self, x0, conf=None, obj_fun=None, obj_fun_grad=None,
status=None, obj_args=None):
if conf is not None:
self.set_method(conf)
else:
conf = self.conf
obj_fun = get_default(obj_fun, self.obj_fun)
obj_fun_grad = get_default(obj_fun_grad, self.obj_fun_grad)
status = get_default(status, self.status)
obj_args = get_default(obj_args, self.obj_args)
tt = time.clock()
kwargs = {self._i_max_name[conf.method] : conf.i_max,
'disp' : conf.verbose,
'args' : obj_args}
if conf.method in self._has_grad:
kwargs['fprime'] = obj_fun_grad
for key, val in conf.to_dict().iteritems():
if key not in self._omit:
kwargs[key] = val
out = self.solver(obj_fun, x0, **kwargs)
if status is not None:
status['time_stats'] = time.clock() - tt
return out
def solve_pressure_eigenproblem(self, mtx, eig_problem=None,
n_eigs=0, check=False):
"""G = B*AI*BT or B*AI*BT+D"""
def get_slice(n_eigs, nn):
if n_eigs > 0:
ii = slice(0, n_eigs)
elif n_eigs < 0:
ii = slice(nn + n_eigs, nn)
else:
ii = slice(0, 0)
return ii
eig_problem = get_default(eig_problem, self.eig_problem)
n_eigs = get_default(n_eigs, self.n_eigs)
check = get_default(check, self.check)
mtx_c, mtx_b, action_aibt = mtx['C'], mtx['B'], mtx['action_aibt']
mtx_g = mtx_b * action_aibt.to_array() # mtx_b must be sparse!
if eig_problem == 'B*AI*BT+D':
mtx_g += mtx['D'].toarray()
mtx['G'] = mtx_g
output(mtx_c.shape, mtx_g.shape)
eigs, mtx_q = eig(mtx_c.toarray(), mtx_g, method='eig.sgscipy')
if check:
ee = nm.diag(sc.dot(mtx_q.T * mtx_c, mtx_q)).squeeze()
oo = nm.diag(sc.dot(sc.dot(mtx_q.T, mtx_g), mtx_q)).squeeze()
try:
assert_(nm.allclose(ee, eigs))
assert_(nm.allclose(oo, nm.ones_like(eigs)))
except ValueError:
debug()
nn = mtx_c.shape[0]
if isinstance(n_eigs, tuple):
output('required number of eigenvalues: (%d, %d)' % n_eigs)
if sum(n_eigs) < nn:
ii0 = get_slice(n_eigs[0], nn)
ii1 = get_slice(-n_eigs[1], nn)
eigs = nm.concatenate((eigs[ii0], eigs[ii1]))
mtx_q = nm.concatenate((mtx_q[:,ii0], mtx_q[:,ii1]), 1)
else:
output('required number of eigenvalues: %d' % n_eigs)
if (n_eigs != 0) and (abs(n_eigs) < nn):
ii = get_slice(n_eigs, nn)
eigs = eigs[ii]
mtx_q = mtx_q[:,ii]
## from sfepy.base.plotutils import pylab, iplot
## pylab.semilogy(eigs)
## pylab.figure(2)
## iplot(eigs)
## pylab.show()
## debug()
out = Struct(eigs=eigs, mtx_q=mtx_q)
return out
def __call__(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None,
i_max=None, mtx=None, status=None, **kwargs):
eps_a = get_default(eps_a, self.conf.eps_a)
eps_r = get_default(eps_r, self.conf.eps_r)
i_max = get_default(i_max, self.conf.i_max)
eps_d = self.conf.eps_d
# There is no use in caching matrix in the solver - always set as new.
pmtx, psol, prhs = self.set_matrix(mtx)
ksp = self.ksp
ksp.setOperators(pmtx)
ksp.setFromOptions() # PETSc.Options() not used yet...
ksp.setTolerances(atol=eps_a, rtol=eps_r, divtol=eps_d, max_it=i_max)
# Set PETSc rhs, solve, get solution from PETSc solution.
if x0 is not None:
psol[...] = x0
ksp.setInitialGuessNonzero(True)
prhs[...] = rhs
ksp.solve(prhs, psol)
sol = psol[...].copy()
output('%s(%s) convergence: %s (%s)'
% (self.conf.method, self.conf.precond,
ksp.reason, self.converged_reasons[ksp.reason]))
return sol
def setup_ic( self, conf_ics = None, functions = None ):
conf_ics = get_default(conf_ics, self.conf.ics)
ics = Conditions.from_conf(conf_ics, self.domain.regions)
functions = get_default(functions, self.functions)
self.equations.setup_initial_conditions(ics, functions)
def __call__(self, vec_x0, conf=None, fun=None, fun_grad=None,
lin_solver=None, iter_hook=None, status=None):
if conf is not None:
self.set_method( conf )
else:
conf = self.conf
fun = get_default( fun, self.fun )
status = get_default( status, self.status )
tt = time.clock()
kwargs = {'iter' : conf.i_max,
'alpha' : conf.alpha,
'verbose' : conf.verbose}
if conf.method == 'broyden_generalized':
kwargs.update( {'M' : conf.M} )
elif conf.method in ['anderson', 'anderson2']:
kwargs.update( {'M' : conf.M, 'w0' : conf.w0} )
vec_x = self.solver( fun, vec_x0, **kwargs )
vec_x = nm.asarray(vec_x)
if status is not None:
status['time_stats'] = time.clock() - tt
return vec_x
def __call__(self, x0, conf=None, obj_fun=None, obj_fun_grad=None,
status=None, obj_args=None):
import inspect
if conf is not None:
self.set_method(conf)
else:
conf = self.conf
obj_fun = get_default(obj_fun, self.obj_fun)
obj_fun_grad = get_default(obj_fun_grad, self.obj_fun_grad)
status = get_default(status, self.status)
obj_args = get_default(obj_args, self.obj_args)
tt = time.clock()
kwargs = {self._i_max_name[conf.method] : conf.i_max,
'args' : obj_args}
if conf.method in self._has_grad:
kwargs['fprime'] = obj_fun_grad
if 'disp' in inspect.getargspec(self.solver)[0]:
kwargs['disp'] = conf.verbose
kwargs.update(self.build_solver_kwargs(conf))
out = self.solver(obj_fun, x0, **kwargs)
if status is not None:
status['time_stats'] = time.clock() - tt
return out
def setup_ics(self, ics=None, functions=None):
"""
Setup the initial conditions for use.
"""
self.set_ics(get_default(ics, self.ics))
functions = get_default(functions, self.functions)
self.equations.setup_initial_conditions(self.ics, functions)
def time_update(self, ts=None,
ebcs=None, epbcs=None, lcbcs=None,
functions=None, create_matrix=False):
self.set_bcs(get_default(ebcs, self.ebcs),
get_default(epbcs, self.epbcs),
get_default(lcbcs, self.lcbcs))
self.update_equations(ts, self.ebcs, self.epbcs, self.lcbcs,
functions, create_matrix)
def get_default_ts(self, t0=None, t1=None, dt=None, n_step=None, step=None):
t0 = get_default(t0, 0.0)
t1 = get_default(t1, 1.0)
dt = get_default(dt, 1.0)
n_step = get_default(n_step, 1)
ts = TimeStepper(t0, t1, dt, n_step, step=step)
return ts
def __init__(self, filename, approx, region_selects, mat_pars, options,
evp_options, eigenmomenta_options, band_gaps_options,
coefs_save_name='coefs',
corrs_save_names=None,
incwd=None,
output_dir=None, **kwargs):
Struct.__init__(self, approx=approx, region_selects=region_selects,
mat_pars=mat_pars, options=options,
evp_options=evp_options,
eigenmomenta_options=eigenmomenta_options,
band_gaps_options=band_gaps_options,
**kwargs)
self.incwd = get_default(incwd, lambda x: x)
self.conf = Struct()
self.conf.filename_mesh = self.incwd(filename)
output_dir = get_default(output_dir, self.incwd('output'))
default = {'evp' : 'evp', 'corrs_rs' : 'corrs_rs'}
self.corrs_save_names = get_default(corrs_save_names,
default)
io = MeshIO.any_from_filename(self.conf.filename_mesh)
self.bbox, self.dim = io.read_bounding_box(ret_dim=True)
rpc_axes = nm.eye(self.dim, dtype=nm.float64) \
* (self.bbox[1] - self.bbox[0])
self.conf.options = options
self.conf.options.update({
'output_dir' : output_dir,
'volume' : {
'value' : get_lattice_volume(rpc_axes),
},
'coefs' : 'coefs',
'requirements' : 'requirements',
'coefs_filename' : coefs_save_name,
})
self.conf.mat_pars = mat_pars
self.conf.solvers = self.define_solvers()
self.conf.regions = self.define_regions()
self.conf.materials = self.define_materials()
self.conf.fields = self.define_fields()
self.conf.variables = self.define_variables()
(self.conf.ebcs, self.conf.epbcs,
self.conf.lcbcs, self.all_periodic) = self.define_bcs()
self.conf.functions = self.define_functions()
self.conf.integrals = self.define_integrals()
self.equations, self.expr_coefs = self.define_equations()
self.conf.coefs = self.define_coefs()
self.conf.requirements = self.define_requirements()
def __init__(self, data_names=None, yscales=None,
xlabels=None, ylabels=None, is_plot=True, aggregate=200,
formats=None, log_filename=None):
"""`data_names` ... tuple of names grouped by subplots:
([name1, name2, ...], [name3, name4, ...], ...)
where name<n> are strings to display in (sub)plot legends."""
try:
import matplotlib as mpl
except:
mpl = None
if (mpl is not None) and mpl.rcParams['backend'] == 'GTKAgg':
can_live_plot = True
else:
can_live_plot = False
Struct.__init__(self, data_names = {},
n_arg = 0, n_gr = 0,
data = {}, x_values = {}, n_calls = 0,
yscales = {}, xlabels = {}, ylabels = {},
plot_pipe = None, formats = {}, output = None)
if data_names is not None:
n_gr = len(data_names)
else:
n_gr = 0
data_names = []
yscales = get_default(yscales, ['linear'] * n_gr)
xlabels = get_default(xlabels, ['iteration'] * n_gr)
ylabels = get_default(ylabels, [''] * n_gr )
if formats is None:
formats = [None] * n_gr
for ig, names in enumerate(data_names):
self.add_group(names, yscales[ig], xlabels[ig], ylabels[ig],
formats[ig])
self.is_plot = get_default( is_plot, True )
self.aggregate = get_default( aggregate, 100 )
self.can_plot = (can_live_plot and (mpl is not None)
and (Process is not None))
if log_filename is not None:
self.output = Output('', filename=log_filename)
self.output('# started: %s' % time.asctime())
self.output('# groups: %d' % n_gr)
for ig, names in enumerate(data_names):
self.output('# %d' % ig)
self.output('# xlabel: "%s", ylabel: "%s", yscales: "%s"'
% (xlabels[ig], ylabels[ig], yscales[ig]))
self.output('# names: "%s"' % ', '.join(names))
if self.is_plot and (not self.can_plot):
output(_msg_no_live)
def __call__(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None,
i_max=None, mtx=None, status=None, context=None, **kwargs):
solver_kwargs = self.build_solver_kwargs(conf)
eps_a = get_default(eps_a, self.conf.eps_a)
eps_r = get_default(eps_r, self.conf.eps_r)
i_max = get_default(i_max, self.conf.i_max)
setup_precond = get_default(kwargs.get('setup_precond', None),
self.conf.setup_precond)
callback = get_default(kwargs.get('callback', lambda sol: None),
self.conf.callback)
self.iter = 0
def iter_callback(sol):
self.iter += 1
msg = '%s: iteration %d' % (self.conf.name, self.iter)
if conf.verbose > 2:
if conf.method not in self._callbacks_res:
res = mtx * sol - rhs
else:
res = sol
rnorm = nm.linalg.norm(res)
msg += ': |Ax-b| = %e' % rnorm
output(msg, verbose=conf.verbose > 1)
# Call an optional user-defined callback.
callback(sol)
precond = setup_precond(mtx, context)
if conf.method == 'qmr':
prec_args = {'M1' : precond, 'M2' : precond}
else:
prec_args = {'M' : precond}
solver_kwargs.update(prec_args)
try:
sol, info = self.solver(mtx, rhs, x0=x0, atol=eps_a, tol=eps_r,
maxiter=i_max, callback=iter_callback,
**solver_kwargs)
except TypeError:
sol, info = self.solver(mtx, rhs, x0=x0, tol=eps_r,
maxiter=i_max, callback=iter_callback,
**solver_kwargs)
output('%s: %s convergence: %s (%s, %d iterations)'
% (self.conf.name, self.conf.method,
info, self.converged_reasons[nm.sign(info)], self.iter),
verbose=conf.verbose)
return sol, self.iter
def __call__(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None,
i_max=None, mtx=None, status=None, **kwargs):
conf = get_default(conf, self.conf)
mtx = get_default(mtx, self.mtx)
status = get_default(status, self.status)
if self.solve is not None:
# Matrix is already prefactorized.
return self.solve(rhs)
else:
return self.sls.spsolve(mtx, rhs)
def __call__( self, state0 = None, conf = None,
step_fun = None, step_args = None ):
step_fun = get_default( step_fun, self.step_fun )
step_args = get_default( step_args, self.step_args )
for step, time in self.ts:
output( self.format % (time, step + 1, self.ts.n_step) )
state = step_fun( self.ts, state0, *step_args )
state0 = state.copy(deep=True)
yield self.ts, state
def __call__(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None,
i_max=None, mtx=None, status=None, **kwargs):
conf = get_default(conf, self.conf)
mtx = get_default(mtx, self.mtx)
status = get_default(status, self.status)
mtxi= self.orig_conf.idxs
mtxslc_s = {}
mtxslc_f = {}
nn = {}
for ik, iv in mtxi.iteritems():
ptr = 0
nn[ik] = len(iv)
mtxslc_s[ik] = []
mtxslc_f[ik] = []
while ptr < nn[ik]:
idx0 = iv[ptr:]
idxrange = nm.arange(idx0[0], idx0[0] + len(idx0))
aux = nm.where(idx0 == idxrange)[0]
mtxslc_s[ik].append(slice(ptr + aux[0], ptr + aux[-1] + 1))
mtxslc_f[ik].append(slice(idx0[aux][0], idx0[aux][-1] + 1))
ptr += aux[-1] + 1
mtxs = {}
rhss = {}
ress = {}
for ir in mtxi.iterkeys():
rhss[ir] = nm.zeros((nn[ir],), dtype=nm.float64)
ress[ir] = nm.zeros((nn[ir],), dtype=nm.float64)
for jr, idxr in enumerate(mtxslc_f[ir]):
rhss[ir][mtxslc_s[ir][jr]] = rhs[idxr]
for ic in mtxi.iterkeys():
mtxid = '%s%s' % (ir, ic)
mtxs[mtxid] = nm.zeros((nn[ir], nn[ic]), dtype=nm.float64)
for jr, idxr in enumerate(mtxslc_f[ir]):
for jc, idxc in enumerate(mtxslc_f[ic]):
iir = mtxslc_s[ir][jr]
iic = mtxslc_s[ic][jc]
mtxs[mtxid][iir, iic] = mtx._get_submatrix(idxr, idxc).todense()
self.orig_conf.function(ress, mtxs, rhss, nn)
res = nm.zeros_like(rhs)
for ir in mtxi.iterkeys():
for jr, idxr in enumerate(mtxslc_f[ir]):
res[idxr] = ress[ir][mtxslc_s[ir][jr]]
return res
def solve(mtx, rhs, solver_class=None, solver_conf=None):
"""
Solve the linear system with the matrix `mtx` and the right-hand side
`rhs`.
Convenience wrapper around the linear solver classes below.
"""
solver_class = get_default(solver_class, ScipyDirect)
solver_conf = get_default(solver_conf, {})
solver = solver_class(solver_conf, mtx=mtx)
solution = solver(rhs)
return solution
def __call__(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None,
i_max=None, mtx=None, status=None, **kwargs):
conf = get_default(conf, self.conf)
eps_r = get_default(eps_r, self.eps_r)
mtx = get_default(mtx, self.mtx)
status = get_default(status, self.status)
if (self.mg is None) or (mtx is not self.mtx):
self.mg = self.solver(mtx)
self.mtx = mtx
sol = self.mg.solve(rhs, x0=x0, accel=conf.accel, tol=eps_r)
return sol
def __call__(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None,
i_max=None, mtx=None, status=None, **kwargs):
eps_r = get_default(eps_r, self.conf.eps_r)
i_max = get_default(i_max, self.conf.i_max)
if (self.mg is None) or (mtx is not self.mtx):
self.mg = self.solver(mtx)
self.mtx = mtx
sol = self.mg.solve(rhs, x0=x0, accel=conf.accel, tol=eps_r,
maxiter=i_max)
return sol
def __call__(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None,
i_max=None, mtx=None, status=None, **kwargs):
conf = get_default(conf, self.conf)
eps_r = get_default(eps_r, self.conf.eps_r)
i_max = get_default(i_max, self.conf.i_max)
mtx = get_default(mtx, self.mtx)
status = get_default(status, self.status)
sol, info = self.solver(mtx, rhs, x0=x0, tol=eps_r, maxiter=i_max)
output('%s convergence: %s (%s)'
% (self.conf.method,
info, self.converged_reasons[nm.sign(info)]))
return sol
def __call__(self, vec0=None, nls=None, init_fun=None, prestep_fun=None,
poststep_fun=None, status=None, **kwargs):
"""
Solve elastodynamics problems by the generalized :math:`\alpha` method.
"""
conf = self.conf
nls = get_default(nls, self.nls)
rho_inf = conf.rho_inf
alpha_m = get_default(conf.alpha_m,
(2.0 * rho_inf - 1.0) / (rho_inf + 1.0))
alpha_f = get_default(conf.alpha_f, rho_inf / (rho_inf + 1.0))
beta = get_default(conf.beta, 0.25 * (1.0 - alpha_m + alpha_f)**2)
gamma = get_default(conf.gamma, 0.5 - alpha_m + alpha_f)
output('parameters rho_inf, alpha_m, alpha_f, beta, gamma:',
verbose=self.verbose)
output(rho_inf, alpha_m, alpha_f, beta, gamma,
verbose=self.verbose)
vec, unpack, pack = self.get_initial_vec(
nls, vec0, init_fun, prestep_fun, poststep_fun)
ts = self.ts
for step, time in ts.iter_from(ts.step):
output(self.format % (time, step + 1, ts.n_step),
verbose=self.verbose)
dt = ts.dt
prestep_fun(ts, vec)
ut, vt, at = unpack(vec)
nlst = self.create_nlst(nls, dt, alpha_m, alpha_f, gamma, beta,
ut, vt, at)
ts.set_substep_time((1.0 - alpha_f) * dt)
am = nlst(at)
ts.restore_step_time()
atp = nlst.a1(am)
vtp = nlst.v1(atp)
utp = nlst.u1(atp)
vect = pack(utp, vtp, atp)
poststep_fun(ts, vect)
vec = vect
return vec
def __call__(self, volume, problem=None, data=None):
problem = get_default(problem, self.problem)
coef = nm.zeros((self.dim, self.dim), dtype=self.dtype)
term_mode = self.term_mode
equations, variables = problem.create_evaluable(self.expression,
term_mode=term_mode)
if isinstance(self.set_variables, list):
for ir in range(self.dim):
self.set_variables_default(variables, ir, None, 'row',
self.set_variables, data)
for ic in range(self.dim):
self.set_variables_default(variables, None, ic, 'col',
self.set_variables, data)
val = eval_equations(equations, variables,
term_mode=term_mode)
coef[ir,ic] = val
else:
for ir in range(self.dim):
self.set_variables(variables, ir, None, 'row', **data)
for ic in range(self.dim):
self.set_variables(variables, None, ic, 'col', **data)
val = eval_equations(equations, variables,
term_mode=term_mode)
coef[ir,ic] = val
coef /= self._get_volume(volume)
return coef
def set_linear( self, is_linear ):
nls_conf = get_default( None, self.nls_conf,
'you must set nonlinear solver!' )
if is_linear:
nls_conf.problem = 'linear'
else:
nls_conf.problem = 'nonlinear'
def _set_data(self, coors, ngroups, conns, mat_ids, descs, nodal_bcs=None):
"""
Set mesh data.
Parameters
----------
coors : array
Coordinates of mesh nodes.
ngroups : array
Node groups.
conns : list of arrays
The array of mesh elements (connectivities) for each element group.
mat_ids : list of arrays
The array of material ids for each element group.
descs: list of strings
The element type for each element group.
nodal_bcs : dict of arrays, optional
The nodes defining regions for boundary conditions referred
to by the dict keys in problem description files.
"""
self.coors = nm.ascontiguousarray(coors)
if ngroups is None:
self.ngroups = nm.zeros((self.coors.shape[0],), dtype=nm.int32)
else:
self.ngroups = nm.ascontiguousarray(ngroups)
self.conns = [nm.asarray(conn, dtype=nm.int32) for conn in conns]
self.mat_ids = [nm.asarray(mat_id, dtype=nm.int32)
for mat_id in mat_ids]
self.descs = descs
self.nodal_bcs = get_default(nodal_bcs, {})
def set_equations(self, conf_equations=None, user=None,
keep_solvers=False, make_virtual=False):
"""
Set equations of the problem using the `equations` problem
description entry.
Fields and Regions have to be already set.
"""
conf_equations = get_default(conf_equations,
self.conf.get_default_attr('equations',
None))
self.set_variables()
variables = Variables.from_conf(self.conf_variables, self.fields)
self.set_materials()
materials = Materials.from_conf(self.conf_materials, self.functions)
self.integrals = self.get_integrals()
equations = Equations.from_conf(conf_equations, variables,
self.domain.regions,
materials, self.integrals,
user=user,
make_virtual=make_virtual)
self.equations = equations
if not keep_solvers:
self.solvers = None
def setup_default_output(self, conf=None, options=None):
"""
Provide default values to `ProblemDefinition.setup_output()`
from `conf.options` and `options`.
"""
conf = get_default(conf, self.conf)
if options and options.output_filename_trunk:
default_output_dir, of = op.split(options.output_filename_trunk)
default_trunk = io.get_trunk(of)
else:
default_trunk = None
default_output_dir = get_default_attr(conf.options,
'output_dir', None)
if options and options.output_format:
default_output_format = options.output_format
else:
default_output_format = get_default_attr(conf.options,
'output_format', None)
default_file_per_var = get_default_attr(conf.options,
'file_per_var', None)
default_float_format = get_default_attr(conf.options,
'float_format', None)
default_linearization = Struct(kind='strip')
self.setup_output(output_filename_trunk=default_trunk,
output_dir=default_output_dir,
file_per_var=default_file_per_var,
output_format=default_output_format,
float_format=default_float_format,
linearization=default_linearization)
def eval_tangent_matrix( self, vec, mtx = None, is_full = False ):
if isinstance(vec, basestr) and vec == 'linear':
return get_default(mtx, self.problem.mtx_a)
if not is_full:
vec = self.make_full_vec( vec )
pb = self.problem
if mtx is None:
mtx = pb.mtx_a
mtx = pb.equations.eval_tangent_matrices(vec, mtx)
if self.matrix_hook is not None:
mtx = self.matrix_hook(mtx, pb, call_mode='basic')
return mtx
def __call__(self, volume, problem=None, data=None):
problem = get_default(problem, self.problem)
term_mode = self.term_mode
equations, variables = problem.create_evaluable(self.expression,
term_mode=term_mode)
if isinstance(self.set_variables, list):
self.set_variables_default(variables, self.set_variables, data)
else:
self.set_variables(variables, **data)
val = eval_equations(equations, variables, term_mode=term_mode)
coef = val / self._get_volume(volume)
return coef
def __call__(self, volume=None, problem=None, data=None):
problem = get_default(problem, self.problem)
vf = {}
for region_name in self.regions:
vkey = 'volume_%s' % region_name
key = 'fraction_%s' % region_name
equations, variables = problem.create_evaluable(self.expression %
region_name)
val = eval_equations(equations, variables)
vf[vkey] = nm.asarray(val, dtype=nm.float64)
vf[key] = vf[vkey] / self._get_volume(volume)
return vf
def __call__(self, problem=None, data=None):
problem = get_default(problem, self.problem)
problem.set_equations(self.equations)
problem.select_bcs(ebc_names=self.ebcs, epbc_names=self.epbcs,
lcbc_names=self.get('lcbcs', []))
problem.update_materials()
mtx = problem.equations.eval_tangent_matrices(problem.create_state()(),
problem.mtx_a,
by_blocks=True)
self.presolve(mtx)
evp = self.solve_pressure_eigenproblem(mtx)
return Struct(name=self.name, ebcs=self.ebcs, epbcs=self.epbcs,
mtx=mtx, evp=evp)
def __call__(self,
vec0=None,
nls=None,
init_fun=None,
prestep_fun=None,
poststep_fun=None,
status=None,
**kwargs):
"""
Solve elastodynamics problems by the Bathe method.
"""
nls = get_default(nls, self.nls)
vec, unpack, pack = self.get_initial_vec(nls, vec0, init_fun,
prestep_fun, poststep_fun)
ts = self.ts
for step, time in ts.iter_from(ts.step):
output(self.format % (time, step + 1, ts.n_step),
verbose=self.verbose)
dt = ts.dt
prestep_fun(ts, vec)
ut, vt, at = unpack(vec)
nlst1 = self.create_nlst1(nls, dt, ut, vt, at)
ut1 = nlst1(ut)
vt1 = nlst1.v(ut1)
at1 = nlst1.a(vt1)
ts.set_substep_time(0.5 * dt)
vec1 = pack(ut1, vt1, at1)
prestep_fun(ts, vec1)
nlst2 = self.create_nlst2(nls, dt, ut, ut1, vt, vt1)
ut2 = nlst2(ut1)
vt2 = nlst2.v(ut2)
at2 = nlst2.a(vt2)
ts.restore_step_time()
vec2 = pack(ut2, vt2, at2)
poststep_fun(ts, vec2)
vec = vec2
return vec
def __init__(self, name, region, efaces, volume_econn, ig):
"""nodes[leconn] == econn"""
"""nodes are sorted by node number -> same order as region.vertices"""
self.name = get_default(name, 'surface_data_%s' % region.name)
face_indices = region.fis[ig]
faces = efaces[face_indices[:,1]]
if faces.size == 0:
raise ValueError('region with group with no faces! (%s)'
% region.name)
try:
ee = volume_econn[face_indices[:,0]]
except:
raise ValueError('missing region face indices! (%s)'
% region.name)
econn = nm.empty(faces.shape, dtype=nm.int32)
for ir, face in enumerate( faces ):
econn[ir] = ee[ir,face]
ef = econn.flat
nodes = nm.unique(ef)
aux = -nm.ones((nm.max( ef ) + 1,), dtype=nm.int32)
aux[nodes] = nm.arange(len(nodes), dtype=nm.int32)
leconn = aux[econn].copy()
assert_(nm.alltrue(nodes[leconn] == econn))
n_fa, n_fp = face_indices.shape[0], faces.shape[1]
face_type = 's%d' % n_fp
# Store bkey in SurfaceData, so that base function can be
# queried later.
bkey = 'b%s' % face_type[1:]
self.ig = ig
self.econn = econn
self.fis = face_indices
self.n_fa, self.n_fp = n_fa, n_fp
self.nodes = nodes
self.leconn = leconn
self.face_type = face_type
self.bkey = bkey
self.meconn = self.mleconn = None
def __call__(self, problem=None, data=None):
problem = get_default(problem, self.problem)
problem.select_variables(self.variables)
problem.set_equations(self.equations)
problem.select_bcs(ebc_names=self.ebcs, epbc_names=self.epbcs)
state = problem.create_state()
state.apply_ebc()
vec = eval_term_op(state,
self.equations.values()[0],
problem,
dw_mode='vector')
## print vec.max(), vec.min()
return vec
def __call__(self, volume=None, problem=None, data=None):
problem = get_default(problem, self.problem)
opts = self.app_options
evp, dv_info = [data[ii] for ii in self.requires]
output('computing eigenmomenta...')
if opts.transform is not None:
fun = problem.conf.get_function(opts.transform[0])
def wrap_transform(vec, shape):
return fun(vec, shape, *opts.eig_vector_transform[1:])
else:
wrap_transform = None
tt = time.clock()
eigenmomenta = compute_eigenmomenta(self.expression, opts.var_name,
problem, evp.eig_vectors,
wrap_transform)
output('...done in %.2f s' % (time.clock() - tt))
n_eigs = evp.eigs.shape[0]
mag = norm_l2_along_axis(eigenmomenta)
if opts.threshold_is_relative:
tol = opts.threshold * mag.max()
else:
tol = opts.threshold
valid = nm.where(mag < tol, False, True)
mask = nm.where(valid == False)[0]
eigenmomenta[mask, :] = 0.0
n_zeroed = mask.shape[0]
output('%d of %d eigenmomenta zeroed (under %.2e)'\
% (n_zeroed, n_eigs, tol))
out = Struct(name='eigenmomenta',
n_zeroed=n_zeroed,
eigenmomenta=eigenmomenta,
valid=valid,
to_file_txt=None)
return out
def __call__(self, problem=None, data=None):
problem = get_default(problem, self.problem)
var_name = self.variable
clist = ['data']
dn = self.data
if type(dn) is list:
data = problem
for ii in dn:
data = data.get(ii, 'None')
else:
data = problem.get(dn, 'None')
ndof, ndim = data.shape
state = {var_name: data.reshape((ndof * ndim, ))}
corr_sol = CorrSolution(name=self.name, state=state, components=clist)
return corr_sol
def __call__(self, volume=None, problem=None, data=None):
problem = get_default(problem, self.problem)
opts = self.app_options
dv_info, cat = [data[ii] for ii in self.requires]
output('average density:', dv_info.average_density)
dim = problem.get_dim()
eye = nm.eye(dim, dim, dtype=nm.float64)
mtx_mass = eye * dv_info.average_density
meigs, mvecs = eig(mtx_mass, mtx_b=cat,
eigenvectors=True, method=opts.eigensolver)
phase_velocity = 1.0 / nm.sqrt(meigs)
return phase_velocity
def set_field_split(self, field_ranges, comm=None):
"""
Setup local PETSc ranges for fields to be used with 'fieldsplit'
preconditioner.
This function must be called before solving the linear system.
"""
comm = get_default(comm, self.comm)
self.fields = []
for key, rng in six.iteritems(field_ranges):
size = rng[1] - rng[0]
field_is = self.petsc.IS().createStride(size,
first=rng[0],
step=1,
comm=comm)
self.fields.append((key, field_is))
def setup(self, define_dict=None, funmod=None, filename=None,
required=None, other=None):
define_dict = get_default(define_dict, self.__dict__)
self._filename = filename
self.validate(required=required, other=other)
self.transform_input_trivial()
self._raw = {}
for key, val in define_dict.iteritems():
if isinstance(val, dict):
self._raw[key] = copy(val)
self.transform_input()
self.funmod = funmod
def __init__(self, name, conf=None, functions=None,
domain=None, fields=None, equations=None, auto_conf=True,
nls=None, ls=None, ts=None, auto_solvers=True):
self.name = name
self.conf = conf
self.functions = functions
self.reset()
self.ts = get_default(ts, self.get_default_ts())
if auto_conf:
if equations is None:
raise ValueError('missing equations in auto_conf mode!')
if fields is None:
variables = equations.variables
fields = {}
for field in [var.get_field() for var in variables]:
fields[field.name] = field
if domain is None:
domain = fields.values()[0].domain
if conf is None:
self.conf = Struct(ebcs={}, epbcs={}, lcbcs={})
self.equations = equations
self.fields = fields
self.domain = domain
if auto_solvers:
if ls is None:
ls = ScipyDirect({})
if nls is None:
nls = Newton({}, lin_solver=ls)
ev = self.get_evaluator()
nls.fun = ev.eval_residual
nls.fun_grad = ev.eval_tangent_matrix
self.set_solvers_instances(ls=ls, nls=nls)
self.setup_output()
def verify_correctors(self, sign, state0, filename, problem=None):
problem = get_default(problem, self.problem)
io = HDF5MeshIO(filename)
ts = TimeStepper(*io.read_time_stepper())
ts.set_step(0)
problem.equations.init_time(ts)
variables = self.problem.get_variables()
vu, vp = self.dump_variables
vdp = self.verify_variables[-1]
p0 = sign * state0[vp]
format = '====== time %%e (step %%%dd of %%%dd) ====='\
% ((ts.n_digit,) * 2)
vv = variables
ok = True
for step, time in ts:
output(format % (time, step + 1, ts.n_step))
data = io.read_data(step)
if step == 0:
assert_(nm.allclose(data[vp].data, p0))
state0 = problem.create_state()
state0.set_full(data[vu].data, vu)
state0.set_full(data[vp].data, vp)
vv[vdp].set_data(data['d' + vp].data)
problem.update_time_stepper(ts)
state = problem.solve(state0)
state, state0 = state(), state0()
err = nla.norm(state - state0) / nla.norm(state0)
output(state.min(), state.max())
output(state0.min(), state0.max())
output('>>>>>', err)
ok = ok and (err < 1e-12)
problem.advance(ts)
return ok
def get_sorted_dependencies(req_info, coef_info, compute_only):
"Make corrs and coefs list sorted according to the dependencies."
reqcoef_info = copy(coef_info)
reqcoef_info.update(req_info)
compute_names = set(get_default(compute_only, coef_info.keys()))
compute_names = ['c.' + key for key in compute_names]
dep_names = []
for coef_name in compute_names:
requires = coef_info[coef_name[2:]].get('requires', [])
deps = insert_sub_reqs(copy(requires), [], reqcoef_info)\
+ [coef_name]
for dep in deps:
if dep not in dep_names:
dep_names.append(dep)
return dep_names
def get_fargs(self,
mat,
par_r,
par_p,
par_mv,
mode=None,
term_mode=None,
diff_var=None,
**kwargs):
vg, _ = self.get_mapping(par_p)
grad_r = self.get(par_r, 'grad')
grad_p = self.get(par_p, 'grad')
div_mv = self.get(par_mv, 'div')
grad_mv = self.get(par_mv, 'grad').transpose((0, 1, 3, 2)).copy()
return (grad_r, grad_p, div_mv, grad_mv, mat, vg,
get_default(term_mode, 1))
def get_fargs(self,
par_u,
par_w,
par_mv,
mode=None,
term_mode=None,
diff_var=None,
**kwargs):
vg, _ = self.get_mapping(par_u)
val_u = self.get(par_u, 'val')
grad_u = grad_as_vector(self.get(par_u, 'grad'))
val_w = self.get(par_w, 'val')
div_mv = self.get(par_mv, 'div')
grad_mv = grad_as_vector(self.get(par_mv, 'grad'))
return (val_u, grad_u, val_w, div_mv, grad_mv, vg,
get_default(term_mode, 1))
def __call__(self, problem=None, data=None):
problem = get_default(problem, self.problem)
states = nm.zeros((self.dim, ), dtype=nm.object)
clist = []
eqns = {}
for ir in range(self.dim):
for key_eq, val_eq in self.equations.iteritems():
eqns[key_eq] = val_eq % self.eq_pars[ir]
problem.set_equations(eqns)
problem.select_bcs(ebc_names=self.ebcs,
epbc_names=self.epbcs,
lcbc_names=self.get('lcbcs', []))
problem.update_materials(problem.ts)
self.init_solvers(problem)
variables = problem.get_variables()
if hasattr(self, 'set_variables'):
if isinstance(self.set_variables, list):
self.set_variables_default(variables, self.set_variables,
data)
else:
self.set_variables(variables, **data)
state = problem.solve()
assert_(state.has_ebc())
states[ir] = state.get_parts()
clist.append((ir, ))
corr_sol = CorrSolution(name=self.name,
states=states,
components=clist)
self.save(corr_sol, problem)
return corr_sol
def __call__(self, problem=None, data=None):
problem = get_default(problem, self.problem)
micro_state, im = problem.micro_state
macro_data = problem.homogenization_macro_data
pvar = self.variable
if micro_state[pvar] is not None:
coors = problem.fields['pressure' + pvar[-1]].coors
press = nm.dot(coors, macro_data['g' + pvar + '_0'][im])[:, 0] \
+ micro_state[pvar][im] - macro_data[pvar + '_0'][im][:, 0]
else:
ndof = problem.fields['pressure' + pvar[-1]].n_vertex_dof
press = nm.zeros((ndof, ), dtype=nm.float64)
corr_sol = cb.CorrSolution(name=self.name, state={pvar: press})
return corr_sol
def save_recovery_region(mac_pb, rname, filename=None):
filename = get_default(filename, os.path.join(mac_pb.output_dir,
'recovery_region.vtk'))
region = mac_pb.domain.regions[rname]
# Save recovery region characteristic function.
out = {}
mask = region.get_charfun(by_cell=False, val_by_id=False)
out['vmask'] = Struct(name='output_data',
mode='vertex', data=mask[:, nm.newaxis],
dofs=None)
mask = region.get_charfun(by_cell=True, val_by_id=False)
out['cmask'] = Struct(name='output_data',
mode='cell',
data=mask[:, nm.newaxis, nm.newaxis, nm.newaxis],
dofs=None)
mac_pb.save_state(filename, out=out)
def __call__(self, problem=None, data=None):
problem = get_default(problem, self.problem)
problem.select_variables(self.variables)
problem.set_equations(self.equations)
problem.select_bcs(ebc_names=self.ebcs,
epbc_names=self.epbcs,
lcbc_names=self.get('lcbcs', []))
state = problem.create_state()
state.apply_ebc()
eqs = problem.equations
eqs.set_variables_from_state(state.vec)
vec = eqs.create_stripped_state_vector()
eqs.time_update_materials(problem.get_timestepper())
eqs.evaluate(mode='weak', dw_mode='vector', asm_obj=vec)
return vec
def solve_eigen_problem(self):
opts = self.app_options
pb = self.problem
pb.set_equations(pb.conf.equations)
pb.time_update()
output('assembling lhs...')
tt = time.clock()
mtx_a = pb.evaluate(pb.conf.equations['lhs'],
mode='weak',
auto_init=True,
dw_mode='matrix')
output('...done in %.2f s' % (time.clock() - tt))
if 'rhs' in pb.conf.equations:
output('assembling rhs...')
tt = time.clock()
mtx_b = pb.evaluate(pb.conf.equations['rhs'],
mode='weak',
dw_mode='matrix')
output('...done in %.2f s' % (time.clock() - tt))
else:
mtx_b = None
n_eigs = get_default(opts.n_eigs, mtx_a.shape[0])
output('solving eigenvalue problem for {} values...'.format(n_eigs))
eig = Solver.any_from_conf(pb.get_solver_conf(opts.evps))
if opts.eigs_only:
eigs = eig(mtx_a, mtx_b, n_eigs, eigenvectors=False)
svecs = None
else:
eigs, svecs = eig(mtx_a, mtx_b, n_eigs, eigenvectors=True)
output('...done')
vecs = self.make_full(svecs)
self.save_results(eigs, vecs)
return Struct(pb=pb, eigs=eigs, vecs=vecs)
def get_fargs(self,
mat1,
mat2,
par_u,
par_w,
par_mv,
mode=None,
term_mode=None,
diff_var=None,
**kwargs):
vg, _ = self.get_mapping(par_u)
grad_u = grad_as_vector(self.get(par_u, 'grad'))
grad_w = grad_as_vector(self.get(par_w, 'grad'))
div_mv = self.get(par_mv, 'div')
grad_mv = grad_as_vector(self.get(par_mv, 'grad'))
return (grad_u, grad_w, div_mv, grad_mv, mat1 * mat2, vg,
get_default(term_mode, 1))
def eval_tangent_matrix(self, vec, mtx=None, is_full=False):
if isinstance(vec, basestr) and vec == 'linear':
return get_default(mtx, self.problem.mtx_a)
if not is_full:
vec = self.make_full_vec(vec)
try:
pb = self.problem
if mtx is None:
mtx = pb.mtx_a
mtx = pb.equations.eval_tangent_matrices(vec, mtx)
except StopIteration, exc:
status = exc.args[0]
output( ('error %d in term "%s" of derivative of equation "%s"'
+ ' with respect to variable "%s"!')\
% (status,
exc.args[1].name, exc.args[2].desc, exc.args[3] ) )
raise ValueError
def main():
parser = ArgumentParser(description=__doc__,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('--version', action='version', version='%(prog)s')
parser.add_argument('-e', '--examples-dir', metavar='directory',
action='store', dest='examples_dir',
default='examples', help=help['examples_dir'])
parser.add_argument('-i', '--images-dir', metavar='directory',
action='store', dest='images_dir',
default=None, help=help['images_dir'])
parser.add_argument('-n', '--no-images',
action='store_true', dest='no_images',
default=False, help=help['no_images'])
parser.add_argument('-o', '--output', metavar='output_filename',
action='store', dest='output_filename',
default='gallery/gallery.html',
help=help['output_filename'])
parser.add_argument('-l', '--link-prefix', metavar='prefix',
action='store', dest='link_prefix',
default='http://sfepy.org/doc-devel',
help=help['link_prefix'])
options = parser.parse_args()
examples_dir = os.path.realpath(options.examples_dir)
output_filename = os.path.realpath(options.output_filename)
gallery_dir = os.path.dirname(output_filename)
images_dir = get_default(options.images_dir,
os.path.join(gallery_dir, 'images'))
thumbnails_dir = os.path.join(images_dir, 'thumbnails')
rst_dir = os.path.join(gallery_dir, 'examples')
if not options.no_images:
generate_images(images_dir, examples_dir)
generate_thumbnails(thumbnails_dir, images_dir)
dir_map = generate_rst_files(rst_dir, examples_dir, images_dir)
generate_gallery_html(examples_dir,output_filename, gallery_dir,
rst_dir, thumbnails_dir, dir_map,
link_prefix=options.link_prefix)
def view_file(filename, filter_names, options, view=None):
if view is None:
if options.show:
offscreen = False
else:
offscreen = get_default(options.offscreen, True)
view = Viewer(filename, watch=options.watch,
ffmpeg_options=options.ffmpeg_options,
output_dir=options.output_dir,
offscreen=offscreen)
if options.only_names is not None:
options.only_names = options.only_names.split(',')
view(show=options.show, is_3d=options.is_3d, view=options.view,
roll=options.roll,
parallel_projection=options.parallel_projection,
fgcolor=options.fgcolor, bgcolor=options.bgcolor,
colormap=options.colormap,
layout=options.layout,
scalar_mode=options.scalar_mode,
vector_mode=options.vector_mode,
rel_scaling=options.rel_scaling,
clamping=options.clamping, ranges=options.ranges,
is_scalar_bar=options.is_scalar_bar,
is_wireframe=options.is_wireframe,
opacity=options.opacity,
subdomains_args=options.subdomains_args,
rel_text_width=options.rel_text_width,
fig_filename=options.filename, resolution=options.resolution,
filter_names=filter_names, only_names=options.only_names,
group_names=options.group_names,
step=options.step, time=options.time,
anti_aliasing=options.anti_aliasing,
domain_specific=options.domain_specific)
else:
view.set_source_filename(filename)
view.save_image(options.filename)
return view
def __call__(self,
rhs,
x0=None,
conf=None,
eps_a=None,
eps_r=None,
i_max=None,
mtx=None,
status=None,
**kwargs):
eps_r = get_default(eps_r, self.conf.eps_r)
if (self.mg is None) or (mtx is not self.mtx):
self.mg = self.solver(mtx)
self.mtx = mtx
sol = self.mg.solve(rhs, x0=x0, accel=conf.accel, tol=eps_r)
return sol
def get_fargs(self,
mat,
par_b,
par_u,
par_r,
par_mv,
mode=None,
term_mode=None,
diff_var=None,
**kwargs):
vg, _ = self.get_mapping(par_u)
val_b = self.get(par_b, 'val')
grad_u = self.get(par_u, 'grad').transpose((0, 1, 3, 2)).copy()
grad_r = self.get(par_r, 'grad')
div_mv = self.get(par_mv, 'div')
grad_mv = self.get(par_mv, 'grad').transpose((0, 1, 3, 2)).copy()
return (val_b, grad_u, grad_r, div_mv, grad_mv, mat, vg,
get_default(term_mode, 1))
def __call__(self,
vec0=None,
nls=None,
init_fun=None,
prestep_fun=None,
poststep_fun=None,
status=None,
**kwargs):
ts = self.ts
nls = get_default(nls, self.nls)
vec0 = init_fun(ts, vec0)
prestep_fun(ts, vec0)
vec = nls(vec0)
poststep_fun(ts, vec)
return vec
def __call__(self, problem=None, data=None):
problem = get_default(problem, self.problem)
var_name = self.variables[0]
var = problem.get_variables(auto_create=True)[var_name]
dim = problem.domain.mesh.dim
nnod = var.n_nod
e00 = nm.zeros((nnod, dim), dtype=nm.float64)
e1 = nm.ones((nnod, ), dtype=nm.float64)
ones = nm.zeros((dim, ), dtype=nm.object)
clist = []
for ir in range(dim):
aux = e00.copy()
aux[:, ir] = e1
ones[ir] = {var_name: nm.ascontiguousarray(aux)}
clist.append('pi_%d' % (ir, ))
corr_sol = CorrSolution(name=self.name, states=ones, components=clist)
return corr_sol
