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 recovery_hook(pb, ncoors, region, ts, naming_scheme='step_iel', recovery_file_tag=''): from sfepy.base.ioutils import get_print_info from sfepy.homogenization.recovery import get_output_suffix import os.path as op for ii, icell in enumerate(region.cells): out = {} pb.set_mesh_coors(ncoors[ii], update_fields=True, clear_all=False, actual=True) stress = pb.evaluate('ev_integrate_mat.3.Y(mat_he.S, u)', mode='el_avg') out['cauchy_stress'] = Struct(name='output_data', mode='cell', data=stress, dofs=None) strain = pb.evaluate('ev_integrate_mat.3.Y(mat_he.E, u)', mode='el_avg') out['green_strain'] = Struct(name='output_data', mode='cell', data=strain, dofs=None) out['displacement'] = Struct(name='output_data', mode='vertex', data=ncoors[ii] - pb.get_mesh_coors(), dofs=None) output_dir = pb.conf.options.get('output_dir', '.') format = get_print_info(pb.domain.mesh.n_el, fill='0')[1] suffix = get_output_suffix(icell, ts, naming_scheme, format, pb.output_format) 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)
def recovery_hook(pb, ncoors, region, ts, naming_scheme='step_iel', recovery_file_tag=''): from sfepy.base.ioutils import get_print_info from sfepy.homogenization.recovery import get_output_suffix import os.path as op for ii, icell in enumerate(region.cells): out = {} pb.set_mesh_coors(ncoors[ii], update_fields=True, clear_all=False, actual=True) stress = pb.evaluate('ev_volume_integrate_mat.3.Y(mat_he.S, u)', mode='el_avg') out['cauchy_stress'] = Struct(name='output_data', mode='cell', data=stress, dofs=None) strain = pb.evaluate('ev_volume_integrate_mat.3.Y(mat_he.E, u)', mode='el_avg') out['green_strain'] = Struct(name='output_data', mode='cell', data=strain, dofs=None) out['displacement'] = Struct(name='output_data', mode='vertex', data=ncoors[ii] - pb.get_mesh_coors(), dofs=None) output_dir = pb.conf.options.get('output_dir', '.') format = get_print_info(pb.domain.mesh.n_el, fill='0')[1] suffix = get_output_suffix(icell, ts, naming_scheme, format, pb.output_format) 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)
def main(): parser = OptionParser(usage=usage, version='%prog') parser.add_option('-b', '--basis', metavar='name', action='store', dest='basis', default='lagrange', help=help['basis']) parser.add_option('-d', '--derivative', metavar='d', type=int, action='store', dest='derivative', default=0, help=help['derivative']) parser.add_option('-n', '--max-order', metavar='order', type=int, action='store', dest='max_order', default=2, help=help['max_order']) parser.add_option('-g', '--geometry', metavar='name', action='store', dest='geometry', default='2_4', help=help['geometry']) parser.add_option('-m', '--mesh', metavar='mesh', action='store', dest='mesh', default=None, help=help['mesh']) parser.add_option('', '--permutations', metavar='permutations', action='store', dest='permutations', default=None, help=help['permutations']) parser.add_option('', '--dofs', metavar='dofs', action='store', dest='dofs', default=None, help=help['dofs']) parser.add_option('-l', '--lin-options', metavar='options', action='store', dest='lin_options', default='min_level=2,max_level=5,eps=1e-3', help=help['lin_options']) parser.add_option('', '--plot-dofs', action='store_true', dest='plot_dofs', default=False, help=help['plot_dofs']) options, args = parser.parse_args() if len(args) == 1: output_dir = args[0] else: parser.print_help(), return output('polynomial space:', options.basis) output('max. order:', options.max_order) lin = Struct(kind='adaptive', min_level=2, max_level=5, eps=1e-3) for opt in options.lin_options.split(','): key, val = opt.split('=') setattr(lin, key, eval(val)) if options.mesh is None: dim, n_ep = int(options.geometry[0]), int(options.geometry[2]) output('reference element geometry:') output(' dimension: %d, vertices: %d' % (dim, n_ep)) gel = GeometryElement(options.geometry) gps = PolySpace.any_from_args(None, gel, 1, base=options.basis) ps = PolySpace.any_from_args(None, gel, options.max_order, base=options.basis) n_digit, _format = get_print_info(ps.n_nod, fill='0') name_template = os.path.join(output_dir, 'bf_%s.vtk' % _format) for ip in get_dofs(options.dofs, ps.n_nod): output('shape function %d...' % ip) def eval_dofs(iels, rx): if options.derivative == 0: bf = ps.eval_base(rx).squeeze() rvals = bf[None, :, ip:ip+1] else: bfg = ps.eval_base(rx, diff=True) rvals = bfg[None, ..., ip] return rvals def eval_coors(iels, rx): bf = gps.eval_base(rx).squeeze() coors = nm.dot(bf, gel.coors)[None, ...] return coors (level, coors, conn, vdofs, mat_ids) = create_output(eval_dofs, eval_coors, 1, ps, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) out = { 'bf' : Struct(name='output_data', mode='vertex', data=vdofs, var_name='bf', dofs=None) } mesh = Mesh.from_data('bf_mesh', coors, None, [conn], [mat_ids], [options.geometry]) name = name_template % ip mesh.write(name, out=out) output('...done (%s)' % name) else: mesh = Mesh.from_file(options.mesh) output('mesh geometry:') output(' dimension: %d, vertices: %d, elements: %d' % (mesh.dim, mesh.n_nod, mesh.n_el)) domain = Domain('domain', mesh) if options.permutations: permutations = [int(ii) for ii in options.permutations.split(',')] output('using connectivity permutations:', permutations) for group in domain.iter_groups(): perms = group.gel.get_conn_permutations()[permutations] offsets = nm.arange(group.shape.n_el) * group.shape.n_ep group.conn[:] = group.conn.take(perms + offsets[:, None]) domain.setup_facets() omega = domain.create_region('Omega', 'all') field = Field.from_args('f', nm.float64, shape=1, region=omega, approx_order=options.max_order, poly_space_base=options.basis) var = FieldVariable('u', 'unknown', field, 1) if options.plot_dofs: import sfepy.postprocess.plot_dofs as pd group = domain.groups[0] ax = pd.plot_mesh(None, mesh.coors, mesh.conns[0], group.gel.edges) ax = pd.plot_global_dofs(ax, field.get_coor(), field.aps[0].econn) ax = pd.plot_local_dofs(ax, field.get_coor(), field.aps[0].econn) pd.plt.show() output('dofs: %d' % var.n_dof) vec = nm.empty(var.n_dof, dtype=var.dtype) n_digit, _format = get_print_info(var.n_dof, fill='0') name_template = os.path.join(output_dir, 'dof_%s.vtk' % _format) for ip in get_dofs(options.dofs, var.n_dof): output('dof %d...' % ip) vec.fill(0.0) vec[ip] = 1.0 var.data_from_any(vec) if options.derivative == 0: out = var.create_output(vec, linearization=lin) else: out = create_expression_output('ev_grad.ie.Elements(u)', 'u', 'f', {'f' : field}, None, Variables([var]), mode='qp', verbose=False, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) name = name_template % ip out['u'].mesh.write(name, out=out) output('...done (%s)' % name)
def recover_paraflow(problem, micro_problem, region, ts, strain, dstrains, pressures1, pressures2, corrs_rs, corrs_time_rs, corrs_alpha1, corrs_time_alpha1, corrs_alpha2, corrs_time_alpha2, var_names, naming_scheme='step_iel'): dim = problem.domain.mesh.dim vu, vp = var_names vdp = 'd' + vp micro_u = micro_problem.variables[vu] micro_coor = micro_u.field.get_coor() micro_n_nod = micro_problem.domain.mesh.n_nod micro_p = micro_problem.variables[vp] nodes_y1 = micro_problem.domain.regions['Y1'].all_vertices nodes_y2 = micro_problem.domain.regions['Y2'].all_vertices to_output = micro_problem.variables.state_to_output join = os.path.join aux = max(problem.domain.shape.n_gr, 2) format = get_print_info( aux, fill = '0' )[1] \ + '_' + get_print_info( problem.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) p1, p2 = pressures1[-1][ii, 0, 0, 0], pressures2[-1][ii, 0, 0, 0] us = corrs_alpha1[vu].data * p1 + corrs_alpha2[vu].data * p2 add_strain_rs(corrs_rs, strain, vu, dim, ii, out=us) ut = convolve_field_scalar(corrs_time_alpha1[vu], pressures1, ii, ts) ut += convolve_field_scalar(corrs_time_alpha2[vu], pressures2, ii, ts) ut += convolve_field_sym_tensor(corrs_time_rs, dstrains, vu, dim, ii, ts) u_corr = us + ut u_mic = compute_u_from_macro(strain, micro_coor, ii) + u_corr ps = corrs_alpha1[vp].data * p1 + corrs_alpha2[vp].data * p2 pt = convolve_field_scalar(corrs_time_alpha1[vdp], pressures1, ii, ts) pt += convolve_field_scalar(corrs_time_alpha2[vdp], pressures2, ii, ts) pt += convolve_field_sym_tensor(corrs_time_rs, dstrains, vdp, dim, ii, ts) p_corr = ps + pt p_mic = micro_p.field.extend_dofs(p_corr[:, nm.newaxis]) p_mic[nodes_y1] = p1 p_mic[nodes_y2] = p2 out = {} out.update(to_output(u_mic, var_info={vu: (True, vu)}, extend=True)) out[vp] = Struct(name='output_data', mode='vertex', data=p_mic, var_name=vp, dofs=micro_p.dofs) suffix = get_output_suffix(ig, iel, ts, naming_scheme, format, micro_problem.output_format) micro_name = micro_problem.get_output_name(extra=suffix) filename = join(problem.output_dir, 'recovered_' + micro_name) micro_problem.save_state(filename, out=out, ts=ts)
def recover_bones(problem, micro_problem, region, eps0, ts, strain, dstrains, p_grad, pressures, corrs_permeability, corrs_rs, corrs_time_rs, corrs_pressure, corrs_time_pressure, var_names, naming_scheme='step_iel'): r""" Notes ----- - note that .. math:: \widetilde{\pi}^P is in corrs_pressure -> from time correctors only 'u', 'dp' are needed. """ dim = problem.domain.mesh.dim vu, vp, vn, vpp1, vppp1 = var_names vdp = 'd' + vp variables = micro_problem.create_variables() to_output = variables.state_to_output micro_u, micro_p = variables[vu], variables[vp] micro_coor = micro_u.field.get_coor() nodes_yc = micro_problem.domain.regions['Yc'].all_vertices join = os.path.join aux = max(problem.domain.shape.n_gr, 2) format = get_print_info( aux, fill = '0' )[1] \ + '_' + get_print_info( problem.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) pressure = pressures[-1][ii, 0, 0, 0] us = corrs_pressure[vu].data * pressure add_strain_rs(corrs_rs, strain, vu, dim, ii, out=us) ut = convolve_field_scalar(corrs_time_pressure[vu], pressures, ii, ts) ut += convolve_field_sym_tensor(corrs_time_rs, dstrains, vu, dim, ii, ts) u1 = us + ut u_mic = compute_u_from_macro(strain, micro_coor, ii) + u1 ps = corrs_pressure[vp].data * pressure pt = convolve_field_scalar(corrs_time_pressure[vdp], pressures, ii, ts) pt += convolve_field_sym_tensor(corrs_time_rs, dstrains, vdp, dim, ii, ts) ## print us ## print ut ## print ps ## print pt p_hat = ps + pt # \eta_k \partial_k^x p p1 = combine_scalar_grad(corrs_permeability, p_grad, vn, ii) p_hat_e = micro_p.field.extend_dofs(p_hat[:, None], fill_value=0.0) p_mic = compute_p_from_macro(p_grad, micro_coor, ii)[:,None] \ + p_hat_e / eps0 p_mic[nodes_yc] = p1[:, None] ## print u_mic ## print p_mic # (y_k + \eta_k) \partial_k^x p p_aux = combine_scalar_grad(corrs_permeability, p_grad, vn, ii, shift_coors=micro_coor[nodes_yc]) meval = micro_problem.evaluate var_p = variables[vppp1] var_p.set_data(p_aux) dvel_m1 = meval('ev_diffusion_velocity.i1.Yc( m.K, %s )' % vppp1, verbose=False, mode='el_avg', **{vppp1: var_p}) var_p = variables[vpp1] var_p.set_data(p_hat) dvel_m2 = meval('ev_diffusion_velocity.i1.Ym( m.K, %s )' % vpp1, verbose=False, mode='el_avg', **{vpp1: var_p}) * eps0 out = {} out.update(to_output(u_mic, var_info={vu: (True, vu)}, extend=True)) out[vp] = Struct(name='output_data', mode='vertex', data=p_mic, var_name=vp, dofs=micro_p.dofs) aux = extend_cell_data(dvel_m1, micro_problem.domain, 'Yc') out['dvel_m1'] = Struct(name='output_data', mode='cell', data=aux, dofs=None) aux = extend_cell_data(dvel_m2, micro_problem.domain, 'Ym') out['dvel_m2'] = Struct(name='output_data', mode='cell', data=aux, dofs=None) suffix = get_output_suffix(ig, iel, ts, naming_scheme, format, micro_problem.output_format) micro_name = micro_problem.get_output_name(extra=suffix) filename = join(problem.output_dir, 'recovered_' + os.path.basename(micro_name)) micro_problem.save_state(filename, out=out, ts=ts)
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 save_basis_on_mesh(mesh, options, output_dir, lin, permutations=None, suffix=''): domain = Domain('domain', mesh) if permutations is not None: for group in domain.iter_groups(): perms = group.gel.get_conn_permutations()[permutations] offsets = nm.arange(group.shape.n_el) * group.shape.n_ep group.conn[:] = group.conn.take(perms + offsets[:, None]) domain.setup_facets() omega = domain.create_region('Omega', 'all') field = Field.from_args('f', nm.float64, shape=1, region=omega, approx_order=options.max_order, poly_space_base=options.basis) var = FieldVariable('u', 'unknown', field, 1) if options.plot_dofs: import sfepy.postprocess.plot_dofs as pd group = domain.groups[0] ax = pd.plot_mesh(None, mesh.coors, mesh.conns[0], group.gel.edges) ax = pd.plot_global_dofs(ax, field.get_coor(), field.aps[0].econn) ax = pd.plot_local_dofs(ax, field.get_coor(), field.aps[0].econn) if options.dofs is not None: ax = pd.plot_nodes(ax, field.get_coor(), field.aps[0].econn, field.aps[0].interp.poly_spaces['v'].nodes, get_dofs(options.dofs, var.n_dof)) pd.plt.show() output('dofs: %d' % var.n_dof) vec = nm.empty(var.n_dof, dtype=var.dtype) n_digit, _format = get_print_info(var.n_dof, fill='0') name_template = os.path.join(output_dir, 'dof_%s_%s.vtk' % (_format, suffix)) for ip in get_dofs(options.dofs, var.n_dof): output('dof %d...' % ip) vec.fill(0.0) vec[ip] = 1.0 var.set_data(vec) if options.derivative == 0: out = var.create_output(vec, linearization=lin) else: out = create_expression_output('ev_grad.ie.Elements(u)', 'u', 'f', {'f': field}, None, Variables([var]), mode='qp', verbose=False, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) name = name_template % ip ensure_path(name) out['u'].mesh.write(name, out=out) output('...done (%s)' % name)
def recover_bones( problem, micro_problem, region, eps0, ts, strain, dstrains, p_grad, pressures, corrs_permeability, corrs_rs, corrs_time_rs, corrs_pressure, corrs_time_pressure, var_names, naming_scheme = 'step_iel' ): r""" Notes ----- - note that .. math:: \widetilde{\pi}^P is in corrs_pressure -> from time correctors only 'u', 'dp' are needed. """ dim = problem.domain.mesh.dim vu, vp, vn, vpp1, vppp1 = var_names vdp = 'd' + vp variables = micro_problem.create_variables() to_output = variables.state_to_output micro_u, micro_p = variables[vu], variables[vp] micro_coor = micro_u.field.get_coor() nodes_yc = micro_problem.domain.regions['Yc'].all_vertices join = os.path.join aux = max(problem.domain.shape.n_gr, 2) format = get_print_info( aux, fill = '0' )[1] \ + '_' + get_print_info( problem.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) pressure = pressures[-1][ii,0,0,0] us = corrs_pressure[vu].data * pressure add_strain_rs(corrs_rs, strain, vu, dim, ii, out=us) ut = convolve_field_scalar(corrs_time_pressure[vu], pressures, ii, ts) ut += convolve_field_sym_tensor(corrs_time_rs, dstrains, vu, dim, ii, ts) u1 = us + ut u_mic = compute_u_from_macro(strain, micro_coor, ii ) + u1 ps = corrs_pressure[vp].data * pressure pt = convolve_field_scalar(corrs_time_pressure[vdp], pressures, ii, ts) pt += convolve_field_sym_tensor(corrs_time_rs, dstrains, vdp, dim, ii, ts) ## print us ## print ut ## print ps ## print pt p_hat = ps + pt # \eta_k \partial_k^x p p1 = combine_scalar_grad(corrs_permeability, p_grad, vn, ii) p_hat_e = micro_p.field.extend_dofs(p_hat[:,None], fill_value=0.0) p_mic = compute_p_from_macro(p_grad, micro_coor, ii)[:,None] \ + p_hat_e / eps0 p_mic[nodes_yc] = p1[:,None] ## print u_mic ## print p_mic # (y_k + \eta_k) \partial_k^x p p_aux = combine_scalar_grad(corrs_permeability, p_grad, vn, ii, shift_coors=micro_coor[nodes_yc]) meval = micro_problem.evaluate var_p = variables[vppp1] var_p.data_from_any(p_aux) dvel_m1 = meval('de_diffusion_velocity.i1.Yc( m.K, %s )' % vppp1, verbose=False, mode='el_avg', **{vppp1 : var_p}) var_p = variables[vpp1] var_p.data_from_any(p_hat) dvel_m2 = meval('de_diffusion_velocity.i1.Ym( m.K, %s )' % vpp1, verbose=False, mode='el_avg', **{vpp1 : var_p}) * eps0 out = {} out.update( to_output( u_mic, var_info = {vu : (True, vu)}, extend = True ) ) out[vp] = Struct(name = 'output_data', mode = 'vertex', data = p_mic, var_name = vp, dofs = micro_p.dofs) aux = extend_cell_data(dvel_m1, micro_problem.domain, 'Yc') out['dvel_m1'] = Struct(name = 'output_data', mode = 'cell', data = aux, dofs = None) aux = extend_cell_data(dvel_m2, micro_problem.domain, 'Ym') out['dvel_m2'] = Struct(name = 'output_data', mode = 'cell', data = aux, dofs = None) suffix = get_output_suffix(ig, iel, ts, naming_scheme, format, micro_problem.output_format) micro_name = micro_problem.get_output_name(extra=suffix) filename = join(problem.output_dir, 'recovered_' + os.path.basename(micro_name)) micro_problem.save_state(filename, out=out, ts=ts)
def main(): parser = OptionParser(usage=usage, version='%prog') parser.add_option('-b', '--basis', metavar='name', action='store', dest='basis', default='lagrange', help=help['basis']) parser.add_option('-d', '--derivative', metavar='d', type=int, action='store', dest='derivative', default=0, help=help['derivative']) parser.add_option('-n', '--max-order', metavar='order', type=int, action='store', dest='max_order', default=2, help=help['max_order']) parser.add_option('-g', '--geometry', metavar='name', action='store', dest='geometry', default='2_4', help=help['geometry']) parser.add_option('-m', '--mesh', metavar='mesh', action='store', dest='mesh', default=None, help=help['mesh']) parser.add_option('', '--permutations', metavar='permutations', action='store', dest='permutations', default=None, help=help['permutations']) parser.add_option('', '--dofs', metavar='dofs', action='store', dest='dofs', default=None, help=help['dofs']) parser.add_option('-l', '--lin-options', metavar='options', action='store', dest='lin_options', default='min_level=2,max_level=5,eps=1e-3', help=help['lin_options']) parser.add_option('', '--plot-dofs', action='store_true', dest='plot_dofs', default=False, help=help['plot_dofs']) options, args = parser.parse_args() if len(args) == 1: output_dir = args[0] else: parser.print_help(), return output('polynomial space:', options.basis) output('max. order:', options.max_order) lin = Struct(kind='adaptive', min_level=2, max_level=5, eps=1e-3) for opt in options.lin_options.split(','): key, val = opt.split('=') setattr(lin, key, eval(val)) if options.mesh is None: dim, n_ep = int(options.geometry[0]), int(options.geometry[2]) output('reference element geometry:') output(' dimension: %d, vertices: %d' % (dim, n_ep)) gel = GeometryElement(options.geometry) gps = PolySpace.any_from_args(None, gel, 1, base=options.basis) ps = PolySpace.any_from_args(None, gel, options.max_order, base=options.basis) n_digit, _format = get_print_info(ps.n_nod, fill='0') name_template = os.path.join(output_dir, 'bf_%s.vtk' % _format) for ip in get_dofs(options.dofs, ps.n_nod): output('shape function %d...' % ip) def eval_dofs(iels, rx): if options.derivative == 0: bf = ps.eval_base(rx).squeeze() rvals = bf[None, :, ip:ip + 1] else: bfg = ps.eval_base(rx, diff=True) rvals = bfg[None, ..., ip] return rvals def eval_coors(iels, rx): bf = gps.eval_base(rx).squeeze() coors = nm.dot(bf, gel.coors)[None, ...] return coors (level, coors, conn, vdofs, mat_ids) = create_output(eval_dofs, eval_coors, 1, ps, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) out = { 'bf': Struct(name='output_data', mode='vertex', data=vdofs, var_name='bf', dofs=None) } mesh = Mesh.from_data('bf_mesh', coors, None, [conn], [mat_ids], [options.geometry]) name = name_template % ip mesh.write(name, out=out) output('...done (%s)' % name) else: mesh = Mesh.from_file(options.mesh) output('mesh geometry:') output(' dimension: %d, vertices: %d, elements: %d' % (mesh.dim, mesh.n_nod, mesh.n_el)) domain = Domain('domain', mesh) if options.permutations: permutations = [int(ii) for ii in options.permutations.split(',')] output('using connectivity permutations:', permutations) for group in domain.iter_groups(): perms = group.gel.get_conn_permutations()[permutations] offsets = nm.arange(group.shape.n_el) * group.shape.n_ep group.conn[:] = group.conn.take(perms + offsets[:, None]) domain.setup_facets() omega = domain.create_region('Omega', 'all') field = Field.from_args('f', nm.float64, shape=1, region=omega, approx_order=options.max_order, poly_space_base=options.basis) var = FieldVariable('u', 'unknown', field, 1) if options.plot_dofs: import sfepy.postprocess.plot_dofs as pd group = domain.groups[0] ax = pd.plot_mesh(None, mesh.coors, mesh.conns[0], group.gel.edges) ax = pd.plot_global_dofs(ax, field.get_coor(), field.aps[0].econn) ax = pd.plot_local_dofs(ax, field.get_coor(), field.aps[0].econn) if options.dofs is not None: ax = pd.plot_nodes(ax, field.get_coor(), field.aps[0].econn, field.aps[0].interp.poly_spaces['v'].nodes, get_dofs(options.dofs, var.n_dof)) pd.plt.show() output('dofs: %d' % var.n_dof) vec = nm.empty(var.n_dof, dtype=var.dtype) n_digit, _format = get_print_info(var.n_dof, fill='0') name_template = os.path.join(output_dir, 'dof_%s.vtk' % _format) for ip in get_dofs(options.dofs, var.n_dof): output('dof %d...' % ip) vec.fill(0.0) vec[ip] = 1.0 var.set_data(vec) if options.derivative == 0: out = var.create_output(vec, linearization=lin) else: out = create_expression_output('ev_grad.ie.Elements(u)', 'u', 'f', {'f': field}, None, Variables([var]), mode='qp', verbose=False, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) name = name_template % ip out['u'].mesh.write(name, out=out) output('...done (%s)' % name)
def save_basis_on_mesh(mesh, options, output_dir, lin, permutations=None, suffix=''): domain = Domain('domain', mesh) if permutations is not None: for group in domain.iter_groups(): perms = group.gel.get_conn_permutations()[permutations] offsets = nm.arange(group.shape.n_el) * group.shape.n_ep group.conn[:] = group.conn.take(perms + offsets[:, None]) domain.setup_facets() omega = domain.create_region('Omega', 'all') field = Field.from_args('f', nm.float64, shape=1, region=omega, approx_order=options.max_order, poly_space_base=options.basis) var = FieldVariable('u', 'unknown', field, 1) if options.plot_dofs: import sfepy.postprocess.plot_dofs as pd group = domain.groups[0] ax = pd.plot_mesh(None, mesh.coors, mesh.conns[0], group.gel.edges) ax = pd.plot_global_dofs(ax, field.get_coor(), field.aps[0].econn) ax = pd.plot_local_dofs(ax, field.get_coor(), field.aps[0].econn) if options.dofs is not None: ax = pd.plot_nodes(ax, field.get_coor(), field.aps[0].econn, field.aps[0].interp.poly_spaces['v'].nodes, get_dofs(options.dofs, var.n_dof)) pd.plt.show() output('dofs: %d' % var.n_dof) vec = nm.empty(var.n_dof, dtype=var.dtype) n_digit, _format = get_print_info(var.n_dof, fill='0') name_template = os.path.join(output_dir, 'dof_%s_%s.vtk' % (_format, suffix)) for ip in get_dofs(options.dofs, var.n_dof): output('dof %d...' % ip) vec.fill(0.0) vec[ip] = 1.0 var.set_data(vec) if options.derivative == 0: out = var.create_output(vec, linearization=lin) else: out = create_expression_output('ev_grad.ie.Elements(u)', 'u', 'f', {'f' : field}, None, Variables([var]), mode='qp', verbose=False, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) name = name_template % ip ensure_path(name) out['u'].mesh.write(name, out=out) output('...done (%s)' % name)
def main(): parser = OptionParser(usage=usage, version='%prog') parser.add_option('-b', '--basis', metavar='name', action='store', dest='basis', default='lagrange', help=help['basis']) parser.add_option('-d', '--derivative', metavar='d', type=int, action='store', dest='derivative', default=0, help=help['derivative']) parser.add_option('-n', '--max-order', metavar='order', type=int, action='store', dest='max_order', default=2, help=help['max_order']) parser.add_option('-g', '--geometry', metavar='name', action='store', dest='geometry', default='2_4', help=help['geometry']) options, args = parser.parse_args() dim, n_ep = int(options.geometry[0]), int(options.geometry[2]) output('reference element geometry:') output(' dimension: %d, vertices: %d' % (dim, n_ep)) output('polynomial space:', options.basis) output('max. order:', options.max_order) gel = GeometryElement(options.geometry) gps = PolySpace.any_from_args(None, gel, 1, base=options.basis) ps = PolySpace.any_from_args(None, gel, options.max_order, base=options.basis) n_digit, _format = get_print_info(ps.n_nod, fill='0') name_template = 'bf_%s.vtk' % _format for ip in range(ps.n_nod): output('shape function %d...' % ip) def eval_dofs(iels, rx, bf): if options.derivative == 0: rvals = bf[None, :, ip:ip+1] else: bfg = ps.eval_base(rx, diff=True) rvals = bfg[None, ..., ip] return rvals def eval_coors(iels, rx): bf = gps.eval_base(rx).squeeze() coors = nm.dot(bf, gel.coors)[None, ...] return coors (level, coors, conn, vdofs, mat_ids) = create_output(eval_dofs, eval_coors, 1, ps, min_level=2, max_level=5, eps=1e-3) out = { 'bf' : Struct(name='output_data', mode='vertex', data=vdofs, var_name='bf', dofs=None) } mesh = Mesh.from_data('bf_mesh', coors, None, [conn], [mat_ids], [options.geometry]) name = name_template % ip mesh.write(name, out=out) output('...done (%s)' % name)
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 main(): parser = OptionParser(usage=usage, version='%prog') parser.add_option('-b', '--basis', metavar='name', action='store', dest='basis', default='lagrange', help=help['basis']) parser.add_option('-d', '--derivative', metavar='d', type=int, action='store', dest='derivative', default=0, help=help['derivative']) parser.add_option('-n', '--max-order', metavar='order', type=int, action='store', dest='max_order', default=2, help=help['max_order']) parser.add_option('-g', '--geometry', metavar='name', action='store', dest='geometry', default='2_4', help=help['geometry']) parser.add_option('-m', '--mesh', metavar='mesh', action='store', dest='mesh', default=None, help=help['mesh']) parser.add_option('', '--permutations', metavar='permutations', action='store', dest='permutations', default=None, help=help['permutations']) parser.add_option('', '--dofs', metavar='dofs', action='store', dest='dofs', default=None, help=help['dofs']) parser.add_option('-l', '--lin-options', metavar='options', action='store', dest='lin_options', default='min_level=2,max_level=5,eps=1e-3', help=help['lin_options']) parser.add_option('', '--plot-dofs', action='store_true', dest='plot_dofs', default=False, help=help['plot_dofs']) options, args = parser.parse_args() if len(args) == 1: output_dir = args[0] else: parser.print_help(), return output('polynomial space:', options.basis) output('max. order:', options.max_order) lin = Struct(kind='adaptive', min_level=2, max_level=5, eps=1e-3) for opt in options.lin_options.split(','): key, val = opt.split('=') setattr(lin, key, eval(val)) if options.mesh is None: dim, n_ep = int(options.geometry[0]), int(options.geometry[2]) output('reference element geometry:') output(' dimension: %d, vertices: %d' % (dim, n_ep)) gel = GeometryElement(options.geometry) gps = PolySpace.any_from_args(None, gel, 1, base=options.basis) ps = PolySpace.any_from_args(None, gel, options.max_order, base=options.basis) n_digit, _format = get_print_info(ps.n_nod, fill='0') name_template = os.path.join(output_dir, 'bf_%s.vtk' % _format) for ip in get_dofs(options.dofs, ps.n_nod): output('shape function %d...' % ip) def eval_dofs(iels, rx): if options.derivative == 0: bf = ps.eval_base(rx).squeeze() rvals = bf[None, :, ip:ip+1] else: bfg = ps.eval_base(rx, diff=True) rvals = bfg[None, ..., ip] return rvals def eval_coors(iels, rx): bf = gps.eval_base(rx).squeeze() coors = nm.dot(bf, gel.coors)[None, ...] return coors (level, coors, conn, vdofs, mat_ids) = create_output(eval_dofs, eval_coors, 1, ps, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) out = { 'bf' : Struct(name='output_data', mode='vertex', data=vdofs, var_name='bf', dofs=None) } mesh = Mesh.from_data('bf_mesh', coors, None, [conn], [mat_ids], [options.geometry]) name = name_template % ip ensure_path(name) mesh.write(name, out=out) output('...done (%s)' % name) else: mesh = Mesh.from_file(options.mesh) output('mesh geometry:') output(' dimension: %d, vertices: %d, elements: %d' % (mesh.dim, mesh.n_nod, mesh.n_el)) if options.permutations: if options.permutations == 'all': from sfepy.linalg import cycle gel = GeometryElement(mesh.descs[0]) n_perms = gel.get_conn_permutations().shape[0] all_permutations = [ii for ii in cycle(mesh.n_el * [n_perms])] else: all_permutations = [int(ii) for ii in options.permutations.split(',')] all_permutations = nm.array(all_permutations) np = len(all_permutations) all_permutations.shape = (np / mesh.n_el, mesh.n_el) output('using connectivity permutations:\n', all_permutations) else: all_permutations = [None] for ip, permutations in enumerate(all_permutations): if permutations is None: suffix = '' else: suffix = '_' + '_'.join('%d' % ii for ii in permutations) save_basis_on_mesh(mesh, options, output_dir, lin, permutations, suffix)
def save_basis_on_mesh(mesh, options, output_dir, lin, permutations=None, suffix=''): if permutations is not None: mesh = mesh.copy() gel = GeometryElement(mesh.descs[0]) perms = gel.get_conn_permutations()[permutations] conn = mesh.cmesh.get_cell_conn() n_el, n_ep = conn.num, gel.n_vertex offsets = nm.arange(n_el) * n_ep conn.indices[:] = conn.indices.take((perms + offsets[:, None]).ravel()) domain = FEDomain('domain', mesh) omega = domain.create_region('Omega', 'all') field = Field.from_args('f', nm.float64, shape=1, region=omega, approx_order=options.max_order, poly_space_base=options.basis) var = FieldVariable('u', 'unknown', field) if options.plot_dofs: import sfepy.postprocess.plot_dofs as pd import sfepy.postprocess.plot_cmesh as pc ax = pc.plot_wireframe(None, mesh.cmesh) ax = pd.plot_global_dofs(ax, field.get_coor(), field.econn) ax = pd.plot_local_dofs(ax, field.get_coor(), field.econn) if options.dofs is not None: ax = pd.plot_nodes(ax, field.get_coor(), field.econn, field.poly_space.nodes, get_dofs(options.dofs, var.n_dof)) pd.plt.show() output('dofs: %d' % var.n_dof) vec = nm.empty(var.n_dof, dtype=var.dtype) n_digit, _format = get_print_info(var.n_dof, fill='0') name_template = os.path.join(output_dir, 'dof_%s%s.vtk' % (_format, suffix)) for ip in get_dofs(options.dofs, var.n_dof): output('dof %d...' % ip) vec.fill(0.0) vec[ip] = 1.0 var.set_data(vec) if options.derivative == 0: out = var.create_output(vec, linearization=lin) else: out = create_expression_output('ev_grad.ie.Elements(u)', 'u', 'f', {'f' : field}, None, Variables([var]), mode='qp', verbose=False, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) name = name_template % ip ensure_path(name) out['u'].mesh.write(name, out=out) output('...done (%s)' % name)
def recover_paraflow( problem, micro_problem, region, ts, strain, dstrains, pressures1, pressures2, corrs_rs, corrs_time_rs, corrs_alpha1, corrs_time_alpha1, corrs_alpha2, corrs_time_alpha2, var_names, naming_scheme = 'step_iel' ): dim = problem.domain.mesh.dim vu, vp = var_names vdp = 'd' + vp micro_u = micro_problem.variables[vu] micro_coor = micro_u.field.get_coor() micro_n_nod = micro_problem.domain.mesh.n_nod micro_p = micro_problem.variables[vp] nodes_y1 = micro_problem.domain.regions['Y1'].all_vertices nodes_y2 = micro_problem.domain.regions['Y2'].all_vertices to_output = micro_problem.variables.state_to_output join = os.path.join aux = max(problem.domain.shape.n_gr, 2) format = get_print_info( aux, fill = '0' )[1] \ + '_' + get_print_info( problem.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) p1, p2 = pressures1[-1][ii,0,0,0], pressures2[-1][ii,0,0,0] us = corrs_alpha1[vu].data * p1 + corrs_alpha2[vu].data * p2 add_strain_rs( corrs_rs, strain, vu, dim, ii, out = us ) ut = convolve_field_scalar( corrs_time_alpha1[vu], pressures1, ii, ts ) ut += convolve_field_scalar( corrs_time_alpha2[vu], pressures2, ii, ts ) ut += convolve_field_sym_tensor( corrs_time_rs, dstrains, vu, dim, ii, ts ) u_corr = us + ut u_mic = compute_u_from_macro( strain, micro_coor, ii ) + u_corr ps = corrs_alpha1[vp].data * p1 + corrs_alpha2[vp].data * p2 pt = convolve_field_scalar( corrs_time_alpha1[vdp], pressures1, ii, ts ) pt += convolve_field_scalar( corrs_time_alpha2[vdp], pressures2, ii, ts ) pt += convolve_field_sym_tensor( corrs_time_rs, dstrains, vdp, dim, ii, ts ) p_corr = ps + pt p_mic = micro_p.field.extend_dofs(p_corr[:,nm.newaxis]) p_mic[nodes_y1] = p1 p_mic[nodes_y2] = p2 out = {} out.update( to_output( u_mic, var_info = {vu : (True, vu)}, extend = True ) ) out[vp] = Struct( name = 'output_data', mode = 'vertex', data = p_mic, var_name = vp, dofs = micro_p.dofs ) suffix = get_output_suffix(ig, iel, ts, naming_scheme, format, micro_problem.output_format) micro_name = micro_problem.get_output_name(extra=suffix) filename = join( problem.output_dir, 'recovered_' + micro_name ) micro_problem.save_state(filename, out=out, ts=ts)