def from_file(filename,
required=None,
other=None,
verbose=True,
define_args=None,
override=None):
"""
Loads the problem definition from a file.
The filename can either contain plain definitions, or it can contain
the define() function, in which case it will be called to return the
input definitions.
The job of the define() function is to return a dictionary of
parameters. How the dictionary is constructed is not our business, but
the usual way is to simply have a function define() along these lines
in the input file::
def define():
options = {
'save_eig_vectors' : None,
'eigen_solver' : 'eigen1',
}
region_2 = {
'name' : 'Surface',
'select' : 'nodes of surface',
}
return locals()
Optionally, the define() function can accept additional arguments
that should be defined using the `define_args` tuple or dictionary.
"""
funmod = import_file(filename)
if "define" in funmod.__dict__:
if define_args is None:
define_dict = funmod.__dict__["define"]()
else:
if isinstance(define_args, str):
define_args = ProblemConf.dict_from_string(define_args)
if isinstance(define_args, dict):
define_dict = funmod.__dict__["define"](**define_args)
else:
define_dict = funmod.__dict__["define"](*define_args)
else:
define_dict = funmod.__dict__
obj = ProblemConf(define_dict, funmod, filename, required, other,
verbose, override)
return obj
def from_file(filename, required=None, other=None, verbose=True,
define_args=None, override=None, setup=True):
"""
Loads the problem definition from a file.
The filename can either contain plain definitions, or it can contain
the define() function, in which case it will be called to return the
input definitions.
The job of the define() function is to return a dictionary of
parameters. How the dictionary is constructed is not our business, but
the usual way is to simply have a function define() along these lines
in the input file::
def define():
options = {
'save_eig_vectors' : None,
'eigen_solver' : 'eigen1',
}
region_2 = {
'name' : 'Surface',
'select' : 'nodes of surface',
}
return locals()
Optionally, the define() function can accept additional arguments
that should be defined using the `define_args` tuple or dictionary.
"""
funmod = import_file(filename)
if "define" in funmod.__dict__:
if define_args is None:
define_dict = funmod.__dict__["define"]()
else:
if isinstance(define_args, str):
define_args = dict_from_string(define_args)
if isinstance(define_args, dict):
define_dict = funmod.__dict__["define"](**define_args)
else:
define_dict = funmod.__dict__["define"](*define_args)
else:
define_dict = funmod.__dict__
obj = ProblemConf(define_dict, funmod=funmod, filename=filename,
required=required, other=other, verbose=verbose,
override=override, setup=setup)
return obj
def load_coefs(filename):
coefs = Coefficients.from_file_hdf5(filename)
try:
options = import_file(coefs.filename).options
except:
options = None
if options is not None:
plot_info = options["plot_info"]
tex_names = options["tex_names"]
else:
plot_info = coefs.get("plot_info", {})
tex_names = coefs.get("tex_names", {})
return coefs, plot_info, tex_names
def load_coefs(filename):
coefs = Coefficients.from_file_hdf5(filename)
try:
options = import_file(coefs.filename).options
except:
options = None
if options is not None:
plot_info = options['plot_info']
tex_names = options['tex_names']
else:
plot_info = get_default_attr(coefs, 'plot_info', {})
tex_names = get_default_attr(coefs, 'tex_names', {})
return coefs, plot_info, tex_names
def load_coefs( filename ):
coefs = Coefficients.from_file_hdf5( filename )
try:
options = import_file( coefs.filename ).options
except:
options = None
if options is not None:
plot_info = options['plot_info']
tex_names = options['tex_names']
else:
plot_info = get_default_attr(coefs, 'plot_info', {})
tex_names = get_default_attr(coefs, 'tex_names', {})
return coefs, plot_info, tex_names
def __call__(self):
return ProblemConf.from_dict(self.conf.__dict__, import_file(__file__))
def generate_gallery_html(examples_dir, output_filename, gallery_dir,
rst_dir, thumbnails_dir, dir_map, link_prefix):
"""
Generate the gallery html file with thumbnail images and links to
examples.
Parameters
----------
output_filename : str
The output html file name.
gallery_dir : str
The top level directory of gallery files.
rst_dir : str
The full path to rst files of examples within `gallery_dir`.
thumbnails_dir : str
The full path to thumbnail images within `gallery_dir`.
dir_map : dict
The directory mapping returned by `generate_rst_files()`
link_prefix : str, optional
The prefix to prepend to links to individual pages of examples.
"""
output('generating %s...' % output_filename)
with open(_gallery_template_file, 'r') as fd:
gallery_template = fd.read()
div_lines=[]
sidebar = []
for dirname, filenames in ordered_iteritems(dir_map):
full_dirname = os.path.join(rst_dir, dirname)
dirnamenew = dirname.replace("_"," ")
sidebarline = _side_links % (dirname, dirnamenew.title())
lines = []
for ex_filename, rst_filename in filenames:
full_rst_filename = os.path.join(full_dirname, rst_filename)
ebase = full_rst_filename.replace(rst_dir, '')[1:]
ebase = edit_filename(ebase, new_ext='.py')
link_base = full_rst_filename.replace(gallery_dir, '')[1:]
link = os.path.join(link_prefix,
os.path.splitext(link_base)[0] + '.html')
_get_fig_filenames(ebase, thumbnails_dir).next()
for thumbnail_filename in _get_fig_filenames(ebase,
thumbnails_dir):
if not os.path.isfile(thumbnail_filename):
# Skip examples with no image (= failed examples).
continue
thumbnail_name = thumbnail_filename.replace(gallery_dir,
'')[1:]
path_to_file = os.path.join(examples_dir,ebase)
docstring = get_default(import_file(path_to_file).__doc__,
'missing description!')
docstring = docstring.replace('e.g.', 'eg:')
docstring = docstring.split('.')
line = _link_template % (link,os.path.splitext(ebase)[0],
thumbnail_name,link,docstring[0]+'.')
lines.append(line)
if(len(lines)!=0):
div_lines.append(_div_line % (dirname, dirnamenew.title(),
dirname, '\n'.join(lines)))
sidebar.append(sidebarline)
fd = open(output_filename, 'w')
fd.write(gallery_template % ((link_prefix,) * 7
+ ('\n'.join(sidebar), '\n'.join(div_lines))))
fd.close()
output('...done')
def generate_rst_files(rst_dir, examples_dir, images_dir):
"""
Generate Sphinx rst files for examples in `examples_dir` with images
in `images_dir` and put them into `rst_dir`.
Returns
-------
dir_map : dict
The directory mapping of examples and corresponding rst files.
"""
ensure_path(rst_dir + os.path.sep)
output('generating rst files...')
dir_map = {}
for ex_filename in locate_files('*.py', examples_dir):
if _omit(ex_filename): continue
ebase = ex_filename.replace(examples_dir, '')[1:]
base_dir = os.path.dirname(ebase)
rst_filename = os.path.basename(ex_filename).replace('.py', '.rst')
dir_map.setdefault(base_dir, []).append((ex_filename, rst_filename))
for dirname, filenames in dir_map.iteritems():
filenames = sorted(filenames, cmp=lambda a, b: cmp(a[1], b[1]))
dir_map[dirname ] = filenames
# Main index.
mfd = open(os.path.join(rst_dir, 'index.rst'), 'w')
mfd.write(_index % ('sfepy', 'Examples', '=' * 8))
for dirname, filenames in ordered_iteritems(dir_map):
full_dirname = os.path.join(rst_dir, dirname)
ensure_path(full_dirname + os.path.sep)
# Subdirectory index.
ifd = open(os.path.join(full_dirname, 'index.rst'), 'w')
ifd.write(_index % (dirname, dirname, '=' * len(dirname)))
for ex_filename, rst_filename in filenames:
full_rst_filename = os.path.join(full_dirname, rst_filename)
output('"%s"' % full_rst_filename.replace(rst_dir, '')[1:])
rst_filename_ns = rst_filename.replace('.rst', '')
ebase = ex_filename.replace(examples_dir, '')[1:]
rst_ex_filename = _make_sphinx_path(ex_filename)
docstring = get_default(import_file(ex_filename).__doc__,
'missing description!')
ifd.write(' %s\n' % rst_filename_ns)
fig_include = ''
fig_base = _get_fig_filenames(ebase, images_dir).next()
for fig_filename in _get_fig_filenames(ebase, images_dir):
rst_fig_filename = _make_sphinx_path(fig_filename)
if os.path.exists(fig_filename):
fig_include += _image % rst_fig_filename + '\n'
# Example rst file.
fd = open(full_rst_filename, 'w')
fd.write(_include % (fig_base, ebase, '=' * len(ebase),
docstring,
fig_include,
rst_ex_filename, rst_ex_filename))
fd.close()
ifd.close()
mfd.write(' %s/index\n' % dirname)
mfd.close()
output('...done')
return dir_map
def generate_gallery_html(examples_dir, output_filename, gallery_dir,
rst_dir, thumbnails_dir, dir_map, link_prefix):
"""
Generate the gallery html file with thumbnail images and links to
examples.
Parameters
----------
output_filename : str
The output html file name.
gallery_dir : str
The top level directory of gallery files.
rst_dir : str
The full path to rst files of examples within `gallery_dir`.
thumbnails_dir : str
The full path to thumbnail images within `gallery_dir`.
dir_map : dict
The directory mapping returned by `generate_rst_files()`
link_prefix : str, optional
The prefix to prepend to links to individual pages of examples.
"""
output('generating %s...' % output_filename)
with open(_gallery_template_file, 'r') as fd:
gallery_template = fd.read()
div_lines=[]
sidebar = []
for dirname, filenames in ordered_iteritems(dir_map):
full_dirname = os.path.join(rst_dir, dirname)
dirnamenew = dirname.replace("_"," ")
sidebarline = _side_links % (dirname, dirnamenew.title())
lines = []
for ex_filename, rst_filename in filenames:
full_rst_filename = os.path.join(full_dirname, rst_filename)
ebase = full_rst_filename.replace(rst_dir, '')[1:]
ebase = edit_filename(ebase, new_ext='.py')
link_base = full_rst_filename.replace(gallery_dir, '')[1:]
link = os.path.join(link_prefix,
os.path.splitext(link_base)[0] + '.html')
_get_fig_filenames(ebase, thumbnails_dir).next()
for thumbnail_filename in _get_fig_filenames(ebase,
thumbnails_dir):
if not os.path.isfile(thumbnail_filename):
# Skip examples with no image (= failed examples).
continue
thumbnail_name = thumbnail_filename.replace(gallery_dir,
'')[1:]
path_to_file = os.path.join(examples_dir,ebase)
docstring = get_default(import_file(path_to_file).__doc__,
'missing description!')
docstring = docstring.replace('e.g.', 'eg:')
docstring = docstring.split('.')
line = _link_template % (link,os.path.splitext(ebase)[0],
thumbnail_name,link,docstring[0]+'.')
lines.append(line)
if(len(lines)!=0):
div_lines.append(_div_line % (dirname, dirnamenew.title(),
dirname, '\n'.join(lines)))
sidebar.append(sidebarline)
fd = open(output_filename, 'w')
fd.write(gallery_template % ((link_prefix,) * 7
+ ('\n'.join(sidebar), '\n'.join(div_lines))))
fd.close()
output('...done')
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 generate_rst_files(rst_dir, examples_dir, images_dir):
"""
Generate Sphinx rst files for examples in `examples_dir` with images
in `images_dir` and put them into `rst_dir`.
Returns
-------
dir_map : dict
The directory mapping of examples and corresponding rst files.
"""
ensure_path(rst_dir + os.path.sep)
output("generating rst files...")
dir_map = {}
for ex_filename in locate_files("*.py", examples_dir):
if _omit(ex_filename):
continue
ebase = ex_filename.replace(examples_dir, "")[1:]
base_dir = os.path.dirname(ebase)
rst_filename = os.path.basename(ex_filename).replace(".py", ".rst")
dir_map.setdefault(base_dir, []).append((ex_filename, rst_filename))
for dirname, filenames in dir_map.iteritems():
filenames = sorted(filenames, cmp=lambda a, b: cmp(a[1], b[1]))
dir_map[dirname] = filenames
# Main index.
mfd = open(os.path.join(rst_dir, "index.rst"), "w")
mfd.write(_index % ("sfepy", "SfePy autogenerated gallery", "=" * 27))
for dirname, filenames in ordered_iteritems(dir_map):
full_dirname = os.path.join(rst_dir, dirname)
ensure_path(full_dirname + os.path.sep)
# Subdirectory index.
ifd = open(os.path.join(full_dirname, "index.rst"), "w")
ifd.write(_index % (dirname, dirname, "=" * len(dirname)))
for ex_filename, rst_filename in filenames:
full_rst_filename = os.path.join(full_dirname, rst_filename)
output('"%s"' % full_rst_filename.replace(rst_dir, "")[1:])
rst_filename_ns = rst_filename.replace(".rst", "")
ebase = ex_filename.replace(examples_dir, "")[1:]
rst_ex_filename = _make_sphinx_path(ex_filename)
docstring = get_default(import_file(ex_filename).__doc__, "missing description!")
ifd.write(" %s\n" % rst_filename_ns)
fig_include = ""
fig_base = _get_fig_filenames(ebase, images_dir).next()
for fig_filename in _get_fig_filenames(ebase, images_dir):
rst_fig_filename = _make_sphinx_path(fig_filename)
if os.path.exists(fig_filename):
fig_include += _image % rst_fig_filename + "\n"
# Example rst file.
fd = open(full_rst_filename, "w")
fd.write(
_include % (fig_base, ebase, "=" * len(ebase), docstring, fig_include, rst_ex_filename, rst_ex_filename)
)
fd.close()
ifd.close()
mfd.write(" %s/index\n" % dirname)
mfd.close()
output("...done")
return dir_map
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 generate_gallery(examples_dir, output_filename, doc_dir,
rst_dir, thumbnails_dir, dir_map, n_col=3):
"""
Generate the gallery rst file with thumbnail images and links to
examples.
Parameters
----------
output_filename : str
The output rst file name.
doc_dir : str
The top level directory of gallery files.
rst_dir : str
The full path to rst files of examples within `doc_dir`.
thumbnails_dir : str
The full path to thumbnail images within `doc_dir`.
dir_map : dict
The directory mapping returned by `generate_rst_files()`
n_col : int
The number of columns in the gallery table.
"""
output('generating %s...' % output_filename)
lines = [_gallery_head]
for dirname, filenames in ordered_iteritems(dir_map):
title= [' %s' % dirname.title().replace('_', ' '),
' ' + len(dirname) * '^' + '',
_gallery_table]
llines = []
icol = 0
for ex_filename, rst_filename in filenames:
ebase = ex_filename.replace(examples_dir, '')[1:]
link = os.path.splitext(rst_filename)[0]
thumbnail_filename = next(_get_fig_filenames(ebase,
thumbnails_dir))
if not os.path.isfile(thumbnail_filename):
# Skip examples with no image (= failed examples).
output('warning: figure "%s" not found' % thumbnail_filename)
continue
thumbnail_name = thumbnail_filename.replace(doc_dir, '..')
path_to_file = os.path.join(examples_dir, ebase)
docstring = get_default(import_file(path_to_file).__doc__,
'missing description!')
docstring = docstring.replace('e.g.', 'eg:')
docstring = docstring.split('.')
label = docstring[0].strip()
label = label.replace('\n', ' ')
label = label.replace(' ', ' ')
llines.append(_rst_item % (' ' if icol else '*', thumbnail_name,
link + '.html', label, link))
icol = (icol + 1) % n_col
if icol > 0:
for j in range(icol, n_col):
llines.append(_rst_empty_item)
if len(llines) > 0:
lines += title + llines
else:
output('warning: no figures in "%s"' % dirname)
fd = open(output_filename, 'wt')
fd.write('\n'.join(lines))
fd.close()
output('...done')
def generate_rst_files(rst_dir, examples_dir, images_dir):
"""
Generate Sphinx rst files for examples in `examples_dir` with images
in `images_dir` and put them into `rst_dir`.
Returns
-------
dir_map : dict
The directory mapping of examples and corresponding rst files.
"""
ensure_path(rst_dir + os.path.sep)
output('generating rst files...')
dir_map = {}
for ex_filename in locate_files('*.py', examples_dir):
if _omit(ex_filename): continue
ebase = ex_filename.replace(examples_dir, '')[1:]
base_dir = os.path.dirname(ebase)
rst_filename = ebase2fbase(ebase) + '.rst'
dir_map.setdefault(base_dir, []).append((ex_filename, rst_filename))
for dirname, filenames in six.iteritems(dir_map):
filenames = sorted(filenames, key=lambda a: a[1])
dir_map[dirname] = filenames
# Main index.
mfd = open(os.path.join(rst_dir, 'index.rst'), 'w')
mfd.write(_index % ('examples', 'Examples', '=' * 8))
for dirname, filenames in ordered_iteritems(dir_map):
# Subdirectory index.
ifd = open(os.path.join(rst_dir, '%s-index.rst' % dirname), 'w')
ifd.write(_index % (dirname + '-examples',
dirname, '=' * len(dirname)))
for ex_filename, rst_filename in filenames:
full_rst_filename = os.path.join(rst_dir, rst_filename)
output('"%s"' % rst_filename)
ebase = ex_filename.replace(examples_dir, '')[1:]
rst_base = os.path.splitext(rst_filename)[0]
rst_ex_filename = _make_sphinx_path(ex_filename)
docstring = get_default(import_file(ex_filename).__doc__,
'missing description!')
ifd.write(' %s <%s>\n' % (os.path.basename(ebase), rst_base))
fig_include = ''
for fig_filename in _get_fig_filenames(ebase, images_dir):
rst_fig_filename = _make_sphinx_path(fig_filename)
if os.path.exists(fig_filename):
fig_include += _image % rst_fig_filename + '\n'
else:
output(' warning: figure "%s" not found' % fig_filename)
# Example rst file.
fd = open(full_rst_filename, 'w')
fd.write(_include % (rst_base, ebase, '=' * len(ebase),
docstring,
fig_include,
rst_ex_filename, rst_ex_filename))
fd.close()
ifd.close()
mfd.write(' %s-index\n' % dirname)
mfd.close()
output('...done')
return dir_map
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 __call__(self):
return ProblemConf.from_dict(self.conf.__dict__,
import_file(__file__))
def generate_rst_files(rst_dir, examples_dir, images_dir):
"""
Generate Sphinx rst files for examples in `examples_dir` with images
in `images_dir` and put them into `rst_dir`.
Returns
-------
dir_map : dict
The directory mapping of examples and corresponding rst files.
"""
ensure_path(rst_dir + os.path.sep)
output('generating rst files...')
dir_map = {}
for ex_filename in locate_files('*.py', examples_dir):
if _omit(ex_filename): continue
ebase = ex_filename.replace(examples_dir, '')[1:]
base_dir = os.path.dirname(ebase)
rst_filename = os.path.basename(ex_filename).replace('.py', '.rst')
dir_map.setdefault(base_dir, []).append((ex_filename, rst_filename))
for dirname, filenames in dir_map.iteritems():
filenames = sorted(filenames, cmp=lambda a, b: cmp(a[1], b[1]))
dir_map[dirname ] = filenames
# Main index.
mfd = open(os.path.join(rst_dir, 'index.rst'), 'w')
mfd.write(_index % ('sfepy', 'SfePy autogenerated gallery', '=' * 27))
for dirname, filenames in ordered_iteritems(dir_map):
full_dirname = os.path.join(rst_dir, dirname)
ensure_path(full_dirname + os.path.sep)
# Subdirectory index.
ifd = open(os.path.join(full_dirname, 'index.rst'), 'w')
ifd.write(_index % (dirname, dirname, '=' * len(dirname)))
for ex_filename, rst_filename in filenames:
full_rst_filename = os.path.join(full_dirname, rst_filename)
output('"%s"' % full_rst_filename.replace(rst_dir, '')[1:])
rst_filename_ns = rst_filename.replace('.rst', '')
ebase = ex_filename.replace(examples_dir, '')[1:]
rst_ex_filename = _make_sphinx_path(ex_filename)
docstring = get_default(import_file(ex_filename).__doc__,
'missing description!')
ifd.write(' %s\n' % rst_filename_ns)
fig_include = ''
fig_base = _get_fig_filenames(ebase, images_dir).next()
for fig_filename in _get_fig_filenames(ebase, images_dir):
rst_fig_filename = _make_sphinx_path(fig_filename)
if os.path.exists(fig_filename):
fig_include += _image % rst_fig_filename + '\n'
# Example rst file.
fd = open(full_rst_filename, 'w')
fd.write(_include % (fig_base, ebase, '=' * len(ebase),
docstring,
fig_include,
rst_ex_filename, rst_ex_filename))
fd.close()
ifd.close()
mfd.write(' %s/index\n' % dirname)
mfd.close()
output('...done')
return dir_map
