def evalValAndDeriv(D):
m = Material('m', D = D, rho = 2700.0)
integral = Integral('i', order=2)
t1 = Term.new('dw_lin_elastic(m.D, v, u)', integral, omega, m=m, v=v, u=u)
t2 = Term.new('dw_volume_dot(m.rho, v, u)', integral, omega, m=m, v=v, u=u)
eq1 = Equation('stiffness', t1)
eq2 = Equation('mass', t2)
lhs_eqs = Equations([eq1, eq2])
pb = Problem('modal', equations = lhs_eqs)
pb.time_update()
n_rbm = dim * (dim + 1) / 2
pb.update_materials()
# Assemble stiffness and mass matrices.
mtx_k = eq1.evaluate(mode='weak', dw_mode='matrix', asm_obj=pb.mtx_a)
mtx_m = mtx_k.copy()
mtx_m.data[:] = 0.0
mtx_m = eq2.evaluate(mode='weak', dw_mode='matrix', asm_obj=mtx_m)
eigs0, evecs0 = scipy.sparse.linalg.eigsh(mtx_k, k = 10, M = mtx_m, which = 'SM')
eigs = eigs0[3:]
evecs = evecs0[:, 3:]
dydmu = numpy.array([evecs[:, i].T.dot(dKdmu.dot(evecs[:, i])) for i in range(evecs.shape[1])])
dydlambda = numpy.array([evecs[:, i].T.dot(dKdlambda.dot(evecs[:, i])) for i in range(evecs.shape[1])])
return eigs, dydmu, dydlambda
def assemble(mtx_d):
m = Material('m', D=mtx_d, rho=density)
integral = Integral('i', order=2 * order)
t1 = Term.new('dw_lin_elastic(m.D, v, u)', integral, omega, m=m, v=v, u=u)
t2 = Term.new('dw_volume_dot(m.rho, v, u)', integral, omega, m=m, v=v, u=u)
eq1 = Equation('stiffness', t1)
eq2 = Equation('mass', t2)
lhs_eqs = Equations([eq1, eq2])
pb = Problem('modal', equations=lhs_eqs)
pb.time_update()
n_rbm = dim * (dim + 1) / 2
pb.update_materials()
tmp = time.time()
# Assemble stiffness and mass matrices.
mtx_k = eq1.evaluate(mode='weak', dw_mode='matrix', asm_obj=pb.mtx_a)
mtx_m = mtx_k.copy()
mtx_m.data[:] = 0.0
mtx_m = eq2.evaluate(mode='weak', dw_mode='matrix', asm_obj=mtx_m)
return mtx_k, mtx_m
def run(domain, order):
omega = domain.create_region('Omega', 'all')
bbox = domain.get_mesh_bounding_box()
min_x, max_x = bbox[:, 0]
min_y, max_y = bbox[:, 1]
eps = 1e-8 * (max_x - min_x)
gamma1 = domain.create_region('Gamma1',
'vertices in (x < %.10f)' % (min_x + eps),
'facet')
gamma2 = domain.create_region('Gamma2',
'vertices in (x > %.10f)' % (max_x - eps),
'facet')
gamma3 = domain.create_region('Gamma3',
'vertices in y < %.10f' % (min_y + eps),
'facet')
gamma4 = domain.create_region('Gamma4',
'vertices in y > %.10f' % (max_y - eps),
'facet')
field = Field.from_args('fu', nm.float64, 1, omega, approx_order=order)
u = FieldVariable('u', 'unknown', field)
v = FieldVariable('v', 'test', field, primary_var_name='u')
integral = Integral('i', order=2*order)
t1 = Term.new('dw_laplace(v, u)',
integral, omega, v=v, u=u)
eq = Equation('eq', t1)
eqs = Equations([eq])
fix1 = EssentialBC('fix1', gamma1, {'u.0' : 0.4})
fix2 = EssentialBC('fix2', gamma2, {'u.0' : 0.0})
def get_shift(ts, coors, region):
return nm.ones_like(coors[:, 0])
dof_map_fun = Function('dof_map_fun', per.match_x_line)
shift_fun = Function('shift_fun', get_shift)
sper = LinearCombinationBC('sper', [gamma3, gamma4], {'u.0' : 'u.0'},
dof_map_fun, 'shifted_periodic',
arguments=(shift_fun,))
ls = ScipyDirect({})
pb = Problem('laplace', equations=eqs, auto_solvers=None)
pb.time_update(ebcs=Conditions([fix1, fix2]), lcbcs=Conditions([sper]))
ev = pb.get_evaluator()
nls = Newton({}, lin_solver=ls,
fun=ev.eval_residual, fun_grad=ev.eval_tangent_matrix)
pb.set_solver(nls)
state = pb.solve()
return pb, state
def test_solving(self):
from sfepy.base.base import IndexedStruct
from sfepy.discrete import (FieldVariable, Material, Problem, Function,
Equation, Equations, Integral)
from sfepy.discrete.conditions import Conditions, EssentialBC
from sfepy.terms import Term
from sfepy.solvers.ls import ScipyDirect
from sfepy.solvers.nls import Newton
from sfepy.mechanics.matcoefs import stiffness_from_lame
u = FieldVariable('u', 'unknown', self.field)
v = FieldVariable('v', 'test', self.field, primary_var_name='u')
m = Material('m', D=stiffness_from_lame(self.dim, 1.0, 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(m.D, 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 = Problem('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, 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 = Problem('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 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", "vertices in x < %.10f" % (min_x + eps), "facet")
gamma2 = domain.create_region("Gamma2", "vertices in x > %.10f" % (max_x - eps), "facet")
field = Field.from_args("fu", nm.float64, "vector", omega, approx_order=2)
u = FieldVariable("u", "unknown", field)
v = FieldVariable("v", "test", field, 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 = Problem("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 solve_problem(shape, dims, young, poisson, force, transform=None):
domain = make_domain(dims[:2], shape, transform=transform)
omega = domain.regions['Omega']
gamma1 = domain.regions['Gamma1']
gamma2 = domain.regions['Gamma2']
field = Field.from_args('fu', nm.float64, 6, omega, approx_order=1,
poly_space_base='shell10x')
u = FieldVariable('u', 'unknown', field)
v = FieldVariable('v', 'test', field, primary_var_name='u')
thickness = dims[2]
if transform is None:
pload = [[0.0, 0.0, force / shape[1], 0.0, 0.0, 0.0]] * shape[1]
elif transform == 'bend':
pload = [[force / shape[1], 0.0, 0.0, 0.0, 0.0, 0.0]] * shape[1]
elif transform == 'twist':
pload = [[0.0, force / shape[1], 0.0, 0.0, 0.0, 0.0]] * shape[1]
m = Material('m', D=sh.create_elastic_tensor(young=young, poisson=poisson),
values={'.drill' : 1e-7})
load = Material('load', values={'.val' : pload})
aux = Integral('i', order=3)
qp_coors, qp_weights = aux.get_qp('3_8')
qp_coors[:, 2] = thickness * (qp_coors[:, 2] - 0.5)
qp_weights *= thickness
integral = Integral('i', coors=qp_coors, weights=qp_weights, order='custom')
t1 = Term.new('dw_shell10x(m.D, m.drill, v, u)',
integral, omega, m=m, v=v, u=u)
t2 = Term.new('dw_point_load(load.val, v)',
integral, gamma2, load=load, v=v)
eq = Equation('balance', t1 - t2)
eqs = Equations([eq])
fix_u = EssentialBC('fix_u', gamma1, {'u.all' : 0.0})
ls = ScipyDirect({})
nls_status = IndexedStruct()
nls = Newton({}, lin_solver=ls, status=nls_status)
pb = Problem('elasticity with shell10x', equations=eqs, nls=nls, ls=ls)
pb.time_update(ebcs=Conditions([fix_u]))
state = pb.solve()
return pb, state, u, gamma2
def run(domain, order):
omega = domain.create_region("Omega", "all")
bbox = domain.get_mesh_bounding_box()
min_x, max_x = bbox[:, 0]
min_y, max_y = bbox[:, 1]
eps = 1e-8 * (max_x - min_x)
gamma1 = domain.create_region("Gamma1", "vertices in (x < %.10f)" % (min_x + eps), "facet")
gamma2 = domain.create_region("Gamma2", "vertices in (x > %.10f)" % (max_x - eps), "facet")
gamma3 = domain.create_region("Gamma3", "vertices in y < %.10f" % (min_y + eps), "facet")
gamma4 = domain.create_region("Gamma4", "vertices in y > %.10f" % (max_y - eps), "facet")
field = Field.from_args("fu", nm.float64, 1, omega, approx_order=order)
u = FieldVariable("u", "unknown", field)
v = FieldVariable("v", "test", field, primary_var_name="u")
integral = Integral("i", order=2 * order)
t1 = Term.new("dw_laplace(v, u)", integral, omega, v=v, u=u)
eq = Equation("eq", t1)
eqs = Equations([eq])
fix1 = EssentialBC("fix1", gamma1, {"u.0": 0.4})
fix2 = EssentialBC("fix2", gamma2, {"u.0": 0.0})
def get_shift(ts, coors, region):
return nm.ones_like(coors[:, 0])
dof_map_fun = Function("dof_map_fun", per.match_x_line)
shift_fun = Function("shift_fun", get_shift)
sper = LinearCombinationBC(
"sper", [gamma3, gamma4], {"u.0": "u.0"}, dof_map_fun, "shifted_periodic", arguments=(shift_fun,)
)
ls = ScipyDirect({})
pb = Problem("laplace", equations=eqs, auto_solvers=None)
pb.time_update(ebcs=Conditions([fix1, fix2]), lcbcs=Conditions([sper]))
ev = pb.get_evaluator()
nls = Newton({}, lin_solver=ls, fun=ev.eval_residual, fun_grad=ev.eval_tangent_matrix)
pb.set_solver(nls)
state = pb.solve()
return pb, state
def test_save_ebc(self):
from sfepy.discrete import (FieldVariable, Integral, Equation,
Equations, Problem)
from sfepy.discrete.conditions import Conditions, EssentialBC
from sfepy.terms import Term
name = op.join(self.options.out_dir,
op.splitext(op.basename(__file__))[0])
integral = Integral('i', order=1)
u = self.variables['u']
v = FieldVariable('v', 'test', u.field, primary_var_name='u')
p = self.variables['p']
q = FieldVariable('q', 'test', p.field, primary_var_name='p')
regions = self.problem.domain.regions
omega = regions['Omega']
# Problem.save_ebc() requires to have equations defined.
t1 = Term.new('dw_lin_elastic(v, u)', integral, omega, v=v, u=u)
t2 = Term.new('dw_laplace(q, p)', integral, omega, q=q, p=p)
eq = Equation('aux', t1 + t2)
eqs = Equations([eq])
pb = Problem('test', equations=eqs, auto_solvers=False)
all_ebcs = []
all_ebcs.append(
EssentialBC('fix_u1', regions['RightFix'],
{'u.all': nm.array([0.0, 1.0])}))
all_ebcs.append(
EssentialBC('fix_u2', regions['LeftStrip'], {
'u.0': 0.0,
'u.1': 1.0
}))
all_ebcs.append(
EssentialBC('fix_p1', regions['LeftFix'], {'p.all': 0.0}))
all_ebcs.append(
EssentialBC('fix_p2', regions['RightStrip'], {'p.0': 0.0}))
ebcs = Conditions(all_ebcs)
pb.time_update(ebcs=ebcs)
pb.save_ebc(name + '_ebcs_f.vtk', ebcs=ebcs, force=True)
pb.save_ebc(name + '_ebcs.vtk', ebcs=ebcs, default=-1, force=False)
return True
def test_save_ebc(self):
from sfepy.discrete import (FieldVariable, Integral,
Equation, Equations, Problem)
from sfepy.discrete.conditions import Conditions, EssentialBC
from sfepy.terms import Term
name = op.join(self.options.out_dir,
op.splitext(op.basename(__file__))[0])
integral = Integral('i', order=1)
u = self.variables['u']
v = FieldVariable('v', 'test', u.field, primary_var_name='u')
p = self.variables['p']
q = FieldVariable('q', 'test', p.field, primary_var_name='p')
regions = self.problem.domain.regions
omega = regions['Omega']
# Problem.save_ebc() requires to have equations defined.
t1 = Term.new('dw_lin_elastic(v, u)',
integral, omega, v=v, u=u)
t2 = Term.new('dw_laplace(q, p)', integral, omega, q=q, p=p)
eq = Equation('aux', t1 + t2)
eqs = Equations([eq])
pb = Problem('test', equations=eqs, auto_solvers=False)
all_ebcs = []
all_ebcs.append(EssentialBC('fix_u1', regions['RightFix'],
{'u.all' : nm.array([0.0, 1.0])}))
all_ebcs.append(EssentialBC('fix_u2', regions['LeftStrip'],
{'u.0' : 0.0, 'u.1' : 1.0}))
all_ebcs.append(EssentialBC('fix_p1', regions['LeftFix'],
{'p.all' : 0.0}))
all_ebcs.append(EssentialBC('fix_p2', regions['RightStrip'],
{'p.0' : 0.0}))
ebcs = Conditions(all_ebcs)
pb.time_update(ebcs=ebcs)
pb.save_ebc(name + '_ebcs_f.vtk', ebcs=ebcs, force=True)
pb.save_ebc(name + '_ebcs.vtk', ebcs=ebcs, default=-1, force=False)
return True
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, 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 = Problem('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 linear_projection(pb, cval):
from sfepy.discrete import (FieldVariable, Material, Integral, Equation,
Equations, Problem)
from sfepy.discrete.fem import Mesh, FEDomain, Field
from sfepy.terms import Term
from sfepy.solvers.ls import ScipyDirect
from sfepy.solvers.nls import Newton
from sfepy.base.base import IndexedStruct
mesh = Mesh.from_file(pb.conf.filename_mesh)
domain = FEDomain('domain', mesh)
omega = domain.create_region('Omega', 'all')
field = Field.from_args('scf', nm.float64, 'scalar', omega, approx_order=1)
g = FieldVariable('g', 'unknown', field)
f = FieldVariable('f', 'test', field, primary_var_name='g')
integral = Integral('i', order=2)
m = Material('m', function=set_grad)
t1 = Term.new('dw_volume_dot(f, g)', integral, omega, f=f, g=g)
t2 = Term.new('dw_volume_lvf(m.cs, f)', integral, omega, m=m, f=f)
eq = Equation('balance', t1 - t2)
eqs = Equations([eq])
ls = ScipyDirect({})
nls_status = IndexedStruct()
nls = Newton({'eps_a': 1e-15}, lin_solver=ls, status=nls_status)
pb = Problem('elasticity', equations=eqs)
pb.set_solver(nls)
out = nm.empty((g.n_dof, cval.shape[2]), dtype=nm.float64)
for ii in range(cval.shape[2]):
pb.data = nm.ascontiguousarray(cval[:, :, ii, :])
pb.time_update()
state = pb.solve()
out[:, ii] = state.get_parts()['g']
return out
def create_local_problem(omega_gi, order):
"""
Local problem definition using a domain corresponding to the global region
`omega_gi`.
"""
mesh = omega_gi.domain.mesh
# All tasks have the whole mesh.
bbox = mesh.get_bounding_box()
min_x, max_x = bbox[:, 0]
eps_x = 1e-8 * (max_x - min_x)
mesh_i = Mesh.from_region(omega_gi, mesh, localize=True)
domain_i = FEDomain('domain_i', mesh_i)
omega_i = domain_i.create_region('Omega', 'all')
gamma1_i = domain_i.create_region('Gamma1',
'vertices in (x < %.10f)' %
(min_x + eps_x),
'facet',
allow_empty=True)
gamma2_i = domain_i.create_region('Gamma2',
'vertices in (x > %.10f)' %
(max_x - eps_x),
'facet',
allow_empty=True)
field_i = Field.from_args('fu', nm.float64, 1, omega_i, approx_order=order)
output('number of local field DOFs:', field_i.n_nod)
u_i = FieldVariable('u_i', 'unknown', field_i)
v_i = FieldVariable('v_i', 'test', field_i, primary_var_name='u_i')
integral = Integral('i', order=2 * order)
mat = Material('m', lam=10, mu=5)
t1 = Term.new('dw_laplace(m.lam, v_i, u_i)',
integral,
omega_i,
m=mat,
v_i=v_i,
u_i=u_i)
def _get_load(coors):
val = nm.ones_like(coors[:, 0])
for coor in coors.T:
val *= nm.sin(4 * nm.pi * coor)
return val
def get_load(ts, coors, mode=None, **kwargs):
if mode == 'qp':
return {'val': _get_load(coors).reshape(coors.shape[0], 1, 1)}
load = Material('load', function=Function('get_load', get_load))
t2 = Term.new('dw_volume_lvf(load.val, v_i)',
integral,
omega_i,
load=load,
v_i=v_i)
eq = Equation('balance', t1 - 100 * t2)
eqs = Equations([eq])
ebc1 = EssentialBC('ebc1', gamma1_i, {'u_i.all': 0.0})
ebc2 = EssentialBC('ebc2', gamma2_i, {'u_i.all': 0.1})
pb = Problem('problem_i', equations=eqs, active_only=False)
pb.time_update(ebcs=Conditions([ebc1, ebc2]))
pb.update_materials()
return pb
def main():
from sfepy import data_dir
parser = OptionParser(usage=usage, version='%prog')
parser.add_option('--young', metavar='float', type=float,
action='store', dest='young',
default=2000.0, help=helps['young'])
parser.add_option('--poisson', metavar='float', type=float,
action='store', dest='poisson',
default=0.4, help=helps['poisson'])
parser.add_option('--load', metavar='float', type=float,
action='store', dest='load',
default=-1000.0, help=helps['load'])
parser.add_option('--order', metavar='int', type=int,
action='store', dest='order',
default=1, help=helps['order'])
parser.add_option('-r', '--refine', metavar='int', type=int,
action='store', dest='refine',
default=0, help=helps['refine'])
parser.add_option('-s', '--show',
action="store_true", dest='show',
default=False, help=helps['show'])
parser.add_option('-p', '--probe',
action="store_true", dest='probe',
default=False, help=helps['probe'])
options, args = parser.parse_args()
assert_((0.0 < options.poisson < 0.5),
"Poisson's ratio must be in ]0, 0.5[!")
assert_((0 < options.order),
'displacement approximation order must be at least 1!')
output('using values:')
output(" Young's modulus:", options.young)
output(" Poisson's ratio:", options.poisson)
output(' vertical load:', options.load)
output('uniform mesh refinement level:', options.refine)
# Build the problem definition.
mesh = Mesh.from_file(data_dir + '/meshes/2d/its2D.mesh')
domain = FEDomain('domain', mesh)
if options.refine > 0:
for ii in range(options.refine):
output('refine %d...' % ii)
domain = domain.refine()
output('... %d nodes %d elements'
% (domain.shape.n_nod, domain.shape.n_el))
omega = domain.create_region('Omega', 'all')
left = domain.create_region('Left',
'vertices in x < 0.001', 'facet')
bottom = domain.create_region('Bottom',
'vertices in y < 0.001', 'facet')
top = domain.create_region('Top', 'vertex 2', 'vertex')
field = Field.from_args('fu', nm.float64, 'vector', omega,
approx_order=options.order)
u = FieldVariable('u', 'unknown', field)
v = FieldVariable('v', 'test', field, primary_var_name='u')
D = stiffness_from_youngpoisson(2, options.young, options.poisson)
asphalt = Material('Asphalt', D=D)
load = Material('Load', values={'.val' : [0.0, options.load]})
integral = Integral('i', order=2*options.order)
integral0 = Integral('i', order=0)
t1 = Term.new('dw_lin_elastic(Asphalt.D, v, u)',
integral, omega, Asphalt=asphalt, v=v, u=u)
t2 = Term.new('dw_point_load(Load.val, v)',
integral0, top, Load=load, v=v)
eq = Equation('balance', t1 - t2)
eqs = Equations([eq])
xsym = EssentialBC('XSym', bottom, {'u.1' : 0.0})
ysym = EssentialBC('YSym', left, {'u.0' : 0.0})
ls = ScipyDirect({})
nls_status = IndexedStruct()
nls = Newton({}, lin_solver=ls, status=nls_status)
pb = Problem('elasticity', equations=eqs, nls=nls, ls=ls)
pb.time_update(ebcs=Conditions([xsym, ysym]))
# Solve the problem.
state = pb.solve()
output(nls_status)
# Postprocess the solution.
out = state.create_output_dict()
out = stress_strain(out, pb, state, extend=True)
pb.save_state('its2D_interactive.vtk', out=out)
gdata = geometry_data['2_3']
nc = len(gdata.coors)
integral_vn = Integral('ivn', coors=gdata.coors,
weights=[gdata.volume / nc] * nc)
nodal_stress(out, pb, state, integrals=Integrals([integral_vn]))
if options.probe:
# Probe the solution.
probes, labels = gen_lines(pb)
sfield = Field.from_args('sym_tensor', nm.float64, 3, omega,
approx_order=options.order - 1)
stress = FieldVariable('stress', 'parameter', sfield,
primary_var_name='(set-to-None)')
strain = FieldVariable('strain', 'parameter', sfield,
primary_var_name='(set-to-None)')
cfield = Field.from_args('component', nm.float64, 1, omega,
approx_order=options.order - 1)
component = FieldVariable('component', 'parameter', cfield,
primary_var_name='(set-to-None)')
ev = pb.evaluate
order = 2 * (options.order - 1)
strain_qp = ev('ev_cauchy_strain.%d.Omega(u)' % order, mode='qp')
stress_qp = ev('ev_cauchy_stress.%d.Omega(Asphalt.D, u)' % order,
mode='qp', copy_materials=False)
project_by_component(strain, strain_qp, component, order)
project_by_component(stress, stress_qp, component, order)
all_results = []
for ii, probe in enumerate(probes):
fig, results = probe_results(u, strain, stress, probe, labels[ii])
fig.savefig('its2D_interactive_probe_%d.png' % ii)
all_results.append(results)
for ii, results in enumerate(all_results):
output('probe %d:' % ii)
output.level += 2
for key, res in ordered_iteritems(results):
output(key + ':')
val = res[1]
output(' min: %+.2e, mean: %+.2e, max: %+.2e'
% (val.min(), val.mean(), val.max()))
output.level -= 2
if options.show:
# Show the solution. If the approximation order is greater than 1, the
# extra DOFs are simply thrown away.
from sfepy.postprocess.viewer import Viewer
view = Viewer('its2D_interactive.vtk')
view(vector_mode='warp_norm', rel_scaling=1,
is_scalar_bar=True, is_wireframe=True)
def make_l2_projection_data(target,
eval_data,
order=None,
ls=None,
nls_options=None):
"""
Project scalar data to a scalar `target` field variable using the
:math:`L^2` dot product.
Parameters
----------
target : FieldVariable instance
The target variable.
eval_data : callable or array
Either a material-like function `eval_data()`, or an array of values in
quadrature points that has to be reshapable to the shape required by
`order`.
order : int, optional
The quadrature order. If not given, it is set to
`2 * target.field.approx_order`.
"""
if order is None:
order = 2 * target.field.approx_order
integral = Integral('i', order=order)
un = FieldVariable('u', 'unknown', target.field)
v = FieldVariable('v', 'test', un.field, primary_var_name=un.name)
lhs = Term.new('dw_volume_dot(v, %s)' % un.name,
integral,
un.field.region,
v=v,
**{un.name: un})
def _eval_data(ts, coors, mode, **kwargs):
if mode == 'qp':
if callable(eval_data):
val = eval_data(ts, coors, mode, **kwargs)
else:
val = eval_data.reshape((coors.shape[0], 1, 1))
return {'val': val}
m = Material('m', function=_eval_data)
rhs = Term.new('dw_volume_lvf(m.val, v)',
integral,
un.field.region,
m=m,
v=v)
eq = Equation('projection', lhs - rhs)
eqs = Equations([eq])
if ls is None:
ls = ScipyDirect({})
if nls_options is None:
nls_options = {}
nls_status = IndexedStruct()
nls = Newton(nls_options, lin_solver=ls, status=nls_status)
pb = Problem('aux', equations=eqs, nls=nls, ls=ls)
pb.time_update()
# This sets the un variable with the projection solution.
pb.solve()
# Copy the projection solution to target.
target.set_data(un())
if nls_status.condition != 0:
output('L2 projection: solver did not converge!')
def main():
from sfepy import data_dir
parser = ArgumentParser(description=__doc__,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('--version', action='version', version='%(prog)s')
parser.add_argument('--diffusivity', metavar='float', type=float,
action='store', dest='diffusivity',
default=1e-5, help=helps['diffusivity'])
parser.add_argument('--ic-max', metavar='float', type=float,
action='store', dest='ic_max',
default=2.0, help=helps['ic_max'])
parser.add_argument('--order', metavar='int', type=int,
action='store', dest='order',
default=2, help=helps['order'])
parser.add_argument('-r', '--refine', metavar='int', type=int,
action='store', dest='refine',
default=0, help=helps['refine'])
parser.add_argument('-p', '--probe',
action="store_true", dest='probe',
default=False, help=helps['probe'])
parser.add_argument('-s', '--show',
action="store_true", dest='show',
default=False, help=helps['show'])
options = parser.parse_args()
assert_((0 < options.order),
'temperature approximation order must be at least 1!')
output('using values:')
output(' diffusivity:', options.diffusivity)
output(' max. IC value:', options.ic_max)
output('uniform mesh refinement level:', options.refine)
mesh = Mesh.from_file(data_dir + '/meshes/3d/cylinder.mesh')
domain = FEDomain('domain', mesh)
if options.refine > 0:
for ii in range(options.refine):
output('refine %d...' % ii)
domain = domain.refine()
output('... %d nodes %d elements'
% (domain.shape.n_nod, domain.shape.n_el))
omega = domain.create_region('Omega', 'all')
left = domain.create_region('Left',
'vertices in x < 0.00001', 'facet')
right = domain.create_region('Right',
'vertices in x > 0.099999', 'facet')
field = Field.from_args('fu', nm.float64, 'scalar', omega,
approx_order=options.order)
T = FieldVariable('T', 'unknown', field, history=1)
s = FieldVariable('s', 'test', field, primary_var_name='T')
m = Material('m', diffusivity=options.diffusivity * nm.eye(3))
integral = Integral('i', order=2*options.order)
t1 = Term.new('dw_diffusion(m.diffusivity, s, T)',
integral, omega, m=m, s=s, T=T)
t2 = Term.new('dw_volume_dot(s, dT/dt)',
integral, omega, s=s, T=T)
eq = Equation('balance', t1 + t2)
eqs = Equations([eq])
# Boundary conditions.
ebc1 = EssentialBC('T1', left, {'T.0' : 2.0})
ebc2 = EssentialBC('T2', right, {'T.0' : -2.0})
# Initial conditions.
def get_ic(coors, ic):
x, y, z = coors.T
return 2 - 40.0 * x + options.ic_max * nm.sin(4 * nm.pi * x / 0.1)
ic_fun = Function('ic_fun', get_ic)
ic = InitialCondition('ic', omega, {'T.0' : ic_fun})
pb = Problem('heat', equations=eqs)
pb.set_bcs(ebcs=Conditions([ebc1, ebc2]))
pb.set_ics(Conditions([ic]))
state0 = pb.get_initial_state()
init_fun, prestep_fun, _poststep_fun = pb.get_tss_functions(state0)
ls = ScipyDirect({})
nls_status = IndexedStruct()
nls = Newton({'is_linear' : True}, lin_solver=ls, status=nls_status)
tss = SimpleTimeSteppingSolver({'t0' : 0.0, 't1' : 100.0, 'n_step' : 11},
nls=nls, context=pb, verbose=True)
pb.set_solver(tss)
if options.probe:
# Prepare probe data.
probes, labels = gen_probes(pb)
ev = pb.evaluate
order = 2 * (options.order - 1)
gfield = Field.from_args('gu', nm.float64, 'vector', omega,
approx_order=options.order - 1)
dvel = FieldVariable('dvel', 'parameter', gfield,
primary_var_name='(set-to-None)')
cfield = Field.from_args('gu', nm.float64, 'scalar', omega,
approx_order=options.order - 1)
component = FieldVariable('component', 'parameter', cfield,
primary_var_name='(set-to-None)')
nls_options = {'eps_a' : 1e-16, 'i_max' : 1}
suffix = tss.ts.suffix
def poststep_fun(ts, vec):
_poststep_fun(ts, vec)
# Probe the solution.
dvel_qp = ev('ev_diffusion_velocity.%d.Omega(m.diffusivity, T)'
% order, copy_materials=False, mode='qp')
project_by_component(dvel, dvel_qp, component, order,
nls_options=nls_options)
all_results = []
for ii, probe in enumerate(probes):
fig, results = probe_results(ii, T, dvel, probe, labels[ii])
all_results.append(results)
plt.tight_layout()
fig.savefig('time_poisson_interactive_probe_%s.png'
% (suffix % ts.step), bbox_inches='tight')
for ii, results in enumerate(all_results):
output('probe %d (%s):' % (ii, probes[ii].name))
output.level += 2
for key, res in ordered_iteritems(results):
output(key + ':')
val = res[1]
output(' min: %+.2e, mean: %+.2e, max: %+.2e'
% (val.min(), val.mean(), val.max()))
output.level -= 2
else:
poststep_fun = _poststep_fun
pb.time_update(tss.ts)
state0.apply_ebc()
# This is required if {'is_linear' : True} is passed to Newton.
mtx = prepare_matrix(pb, state0)
pb.try_presolve(mtx)
tss_status = IndexedStruct()
tss(state0.get_vec(pb.active_only),
init_fun=init_fun, prestep_fun=prestep_fun, poststep_fun=poststep_fun,
status=tss_status)
output(tss_status)
if options.show:
plt.show()
def main():
from sfepy import data_dir
parser = ArgumentParser()
parser.add_argument('--version', action='version', version='%(prog)s')
parser.add_argument('-s', '--show',
action="store_true", dest='show',
default=False, help=helps['show'])
options = parser.parse_args()
mesh = Mesh.from_file(data_dir + '/meshes/2d/rectangle_tri.mesh')
domain = FEDomain('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',
'vertices in x < %.10f' % (min_x + eps),
'facet')
gamma2 = domain.create_region('Gamma2',
'vertices in x > %.10f' % (max_x - eps),
'facet')
field = Field.from_args('fu', nm.float64, 'vector', omega,
approx_order=2)
u = FieldVariable('u', 'unknown', field)
v = FieldVariable('v', 'test', field, primary_var_name='u')
m = Material('m', D=stiffness_from_lame(dim=2, 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(m.D, 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 = Problem('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 main():
parser = ArgumentParser(description=__doc__,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('--version', action='version', version='%(prog)s')
parser.add_argument('-d', '--dims', metavar='dims',
action='store', dest='dims',
default='[1.0, 1.0]', help=helps['dims'])
parser.add_argument('-c', '--centre', metavar='centre',
action='store', dest='centre',
default='[0.0, 0.0]', help=helps['centre'])
parser.add_argument('-s', '--shape', metavar='shape',
action='store', dest='shape',
default='[11, 11]', help=helps['shape'])
parser.add_argument('-b', '--bc-kind', metavar='kind',
action='store', dest='bc_kind',
choices=['free', 'cantilever', 'fixed'],
default='free', help=helps['bc_kind'])
parser.add_argument('-a', '--axis', metavar='0, ..., dim, or -1',
type=int, action='store', dest='axis',
default=-1, help=helps['axis'])
parser.add_argument('--young', metavar='float', type=float,
action='store', dest='young',
default=6.80e+10, help=helps['young'])
parser.add_argument('--poisson', metavar='float', type=float,
action='store', dest='poisson',
default=0.36, help=helps['poisson'])
parser.add_argument('--density', metavar='float', type=float,
action='store', dest='density',
default=2700.0, help=helps['density'])
parser.add_argument('--order', metavar='int', type=int,
action='store', dest='order',
default=1, help=helps['order'])
parser.add_argument('-n', '--n-eigs', metavar='int', type=int,
action='store', dest='n_eigs',
default=6, help=helps['n_eigs'])
parser.add_argument('-i', '--ignore', metavar='int', type=int,
action='store', dest='ignore',
default=None, help=helps['ignore'])
parser.add_argument('--solver', metavar='solver', action='store',
dest='solver',
default= \
"eig.scipy,method:'eigh',tol:1e-5,maxiter:1000",
help=helps['solver'])
parser.add_argument('--show',
action="store_true", dest='show',
default=False, help=helps['show'])
parser.add_argument('filename', nargs='?', default=None)
options = parser.parse_args()
aux = options.solver.split(',')
kwargs = {}
for option in aux[1:]:
key, val = option.split(':')
kwargs[key.strip()] = eval(val)
eig_conf = Struct(name='evp', kind=aux[0], **kwargs)
output('using values:')
output(" Young's modulus:", options.young)
output(" Poisson's ratio:", options.poisson)
output(' density:', options.density)
output('displacement field approximation order:', options.order)
output('requested %d eigenvalues' % options.n_eigs)
output('using eigenvalue problem solver:', eig_conf.kind)
output.level += 1
for key, val in six.iteritems(kwargs):
output('%s: %r' % (key, val))
output.level -= 1
assert_((0.0 < options.poisson < 0.5),
"Poisson's ratio must be in ]0, 0.5[!")
assert_((0 < options.order),
'displacement approximation order must be at least 1!')
filename = options.filename
if filename is not None:
mesh = Mesh.from_file(filename)
dim = mesh.dim
dims = nm.diff(mesh.get_bounding_box(), axis=0)
else:
dims = nm.array(eval(options.dims), dtype=nm.float64)
dim = len(dims)
centre = nm.array(eval(options.centre), dtype=nm.float64)[:dim]
shape = nm.array(eval(options.shape), dtype=nm.int32)[:dim]
output('dimensions:', dims)
output('centre: ', centre)
output('shape: ', shape)
mesh = gen_block_mesh(dims, shape, centre, name='mesh')
output('axis: ', options.axis)
assert_((-dim <= options.axis < dim), 'invalid axis value!')
eig_solver = Solver.any_from_conf(eig_conf)
# Build the problem definition.
domain = FEDomain('domain', mesh)
bbox = domain.get_mesh_bounding_box()
min_coor, max_coor = bbox[:, options.axis]
eps = 1e-8 * (max_coor - min_coor)
ax = 'xyz'[:dim][options.axis]
omega = domain.create_region('Omega', 'all')
bottom = domain.create_region('Bottom',
'vertices in (%s < %.10f)'
% (ax, min_coor + eps),
'facet')
bottom_top = domain.create_region('BottomTop',
'r.Bottom +v vertices in (%s > %.10f)'
% (ax, max_coor - eps),
'facet')
field = Field.from_args('fu', nm.float64, 'vector', omega,
approx_order=options.order)
u = FieldVariable('u', 'unknown', field)
v = FieldVariable('v', 'test', field, primary_var_name='u')
mtx_d = stiffness_from_youngpoisson(dim, options.young, options.poisson)
m = Material('m', D=mtx_d, rho=options.density)
integral = Integral('i', order=2*options.order)
t1 = Term.new('dw_lin_elastic(m.D, v, u)', integral, omega, m=m, v=v, u=u)
t2 = Term.new('dw_volume_dot(m.rho, v, u)', integral, omega, m=m, v=v, u=u)
eq1 = Equation('stiffness', t1)
eq2 = Equation('mass', t2)
lhs_eqs = Equations([eq1, eq2])
pb = Problem('modal', equations=lhs_eqs)
if options.bc_kind == 'free':
pb.time_update()
n_rbm = dim * (dim + 1) / 2
elif options.bc_kind == 'cantilever':
fixed = EssentialBC('Fixed', bottom, {'u.all' : 0.0})
pb.time_update(ebcs=Conditions([fixed]))
n_rbm = 0
elif options.bc_kind == 'fixed':
fixed = EssentialBC('Fixed', bottom_top, {'u.all' : 0.0})
pb.time_update(ebcs=Conditions([fixed]))
n_rbm = 0
else:
raise ValueError('unsupported BC kind! (%s)' % options.bc_kind)
if options.ignore is not None:
n_rbm = options.ignore
pb.update_materials()
# Assemble stiffness and mass matrices.
mtx_k = eq1.evaluate(mode='weak', dw_mode='matrix', asm_obj=pb.mtx_a)
mtx_m = mtx_k.copy()
mtx_m.data[:] = 0.0
mtx_m = eq2.evaluate(mode='weak', dw_mode='matrix', asm_obj=mtx_m)
try:
eigs, svecs = eig_solver(mtx_k, mtx_m, options.n_eigs + n_rbm,
eigenvectors=True)
except sla.ArpackNoConvergence as ee:
eigs = ee.eigenvalues
svecs = ee.eigenvectors
output('only %d eigenvalues converged!' % len(eigs))
output('%d eigenvalues converged (%d ignored as rigid body modes)' %
(len(eigs), n_rbm))
eigs = eigs[n_rbm:]
svecs = svecs[:, n_rbm:]
omegas = nm.sqrt(eigs)
freqs = omegas / (2 * nm.pi)
output('number | eigenvalue | angular frequency '
'| frequency')
for ii, eig in enumerate(eigs):
output('%6d | %17.12e | %17.12e | %17.12e'
% (ii + 1, eig, omegas[ii], freqs[ii]))
# Make full eigenvectors (add DOFs fixed by boundary conditions).
variables = pb.get_variables()
vecs = nm.empty((variables.di.ptr[-1], svecs.shape[1]),
dtype=nm.float64)
for ii in range(svecs.shape[1]):
vecs[:, ii] = variables.make_full_vec(svecs[:, ii])
# Save the eigenvectors.
out = {}
state = pb.create_state()
for ii in range(eigs.shape[0]):
state.set_full(vecs[:, ii])
aux = state.create_output_dict()
strain = pb.evaluate('ev_cauchy_strain.i.Omega(u)',
integrals=Integrals([integral]),
mode='el_avg', verbose=False)
out['u%03d' % ii] = aux.popitem()[1]
out['strain%03d' % ii] = Struct(mode='cell', data=strain)
pb.save_state('eigenshapes.vtk', out=out)
pb.save_regions_as_groups('regions')
if len(eigs) and options.show:
# Show the solution. If the approximation order is greater than 1, the
# extra DOFs are simply thrown away.
from sfepy.postprocess.viewer import Viewer
from sfepy.postprocess.domain_specific import DomainSpecificPlot
scaling = 0.05 * dims.max() / nm.abs(vecs).max()
ds = {}
for ii in range(eigs.shape[0]):
pd = DomainSpecificPlot('plot_displacements',
['rel_scaling=%s' % scaling,
'color_kind="tensors"',
'color_name="strain%03d"' % ii])
ds['u%03d' % ii] = pd
view = Viewer('eigenshapes.vtk')
view(domain_specific=ds, only_names=sorted(ds.keys()),
is_scalar_bar=False, is_wireframe=True)
def create_local_problem(omega_gi, order):
"""
Local problem definition using a domain corresponding to the global region
`omega_gi`.
"""
mesh = omega_gi.domain.mesh
# All tasks have the whole mesh.
bbox = mesh.get_bounding_box()
min_x, max_x = bbox[:, 0]
eps_x = 1e-8 * (max_x - min_x)
mesh_i = Mesh.from_region(omega_gi, mesh, localize=True)
domain_i = FEDomain('domain_i', mesh_i)
omega_i = domain_i.create_region('Omega', 'all')
gamma1_i = domain_i.create_region('Gamma1',
'vertices in (x < %.10f)'
% (min_x + eps_x),
'facet', allow_empty=True)
gamma2_i = domain_i.create_region('Gamma2',
'vertices in (x > %.10f)'
% (max_x - eps_x),
'facet', allow_empty=True)
field_i = Field.from_args('fu', nm.float64, 1, omega_i,
approx_order=order)
output('number of local field DOFs:', field_i.n_nod)
u_i = FieldVariable('u_i', 'unknown', field_i)
v_i = FieldVariable('v_i', 'test', field_i, primary_var_name='u_i')
integral = Integral('i', order=2*order)
mat = Material('m', lam=10, mu=5)
t1 = Term.new('dw_laplace(m.lam, v_i, u_i)',
integral, omega_i, m=mat, v_i=v_i, u_i=u_i)
def _get_load(coors):
val = nm.ones_like(coors[:, 0])
for coor in coors.T:
val *= nm.sin(4 * nm.pi * coor)
return val
def get_load(ts, coors, mode=None, **kwargs):
if mode == 'qp':
return {'val' : _get_load(coors).reshape(coors.shape[0], 1, 1)}
load = Material('load', function=Function('get_load', get_load))
t2 = Term.new('dw_volume_lvf(load.val, v_i)',
integral, omega_i, load=load, v_i=v_i)
eq = Equation('balance', t1 - 100 * t2)
eqs = Equations([eq])
ebc1 = EssentialBC('ebc1', gamma1_i, {'u_i.all' : 0.0})
ebc2 = EssentialBC('ebc2', gamma2_i, {'u_i.all' : 0.1})
pb = Problem('problem_i', equations=eqs, active_only=False)
pb.time_update(ebcs=Conditions([ebc1, ebc2]))
pb.update_materials()
return pb
def _solve(self, property_array):
"""
Solve the Sfepy problem for one sample.
Args:
property_array: array of shape (n_x, n_y, 2) where the last
index is for Lame's parameter and shear modulus,
respectively.
Returns:
the strain field of shape (n_x, n_y, 2) where the last
index represents the x and y displacements
"""
shape = property_array.shape[:-1]
mesh = self._get_mesh(shape)
domain = Domain('domain', mesh)
region_all = domain.create_region('region_all', 'all')
field = Field.from_args('fu', np.float64, 'vector', region_all, # pylint: disable=no-member
approx_order=2)
u = FieldVariable('u', 'unknown', field)
v = FieldVariable('v', 'test', field, primary_var_name='u')
m = self._get_material(property_array, domain)
integral = Integral('i', order=4)
t1 = Term.new('dw_lin_elastic_iso(m.lam, m.mu, v, u)',
integral, region_all, m=m, v=v, u=u)
eq = Equation('balance_of_forces', t1)
eqs = Equations([eq])
epbcs, functions = self._get_periodicBCs(domain)
ebcs = self._get_displacementBCs(domain)
lcbcs = self._get_linear_combinationBCs(domain)
ls = ScipyDirect({})
pb = Problem('elasticity', equations=eqs, auto_solvers=None)
pb.time_update(
ebcs=ebcs, epbcs=epbcs, lcbcs=lcbcs, functions=functions)
ev = pb.get_evaluator()
nls = Newton({}, lin_solver=ls,
fun=ev.eval_residual, fun_grad=ev.eval_tangent_matrix)
try:
pb.set_solvers_instances(ls, nls)
except AttributeError:
pb.set_solver(nls)
vec = pb.solve()
u = vec.create_output_dict()['u'].data
u_reshape = np.reshape(u, (tuple(x + 1 for x in shape) + u.shape[-1:]))
dims = domain.get_mesh_bounding_box().shape[1]
strain = np.squeeze(
pb.evaluate(
'ev_cauchy_strain.{dim}.region_all(u)'.format(
dim=dims),
mode='el_avg',
copy_materials=False))
strain_reshape = np.reshape(strain, (shape + strain.shape[-1:]))
stress = np.squeeze(
pb.evaluate(
'ev_cauchy_stress.{dim}.region_all(m.D, u)'.format(
dim=dims),
mode='el_avg',
copy_materials=False))
stress_reshape = np.reshape(stress, (shape + stress.shape[-1:]))
return strain_reshape, u_reshape, stress_reshape
def create_local_problem(omega_gi, orders):
"""
Local problem definition using a domain corresponding to the global region
`omega_gi`.
"""
order_u, order_p = orders
mesh = omega_gi.domain.mesh
# All tasks have the whole mesh.
bbox = mesh.get_bounding_box()
min_x, max_x = bbox[:, 0]
eps_x = 1e-8 * (max_x - min_x)
min_y, max_y = bbox[:, 1]
eps_y = 1e-8 * (max_y - min_y)
mesh_i = Mesh.from_region(omega_gi, mesh, localize=True)
domain_i = FEDomain('domain_i', mesh_i)
omega_i = domain_i.create_region('Omega', 'all')
gamma1_i = domain_i.create_region('Gamma1',
'vertices in (x < %.10f)'
% (min_x + eps_x),
'facet', allow_empty=True)
gamma2_i = domain_i.create_region('Gamma2',
'vertices in (x > %.10f)'
% (max_x - eps_x),
'facet', allow_empty=True)
gamma3_i = domain_i.create_region('Gamma3',
'vertices in (y < %.10f)'
% (min_y + eps_y),
'facet', allow_empty=True)
field1_i = Field.from_args('fu', nm.float64, mesh.dim, omega_i,
approx_order=order_u)
field2_i = Field.from_args('fp', nm.float64, 1, omega_i,
approx_order=order_p)
output('field 1: number of local DOFs:', field1_i.n_nod)
output('field 2: number of local DOFs:', field2_i.n_nod)
u_i = FieldVariable('u_i', 'unknown', field1_i, order=0)
v_i = FieldVariable('v_i', 'test', field1_i, primary_var_name='u_i')
p_i = FieldVariable('p_i', 'unknown', field2_i, order=1)
q_i = FieldVariable('q_i', 'test', field2_i, primary_var_name='p_i')
if mesh.dim == 2:
alpha = 1e2 * nm.array([[0.132], [0.132], [0.092]])
else:
alpha = 1e2 * nm.array([[0.132], [0.132], [0.132],
[0.092], [0.092], [0.092]])
mat = Material('m', D=stiffness_from_lame(mesh.dim, lam=10, mu=5),
k=1, alpha=alpha)
integral = Integral('i', order=2*(max(order_u, order_p)))
t11 = Term.new('dw_lin_elastic(m.D, v_i, u_i)',
integral, omega_i, m=mat, v_i=v_i, u_i=u_i)
t12 = Term.new('dw_biot(m.alpha, v_i, p_i)',
integral, omega_i, m=mat, v_i=v_i, p_i=p_i)
t21 = Term.new('dw_biot(m.alpha, u_i, q_i)',
integral, omega_i, m=mat, u_i=u_i, q_i=q_i)
t22 = Term.new('dw_laplace(m.k, q_i, p_i)',
integral, omega_i, m=mat, q_i=q_i, p_i=p_i)
eq1 = Equation('eq1', t11 - t12)
eq2 = Equation('eq1', t21 + t22)
eqs = Equations([eq1, eq2])
ebc1 = EssentialBC('ebc1', gamma1_i, {'u_i.all' : 0.0})
ebc2 = EssentialBC('ebc2', gamma2_i, {'u_i.0' : 0.05})
def bc_fun(ts, coors, **kwargs):
val = 0.3 * nm.sin(4 * nm.pi * (coors[:, 0] - min_x) / (max_x - min_x))
return val
fun = Function('bc_fun', bc_fun)
ebc3 = EssentialBC('ebc3', gamma3_i, {'p_i.all' : fun})
pb = Problem('problem_i', equations=eqs, active_only=False)
pb.time_update(ebcs=Conditions([ebc1, ebc2, ebc3]))
pb.update_materials()
return pb
def main():
parser = ArgumentParser(description=__doc__.rstrip(),
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('output_dir', help=helps['output_dir'])
parser.add_argument('--dims', metavar='dims',
action='store', dest='dims',
default='1.0,1.0,1.0', help=helps['dims'])
parser.add_argument('--shape', metavar='shape',
action='store', dest='shape',
default='7,7,7', help=helps['shape'])
parser.add_argument('--centre', metavar='centre',
action='store', dest='centre',
default='0.0,0.0,0.0', help=helps['centre'])
parser.add_argument('-3', '--3d',
action='store_true', dest='is_3d',
default=False, help=helps['3d'])
parser.add_argument('--order', metavar='int', type=int,
action='store', dest='order',
default=1, help=helps['order'])
options = parser.parse_args()
dim = 3 if options.is_3d else 2
dims = nm.array(eval(options.dims), dtype=nm.float64)[:dim]
shape = nm.array(eval(options.shape), dtype=nm.int32)[:dim]
centre = nm.array(eval(options.centre), dtype=nm.float64)[:dim]
output('dimensions:', dims)
output('shape: ', shape)
output('centre: ', centre)
mesh0 = gen_block_mesh(dims, shape, centre, name='block-fem',
verbose=True)
domain0 = FEDomain('d', mesh0)
bbox = domain0.get_mesh_bounding_box()
min_x, max_x = bbox[:, 0]
eps = 1e-8 * (max_x - min_x)
cnt = (shape[0] - 1) // 2
g0 = 0.5 * dims[0]
grading = nm.array([g0 / 2**ii for ii in range(cnt)]) + eps + centre[0] - g0
domain, subs = refine_towards_facet(domain0, grading, 'x <')
omega = domain.create_region('Omega', 'all')
gamma1 = domain.create_region('Gamma1',
'vertices in (x < %.10f)' % (min_x + eps),
'facet')
gamma2 = domain.create_region('Gamma2',
'vertices in (x > %.10f)' % (max_x - eps),
'facet')
field = Field.from_args('fu', nm.float64, 1, omega,
approx_order=options.order)
if subs is not None:
field.substitute_dofs(subs)
u = FieldVariable('u', 'unknown', field)
v = FieldVariable('v', 'test', field, primary_var_name='u')
integral = Integral('i', order=2*options.order)
t1 = Term.new('dw_laplace(v, u)',
integral, omega, v=v, u=u)
eq = Equation('eq', t1)
eqs = Equations([eq])
def u_fun(ts, coors, bc=None, problem=None):
"""
Define a displacement depending on the y coordinate.
"""
if coors.shape[1] == 2:
min_y, max_y = bbox[:, 1]
y = (coors[:, 1] - min_y) / (max_y - min_y)
val = (max_y - min_y) * nm.cos(3 * nm.pi * y)
else:
min_y, max_y = bbox[:, 1]
min_z, max_z = bbox[:, 2]
y = (coors[:, 1] - min_y) / (max_y - min_y)
z = (coors[:, 2] - min_z) / (max_z - min_z)
val = ((max_y - min_y) * (max_z - min_z)
* nm.cos(3 * nm.pi * y) * (1.0 + 3.0 * (z - 0.5)**2))
return val
bc_fun = Function('u_fun', u_fun)
fix1 = EssentialBC('shift_u', gamma1, {'u.0' : bc_fun})
fix2 = EssentialBC('fix2', gamma2, {'u.all' : 0.0})
ls = ScipyDirect({})
nls = Newton({}, lin_solver=ls)
pb = Problem('heat', equations=eqs, nls=nls, ls=ls)
pb.time_update(ebcs=Conditions([fix1, fix2]))
state = pb.solve()
if subs is not None:
field.restore_dofs()
filename = os.path.join(options.output_dir, 'hanging.vtk')
ensure_path(filename)
pb.save_state(filename, state)
if options.order > 1:
pb.save_state(filename, state, linearization=Struct(kind='adaptive',
min_level=0,
max_level=8,
eps=1e-3))
def main():
from sfepy import data_dir
parser = OptionParser(usage=usage, version='%prog')
parser.add_option('--young',
metavar='float',
type=float,
action='store',
dest='young',
default=2000.0,
help=helps['young'])
parser.add_option('--poisson',
metavar='float',
type=float,
action='store',
dest='poisson',
default=0.4,
help=helps['poisson'])
parser.add_option('--load',
metavar='float',
type=float,
action='store',
dest='load',
default=-1000.0,
help=helps['load'])
parser.add_option('--order',
metavar='int',
type=int,
action='store',
dest='order',
default=1,
help=helps['order'])
parser.add_option('-r',
'--refine',
metavar='int',
type=int,
action='store',
dest='refine',
default=0,
help=helps['refine'])
parser.add_option('-s',
'--show',
action="store_true",
dest='show',
default=False,
help=helps['show'])
parser.add_option('-p',
'--probe',
action="store_true",
dest='probe',
default=False,
help=helps['probe'])
options, args = parser.parse_args()
assert_((0.0 < options.poisson < 0.5),
"Poisson's ratio must be in ]0, 0.5[!")
assert_((0 < options.order),
'displacement approximation order must be at least 1!')
output('using values:')
output(" Young's modulus:", options.young)
output(" Poisson's ratio:", options.poisson)
output(' vertical load:', options.load)
output('uniform mesh refinement level:', options.refine)
# Build the problem definition.
mesh = Mesh.from_file(data_dir + '/meshes/2d/its2D.mesh')
domain = FEDomain('domain', mesh)
if options.refine > 0:
for ii in xrange(options.refine):
output('refine %d...' % ii)
domain = domain.refine()
output('... %d nodes %d elements' %
(domain.shape.n_nod, domain.shape.n_el))
omega = domain.create_region('Omega', 'all')
left = domain.create_region('Left', 'vertices in x < 0.001', 'facet')
bottom = domain.create_region('Bottom', 'vertices in y < 0.001', 'facet')
top = domain.create_region('Top', 'vertex 2', 'vertex')
field = Field.from_args('fu',
nm.float64,
'vector',
omega,
approx_order=options.order)
u = FieldVariable('u', 'unknown', field)
v = FieldVariable('v', 'test', field, primary_var_name='u')
D = stiffness_from_youngpoisson(2, options.young, options.poisson)
asphalt = Material('Asphalt', D=D)
load = Material('Load', values={'.val': [0.0, options.load]})
integral = Integral('i', order=2 * options.order)
integral0 = Integral('i', order=0)
t1 = Term.new('dw_lin_elastic(Asphalt.D, v, u)',
integral,
omega,
Asphalt=asphalt,
v=v,
u=u)
t2 = Term.new('dw_point_load(Load.val, v)', integral0, top, Load=load, v=v)
eq = Equation('balance', t1 - t2)
eqs = Equations([eq])
xsym = EssentialBC('XSym', bottom, {'u.1': 0.0})
ysym = EssentialBC('YSym', left, {'u.0': 0.0})
ls = ScipyDirect({})
nls_status = IndexedStruct()
nls = Newton({}, lin_solver=ls, status=nls_status)
pb = Problem('elasticity', equations=eqs, nls=nls, ls=ls)
pb.time_update(ebcs=Conditions([xsym, ysym]))
# Solve the problem.
state = pb.solve()
output(nls_status)
# Postprocess the solution.
out = state.create_output_dict()
out = stress_strain(out, pb, state, extend=True)
pb.save_state('its2D_interactive.vtk', out=out)
gdata = geometry_data['2_3']
nc = len(gdata.coors)
integral_vn = Integral('ivn',
coors=gdata.coors,
weights=[gdata.volume / nc] * nc)
nodal_stress(out, pb, state, integrals=Integrals([integral_vn]))
if options.probe:
# Probe the solution.
probes, labels = gen_lines(pb)
sfield = Field.from_args('sym_tensor',
nm.float64,
3,
omega,
approx_order=options.order - 1)
stress = FieldVariable('stress',
'parameter',
sfield,
primary_var_name='(set-to-None)')
strain = FieldVariable('strain',
'parameter',
sfield,
primary_var_name='(set-to-None)')
cfield = Field.from_args('component',
nm.float64,
1,
omega,
approx_order=options.order - 1)
component = FieldVariable('component',
'parameter',
cfield,
primary_var_name='(set-to-None)')
ev = pb.evaluate
order = 2 * (options.order - 1)
strain_qp = ev('ev_cauchy_strain.%d.Omega(u)' % order, mode='qp')
stress_qp = ev('ev_cauchy_stress.%d.Omega(Asphalt.D, u)' % order,
mode='qp',
copy_materials=False)
project_by_component(strain, strain_qp, component, order)
project_by_component(stress, stress_qp, component, order)
all_results = []
for ii, probe in enumerate(probes):
fig, results = probe_results(u, strain, stress, probe, labels[ii])
fig.savefig('its2D_interactive_probe_%d.png' % ii)
all_results.append(results)
for ii, results in enumerate(all_results):
output('probe %d:' % ii)
output.level += 2
for key, res in ordered_iteritems(results):
output(key + ':')
val = res[1]
output(' min: %+.2e, mean: %+.2e, max: %+.2e' %
(val.min(), val.mean(), val.max()))
output.level -= 2
if options.show:
# Show the solution. If the approximation order is greater than 1, the
# extra DOFs are simply thrown away.
from sfepy.postprocess.viewer import Viewer
view = Viewer('its2D_interactive.vtk')
view(vector_mode='warp_norm',
rel_scaling=1,
is_scalar_bar=True,
is_wireframe=True)
def run(domain, order):
omega = domain.create_region('Omega', 'all')
bbox = domain.get_mesh_bounding_box()
min_x, max_x = bbox[:, 0]
min_y, max_y = bbox[:, 1]
eps = 1e-8 * (max_x - min_x)
gamma1 = domain.create_region('Gamma1',
'vertices in (x < %.10f)' % (min_x + eps),
'facet')
gamma2 = domain.create_region('Gamma2',
'vertices in (x > %.10f)' % (max_x - eps),
'facet')
gamma3 = domain.create_region('Gamma3',
'vertices in y < %.10f' % (min_y + eps),
'facet')
gamma4 = domain.create_region('Gamma4',
'vertices in y > %.10f' % (max_y - eps),
'facet')
field = Field.from_args('fu', nm.float64, 1, omega, approx_order=order)
u = FieldVariable('u', 'unknown', field)
v = FieldVariable('v', 'test', field, primary_var_name='u')
integral = Integral('i', order=2 * order)
t1 = Term.new('dw_laplace(v, u)', integral, omega, v=v, u=u)
eq = Equation('eq', t1)
eqs = Equations([eq])
fix1 = EssentialBC('fix1', gamma1, {'u.0': 0.4})
fix2 = EssentialBC('fix2', gamma2, {'u.0': 0.0})
def get_shift(ts, coors, region):
return nm.ones_like(coors[:, 0])
dof_map_fun = Function('dof_map_fun', per.match_x_line)
shift_fun = Function('shift_fun', get_shift)
sper = LinearCombinationBC('sper', [gamma3, gamma4], {'u.0': 'u.0'},
dof_map_fun,
'shifted_periodic',
arguments=(shift_fun, ))
ls = ScipyDirect({})
pb = Problem('laplace', equations=eqs, auto_solvers=None)
pb.time_update(ebcs=Conditions([fix1, fix2]), lcbcs=Conditions([sper]))
ev = pb.get_evaluator()
nls = Newton({},
lin_solver=ls,
fun=ev.eval_residual,
fun_grad=ev.eval_tangent_matrix)
pb.set_solver(nls)
state = pb.solve()
return pb, state
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()
options_probe = True
folder = str(uuid.uuid4())
os.mkdir(folder)
os.chdir(folder)
file = open('README.txt', 'w')
file.write('DIMENSIONS\n')
file.write('Lx = '+str(dims[0])+' Ly = '+str(dims[1])+' Lz = '+str(dims[2])+'\n')
file.write('DISCRETIZATION (NX, NY, NZ)\n')
file.write(str(NX)+' '+str(NY)+' '+str(NZ)+'\n')
file.write('MATERIALS\n')
file.write(str(E_f)+' '+str(nu_f)+' '+str(E_m)+' '+str(nu_m)+'\n')
#mesh = Mesh.from_file(data_dir + '/meshes/2d/rectangle_tri.mesh')
mesh = mesh_generators.gen_block_mesh(dims,shape,centre,name='block')
domain = FEDomain('domain', mesh)
min_x, max_x = domain.get_mesh_bounding_box()[:,0]
min_y, max_y = domain.get_mesh_bounding_box()[:,1]
min_z, max_z = domain.get_mesh_bounding_box()[:,2]
eps = 1e-8 * (max_x - min_x)
print min_x, max_x
print min_y, max_y
print min_z, max_z
R1 = domain.create_region('Ym',
'vertices in z < %.10f' % (max_z/2))
R2 = domain.create_region('Yf',
'vertices in z >= %.10f' % (min_z/2))
omega = domain.create_region('Omega', 'all')
gamma1 = domain.create_region('Left',
'vertices in x < %.10f' % (min_x + eps),
'facet')
gamma2 = domain.create_region('Right',
'vertices in x > %.10f' % (max_x - eps),
'facet')
gamma3 = domain.create_region('Front',
'vertices in y < %.10f' % (min_y + eps),
'facet')
gamma4 = domain.create_region('Back',
'vertices in y > %.10f' % (max_y - eps),
'facet')
gamma5 = domain.create_region('Bottom',
'vertices in z < %.10f' % (min_z + eps),
'facet')
gamma6 = domain.create_region('Top',
'vertices in z > %.10f' % (max_z - eps),
'facet')
field = Field.from_args('fu', nm.float64, 'vector', omega, approx_order=2)
u = FieldVariable('u', 'unknown', field)
v = FieldVariable('v', 'test', field, primary_var_name='u')
mu=1.1
lam=1.0
m = Material('m', lam=lam, mu=mu)
f = Material('f', val=[[0.0], [0.0],[0.0]])
#mu,lam=m.get_constants_mu_lam()
#print mu.lam
D = stiffness_from_lame(3,lam, mu)
mat = Material('Mat', D=D)
#D = stiffness_from_youngpoisson(2, options.young, options.poisson)
get_mat = Function('get_mat1',get_mat1)
#get_mat1=Function('get_mat', (lambda ts, coors, mode=None, problem=None, **kwargs:
# get_mat(coors, mode, problem)))
#mat = Material('Mat', function=Function('get_mat1',get_mat1))
#mat = Material('Mat', 'get_mat')
integral = Integral('i', order=3)
t1 = Term.new('dw_lin_elastic(Mat.D, v, u)',
integral, omega, Mat=mat, 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})
left_bc = EssentialBC('Left', gamma1, {'u.0' : 0.0})
right_bc = EssentialBC('Right', gamma2, {'u.0' : 0.0})
back_bc = EssentialBC('Front', gamma3, {'u.1' : 0.0})
front_bc = EssentialBC('Back', gamma4, {'u.1' : 0.0})
bottom_bc = EssentialBC('Bottom', gamma5, {'u.all' : 0.0})
top_bc = EssentialBC('Top', gamma6, {'u.2' : 0.2})
bc=[left_bc,right_bc,back_bc,front_bc,bottom_bc,top_bc]
#bc=[bottom_bc,top_bc]
bc_fun = Function('shift_u_fun', shift_u_fun, extra_args={'shift' : 0.01})
shift_u = EssentialBC('shift_u', gamma2, {'u.0' : bc_fun})
#get_mat = Function('get_mat1',get_mat1)
#mat = Material('Mat', function=Function('get_mat1',get_mat1))
#ls = ScipyDirect({'method':'umfpack'})
##############################
# ##### SOLVER SECTION #####
##############################
# GET MATRIX FOR PRECONTITIONER #
#ls = ScipyIterative({'method':'bicgstab','i_max':5000,'eps_r':1e-10})
#ls = ScipyIterative({})
#ls = PyAMGSolver({'i_max':5000,'eps_r':1e-10})
#conf = Struct(method='cg', precond='gamg', sub_precond=None,i_max=10000, eps_a=1e-50, eps_r=1e-5, eps_d=1e4, verbose=True)
#ls = PETScKrylovSolver({'method' : 'cg', 'precond' : 'icc', 'eps_r' : 1e-10, 'i_max' : 5000})
conf = Struct(method='bcgsl', precond='jacobi', sub_precond=None,
i_max=10000, eps_a=1e-50, eps_r=1e-10, eps_d=1e4,
verbose=True)
#conf = Struct(method = 'cg', precond = 'icc', eps_r = 1e-10, i_max = 5000)
ls = PETScKrylovSolver(conf)
#if hasattr(ls.name,'ls.scipy_iterative'):
file.write(str(ls.name)+' '+str(ls.conf.method)+' '+str(ls.conf.precond)+' '+str(ls.conf.eps_r)+' '+str(ls.conf.i_max)+'\n' )
# else:
#file.write(str(ls.name)+' '+str(ls.conf.method)+'\n')
# conf = Struct(method='bcgsl', precond='jacobi', sub_precond=None,
# i_max=10000, eps_a=1e-50, eps_r=1e-8, eps_d=1e4,
# verbose=True)
#ls = PETScKrylovSolver(conf)
#ls = ScipyIterative({'method':'bicgstab','i_max':100,'eps_r':1e-10})
nls_status = IndexedStruct()
nls = Newton({'i_max':1,'eps_a':1e-10}, lin_solver=ls, status=nls_status)
pb = Problem('elasticity', equations=eqs, nls=nls, ls=ls)
dd=pb.get_materials()['Mat']
dd.set_function(get_mat1)
pb.save_regions_as_groups('regions')
#pb.time_update(ebcs=Conditions([fix_u, shift_u]))
pb.time_update(ebcs=Conditions(bc))
pb.save_regions_as_groups('regions')
#ls = ScipyIterative({'method':'bicgstab','i_max':100,'eps_r':1e-10})
# A = pb.mtx_a
# M = spilu(A,fill_factor = 1)
#conf = Struct(solvers ='ScipyIterative',method='bcgsl', sub_precond=None,
# i_max=1000, eps_r=1e-8)
#pb.set_conf_solvers(conf)
vec = pb.solve()
print nls_status
file.write('TIME TO SOLVE\n')
file.write(str(nls.status.time_stats['solve'])+'\n')
file.write('TIME TO CREATE MATRIX\n')
file.write(str(nls.status.time_stats['matrix'])+'\n')
#out = post_process(out, pb, state, extend=False)
ev = pb.evaluate
out = vec.create_output_dict()
strain = ev('ev_cauchy_strain.3.Omega(u)', mode='el_avg')
stress = ev('ev_cauchy_stress.3.Omega(Mat.D, u)', mode='el_avg',
copy_materials=False)
out['cauchy_strain'] = Struct(name='output_data', mode='cell',
data=strain, dofs=None)
out['cauchy_stress'] = Struct(name='output_data', mode='cell',
data=stress, dofs=None)
# Postprocess the solution.
#out = vec.create_output_dict()
#out = stress_strain(out, pb, vec,lam,mu, extend=True)
#pb.save_state('its2D_interactive.vtk', out=out)
#print 'aqui estoy'
pb.save_state('strain.vtk', out=out)
#pb.save_state('disp.vtk', out=vec)
#print 'ahora estoy aqui'
#out = stress_strain(out, pb, vec, extend=True)
#pb.save_state('out.vtk', out=out)
print nls_status
order = 3
strain_qp = ev('ev_cauchy_strain.%d.Omega(u)' % order, mode='qp')
stress_qp = ev('ev_cauchy_stress.%d.Omega(Mat.D, u)' % order,
mode='qp', copy_materials=False)
file.close()
options_probe=False
if options_probe:
# Probe the solution.
probes, labels = gen_lines(pb)
nls_options = {'eps_a':1e-8,'i_max':1}
ls = ScipyDirect({})
ls2 = ScipyIterative({'method':'bicgstab','i_max':5000,'eps_r':1e-20})
order = 5
sfield = Field.from_args('sym_tensor', nm.float64, (3,), omega,
approx_order=order-1)
stress = FieldVariable('stress', 'parameter', sfield,
primary_var_name='(set-to-None)')
strain = FieldVariable('strain', 'parameter', sfield,
primary_var_name='(set-to-None)')
cfield = Field.from_args('component', nm.float64, 1, omega,
approx_order=order-1)
component = FieldVariable('component', 'parameter', cfield,
primary_var_name='(set-to-None)')
ev = pb.evaluate
order = 2*(order - 1) #2 * (2- 1)
print "before strain_qp"
strain_qp = ev('ev_cauchy_strain.%d.Omega(u)' % order, mode='qp')
stress_qp = ev('ev_cauchy_stress.%d.Omega(Mat.D, u)' % order,
mode='qp', copy_materials=False)
print "before projections"
print stress
project_by_component(strain, strain_qp, component, order,ls2,nls_options)
#print 'strain done'
project_by_component(stress, stress_qp, component, order,ls2,nls_options)
print "after projections"
all_results = []
for ii, probe in enumerate(probes):
fig, results = probe_results2(u, strain, stress, probe, labels[ii])
fig.savefig('test_probe_%d.png' % ii)
all_results.append(results)
for ii, results in enumerate(all_results):
output('probe %d:' % ii)
output.level += 2
for key, res in ordered_iteritems(results):
output(key + ':')
val = res[1]
output(' min: %+.2e, mean: %+.2e, max: %+.2e'
% (val.min(), val.mean(), val.max()))
output.level -= 2
def create_local_problem(omega_gi, orders):
"""
Local problem definition using a domain corresponding to the global region
`omega_gi`.
"""
order_u, order_p = orders
mesh = omega_gi.domain.mesh
# All tasks have the whole mesh.
bbox = mesh.get_bounding_box()
min_x, max_x = bbox[:, 0]
eps_x = 1e-8 * (max_x - min_x)
min_y, max_y = bbox[:, 1]
eps_y = 1e-8 * (max_y - min_y)
mesh_i = Mesh.from_region(omega_gi, mesh, localize=True)
domain_i = FEDomain("domain_i", mesh_i)
omega_i = domain_i.create_region("Omega", "all")
gamma1_i = domain_i.create_region("Gamma1", "vertices in (x < %.10f)" % (min_x + eps_x), "facet", allow_empty=True)
gamma2_i = domain_i.create_region("Gamma2", "vertices in (x > %.10f)" % (max_x - eps_x), "facet", allow_empty=True)
gamma3_i = domain_i.create_region("Gamma3", "vertices in (y < %.10f)" % (min_y + eps_y), "facet", allow_empty=True)
field1_i = Field.from_args("fu", nm.float64, mesh.dim, omega_i, approx_order=order_u)
field2_i = Field.from_args("fp", nm.float64, 1, omega_i, approx_order=order_p)
output("field 1: number of local DOFs:", field1_i.n_nod)
output("field 2: number of local DOFs:", field2_i.n_nod)
u_i = FieldVariable("u_i", "unknown", field1_i, order=0)
v_i = FieldVariable("v_i", "test", field1_i, primary_var_name="u_i")
p_i = FieldVariable("p_i", "unknown", field2_i, order=1)
q_i = FieldVariable("q_i", "test", field2_i, primary_var_name="p_i")
if mesh.dim == 2:
alpha = 1e2 * nm.array([[0.132], [0.132], [0.092]])
else:
alpha = 1e2 * nm.array([[0.132], [0.132], [0.132], [0.092], [0.092], [0.092]])
mat = Material("m", lam=10, mu=5, k=1, alpha=alpha)
integral = Integral("i", order=2 * (max(order_u, order_p)))
t11 = Term.new("dw_lin_elastic_iso(m.lam, m.mu, v_i, u_i)", integral, omega_i, m=mat, v_i=v_i, u_i=u_i)
t12 = Term.new("dw_biot(m.alpha, v_i, p_i)", integral, omega_i, m=mat, v_i=v_i, p_i=p_i)
t21 = Term.new("dw_biot(m.alpha, u_i, q_i)", integral, omega_i, m=mat, u_i=u_i, q_i=q_i)
t22 = Term.new("dw_laplace(m.k, q_i, p_i)", integral, omega_i, m=mat, q_i=q_i, p_i=p_i)
eq1 = Equation("eq1", t11 - t12)
eq2 = Equation("eq1", t21 + t22)
eqs = Equations([eq1, eq2])
ebc1 = EssentialBC("ebc1", gamma1_i, {"u_i.all": 0.0})
ebc2 = EssentialBC("ebc2", gamma2_i, {"u_i.0": 0.05})
def bc_fun(ts, coors, **kwargs):
val = 0.3 * nm.sin(4 * nm.pi * (coors[:, 0] - min_x) / (max_x - min_x))
return val
fun = Function("bc_fun", bc_fun)
ebc3 = EssentialBC("ebc3", gamma3_i, {"p_i.all": fun})
pb = Problem("problem_i", equations=eqs, active_only=False)
pb.time_update(ebcs=Conditions([ebc1, ebc2, ebc3]))
pb.update_materials()
return pb
def main():
from sfepy import data_dir
parser = ArgumentParser(description=__doc__,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('--version', action='version', version='%(prog)s')
parser.add_argument('--diffusivity',
metavar='float',
type=float,
action='store',
dest='diffusivity',
default=1e-5,
help=helps['diffusivity'])
parser.add_argument('--ic-max',
metavar='float',
type=float,
action='store',
dest='ic_max',
default=2.0,
help=helps['ic_max'])
parser.add_argument('--order',
metavar='int',
type=int,
action='store',
dest='order',
default=2,
help=helps['order'])
parser.add_argument('-r',
'--refine',
metavar='int',
type=int,
action='store',
dest='refine',
default=0,
help=helps['refine'])
parser.add_argument('-p',
'--probe',
action="store_true",
dest='probe',
default=False,
help=helps['probe'])
parser.add_argument('-s',
'--show',
action="store_true",
dest='show',
default=False,
help=helps['show'])
options = parser.parse_args()
assert_((0 < options.order),
'temperature approximation order must be at least 1!')
output('using values:')
output(' diffusivity:', options.diffusivity)
output(' max. IC value:', options.ic_max)
output('uniform mesh refinement level:', options.refine)
mesh = Mesh.from_file(data_dir + '/meshes/3d/cylinder.mesh')
domain = FEDomain('domain', mesh)
if options.refine > 0:
for ii in range(options.refine):
output('refine %d...' % ii)
domain = domain.refine()
output('... %d nodes %d elements' %
(domain.shape.n_nod, domain.shape.n_el))
omega = domain.create_region('Omega', 'all')
left = domain.create_region('Left', 'vertices in x < 0.00001', 'facet')
right = domain.create_region('Right', 'vertices in x > 0.099999', 'facet')
field = Field.from_args('fu',
nm.float64,
'scalar',
omega,
approx_order=options.order)
T = FieldVariable('T', 'unknown', field, history=1)
s = FieldVariable('s', 'test', field, primary_var_name='T')
m = Material('m', diffusivity=options.diffusivity * nm.eye(3))
integral = Integral('i', order=2 * options.order)
t1 = Term.new('dw_diffusion(m.diffusivity, s, T)',
integral,
omega,
m=m,
s=s,
T=T)
t2 = Term.new('dw_volume_dot(s, dT/dt)', integral, omega, s=s, T=T)
eq = Equation('balance', t1 + t2)
eqs = Equations([eq])
# Boundary conditions.
ebc1 = EssentialBC('T1', left, {'T.0': 2.0})
ebc2 = EssentialBC('T2', right, {'T.0': -2.0})
# Initial conditions.
def get_ic(coors, ic):
x, y, z = coors.T
return 2 - 40.0 * x + options.ic_max * nm.sin(4 * nm.pi * x / 0.1)
ic_fun = Function('ic_fun', get_ic)
ic = InitialCondition('ic', omega, {'T.0': ic_fun})
pb = Problem('heat', equations=eqs)
pb.set_bcs(ebcs=Conditions([ebc1, ebc2]))
pb.set_ics(Conditions([ic]))
state0 = pb.get_initial_state()
init_fun, prestep_fun, _poststep_fun = pb.get_tss_functions(state0)
ls = ScipyDirect({})
nls_status = IndexedStruct()
nls = Newton({'is_linear': True}, lin_solver=ls, status=nls_status)
tss = SimpleTimeSteppingSolver({
't0': 0.0,
't1': 100.0,
'n_step': 11
},
nls=nls,
context=pb,
verbose=True)
pb.set_solver(tss)
if options.probe:
# Prepare probe data.
probes, labels = gen_lines(pb)
ev = pb.evaluate
order = 2 * (options.order - 1)
gfield = Field.from_args('gu',
nm.float64,
'vector',
omega,
approx_order=options.order - 1)
dvel = FieldVariable('dvel',
'parameter',
gfield,
primary_var_name='(set-to-None)')
cfield = Field.from_args('gu',
nm.float64,
'scalar',
omega,
approx_order=options.order - 1)
component = FieldVariable('component',
'parameter',
cfield,
primary_var_name='(set-to-None)')
nls_options = {'eps_a': 1e-16, 'i_max': 1}
if options.show:
plt.ion()
suffix = tss.ts.suffix
def poststep_fun(ts, vec):
_poststep_fun(ts, vec)
# Probe the solution.
dvel_qp = ev('ev_diffusion_velocity.%d.Omega(m.diffusivity, T)' %
order,
copy_materials=False,
mode='qp')
project_by_component(dvel,
dvel_qp,
component,
order,
nls_options=nls_options)
all_results = []
for ii, probe in enumerate(probes):
fig, results = probe_results(ii, T, dvel, probe, labels[ii])
all_results.append(results)
plt.tight_layout()
fig.savefig('time_poisson_interactive_probe_%s.png' %
(suffix % ts.step),
bbox_inches='tight')
if options.show:
plt.draw()
for ii, results in enumerate(all_results):
output('probe %d (%s):' % (ii, probes[ii].name))
output.level += 2
for key, res in ordered_iteritems(results):
output(key + ':')
val = res[1]
output(' min: %+.2e, mean: %+.2e, max: %+.2e' %
(val.min(), val.mean(), val.max()))
output.level -= 2
else:
poststep_fun = _poststep_fun
pb.time_update(tss.ts)
state0.apply_ebc()
# This is required if {'is_linear' : True} is passed to Newton.
mtx = prepare_matrix(pb, state0)
pb.try_presolve(mtx)
tss_status = IndexedStruct()
tss(state0.get_vec(pb.active_only),
init_fun=init_fun,
prestep_fun=prestep_fun,
poststep_fun=poststep_fun,
status=tss_status)
output(tss_status)
def create_local_problem(omega_gi, orders):
"""
Local problem definition using a domain corresponding to the global region
`omega_gi`.
"""
order_u, order_p = orders
mesh = omega_gi.domain.mesh
# All tasks have the whole mesh.
bbox = mesh.get_bounding_box()
min_x, max_x = bbox[:, 0]
eps_x = 1e-8 * (max_x - min_x)
min_y, max_y = bbox[:, 1]
eps_y = 1e-8 * (max_y - min_y)
mesh_i = Mesh.from_region(omega_gi, mesh, localize=True)
domain_i = FEDomain('domain_i', mesh_i)
omega_i = domain_i.create_region('Omega', 'all')
gamma1_i = domain_i.create_region('Gamma1',
'vertices in (x < %.10f)'
% (min_x + eps_x),
'facet', allow_empty=True)
gamma2_i = domain_i.create_region('Gamma2',
'vertices in (x > %.10f)'
% (max_x - eps_x),
'facet', allow_empty=True)
gamma3_i = domain_i.create_region('Gamma3',
'vertices in (y < %.10f)'
% (min_y + eps_y),
'facet', allow_empty=True)
field1_i = Field.from_args('fu', nm.float64, mesh.dim, omega_i,
approx_order=order_u)
field2_i = Field.from_args('fp', nm.float64, 1, omega_i,
approx_order=order_p)
output('field 1: number of local DOFs:', field1_i.n_nod)
output('field 2: number of local DOFs:', field2_i.n_nod)
u_i = FieldVariable('u_i', 'unknown', field1_i, order=0)
v_i = FieldVariable('v_i', 'test', field1_i, primary_var_name='u_i')
p_i = FieldVariable('p_i', 'unknown', field2_i, order=1)
q_i = FieldVariable('q_i', 'test', field2_i, primary_var_name='p_i')
if mesh.dim == 2:
alpha = 1e2 * nm.array([[0.132], [0.132], [0.092]])
else:
alpha = 1e2 * nm.array([[0.132], [0.132], [0.132],
[0.092], [0.092], [0.092]])
mat = Material('m', D=stiffness_from_lame(mesh.dim, lam=10, mu=5),
k=1, alpha=alpha)
integral = Integral('i', order=2*(max(order_u, order_p)))
t11 = Term.new('dw_lin_elastic(m.D, v_i, u_i)',
integral, omega_i, m=mat, v_i=v_i, u_i=u_i)
t12 = Term.new('dw_biot(m.alpha, v_i, p_i)',
integral, omega_i, m=mat, v_i=v_i, p_i=p_i)
t21 = Term.new('dw_biot(m.alpha, u_i, q_i)',
integral, omega_i, m=mat, u_i=u_i, q_i=q_i)
t22 = Term.new('dw_laplace(m.k, q_i, p_i)',
integral, omega_i, m=mat, q_i=q_i, p_i=p_i)
eq1 = Equation('eq1', t11 - t12)
eq2 = Equation('eq1', t21 + t22)
eqs = Equations([eq1, eq2])
ebc1 = EssentialBC('ebc1', gamma1_i, {'u_i.all' : 0.0})
ebc2 = EssentialBC('ebc2', gamma2_i, {'u_i.0' : 0.05})
def bc_fun(ts, coors, **kwargs):
val = 0.3 * nm.sin(4 * nm.pi * (coors[:, 0] - min_x) / (max_x - min_x))
return val
fun = Function('bc_fun', bc_fun)
ebc3 = EssentialBC('ebc3', gamma3_i, {'p_i.all' : fun})
pb = Problem('problem_i', equations=eqs, active_only=False)
pb.time_update(ebcs=Conditions([ebc1, ebc2, ebc3]))
pb.update_materials()
return pb
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()
options_probe = True
folder = str(uuid.uuid4())
os.mkdir(folder)
os.chdir(folder)
file = open('README.txt', 'w')
file.write('DIMENSIONS\n')
file.write('Lx = '+str(dims[0])+' Ly = '+str(dims[1])+' Lz = '+str(dims[2])+'\n')
file.write('DISCRETIZATION (NX, NY, NZ)\n')
file.write(str(NX)+' '+str(NY)+' '+str(NZ)+'\n')
file.write('MATERIALS\n')
file.write(str(E_f)+' '+str(nu_f)+' '+str(E_m)+' '+str(nu_m)+'\n')
#mesh = Mesh.from_file(data_dir + '/meshes/2d/rectangle_tri.mesh')
mesh = mesh_generators.gen_block_mesh(dims,shape,centre,name='block')
domain = FEDomain('domain', mesh)
min_x, max_x = domain.get_mesh_bounding_box()[:,0]
min_y, max_y = domain.get_mesh_bounding_box()[:,1]
min_z, max_z = domain.get_mesh_bounding_box()[:,2]
eps = 1e-8 * (max_x - min_x)
print min_x, max_x
print min_y, max_y
print min_z, max_z
R1 = domain.create_region('Ym',
'vertices in z < %.10f' % (max_z/2))
R2 = domain.create_region('Yf',
'vertices in z >= %.10f' % (min_z/2))
omega = domain.create_region('Omega', 'all')
gamma1 = domain.create_region('Left',
'vertices in x < %.10f' % (min_x + eps),
'facet')
gamma2 = domain.create_region('Right',
'vertices in x > %.10f' % (max_x - eps),
'facet')
gamma3 = domain.create_region('Front',
'vertices in y < %.10f' % (min_y + eps),
'facet')
gamma4 = domain.create_region('Back',
'vertices in y > %.10f' % (max_y - eps),
'facet')
gamma5 = domain.create_region('Bottom',
'vertices in z < %.10f' % (min_z + eps),
'facet')
gamma6 = domain.create_region('Top',
'vertices in z > %.10f' % (max_z - eps),
'facet')
field = Field.from_args('fu', nm.float64, 'vector', omega, approx_order=2)
u = FieldVariable('u', 'unknown', field)
v = FieldVariable('v', 'test', field, primary_var_name='u')
mu=1.1
lam=1.0
m = Material('m', lam=lam, mu=mu)
f = Material('f', val=[[0.0], [0.0],[-1.0]])
load = Material('Load',val=[[0.0],[0.0],[-Load]])
D = stiffness_from_lame(3,lam, mu)
mat = Material('Mat', D=D)
get_mat = Function('get_mat1',get_mat1)
get_mat_f = Function('get_mat_f',get_mat1)
integral = Integral('i', order=3)
s_integral = Integral('is',order=2)
t1 = Term.new('dw_lin_elastic(Mat.D, v, u)',
integral, omega, Mat=mat, v=v, u=u)
t2 = Term.new('dw_volume_lvf(f.val, v)', integral, omega, f=f, v=v)
#t3 = Term.new('DotProductSurfaceTerm(Load.val, v)',s_integral,gamma5,Load=load,v=v)
t3 = Term.new('dw_surface_ltr( Load.val, v )',s_integral,gamma6,Load=load,v=v)
eq = Equation('balance', t1 + t2 + t3)
eqs = Equations([eq])
fix_u = EssentialBC('fix_u', gamma1, {'u.all' : 0.0})
left_bc = EssentialBC('Left', gamma1, {'u.0' : 0.0})
right_bc = EssentialBC('Right', gamma2, {'u.0' : 0.0})
back_bc = EssentialBC('Front', gamma3, {'u.1' : 0.0})
front_bc = EssentialBC('Back', gamma4, {'u.1' : 0.0})
bottom_bc = EssentialBC('Bottom', gamma5, {'u.all' : 0.0})
top_bc = EssentialBC('Top', gamma6, {'u.2' : 0.2})
bc=[left_bc,right_bc,back_bc,front_bc,bottom_bc]
#bc=[bottom_bc,top_bc]
##############################
# ##### SOLVER SECTION #####
##############################
conf = Struct(method='bcgsl', precond='jacobi', sub_precond=None,
i_max=10000, eps_a=1e-50, eps_r=1e-10, eps_d=1e4,
verbose=True)
ls = PETScKrylovSolver(conf)
file.write(str(ls.name)+' '+str(ls.conf.method)+' '+str(ls.conf.precond)+' '+str(ls.conf.eps_r)+' '+str(ls.conf.i_max)+'\n' )
nls_status = IndexedStruct()
nls = Newton({'i_max':1,'eps_a':1e-10}, lin_solver=ls, status=nls_status)
pb = Problem('elasticity', equations=eqs, nls=nls, ls=ls)
dd=pb.get_materials()['Mat']
dd.set_function(get_mat1)
#xload = pb.get_materials()['f']
#xload.set_function(get_mat_f)
pb.save_regions_as_groups('regions')
pb.time_update(ebcs=Conditions(bc))
vec = pb.solve()
print nls_status
file.write('TIME TO SOLVE\n')
file.write(str(nls.status.time_stats['solve'])+'\n')
file.write('TIME TO CREATE MATRIX\n')
file.write(str(nls.status.time_stats['matrix'])+'\n')
ev = pb.evaluate
out = vec.create_output_dict()
strain = ev('ev_cauchy_strain.3.Omega(u)', mode='el_avg')
stress = ev('ev_cauchy_stress.3.Omega(Mat.D, u)', mode='el_avg',
copy_materials=False)
out['cauchy_strain'] = Struct(name='output_data', mode='cell',
data=strain, dofs=None)
out['cauchy_stress'] = Struct(name='output_data', mode='cell',
data=stress, dofs=None)
pb.save_state('strain.vtk', out=out)
print nls_status
file.close()
def make_l2_projection_data(target, eval_data, order=None,
ls=None, nls_options=None):
"""
Project scalar data to a scalar `target` field variable using the
:math:`L^2` dot product.
Parameters
----------
target : FieldVariable instance
The target variable.
eval_data : callable or array
Either a material-like function `eval_data()`, or an array of values in
quadrature points that has to be reshapable to the shape required by
`order`.
order : int, optional
The quadrature order. If not given, it is set to
`2 * target.field.approx_order`.
"""
if order is None:
order = 2 * target.field.approx_order
integral = Integral('i', order=order)
un = FieldVariable('u', 'unknown', target.field)
v = FieldVariable('v', 'test', un.field, primary_var_name=un.name)
lhs = Term.new('dw_volume_dot(v, %s)' % un.name, integral,
un.field.region, v=v, **{un.name : un})
def _eval_data(ts, coors, mode, **kwargs):
if mode == 'qp':
if callable(eval_data):
val = eval_data(ts, coors, mode, **kwargs)
else:
val = eval_data.reshape((coors.shape[0], 1, 1))
return {'val' : val}
m = Material('m', function=_eval_data)
rhs = Term.new('dw_volume_lvf(m.val, v)', integral, un.field.region,
m=m, v=v)
eq = Equation('projection', lhs - rhs)
eqs = Equations([eq])
if ls is None:
ls = ScipyDirect({})
if nls_options is None:
nls_options = {}
nls_status = IndexedStruct()
nls = Newton(nls_options, lin_solver=ls, status=nls_status)
pb = Problem('aux', equations=eqs, nls=nls, ls=ls)
pb.time_update()
# This sets the un variable with the projection solution.
pb.solve()
# Copy the projection solution to target.
target.set_data(un())
if nls_status.condition != 0:
output('L2 projection: solver did not converge!')
bc2 = EssentialBC('Gamma_Right', gammaR, {'t.0': set_bc_fun})
bc3 = EssentialBC('Gamma_Top', gammaT, {'t.0': set_bc_fun})
bc4 = EssentialBC('Gamma_Bottom', gammaB, {'t.0': set_bc_fun})
ls = ScipyDirect({})
nls_status = IndexedStruct()
newtonConfig = {'i_max': 10, 'eps_a': 1e-10, 'eps_r': 1}
nls = Newton(newtonConfig, lin_solver=ls, status=nls_status)
pb = Problem('Poisson', equations=eqs, nls=nls, ls=ls)
pb.save_regions_as_groups('regions')
# pb.time_update(ebcs=Conditions([fix_u, t1, t2]))
pb.time_update(ebcs=Conditions([bc1, bc2, bc3, bc4]))
vec = pb.solve()
print nls_status
pb.save_state('customCylinder.vtk', vec)
# if options.show:
# view = Viewer('customCylinder.vtk')
# view(vector_mode='warp_norm', rel_scaling=2,
# is_scalar_bar=True, is_wireframe=True)
solutionData = vec.vec.reshape(100, 100)
xGrid = mesh.coors[:, 0].reshape(100, 100)
yGrid = mesh.coors[:, 1].reshape(100, 100)
analyticSolution = np.sin(xGrid / np.pi) * np.sin(yGrid / np.pi)
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 = FEDomain('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',
'vertices in x < %.10f' % (min_x + eps),
'facet')
gamma2 = domain.create_region('Gamma2',
'vertices in x > %.10f' % (max_x - eps),
'facet')
field = Field.from_args('fu', nm.float64, 'vector', omega, approx_order=2)
u = FieldVariable('u', 'unknown', field)
v = FieldVariable('v', 'test', field, primary_var_name='u')
m = Material('m', D=stiffness_from_lame(dim=2, 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(m.D, 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 = Problem('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 main():
parser = ArgumentParser(description=__doc__,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('--version', action='version', version='%(prog)s')
parser.add_argument('-d',
'--dims',
metavar='dims',
action='store',
dest='dims',
default='[1.0, 1.0]',
help=helps['dims'])
parser.add_argument('-c',
'--centre',
metavar='centre',
action='store',
dest='centre',
default='[0.0, 0.0]',
help=helps['centre'])
parser.add_argument('-s',
'--shape',
metavar='shape',
action='store',
dest='shape',
default='[11, 11]',
help=helps['shape'])
parser.add_argument('-b',
'--bc-kind',
metavar='kind',
action='store',
dest='bc_kind',
choices=['free', 'cantilever', 'fixed'],
default='free',
help=helps['bc_kind'])
parser.add_argument('-a',
'--axis',
metavar='0, ..., dim, or -1',
type=int,
action='store',
dest='axis',
default=-1,
help=helps['axis'])
parser.add_argument('--young',
metavar='float',
type=float,
action='store',
dest='young',
default=200e+9,
help=helps['young'])
parser.add_argument('--poisson',
metavar='float',
type=float,
action='store',
dest='poisson',
default=0.3,
help=helps['poisson'])
parser.add_argument('--density',
metavar='float',
type=float,
action='store',
dest='density',
default=7800.0,
help=helps['density'])
parser.add_argument('--order',
metavar='int',
type=int,
action='store',
dest='order',
default=1,
help=helps['order'])
parser.add_argument('-n',
'--n-eigs',
metavar='int',
type=int,
action='store',
dest='n_eigs',
default=6,
help=helps['n_eigs'])
parser.add_argument('-i',
'--ignore',
metavar='int',
type=int,
action='store',
dest='ignore',
default=None,
help=helps['ignore'])
parser.add_argument('--solver', metavar='solver', action='store',
dest='solver',
default= \
"eig.scipy,method:'eigh',tol:1e-5,maxiter:1000",
help=helps['solver'])
parser.add_argument('--show',
action="store_true",
dest='show',
default=False,
help=helps['show'])
#parser.add_argument('filename', nargs='?', default=None)
#read block.mesh
#parser.add_argument('filename', nargs='?', default="platehexat200mm.mesh")
parser.add_argument('filename', nargs='?', default="block_1m.mesh")
options = parser.parse_args()
aux = options.solver.split(',')
kwargs = {}
for option in aux[1:]:
key, val = option.split(':')
kwargs[key.strip()] = eval(val)
eig_conf = Struct(name='evp', kind=aux[0], **kwargs)
output('using values:')
output(" Young's modulus:", options.young)
output(" Poisson's ratio:", options.poisson)
output(' density:', options.density)
output('displacement field approximation order:', options.order)
output('requested %d eigenvalues' % options.n_eigs)
output('using eigenvalue problem solver:', eig_conf.kind)
output.level += 1
for key, val in six.iteritems(kwargs):
output('%s: %r' % (key, val))
output.level -= 1
assert_((0.0 < options.poisson < 0.5),
"Poisson's ratio must be in ]0, 0.5[!")
assert_((0 < options.order),
'displacement approximation order must be at least 1!')
filename = options.filename
if filename is not None:
mesh = Mesh.from_file(filename)
dim = mesh.dim
dims = nm.diff(mesh.get_bounding_box(), axis=0)
else:
dims = nm.array(eval(options.dims), dtype=nm.float64)
dim = len(dims)
centre = nm.array(eval(options.centre), dtype=nm.float64)[:dim]
shape = nm.array(eval(options.shape), dtype=nm.int32)[:dim]
output('dimensions:', dims)
output('centre: ', centre)
output('shape: ', shape)
mesh = gen_block_mesh(dims, shape, centre, name='mesh')
output('axis: ', options.axis)
assert_((-dim <= options.axis < dim), 'invalid axis value!')
eig_solver = Solver.any_from_conf(eig_conf)
# Build the problem definition.
domain = FEDomain('domain', mesh)
bbox = domain.get_mesh_bounding_box()
min_coor, max_coor = bbox[:, options.axis]
eps = 1e-8 * (max_coor - min_coor)
ax = 'xyz'[:dim][options.axis]
omega = domain.create_region('Omega', 'all')
"""
bottom = domain.create_region('Bottom',
'vertices in (%s < %.10f)'
% (ax, min_coor + eps),
'facet')
bottom_top = domain.create_region('BottomTop',
'r.Bottom +v vertices in (%s > %.10f)'
% (ax, max_coor - eps),
'facet')
"""
#import pdb; pdb.set_trace()
left = domain.create_region('left', 'vertices in (x < -0.49)', 'facet')
field = Field.from_args('fu',
nm.float64,
'vector',
omega,
approx_order=options.order)
u = FieldVariable('u', 'unknown', field)
v = FieldVariable('v', 'test', field, primary_var_name='u')
mtx_d = stiffness_from_youngpoisson(dim, options.young, options.poisson)
m = Material('m', D=mtx_d, rho=options.density)
integral = Integral('i', order=2 * options.order)
t1 = Term.new('dw_lin_elastic(m.D, v, u)', integral, omega, m=m, v=v, u=u)
t2 = Term.new('dw_volume_dot(m.rho, v, u)', integral, omega, m=m, v=v, u=u)
eq1 = Equation('stiffness', t1)
eq2 = Equation('mass', t2)
lhs_eqs = Equations([eq1, eq2])
pb = Problem('modal', equations=lhs_eqs)
"""
if options.bc_kind == 'free':
pb.time_update()
n_rbm = dim * (dim + 1) // 2
elif options.bc_kind == 'cantilever':
fixed = EssentialBC('Fixed', bottom, {'u.all' : 0.0})
pb.time_update(ebcs=Conditions([fixed]))
n_rbm = 0
elif options.bc_kind == 'fixed':
fixed = EssentialBC('Fixed', bottom_top, {'u.all' : 0.0})
pb.time_update(ebcs=Conditions([fixed]))
n_rbm = 0
else:
raise ValueError('unsupported BC kind! (%s)' % options.bc_kind)
if options.ignore is not None:
n_rbm = options.ignore
"""
fixed = EssentialBC('Fixed', left, {'u.all': 0.0})
pb.time_update(ebcs=Conditions([fixed]))
n_rbm = 0
pb.update_materials()
# Assemble stiffness and mass matrices.
mtx_k = eq1.evaluate(mode='weak', dw_mode='matrix', asm_obj=pb.mtx_a)
mtx_m = mtx_k.copy()
mtx_m.data[:] = 0.0
mtx_m = eq2.evaluate(mode='weak', dw_mode='matrix', asm_obj=mtx_m)
try:
eigs, svecs = eig_solver(mtx_k,
mtx_m,
options.n_eigs + n_rbm,
eigenvectors=True)
except sla.ArpackNoConvergence as ee:
eigs = ee.eigenvalues
svecs = ee.eigenvectors
output('only %d eigenvalues converged!' % len(eigs))
output('%d eigenvalues converged (%d ignored as rigid body modes)' %
(len(eigs), n_rbm))
eigs = eigs[n_rbm:]
svecs = svecs[:, n_rbm:]
omegas = nm.sqrt(eigs)
freqs = omegas / (2 * nm.pi)
output('number | eigenvalue | angular frequency '
'| frequency')
for ii, eig in enumerate(eigs):
output('%6d | %17.12e | %17.12e | %17.12e' %
(ii + 1, eig, omegas[ii], freqs[ii]))
# Make full eigenvectors (add DOFs fixed by boundary conditions).
variables = pb.get_variables()
vecs = nm.empty((variables.di.ptr[-1], svecs.shape[1]), dtype=nm.float64)
for ii in range(svecs.shape[1]):
vecs[:, ii] = variables.make_full_vec(svecs[:, ii])
# Save the eigenvectors.
out = {}
state = pb.create_state()
for ii in range(eigs.shape[0]):
state.set_full(vecs[:, ii])
aux = state.create_output_dict()
strain = pb.evaluate('ev_cauchy_strain.i.Omega(u)',
integrals=Integrals([integral]),
mode='el_avg',
verbose=False)
out['u%03d' % ii] = aux.popitem()[1]
out['strain%03d' % ii] = Struct(mode='cell', data=strain)
pb.save_state('eigenshapes.vtk', out=out)
pb.save_regions_as_groups('regions')
if len(eigs) and options.show:
# Show the solution. If the approximation order is greater than 1, the
# extra DOFs are simply thrown away.
from sfepy.postprocess.viewer import Viewer
from sfepy.postprocess.domain_specific import DomainSpecificPlot
scaling = 0.05 * dims.max() / nm.abs(vecs).max()
ds = {}
for ii in range(eigs.shape[0]):
pd = DomainSpecificPlot('plot_displacements', [
'rel_scaling=%s' % scaling, 'color_kind="tensors"',
'color_name="strain%03d"' % ii
])
ds['u%03d' % ii] = pd
view = Viewer('eigenshapes.vtk')
view(domain_specific=ds,
only_names=sorted(ds.keys()),
is_scalar_bar=False,
is_wireframe=True)
Ks = []
Ms = []
for D in [Ddmu, Ddlambda]:#, D2, D3]
m = Material('m', D = D, rho = 2700.0)
integral = Integral('i', order=2)
t1 = Term.new('dw_lin_elastic(m.D, v, u)', integral, omega, m=m, v=v, u=u)
t2 = Term.new('dw_volume_dot(m.rho, v, u)', integral, omega, m=m, v=v, u=u)
eq1 = Equation('stiffness', t1)
eq2 = Equation('mass', t2)
lhs_eqs = Equations([eq1, eq2])
pb = Problem('modal', equations = lhs_eqs)
pb.time_update()
n_rbm = dim * (dim + 1) / 2
pb.update_materials()
# Assemble stiffness and mass matrices.
mtx_k = eq1.evaluate(mode='weak', dw_mode='matrix', asm_obj=pb.mtx_a)
mtx_m = mtx_k.copy()
mtx_m.data[:] = 0.0
mtx_m = eq2.evaluate(mode='weak', dw_mode='matrix', asm_obj=mtx_m)
Ks.append(mtx_k)
Ms.append(mtx_m)
dKdmu = Ks[0]# (Ks[1] - Ks[0]) / (mu1 - mu0)
dKdlambda = Ks[1]# (Ks[3] - Ks[2]) / (lambda1 - lambda0)
def main():
parser = OptionParser(usage=usage, version='%prog')
parser.add_option('-d',
'--dims',
metavar='dims',
action='store',
dest='dims',
default='[1.0, 1.0]',
help=helps['dims'])
parser.add_option('-c',
'--centre',
metavar='centre',
action='store',
dest='centre',
default='[0.0, 0.0]',
help=helps['centre'])
parser.add_option('-s',
'--shape',
metavar='shape',
action='store',
dest='shape',
default='[11, 11]',
help=helps['shape'])
parser.add_option('-b',
'--bc-kind',
metavar='kind',
action='store',
dest='bc_kind',
choices=['free', 'clamped'],
default='free',
help=helps['bc_kind'])
parser.add_option('--young',
metavar='float',
type=float,
action='store',
dest='young',
default=6.80e+10,
help=helps['young'])
parser.add_option('--poisson',
metavar='float',
type=float,
action='store',
dest='poisson',
default=0.36,
help=helps['poisson'])
parser.add_option('--density',
metavar='float',
type=float,
action='store',
dest='density',
default=2700.0,
help=helps['density'])
parser.add_option('--order',
metavar='int',
type=int,
action='store',
dest='order',
default=1,
help=helps['order'])
parser.add_option('-n',
'--n-eigs',
metavar='int',
type=int,
action='store',
dest='n_eigs',
default=6,
help=helps['order'])
parser.add_option('',
'--show',
action="store_true",
dest='show',
default=False,
help=helps['show'])
options, args = parser.parse_args()
assert_((0.0 < options.poisson < 0.5),
"Poisson's ratio must be in ]0, 0.5[!")
assert_((0 < options.order),
'displacement approximation order must be at least 1!')
dims = nm.array(eval(options.dims), dtype=nm.float64)
dim = len(dims)
centre = nm.array(eval(options.centre), dtype=nm.float64)[:dim]
shape = nm.array(eval(options.shape), dtype=nm.int32)[:dim]
output('dimensions:', dims)
output('centre: ', centre)
output('shape: ', shape)
output('using values:')
output(" Young's modulus:", options.young)
output(" Poisson's ratio:", options.poisson)
output(' density:', options.density)
# Build the problem definition.
mesh = gen_block_mesh(dims, shape, centre, name='mesh')
domain = FEDomain('domain', mesh)
bbox = domain.get_mesh_bounding_box()
min_y, max_y = bbox[:, 1]
eps = 1e-8 * (max_y - min_y)
omega = domain.create_region('Omega', 'all')
bottom = domain.create_region('Bottom',
'vertices in (y < %.10f)' % (min_y + eps),
'facet')
field = Field.from_args('fu',
nm.float64,
'vector',
omega,
approx_order=options.order)
u = FieldVariable('u', 'unknown', field)
v = FieldVariable('v', 'test', field, primary_var_name='u')
mtx_d = stiffness_from_youngpoisson(dim, options.young, options.poisson)
m = Material('m', D=mtx_d, rho=options.density)
integral = Integral('i', order=2 * options.order)
t1 = Term.new('dw_lin_elastic(m.D, v, u)', integral, omega, m=m, v=v, u=u)
t2 = Term.new('dw_volume_dot(m.rho, v, u)', integral, omega, m=m, v=v, u=u)
eq1 = Equation('stiffness', t1)
eq2 = Equation('mass', t2)
lhs_eqs = Equations([eq1, eq2])
pb = Problem('modal', equations=lhs_eqs)
if options.bc_kind == 'free':
pb.time_update()
n_rbm = dim * (dim + 1) / 2
else:
fixed_b = EssentialBC('FixedB', bottom, {'u.all': 0.0})
pb.time_update(ebcs=Conditions([fixed_b]))
n_rbm = 0
pb.update_materials()
# Assemble stiffness and mass matrices.
mtx_k = eq1.evaluate(mode='weak', dw_mode='matrix', asm_obj=pb.mtx_a)
mtx_m = mtx_k.copy()
mtx_m.data[:] = 0.0
mtx_m = eq2.evaluate(mode='weak', dw_mode='matrix', asm_obj=mtx_m)
try:
eigs, svecs = sla.eigsh(mtx_k,
k=options.n_eigs + n_rbm,
M=mtx_m,
which='SM',
tol=1e-5,
maxiter=10000)
except sla.ArpackNoConvergence as ee:
eigs = ee.eigenvalues
svecs = ee.eigenvectors
output('only %d eigenvalues converged!' % len(eigs))
eigs = eigs[n_rbm:]
svecs = svecs[:, n_rbm:]
output('eigenvalues:', eigs)
output('eigen-frequencies:', nm.sqrt(eigs))
# Make full eigenvectors (add DOFs fixed by boundary conditions).
variables = pb.get_variables()
vecs = nm.empty((variables.di.ptr[-1], svecs.shape[1]), dtype=nm.float64)
for ii in xrange(svecs.shape[1]):
vecs[:, ii] = variables.make_full_vec(svecs[:, ii])
# Save the eigenvectors.
out = {}
state = pb.create_state()
for ii in xrange(eigs.shape[0]):
state.set_full(vecs[:, ii])
aux = state.create_output_dict()
strain = pb.evaluate('ev_cauchy_strain.i.Omega(u)',
integrals=Integrals([integral]),
mode='el_avg',
verbose=False)
out['u%03d' % ii] = aux.popitem()[1]
out['strain%03d' % ii] = Struct(mode='cell', data=strain)
pb.save_state('eigenshapes.vtk', out=out)
pb.save_regions_as_groups('regions')
if options.show:
# Show the solution. If the approximation order is greater than 1, the
# extra DOFs are simply thrown away.
from sfepy.postprocess.viewer import Viewer
from sfepy.postprocess.domain_specific import DomainSpecificPlot
scaling = 0.05 * dims.max() / nm.abs(vecs).max()
ds = {}
for ii in xrange(eigs.shape[0]):
pd = DomainSpecificPlot('plot_displacements', [
'rel_scaling=%s' % scaling, 'color_kind="tensors"',
'color_name="strain%03d"' % ii
])
ds['u%03d' % ii] = pd
view = Viewer('eigenshapes.vtk')
view(domain_specific=ds,
only_names=sorted(ds.keys()),
is_scalar_bar=False,
is_wireframe=True)
