def one_simulation(material_type,
define_args,
coef_tension=0.25,
coef_compression=-0.25,
plot_mesh_bool=False,
return_load=False):
#parser = ArgumentParser(description=__doc__,
# formatter_class=RawDescriptionHelpFormatter)
#parser.add_argument('--version', action='version', version='%(prog)s')
#options = parser.parse_args()
output.set_output(filename='sfepy_log.txt', quiet=True)
required, other = get_standard_keywords()
# Use this file as the input file.
conf = ProblemConf.from_file(__file__,
required,
other,
define_args=define_args)
# Create problem instance, but do not set equations.
problem = Problem.from_conf(conf, init_equations=False)
if plot_mesh_bool:
plot_mesh(problem)
# Solve the problem. Output is ignored, results stored by using the
# step_hook.
linear_tension = partial(linear_pressure, coef=coef_tension)
u_t = solve_branch(problem, linear_tension, material_type)
linear_compression = partial(linear_pressure, coef=coef_compression)
u_c = solve_branch(problem, linear_compression, material_type)
# Get pressure load by calling linear_*() for each time step.
ts = problem.get_timestepper()
load_t = np.array([
linear_tension(ts, np.array([[0.0]]), 'qp')['val']
for aux in ts.iter_from(0)
],
dtype=np.float64).squeeze()
load_c = np.array([
linear_compression(ts, np.array([[0.0]]), 'qp')['val']
for aux in ts.iter_from(0)
],
dtype=np.float64).squeeze()
# Join the branches.
displacements = np.r_[u_c[::-1], u_t]
load = np.r_[load_c[::-1], load_t]
if return_load:
return displacements, load
else:
return displacements
def create_app(filename, is_homog=False, **kwargs):
from sfepy.base.conf import ProblemConf, get_standard_keywords
from sfepy.homogenization.homogen_app import HomogenizationApp
from sfepy.applications import PDESolverApp
required, other = get_standard_keywords()
if is_homog:
required.remove('equations')
conf = ProblemConf.from_file(filename,
required,
other,
define_args=kwargs)
options = Struct(
output_filename_trunk=None,
save_ebc=False,
save_ebc_nodes=False,
save_regions=False,
save_regions_as_groups=False,
save_field_meshes=False,
solve_not=False,
)
output.set_output(filename='sfepy_log.txt', quiet=True)
if is_homog:
app = HomogenizationApp(conf, options, 'material_opt_micro:')
else:
app = PDESolverApp(conf, options, 'material_opt_macro:')
app.conf.opt_data = {}
opts = conf.options
if hasattr(opts, 'parametric_hook'): # Parametric study.
parametric_hook = conf.get_function(opts.parametric_hook)
app.parametrize(parametric_hook)
return app
def main():
# Aluminium and epoxy.
default_pars = '70e9,0.35,2.799e3, 3.8e9,0.27,1.142e3'
default_solver_conf = ("kind='eig.scipy',method='eigh',tol=1.0e-5,"
"maxiter=1000,which='LM',sigma=0.0")
parser = ArgumentParser(description=__doc__,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('--pars',
metavar='young1,poisson1,density1'
',young2,poisson2,density2',
action='store',
dest='pars',
default=default_pars,
help=helps['pars'])
parser.add_argument('--conf',
metavar='filename',
action='store',
dest='conf',
default=None,
help=helps['conf'])
parser.add_argument('--mesh-size',
type=float,
metavar='float',
action='store',
dest='mesh_size',
default=None,
help=helps['mesh_size'])
parser.add_argument('--unit-multipliers',
metavar='c_time,c_length,c_mass',
action='store',
dest='unit_multipliers',
default='1.0,1.0,1.0',
help=helps['unit_multipliers'])
parser.add_argument('--plane',
action='store',
dest='plane',
choices=['strain', 'stress'],
default='strain',
help=helps['plane'])
parser.add_argument('--wave-dir',
metavar='float,float[,float]',
action='store',
dest='wave_dir',
default='1.0,0.0,0.0',
help=helps['wave_dir'])
parser.add_argument('--mode',
action='store',
dest='mode',
choices=['omega', 'kappa'],
default='omega',
help=helps['mode'])
parser.add_argument('--range',
metavar='start,stop,count',
action='store',
dest='range',
default='10,100,10',
help=helps['range'])
parser.add_argument('--order',
metavar='int',
type=int,
action='store',
dest='order',
default=1,
help=helps['order'])
parser.add_argument('--refine',
metavar='int',
type=int,
action='store',
dest='refine',
default=0,
help=helps['refine'])
parser.add_argument('-n',
'--n-eigs',
metavar='int',
type=int,
action='store',
dest='n_eigs',
default=6,
help=helps['n_eigs'])
parser.add_argument('--eigs-only',
action='store_true',
dest='eigs_only',
default=False,
help=helps['eigs_only'])
parser.add_argument('--solver-conf',
metavar='dict-like',
action='store',
dest='solver_conf',
default=default_solver_conf,
help=helps['solver_conf'])
parser.add_argument('--save-materials',
action='store_true',
dest='save_materials',
default=False,
help=helps['save_materials'])
parser.add_argument('--log-std-waves',
action='store_true',
dest='log_std_waves',
default=False,
help=helps['log_std_waves'])
parser.add_argument('--silent',
action='store_true',
dest='silent',
default=False,
help=helps['silent'])
parser.add_argument('-c',
'--clear',
action='store_true',
dest='clear',
default=False,
help=helps['clear'])
parser.add_argument('-o',
'--output-dir',
metavar='path',
action='store',
dest='output_dir',
default='output',
help=helps['output_dir'])
parser.add_argument('mesh_filename',
default='',
help=helps['mesh_filename'])
options = parser.parse_args()
output_dir = options.output_dir
output.set_output(filename=os.path.join(output_dir, 'output_log.txt'),
combined=options.silent == False)
if options.conf is not None:
mod = import_file(options.conf)
apply_units = mod.apply_units
define = mod.define
set_wave_dir = mod.set_wave_dir
else:
apply_units = apply_units_le
define = define_le
set_wave_dir = set_wave_dir_le
options.pars = [float(ii) for ii in options.pars.split(',')]
options.unit_multipliers = [
float(ii) for ii in options.unit_multipliers.split(',')
]
options.wave_dir = [float(ii) for ii in options.wave_dir.split(',')]
aux = options.range.split(',')
options.range = [float(aux[0]), float(aux[1]), int(aux[2])]
options.solver_conf = dict_from_string(options.solver_conf)
if options.clear:
remove_files_patterns(output_dir, ['*.h5', '*.vtk', '*.txt'],
ignores=['output_log.txt'],
verbose=True)
filename = os.path.join(output_dir, 'options.txt')
ensure_path(filename)
save_options(filename, [('options', vars(options))])
pars = apply_units(options.pars, options.unit_multipliers)
output('material parameters with applied unit multipliers:')
output(pars)
if options.mode == 'omega':
rng = copy(options.range)
rng[:2] = apply_unit_multipliers(options.range[:2],
['wave_number', 'wave_number'],
options.unit_multipliers)
output('wave number range with applied unit multipliers:', rng)
else:
rng = copy(options.range)
rng[:2] = apply_unit_multipliers(options.range[:2],
['frequency', 'frequency'],
options.unit_multipliers)
output('frequency range with applied unit multipliers:', rng)
define_problem = functools.partial(define,
filename_mesh=options.mesh_filename,
pars=pars,
approx_order=options.order,
refinement_level=options.refine,
solver_conf=options.solver_conf,
plane=options.plane)
conf = ProblemConf.from_dict(define_problem(), sys.modules[__name__])
pb = Problem.from_conf(conf)
dim = pb.domain.shape.dim
if dim != 2:
options.plane = 'strain'
wdir = nm.asarray(options.wave_dir[:dim], dtype=nm.float64)
wdir = wdir / nm.linalg.norm(wdir)
stepper = TimeStepper(rng[0], rng[1], dt=None, n_step=rng[2])
bbox = pb.domain.mesh.get_bounding_box()
size = (bbox[1] - bbox[0]).max()
scaling0 = apply_unit_multipliers([1.0], ['length'],
options.unit_multipliers)[0]
scaling = scaling0
if options.mesh_size is not None:
scaling *= options.mesh_size / size
output('scaling factor of periodic cell mesh coordinates:', scaling)
output('new mesh size with applied unit multipliers:', scaling * size)
pb.domain.mesh.coors[:] *= scaling
pb.set_mesh_coors(pb.domain.mesh.coors, update_fields=True)
bzone = 2.0 * nm.pi / (scaling * size)
output('1. Brillouin zone size:', bzone * scaling0)
output('1. Brillouin zone size with applied unit multipliers:', bzone)
pb.time_update()
pb.update_materials()
if options.save_materials or options.log_std_waves:
stiffness = pb.evaluate('ev_integrate_mat.2.Omega(m.D, u)',
mode='el_avg',
copy_materials=False,
verbose=False)
young, poisson = mc.youngpoisson_from_stiffness(stiffness,
plane=options.plane)
density = pb.evaluate('ev_integrate_mat.2.Omega(m.density, u)',
mode='el_avg',
copy_materials=False,
verbose=False)
if options.save_materials:
out = {}
out['young'] = Struct(name='young',
mode='cell',
data=young[..., None, None])
out['poisson'] = Struct(name='poisson',
mode='cell',
data=poisson[..., None, None])
out['density'] = Struct(name='density', mode='cell', data=density)
materials_filename = os.path.join(output_dir, 'materials.vtk')
pb.save_state(materials_filename, out=out)
# Set the normalized wave vector direction to the material(s).
set_wave_dir(pb.get_materials(), wdir)
conf = pb.solver_confs['eig']
eig_solver = Solver.any_from_conf(conf)
# Assemble the matrices.
mtx_m = pb.mtx_a.copy()
eq_m = pb.equations['M']
mtx_m = eq_m.evaluate(mode='weak', dw_mode='matrix', asm_obj=mtx_m)
mtx_m.eliminate_zeros()
mtx_k = pb.mtx_a.copy()
eq_k = pb.equations['K']
mtx_k = eq_k.evaluate(mode='weak', dw_mode='matrix', asm_obj=mtx_k)
mtx_k.eliminate_zeros()
mtx_s = pb.mtx_a.copy()
eq_s = pb.equations['S']
mtx_s = eq_s.evaluate(mode='weak', dw_mode='matrix', asm_obj=mtx_s)
mtx_s.eliminate_zeros()
mtx_r = pb.mtx_a.copy()
eq_r = pb.equations['R']
mtx_r = eq_r.evaluate(mode='weak', dw_mode='matrix', asm_obj=mtx_r)
mtx_r.eliminate_zeros()
output('symmetry checks of real blocks:')
output('M - M^T:', _max_diff_csr(mtx_m, mtx_m.T))
output('K - K^T:', _max_diff_csr(mtx_k, mtx_k.T))
output('S - S^T:', _max_diff_csr(mtx_s, mtx_s.T))
output('R + R^T:', _max_diff_csr(mtx_r, -mtx_r.T))
n_eigs = options.n_eigs
if options.n_eigs > mtx_k.shape[0]:
options.n_eigs = mtx_k.shape[0]
n_eigs = None
if options.mode == 'omega':
eigenshapes_filename = os.path.join(
output_dir, 'frequency-eigenshapes-%s.vtk' % stepper.suffix)
extra = []
extra_plot_kwargs = []
if options.log_std_waves:
lam, mu = mc.lame_from_youngpoisson(young,
poisson,
plane=options.plane)
alam = nm.average(lam)
amu = nm.average(mu)
adensity = nm.average(density)
cp = nm.sqrt((alam + 2.0 * amu) / adensity)
cs = nm.sqrt(amu / adensity)
output('average p-wave speed:', cp)
output('average shear wave speed:', cs)
extra = [r'$\omega_p$', r'$\omega_s$']
extra_plot_kwargs = [{
'ls': '--',
'color': 'k'
}, {
'ls': '--',
'color': 'gray'
}]
log = Log(
[[r'$\lambda_{%d}$' % ii for ii in range(options.n_eigs)],
[r'$\omega_{%d}$' % ii for ii in range(options.n_eigs)] + extra],
plot_kwargs=[{}, [{}] * options.n_eigs + extra_plot_kwargs],
yscales=['linear', 'linear'],
xlabels=[r'$\kappa$', r'$\kappa$'],
ylabels=[r'eigenvalues $\lambda_i$', r'frequencies $\omega_i$'],
log_filename=os.path.join(output_dir, 'frequencies.txt'),
aggregate=1000,
sleep=0.1)
for iv, wmag in stepper:
output('step %d: wave vector %s' % (iv, wmag * wdir))
mtx_a = mtx_k + wmag**2 * mtx_s + (1j * wmag) * mtx_r
mtx_b = mtx_m
output('A - A^H:', _max_diff_csr(mtx_a, mtx_a.H))
if options.eigs_only:
eigs = eig_solver(mtx_a,
mtx_b,
n_eigs=n_eigs,
eigenvectors=False)
svecs = None
else:
eigs, svecs = eig_solver(mtx_a,
mtx_b,
n_eigs=options.n_eigs,
eigenvectors=True)
omegas = nm.sqrt(eigs)
output('eigs, omegas:\n', nm.c_[eigs, omegas])
out = tuple(eigs) + tuple(omegas)
if options.log_std_waves:
out = out + (cp * wmag, cs * wmag)
log(*out, x=[wmag, wmag])
save_eigenvectors(eigenshapes_filename % iv, svecs, pb)
log(save_figure=os.path.join(output_dir, 'frequencies.png'))
log(finished=True)
else:
import scipy.sparse as sps
from sksparse.cholmod import cholesky
eigenshapes_filename = os.path.join(
output_dir, 'wave-number-eigenshapes-%s.vtk' % stepper.suffix)
factor = cholesky(mtx_s)
perm = factor.P()
ir = nm.arange(len(perm))
mtx_p = sps.coo_matrix((nm.ones_like(perm), (ir, perm)))
mtx_l = mtx_p.T * factor.L()
mtx_eye = sps.eye(mtx_l.shape[0], dtype=nm.float64)
output('S - LL^T:', _max_diff_csr(mtx_s, mtx_l * mtx_l.T))
log = Log([[r'$\kappa_{%d}$' % ii for ii in range(options.n_eigs)]],
plot_kwargs=[{
'ls': 'None',
'marker': 'o'
}],
yscales=['linear'],
xlabels=[r'$\omega$'],
ylabels=[r'wave numbers $\kappa_i$'],
log_filename=os.path.join(output_dir, 'wave-numbers.txt'),
aggregate=1000,
sleep=0.1)
for io, omega in stepper:
output('step %d: frequency %s' % (io, omega))
mtx_a = sps.bmat([[mtx_k - omega**2 * mtx_m, None],
[None, mtx_eye]])
mtx_b = sps.bmat([[1j * mtx_r, mtx_l], [mtx_l.T, None]])
output('A - A^T:', _max_diff_csr(mtx_a, mtx_a.T))
output('A - A^H:', _max_diff_csr(mtx_a, mtx_a.T))
output('B - B^H:', _max_diff_csr(mtx_b, mtx_b.H))
if options.eigs_only:
eigs = eig_solver(mtx_a,
mtx_b,
n_eigs=n_eigs,
eigenvectors=False)
svecs = None
else:
eigs, svecs = eig_solver(mtx_a,
mtx_b,
n_eigs=options.n_eigs,
eigenvectors=True)
kappas = eigs
output('kappas:\n', kappas[:, None])
out = tuple(kappas)
log(*out, x=[omega])
save_eigenvectors(eigenshapes_filename % io, svecs, pb)
log(save_figure=os.path.join(output_dir, 'wave-numbers.png'))
log(finished=True)
def recover_micro_hook_eps(micro_filename, region,
eval_var, nodal_values, const_values, eps0,
recovery_file_tag='',
define_args=None, verbose=False):
# Create a micro-problem instance.
required, other = get_standard_keywords()
required.remove('equations')
conf = ProblemConf.from_file(micro_filename, required, other,
verbose=False, define_args=define_args)
coefs_filename = conf.options.get('coefs_filename', 'coefs')
output_dir = conf.options.get('output_dir', '.')
coefs_filename = op.join(output_dir, coefs_filename) + '.h5'
# Coefficients and correctors
coefs = Coefficients.from_file_hdf5(coefs_filename)
corrs = get_correctors_from_file(dump_names=coefs.dump_names)
recovery_hook = conf.options.get('recovery_hook', None)
if recovery_hook is not None:
recovery_hook = conf.get_function(recovery_hook)
pb = Problem.from_conf(conf, init_equations=False, init_solvers=False)
# Get tiling of a given region
rcoors = region.domain.mesh.coors[region.get_entities(0), :]
rcmin = nm.min(rcoors, axis=0)
rcmax = nm.max(rcoors, axis=0)
nn = nm.round((rcmax - rcmin) / eps0)
if nm.prod(nn) == 0:
output('inconsistency in recovery region and microstructure size!')
return
cs = []
for ii, n in enumerate(nn):
cs.append(nm.arange(n) * eps0 + rcmin[ii])
x0 = nm.empty((int(nm.prod(nn)), nn.shape[0]), dtype=nm.float64)
for ii, icoor in enumerate(nm.meshgrid(*cs, indexing='ij')):
x0[:, ii] = icoor.flatten()
mesh = pb.domain.mesh
coors, conn, outs, ndoffset = [], [], [], 0
# Recover region
mic_coors = (mesh.coors - mesh.get_bounding_box()[0, :]) * eps0
evfield = eval_var.field
output('recovering microsctructures...')
tt = time.clock()
output_fun = output.output_function
output_level = output.level
for ii, c0 in enumerate(x0):
local_macro = {'eps0': eps0}
local_coors = mic_coors + c0
# Inside recovery region?
v = nm.ones((evfield.region.entities[0].shape[0], 1))
v[evfield.vertex_remap[region.entities[0]]] = 0
no = nm.sum(v)
aux = evfield.evaluate_at(local_coors, v)
if (nm.sum(aux) / no) > 1e-3:
continue
output.level = output_level
output('micro: %d' % ii)
for k, v in six.iteritems(nodal_values):
local_macro[k] = evfield.evaluate_at(local_coors, v)
for k, v in six.iteritems(const_values):
local_macro[k] = v
output.set_output(quiet=not(verbose))
outs.append(recovery_hook(pb, corrs, local_macro))
output.output_function = output_fun
coors.append(local_coors)
conn.append(mesh.get_conn(mesh.descs[0]) + ndoffset)
ndoffset += mesh.n_nod
output('...done in %.2f s' % (time.clock() - tt))
# Collect output variables
outvars = {}
for k, v in six.iteritems(outs[0]):
if v.var_name in outvars:
outvars[v.var_name].append(k)
else:
outvars[v.var_name] = [k]
# Split output by variables/regions
pvs = pb.create_variables(outvars.keys())
outregs = {k: pvs[k].field.region.get_entities(-1) for k in outvars.keys()}
nrve = len(coors)
coors = nm.vstack(coors)
ngroups = nm.tile(mesh.cmesh.vertex_groups.squeeze(), (nrve,))
conn = nm.vstack(conn)
cgroups = nm.tile(mesh.cmesh.cell_groups.squeeze(), (nrve,))
# Get region mesh and data
for k, cidxs in six.iteritems(outregs):
gcidxs = nm.hstack([cidxs + mesh.n_el * ii for ii in range(nrve)])
rconn = conn[gcidxs]
remap = -nm.ones((coors.shape[0],), dtype=nm.int32)
remap[rconn] = 1
vidxs = nm.where(remap > 0)[0]
remap[vidxs] = nm.arange(len(vidxs))
rconn = remap[rconn]
rcoors = coors[vidxs, :]
out = {}
for ifield in outvars[k]:
data = [outs[ii][ifield].data for ii in range(nrve)]
out[ifield] = Struct(name='output_data',
mode=outs[0][ifield].mode,
dofs=None,
var_name=k,
data=nm.vstack(data))
micro_name = pb.get_output_name(extra='recovered%s_%s'
% (recovery_file_tag, k))
filename = op.join(output_dir, op.basename(micro_name))
mesh_out = Mesh.from_data('recovery_%s' % k, rcoors, ngroups[vidxs],
[rconn], [cgroups[gcidxs]], [mesh.descs[0]])
mesh_out.write(filename, io='auto', out=out)
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="11,11,11", 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("-2", "--2d", action="store_true", dest="is_2d", default=False, help=helps["2d"])
parser.add_argument(
"--u-order", metavar="int", type=int, action="store", dest="order_u", default=1, help=helps["u-order"]
)
parser.add_argument(
"--p-order", metavar="int", type=int, action="store", dest="order_p", default=1, help=helps["p-order"]
)
parser.add_argument(
"--linearization",
choices=["strip", "adaptive"],
action="store",
dest="linearization",
default="strip",
help=helps["linearization"],
)
parser.add_argument("--metis", action="store_true", dest="metis", default=False, help=helps["metis"])
parser.add_argument("--silent", action="store_true", dest="silent", default=False, help=helps["silent"])
parser.add_argument("--clear", action="store_true", dest="clear", default=False, help=helps["clear"])
options, petsc_opts = parser.parse_known_args()
comm = pl.PETSc.COMM_WORLD
output_dir = options.output_dir
filename = os.path.join(output_dir, "output_log_%02d.txt" % comm.rank)
if comm.rank == 0:
ensure_path(filename)
comm.barrier()
output.prefix = "sfepy_%02d:" % comm.rank
output.set_output(filename=filename, combined=options.silent == False)
output("petsc options:", petsc_opts)
mesh_filename = os.path.join(options.output_dir, "para.h5")
if comm.rank == 0:
from sfepy.mesh.mesh_generators import gen_block_mesh
if options.clear:
for _f in chain(
*[glob.glob(os.path.join(output_dir, clean_pattern)) for clean_pattern in ["*.h5", "*.txt", "*.png"]]
):
output('removing "%s"' % _f)
os.remove(_f)
dim = 2 if options.is_2d else 3
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)
mesh = gen_block_mesh(dims, shape, centre, name="block-fem", verbose=True)
mesh.write(mesh_filename, io="auto")
comm.barrier()
output("field u order:", options.order_u)
output("field p order:", options.order_p)
solve_problem(mesh_filename, options, comm)
def main():
# if multi_mpi.cpu_count() < 2:
# raise ValueError('MPI mode - the number of nodes is less then 2!')
if multi_mpi.mpi_rank == multi_mpi.mpi_master:
# MPI master node - solve problem at macro scale
parser = ArgumentParser(description=__doc__,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('--debug',
action='store_true', dest='debug',
default=False, help=helps['debug'])
parser.add_argument('--debug_mpi',
action='store_true', dest='debug_mpi',
default=False, help=helps['debug_mpi'])
parser.add_argument('-c', '--conf', metavar='"key : value, ..."',
action='store', dest='conf', type=str,
default=None, help=helps['conf'])
parser.add_argument('-O', '--options', metavar='"key : value, ..."',
action='store', dest='app_options', type=str,
default=None, help=helps['options'])
parser.add_argument('-d', '--define', metavar='"key : value, ..."',
action='store', dest='define_args', type=str,
default=None, help=helps['define'])
parser.add_argument('-o', metavar='filename',
action='store', dest='output_filename_trunk',
default=None, help=helps['filename'])
parser.add_argument('--format', metavar='format',
action='store', dest='output_format',
default=None, help=helps['output_format'])
parser.add_argument('--log', metavar='file',
action='store', dest='log',
default=None, help=helps['log'])
parser.add_argument('-q', '--quiet',
action='store_true', dest='quiet',
default=False, help=helps['quiet'])
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument('filename_in', nargs='?')
options = parser.parse_args()
for k in ['save_ebc', 'save_ebc_nodes', 'save_regions',
'save_regions_as_groups', 'save_field_meshes', 'solve_not']:
setattr(options, k, False)
if options.debug:
from sfepy.base.base import debug_on_error; debug_on_error()
if options.debug_mpi:
multi_mpi.set_logging_level('debug')
filename_in = options.filename_in
output.set_output(filename=options.log,
quiet=options.quiet,
combined=options.log is not None)
required, other = get_standard_keywords()
conf = ProblemConf.from_file_and_options(filename_in, options,
required, other, define_args=options.define_args)
opts = conf.options
nslaves = multi_mpi.cpu_count() - 1
opts.n_mpi_homog_slaves = nslaves
output_prefix = opts.get('output_prefix', 'sfepy:')
app = PDESolverApp(conf, options, output_prefix)
if hasattr(opts, 'parametric_hook'): # Parametric study.
parametric_hook = conf.get_function(opts.parametric_hook)
app.parametrize(parametric_hook)
app()
multi_mpi.master_send_task('finalize', None)
else:
# MPI slave mode - calculate homogenized coefficients
homogen_app = None
done = False
rank = multi_mpi.mpi_rank
while not done:
task, data = multi_mpi.slave_get_task('main slave loop')
if task == 'init': # data: micro_file, n_micro
output.set_output(filename='homog_app_mpi_%d.log' % rank,
quiet=True)
micro_file, n_micro = data[:2]
required, other = get_standard_keywords()
required.remove('equations')
conf = ProblemConf.from_file(micro_file, required, other,
verbose=False)
options = Struct(output_filename_trunk=None)
homogen_app = HomogenizationApp(conf, options, 'micro:',
n_micro=n_micro,
update_micro_coors=True)
elif task == 'calculate': # data: rel_def_grad, ts, iteration
rel_def_grad, ts, iteration = data[:3]
homogen_app.setup_macro_deformation(rel_def_grad)
homogen_app(ret_all=True, itime=ts.step, iiter=iteration)
elif task == 'finalize':
done = True
def main():
parser = ArgumentParser(description=__doc__.rstrip(),
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('output_dir', help=helps['output_dir'])
parser.add_argument('-d', '--dims', metavar='l,w,t',
action='store', dest='dims',
default='0.2,0.01,0.001', help=helps['dims'])
parser.add_argument('-n', '--nx', metavar='start,stop,step',
action='store', dest='nx',
default='2,103,10', help=helps['nx'])
parser.add_argument('-t', '--transform', choices=['none', 'bend', 'twist'],
action='store', dest='transform',
default='none', help=helps['transform'])
parser.add_argument('--young', metavar='float', type=float,
action='store', dest='young',
default=210e9, help=helps['young'])
parser.add_argument('--poisson', metavar='float', type=float,
action='store', dest='poisson',
default=0.3, help=helps['poisson'])
parser.add_argument('--force', metavar='float', type=float,
action='store', dest='force',
default=-1.0, help=helps['force'])
parser.add_argument('-p', '--plot',
action="store_true", dest='plot',
default=False, help=helps['plot'])
parser.add_argument('--u-scaling', metavar='float', type=float,
action='store', dest='scaling',
default=1.0, help=helps['scaling'])
parser.add_argument('-s', '--show',
action="store_true", dest='show',
default=False, help=helps['show'])
parser.add_argument('--silent',
action='store_true', dest='silent',
default=False, help=helps['silent'])
options = parser.parse_args()
dims = nm.array([float(ii) for ii in options.dims.split(',')],
dtype=nm.float64)
nxs = tuple([int(ii) for ii in options.nx.split(',')])
young = options.young
poisson = options.poisson
force = options.force
output_dir = options.output_dir
odir = lambda filename: os.path.join(output_dir, filename)
filename = odir('output_log.txt')
ensure_path(filename)
output.set_output(filename=filename, combined=options.silent == False)
output('output directory:', output_dir)
output('using values:')
output(" dimensions:", dims)
output(" nx range:", nxs)
output(" Young's modulus:", options.young)
output(" Poisson's ratio:", options.poisson)
output(' force:', options.force)
output(' transform:', options.transform)
if options.transform == 'none':
options.transform = None
u_exact = get_analytical_displacement(dims, young, force,
transform=options.transform)
if options.transform is None:
ilog = 2
labels = ['u_3']
elif options.transform == 'bend':
ilog = 0
labels = ['u_1']
elif options.transform == 'twist':
ilog = [0, 1, 2]
labels = ['u_1', 'u_2', 'u_3']
label = ', '.join(labels)
log = []
for nx in range(*nxs):
shape = (nx, 2)
pb, state, u, gamma2 = solve_problem(shape, dims, young, poisson, force,
transform=options.transform)
dofs = u.get_state_in_region(gamma2)
output('DOFs along the loaded edge:')
output('\n%s' % dofs)
log.append([nx - 1] + nm.array(dofs[0, ilog], ndmin=1).tolist())
pb.save_state(odir('shell10x_cantilever.vtk'), state)
log = nm.array(log)
output('max. %s displacement w.r.t. number of cells:' % label)
output('\n%s' % log)
output('analytical value:', u_exact)
if options.plot:
import matplotlib.pyplot as plt
plt.rcParams.update({
'lines.linewidth' : 3,
'font.size' : 16,
})
fig, ax1 = plt.subplots()
fig.suptitle('max. $%s$ displacement' % label)
for ic in range(log.shape[1] - 1):
ax1.plot(log[:, 0], log[:, ic + 1], label=r'$%s$' % labels[ic])
ax1.set_xlabel('# of cells')
ax1.set_ylabel(r'$%s$' % label)
ax1.grid(which='both')
lines1, labels1 = ax1.get_legend_handles_labels()
if u_exact is not None:
ax1.hlines(u_exact, log[0, 0], log[-1, 0],
'r', 'dotted', label=r'$%s^{analytical}$' % label)
ax2 = ax1.twinx()
# Assume single log column.
ax2.semilogy(log[:, 0], nm.abs(log[:, 1] - u_exact), 'g',
label=r'$|%s - %s^{analytical}|$' % (label, label))
ax2.set_ylabel(r'$|%s - %s^{analytical}|$' % (label, label))
lines2, labels2 = ax2.get_legend_handles_labels()
else:
lines2, labels2 = [], []
ax1.legend(lines1 + lines2, labels1 + labels2, loc='best')
plt.tight_layout()
ax1.set_xlim([log[0, 0] - 2, log[-1, 0] + 2])
suffix = {None: 'straight',
'bend' : 'bent', 'twist' : 'twisted'}[options.transform]
fig.savefig(odir('shell10x_cantilever_convergence_%s.png' % suffix))
plt.show()
if options.show:
from sfepy.postprocess.viewer import Viewer
from sfepy.postprocess.domain_specific import DomainSpecificPlot
ds = {'u_disp' :
DomainSpecificPlot('plot_displacements',
['rel_scaling=%f' % options.scaling])}
view = Viewer(odir('shell10x_cantilever.vtk'))
view(domain_specific=ds, is_scalar_bar=True, is_wireframe=True,
opacity={'wireframe' : 0.5})
def main():
parser = ArgumentParser(description=__doc__.rstrip(),
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('output_dir', help=helps['output_dir'])
parser.add_argument('-d', '--dims', metavar='l,w,t',
action='store', dest='dims',
default='0.2,0.01,0.001', help=helps['dims'])
parser.add_argument('-n', '--nx', metavar='start,stop,step',
action='store', dest='nx',
default='2,103,10', help=helps['nx'])
parser.add_argument('-t', '--transform', choices=['none', 'bend', 'twist'],
action='store', dest='transform',
default='none', help=helps['transform'])
parser.add_argument('--young', metavar='float', type=float,
action='store', dest='young',
default=210e9, help=helps['young'])
parser.add_argument('--poisson', metavar='float', type=float,
action='store', dest='poisson',
default=0.3, help=helps['poisson'])
parser.add_argument('--force', metavar='float', type=float,
action='store', dest='force',
default=-1.0, help=helps['force'])
parser.add_argument('-p', '--plot',
action="store_true", dest='plot',
default=False, help=helps['plot'])
parser.add_argument('--u-scaling', metavar='float', type=float,
action='store', dest='scaling',
default=1.0, help=helps['scaling'])
parser.add_argument('-s', '--show',
action="store_true", dest='show',
default=False, help=helps['show'])
parser.add_argument('--silent',
action='store_true', dest='silent',
default=False, help=helps['silent'])
options = parser.parse_args()
dims = nm.array([float(ii) for ii in options.dims.split(',')],
dtype=nm.float64)
nxs = tuple([int(ii) for ii in options.nx.split(',')])
young = options.young
poisson = options.poisson
force = options.force
output_dir = options.output_dir
odir = lambda filename: os.path.join(output_dir, filename)
filename = odir('output_log.txt')
ensure_path(filename)
output.set_output(filename=filename, combined=options.silent == False)
output('output directory:', output_dir)
output('using values:')
output(" dimensions:", dims)
output(" nx range:", nxs)
output(" Young's modulus:", options.young)
output(" Poisson's ratio:", options.poisson)
output(' force:', options.force)
output(' transform:', options.transform)
if options.transform == 'none':
options.transform = None
u_exact = get_analytical_displacement(dims, young, force,
transform=options.transform)
if options.transform is None:
ilog = 2
labels = ['u_3']
elif options.transform == 'bend':
ilog = 0
labels = ['u_1']
elif options.transform == 'twist':
ilog = [0, 1, 2]
labels = ['u_1', 'u_2', 'u_3']
label = ', '.join(labels)
log = []
for nx in range(*nxs):
shape = (nx, 2)
pb, state, u, gamma2 = solve_problem(shape, dims, young, poisson, force,
transform=options.transform)
dofs = u.get_state_in_region(gamma2)
output('DOFs along the loaded edge:')
output('\n%s' % dofs)
log.append([nx - 1] + nm.array(dofs[0, ilog], ndmin=1).tolist())
pb.save_state(odir('shell10x_cantilever.vtk'), state)
log = nm.array(log)
output('max. %s displacement w.r.t. number of cells:' % label)
output('\n%s' % log)
output('analytical value:', u_exact)
if options.plot:
import matplotlib.pyplot as plt
plt.rcParams.update({
'lines.linewidth' : 3,
'font.size' : 16,
})
fig, ax1 = plt.subplots()
fig.suptitle('max. $%s$ displacement' % label)
for ic in range(log.shape[1] - 1):
ax1.plot(log[:, 0], log[:, ic + 1], label=r'$%s$' % labels[ic])
ax1.set_xlabel('# of cells')
ax1.set_ylabel(r'$%s$' % label)
ax1.grid(which='both')
lines1, labels1 = ax1.get_legend_handles_labels()
if u_exact is not None:
ax1.hlines(u_exact, log[0, 0], log[-1, 0],
'r', 'dotted', label=r'$%s^{analytical}$' % label)
ax2 = ax1.twinx()
# Assume single log column.
ax2.semilogy(log[:, 0], nm.abs(log[:, 1] - u_exact), 'g',
label=r'$|%s - %s^{analytical}|$' % (label, label))
ax2.set_ylabel(r'$|%s - %s^{analytical}|$' % (label, label))
lines2, labels2 = ax2.get_legend_handles_labels()
else:
lines2, labels2 = [], []
ax1.legend(lines1 + lines2, labels1 + labels2, loc='best')
plt.tight_layout()
ax1.set_xlim([log[0, 0] - 2, log[-1, 0] + 2])
suffix = {None: 'straight',
'bend' : 'bent', 'twist' : 'twisted'}[options.transform]
fig.savefig(odir('shell10x_cantilever_convergence_%s.png' % suffix))
plt.show()
if options.show:
from sfepy.postprocess.viewer import Viewer
from sfepy.postprocess.domain_specific import DomainSpecificPlot
ds = {'u_disp' :
DomainSpecificPlot('plot_displacements',
['rel_scaling=%f' % options.scaling])}
view = Viewer(odir('shell10x_cantilever.vtk'))
view(domain_specific=ds, is_scalar_bar=True, is_wireframe=True,
opacity={'wireframe' : 0.5})
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='11,11,11', 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('-2', '--2d',
action='store_true', dest='is_2d',
default=False, help=helps['2d'])
parser.add_argument('--order', metavar='int', type=int,
action='store', dest='order',
default=1, help=helps['order'])
parser.add_argument('--linearization', choices=['strip', 'adaptive'],
action='store', dest='linearization',
default='strip', help=helps['linearization'])
parser.add_argument('--metis',
action='store_true', dest='metis',
default=False, help=helps['metis'])
parser.add_argument('--verify',
action='store_true', dest='verify',
default=False, help=helps['verify'])
parser.add_argument('--plot',
action='store_true', dest='plot',
default=False, help=helps['plot'])
parser.add_argument('--show',
action='store_true', dest='show',
default=False, help=helps['show'])
parser.add_argument('--save-inter-regions',
action='store_true', dest='save_inter_regions',
default=False, help=helps['save_inter_regions'])
parser.add_argument('--silent',
action='store_true', dest='silent',
default=False, help=helps['silent'])
parser.add_argument('--clear',
action='store_true', dest='clear',
default=False, help=helps['clear'])
options, petsc_opts = parser.parse_known_args()
if options.show:
options.plot = True
comm = pl.PETSc.COMM_WORLD
output_dir = options.output_dir
filename = os.path.join(output_dir, 'output_log_%02d.txt' % comm.rank)
if comm.rank == 0:
ensure_path(filename)
comm.barrier()
output.prefix = 'sfepy_%02d:' % comm.rank
output.set_output(filename=filename, combined=options.silent == False)
output('petsc options:', petsc_opts)
mesh_filename = os.path.join(options.output_dir, 'para.h5')
if comm.rank == 0:
from sfepy.mesh.mesh_generators import gen_block_mesh
if options.clear:
remove_files_patterns(output_dir,
['*.h5', '*.mesh', '*.txt', '*.png'],
ignores=['output_log_%02d.txt' % ii
for ii in range(comm.size)],
verbose=True)
save_options(os.path.join(output_dir, 'options.txt'),
[('options', vars(options))])
dim = 2 if options.is_2d else 3
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)
mesh = gen_block_mesh(dims, shape, centre, name='block-fem',
verbose=True)
mesh.write(mesh_filename, io='auto')
comm.barrier()
output('field order:', options.order)
solve_problem(mesh_filename, options, comm)
def main():
# Aluminium and epoxy.
default_pars = '70e9,0.35,2.799e3, 3.8e9,0.27,1.142e3'
default_solver_conf = ("kind='eig.scipy',method='eigsh',tol=1.0e-5,"
"maxiter=1000,which='LM',sigma=0.0")
parser = ArgumentParser(description=__doc__,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('--pars', metavar='young1,poisson1,density1'
',young2,poisson2,density2',
action='store', dest='pars',
default=default_pars, help=helps['pars'])
parser.add_argument('--conf', metavar='filename',
action='store', dest='conf',
default=None, help=helps['conf'])
parser.add_argument('--mesh-size', type=float, metavar='float',
action='store', dest='mesh_size',
default=None, help=helps['mesh_size'])
parser.add_argument('--unit-multipliers',
metavar='c_time,c_length,c_mass',
action='store', dest='unit_multipliers',
default='1.0,1.0,1.0', help=helps['unit_multipliers'])
parser.add_argument('--plane', action='store', dest='plane',
choices=['strain', 'stress'],
default='strain', help=helps['plane'])
parser.add_argument('--wave-dir', metavar='float,float[,float]',
action='store', dest='wave_dir',
default='1.0,0.0,0.0', help=helps['wave_dir'])
parser.add_argument('--mode', action='store', dest='mode',
choices=['omega', 'kappa'],
default='omega', help=helps['mode'])
parser.add_argument('--range', metavar='start,stop,count',
action='store', dest='range',
default='0,6.4,33', help=helps['range'])
parser.add_argument('--order', metavar='int', type=int,
action='store', dest='order',
default=1, help=helps['order'])
parser.add_argument('--refine', metavar='int', type=int,
action='store', dest='refine',
default=0, help=helps['refine'])
parser.add_argument('-n', '--n-eigs', metavar='int', type=int,
action='store', dest='n_eigs',
default=6, help=helps['n_eigs'])
group = parser.add_mutually_exclusive_group()
group.add_argument('--eigs-only',
action='store_true', dest='eigs_only',
default=False, help=helps['eigs_only'])
group.add_argument('--post-process',
action='store_true', dest='post_process',
default=False, help=helps['post_process'])
parser.add_argument('--solver-conf', metavar='dict-like',
action='store', dest='solver_conf',
default=default_solver_conf, help=helps['solver_conf'])
parser.add_argument('--save-regions',
action='store_true', dest='save_regions',
default=False, help=helps['save_regions'])
parser.add_argument('--save-materials',
action='store_true', dest='save_materials',
default=False, help=helps['save_materials'])
parser.add_argument('--log-std-waves',
action='store_true', dest='log_std_waves',
default=False, help=helps['log_std_waves'])
parser.add_argument('--no-legends',
action='store_false', dest='show_legends',
default=True, help=helps['no_legends'])
parser.add_argument('--no-show',
action='store_false', dest='show',
default=True, help=helps['no_show'])
parser.add_argument('--silent',
action='store_true', dest='silent',
default=False, help=helps['silent'])
parser.add_argument('-c', '--clear',
action='store_true', dest='clear',
default=False, help=helps['clear'])
parser.add_argument('-o', '--output-dir', metavar='path',
action='store', dest='output_dir',
default='output', help=helps['output_dir'])
parser.add_argument('mesh_filename', default='',
help=helps['mesh_filename'])
options = parser.parse_args()
output_dir = options.output_dir
output.set_output(filename=os.path.join(output_dir,'output_log.txt'),
combined=options.silent == False)
if options.conf is not None:
mod = import_file(options.conf)
else:
mod = sys.modules[__name__]
apply_units = mod.apply_units
define = mod.define
set_wave_dir = mod.set_wave_dir
setup_n_eigs = mod.setup_n_eigs
build_evp_matrices = mod.build_evp_matrices
save_materials = mod.save_materials
get_std_wave_fun = mod.get_std_wave_fun
get_stepper = mod.get_stepper
process_evp_results = mod.process_evp_results
options.pars = [float(ii) for ii in options.pars.split(',')]
options.unit_multipliers = [float(ii)
for ii in options.unit_multipliers.split(',')]
options.wave_dir = [float(ii)
for ii in options.wave_dir.split(',')]
aux = options.range.split(',')
options.range = [float(aux[0]), float(aux[1]), int(aux[2])]
options.solver_conf = dict_from_string(options.solver_conf)
if options.clear:
remove_files_patterns(output_dir,
['*.h5', '*.vtk', '*.txt'],
ignores=['output_log.txt'],
verbose=True)
filename = os.path.join(output_dir, 'options.txt')
ensure_path(filename)
save_options(filename, [('options', vars(options))],
quote_command_line=True)
pars = apply_units(options.pars, options.unit_multipliers)
output('material parameters with applied unit multipliers:')
output(pars)
if options.mode == 'omega':
rng = copy(options.range)
rng[:2] = apply_unit_multipliers(options.range[:2],
['wave_number', 'wave_number'],
options.unit_multipliers)
output('wave number range with applied unit multipliers:', rng)
else:
rng = copy(options.range)
rng[:2] = apply_unit_multipliers(options.range[:2],
['frequency', 'frequency'],
options.unit_multipliers)
output('frequency range with applied unit multipliers:', rng)
pb, wdir, bzone, mtxs = assemble_matrices(define, mod, pars, set_wave_dir,
options)
dim = pb.domain.shape.dim
if dim != 2:
options.plane = 'strain'
if options.save_regions:
pb.save_regions_as_groups(os.path.join(output_dir, 'regions'))
if options.save_materials:
save_materials(output_dir, pb, options)
conf = pb.solver_confs['eig']
eig_solver = Solver.any_from_conf(conf)
n_eigs, options.n_eigs = setup_n_eigs(options, pb, mtxs)
get_color = lambda ii: plt.cm.viridis((float(ii) / (options.n_eigs - 1)))
plot_kwargs = [{'color' : get_color(ii), 'ls' : '', 'marker' : 'o'}
for ii in range(options.n_eigs)]
log_names = []
log_plot_kwargs = []
if options.log_std_waves:
std_wave_fun, log_names, log_plot_kwargs = get_std_wave_fun(
pb, options)
else:
std_wave_fun = None
stepper = get_stepper(rng, pb, options)
if options.mode == 'omega':
eigenshapes_filename = os.path.join(output_dir,
'frequency-eigenshapes-%s.vtk'
% stepper.suffix)
log = Log([[r'$\lambda_{%d}$' % ii for ii in range(options.n_eigs)],
[r'$\omega_{%d}$'
% ii for ii in range(options.n_eigs)] + log_names],
plot_kwargs=[plot_kwargs, plot_kwargs + log_plot_kwargs],
formats=[['{:.5e}'] * options.n_eigs,
['{:.5e}'] * (options.n_eigs + len(log_names))],
yscales=['linear', 'linear'],
xlabels=[r'$\kappa$', r'$\kappa$'],
ylabels=[r'eigenvalues $\lambda_i$',
r'frequencies $\omega_i$'],
show_legends=options.show_legends,
is_plot=options.show,
log_filename=os.path.join(output_dir, 'frequencies.txt'),
aggregate=1000, sleep=0.1)
for iv, wmag in stepper:
output('step %d: wave vector %s' % (iv, wmag * wdir))
evp_mtxs = build_evp_matrices(mtxs, wmag, options.mode, pb)
if options.eigs_only:
eigs = eig_solver(*evp_mtxs, n_eigs=n_eigs,
eigenvectors=False)
svecs = None
else:
eigs, svecs = eig_solver(*evp_mtxs, n_eigs=n_eigs,
eigenvectors=True)
omegas, svecs, out = process_evp_results(
eigs, svecs, wmag, options.mode,
wdir, bzone, pb, mtxs, std_wave_fun=std_wave_fun
)
log(*out, x=[wmag, wmag])
save_eigenvectors(eigenshapes_filename % iv, svecs, wmag, wdir, pb)
gc.collect()
log(save_figure=os.path.join(output_dir, 'frequencies.png'))
log(finished=True)
else:
eigenshapes_filename = os.path.join(output_dir,
'wave-number-eigenshapes-%s.vtk'
% stepper.suffix)
log = Log([[r'$\kappa_{%d}$' % ii for ii in range(options.n_eigs)]
+ log_names],
plot_kwargs=[plot_kwargs + log_plot_kwargs],
formats=[['{:.5e}'] * (options.n_eigs + len(log_names))],
yscales=['linear'],
xlabels=[r'$\omega$'],
ylabels=[r'wave numbers $\kappa_i$'],
show_legends=options.show_legends,
is_plot=options.show,
log_filename=os.path.join(output_dir, 'wave-numbers.txt'),
aggregate=1000, sleep=0.1)
for io, omega in stepper:
output('step %d: frequency %s' % (io, omega))
evp_mtxs = build_evp_matrices(mtxs, omega, options.mode, pb)
if options.eigs_only:
eigs = eig_solver(*evp_mtxs, n_eigs=n_eigs,
eigenvectors=False)
svecs = None
else:
eigs, svecs = eig_solver(*evp_mtxs, n_eigs=n_eigs,
eigenvectors=True)
kappas, svecs, out = process_evp_results(
eigs, svecs, omega, options.mode,
wdir, bzone, pb, mtxs, std_wave_fun=std_wave_fun
)
log(*out, x=[omega])
save_eigenvectors(eigenshapes_filename % io, svecs, kappas, wdir,
pb)
gc.collect()
log(save_figure=os.path.join(output_dir, 'wave-numbers.png'))
log(finished=True)
def main():
parser = OptionParser(usage=usage, version='%prog ' + sfepy.__version__)
parser.add_option('-c', '--conf', metavar='"key : value, ..."',
action='store', dest='conf', type='string',
default=None, help= help['conf'])
parser.add_option('-O', '--options', metavar='"key : value, ..."',
action='store', dest='app_options', type='string',
default=None, help=help['options'])
parser.add_option('-d', '--define', metavar='"key : value, ..."',
action='store', dest='define_args', type='string',
default=None, help=help['define'])
parser.add_option('-o', '', metavar='filename',
action='store', dest='output_filename_trunk',
default=None, help=help['filename'])
parser.add_option('', '--format', metavar='format',
action='store', dest='output_format',
default=None, help=help['output_format'])
parser.add_option('', '--log', metavar='file',
action='store', dest='log',
default=None, help=help['log'])
parser.add_option('-q', '--quiet',
action='store_true', dest='quiet',
default=False, help=help['quiet'])
parser.add_option('', '--save-ebc',
action='store_true', dest='save_ebc',
default=False, help=help['save_ebc'])
parser.add_option('', '--save-ebc-nodes',
action='store_true', dest='save_ebc_nodes',
default=False, help=help['save_ebc_nodes'])
parser.add_option('', '--save-regions',
action='store_true', dest='save_regions',
default=False, help=help['save_regions'])
parser.add_option('', '--save-regions-as-groups',
action='store_true', dest='save_regions_as_groups',
default=False, help=help['save_regions_as_groups'])
parser.add_option('', '--save-field-meshes',
action='store_true', dest='save_field_meshes',
default=False, help=help['save_field_meshes'])
parser.add_option('', '--solve-not',
action='store_true', dest='solve_not',
default=False, help=help['solve_not'])
parser.add_option('', '--list', metavar='what',
action='store', dest='_list',
default=None, help=help['list'])
options, args = parser.parse_args()
if (len(args) == 1):
filename_in = args[0];
else:
if options._list == 'terms':
print_terms()
else:
parser.print_help(),
return
output.set_output(filename=options.log,
quiet=options.quiet,
combined=options.log is not None)
required, other = get_standard_keywords()
if options.solve_not:
required.remove('equations')
required.remove('solver_[0-9]+|solvers')
other.extend(['equations'])
conf = ProblemConf.from_file_and_options(filename_in, options,
required, other,
define_args=options.define_args)
opts = conf.options
output_prefix = get_default_attr(opts, 'output_prefix', 'sfepy:')
app = PDESolverApp(conf, options, output_prefix)
if hasattr(opts, 'parametric_hook'): # Parametric study.
parametric_hook = conf.get_function(opts.parametric_hook)
app.parametrize(parametric_hook)
app()
def main():
parser = ArgumentParser(description=__doc__,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('--version', action='version',
version='%(prog)s ' + sfepy.__version__)
parser.add_argument('--debug',
action='store_true', dest='debug',
default=False, help=helps['debug'])
parser.add_argument('-c', '--conf', metavar='"key : value, ..."',
action='store', dest='conf', type=str,
default=None, help= helps['conf'])
parser.add_argument('-O', '--options', metavar='"key : value, ..."',
action='store', dest='app_options', type=str,
default=None, help=helps['options'])
parser.add_argument('-d', '--define', metavar='"key : value, ..."',
action='store', dest='define_args', type=str,
default=None, help=helps['define'])
parser.add_argument('-o', metavar='filename',
action='store', dest='output_filename_trunk',
default=None, help=helps['filename'])
parser.add_argument('--format', metavar='format',
action='store', dest='output_format',
default=None, help=helps['output_format'])
parser.add_argument('--save-restart', metavar='mode', type=int,
action='store', dest='save_restart',
default=None, help=helps['save_restart'])
parser.add_argument('--load-restart', metavar='filename',
action='store', dest='load_restart',
default=None, help=helps['load_restart'])
parser.add_argument('--log', metavar='file',
action='store', dest='log',
default=None, help=helps['log'])
parser.add_argument('-q', '--quiet',
action='store_true', dest='quiet',
default=False, help=helps['quiet'])
parser.add_argument('--save-ebc',
action='store_true', dest='save_ebc',
default=False, help=helps['save_ebc'])
parser.add_argument('--save-ebc-nodes',
action='store_true', dest='save_ebc_nodes',
default=False, help=helps['save_ebc_nodes'])
parser.add_argument('--save-regions',
action='store_true', dest='save_regions',
default=False, help=helps['save_regions'])
parser.add_argument('--save-regions-as-groups',
action='store_true', dest='save_regions_as_groups',
default=False, help=helps['save_regions_as_groups'])
parser.add_argument('--save-field-meshes',
action='store_true', dest='save_field_meshes',
default=False, help=helps['save_field_meshes'])
parser.add_argument('--solve-not',
action='store_true', dest='solve_not',
default=False, help=helps['solve_not'])
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument('--list', metavar='what',
action='store', dest='_list',
default=None, help=helps['list'])
group.add_argument('filename_in', nargs='?')
options = parser.parse_args()
if options._list is not None:
if options._list == 'terms':
print_terms()
elif options._list == 'solvers':
print_solvers()
return
if options.debug:
from sfepy.base.base import debug_on_error; debug_on_error()
filename_in = options.filename_in
output.set_output(filename=options.log,
quiet=options.quiet,
combined=options.log is not None)
required, other = get_standard_keywords()
if options.solve_not:
required.remove('equations')
required.remove('solver_[0-9]+|solvers')
other.extend(['equations'])
conf = ProblemConf.from_file_and_options(filename_in, options,
required, other,
define_args=options.define_args)
opts = conf.options
output_prefix = opts.get('output_prefix', 'sfepy:')
opts.save_restart = options.save_restart
opts.load_restart = options.load_restart
app = PDESolverApp(conf, options, output_prefix)
if hasattr(opts, 'parametric_hook'): # Parametric study.
parametric_hook = conf.get_function(opts.parametric_hook)
app.parametrize(parametric_hook)
app()
def FarField(eltype,
points,
boundary,
lcar,
epsilon,
meshfile,
thickness=None,
verbose=False):
"""
This function determines a geometric factor F within a single element.
The element type can be triangular, quadrilateral, tetrahedral or
hexahedral. For these types eltype is set to "CTRIA3", "CQUAD4"
"CTETRA" and "CHEXA8" respectively. The vertices of the element are
provided in the input parameter points. The input parameter boundary is of
boolean type and has the same size as points. Those points which are
part of the conductive interface CI are flagged True. Epsilon sets
a tolerance to determine which mesh vertices are considered part of
the FF boundary. The meshing of the element is stored in a location
provided by meshfile.
Parameters
----------
eltype: string
'CTRIA3' for triangular surface elements,
'CQUAD4' for quadrilateral surface elements,
'CTETRA' for tetrahedral volume elements.
'CHEXA8' for hexahedral volume elements.
points: array like
Array containing the coordinates of the element
boundary: array like
Array containing the entries of the boundary points
lcar: float
Characteristic length value provided to gmsh for mesh sizing.
epsilon: float
Numerical tolerance on criterion for far field
boundary
meshfile: string
Filename and location for storing temporary mesh file
verbose: boolean
Indicate whether intermediate results should be displayed
or not
Returns
-------
: array like
Array with boolean entries stating True for those items
on the boundary and False otherwise
"""
if verbose is True:
output.set_output(quiet=False)
else:
output.set_output(quiet=True)
if (eltype == "CTRIA3") or (eltype == "CQUAD4"):
sdim = 2
else:
sdim = 3
boundpnts = []
for i in range(len(points)):
if boundary[i]:
boundpnts.append(points[i])
mesh = sfedis.fem.Mesh.from_file(meshfile)
domain = sfedis.fem.FEDomain('domain', mesh)
c = sfedis.Material('c', val=1.0)
omega = domain.create_region('Omega', 'all')
if verbose is True:
coors = mesh.coors
fixed_vert = _is_on_bound(coors,
bound=boundpnts,
sdim=sdim,
epsilon=epsilon)
print "fixed vertices:"
print fixed_vert
is_on_bound = sfedis.Functions([
sfedis.Function('_is_on_bound',
_is_on_bound,
extra_args={
'bound': boundpnts,
'sdim': sdim,
'epsilon': lcar / 100.
}),
])
fixed = domain.create_region('fixed',
'vertices by _is_on_bound',
'facet',
functions=is_on_bound,
add_to_regions=True)
field_t = sfedis.fem.Field.from_args('temperature',
np.float64,
'scalar',
omega,
approx_order=2)
t = sfedis.FieldVariable('t', 'unknown', field_t, 1)
s = sfedis.FieldVariable('s', 'test', field_t, 1, primary_var_name='t')
integral = sfedis.Integral('i', order=4)
term1 = Term.new('dw_laplace(s, t)', integral, omega, s=s, t=t)
term2 = Term.new('dw_volume_integrate(c.val, s)',
integral,
omega,
c=c,
s=s) # heat source term for 1st step of far field
eq = sfedis.Equation('temperature', term1 - term2)
eqs = sfedis.Equations([eq])
t_fixed = EssentialBC('t_fixed', fixed, {'t.0': 0.0})
ls = ScipyDirect({})
nls = Newton({'i_max': 1, 'eps_a': 1e-10}, lin_solver=ls)
pb = sfedis.Problem('temperature', equations=eqs, nls=nls, ls=ls)
pb.time_update(ebcs=Conditions([
t_fixed,
]))
temperature = pb.solve()
out = temperature.create_output_dict()
if verbose is True:
pb.save_state('result.vtk', out=out)
view = Viewer('result.vtk')
view(is_wireframe=True, rel_scaling=1, is_scalar_bar=True)
print "Maximum temperature: %f" % np.max(out['t'].data)
data = [i[0] for i in out['t'].data]
FF = _get_far(eltype, points, data, mesh, sdim, epsilon)
str1 = ''.join(str(v) + ', ' for v in FF)[:-2]
try:
far = domain.create_region('far',
'vertex %s' % str1,
'facet',
add_to_regions=True)
except Exception as e:
print "Far field region creation failed!"
print(e)
t.reset()
s.reset()
return
area_source = pb.evaluate('d_surface.3.far(t)')
fluxval = 1.0 / (area_source)
c2 = sfedis.Material(
'c2', val=fluxval
) # So that total heat at the far field is 1W equally distributed over all elements
term1A = Term.new('dw_laplace(c.val, s, t)',
integral,
omega,
c=c,
s=s,
t=t)
term2A = Term.new('dw_surface_integrate(c2.val, s)',
integral,
far,
c2=c2,
s=s)
eq2 = sfedis.Equation('temperature2', term1A - term2A)
eqs2 = sfedis.Equations([eq2])
pb2 = sfedis.Problem('temperature2', equations=eqs2, nls=nls, ls=ls)
pb2.time_update(ebcs=Conditions([
t_fixed,
]))
temperature2 = pb2.solve()
out2 = temperature2.create_output_dict()
volume = pb2.evaluate('d_volume.3.Omega(t)')
t_int = pb2.evaluate('ev_volume_integrate.3.Omega(t)')
avg_t = t_int / volume
F = 1.0 / avg_t
if verbose is True:
print "Average temperature: %f" % avg_t
if thickness:
'Correction factor 1e-3 is due to geometry in mm instead of m'
F = F * thickness * 1e-3
if verbose is True:
pb.save_state('result.vtk', out=out2)
view = Viewer('result.vtk')
view(is_wireframe=True, rel_scaling=1, is_scalar_bar=True)
t.reset()
s.reset()
return F
def main():
parser = OptionParser(usage=usage, version="%prog " + sfepy.__version__)
parser.add_option(
"-c",
"--conf",
metavar='"key : value, ..."',
action="store",
dest="conf",
type="string",
default=None,
help=help["conf"],
)
parser.add_option(
"-O",
"--options",
metavar='"key : value, ..."',
action="store",
dest="app_options",
type="string",
default=None,
help=help["options"],
)
parser.add_option(
"-d",
"--define",
metavar='"key : value, ..."',
action="store",
dest="define_args",
type="string",
default=None,
help=help["define"],
)
parser.add_option(
"-o", "", metavar="filename", action="store", dest="output_filename_trunk", default=None, help=help["filename"]
)
parser.add_option(
"", "--format", metavar="format", action="store", dest="output_format", default=None, help=help["output_format"]
)
parser.add_option("", "--log", metavar="file", action="store", dest="log", default=None, help=help["log"])
parser.add_option("-q", "--quiet", action="store_true", dest="quiet", default=False, help=help["quiet"])
parser.add_option("", "--save-ebc", action="store_true", dest="save_ebc", default=False, help=help["save_ebc"])
parser.add_option(
"", "--save-ebc-nodes", action="store_true", dest="save_ebc_nodes", default=False, help=help["save_ebc_nodes"]
)
parser.add_option(
"", "--save-regions", action="store_true", dest="save_regions", default=False, help=help["save_regions"]
)
parser.add_option(
"",
"--save-regions-as-groups",
action="store_true",
dest="save_regions_as_groups",
default=False,
help=help["save_regions_as_groups"],
)
parser.add_option(
"",
"--save-field-meshes",
action="store_true",
dest="save_field_meshes",
default=False,
help=help["save_field_meshes"],
)
parser.add_option("", "--solve-not", action="store_true", dest="solve_not", default=False, help=help["solve_not"])
parser.add_option("", "--list", metavar="what", action="store", dest="_list", default=None, help=help["list"])
options, args = parser.parse_args()
if len(args) == 1:
filename_in = args[0]
else:
if options._list == "terms":
print_terms()
else:
parser.print_help(),
return
output.set_output(filename=options.log, quiet=options.quiet, combined=options.log is not None)
required, other = get_standard_keywords()
if options.solve_not:
required.remove("equations")
required.remove("solver_[0-9]+|solvers")
other.extend(["equations"])
conf = ProblemConf.from_file_and_options(filename_in, options, required, other, define_args=options.define_args)
opts = conf.options
output_prefix = opts.get("output_prefix", "sfepy:")
app = PDESolverApp(conf, options, output_prefix)
if hasattr(opts, "parametric_hook"): # Parametric study.
parametric_hook = conf.get_function(opts.parametric_hook)
app.parametrize(parametric_hook)
app()
def init_session(ipython=None, message=None, quiet=False, silent=False,
is_viewer=True, is_wx=True, argv=[]):
"""
Initialize embedded IPython or Python session.
"""
import os, sys, atexit
in_ipython = False
is_runsource = True
_preexec_source = preexec_source
if is_viewer:
_preexec_source += preexec_source_viewer
if ipython is False:
ip = _init_python_session()
mainloop = ip.interact
else:
try:
import IPython
except ImportError:
if ipython is not True:
print no_ipython
ip = _init_python_session()
mainloop = ip.interact
else:
raise RuntimeError('IPython is not available on this system')
else:
ipython = True
if IPython.__version__ >= '0.11':
try:
ip = get_ipython()
except NameError:
ip = None
else:
ip = IPython.ipapi.get()
if ip:
ip = ip.IP
if ip is not None:
in_ipython = True
else:
ip = _init_ipython_session(is_wx, _preexec_source, argv)
if IPython.__version__ >= '0.11':
# runsource is gone, use run_cell instead, which doesn't
# take a symbol arg. The second arg is `store_history`,
# and False means don't add the line to IPython's history.
ip.runsource = lambda src, symbol='exec': \
ip.run_cell(src, False)
mainloop = ip.mainloop
else:
if is_wx:
mainloop = ip.mainloop
is_runsource = False
else:
mainloop = ip.interact
if is_runsource:
ip.runsource(_preexec_source, symbol='exec')
message = _make_message(ipython, quiet, _preexec_source)
output.set_output(filename=os.path.join(sfepy_config_dir, 'isfepy.log'),
combined=silent == False,
append=True)
atexit.register(output, 'isfepy finished\n' + '*' * 55)
if not in_ipython:
if is_runsource:
mainloop(message)
else:
mainloop(banner=message)
sys.exit('Exiting ...')
else:
ip.write(message)
ip.set_hook('shutdown_hook', lambda ip: ip.write('Exiting ...\n'))
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='11,11,11',
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('-2',
'--2d',
action='store_true',
dest='is_2d',
default=False,
help=helps['2d'])
parser.add_argument('--u-order',
metavar='int',
type=int,
action='store',
dest='order_u',
default=1,
help=helps['u-order'])
parser.add_argument('--p-order',
metavar='int',
type=int,
action='store',
dest='order_p',
default=1,
help=helps['p-order'])
parser.add_argument('--linearization',
choices=['strip', 'adaptive'],
action='store',
dest='linearization',
default='strip',
help=helps['linearization'])
parser.add_argument('--metis',
action='store_true',
dest='metis',
default=False,
help=helps['metis'])
parser.add_argument('--silent',
action='store_true',
dest='silent',
default=False,
help=helps['silent'])
parser.add_argument('--clear',
action='store_true',
dest='clear',
default=False,
help=helps['clear'])
options, petsc_opts = parser.parse_known_args()
comm = pl.PETSc.COMM_WORLD
output_dir = options.output_dir
filename = os.path.join(output_dir, 'output_log_%02d.txt' % comm.rank)
if comm.rank == 0:
ensure_path(filename)
comm.barrier()
output.prefix = 'sfepy_%02d:' % comm.rank
output.set_output(filename=filename, combined=options.silent == False)
output('petsc options:', petsc_opts)
mesh_filename = os.path.join(options.output_dir, 'para.h5')
if comm.rank == 0:
from sfepy.mesh.mesh_generators import gen_block_mesh
if options.clear:
for _f in chain(*[
glob.glob(os.path.join(output_dir, clean_pattern))
for clean_pattern in ['*.h5', '*.txt', '*.png']
]):
output('removing "%s"' % _f)
os.remove(_f)
dim = 2 if options.is_2d else 3
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)
mesh = gen_block_mesh(dims,
shape,
centre,
name='block-fem',
verbose=True)
mesh.write(mesh_filename, io='auto')
comm.barrier()
output('field u order:', options.order_u)
output('field p order:', options.order_p)
solve_problem(mesh_filename, options, comm)
)
from sfepy.terms import Term
from sfepy.discrete.conditions import Conditions, EssentialBC, PeriodicBC
from sfepy.solvers.ls import ScipyDirect
from sfepy.solvers.nls import Newton
import sfepy.discrete.fem.periodic as per
from sfepy.discrete import Functions
from sfepy.mesh.mesh_generators import gen_block_mesh
from sfepy.mechanics.matcoefs import ElasticConstants
from sfepy.base.base import output
from sfepy.discrete.conditions import LinearCombinationBC
from sfepy.mechanics.matcoefs import stiffness_from_lame
goptions["verbose"] = False
output.set_output(quiet=True)
def sequence(*args):
"""Compose functions in order
Args:
args: the functions to compose
Returns:
composed functions
"""
return compose(*args[::-1])
def main():
parser = OptionParser(usage = usage, version = "%prog " + sfepy.__version__)
parser.add_option('-c', '--conf', metavar='"key : value, ..."',
action='store', dest='conf', type='string',
default=None, help= help['conf'])
parser.add_option('-O', '--options', metavar='"key : value, ..."',
action='store', dest='app_options', type='string',
default=None, help=help['options'])
parser.add_option('-d', '--define', metavar='"key : value, ..."',
action='store', dest='define_args', type='string',
default=None, help=help['define'])
parser.add_option( "-o", "", metavar = 'filename',
action = "store", dest = "output_filename_trunk",
default = None, help = help['filename'] )
parser.add_option( "", "--format", metavar = 'format',
action = "store", dest = "output_format",
default = None, help = help['output_format'] )
parser.add_option( "", "--log", metavar = 'file',
action = "store", dest = "log",
default = None, help = help['log'] )
parser.add_option( "-q", "--quiet",
action = "store_true", dest = "quiet",
default = False, help = help['quiet'] )
parser.add_option( "", "--save-ebc",
action = "store_true", dest = "save_ebc",
default = False, help = help['save_ebc'] )
parser.add_option( "", "--save-regions",
action = "store_true", dest = "save_regions",
default = False, help = help['save_regions'] )
parser.add_option( "", "--save-regions-as-groups",
action = "store_true", dest = "save_regions_as_groups",
default = False, help = help['save_regions_as_groups'] )
parser.add_option( "", "--save-field-meshes",
action = "store_true", dest = "save_field_meshes",
default = False, help = help['save_field_meshes'] )
parser.add_option( "", "--solve-not",
action = "store_true", dest = "solve_not",
default = False, help = help['solve_not'] )
parser.add_option( "", "--list", metavar = 'what',
action = "store", dest = "_list",
default = None, help = help['list'] )
options, args = parser.parse_args()
if (len( args ) == 1):
filename_in = args[0];
else:
if options._list == 'terms':
print_terms()
else:
parser.print_help(),
return
output.set_output(filename=options.log,
quiet=options.quiet,
combined=options.log is not None)
required, other = get_standard_keywords()
if options.solve_not:
required.remove( 'equations' )
required.remove( 'solver_[0-9]+|solvers' )
other.extend( ['equations'] )
conf = ProblemConf.from_file_and_options(filename_in, options,
required, other,
define_args=options.define_args)
opts = conf.options
output_prefix = get_default_attr( opts, 'output_prefix', 'sfepy:' )
app = SimpleApp( conf, options, output_prefix )
if hasattr( opts, 'parametric_hook' ): # Parametric study.
parametric_hook = conf.get_function(opts.parametric_hook)
app.parametrize( parametric_hook )
app()
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='11,11,11', 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('-2', '--2d',
action='store_true', dest='is_2d',
default=False, help=helps['2d'])
parser.add_argument('--u-order', metavar='int', type=int,
action='store', dest='order_u',
default=1, help=helps['u-order'])
parser.add_argument('--p-order', metavar='int', type=int,
action='store', dest='order_p',
default=1, help=helps['p-order'])
parser.add_argument('--linearization', choices=['strip', 'adaptive'],
action='store', dest='linearization',
default='strip', help=helps['linearization'])
parser.add_argument('--metis',
action='store_true', dest='metis',
default=False, help=helps['metis'])
parser.add_argument('--silent',
action='store_true', dest='silent',
default=False, help=helps['silent'])
parser.add_argument('--clear',
action='store_true', dest='clear',
default=False, help=helps['clear'])
options, petsc_opts = parser.parse_known_args()
comm = pl.PETSc.COMM_WORLD
output_dir = options.output_dir
filename = os.path.join(output_dir, 'output_log_%02d.txt' % comm.rank)
if comm.rank == 0:
ensure_path(filename)
comm.barrier()
output.prefix = 'sfepy_%02d:' % comm.rank
output.set_output(filename=filename, combined=options.silent == False)
output('petsc options:', petsc_opts)
mesh_filename = os.path.join(options.output_dir, 'para.h5')
if comm.rank == 0:
from sfepy.mesh.mesh_generators import gen_block_mesh
if options.clear:
for _f in chain(*[glob.glob(os.path.join(output_dir, clean_pattern))
for clean_pattern
in ['*.h5', '*.txt', '*.png']]):
output('removing "%s"' % _f)
os.remove(_f)
dim = 2 if options.is_2d else 3
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)
mesh = gen_block_mesh(dims, shape, centre, name='block-fem',
verbose=True)
mesh.write(mesh_filename, io='auto')
comm.barrier()
output('field u order:', options.order_u)
output('field p order:', options.order_p)
solve_problem(mesh_filename, options, comm)
def main():
# if multi_mpi.cpu_count() < 2:
# raise ValueError('MPI mode - the number of nodes is less then 2!')
if multi_mpi.mpi_rank == multi_mpi.mpi_master:
# MPI master node - solve problem at macro scale
parser = ArgumentParser(description=__doc__,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('--debug',
action='store_true',
dest='debug',
default=False,
help=helps['debug'])
parser.add_argument('--debug_mpi',
action='store_true',
dest='debug_mpi',
default=False,
help=helps['debug_mpi'])
parser.add_argument('-c',
'--conf',
metavar='"key : value, ..."',
action='store',
dest='conf',
type=str,
default=None,
help=helps['conf'])
parser.add_argument('-O',
'--options',
metavar='"key : value, ..."',
action='store',
dest='app_options',
type=str,
default=None,
help=helps['options'])
parser.add_argument('-d',
'--define',
metavar='"key : value, ..."',
action='store',
dest='define_args',
type=str,
default=None,
help=helps['define'])
parser.add_argument('-o',
metavar='filename',
action='store',
dest='output_filename_trunk',
default=None,
help=helps['filename'])
parser.add_argument('--format',
metavar='format',
action='store',
dest='output_format',
default=None,
help=helps['output_format'])
parser.add_argument('--log',
metavar='file',
action='store',
dest='log',
default=None,
help=helps['log'])
parser.add_argument('-q',
'--quiet',
action='store_true',
dest='quiet',
default=False,
help=helps['quiet'])
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument('filename_in', nargs='?')
options = parser.parse_args()
for k in [
'save_ebc', 'save_ebc_nodes', 'save_regions',
'save_regions_as_groups', 'save_field_meshes', 'solve_not'
]:
setattr(options, k, False)
if options.debug:
from sfepy.base.base import debug_on_error
debug_on_error()
if options.debug_mpi:
multi_mpi.set_logging_level('debug')
filename_in = options.filename_in
output.set_output(filename=options.log,
quiet=options.quiet,
combined=options.log is not None)
required, other = get_standard_keywords()
conf = ProblemConf.from_file_and_options(
filename_in,
options,
required,
other,
define_args=options.define_args)
opts = conf.options
nslaves = multi_mpi.cpu_count() - 1
opts.n_mpi_homog_slaves = nslaves
output_prefix = opts.get('output_prefix', 'sfepy:')
app = PDESolverApp(conf, options, output_prefix)
if hasattr(opts, 'parametric_hook'): # Parametric study.
parametric_hook = conf.get_function(opts.parametric_hook)
app.parametrize(parametric_hook)
app()
multi_mpi.master_send_task('finalize', None)
else:
# MPI slave mode - calculate homogenized coefficients
homogen_app = None
done = False
rank = multi_mpi.mpi_rank
while not done:
task, data = multi_mpi.slave_get_task('main slave loop')
if task == 'init': # data: micro_file, n_micro
output.set_output(filename='homog_app_mpi_%d.log' % rank,
quiet=True)
micro_file, n_micro = data[:2]
required, other = get_standard_keywords()
required.remove('equations')
conf = ProblemConf.from_file(micro_file,
required,
other,
verbose=False)
options = Struct(output_filename_trunk=None)
homogen_app = HomogenizationApp(conf,
options,
'micro:',
n_micro=n_micro)
elif task == 'calculate': # data: rel_def_grad, ts, iteration
macro_data, ts, iteration = data[:3]
homogen_app.setup_macro_data(macro_data)
homogen_app(ret_all=True, itime=ts.step, iiter=iteration)
elif task == 'finalize':
done = True
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='11,11,11', 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('-2', '--2d',
action='store_true', dest='is_2d',
default=False, help=helps['2d'])
parser.add_argument('--u-order', metavar='int', type=int,
action='store', dest='order_u',
default=1, help=helps['u-order'])
parser.add_argument('--p-order', metavar='int', type=int,
action='store', dest='order_p',
default=1, help=helps['p-order'])
parser.add_argument('--linearization', choices=['strip', 'adaptive'],
action='store', dest='linearization',
default='strip', help=helps['linearization'])
parser.add_argument('--metis',
action='store_true', dest='metis',
default=False, help=helps['metis'])
parser.add_argument('--save-inter-regions',
action='store_true', dest='save_inter_regions',
default=False, help=helps['save_inter_regions'])
parser.add_argument('--stats', metavar='filename',
action='store', dest='stats_filename',
default=None, help=helps['stats_filename'])
parser.add_argument('--new-stats',
action='store_true', dest='new_stats',
default=False, help=helps['new_stats'])
parser.add_argument('--silent',
action='store_true', dest='silent',
default=False, help=helps['silent'])
parser.add_argument('--clear',
action='store_true', dest='clear',
default=False, help=helps['clear'])
options, petsc_opts = parser.parse_known_args()
comm = pl.PETSc.COMM_WORLD
output_dir = options.output_dir
filename = os.path.join(output_dir, 'output_log_%02d.txt' % comm.rank)
if comm.rank == 0:
ensure_path(filename)
comm.barrier()
output.prefix = 'sfepy_%02d:' % comm.rank
output.set_output(filename=filename, combined=options.silent == False)
output('petsc options:', petsc_opts)
mesh_filename = os.path.join(options.output_dir, 'para.h5')
dim = 2 if options.is_2d else 3
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)
if comm.rank == 0:
from sfepy.mesh.mesh_generators import gen_block_mesh
if options.clear:
remove_files_patterns(output_dir,
['*.h5', '*.mesh', '*.txt'],
ignores=['output_log_%02d.txt' % ii
for ii in range(comm.size)],
verbose=True)
save_options(os.path.join(output_dir, 'options.txt'),
[('options', vars(options))])
mesh = gen_block_mesh(dims, shape, centre, name='block-fem',
verbose=True)
mesh.write(mesh_filename, io='auto')
comm.barrier()
output('field u order:', options.order_u)
output('field p order:', options.order_p)
stats = solve_problem(mesh_filename, options, comm)
output(stats)
if options.stats_filename:
from examples.diffusion.poisson_parallel_interactive import save_stats
if comm.rank == 0:
ensure_path(options.stats_filename)
comm.barrier()
pars = Struct(dim=dim, shape=shape, order=options.order_u)
pl.call_in_rank_order(
lambda rank, comm:
save_stats(options.stats_filename, pars, stats, options.new_stats,
rank, comm),
comm
)
import scipy.sparse.linalg as sla
import matplotlib.pyplot as plt
sys.path.append('/home/bbales2/sfepy/')
from sfepy.base.base import assert_, output, Struct
from sfepy.discrete import (FieldVariable, Material, Integral, Integrals,
Equation, Equations, Problem)
from sfepy.discrete.fem import Mesh, FEDomain, Field
from sfepy.terms import Term
from sfepy.discrete.conditions import Conditions, EssentialBC
from sfepy.mechanics.matcoefs import stiffness_from_youngpoisson
from sfepy.mesh.mesh_generators import gen_block_mesh
from sfepy.solvers import Solver
from sfepy.base.base import output
output.set_output(quiet=True)
import numpy
import scipy
aux = "eig.scipy,method:'eigh',tol:1e-7,maxiter:10000".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)
dims = nm.array([1.0, 1.5], dtype=nm.float64)
dim = len(dims)
centre = nm.array([0.0, 0.0], dtype=nm.float64)[:dim]
shape = nm.array([11, 16], dtype=nm.int32)[:dim]
def main():
parser = ArgumentParser(description=__doc__,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('--version',
action='version',
version='%(prog)s ' + sfepy.__version__)
parser.add_argument('--debug',
action='store_true',
dest='debug',
default=False,
help=helps['debug'])
parser.add_argument('-c',
'--conf',
metavar='"key : value, ..."',
action='store',
dest='conf',
type=str,
default=None,
help=helps['conf'])
parser.add_argument('-O',
'--options',
metavar='"key : value, ..."',
action='store',
dest='app_options',
type=str,
default=None,
help=helps['options'])
parser.add_argument('-d',
'--define',
metavar='"key : value, ..."',
action='store',
dest='define_args',
type=str,
default=None,
help=helps['define'])
parser.add_argument('-o',
metavar='filename',
action='store',
dest='output_filename_trunk',
default=None,
help=helps['filename'])
parser.add_argument('--format',
metavar='format',
action='store',
dest='output_format',
default=None,
help=helps['output_format'])
parser.add_argument('--save-restart',
metavar='mode',
type=int,
action='store',
dest='save_restart',
default=None,
help=helps['save_restart'])
parser.add_argument('--load-restart',
metavar='filename',
action='store',
dest='load_restart',
default=None,
help=helps['load_restart'])
parser.add_argument('--log',
metavar='file',
action='store',
dest='log',
default=None,
help=helps['log'])
parser.add_argument('-q',
'--quiet',
action='store_true',
dest='quiet',
default=False,
help=helps['quiet'])
parser.add_argument('--save-ebc',
action='store_true',
dest='save_ebc',
default=False,
help=helps['save_ebc'])
parser.add_argument('--save-ebc-nodes',
action='store_true',
dest='save_ebc_nodes',
default=False,
help=helps['save_ebc_nodes'])
parser.add_argument('--save-regions',
action='store_true',
dest='save_regions',
default=False,
help=helps['save_regions'])
parser.add_argument('--save-regions-as-groups',
action='store_true',
dest='save_regions_as_groups',
default=False,
help=helps['save_regions_as_groups'])
parser.add_argument('--save-field-meshes',
action='store_true',
dest='save_field_meshes',
default=False,
help=helps['save_field_meshes'])
parser.add_argument('--solve-not',
action='store_true',
dest='solve_not',
default=False,
help=helps['solve_not'])
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument('--list',
metavar='what',
action='store',
dest='_list',
default=None,
help=helps['list'])
group.add_argument('filename_in', nargs='?')
options, petsc_opts = parser.parse_known_args()
if options._list is not None:
if options._list == 'terms':
print_terms()
elif options._list == 'solvers':
print_solvers()
return
if options.debug:
from sfepy.base.base import debug_on_error
debug_on_error()
filename_in = options.filename_in
output.set_output(filename=options.log,
quiet=options.quiet,
combined=options.log is not None)
required, other = get_standard_keywords()
if options.solve_not:
required.remove('equations')
required.remove('solver_[0-9]+|solvers')
other.extend(['equations'])
conf = ProblemConf.from_file_and_options(filename_in,
options,
required,
other,
define_args=options.define_args)
opts = conf.options
output_prefix = opts.get('output_prefix', 'sfepy:')
opts.save_restart = options.save_restart
opts.load_restart = options.load_restart
if conf.options.get('evps') is None:
app = PDESolverApp(conf, options, output_prefix)
else:
app = EVPSolverApp(conf, options, output_prefix)
if hasattr(opts, 'parametric_hook'): # Parametric study.
parametric_hook = conf.get_function(opts.parametric_hook)
app.parametrize(parametric_hook)
app()
def recover_micro_hook(micro_filename, region, macro,
naming_scheme='step_iel',
recovery_file_tag='',
define_args=None, verbose=False):
# Create a micro-problem instance.
required, other = get_standard_keywords()
required.remove('equations')
conf = ProblemConf.from_file(micro_filename, required, other,
verbose=False, define_args=define_args)
coefs_filename = conf.options.get('coefs_filename', 'coefs')
output_dir = conf.options.get('output_dir', '.')
coefs_filename = op.join(output_dir, coefs_filename) + '.h5'
# Coefficients and correctors
coefs = Coefficients.from_file_hdf5(coefs_filename)
corrs = get_correctors_from_file(dump_names=coefs.dump_names)
recovery_hook = conf.options.get('recovery_hook', None)
if recovery_hook is not None:
recovery_hook = conf.get_function(recovery_hook)
pb = Problem.from_conf(conf, init_equations=False, init_solvers=False)
format = get_print_info(pb.domain.mesh.n_el, fill='0')[1]
output('recovering microsctructures...')
tt = time.clock()
output_fun = output.output_function
output_level = output.level
for ii, iel in enumerate(region.cells):
output.level = output_level
output('micro: %d (el=%d)' % (ii, iel))
local_macro = {}
for k, v in six.iteritems(macro):
local_macro[k] = v[ii, 0]
output.set_output(quiet=not(verbose))
out = recovery_hook(pb, corrs, local_macro)
output.output_function = output_fun
if ii == 0:
new_keys = []
new_data = {}
new_idxs = []
for k in six.iterkeys(local_macro):
if k not in macro:
new_keys.append(k)
new_data[k] = []
new_idxs.append(ii)
for jj in new_keys:
new_data[jj].append(local_macro[jj])
# save data
if out is not None:
suffix = format % iel
micro_name = pb.get_output_name(extra='recovered_'
+ recovery_file_tag + suffix)
filename = op.join(output_dir, op.basename(micro_name))
fpv = pb.conf.options.get('file_per_var', False)
pb.save_state(filename, out=out,
file_per_var=fpv)
output('...done in %.2f s' % (time.clock() - tt))
for jj in new_keys:
lout = new_data[jj]
macro[jj] = nm.zeros((nm.max(new_idxs) + 1, 1) + lout[0].shape,
dtype=lout[0].dtype)
out = macro[jj]
for kk, ii in enumerate(new_idxs):
out[ii, 0] = lout[kk]
def main():
# Aluminium and epoxy.
default_pars = '70e9,0.35,2.799e3, 3.8e9,0.27,1.142e3'
default_solver_conf = ("kind='eig.scipy',method='eigsh',tol=1.0e-5,"
"maxiter=1000,which='LM',sigma=0.0")
parser = ArgumentParser(description=__doc__,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('--pars', metavar='young1,poisson1,density1'
',young2,poisson2,density2',
action='store', dest='pars',
default=default_pars, help=helps['pars'])
parser.add_argument('--conf', metavar='filename',
action='store', dest='conf',
default=None, help=helps['conf'])
parser.add_argument('--define-kwargs', metavar='dict-like',
action='store', dest='define_kwargs',
default=None, help=helps['define_kwargs'])
parser.add_argument('--mesh-size', type=float, metavar='float',
action='store', dest='mesh_size',
default=None, help=helps['mesh_size'])
parser.add_argument('--unit-multipliers',
metavar='c_time,c_length,c_mass',
action='store', dest='unit_multipliers',
default='1.0,1.0,1.0', help=helps['unit_multipliers'])
parser.add_argument('--plane', action='store', dest='plane',
choices=['strain', 'stress'],
default='strain', help=helps['plane'])
parser.add_argument('--wave-dir', metavar='float,float[,float]',
action='store', dest='wave_dir',
default='1.0,0.0,0.0', help=helps['wave_dir'])
parser.add_argument('--mode', action='store', dest='mode',
choices=['omega', 'kappa'],
default='omega', help=helps['mode'])
parser.add_argument('--stepper', action='store', dest='stepper',
choices=['linear', 'brillouin'],
default='linear', help=helps['stepper'])
parser.add_argument('--range', metavar='start,stop,count',
action='store', dest='range',
default='0,6.4,33', help=helps['range'])
parser.add_argument('--order', metavar='int', type=int,
action='store', dest='order',
default=1, help=helps['order'])
parser.add_argument('--refine', metavar='int', type=int,
action='store', dest='refine',
default=0, help=helps['refine'])
parser.add_argument('-n', '--n-eigs', metavar='int', type=int,
action='store', dest='n_eigs',
default=6, help=helps['n_eigs'])
group = parser.add_mutually_exclusive_group()
group.add_argument('--eigs-only',
action='store_true', dest='eigs_only',
default=False, help=helps['eigs_only'])
group.add_argument('--post-process',
action='store_true', dest='post_process',
default=False, help=helps['post_process'])
parser.add_argument('--solver-conf', metavar='dict-like',
action='store', dest='solver_conf',
default=default_solver_conf, help=helps['solver_conf'])
parser.add_argument('--save-regions',
action='store_true', dest='save_regions',
default=False, help=helps['save_regions'])
parser.add_argument('--save-materials',
action='store_true', dest='save_materials',
default=False, help=helps['save_materials'])
parser.add_argument('--log-std-waves',
action='store_true', dest='log_std_waves',
default=False, help=helps['log_std_waves'])
parser.add_argument('--no-legends',
action='store_false', dest='show_legends',
default=True, help=helps['no_legends'])
parser.add_argument('--no-show',
action='store_false', dest='show',
default=True, help=helps['no_show'])
parser.add_argument('--silent',
action='store_true', dest='silent',
default=False, help=helps['silent'])
parser.add_argument('-c', '--clear',
action='store_true', dest='clear',
default=False, help=helps['clear'])
parser.add_argument('-o', '--output-dir', metavar='path',
action='store', dest='output_dir',
default='output', help=helps['output_dir'])
parser.add_argument('mesh_filename', default='',
help=helps['mesh_filename'])
options = parser.parse_args()
output_dir = options.output_dir
output.set_output(filename=os.path.join(output_dir,'output_log.txt'),
combined=options.silent == False)
if options.conf is not None:
mod = import_file(options.conf)
else:
mod = sys.modules[__name__]
apply_units = mod.apply_units
define = mod.define
set_wave_dir = mod.set_wave_dir
setup_n_eigs = mod.setup_n_eigs
build_evp_matrices = mod.build_evp_matrices
save_materials = mod.save_materials
get_std_wave_fun = mod.get_std_wave_fun
get_stepper = mod.get_stepper
process_evp_results = mod.process_evp_results
options.pars = [float(ii) for ii in options.pars.split(',')]
options.unit_multipliers = [float(ii)
for ii in options.unit_multipliers.split(',')]
options.wave_dir = [float(ii)
for ii in options.wave_dir.split(',')]
aux = options.range.split(',')
options.range = [float(aux[0]), float(aux[1]), int(aux[2])]
options.solver_conf = dict_from_string(options.solver_conf)
options.define_kwargs = dict_from_string(options.define_kwargs)
if options.clear:
remove_files_patterns(output_dir,
['*.h5', '*.vtk', '*.txt'],
ignores=['output_log.txt'],
verbose=True)
filename = os.path.join(output_dir, 'options.txt')
ensure_path(filename)
save_options(filename, [('options', vars(options))],
quote_command_line=True)
pars = apply_units(options.pars, options.unit_multipliers)
output('material parameters with applied unit multipliers:')
output(pars)
if options.mode == 'omega':
rng = copy(options.range)
rng[:2] = apply_unit_multipliers(options.range[:2],
['wave_number', 'wave_number'],
options.unit_multipliers)
output('wave number range with applied unit multipliers:', rng)
else:
if options.stepper == 'brillouin':
raise ValueError('Cannot use "brillouin" stepper in kappa mode!')
rng = copy(options.range)
rng[:2] = apply_unit_multipliers(options.range[:2],
['frequency', 'frequency'],
options.unit_multipliers)
output('frequency range with applied unit multipliers:', rng)
pb, wdir, bzone, mtxs = assemble_matrices(define, mod, pars, set_wave_dir,
options)
dim = pb.domain.shape.dim
if dim != 2:
options.plane = 'strain'
if options.save_regions:
pb.save_regions_as_groups(os.path.join(output_dir, 'regions'))
if options.save_materials:
save_materials(output_dir, pb, options)
conf = pb.solver_confs['eig']
eig_solver = Solver.any_from_conf(conf)
n_eigs, options.n_eigs = setup_n_eigs(options, pb, mtxs)
get_color = lambda ii: plt.cm.viridis((float(ii) / (options.n_eigs - 1)))
plot_kwargs = [{'color' : get_color(ii), 'ls' : '', 'marker' : 'o'}
for ii in range(options.n_eigs)]
get_color_dim = lambda ii: plt.cm.viridis((float(ii) / (dim-1)))
plot_kwargs_dim = [{'color' : get_color_dim(ii), 'ls' : '', 'marker' : 'o'}
for ii in range(dim)]
log_names = []
log_plot_kwargs = []
if options.log_std_waves:
std_wave_fun, log_names, log_plot_kwargs = get_std_wave_fun(
pb, options)
else:
std_wave_fun = None
stepper = get_stepper(rng, pb, options)
if options.mode == 'omega':
eigenshapes_filename = os.path.join(output_dir,
'frequency-eigenshapes-%s.vtk'
% stepper.suffix)
if options.stepper == 'linear':
log = Log([[r'$\lambda_{%d}$' % ii for ii in range(options.n_eigs)],
[r'$\omega_{%d}$'
% ii for ii in range(options.n_eigs)] + log_names],
plot_kwargs=[plot_kwargs, plot_kwargs + log_plot_kwargs],
formats=[['{:.5e}'] * options.n_eigs,
['{:.5e}'] * (options.n_eigs + len(log_names))],
yscales=['linear', 'linear'],
xlabels=[r'$\kappa$', r'$\kappa$'],
ylabels=[r'eigenvalues $\lambda_i$',
r'frequencies $\omega_i$'],
show_legends=options.show_legends,
is_plot=options.show,
log_filename=os.path.join(output_dir, 'frequencies.txt'),
aggregate=1000, sleep=0.1)
else:
log = Log([[r'$\kappa_{%d}$'% ii for ii in range(dim)],
[r'$\omega_{%d}$'
% ii for ii in range(options.n_eigs)] + log_names],
plot_kwargs=[plot_kwargs_dim,
plot_kwargs + log_plot_kwargs],
formats=[['{:.5e}'] * dim,
['{:.5e}'] * (options.n_eigs + len(log_names))],
yscales=['linear', 'linear'],
xlabels=[r'', r''],
ylabels=[r'wave vector $\kappa$',
r'frequencies $\omega_i$'],
show_legends=options.show_legends,
is_plot=options.show,
log_filename=os.path.join(output_dir, 'frequencies.txt'),
aggregate=1000, sleep=0.1)
for aux in stepper:
if options.stepper == 'linear':
iv, wmag = aux
else:
iv, wmag, wdir = aux
output('step %d: wave vector %s' % (iv, wmag * wdir))
if options.stepper == 'brillouin':
pb, _, bzone, mtxs = assemble_matrices(
define, mod, pars, set_wave_dir, options, wdir=wdir)
evp_mtxs = build_evp_matrices(mtxs, wmag, options.mode, pb)
if options.eigs_only:
eigs = eig_solver(*evp_mtxs, n_eigs=n_eigs,
eigenvectors=False)
svecs = None
else:
eigs, svecs = eig_solver(*evp_mtxs, n_eigs=n_eigs,
eigenvectors=True)
omegas, svecs, out = process_evp_results(
eigs, svecs, wmag, wdir, bzone, pb, mtxs, options,
std_wave_fun=std_wave_fun
)
if options.stepper == 'linear':
log(*out, x=[wmag, wmag])
else:
log(*out, x=[iv, iv])
save_eigenvectors(eigenshapes_filename % iv, svecs, wmag, wdir, pb)
gc.collect()
log(save_figure=os.path.join(output_dir, 'frequencies.png'))
log(finished=True)
else:
eigenshapes_filename = os.path.join(output_dir,
'wave-number-eigenshapes-%s.vtk'
% stepper.suffix)
log = Log([[r'$\kappa_{%d}$' % ii for ii in range(options.n_eigs)]
+ log_names],
plot_kwargs=[plot_kwargs + log_plot_kwargs],
formats=[['{:.5e}'] * (options.n_eigs + len(log_names))],
yscales=['linear'],
xlabels=[r'$\omega$'],
ylabels=[r'wave numbers $\kappa_i$'],
show_legends=options.show_legends,
is_plot=options.show,
log_filename=os.path.join(output_dir, 'wave-numbers.txt'),
aggregate=1000, sleep=0.1)
for io, omega in stepper:
output('step %d: frequency %s' % (io, omega))
evp_mtxs = build_evp_matrices(mtxs, omega, options.mode, pb)
if options.eigs_only:
eigs = eig_solver(*evp_mtxs, n_eigs=n_eigs,
eigenvectors=False)
svecs = None
else:
eigs, svecs = eig_solver(*evp_mtxs, n_eigs=n_eigs,
eigenvectors=True)
kappas, svecs, out = process_evp_results(
eigs, svecs, omega, wdir, bzone, pb, mtxs, options,
std_wave_fun=std_wave_fun
)
log(*out, x=[omega])
save_eigenvectors(eigenshapes_filename % io, svecs, kappas, wdir,
pb)
gc.collect()
log(save_figure=os.path.join(output_dir, 'wave-numbers.png'))
log(finished=True)
def init_session(ipython=None,
message=None,
quiet=False,
silent=False,
is_viewer=True,
is_wx=True,
argv=[]):
"""
Initialize embedded IPython or Python session.
"""
import os, sys, atexit
in_ipython = False
is_runsource = True
_preexec_source = preexec_source
if is_viewer:
_preexec_source += preexec_source_viewer
if ipython is False:
ip = _init_python_session()
mainloop = ip.interact
else:
try:
import IPython
except ImportError:
if ipython is not True:
print no_ipython
ip = _init_python_session()
mainloop = ip.interact
else:
raise RuntimeError('IPython is not available on this system')
else:
ipython = True
if IPython.__version__ >= '0.11':
try:
ip = get_ipython()
except NameError:
ip = None
else:
ip = IPython.ipapi.get()
if ip:
ip = ip.IP
if ip is not None:
in_ipython = True
else:
ip = _init_ipython_session(is_wx, _preexec_source, argv)
if IPython.__version__ >= '0.11':
# runsource is gone, use run_cell instead, which doesn't
# take a symbol arg. The second arg is `store_history`,
# and False means don't add the line to IPython's history.
ip.runsource = lambda src, symbol='exec': \
ip.run_cell(src, False)
mainloop = ip.mainloop
else:
if is_wx:
mainloop = ip.mainloop
is_runsource = False
else:
mainloop = ip.interact
if is_runsource:
ip.runsource(_preexec_source, symbol='exec')
message = _make_message(ipython, quiet, _preexec_source)
output.set_output(filename=os.path.join(sfepy_config_dir, 'isfepy.log'),
combined=silent == False,
append=True)
atexit.register(output, 'isfepy finished\n' + '*' * 55)
if not in_ipython:
if is_runsource:
mainloop(message)
else:
mainloop(banner=message)
sys.exit('Exiting ...')
else:
ip.write(message)
ip.set_hook('shutdown_hook', lambda ip: ip.write('Exiting ...\n'))
