def save_ebc(self, filename, force=True, default=0.0):
"""
Save essential boundary conditions as state variables.
"""
output('saving ebc...')
variables = self.get_variables(auto_create=True)
ebcs = Conditions.from_conf(self.conf.ebcs, self.domain.regions)
epbcs = Conditions.from_conf(self.conf.epbcs, self.domain.regions)
try:
variables.equation_mapping(ebcs, epbcs, self.ts, self.functions,
problem=self)
except:
output('cannot make equation mapping!')
raise
state = self.create_state()
state.fill(default)
if force:
vals = dict_from_keys_init(variables.state)
for ii, key in enumerate(vals.iterkeys()):
vals[key] = ii + 1
state.apply_ebc(force_values=vals)
else:
state.apply_ebc()
out = state.create_output_dict(extend=True)
self.save_state(filename, out=out, fill_value=default)
output('...done')
def __call__(self, problem=None, data=None):
from sfepy.base.base import select_by_names
from sfepy.fem.variables import Variables
from sfepy.fem.state import State
from sfepy.fem.conditions import Conditions
problem = get_default(problem, self.problem)
conf_ebc = select_by_names(problem.conf.ebcs, self.ebcs)
conf_epbc = select_by_names(problem.conf.epbcs, self.epbcs)
ebcs = Conditions.from_conf(conf_ebc, problem.domain.regions)
epbcs = Conditions.from_conf(conf_epbc, problem.domain.regions)
conf_variables = select_by_names(problem.conf.variables, self.variable)
problem.set_variables(conf_variables)
variables = Variables.from_conf(conf_variables, problem.fields)
variables.equation_mapping(ebcs, epbcs, problem.ts, problem.functions)
state = State(variables)
state.fill(0.0)
state.apply_ebc()
corr_sol = CorrSolution(name=self.name,
state=state.get_parts())
self.save(corr_sol, problem, variables)
return corr_sol
def __call__(self, problem=None, data=None):
from sfepy.base.base import select_by_names
from sfepy.fem.variables import Variables
from sfepy.fem.state import State
from sfepy.fem.conditions import Conditions
problem = get_default(problem, self.problem)
conf_ebc = select_by_names(problem.conf.ebcs, self.ebcs)
conf_epbc = select_by_names(problem.conf.epbcs, self.epbcs)
ebcs = Conditions.from_conf(conf_ebc, problem.domain.regions)
epbcs = Conditions.from_conf(conf_epbc, problem.domain.regions)
conf_variables = select_by_names(problem.conf.variables, self.variable)
problem.set_variables(conf_variables)
variables = Variables.from_conf(conf_variables, problem.fields)
variables.equation_mapping(ebcs, epbcs, problem.ts, problem.functions)
state = State(variables)
state.fill(0.0)
state.apply_ebc()
corr_sol = CorrSolution(name=self.name, state=state.get_parts())
self.save(corr_sol, problem, variables)
return corr_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 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 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 set_bcs(self, ebcs=None, epbcs=None, lcbcs=None):
"""
Update boundary conditions.
"""
if isinstance(ebcs, Conditions):
self.ebcs = ebcs
else:
conf_ebc = get_default(ebcs, self.conf.ebcs)
self.ebcs = Conditions.from_conf(conf_ebc, self.domain.regions)
if isinstance(epbcs, Conditions):
self.epbcs = epbcs
else:
conf_epbc = get_default(epbcs, self.conf.epbcs)
self.epbcs = Conditions.from_conf(conf_epbc, self.domain.regions)
if isinstance(lcbcs, Conditions):
self.lcbcs = lcbcs
else:
conf_lcbc = get_default(lcbcs, self.conf.lcbcs)
self.lcbcs = Conditions.from_conf(conf_lcbc, self.domain.regions)
def save_ebc(self, filename, force=True, default=0.0):
"""
Save essential boundary conditions as state variables.
"""
output('saving ebc...')
variables = self.get_variables(auto_create=True)
ebcs = Conditions.from_conf(self.conf.ebcs, self.domain.regions)
epbcs = Conditions.from_conf(self.conf.epbcs, self.domain.regions)
try:
variables.equation_mapping(ebcs,
epbcs,
self.ts,
self.functions,
problem=self)
except:
output('cannot make equation mapping!')
raise
state = self.create_state()
state.fill(default)
if force:
vals = dict_from_keys_init(variables.state)
for ii, key in enumerate(vals.iterkeys()):
vals[key] = ii + 1
state.apply_ebc(force_values=vals)
else:
state.apply_ebc()
out = state.create_output_dict(extend=True)
self.save_state(filename, out=out, fill_value=default)
output('...done')
def set_bcs(self, ebcs=None, epbcs=None, lcbcs=None):
"""
Update boundary conditions.
"""
if isinstance(ebcs, Conditions):
self.ebcs = ebcs
else:
conf_ebc = get_default(ebcs, self.conf.ebcs)
self.ebcs = Conditions.from_conf(conf_ebc, self.domain.regions)
if isinstance(epbcs, Conditions):
self.epbcs = epbcs
else:
conf_epbc = get_default(epbcs, self.conf.epbcs)
self.epbcs = Conditions.from_conf(conf_epbc, self.domain.regions)
if isinstance(lcbcs, Conditions):
self.lcbcs = lcbcs
else:
conf_lcbc = get_default(lcbcs, self.conf.lcbcs)
self.lcbcs = Conditions.from_conf(conf_lcbc, self.domain.regions)
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)