def test_solving(self):
from sfepy.base.base import IndexedStruct
from sfepy.fem \
import FieldVariable, Material, ProblemDefinition, \
Function, Equation, Equations, Integral
from sfepy.fem.conditions import Conditions, EssentialBC
from sfepy.terms import Term
from sfepy.solvers.ls import ScipyDirect
from sfepy.solvers.nls import Newton
u = FieldVariable('u', 'unknown', self.field, self.dim)
v = FieldVariable('v', 'test', self.field, self.dim,
primary_var_name='u')
m = Material('m', lam=1.0, mu=1.0)
f = Material('f', val=[[0.02], [0.01]])
bc_fun = Function('fix_u_fun', fix_u_fun,
extra_args={'extra_arg' : 'hello'})
fix_u = EssentialBC('fix_u', self.gamma1, {'u.all' : bc_fun})
shift_u = EssentialBC('shift_u', self.gamma2, {'u.0' : 0.1})
integral = Integral('i', order=3)
t1 = Term.new('dw_lin_elastic_iso(m.lam, m.mu, v, u)',
integral, self.omega, m=m, v=v, u=u)
t2 = Term.new('dw_volume_lvf(f.val, v)', integral, self.omega, f=f, v=v)
eq = Equation('balance', t1 + t2)
eqs = Equations([eq])
ls = ScipyDirect({})
nls_status = IndexedStruct()
nls = Newton({}, lin_solver=ls, status=nls_status)
pb = ProblemDefinition('elasticity', equations=eqs, nls=nls, ls=ls)
## pb.save_regions_as_groups('regions')
pb.time_update(ebcs=Conditions([fix_u, shift_u]))
state = pb.solve()
name = op.join(self.options.out_dir, 'test_high_level_solving.vtk')
pb.save_state(name, state)
ok = nls_status.condition == 0
if not ok:
self.report('solver did not converge!')
_ok = state.has_ebc()
if not _ok:
self.report('EBCs violated!')
ok = ok and _ok
return ok
def make_h1_projection_data(target, eval_data):
"""
Project scalar data given by a material-like `eval_data()` function to a
scalar `target` field variable using the :math:`H^1` dot product.
"""
order = target.field.approx_order * 2
integral = Integral('i', order=order)
un = target.name
v = FieldVariable('v', 'test', target.field, 1, primary_var_name=un)
lhs1 = Term.new('dw_volume_dot(v, %s)' % un,
integral,
target.field.region,
v=v,
**{un: target})
lhs2 = Term.new('dw_laplace(v, %s)' % un,
integral,
target.field.region,
v=v,
**{un: target})
def _eval_data(ts, coors, mode, **kwargs):
if mode == 'qp':
val = eval_data(ts, coors, mode, 'val', **kwargs)
gval = eval_data(ts, coors, mode, 'grad', **kwargs)
return {'val': val, 'gval': gval}
m = Material('m', function=_eval_data)
rhs1 = Term.new('dw_volume_lvf(m.val, v)',
integral,
target.field.region,
m=m,
v=v)
rhs2 = Term.new('dw_diffusion_r(m.gval, v)',
integral,
target.field.region,
m=m,
v=v)
eq = Equation('projection', lhs1 + lhs2 - rhs1 - rhs2)
eqs = Equations([eq])
ls = ScipyDirect({})
nls_status = IndexedStruct()
nls = Newton({}, lin_solver=ls, status=nls_status)
pb = ProblemDefinition('aux', equations=eqs, nls=nls, ls=ls)
pb.time_update()
# This sets the target variable with the projection solution.
pb.solve()
if nls_status.condition != 0:
output('H1 projection: solver did not converge!')
def create_mass_matrix(field):
"""
Create scalar mass matrix corresponding to the given field.
Returns
-------
mtx : csr_matrix
The mass matrix in CSR format.
"""
u = FieldVariable('u', 'unknown', field, 1)
v = FieldVariable('v', 'test', field, 1, primary_var_name='u')
integral = Integral('i', order=field.approx_order * 2)
term = Term.new('dw_volume_dot(v, u)', integral, field.region, v=v, u=u)
eq = Equation('aux', term)
eqs = Equations([eq])
eqs.time_update(None)
dummy = eqs.create_state_vector()
mtx = eqs.create_matrix_graph()
mtx = eqs.eval_tangent_matrices(dummy, mtx)
return mtx
def create_mass_matrix(field):
"""
Create scalar mass matrix corresponding to the given field.
Returns
-------
mtx : csr_matrix
The mass matrix in CSR format.
"""
u = FieldVariable('u', 'unknown', field, 1)
v = FieldVariable('v', 'test', field, 1, primary_var_name='u')
integral = Integral('i', order=field.approx_order * 2)
term = Term.new('dw_volume_dot(v, u)', integral, field.region, v=v, u=u)
eq = Equation('aux', term)
eqs = Equations([eq])
eqs.time_update(None)
dummy = eqs.create_state_vector()
mtx = eqs.create_matrix_graph()
mtx = eqs.eval_tangent_matrices(dummy, mtx)
return mtx
def create_mass_matrix(field):
"""
Create scalar mass matrix corresponding to the given field.
Returns
-------
mtx : csr_matrix
The mass matrix in CSR format.
"""
u = FieldVariable("u", "unknown", field)
v = FieldVariable("v", "test", field, primary_var_name="u")
integral = Integral("i", order=field.approx_order * 2)
term = Term.new("dw_volume_dot(v, u)", integral, field.region, v=v, u=u)
eq = Equation("aux", term)
eqs = Equations([eq])
eqs.time_update(None)
dummy = eqs.create_state_vector()
mtx = eqs.create_matrix_graph()
mtx = eqs.eval_tangent_matrices(dummy, mtx)
return mtx
def main():
from sfepy import data_dir
parser = OptionParser(usage=usage, version='%prog')
parser.add_option('-s',
'--show',
action="store_true",
dest='show',
default=False,
help=help['show'])
options, args = parser.parse_args()
mesh = Mesh.from_file(data_dir + '/meshes/2d/rectangle_tri.mesh')
domain = Domain('domain', mesh)
min_x, max_x = domain.get_mesh_bounding_box()[:, 0]
eps = 1e-8 * (max_x - min_x)
omega = domain.create_region('Omega', 'all')
gamma1 = domain.create_region('Gamma1',
'nodes in x < %.10f' % (min_x + eps))
gamma2 = domain.create_region('Gamma2',
'nodes in x > %.10f' % (max_x - eps))
field = H1NodalVolumeField('fu',
nm.float64,
'vector',
omega,
approx_order=2)
u = FieldVariable('u', 'unknown', field, mesh.dim)
v = FieldVariable('v', 'test', field, mesh.dim, primary_var_name='u')
m = Material('m', lam=1.0, mu=1.0)
f = Material('f', val=[[0.02], [0.01]])
integral = Integral('i', order=3)
t1 = Term.new('dw_lin_elastic_iso(m.lam, m.mu, v, u)',
integral,
omega,
m=m,
v=v,
u=u)
t2 = Term.new('dw_volume_lvf(f.val, v)', integral, omega, f=f, v=v)
eq = Equation('balance', t1 + t2)
eqs = Equations([eq])
fix_u = EssentialBC('fix_u', gamma1, {'u.all': 0.0})
bc_fun = Function('shift_u_fun', shift_u_fun, extra_args={'shift': 0.01})
shift_u = EssentialBC('shift_u', gamma2, {'u.0': bc_fun})
ls = ScipyDirect({})
nls_status = IndexedStruct()
nls = Newton({}, lin_solver=ls, status=nls_status)
pb = ProblemDefinition('elasticity', equations=eqs, nls=nls, ls=ls)
pb.save_regions_as_groups('regions')
pb.time_update(ebcs=Conditions([fix_u, shift_u]))
vec = pb.solve()
print nls_status
pb.save_state('linear_elasticity.vtk', vec)
if options.show:
view = Viewer('linear_elasticity.vtk')
view(vector_mode='warp_norm',
rel_scaling=2,
is_scalar_bar=True,
is_wireframe=True)
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)
equations = Equations.from_conf({'tmp' : expression},
aux_vars, regions, materials, integrals,
setup=False, 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':
setup_dof_conns(equations.conn_info)
equations.time_update(ts, ebcs, epbcs, lcbcs, functions)
else:
setup_extra_data(equations.conn_info)
return equations, variables
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,
setup=False, 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':
setup_dof_conns(equations.conn_info, verbose=verbose)
equations.time_update(ts, ebcs, epbcs, lcbcs, functions,
verbose=verbose)
else:
setup_extra_data(equations.conn_info)
return equations, variables
