def create_problem(filename):
from sfepy.fem import ProblemDefinition
problem = ProblemDefinition.from_conf_file(filename,
init_equations=False,
init_solvers=False)
return problem
def vary_omega1_size(problem):
"""Vary size of \Omega1. Saves also the regions into options['output_dir'].
Input:
problem: ProblemDefinition instance
Return:
a generator object:
1. creates new (modified) problem
2. yields the new (modified) problem and output container
3. use the output container for some logging
4. yields None (to signal next iteration to Application)
"""
from sfepy.fem import ProblemDefinition
from sfepy.solvers.ts import get_print_info
output.prefix = 'vary_omega1_size:'
diameters = nm.linspace(0.1, 0.6, 7) + 0.001
ofn_trunk, output_format = problem.ofn_trunk, problem.output_format
output_dir = problem.output_dir
join = os.path.join
conf = problem.conf
cf = conf.get_raw('functions')
n_digit, aux, d_format = get_print_info(len(diameters) + 1)
for ii, diameter in enumerate(diameters):
output('iteration %d: diameter %3.2f' % (ii, diameter))
cf['select_circ'] = (lambda coors, domain=None: select_circ(
coors[:, 0], coors[:, 1], 0, diameter),
)
conf.edit('functions', cf)
problem = ProblemDefinition.from_conf(conf)
problem.save_regions(join(output_dir, ('regions_' + d_format) % ii),
['Omega_1'])
region = problem.domain.regions['Omega_1']
if not region.has_cells_if_can():
print region
raise ValueError('region %s has no cells!' % region.name)
ofn_trunk = ofn_trunk + '_' + (d_format % ii)
problem.setup_output(output_filename_trunk=ofn_trunk,
output_dir=output_dir,
output_format=output_format)
out = []
yield problem, out
out_problem, state = out[-1]
filename = join(output_dir, ('log_%s.txt' % d_format) % ii)
fd = open(filename, 'w')
log_item = '$r(\Omega_1)$: %f\n' % diameter
fd.write(log_item)
fd.write('solution:\n')
nm.savetxt(fd, state())
fd.close()
yield None
def create_problem(filename):
from sfepy.fem import ProblemDefinition
problem = ProblemDefinition.from_conf_file(filename,
init_equations=False,
init_solvers=False)
return problem
def save_only( conf, save_names, problem = None ):
"""Save information available prior to setting equations and
solving them."""
if problem is None:
problem = ProblemDefinition.from_conf( conf, init_variables = False )
if save_names.regions is not None:
problem.save_regions( save_names.regions )
if save_names.field_meshes is not None:
problem.save_field_meshes( save_names.field_meshes )
if save_names.region_field_meshes is not None:
problem.save_region_field_meshes( save_names.region_field_meshes )
if save_names.ebc is not None:
if not hasattr( problem, 'variables' ):
problem.set_variables( conf.variables )
try:
ts = TimeStepper.from_conf( conf.ts )
ts.set_step( 0 )
except:
ts = None
try:
problem.variables.equation_mapping( conf.ebcs, conf.epbcs,
problem.domain.regions, ts,
conf.funmod )
except Exception, e:
output( 'cannot make equation mapping!' )
output( 'reason: %s' % e )
else:
problem.save_ebc( save_names.ebc )
def main():
from sfepy.base.base import output
from sfepy.base.conf import ProblemConf, get_standard_keywords
from sfepy.fem import ProblemDefinition
from sfepy.applications import solve_evolutionary
output.prefix = 'therel:'
required, other = get_standard_keywords()
conf = ProblemConf.from_file(__file__, required, other)
problem = ProblemDefinition.from_conf(conf, init_equations=False)
# Setup output directory according to options above.
problem.setup_default_output()
# First solve the stationary electric conduction problem.
problem.set_equations({'eq' : conf.equations['1']})
problem.time_update()
state_el = problem.solve()
problem.save_state(problem.get_output_name(suffix = 'el'), state_el)
# Then solve the evolutionary heat conduction problem, using state_el.
problem.set_equations({'eq' : conf.equations['2']})
phi_var = problem.get_variables()['phi_known']
phi_var.data_from_any(state_el())
solve_evolutionary(problem)
output('results saved in %s' % problem.get_output_name(suffix = '*'))
def from_conf( conf, options ):
from sfepy.fem import ProblemDefinition
problem = ProblemDefinition.from_conf(conf, init_equations=False)
test = Test( problem = problem,
conf = conf, options = options )
return test
def vary_omega1_size( problem ):
"""Vary size of \Omega1. Saves also the regions into options['output_dir'].
Input:
problem: ProblemDefinition instance
Return:
a generator object:
1. creates new (modified) problem
2. yields the new (modified) problem and output container
3. use the output container for some logging
4. yields None (to signal next iteration to Application)
"""
from sfepy.fem import ProblemDefinition
from sfepy.solvers.ts import get_print_info
output.prefix = 'vary_omega1_size:'
diameters = nm.linspace( 0.1, 0.6, 7 ) + 0.001
ofn_trunk, output_format = problem.ofn_trunk, problem.output_format
output_dir = problem.output_dir
join = os.path.join
conf = problem.conf
cf = conf.get_raw( 'functions' )
n_digit, aux, d_format = get_print_info( len( diameters ) + 1 )
for ii, diameter in enumerate( diameters ):
output( 'iteration %d: diameter %3.2f' % (ii, diameter) )
cf['select_circ'] = (lambda coors, domain=None:
select_circ(coors[:,0], coors[:,1], 0, diameter),)
conf.edit('functions', cf)
problem = ProblemDefinition.from_conf( conf )
problem.save_regions( join( output_dir, ('regions_' + d_format) % ii ),
['Omega_1'] )
region = problem.domain.regions['Omega_1']
if not region.has_cells_if_can():
print region
raise ValueError( 'region %s has no cells!' % region.name )
ofn_trunk = ofn_trunk + '_' + (d_format % ii)
problem.setup_output(output_filename_trunk=ofn_trunk,
output_dir=output_dir,
output_format=output_format)
out = []
yield problem, out
out_problem, state = out[-1]
filename = join( output_dir,
('log_%s.txt' % d_format) % ii )
fd = open( filename, 'w' )
log_item = '$r(\Omega_1)$: %f\n' % diameter
fd.write( log_item )
fd.write( 'solution:\n' )
nm.savetxt(fd, state())
fd.close()
yield None
def from_conf( conf, options ):
from sfepy.fem import ProblemDefinition
problem = ProblemDefinition.from_conf( conf )
test = Test( problem = problem,
conf = conf, options = options )
return test
def main():
from sfepy.base.conf import ProblemConf, get_standard_keywords
from sfepy.fem import ProblemDefinition
from sfepy.base.plotutils import plt
parser = OptionParser(usage=usage, version='%prog')
parser.add_option('-n', '--no-plot',
action="store_true", dest='no_plot',
default=False, help=helps['no_plot'])
options, args = parser.parse_args()
required, other = get_standard_keywords()
# Use this file as the input file.
conf = ProblemConf.from_file( __file__, required, other )
# Create problem instance, but do not set equations.
problem = ProblemDefinition.from_conf( conf,
init_equations = False )
# Solve the problem. Output is ignored, results stored by using the
# step_hook.
u_t = solve_branch(problem, linear_tension)
u_c = solve_branch(problem, linear_compression)
# Get pressure load by calling linear_*() for each time step.
ts = problem.get_timestepper()
load_t = nm.array([linear_tension(ts, nm.array([[0.0]]), 'qp')['val']
for aux in ts.iter_from( 0 )],
dtype=nm.float64).squeeze()
load_c = nm.array([linear_compression(ts, nm.array([[0.0]]), 'qp')['val']
for aux in ts.iter_from( 0 )],
dtype=nm.float64).squeeze()
# Join the branches.
displacements = {}
for key in u_t.keys():
displacements[key] = nm.r_[u_c[key][::-1], u_t[key]]
load = nm.r_[load_c[::-1], load_t]
if plt is None:
print 'matplotlib cannot be imported, printing raw data!'
print displacements
print load
else:
legend = []
for key, val in displacements.iteritems():
plt.plot( load, val )
legend.append( key )
plt.legend( legend, loc = 2 )
plt.xlabel( 'tension [kPa]' )
plt.ylabel( 'displacement [mm]' )
plt.grid( True )
plt.gcf().savefig( 'pressure_displacement.png' )
if not options.no_plot:
plt.show()
def from_conf(conf, options):
from sfepy.fem import ProblemDefinition
problem = ProblemDefinition.from_conf(conf)
problem.time_update()
test = Test(problem=problem, conf=conf, options=options)
return test
def solve_direct(conf, options, problem=None, step_hook=None,
post_process_hook=None, post_process_hook_final=None,
pre_process_hook=None, nls_status=None):
"""Generic (simple) problem solver."""
if problem is None:
is_eqs = not options.solve_not
problem = ProblemDefinition.from_conf(conf, init_equations=is_eqs)
problem.setup_default_output(conf, options)
if pre_process_hook is not None: # User pre_processing.
pre_process_hook(problem)
ofn_trunk = problem.ofn_trunk
save_names = Struct( ebc = None, regions = None,
regions_as_groups = None, field_meshes = None,
region_field_meshes = None )
if options.save_ebc:
save_names.ebc = ofn_trunk + '_ebc.vtk'
if options.save_regions:
save_names.regions = ofn_trunk + '_region'
if options.save_regions_as_groups:
save_names.regions_as_groups = ofn_trunk + '_regions'
if options.save_field_meshes:
save_names.field_meshes = ofn_trunk + '_field'
is_extra_save = False
for name, val in save_names.to_dict().iteritems():
if val is not None:
is_extra_save = True
break
if is_extra_save:
save_only( conf, save_names, problem=problem )
if options.solve_not:
return None, None, None
if hasattr( conf.options, 'ts' ):
##
# Time-dependent problem.
state = solve_evolutionary_op(problem, options,
step_hook=step_hook,
post_process_hook=post_process_hook,
nls_status=nls_status)
else:
##
# Stationary problem.
state = solve_stationary_op(problem, options,
post_process_hook=post_process_hook,
nls_status=nls_status)
if post_process_hook_final is not None: # User postprocessing.
post_process_hook_final(problem, state)
return problem, state
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 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 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 = Field("fu", nm.float64, "vector", omega, space="H1", poly_space_base="lagrange", 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 make_l2_projection(target, source):
"""
Project `source` field variable to `target` field variable using
:math:`L^2` dot product.
"""
order = target.field.get_true_order()**2
integral = Integral('i', order=order)
un = target.name
v = FieldVariable('v', 'test', target.field, 1, primary_var_name=un)
lhs = Term.new('dw_mass_scalar(v, %s)' % un, integral,
target.field.region, v=v, **{un : target})
def eval_variable(ts, coors, mode, **kwargs):
if mode == 'qp':
val = source.evaluate_at(coors)
val.shape = val.shape + (1,)
out = {'val' : val}
return out
m = Material('m', function=eval_variable)
rhs = Term.new('dw_volume_lvf(m.val, v)', integral, target.field.region,
m=m, v=v)
eq = Equation('projection', lhs - rhs)
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('L2 projection: solver did not converge!')
def solve_stationary(conf, save_names=None, nls_status=None):
problem = ProblemDefinition.from_conf( conf )
problem.time_update( None )
if save_names is not None:
save_only( conf, save_names, problem = problem )
state = problem.solve( nls_status = nls_status )
return problem, state
def main():
from sfepy.base.conf import ProblemConf, get_standard_keywords
from sfepy.fem import ProblemDefinition
from sfepy.base.plotutils import pylab
required, other = get_standard_keywords()
# Use this file as the input file.
conf = ProblemConf.from_file( __file__, required, other )
# Create problem instance, but do not set equations.
problem = ProblemDefinition.from_conf( conf,
init_equations = False )
options = Struct( output_filename_trunk = None )
# Solve the problem. Output is ignored, results stored by using the
# step_hook.
u_t = solve_branch( problem, options, linear_tension )
u_c = solve_branch( problem, options, linear_compression )
# Get pressure load by calling linear_*() for each time step.
ts = problem.get_timestepper()
load_t = nm.array( [linear_tension( ts, nm.array( [[0.0]] ) )['val']
for aux in ts.iter_from( 0 )],
dtype = nm.float64 ).squeeze()
load_c = nm.array( [linear_compression( ts, nm.array( [[0.0]] ) )['val']
for aux in ts.iter_from( 0 )],
dtype = nm.float64 ).squeeze()
# Join the branches.
displacements = {}
for key in u_t.keys():
displacements[key] = nm.r_[u_c[key][::-1], u_t[key]]
load = nm.r_[load_c[::-1], load_t]
if pylab is None:
print 'pylab cannot be imported, printing raw data!'
print displacements
print load
else:
legend = []
for key, val in displacements.iteritems():
pylab.plot( load, val )
legend.append( key )
pylab.legend( legend, loc = 2 )
pylab.xlabel( 'tension [kPa]' )
pylab.ylabel( 'displacement [mm]' )
pylab.grid( True )
pylab.gcf().savefig( 'pressure_displacement.png' )
pylab.show()
def __init__(self, conf, options, output_prefix, init_equations=True, **kwargs):
"""`kwargs` are passed to ProblemDefinition.from_conf()
Command-line options have precedence over conf.options."""
Application.__init__(self, conf, options, output_prefix)
self.setup_options()
is_eqs = init_equations
if hasattr(options, "solve_not") and options.solve_not:
is_eqs = False
self.problem = ProblemDefinition.from_conf(conf, init_equations=is_eqs, **kwargs)
self.setup_output_info(self.problem, self.options)
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_l2_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:`L^2` dot product.
"""
order = target.field.approx_order * 2
integral = Integral("i", order=order)
un = target.name
v = FieldVariable("v", "test", target.field, primary_var_name=un)
lhs = Term.new("dw_volume_dot(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, **kwargs)
return {"val": val}
m = Material("m", function=_eval_data)
rhs = Term.new("dw_volume_lvf(m.val, v)", integral, target.field.region, m=m, v=v)
eq = Equation("projection", lhs - rhs)
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("L2 projection: solver did not converge!")
def vary_y3_size( problem ):
"""Vary size of Y3 inclusion."""
from sfepy.fem import ProblemDefinition
from sfepy.solvers.ts import get_print_info
default_printer.prefix = 'vary_y3_size:'
y3_diameters = [0.2, 0.25, 0.3, 0.35, 0.4]
if diameters_g is None:
y3_diameters = nm.linspace( 0.15, 0.45, 16 )
else:
y3_diameters = diameters_g
# y3_diameters = [0.45]
ofn_trunk, output_dir = problem.ofn_trunk, problem.output_dir
join = os.path.join
conf = problem.conf
cr = conf.get_raw( 'regions' )
n_digit, aux, d_format = get_print_info( len( y3_diameters ) + 1 )
for ii, diameter in enumerate( y3_diameters ):
output( 'iteration %d: diameter %3.2f' % (ii, diameter) )
opts = problem.conf.options
cr['Y3'] = ('nodes by select_y3_circ( x, y, z, %.5f )' % diameter, {})
conf.edit( 'regions', cr )
problem = ProblemDefinition.from_conf( conf )
problem.save_regions( join( output_dir, ('regions_' + d_format) % ii ),
['Y2', 'Y3'] )
for region in problem.domain.regions:
if not region.has_cells_if_can():
raise ValueError( 'region %s has no cells!' % region.name )
opts.plot_options['show'] = False
opts.fig_name = join( output_dir,
(('band_gaps_%s' % d_format)
+ '_y3_%03.2f' + fig_suffix) % (ii, diameter) )
problem.ofn_trunk = ofn_trunk + '_' + (d_format % ii)
out = []
yield problem, out
evp, bg = out[-1]
filename = join( output_dir,
('band_gaps_%s.txt' % d_format) % ii )
log_item = '$r(Y_3)$: %f\n' % diameter
save_log( filename, bg, log_item )
yield None
def recover_micro_hook(micro_filename,
region,
macro,
naming_scheme='step_iel',
recovery_file_tag=''):
# Create a micro-problem instance.
required, other = get_standard_keywords()
required.remove('equations')
pb = ProblemDefinition.from_conf_file(micro_filename,
required=required,
other=other,
init_equations=False,
init_solvers=False)
coefs_filename = pb.conf.options.get_default_attr('coefs_filename',
'coefs')
output_dir = pb.conf.options.get_default_attr('output_dir', '.')
coefs_filename = op.join(output_dir, coefs_filename) + '.h5'
# Coefficients and correctors
coefs = Coefficients.from_file_hdf5(coefs_filename)
corrs = get_correctors_from_file(dump_names=coefs.dump_names)
recovery_hook = get_default_attr(pb.conf.options, 'recovery_hook', None)
if recovery_hook is not None:
recovery_hook = pb.conf.get_function(recovery_hook)
aux = max(pb.domain.shape.n_gr, 2)
format = get_print_info( aux, fill = '0' )[1] \
+ '_' + get_print_info( pb.domain.mesh.n_el, fill = '0' )[1]
for ig, ii, iel in region.iter_cells():
print 'ig: %d, ii: %d, iel: %d' % (ig, ii, iel)
local_macro = {}
for k, v in macro.iteritems():
local_macro[k] = v[ii, 0]
out = recovery_hook(pb, corrs, local_macro)
# save data
suffix = format % (ig, iel)
micro_name = pb.get_output_name(extra='recovered_'\
+ recovery_file_tag + suffix)
filename = op.join(output_dir, op.basename(micro_name))
fpv = pb.conf.options.get_default_attr('file_per_var', False)
pb.save_state(filename, out=out, file_per_var=fpv)
def solve_stationary( conf, data = None, save_names = None, nls_status = None ):
if data is None:
# Term-dependent data.
data = {}
problem = ProblemDefinition.from_conf( conf )
problem.time_update( None )
if save_names is not None:
save_only( conf, save_names, problem = problem )
state = problem.solve( nls_status = nls_status )
return problem, state, data
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 recover_micro_hook( micro_filename, region, macro,
naming_scheme = 'step_iel',
recovery_file_tag='' ):
# Create a micro-problem instance.
required, other = get_standard_keywords()
required.remove( 'equations' )
pb = ProblemDefinition.from_conf_file(micro_filename,
required=required,
other=other,
init_equations=False,
init_solvers=False)
coefs_filename = pb.conf.options.get_default_attr('coefs_filename', 'coefs')
output_dir = pb.conf.options.get_default_attr('output_dir', '.')
coefs_filename = op.join(output_dir, coefs_filename) + '.h5'
# Coefficients and correctors
coefs = Coefficients.from_file_hdf5( coefs_filename )
corrs = get_correctors_from_file( dump_names = coefs.dump_names )
recovery_hook = get_default_attr( pb.conf.options,
'recovery_hook', None )
if recovery_hook is not None:
recovery_hook = getattr( pb.conf.funmod, recovery_hook )
aux = max(pb.domain.shape.n_gr, 2)
format = get_print_info( aux, fill = '0' )[1] \
+ '_' + get_print_info( pb.domain.mesh.n_el, fill = '0' )[1]
for ig, ii, iel in region.iter_cells():
print 'ig: %d, ii: %d, iel: %d' % (ig, ii, iel)
local_macro = {}
for k, v in macro.iteritems():
local_macro[k] = v[ii,0]
out = recovery_hook( pb, corrs, local_macro )
# save data
suffix = format % (ig, iel)
micro_name = pb.get_output_name(extra='recovered_'\
+ recovery_file_tag + suffix)
filename = op.join(output_dir, op.basename(micro_name))
fpv = pb.conf.options.get_default_attr('file_per_var', False)
pb.save_state(filename, out=out,
file_per_var=fpv)
def solve_direct( conf, options, problem = None, step_hook = None,
post_process_hook = None ):
"""Generic (simple) problem solver."""
if problem is None:
problem = ProblemDefinition.from_conf( conf )
if options.output_filename_trunk:
ofn_trunk = options.output_filename_trunk
problem.ofn_trunk = ofn_trunk
if options.output_format:
problem.output_format = options.output_format
ofn_trunk = problem.ofn_trunk
save_names = Struct( ebc = None, regions = None, field_meshes = None,
region_field_meshes = None )
if options.save_ebc:
save_names.ebc = ofn_trunk + '_ebc.vtk'
if options.save_regions:
save_names.regions = ofn_trunk + '_region'
if options.save_field_meshes:
save_names.field_meshes = ofn_trunk + '_field'
if options.save_region_field_meshes:
save_names.region_field_meshes = ofn_trunk + '_region_field'
is_extra_save = False
for name, val in save_names.to_dict().iteritems():
if val is not None:
is_extra_save = True
break
if is_extra_save:
save_only( conf, save_names )
if options.solve_not:
return None, None, None
if hasattr( conf.options, 'ts' ):
##
# Time-dependent problem.
out = solve_evolutionary_op( problem, options,
post_process_hook = post_process_hook,
step_hook = step_hook )
else:
##
# Stationary problem.
out = solve_stationary_op( problem, options,
post_process_hook = post_process_hook )
state, data = out
return problem, state, data
def __init__(self, conf, options, output_prefix,
init_equations=True, **kwargs):
"""`kwargs` are passed to ProblemDefinition.from_conf()
Command-line options have precedence over conf.options."""
Application.__init__( self, conf, options, output_prefix )
self.setup_options()
is_eqs = init_equations
if hasattr(options, 'solve_not') and options.solve_not:
is_eqs = False
self.problem = ProblemDefinition.from_conf(conf,
init_equations=is_eqs,
**kwargs)
self.setup_output_info( self.problem, self.options )
def save_only( conf, save_names, problem = None ):
"""Save information available prior to setting equations and
solving them."""
if problem is None:
problem = ProblemDefinition.from_conf(conf, init_equations=False)
if save_names.regions is not None:
problem.save_regions( save_names.regions )
if save_names.regions_as_groups is not None:
problem.save_regions_as_groups( save_names.regions_as_groups )
if save_names.field_meshes is not None:
problem.save_field_meshes( save_names.field_meshes )
if save_names.ebc is not None:
problem.save_ebc( save_names.ebc )
def vary_y3_size(problem):
"""Vary size of Y3 inclusion."""
from sfepy.fem import ProblemDefinition
from sfepy.solvers.ts import get_print_info
output.prefix = "vary_y3_size:"
y3_diameters = [0.2, 0.25, 0.3, 0.35, 0.4]
if diameters_g is None:
y3_diameters = nm.linspace(0.15, 0.45, 16)
else:
y3_diameters = diameters_g
# y3_diameters = [0.45]
ofn_trunk, output_dir = problem.ofn_trunk, problem.output_dir
join = os.path.join
conf = problem.conf
cr = conf.get_raw("regions")
n_digit, aux, d_format = get_print_info(len(y3_diameters) + 1)
for ii, diameter in enumerate(y3_diameters):
output("iteration %d: diameter %3.2f" % (ii, diameter))
opts = problem.conf.options
cr["Y3"] = ("nodes by select_y3_circ( x, y, z, %.5f )" % diameter, {})
conf.edit("regions", cr)
problem = ProblemDefinition.from_conf(conf)
problem.save_regions(join(output_dir, ("regions_" + d_format) % ii), ["Y2", "Y3"])
for region in problem.domain.regions:
if not region.has_cells_if_can():
raise ValueError("region %s has no cells!" % region.name)
opts.plot_options["show"] = False
opts.fig_name = join(output_dir, (("band_gaps_%s" % d_format) + "_y3_%03.2f" + fig_suffix) % (ii, diameter))
problem.ofn_trunk = ofn_trunk + "_" + (d_format % ii)
out = []
yield problem, out
evp, bg = out[-1]
filename = join(output_dir, ("band_gaps_%s.txt" % d_format) % ii)
log_item = "$r(Y_3)$: %f\n" % diameter
save_log(filename, bg, log_item)
yield None
def save_only(conf, save_names, problem=None):
"""
Save information available prior to setting equations and
solving them.
"""
if problem is None:
problem = ProblemDefinition.from_conf(conf, init_equations=False)
if save_names.regions is not None:
problem.save_regions(save_names.regions)
if save_names.regions_as_groups is not None:
problem.save_regions_as_groups(save_names.regions_as_groups)
if save_names.field_meshes is not None:
problem.save_field_meshes(save_names.field_meshes)
if save_names.ebc is not None:
problem.save_ebc(save_names.ebc, force=False)
if save_names.ebc_nodes is not None:
problem.save_ebc(save_names.ebc_nodes, force=True)
def __init__( self, conf, options, output_prefix, **kwargs ):
"""`kwargs` are passed to ProblemDefinition.from_conf()
Command-line options have precedence over conf.options."""
Application.__init__( self, conf, options, output_prefix )
self.setup_options()
if options.output_filename_trunk is None:
ofn_trunk = op.join( self.app_options.output_dir,
io.get_trunk( conf.filename_mesh ) )
options.output_filename_trunk = ofn_trunk
else:
ofn_trunk = options.output_filename_trunk
self.problem = ProblemDefinition.from_conf( conf, **kwargs )
self.problem.ofn_trunk = ofn_trunk
self.problem.output_dir = self.app_options.output_dir
if hasattr( options, 'output_format' ):
self.problem.output_format = options.output_format
else:
self.problem.output_format = self.app_options.output_format
def eval_homogenized_coefs( self ):
if self.cached_coefs is not None:
return self.cached_coefs
opts = self.app_options
if opts.homogeneous:
rtm = opts.region_to_material
mat_region = rtm.keys()[0]
mat_name = rtm[mat_region]
self.problem.update_materials()
mat = self.problem.materials[mat_name]
coefs = mat.get_data( mat_region, 0, opts.tensor_names )
else:
dc = opts.dispersion_conf
dconf = ProblemConf.from_dict( dc['input'], dc['module'] )
dconf.materials = self.conf.materials
dconf.fe = self.conf.fe
dconf.regions.update( self.conf.regions )
dconf.options['output_dir'] = self.problem.output_dir
volume = opts.volume(self.problem, 'Y')
problem = ProblemDefinition.from_conf(dconf, init_equations=False)
he = HomogenizationEngine( problem, self.options, volume = volume )
coefs = he()
## print coefs
## pause()
output.prefix = self.output_prefix
self.cached_coefs = coefs
return coefs
def test_ebc(self):
import numpy as nm
from sfepy.fem import ProblemDefinition
pb = ProblemDefinition.from_conf(self.test_conf)
pb.time_update()
vvs = pb.variables
set = vvs.set_state_part
make_full = vvs.make_full_vec
svec_u = nm.ones((vvs.adi.n_dofs["u"],), dtype=nm.float64)
svec_phi = nm.empty((vvs.adi.n_dofs["phi"],), dtype=nm.float64)
svec_phi.fill(2.0)
svec = vvs.create_stripped_state_vector()
set(svec, svec_u, "u", stripped=True)
set(svec, svec_phi, "phi", stripped=True)
vec = make_full(svec)
ii_u = vvs.di.indx["u"].start + vvs["u"].eq_map.eqi
ii_phi = vvs.di.indx["phi"].start + vvs["phi"].eq_map.eqi
ok_ebc = vvs.has_ebc(vec)
ok_u = nm.all(vec[ii_u] == svec_u)
ok_phi = nm.all(vec[ii_phi] == svec_phi)
msg = "%s: %s"
self.report(msg % ("ebc", ok_ebc))
self.report(msg % ("u", ok_u))
self.report(msg % ("phi", ok_phi))
ok = ok_ebc and ok_u and ok_phi
return ok
def main():
import os
from sfepy.base.base import spause, output
from sfepy.base.conf import ProblemConf, get_standard_keywords
from sfepy.fem import ProblemDefinition
import sfepy.homogenization.coefs_base as cb
parser = OptionParser(usage=usage, version='%prog')
parser.add_option('-n', '--no-pauses',
action="store_true", dest='no_pauses',
default=False, help=help['no_pauses'])
options, args = parser.parse_args()
if options.no_pauses:
def spause(*args):
output(*args)
nm.set_printoptions( precision = 3 )
spause( r""">>>
First, this file will be read in place of an input
(problem description) file.
Press 'q' to quit the example, press any other key to continue...""" )
required, other = get_standard_keywords()
required.remove( 'equations' )
# Use this file as the input file.
conf = ProblemConf.from_file( __file__, required, other )
print conf.to_dict().keys()
spause( r""">>>
...the read input as a dict (keys only for brevity).
['q'/other key to quit/continue...]""" )
spause( r""">>>
Now the input will be used to create a ProblemDefinition instance.
['q'/other key to quit/continue...]""" )
problem = ProblemDefinition.from_conf(conf, init_equations=False)
# The homogenization mini-apps need the output_dir.
output_dir = os.path.join(os.path.split(__file__)[0], 'output')
if not os.path.exists(output_dir):
os.makedirs(output_dir)
problem.output_dir = output_dir
print problem
spause( r""">>>
...the ProblemDefinition instance.
['q'/other key to quit/continue...]""" )
spause( r""">>>
The homogenized elastic coefficient $E_{ijkl}$ is expressed
using $\Pi$ operators, computed now. In fact, those operators are permuted
coordinates of the mesh nodes.
['q'/other key to quit/continue...]""" )
req = conf.requirements['pis']
mini_app = cb.ShapeDimDim( 'pis', problem, req )
pis = mini_app()
print pis
spause( r""">>>
...the $\Pi$ operators.
['q'/other key to quit/continue...]""" )
spause( r""">>>
Next, $E_{ijkl}$ needs so called steady state correctors $\bar{\omega}^{rs}$,
computed now.
['q'/other key to quit/continue...]""" )
req = conf.requirements['corrs_rs']
save_name = req.get( 'save_name', '' )
name = os.path.join( output_dir, save_name )
mini_app = cb.CorrDimDim('steady rs correctors', problem, req)
mini_app.setup_output(save_format='vtk',
file_per_var=False)
corrs_rs = mini_app( data = {'pis': pis} )
print corrs_rs
spause( r""">>>
...the $\bar{\omega}^{rs}$ correctors.
The results are saved in: %s.%s
Try to display them with:
python postproc.py %s.%s
['q'/other key to quit/continue...]""" % (2 * (name, problem.output_format)) )
spause( r""">>>
Then the volume of the domain is needed.
['q'/other key to quit/continue...]""" )
volume = problem.evaluate('d_volume.i3.Y( uc )')
print volume
spause( r""">>>
...the volume.
['q'/other key to quit/continue...]""" )
spause( r""">>>
Finally, $E_{ijkl}$ can be computed.
['q'/other key to quit/continue...]""" )
mini_app = cb.CoefSymSym('homogenized elastic tensor',
problem, conf.coefs['E'])
c_e = mini_app(volume, data={'pis': pis, 'corrs_rs' : corrs_rs})
print r""">>>
The homogenized elastic coefficient $E_{ijkl}$, symmetric storage
with rows, columns in 11, 22, 12 ordering:"""
print c_e
integral = Integral('i', order=2)
term = Term.new('dw_laplace(s, t)', integral, omega,
s=s, t=t)
eq = Equation('temperature', term)
eqs = Equations([eq])
t_left = EssentialBC('t_left',
left, {'t.0' : 10.0})
t_right = EssentialBC('t_right',
right, {'t.0' : 30.0})
ls = ScipyDirect({})
nls = Newton({}, lin_solver=ls)
pb = ProblemDefinition('temperature', equations=eqs,
nls=nls, ls=ls)
pb.time_update(ebcs=Conditions([t_left, t_right]))
temperature = pb.solve()
out = temperature.create_output_dict()
field_u = Field.from_args('displacement', np.float64,
'vector', omega, 1)
u = FieldVariable('u', 'unknown', field_u, mesh.dim)
v = FieldVariable('v', 'test', field_u, mesh.dim,
primary_var_name='u')
lam = 10.0 # Lame parameters.
mu = 5.0
te = 0.5 # Thermal expansion coefficient.
T0 = 20.0 # Background temperature.
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 __init__(self, conf, problem, **kwargs):
from sfepy.fem.state import State
from sfepy.fem import ProblemDefinition
from sfepy.base.conf import ProblemConf, get_standard_keywords
from scipy.spatial import cKDTree as KDTree
ScipyDirect.__init__(self, conf, **kwargs)
# init subproblems
pb_vars = problem.get_variables()
# get "master" DofInfo and last index
pb_adi_indx = problem.equations.variables.adi.indx
self.adi_indx = pb_adi_indx.copy()
last_indx = -1
for ii in self.adi_indx.itervalues():
last_indx = nm.max([last_indx, ii.stop])
# coupling variables
self.cvars_to_pb = {}
for jj in conf.coupling_variables:
self.cvars_to_pb[jj] = [None, None]
if jj in pb_vars.names:
if pb_vars[jj].dual_var_name is not None:
self.cvars_to_pb[jj][0] = -1
else:
self.cvars_to_pb[jj][1] = -1
# init subproblems
self.subpb = []
required, other = get_standard_keywords()
master_prefix = output.get_output_prefix()
for ii, ifname in enumerate(conf.others):
sub_prefix = master_prefix[:-1] + '-sub%d:' % (ii + 1)
output.set_output_prefix(sub_prefix)
confi = ProblemConf.from_file(ifname,
required,
other,
define_args=kwargs)
pbi = ProblemDefinition.from_conf(confi, init_equations=True)
sti = State(pbi.equations.variables)
pbi.equations.set_data(None, ignore_unknown=True)
pbi.time_update()
pbi.update_materials()
sti.apply_ebc()
pbi_vars = pbi.get_variables()
output.set_output_prefix(master_prefix)
self.subpb.append([pbi, sti, None])
# append "slave" DofInfo
for jj in pbi_vars.names:
if not (pbi_vars[jj].is_state()):
continue
didx = pbi.equations.variables.adi.indx[jj]
ndof = didx.stop - didx.start
if jj in self.adi_indx:
if ndof != \
(self.adi_indx[jj].stop - self.adi_indx[jj].start):
raise ValueError('DOFs do not match!')
else:
self.adi_indx.update(
{jj: slice(last_indx, last_indx + ndof, None)})
last_indx += ndof
for jj in conf.coupling_variables:
if jj in pbi_vars.names:
if pbi_vars[jj].dual_var_name is not None:
self.cvars_to_pb[jj][0] = ii
else:
self.cvars_to_pb[jj][1] = ii
self.subpb.append([problem, None, None])
self.cvars_to_pb_map = {}
for varname, pbs in self.cvars_to_pb.iteritems():
# match field nodes
coors = []
for ii in pbs:
pbi = self.subpb[ii][0]
pbi_vars = pbi.get_variables()
fcoors = pbi_vars[varname].field.coors
dc = nm.abs(nm.max(fcoors, axis=0)\
- nm.min(fcoors, axis=0))
ax = nm.where(dc > 1e-9)[0]
coors.append(fcoors[:, ax])
if len(coors[0]) != len(coors[1]):
raise ValueError('number of nodes does not match!')
kdtree = KDTree(coors[0])
map_12 = kdtree.query(coors[1])[1]
pbi1 = self.subpb[pbs[0]][0]
pbi1_vars = pbi1.get_variables()
eq_map_1 = pbi1_vars[varname].eq_map
pbi2 = self.subpb[pbs[1]][0]
pbi2_vars = pbi2.get_variables()
eq_map_2 = pbi2_vars[varname].eq_map
dpn = eq_map_2.dpn
nnd = map_12.shape[0]
map_12_nd = nm.zeros((nnd * dpn, ), dtype=nm.int32)
if dpn > 1:
for ii in range(dpn):
map_12_nd[ii::dpn] = map_12 * dpn + ii
else:
map_12_nd = map_12
idx = nm.where(eq_map_2.eq >= 0)[0]
self.cvars_to_pb_map[varname] = eq_map_1.eq[map_12[idx]]
def main():
from sfepy.base.base import spause
from sfepy.base.conf import ProblemConf, get_standard_keywords
from sfepy.fem import eval_term_op, ProblemDefinition
from sfepy.homogenization.utils import create_pis
from sfepy.homogenization.coefs import CorrectorsRS, ElasticCoef
nm.set_printoptions( precision = 3 )
spause( r""">>>
First, this file will be read in place of an input
(problem description) file.
Press 'q' to quit the example, press any other key to continue...""" )
required, other = get_standard_keywords()
required.remove( 'equations' )
# Use this file as the input file.
conf = ProblemConf.from_file( __file__, required, other )
print conf.to_dict().keys()
spause( r""">>>
...the read input as a dict (keys only for brevity).
['q'/other key to quit/continue...]""" )
spause( r""">>>
Now the input will be used to create a ProblemDefinition instance.
['q'/other key to quit/continue...]""" )
problem = ProblemDefinition.from_conf( conf,
init_variables = False,
init_equations = False )
print problem
spause( r""">>>
...the ProblemDefinition instance.
['q'/other key to quit/continue...]""" )
spause( r""">>>
The homogenized elastic coefficient $E_{ijkl}$ is expressed
using $\Pi$ operators, computed now. In fact, those operators are permuted
coordinates of the mesh nodes.
['q'/other key to quit/continue...]""" )
req = conf.requirements['pis']
pis = create_pis( problem, req['variables'][0] )
print pis
spause( r""">>>
...the $\Pi$ operators.
['q'/other key to quit/continue...]""" )
spause( r""">>>
Next, $E_{ijkl}$ needs so called steady state correctors $\bar{\omega}^{rs}$,
computed now. The results will be saved in: %s_*.vtk
['q'/other key to quit/continue...]""" % problem.ofn_trunk )
save_hook = make_save_hook( problem.ofn_trunk + '_rs_%d%d' )
req = conf.requirements['corrs_rs']
solve_corrs = CorrectorsRS( 'steady rs correctors', problem, req )
corrs_rs = solve_corrs( data = pis, save_hook = save_hook )
print corrs_rs
spause( r""">>>
...the $\bar{\omega}^{rs}$ correctors.
['q'/other key to quit/continue...]""" )
spause( r""">>>
Then the volume of the domain is needed.
['q'/other key to quit/continue...]""" )
volume = eval_term_op( None, 'd_volume.i3.Y( uc )', problem )
print volume
spause( r""">>>
...the volume.
['q'/other key to quit/continue...]""" )
spause( r""">>>
Finally, $E_{ijkl}$ can be computed.
['q'/other key to quit/continue...]""" )
get_coef = ElasticCoef( 'homogenized elastic tensor',
problem, conf.coefs['E'] )
c_e = get_coef( volume, data = {'pis': pis, 'corrs' : corrs_rs} )
print r""">>>
The homogenized elastic coefficient $E_{ijkl}$, symmetric storage
with rows, columns in 11, 22, 12 ordering:"""
print c_e
def generate_probes(filename_input, filename_results, options,
conf=None, problem=None, probes=None, labels=None,
probe_hooks=None):
"""
Generate probe figures and data files.
"""
if conf is None:
required, other = get_standard_keywords()
conf = ProblemConf.from_file(filename_input, required, other)
opts = conf.options
if options.auto_dir:
output_dir = opts.get_('output_dir', '.')
filename_results = os.path.join(output_dir, filename_results)
output('results in: %s' % filename_results)
io = MeshIO.any_from_filename(filename_results)
step = options.step if options.step >= 0 else io.read_last_step()
all_data = io.read_data(step)
output('loaded:', all_data.keys())
output('from step:', step)
if options.only_names is None:
data = all_data
else:
data = {}
for key, val in all_data.iteritems():
if key in options.only_names:
data[key] = val
if problem is None:
problem = ProblemDefinition.from_conf(conf,
init_equations=False,
init_solvers=False)
if probes is None:
gen_probes = conf.get_function(conf.options.gen_probes)
probes, labels = gen_probes(problem)
if probe_hooks is None:
probe_hooks = {None : conf.get_function(conf.options.probe_hook)}
if options.output_filename_trunk is None:
options.output_filename_trunk = problem.ofn_trunk
filename_template = options.output_filename_trunk \
+ ('_%%d.%s' % options.output_format)
if options.same_dir:
filename_template = os.path.join(os.path.dirname(filename_results),
filename_template)
output_dir = os.path.dirname(filename_results)
for ip, probe in enumerate(probes):
output(ip, probe.name)
probe.set_options(close_limit=options.close_limit)
for key, probe_hook in probe_hooks.iteritems():
out = probe_hook(data, probe, labels[ip], problem)
if out is None: continue
if isinstance(out, tuple):
fig, results = out
else:
fig = out
if key is not None:
filename = filename_template % (key, ip)
else:
filename = filename_template % ip
if fig is not None:
if isinstance(fig, dict):
for fig_name, fig_fig in fig.iteritems():
fig_filename = edit_filename(filename,
suffix='_' + fig_name)
fig_fig.savefig(fig_filename)
output('figure ->', os.path.normpath(fig_filename))
else:
fig.savefig(filename)
output('figure ->', os.path.normpath(filename))
if results is not None:
txt_filename = edit_filename(filename, new_ext='.txt')
write_results(txt_filename, probe, results)
output('data ->', os.path.normpath(txt_filename))
def main():
import os
from sfepy.base.base import spause, output
from sfepy.base.conf import ProblemConf, get_standard_keywords
from sfepy.fem import ProblemDefinition
import sfepy.homogenization.coefs_base as cb
parser = OptionParser(usage=usage, version='%prog')
parser.add_option('-n',
'--no-pauses',
action="store_true",
dest='no_pauses',
default=False,
help=help['no_pauses'])
options, args = parser.parse_args()
if options.no_pauses:
def spause(*args):
output(*args)
nm.set_printoptions(precision=3)
spause(r""">>>
First, this file will be read in place of an input
(problem description) file.
Press 'q' to quit the example, press any other key to continue...""")
required, other = get_standard_keywords()
required.remove('equations')
# Use this file as the input file.
conf = ProblemConf.from_file(__file__, required, other)
print conf.to_dict().keys()
spause(r""">>>
...the read input as a dict (keys only for brevity).
['q'/other key to quit/continue...]""")
spause(r""">>>
Now the input will be used to create a ProblemDefinition instance.
['q'/other key to quit/continue...]""")
problem = ProblemDefinition.from_conf(conf, init_equations=False)
# The homogenization mini-apps need the output_dir.
output_dir = os.path.join(os.path.split(__file__)[0], 'output')
if not os.path.exists(output_dir):
os.makedirs(output_dir)
problem.output_dir = output_dir
print problem
spause(r""">>>
...the ProblemDefinition instance.
['q'/other key to quit/continue...]""")
spause(r""">>>
The homogenized elastic coefficient $E_{ijkl}$ is expressed
using $\Pi$ operators, computed now. In fact, those operators are permuted
coordinates of the mesh nodes.
['q'/other key to quit/continue...]""")
req = conf.requirements['pis']
mini_app = cb.ShapeDimDim('pis', problem, req)
pis = mini_app()
print pis
spause(r""">>>
...the $\Pi$ operators.
['q'/other key to quit/continue...]""")
spause(r""">>>
Next, $E_{ijkl}$ needs so called steady state correctors $\bar{\omega}^{rs}$,
computed now.
['q'/other key to quit/continue...]""")
req = conf.requirements['corrs_rs']
save_name = req.get('save_name', '')
name = os.path.join(output_dir, save_name)
mini_app = cb.CorrDimDim('steady rs correctors', problem, req)
mini_app.setup_output(save_format='vtk', file_per_var=False)
corrs_rs = mini_app(data={'pis': pis})
print corrs_rs
spause(r""">>>
...the $\bar{\omega}^{rs}$ correctors.
The results are saved in: %s.%s
Try to display them with:
python postproc.py %s.%s
['q'/other key to quit/continue...]""" % (2 * (name, problem.output_format)))
spause(r""">>>
Then the volume of the domain is needed.
['q'/other key to quit/continue...]""")
volume = problem.evaluate('d_volume.i3.Y( uc )')
print volume
spause(r""">>>
...the volume.
['q'/other key to quit/continue...]""")
spause(r""">>>
Finally, $E_{ijkl}$ can be computed.
['q'/other key to quit/continue...]""")
mini_app = cb.CoefSymSym('homogenized elastic tensor', problem,
conf.coefs['E'])
c_e = mini_app(volume, data={'pis': pis, 'corrs_rs': corrs_rs})
print r""">>>
The homogenized elastic coefficient $E_{ijkl}$, symmetric storage
with rows, columns in 11, 22, 12 ordering:"""
print c_e
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 = Field('fu', nm.float64, 'vector', omega,
space='H1', poly_space_base='lagrange', 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)