def get_correctors_from_file_hdf5(coefs_filename='coefs.h5', dump_names=None):
if dump_names == None:
coefs = Coefficients.from_file_hdf5(coefs_filename)
if hasattr(coefs, 'save_names'):
dump_names = coefs.save_names
else:
raise ValueError(' "filenames" coefficient must be used!')
out = {}
for key, val in six.iteritems(dump_names):
if type(val) in [tuple, list]:
h5name, corr_name = val
else:
h5name, corr_name = val, op.split(val)[-1]
io = HDF5MeshIO(h5name + '.h5')
data = io.read_data(0)
dkeys = list(data.keys())
corr = {}
for dk in dkeys:
corr[dk] = data[dk].data.reshape(data[dk].shape)
out[corr_name] = corr
return out
def call(self, verbose=False, ret_all=None):
"""
Call the homogenization engine and compute the homogenized
coefficients.
Parameters
----------
verbose : bool
If True, print the computed coefficients.
ret_all : bool or None
If not None, it can be used to override the 'return_all' option.
If True, also the dependencies are returned.
Returns
-------
coefs : Coefficients instance
The homogenized coefficients.
dependencies : dict
The dependencies, if `ret_all` is True.
"""
opts = self.app_options
ret_all = get_default(ret_all, opts.return_all)
volume = get_volume_from_options(opts, self.problem)
for vk, vv in volume.iteritems():
output('volume: %s = %.2f' % (vk, vv))
he = HomogenizationEngine( self.problem, self.options, volume = volume )
aux = he( ret_all = ret_all)
if ret_all:
coefs, dependencies = aux
else:
coefs = aux
coefs = Coefficients( **coefs.to_dict() )
coefs.volume = volume
if verbose:
prec = nm.get_printoptions()[ 'precision']
if hasattr(opts, 'print_digits'):
nm.set_printoptions(precision=opts.print_digits)
print coefs
nm.set_printoptions(precision=prec)
coef_save_name = op.join( opts.output_dir, opts.coefs_filename )
coefs.to_file_hdf5( coef_save_name + '.h5' )
coefs.to_file_txt( coef_save_name + '.txt',
opts.tex_names,
opts.float_format )
if ret_all:
return coefs, dependencies
else:
return coefs
def get_homog_coefs_linear(ts, coor, mode,
micro_filename=None, regenerate=False,
coefs_filename=None, define_args=None):
oprefix = output.prefix
output.prefix = 'micro:'
required, other = get_standard_keywords()
required.remove( 'equations' )
conf = ProblemConf.from_file(micro_filename, required, other,
verbose=False, define_args=define_args)
if coefs_filename is None:
coefs_filename = conf.options.get('coefs_filename', 'coefs')
coefs_filename = op.join(conf.options.get('output_dir', '.'),
coefs_filename) + '.h5'
if not regenerate:
if op.exists( coefs_filename ):
if not pt.is_hdf5_file( coefs_filename ):
regenerate = True
else:
regenerate = True
if regenerate:
options = Struct( output_filename_trunk = None )
app = HomogenizationApp( conf, options, 'micro:' )
coefs = app()
if type(coefs) is tuple:
coefs = coefs[0]
coefs.to_file_hdf5( coefs_filename )
else:
coefs = Coefficients.from_file_hdf5( coefs_filename )
out = {}
if mode == None:
for key, val in six.iteritems(coefs.__dict__):
out[key] = val
elif mode == 'qp':
for key, val in six.iteritems(coefs.__dict__):
if type( val ) == nm.ndarray or type(val) == nm.float64:
out[key] = nm.tile( val, (coor.shape[0], 1, 1) )
elif type(val) == dict:
for key2, val2 in six.iteritems(val):
if type(val2) == nm.ndarray or type(val2) == nm.float64:
out[key+'_'+key2] = \
nm.tile(val2, (coor.shape[0], 1, 1))
else:
out = None
output.prefix = oprefix
return out
def load_coefs( filename ):
coefs = Coefficients.from_file_hdf5( filename )
try:
options = import_file( coefs.filename ).options
plot_info = options['plot_info']
tex_names = options['tex_names']
except:
plot_info = coefs.plot_info
tex_names = coefs.tex_names
return coefs, plot_info, tex_names
def call(self, ret_all=False, verbose=False):
opts = self.app_options
volume = {}
if opts.volumes is not None:
for vk, vv in opts.volumes.iteritems():
if 'value' in vv:
volume[vk] = nm.float64(vv['value'])
else:
volume[vk] = Volume('volume', self.problem, vv)()
else:
if opts.volume is not None:
if 'value' in opts.volume:
vol = nm.float64(opts.volume['value'])
else:
vol = Volume('volume', self.problem, opts.volume)()
volume['total'] = vol
for vk, vv in volume.iteritems():
output('volume: %s = %.2f' % (vk, vv))
if hasattr(opts, 'return_all'):
ret_all = opts.return_all
he = HomogenizationEngine( self.problem, self.options, volume = volume )
aux = he( ret_all = ret_all)
if ret_all:
coefs, dependencies = aux
else:
coefs = aux
coefs = Coefficients( **coefs.to_dict() )
coefs.volume = volume
if verbose:
prec = nm.get_printoptions()[ 'precision']
if hasattr(opts, 'print_digits'):
nm.set_printoptions(precision=opts.print_digits)
print coefs
nm.set_printoptions(precision=prec)
coef_save_name = op.join( opts.output_dir, opts.coefs_filename )
coefs.to_file_hdf5( coef_save_name + '.h5' )
coefs.to_file_txt( coef_save_name + '.txt',
opts.tex_names,
opts.float_format )
if ret_all:
return coefs, dependencies
else:
return coefs
def recover_micro_hook(micro_filename,
region,
macro,
naming_scheme='step_iel',
recovery_file_tag=''):
# Create a micro-problem instance.
required, other = get_standard_keywords()
required.remove('equations')
pb = ProblemDefinition.from_conf_file(micro_filename,
required=required,
other=other,
init_equations=False,
init_solvers=False)
coefs_filename = pb.conf.options.get_default_attr('coefs_filename',
'coefs')
output_dir = pb.conf.options.get_default_attr('output_dir', '.')
coefs_filename = op.join(output_dir, coefs_filename) + '.h5'
# Coefficients and correctors
coefs = Coefficients.from_file_hdf5(coefs_filename)
corrs = get_correctors_from_file(dump_names=coefs.dump_names)
recovery_hook = get_default_attr(pb.conf.options, 'recovery_hook', None)
if recovery_hook is not None:
recovery_hook = pb.conf.get_function(recovery_hook)
aux = max(pb.domain.shape.n_gr, 2)
format = get_print_info( aux, fill = '0' )[1] \
+ '_' + get_print_info( pb.domain.mesh.n_el, fill = '0' )[1]
for ig, ii, iel in region.iter_cells():
print 'ig: %d, ii: %d, iel: %d' % (ig, ii, iel)
local_macro = {}
for k, v in macro.iteritems():
local_macro[k] = v[ii, 0]
out = recovery_hook(pb, corrs, local_macro)
# save data
suffix = format % (ig, iel)
micro_name = pb.get_output_name(extra='recovered_'\
+ recovery_file_tag + suffix)
filename = op.join(output_dir, op.basename(micro_name))
fpv = pb.conf.options.get_default_attr('file_per_var', False)
pb.save_state(filename, out=out, file_per_var=fpv)
def recover_micro_hook( micro_filename, region, macro,
naming_scheme = 'step_iel',
recovery_file_tag='' ):
# Create a micro-problem instance.
required, other = get_standard_keywords()
required.remove( 'equations' )
pb = ProblemDefinition.from_conf_file(micro_filename,
required=required,
other=other,
init_equations=False,
init_solvers=False)
coefs_filename = pb.conf.options.get_default_attr('coefs_filename', 'coefs')
output_dir = pb.conf.options.get_default_attr('output_dir', '.')
coefs_filename = op.join(output_dir, coefs_filename) + '.h5'
# Coefficients and correctors
coefs = Coefficients.from_file_hdf5( coefs_filename )
corrs = get_correctors_from_file( dump_names = coefs.dump_names )
recovery_hook = get_default_attr( pb.conf.options,
'recovery_hook', None )
if recovery_hook is not None:
recovery_hook = getattr( pb.conf.funmod, recovery_hook )
aux = max(pb.domain.shape.n_gr, 2)
format = get_print_info( aux, fill = '0' )[1] \
+ '_' + get_print_info( pb.domain.mesh.n_el, fill = '0' )[1]
for ig, ii, iel in region.iter_cells():
print 'ig: %d, ii: %d, iel: %d' % (ig, ii, iel)
local_macro = {}
for k, v in macro.iteritems():
local_macro[k] = v[ii,0]
out = recovery_hook( pb, corrs, local_macro )
# save data
suffix = format % (ig, iel)
micro_name = pb.get_output_name(extra='recovered_'\
+ recovery_file_tag + suffix)
filename = op.join(output_dir, op.basename(micro_name))
fpv = pb.conf.options.get_default_attr('file_per_var', False)
pb.save_state(filename, out=out,
file_per_var=fpv)
def 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 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 get_correctors_from_file_hdf5(coefs_filename='coefs.h5', dump_names=None):
if dump_names == None:
coefs = Coefficients.from_file_hdf5(coefs_filename)
if hasattr(coefs, 'save_names'):
dump_names = coefs.save_names
else:
raise ValueError(' "filenames" coefficient must be used!')
out = {}
for key, val in six.iteritems(dump_names):
if type(val) in [tuple, list]:
h5name, corr_name = val
else:
h5name, corr_name = val, op.split(val)[-1]
io = HDF5MeshIO(h5name + '.h5')
try:
ts = io.read_time_stepper()
except ValueError:
ts = None
if ts is None:
data = io.read_data(0)
dkeys = list(data.keys())
corr = {}
for dk in dkeys:
corr[dk] = data[dk].data.reshape(data[dk].shape)
out[corr_name] = corr
else:
n_step = ts[3]
out[corr_name] = []
for step in range(n_step):
data = io.read_data(step)
dkeys = list(data.keys())
corr = {}
for dk in dkeys:
corr[dk] = data[dk].data.reshape(data[dk].shape)
out[corr_name].append(corr)
out[corr_name + '_ts'] = ts
return out
def get_homog_coefs_linear( ts, coor, mode, region, ig,
micro_filename = None, regenerate = False ):
oprefix = output.prefix
output.prefix = 'micro:'
required, other = get_standard_keywords()
required.remove( 'equations' )
conf = ProblemConf.from_file(micro_filename, required, other, verbose=False)
coefs_filename = conf.options.get_default_attr('coefs_filename', 'coefs.h5')
if not regenerate:
if op.exists( coefs_filename ):
if not pt.isHDF5File( coefs_filename ):
regenerate = True
else:
regenerate = True
if regenerate:
options = Struct( output_filename_trunk = None )
app = HomogenizationApp( conf, options, 'micro:' )
coefs = app()
coefs.to_file_hdf5( coefs_filename )
else:
coefs = Coefficients.from_file_hdf5( coefs_filename )
out = {}
if mode == None:
for key, val in coefs.__dict__.iteritems():
out[key] = val
elif mode == 'qp':
for key, val in coefs.__dict__.iteritems():
if type( val ) == nm.ndarray:
out[key] = nm.tile( val, (coor.shape[0], 1, 1) )
else:
out = None
output.prefix = oprefix
return out
def get_correctors_from_file(coefs_filename='coefs.h5', dump_names=None):
if dump_names == None:
coefs = Coefficients.from_file_hdf5(coefs_filename)
if hasattr(coefs, 'dump_names'):
dump_names = coefs.dump_names
else:
raise ValueError(' "filenames" coefficient must be used!')
out = {}
for key, val in dump_names.iteritems():
corr_name = op.split(val)[-1]
io = HDF5MeshIO(val + '.h5')
data = io.read_data(0)
dkeys = data.keys()
corr = {}
for dk in dkeys:
corr[dk] = data[dk].data.reshape(data[dk].shape)
out[corr_name] = corr
return out
def call( self, ret_all = False ):
opts = self.app_options
if 'value' in opts.volume:
volume = nm.float64( opts.options.volume['value'] )
else:
volume = Volume( 'volume', self.problem, opts.volume )()
output( 'volume: %.2f' % volume )
if hasattr(opts.options, 'return_all'):
ret_all = opts.options.return_all
he = HomogenizationEngine( self.problem, self.options, volume = volume )
aux = he( ret_all = ret_all)
if ret_all:
coefs, dependencies = aux
else:
coefs = aux
coefs = Coefficients( **coefs.to_dict() )
coefs.volume = volume
prec = nm.get_printoptions()[ 'precision']
if hasattr( opts, 'print_digits' ):
nm.set_printoptions( precision = opts.print_digits )
print coefs
nm.set_printoptions( precision = prec )
## pause()
coef_save_name = op.join( opts.output_dir, opts.coef_save_name )
coefs.to_file_hdf5( coef_save_name + '.h5' )
coefs.to_file_txt( coef_save_name + '.txt',
opts.tex_names,
opts.float_format )
if ret_all:
return coefs, dependencies
else:
return coefs
def get_correctors_from_file( coefs_filename = 'coefs.h5',
dump_names = None ):
if dump_names == None:
coefs = Coefficients.from_file_hdf5( coefs_filename )
if hasattr( coefs, 'dump_names' ):
dump_names = coefs.dump_names
else:
raise ValueError( ' "filenames" coefficient must be used!' )
out = {}
for key, val in dump_names.iteritems():
corr_name = op.split( val )[-1]
io = HDF5MeshIO( val+'.h5' )
data = io.read_data( 0 )
dkeys = data.keys()
corr = {}
for dk in dkeys:
corr[dk] = data[dk].data.reshape(data[dk].shape)
out[corr_name] = corr
return out
def call(self, ret_all=False, verbose=False):
opts = self.app_options
volume = get_volume_from_options(opts, self.problem)
for vk, vv in volume.iteritems():
output('volume: %s = %.2f' % (vk, vv))
he = HomogenizationEngine( self.problem, self.options, volume = volume )
aux = he( ret_all = ret_all)
if ret_all:
coefs, dependencies = aux
else:
coefs = aux
coefs = Coefficients( **coefs.to_dict() )
coefs.volume = volume
if verbose:
prec = nm.get_printoptions()[ 'precision']
if hasattr(opts, 'print_digits'):
nm.set_printoptions(precision=opts.print_digits)
print coefs
nm.set_printoptions(precision=prec)
coef_save_name = op.join( opts.output_dir, opts.coefs_filename )
coefs.to_file_hdf5( coef_save_name + '.h5' )
coefs.to_file_txt( coef_save_name + '.txt',
opts.tex_names,
opts.float_format )
if ret_all:
return coefs, dependencies
else:
return coefs
# aluminium, in 1e+10 Pa
D_m = get_pars(dim, 5.898, 2.681)
density_m = 0.2799 # in 1e4 kg/m3
# epoxy, in 1e+10 Pa
D_c = get_pars(dim, 0.1798, 0.148)
density_c = 0.1142 # in 1e4 kg/m3
# lead, in 1e+10 Pa, does not matter
D_r = get_pars(dim, 4.074, 0.5556)
density_r = 1.1340 # in 1e4 kg/m3
mat_pars = Coefficients(D_m=D_m,
density_m=density_m,
D_c=D_c,
density_c=density_c,
D_r=D_r,
density_r=density_r)
region_selects = Struct(matrix=('elements of group 1', {}),
inclusion=('elements of group 2', {}))
corrs_save_names = {'evp': 'evp'}
evp_options = {
'eigensolver': 'eig.sgscipy',
'save_eig_vectors': (12, 0),
'scale_epsilon': 1.0,
'elasticity_contrast': 1.0,
}
def call(self, verbose=False, ret_all=None, itime=None, iiter=None):
"""
Call the homogenization engine and compute the homogenized
coefficients.
Parameters
----------
verbose : bool
If True, print the computed coefficients.
ret_all : bool or None
If not None, it can be used to override the 'return_all' option.
If True, also the dependencies are returned.
time_tag: str
The time tag used in file names.
Returns
-------
coefs : Coefficients instance
The homogenized coefficients.
dependencies : dict
The dependencies, if `ret_all` is True.
"""
opts = self.app_options
ret_all = get_default(ret_all, opts.return_all)
if not hasattr(self, 'he'):
volumes = {}
if hasattr(opts, 'volumes') and (opts.volumes is not None):
volumes.update(opts.volumes)
elif hasattr(opts, 'volume') and (opts.volume is not None):
volumes['total'] = opts.volume
else:
volumes['total'] = 1.0
self.he = HomogenizationEngine(self.problem,
self.options,
volumes=volumes)
if self.micro_coors is not None:
self.he.set_micro_coors(self.update_micro_coors(ret_val=True))
multiproc_mode = None
if opts.multiprocessing and multi.use_multiprocessing:
multiproc, multiproc_mode = multi.get_multiproc(mpi=opts.use_mpi)
if multiproc_mode is not None:
upd_var = self.app_options.mesh_update_variable
if upd_var is not None:
uvar = self.problem.create_variables([upd_var])[upd_var]
uvar.field.mappings0 = multiproc.get_dict('mappings0',
soft_set=True)
per.periodic_cache = multiproc.get_dict('periodic_cache',
soft_set=True)
time_tag = ('' if itime is None else '_t%03d' % itime)\
+ ('' if iiter is None else '_i%03d' % iiter)
aux = self.he(ret_all=ret_all, time_tag=time_tag)
if ret_all:
coefs, dependencies = aux
# store correctors for coors update
if opts.mesh_update_corrector is not None:
self.updating_corrs =\
dependencies[opts.mesh_update_corrector]
else:
coefs = aux
if coefs is not None:
coefs = Coefficients(**coefs.to_dict())
if verbose:
prec = nm.get_printoptions()['precision']
if hasattr(opts, 'print_digits'):
nm.set_printoptions(precision=opts.print_digits)
print(coefs)
nm.set_printoptions(precision=prec)
ms_cache = self.micro_state_cache
for ii in self.app_options.store_micro_idxs:
key = self.get_micro_cache_key('coors', ii, itime)
ms_cache[key] = self.micro_coors[ii, ...]
coef_save_name = op.join(opts.output_dir, opts.coefs_filename)
coefs.to_file_hdf5(coef_save_name + '%s.h5' % time_tag)
coefs.to_file_txt(coef_save_name + '%s.txt' % time_tag,
opts.tex_names, opts.float_format)
if ret_all:
return coefs, dependencies
else:
return coefs
def recover_micro_hook( micro_filename, region, macro,
naming_scheme = 'step_iel',
recovery_file_tag='' ):
# Create a micro-problem instance.
required, other = get_standard_keywords()
required.remove( 'equations' )
pb = Problem.from_conf_file(micro_filename, required=required, other=other,
init_equations=False, init_solvers=False)
coefs_filename = pb.conf.options.get('coefs_filename', 'coefs')
output_dir = pb.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 = pb.conf.options.get('recovery_hook', None)
if recovery_hook is not None:
recovery_hook = pb.conf.get_function(recovery_hook)
aux = max(pb.domain.shape.n_gr, 2)
format = get_print_info( aux, fill = '0' )[1] \
+ '_' + get_print_info( pb.domain.mesh.n_el, fill = '0' )[1]
for ig, ii, iel in region.iter_cells():
print 'ig: %d, ii: %d, iel: %d' % (ig, ii, iel)
local_macro = {}
for k, v in macro.iteritems():
local_macro[k] = v[ii,0]
out = recovery_hook( pb, corrs, local_macro )
if ii == 0:
new_keys = []
new_data = {}
new_idxs = []
for k in local_macro.iterkeys():
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 % (ig, iel)
micro_name = pb.get_output_name(extra='recovered_'\
+ recovery_file_tag + suffix)
filename = op.join(output_dir, op.basename(micro_name))
fpv = pb.conf.options.get('file_per_var', False)
pb.save_state(filename, out=out,
file_per_var=fpv)
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 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 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 call(self):
"""
Construct and call the homogenization engine accoring to options.
"""
options = self.options
opts = self.app_options
conf = self.problem.conf
coefs_name = opts.coefs
coef_info = conf.get(opts.coefs, None,
'missing "%s" in problem description!'
% opts.coefs)
if options.detect_band_gaps:
# Compute band gaps coefficients and data.
keys = [key for key in coef_info if key.startswith('band_gaps')]
elif options.analyze_dispersion or options.phase_velocity:
# Insert incident wave direction to coefficients that need it.
for key, val in coef_info.iteritems():
coef_opts = val.get('options', None)
if coef_opts is None: continue
if (('incident_wave_dir' in coef_opts)
and (coef_opts['incident_wave_dir'] is None)):
coef_opts['incident_wave_dir'] = opts.incident_wave_dir
if options.analyze_dispersion:
# Compute dispersion coefficients and data.
keys = [key for key in coef_info
if key.startswith('dispersion')
or key.startswith('polarization_angles')]
else:
# Compute phase velocity and its requirements.
keys = [key for key in coef_info
if key.startswith('phase_velocity')]
else:
# Compute only the eigenvalue problems.
names = [req for req in conf.get(opts.requirements, [''])
if req.startswith('evp')]
coefs = {'dummy' : {'requires' : names,
'class' : CoefDummy,}}
conf.coefs_dummy = coefs
coefs_name = 'coefs_dummy'
keys = ['dummy']
he_options = Struct(coefs=coefs_name, requirements=opts.requirements,
compute_only=keys,
post_process_hook=self.post_process_hook)
volume = get_volume_from_options(opts, self.problem)
he = HomogenizationEngine(self.problem, options,
app_options=he_options,
volume=volume)
coefs = he()
coefs = Coefficients(**coefs.to_dict())
coefs.volume = volume
coefs_filename = op.join(opts.output_dir, opts.coefs_filename)
coefs.to_file_txt(coefs_filename + '.txt',
opts.tex_names,
opts.float_format)
bg_keys = [key for key in coefs.to_dict()
if key.startswith('band_gaps')
or key.startswith('dispersion')]
for ii, key in enumerate(bg_keys):
bg = coefs.get(key)
log_save_name = bg.get('log_save_name', None)
if log_save_name is not None:
filename = op.join(self.problem.output_dir, log_save_name)
bg.save_log(filename, opts.float_format, bg)
if options.plot:
if options.detect_band_gaps:
self.plot_band_gaps(coefs)
elif options.analyze_dispersion:
self.plot_dispersion(coefs)
elif options.phase_velocity:
keys = [key for key in coefs.to_dict()
if key.startswith('phase_velocity')]
for key in keys:
output('%s:' % key, coefs.get(key))
return coefs
def call(self, verbose=False, ret_all=None, itime=None, iiter=None):
"""
Call the homogenization engine and compute the homogenized
coefficients.
Parameters
----------
verbose : bool
If True, print the computed coefficients.
ret_all : bool or None
If not None, it can be used to override the 'return_all' option.
If True, also the dependencies are returned.
time_tag: str
The time tag used in file names.
Returns
-------
coefs : Coefficients instance
The homogenized coefficients.
dependencies : dict
The dependencies, if `ret_all` is True.
"""
opts = self.app_options
ret_all = get_default(ret_all, opts.return_all)
if not hasattr(self, 'he'):
volumes = {}
if hasattr(opts, 'volumes') and (opts.volumes is not None):
volumes.update(opts.volumes)
elif hasattr(opts, 'volume') and (opts.volume is not None):
volumes['total'] = opts.volume
else:
volumes['total'] = 1.0
self.he = HomogenizationEngine(self.problem, self.options,
volumes=volumes)
if self.micro_coors is not None:
self.he.set_micro_coors(self.update_micro_coors(ret_val=True))
multiproc_mode = None
if opts.multiprocessing and multi.use_multiprocessing:
multiproc, multiproc_mode = multi.get_multiproc(mpi=opts.use_mpi)
if multiproc_mode is not None:
upd_var = self.app_options.mesh_update_variable
if upd_var is not None:
uvar = self.problem.create_variables([upd_var])[upd_var]
uvar.field.mappings0 = multiproc.get_dict('mappings0',
soft_set=True)
per.periodic_cache = multiproc.get_dict('periodic_cache',
soft_set=True)
time_tag = ('' if itime is None else '_t%03d' % itime)\
+ ('' if iiter is None else '_i%03d' % iiter)
aux = self.he(ret_all=ret_all, time_tag=time_tag)
if ret_all:
coefs, dependencies = aux
# store correctors for coors update
if opts.mesh_update_corrector is not None:
self.updating_corrs =\
dependencies[opts.mesh_update_corrector]
else:
coefs = aux
if coefs is not None:
coefs = Coefficients(**coefs.to_dict())
if verbose:
prec = nm.get_printoptions()['precision']
if hasattr(opts, 'print_digits'):
nm.set_printoptions(precision=opts.print_digits)
print(coefs)
nm.set_printoptions(precision=prec)
ms_cache = self.micro_state_cache
for ii in self.app_options.store_micro_idxs:
key = self.get_micro_cache_key('coors', ii, itime)
ms_cache[key] = self.micro_coors[ii, ...]
coef_save_name = op.join(opts.output_dir, opts.coefs_filename)
coefs.to_file_hdf5(coef_save_name + '%s.h5' % time_tag)
coefs.to_file_txt(coef_save_name + '%s.txt' % time_tag,
opts.tex_names,
opts.float_format)
if ret_all:
return coefs, dependencies
else:
return coefs
def recover_micro_hook_eps(micro_filename, region,
eval_var, nodal_values, const_values, eps0,
recovery_file_tag='',
define_args=None):
# 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
for ii, c0 in enumerate(x0):
local_macro = {'eps0': eps0}
local_coors = pb.domain.mesh.coors * eps0 + c0
# Inside recovery region?
v = nm.ones((eval_var.field.region.entities[0].shape[0], 1))
v[region.entities[0]] = 0
no = nm.sum(v)
aux = eval_var.field.evaluate_at(local_coors, v)
if (nm.sum(aux) / no) > 1e-3:
continue
output('ii: %d' % ii)
for k, v in six.iteritems(nodal_values):
local_macro[k] = eval_var.field.evaluate_at(local_coors, v)
for k, v in six.iteritems(const_values):
local_macro[k] = v
outs.append(recovery_hook(pb, corrs, local_macro))
coors.append(local_coors)
conn.append(mesh.get_conn(mesh.descs[0]) + ndoffset)
ndoffset += mesh.n_nod
# 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)
