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 __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 check_custom_sensitivity(self, term_desc, idsg, delta, dp_var_data, vec_ap):
pb = self.apb
domain = pb.domain
regions = domain.regions
materials = pb.materials
variables = self.ofg_equations.variables
aux = self.dpb.create_evaluable(term_desc, try_equations=False, var_dict=variables, extra_args={"mode": 0})
check0_equations, check0_variables = aux
aux = self.dpb.create_evaluable(term_desc, try_equations=False, var_dict=variables, extra_args={"mode": 1})
check1_equations, check1_variables = aux
var_data = pb.equations.get_state_parts(vec_ap)
var_data.update(dp_var_data)
check0_equations.set_data(var_data, ignore_unknown=True)
check1_equations.set_data(var_data, ignore_unknown=True)
dim = self.sp_boxes.dim
n_mesh_nod = domain.shape.n_nod
a_grad = []
d_grad = []
coors0 = domain.mesh.coors
for nu in self.generate_mesh_velocity((n_mesh_nod, dim), [idsg]):
check1_variables["Nu"].data_from_any(nu.ravel())
aux = eval_equations(check1_equations, check1_variables)
a_grad.append(aux)
coorsp = coors0 + delta * nu
pb.set_mesh_coors(coorsp, update_state=True)
valp = eval_equations(check0_equations, check0_variables)
coorsm = coors0 - delta * nu
pb.set_mesh_coors(coorsm, update_state=True)
valm = eval_equations(check0_equations, check0_variables)
d_grad.append(0.5 * (valp - valm) / delta)
pb.set_mesh_coors(coors0, update_state=True)
a_grad = nm.array(a_grad, nm.float64)
d_grad = nm.array(d_grad, nm.float64)
output(term_desc + ":")
output(" a: %.8e" % a_grad)
output(" d: %.8e" % d_grad)
output("-> ratio:", a_grad / d_grad)
pause()
def __call__(self, volume, problem=None, data=None):
problem = get_default(problem, self.problem)
filename = self.set_variables(None, None, None, 'filename', **data)
io = HDF5MeshIO(filename)
ts = TimeStepper(*io.read_time_stepper())
coef = nm.zeros((ts.n_step, 1), dtype=self.dtype)
term_mode = self.term_mode
equations, variables = problem.create_evaluable(self.expression,
term_mode=term_mode)
self.set_variables(variables, None, None, 'col', **data)
for step, time in ts:
self.set_variables(variables, io, step, 'row', **data)
val = eval_equations(equations, variables, term_mode=term_mode)
coef[step] = val
coef /= self._get_volume(volume)
return coef
def __call__(self, volume, problem=None, data=None):
problem = get_default(problem, self.problem)
dim, sym = problem.get_dim(get_sym=True)
coef = nm.zeros((sym, sym), dtype=self.dtype)
term_mode = self.term_mode
equations, variables = problem.create_evaluable(self.expression,
term_mode=term_mode)
for ir, (irr, icr) in enumerate(iter_sym(dim)):
if isinstance(self.set_variables, list):
self.set_variables_default(variables, irr, icr, 'row',
self.set_variables, data)
else:
self.set_variables(variables, irr, icr, 'row', **data)
for ic, (irc, icc) in enumerate(iter_sym(dim)):
if isinstance(self.set_variables, list):
self.set_variables_default(variables, irc, icc, 'col',
self.set_variables, data)
else:
self.set_variables(variables, irc, icc, 'col', **data)
val = eval_equations(equations, variables,
term_mode=term_mode)
coef[ir,ic] = val
coef /= self._get_volume(volume)
return coef
def __call__(self, volume, problem=None, data=None):
problem = get_default(problem, self.problem)
dim, sym = problem.get_dim(get_sym=True)
coef = nm.zeros((sym, sym), dtype=self.dtype)
term_mode = self.term_mode
equations, variables = problem.create_evaluable(self.expression,
term_mode=term_mode)
for ir, (irr, icr) in enumerate(iter_sym(dim)):
if isinstance(self.set_variables, list):
self.set_variables_default(variables, irr, icr, 'row',
self.set_variables, data)
else:
self.set_variables(variables, irr, icr, 'row', **data)
for ic, (irc, icc) in enumerate(iter_sym(dim)):
if isinstance(self.set_variables, list):
self.set_variables_default(variables, irc, icc, 'col',
self.set_variables, data)
else:
self.set_variables(variables, irc, icc, 'col', **data)
val = eval_equations(equations, variables, term_mode=term_mode)
coef[ir, ic] = val
coef /= self._get_volume(volume)
return coef
def __call__(self, volume, problem=None, data=None):
problem = get_default(problem, self.problem)
filename = self.set_variables(None, None, None, 'filename', **data)
io = HDF5MeshIO(filename)
ts = TimeStepper(*io.read_time_stepper())
coef = nm.zeros((ts.n_step, 1), dtype=self.dtype)
term_mode = self.term_mode
equations, variables = problem.create_evaluable(self.expression,
term_mode=term_mode)
self.set_variables(variables, None, None, 'col', **data)
for step, time in ts:
self.set_variables(variables, io, step, 'row', **data)
val = eval_equations(equations, variables,
term_mode=term_mode)
coef[step] = val
coef /= self._get_volume(volume)
return coef
def __call__(self, volume, problem=None, data=None):
problem = get_default(problem, self.problem)
dim, sym = problem.get_dim(get_sym=True)
filename = self.set_variables(None, 0, 0, 'filename', **data)
ts = TimeStepper(*HDF5MeshIO(filename).read_time_stepper())
coef = nm.zeros((ts.n_step, sym), dtype=self.dtype)
term_mode = self.term_mode
equations, variables = problem.create_evaluable(self.expression,
term_mode=term_mode)
self.set_variables(variables, None, None, 'col', **data)
for ii, (ir, ic) in enumerate(iter_sym(dim)):
filename = self.set_variables(None, ir, ic, 'filename', **data)
io = HDF5MeshIO(filename)
for step, time in ts:
self.set_variables(variables, io, step, 'row', **data)
val = eval_equations(equations, variables, term_mode=term_mode)
coef[step, ii] = val
coef /= self._get_volume(volume)
return coef
def __call__( self, volume, problem = None, data = None ):
problem = get_default( problem, self.problem )
dim, sym = problem.get_dim( get_sym = True )
aux = self.get_filename( data, 0, 0 )
ts = TimeStepper( *HDF5MeshIO( aux ).read_time_stepper() )
coef = nm.zeros( (ts.n_step, sym), dtype = nm.float64 )
equations, variables = problem.create_evaluable(self.expression)
self.set_variables(variables, None, None, 'col', **data)
for ii, (ir, ic) in enumerate( iter_sym( dim ) ):
io = HDF5MeshIO( self.get_filename( data, ir, ic ) )
for step, time in ts:
self.set_variables(variables, io, step, 'row', **data)
val = eval_equations(equations, variables)
coef[step,ii] = val
coef /= volume
return coef
def __call__(self, volume, problem=None, data=None):
problem = get_default(problem, self.problem)
dim, sym = problem.get_dim(get_sym=True)
filename = self.set_variables(None, 0, 0, 'filename', **data)
ts = TimeStepper(*HDF5MeshIO(filename).read_time_stepper())
coef = nm.zeros((ts.n_step, sym), dtype=self.dtype)
term_mode = self.term_mode
equations, variables = problem.create_evaluable(self.expression,
term_mode=term_mode)
self.set_variables(variables, None, None, 'col', **data)
for ii, (ir, ic) in enumerate(iter_sym(dim)):
filename = self.set_variables(None, ir, ic, 'filename', **data)
io = HDF5MeshIO(filename)
for step, time in ts:
self.set_variables(variables, io, step, 'row', **data)
val = eval_equations(equations, variables,
term_mode=term_mode)
coef[step,ii] = val
coef /= self._get_volume(volume)
return coef
def evaluate(self, expression, try_equations=True, auto_init=False,
preserve_caches=False, copy_materials=True, integrals=None,
ebcs=None, epbcs=None, lcbcs=None,
ts=None, functions=None,
mode='eval', dw_mode='vector', term_mode=None,
var_dict=None, strip_variables=True, ret_variables=False,
verbose=True, extra_args=None, **kwargs):
"""
Evaluate an expression, convenience wrapper of
:func:`ProblemDefinition.create_evaluable` and
:func:`eval_equations() <sfepy.fem.evaluate.eval_equations>`.
Parameters
----------
dw_mode : 'vector' or 'matrix'
The assembling mode for 'weak' evaluation mode.
term_mode : str
The term call mode - some terms support different call modes
and depending on the call mode different values are
returned.
ret_variables : bool
If True, return the variables that were created to evaluate
the expression.
other : arguments
See docstrings of :func:`ProblemDefinition.create_evaluable`.
Returns
-------
out : array
The result of the evaluation.
variables : Variables instance
The variables that were created to evaluate
the expression. Only provided if `ret_variables` is True.
"""
aux = self.create_evaluable(expression,
try_equations=try_equations,
auto_init=auto_init,
preserve_caches=preserve_caches,
copy_materials=copy_materials,
integrals=integrals,
ebcs=ebcs, epbcs=epbcs, lcbcs=lcbcs,
ts=ts, functions=functions,
mode=mode, var_dict=var_dict,
strip_variables=strip_variables,
extra_args=extra_args,
verbose=verbose, **kwargs)
equations, variables = aux
out = eval_equations(equations, variables,
preserve_caches=preserve_caches,
mode=mode, dw_mode=dw_mode, term_mode=term_mode)
if ret_variables:
out = (out, variables)
return out
def obj_fun(self, vec_dp):
"""
Objective function evaluation for given direct problem state.
"""
var_data = self.dpb.equations.get_state_parts(vec_dp)
var_data = remap_dict(var_data, self.var_map)
self.of_equations.set_data(var_data, ignore_unknown=True)
val = eval_equations(self.of_equations, self.of_variables)
return nm.squeeze(val)
def obj_fun(self, state_dp):
"""
Objective function evaluation for given direct problem state.
"""
var_data = state_dp.get_parts()
var_data = remap_dict(var_data, self.var_map)
self.of_equations.set_data(var_data, ignore_unknown=True)
val = eval_equations(self.of_equations, self.of_variables)
return nm.squeeze( val )
def __call__( self, volume, problem = None, data = None ):
problem = get_default( problem, self.problem )
equations, variables = problem.create_evaluable(self.expression)
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)
coef = val / volume
return coef
def sensitivity(self, dp_var_data, state_ap, select=None):
"""
Sensitivity of objective function evaluation for given direct
and adjoint problem states.
"""
apb = self.apb
var_data = state_ap.get_parts()
var_data.update(dp_var_data)
self.ofg_equations.set_data(var_data, ignore_unknown=True)
dim = self.sp_boxes.dim
n_mesh_nod = apb.domain.shape.n_nod
if select is None:
idsgs = nm.arange(self.dsg_vars.n_dsg, dtype=nm.int32)
else:
idsgs = select
sa = []
pbar = MyBar('sensitivity:')
pbar.init(len(idsgs))
shape = (n_mesh_nod, dim)
for ii, nu in enumerate(self.generate_mesh_velocity(shape, idsgs)):
pbar.update(ii)
self.ofg_variables['Nu'].data_from_any(nu.ravel())
## from sfepy.base.ioutils import write_vtk
## cc = nla.norm( vec_nu )
## nun = nu / cc
## out = {'v' : Struct( mode = 'vertex', data = nun,
## ap_name = 'nic', dof_types = (0,1,2) )}
## fd = open( 'anim/pert_%03d.pvtk' % (ii+1), 'w' )
## write_vtk( fd, domain.mesh, out )
## fd.close()
## print ii
val = eval_equations(self.ofg_equations,
self.ofg_variables,
term_mode=1,
preserve_caches=True)
sa.append(val)
vec_sa = nm.array(sa, nm.float64)
return vec_sa
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, 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, 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 sensitivity(self, dp_var_data, state_ap, select=None):
"""
Sensitivity of objective function evaluation for given direct
and adjoint problem states.
"""
apb = self.apb
var_data = state_ap.get_parts()
var_data.update(dp_var_data)
self.ofg_equations.set_data(var_data, ignore_unknown=True)
dim = self.sp_boxes.dim
n_mesh_nod = apb.domain.shape.n_nod
if select is None:
idsgs = nm.arange( self.dsg_vars.n_dsg, dtype = nm.int32 )
else:
idsgs = select
sa = []
pbar = MyBar('sensitivity:')
pbar.init(len(idsgs))
shape = (n_mesh_nod, dim)
for ii, nu in enumerate(self.generate_mesh_velocity(shape, idsgs)):
pbar.update(ii)
self.ofg_variables['Nu'].set_data(nu.ravel())
## from sfepy.base.ioutils import write_vtk
## cc = nla.norm( vec_nu )
## nun = nu / cc
## out = {'v' : Struct( mode = 'vertex', data = nun,
## ap_name = 'nic', dof_types = (0,1,2) )}
## fd = open( 'anim/pert_%03d.pvtk' % (ii+1), 'w' )
## write_vtk( fd, domain.mesh, out )
## fd.close()
## print ii
val = eval_equations(self.ofg_equations, self.ofg_variables,
term_mode=1, preserve_caches=True)
sa.append( val )
vec_sa = nm.array( sa, nm.float64 )
return vec_sa
def compute_eigenmomenta(em_equation,
var_name,
problem,
eig_vectors,
transform=None,
progress_bar=None):
"""
Compute the eigenmomenta corresponding to given eigenvectors.
"""
n_dof, n_eigs = eig_vectors.shape
equations, variables = problem.create_evaluable(em_equation)
var = variables[var_name]
n_c = var.n_components
eigenmomenta = nm.empty((n_eigs, n_c), dtype=nm.float64)
if progress_bar is not None:
progress_bar.init(n_eigs - 1)
for ii in xrange(n_eigs):
if progress_bar is not None:
progress_bar.update(ii)
else:
if (ii % 100) == 0:
output('%d of %d (%f%%)' % (ii, n_eigs, 100. * ii /
(n_eigs - 1)))
if transform is None:
vec_phi, is_zero = eig_vectors[:, ii], False
else:
vec_phi, is_zero = transform(eig_vectors[:, ii],
(n_dof / n_c, n_c))
if is_zero:
eigenmomenta[ii, :] = 0.0
else:
var.data_from_any(vec_phi.copy())
val = eval_equations(equations, variables)
eigenmomenta[ii, :] = val
return eigenmomenta
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, problem = None, data = None ):
problem = get_default( problem, self.problem )
dim, sym = problem.get_dim( get_sym = True )
coef = nm.zeros( (sym,), dtype = nm.float64 )
equations, variables = problem.create_evaluable(self.expression)
self.set_variables(variables, None, None, 'col', **data)
for ii, (ir, ic) in enumerate( iter_sym( dim ) ):
self.set_variables(variables, ir, ic, 'row', **data)
val = eval_equations(equations, variables)
coef[ii] = val
coef /= volume
return coef
def compute_eigenmomenta(em_equation, var_name, problem, eig_vectors,
transform=None, progress_bar=None):
"""
Compute the eigenmomenta corresponding to given eigenvectors.
"""
n_dof, n_eigs = eig_vectors.shape
equations, variables = problem.create_evaluable(em_equation)
var = variables[var_name]
n_c = var.n_components
eigenmomenta = nm.empty((n_eigs, n_c), dtype=nm.float64)
if progress_bar is not None:
progress_bar.init(n_eigs - 1)
for ii in xrange(n_eigs):
if progress_bar is not None:
progress_bar.update(ii)
else:
if (ii % 100) == 0:
output('%d of %d (%f%%)' % (ii, n_eigs,
100. * ii / (n_eigs - 1)))
if transform is None:
vec_phi, is_zero = eig_vectors[:,ii], False
else:
vec_phi, is_zero = transform(eig_vectors[:,ii], (n_dof / n_c, n_c))
if is_zero:
eigenmomenta[ii, :] = 0.0
else:
var.data_from_any(vec_phi.copy())
val = eval_equations(equations, variables)
eigenmomenta[ii, :] = val
return eigenmomenta
def __call__( self, volume, problem = None, data = None ):
problem = get_default( problem, self.problem )
coef = nm.zeros((self.dim,), dtype = nm.float64)
equations, variables = problem.create_evaluable(self.expression)
for ir in range(self.dim):
if isinstance(self.set_variables, list):
self.set_variables_default(variables, ir, self.set_variables,
data)
else:
self.set_variables(variables, ir, **data)
val = eval_equations(equations, variables)
coef[ir] = val
coef /= volume
return coef
def eval_equations(self, names=None, preserve_caches=False,
mode='eval', dw_mode='vector', term_mode=None,
verbose=True):
"""
Evaluate (some of) the problem's equations, convenience wrapper of
:func:`eval_equations() <sfepy.fem.evaluate.eval_equations>`.
Parameters
----------
names : str or sequence of str, optional
Evaluate only equations of the given name(s).
preserve_caches : bool
If True, do not invalidate evaluate caches of variables.
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.
dw_mode : 'vector' or 'matrix'
The assembling mode for 'weak' evaluation mode.
term_mode : str
The term call mode - some terms support different call modes
and depending on the call mode different values are
returned.
verbose : bool
If False, reduce verbosity.
Returns
-------
out : dict or result
The evaluation result. In 'weak' mode it is the vector or sparse
matrix, depending on `dw_mode`. Otherwise, it is a dict of results
with equation names as keys or a single result for a single
equation.
"""
return eval_equations(self.equations, self.equations.variables,
names=names, preserve_caches=preserve_caches,
mode=mode, dw_mode=dw_mode, term_mode=term_mode,
verbose=verbose)
def compute_eigenmomenta( em_equation, u_name, pb, eig_vectors,
transform = None, pbar = None ):
dim = pb.domain.mesh.dim
n_dof, n_eigs = eig_vectors.shape
eigenmomenta = nm.empty( (n_eigs, dim), dtype = nm.float64 )
equations, variables = pb.create_evaluable(em_equation)
var = variables[u_name]
if pbar is not None:
pbar.init( n_eigs - 1 )
for ii in xrange( n_eigs ):
if pbar is not None:
pbar.update( ii )
else:
if (ii % 100) == 0:
output( '%d of %d (%f%%)' % (ii, n_eigs,
100. * ii / (n_eigs - 1)) )
if transform is None:
vec_phi, is_zero = eig_vectors[:,ii], False
else:
vec_phi, is_zero = transform(eig_vectors[:,ii], (n_dof / dim, dim))
if is_zero:
eigenmomenta[ii,:] = 0.0
else:
var.data_from_any(vec_phi.copy())
val = eval_equations(equations, variables)
eigenmomenta[ii,:] = val
return eigenmomenta
def __call__(self, volume, problem=None, data=None):
problem = get_default(problem, self.problem)
coef = nm.zeros((self.dim, ), dtype=self.dtype)
term_mode = self.term_mode
for ir in range(self.dim):
expression = self.expression % self.expr_pars[ir]
equations, variables = \
problem.create_evaluable(expression, term_mode=term_mode)
if isinstance(self.set_variables, list):
self.set_variables_default(variables, ir, self.set_variables,
data)
else:
self.set_variables(variables, ir, **data)
val = eval_equations(equations, variables, term_mode=term_mode)
coef[ir] = val
coef /= self._get_volume(volume)
return coef
def __call__( self, volume, problem = None, data = None ):
problem = get_default( problem, self.problem )
aux = self.get_filename( data )
io = HDF5MeshIO( self.get_filename( data ) )
ts = TimeStepper( *io.read_time_stepper() )
coef = nm.zeros( (ts.n_step, 1), dtype = nm.float64 )
equations, variables = problem.create_evaluable(self.expression)
self.set_variables(variables, None, None, 'col', **data)
for step, time in ts:
self.set_variables(variables, io, step, 'row', **data)
val = eval_equations(equations, variables)
coef[step] = val
coef /= volume
return coef
def __call__(self, volume, problem=None, data=None):
problem = get_default(problem, self.problem)
coef = nm.zeros((self.dim,), dtype=self.dtype)
term_mode = self.term_mode
for ir in range(self.dim):
expression = self.expression % self.expr_pars[ir]
equations, variables = \
problem.create_evaluable(expression, term_mode=term_mode)
if isinstance(self.set_variables, list):
self.set_variables_default(variables, ir, self.set_variables,
data)
else:
self.set_variables(variables, ir, **data)
val = eval_equations(equations, variables,
term_mode=term_mode)
coef[ir] = val
coef /= self._get_volume(volume)
return coef
def check_custom_sensitivity(self, term_desc, idsg, delta,
dp_var_data, state_ap):
pb = self.apb
domain = pb.domain
possible_mat_names = get_expression_arg_names(term_desc)
materials = self.dpb.create_materials(possible_mat_names).as_dict()
variables = self.ofg_equations.variables
aux = self.dpb.create_evaluable(term_desc,
try_equations=False,
var_dict=variables,
verbose=False,
**materials)
check0_equations, check0_variables = aux
aux = self.dpb.create_evaluable(term_desc,
try_equations=False,
var_dict=variables,
verbose=False,
**materials)
check1_equations, check1_variables = aux
var_data = state_ap.get_parts()
var_data.update(dp_var_data)
check0_equations.set_data(var_data, ignore_unknown=True)
check1_equations.set_data(var_data, ignore_unknown=True)
dim = self.sp_boxes.dim
n_mesh_nod = domain.shape.n_nod
a_grad = []
d_grad = []
coors0 = domain.mesh.coors
for nu in self.generate_mesh_velocity( (n_mesh_nod, dim), [idsg] ):
check1_variables['Nu'].set_data(nu.ravel())
aux = eval_equations(check1_equations, check1_variables,
term_mode=1)
a_grad.append( aux )
coorsp = coors0 + delta * nu
pb.set_mesh_coors( coorsp, update_fields=True )
valp = eval_equations(check0_equations, check0_variables,
term_mode=0)
coorsm = coors0 - delta * nu
pb.set_mesh_coors( coorsm, update_fields=True )
valm = eval_equations(check0_equations, check0_variables,
term_mode=0)
d_grad.append( 0.5 * (valp - valm) / delta )
pb.set_mesh_coors( coors0, update_fields=True )
a_grad = nm.array( a_grad, nm.float64 )
d_grad = nm.array( d_grad, nm.float64 )
output( term_desc + ':' )
output( ' a: %.8e' % a_grad )
output( ' d: %.8e' % d_grad )
output( '-> ratio:', a_grad / d_grad )
pause()
def evaluate(self,
expression,
try_equations=True,
auto_init=False,
preserve_caches=False,
copy_materials=True,
integrals=None,
ebcs=None,
epbcs=None,
lcbcs=None,
ts=None,
functions=None,
mode='eval',
dw_mode='vector',
term_mode=None,
var_dict=None,
strip_variables=True,
ret_variables=False,
verbose=True,
extra_args=None,
**kwargs):
"""
Evaluate an expression, convenience wrapper of
:func:`ProblemDefinition.create_evaluable` and
:func:`eval_equations() <sfepy.fem.evaluate.eval_equations>`.
Parameters
----------
dw_mode : 'vector' or 'matrix'
The assembling mode for 'weak' evaluation mode.
term_mode : str
The term call mode - some terms support different call modes
and depending on the call mode different values are
returned.
ret_variables : bool
If True, return the variables that were created to evaluate
the expression.
other : arguments
See docstrings of :func:`ProblemDefinition.create_evaluable`.
Returns
-------
out : array
The result of the evaluation.
variables : Variables instance
The variables that were created to evaluate
the expression. Only provided if `ret_variables` is True.
"""
aux = self.create_evaluable(expression,
try_equations=try_equations,
auto_init=auto_init,
preserve_caches=preserve_caches,
copy_materials=copy_materials,
integrals=integrals,
ebcs=ebcs,
epbcs=epbcs,
lcbcs=lcbcs,
ts=ts,
functions=functions,
mode=mode,
var_dict=var_dict,
strip_variables=strip_variables,
extra_args=extra_args,
verbose=verbose,
**kwargs)
equations, variables = aux
out = eval_equations(equations,
variables,
preserve_caches=preserve_caches,
mode=mode,
dw_mode=dw_mode,
term_mode=term_mode)
if ret_variables:
out = (out, variables)
return out
def iterate(self, v_hxc_qp, eig_solver,
mtx_a_equations, mtx_a_variables, mtx_b, log, file_output,
n_electron=None):
from sfepy.physics import dft
self.itercount += 1
pb = self.problem
opts = self.app_options
n_electron = get_default( n_electron, opts.n_electron )
sh = self.qp_shape
v_hxc_qp = nm.array(v_hxc_qp, dtype=nm.float64)
v_hxc_qp.shape = (sh[0] * sh[1],) + sh[2:]
mat_v = Materials(mtx_a_equations.collect_materials())['mat_v']
mat_v.set_extra_args(vhxc=v_hxc_qp)
mat_v.time_update(None, pb.domain, mtx_a_equations)
v_hxc_qp.shape = sh
v_ion_qp = mat_v.get_data(('Omega', 'i1'), 0, 'V_ion')
output( 'assembling lhs...' )
tt = time.clock()
mtx_a = eval_equations(mtx_a_equations, mtx_a_variables,
mode='weak', dw_mode='matrix')
output( '...done in %.2f s' % (time.clock() - tt) )
assert_( nm.alltrue( nm.isfinite( mtx_a.data ) ) )
output( 'computing the Ax=Blx Kohn-Sham problem...' )
tt = time.clock()
eigs, mtx_s_phi = eig_solver( mtx_a, mtx_b,
opts.n_eigs, eigenvectors = True )
output( '...done in %.2f s' % (time.clock() - tt) )
n_eigs_ok = len(eigs)
output( 'setting-up smearing...' )
e_f, smear_tuned = setup_smearing( eigs, n_electron )
output( 'Fermi energy:', e_f )
if e_f is None:
raise Exception("cannot find Fermi energy - exiting.")
weights = smear_tuned(eigs)
output( '...done' )
if (weights[-1] > 1e-12):
output("last smearing weight is nonzero (%s eigs ok)!" % n_eigs_ok)
output( "saving solutions, iter=%d..." % self.itercount )
out = {}
var_name = mtx_a_variables.get_names(kind='state')[0]
for ii in xrange( n_eigs_ok ):
vec_phi = mtx_a_variables.make_full_vec(mtx_s_phi[:,ii])
update_state_to_output( out, pb, vec_phi, var_name+'%03d' % ii )
name = op.join( opts.output_dir, "iter%d" % self.itercount )
pb.save_state('.'.join((name, opts.output_format)), out=out)
output( "...solutions saved" )
output('computing total charge...')
tt = time.clock()
aux = pb.create_evaluable('dq_state_in_volume_qp.i1.Omega(Psi)')
psi_equations, psi_variables = aux
var = psi_variables['Psi']
n_qp = nm.zeros_like(v_hxc_qp)
for ii in xrange( n_eigs_ok ):
vec_phi = mtx_a_variables.make_full_vec(mtx_s_phi[:,ii])
var.data_from_any(vec_phi)
phi_qp = eval_equations(psi_equations, psi_variables)
n_qp += weights[ii] * (phi_qp ** 2)
output('...done in %.2f s' % (time.clock() - tt))
ap, vg = var.get_approximation(('i1', 'Omega', 0), 'Volume')
det = vg.variable(1)
charge = (det * n_qp).sum()
## Same as above.
## out = nm.zeros((n_qp.shape[0], 1, 1, 1), dtype=nm.float64)
## vg.integrate(out, n_qp)
## charge = out.sum()
vec_n = self._interp_to_nodes(n_qp)
var.data_from_any(vec_n)
charge_n = pb.evaluate('di_volume_integrate.i1.Omega(Psi)', Psi=var)
##
# V_xc in quadrature points.
v_xc_qp = nm.zeros((nm.prod(self.qp_shape),), dtype=nm.float64)
for ii, val in enumerate(n_qp.flat):
## print ii, val
v_xc_qp[ii] = dft.getvxc(val, 0)
assert_(nm.isfinite(v_xc_qp).all())
v_xc_qp.shape = self.qp_shape
mat_key = mat_v.datas.keys()[0]
pb.set_equations( pb.conf.equations_vh )
pb.select_bcs( ebc_names = ['VHSurface'] )
pb.update_materials()
output( "solving Ax=b Poisson equation" )
pb.materials['mat_n'].reset()
pb.materials['mat_n'].set_all_data({mat_key : {0: {'N' : n_qp}}})
vec_v_h = pb.solve()
var.data_from_any(vec_v_h)
v_h_qp = pb.evaluate('dq_state_in_volume_qp.i1.Omega(Psi)', Psi=var)
v_hxc_qp = v_h_qp + v_xc_qp
norm = nla.norm(v_hxc_qp.ravel())
dnorm = abs(norm - self.norm_v_hxc0)
log(norm, max(dnorm,1e-20)) # logplot of pure 0 fails.
file_output( '%d: F(x) = |VH + VXC|: %f, abs(F(x) - F(x_prev)): %e'\
% (self.itercount, norm, dnorm) )
file_output("-"*70)
file_output('Fermi energy:', e_f)
file_output("----------------------------------------")
file_output(" # | eigs | smearing")
file_output("----|-----------------|-----------------")
for ii in xrange( n_eigs_ok ):
file_output("% 3d | %-15s | %-15s" % (ii+1, eigs[ii], weights[ii]))
file_output("----------------------------------------")
file_output("charge_qp: ", charge)
file_output("charge_n: ", charge_n)
file_output("----------------------------------------")
file_output("|N|: ", nla.norm(n_qp.ravel()))
file_output("|V_H|: ", nla.norm(v_h_qp.ravel()))
file_output("|V_XC|: ", nla.norm(v_xc_qp.ravel()))
file_output("|V_HXC|: ", norm)
if self.iter_hook is not None: # User postprocessing.
pb.select_bcs(ebc_names=['ZeroSurface'])
mtx_phi = self.make_full(mtx_s_phi)
data = Struct(iteration = self.itercount,
eigs = eigs, weights = weights,
mtx_s_phi = mtx_s_phi, mtx_phi = mtx_phi,
vec_n = vec_n, vec_v_h = vec_v_h,
n_qp = n_qp, v_ion_qp = v_ion_qp, v_h_qp = v_h_qp,
v_xc_qp = v_xc_qp, file_output = file_output)
self.iter_hook(self.problem, data = data)
file_output("-"*70)
self.norm_v_hxc0 = norm
return eigs, mtx_s_phi, vec_n, vec_v_h, v_ion_qp, v_xc_qp, v_hxc_qp