def _first(self): args = self.args error_product = self.discretization.h1_product if args['--estimator-norm'] == 'h1' else None reductor = partial(reduce_stationary_affine_linear, error_product=error_product) greedy_data = greedy(self.discretization, reductor, self.discretization.parameter_space.sample_uniformly(args['SNAPSHOTS']), use_estimator=True, error_norm=self.discretization.h1_norm, extension_algorithm=gram_schmidt_basis_extension, max_extensions=args['RBSIZE']) self.rb_discretization, self.reconstructor = greedy_data['reduced_discretization'], greedy_data['reconstructor'] self.first = False
def dune_thermalblock_demo(args): args['SNAPSHOTS'] = int(args['SNAPSHOTS']) args['RBSIZE'] = int(args['RBSIZE']) args['--test'] = int(args['--test']) args['--estimator-norm'] = args['--estimator-norm'].lower() assert args['--estimator-norm'] in {'trivial', 'h1'} args['--extension-alg'] = args['--extension-alg'].lower() assert args['--extension-alg'] in {'trivial', 'gram_schmidt'} print('Discretize ...') discretization = DuneLinearEllipticCGDiscretization() print(discretization.parameter_info()) if args['--plot-solutions']: print('Showing some solutions') for mu in discretization.parameter_space.sample_randomly(2): print('Solving for diffusion = \n{} ... '.format(mu['diffusion'])) sys.stdout.flush() U = discretization.solve(mu) discretization.visualize(U) print('RB generation ...') error_product = discretization.h1_product if args['--estimator-norm'] == 'h1' else None reductor = partial(reduce_stationary_affine_linear, error_product=error_product) extension_algorithm = (gram_schmidt_basis_extension if args['--extension-alg'] == 'gram_schmidt' else trivial_basis_extension) greedy_data = greedy(discretization, reductor, discretization.parameter_space.sample_uniformly(args['SNAPSHOTS']), initial_data = DuneVectorArray.empty(dim=discretization.solution_dim), use_estimator=args['--with-estimator'], error_norm=discretization.h1_norm, extension_algorithm=extension_algorithm, max_extensions=args['RBSIZE']) rb_discretization, reconstructor = greedy_data['reduced_discretization'], greedy_data['reconstructor'] print('\nSearching for maximum error on random snapshots ...') tic = time.time() h1_err_max = -1 cond_max = -1 for mu in discretization.parameter_space.sample_randomly(args['--test']): print('Solving RB-Scheme for mu = {} ... '.format(mu), end='') URB = reconstructor.reconstruct(rb_discretization.solve(mu)) U = discretization.solve(mu) h1_err = discretization.h1_norm(U - URB) cond = np.linalg.cond(rb_discretization.operator.assemble(mu)._matrix) if h1_err > h1_err_max: h1_err_max = h1_err Umax = U URBmax = URB mumax = mu if cond > cond_max: cond_max = cond cond_max_mu = mu print('H1-error = {}, condition = {}'.format(h1_err, cond)) toc = time.time() t_est = toc - tic real_rb_size = len(greedy_data['data']) print(''' *** RESULTS *** Greedy basis generation: used estimator: {args[--with-estimator]} estimator norm: {args[--estimator-norm]} extension method: {args[--extension-alg]} prescribed basis size: {args[RBSIZE]} actual basis size: {real_rb_size} elapsed time: {greedy_data[time]} Stochastic error estimation: number of samples: {args[--test]} maximal H1-error: {h1_err_max} (mu = {mumax}) maximal condition of system matrix: {cond_max} (mu = {cond_max_mu}) elapsed time: {t_est} '''.format(**locals())) sys.stdout.flush() if args['--plot-err']: discretization.visualize(Umax - URBmax)
def thermalblock_demo(args): args['XBLOCKS'] = int(args['XBLOCKS']) args['YBLOCKS'] = int(args['YBLOCKS']) args['--grid'] = int(args['--grid']) args['SNAPSHOTS'] = int(args['SNAPSHOTS']) args['RBSIZE'] = int(args['RBSIZE']) args['--test'] = int(args['--test']) args['--estimator-norm'] = args['--estimator-norm'].lower() assert args['--estimator-norm'] in {'trivial', 'h1'} args['--extension-alg'] = args['--extension-alg'].lower() assert args['--extension-alg'] in {'trivial', 'gram_schmidt', 'h1_gram_schmidt'} args['--reductor'] = args['--reductor'].lower() assert args['--reductor'] in {'default', 'numpy_default'} import IPython.parallel as p from pymor.playground.remote import setup_remote, RemoteStationaryDiscretization rc = p.Client() rv = rc[0] print('Discretize ...') rv.execute(''' import numpy as np import pymor.core as core core.logger.MAX_HIERACHY_LEVEL = 2 from pymor.analyticalproblems import ThermalBlockProblem from pymor.discretizers import discretize_elliptic_cg core.getLogger('pymor.algorithms').setLevel('INFO') core.getLogger('pymor.discretizations').setLevel('INFO') core.getLogger('pymor.la').setLevel('INFO') print('Setup Problem ...') problem = ThermalBlockProblem(num_blocks=({nx}, {ny})) print('Discretize ...') discretization, _ = discretize_elliptic_cg(problem, diameter=m.sqrt(2) / {grid}) '''.format(nx=args['XBLOCKS'], ny=args['YBLOCKS'], grid=args['--grid'])) discretization_id = setup_remote(rv, 'discretization') discretization = RemoteStationaryDiscretization(rv, discretization_id) print('The parameter type is {}'.format(discretization.parameter_type)) print('RB generation ...') error_product = discretization.h1_product if args['--estimator-norm'] == 'h1' else None reductors = {'default': partial(reduce_stationary_affine_linear, error_product=error_product)} reductor = reductors[args['--reductor']] extension_algorithms = {'trivial': trivial_basis_extension, 'gram_schmidt': gram_schmidt_basis_extension, 'h1_gram_schmidt': partial(gram_schmidt_basis_extension, product=discretization.h1_product)} extension_algorithm = extension_algorithms[args['--extension-alg']] greedy_data = greedy(discretization, reductor, discretization.parameter_space.sample_uniformly(args['SNAPSHOTS']), use_estimator=args['--with-estimator'], error_norm=discretization.h1_norm, initial_basis=discretization.operator.type_source.empty(dim=discretization.operator.dim_source), # NOQA extension_algorithm=extension_algorithm, max_extensions=args['RBSIZE']) rb_discretization, reconstructor = greedy_data['reduced_discretization'], greedy_data['reconstructor'] print('\nSearching for maximum error on random snapshots ...') tic = time.time() h1_err_max = -1 cond_max = -1 for mu in discretization.parameter_space.sample_randomly(args['--test']): print('Solving RB-Scheme for mu = {} ... '.format(mu), end='') URB = reconstructor.reconstruct(rb_discretization.solve(mu)) U = discretization.solve(mu) h1_err = discretization.h1_norm(U - URB)[0] cond = np.linalg.cond(rb_discretization.operator.assemble(mu)._matrix) if h1_err > h1_err_max: h1_err_max = h1_err Umax = U URBmax = URB mumax = mu if cond > cond_max: cond_max = cond cond_max_mu = mu print('H1-error = {}, condition = {}'.format(h1_err, cond)) toc = time.time() t_est = toc - tic real_rb_size = len(greedy_data['basis']) print(''' *** RESULTS *** Problem: number of blocks: {args[XBLOCKS]}x{args[YBLOCKS]} h: sqrt(2)/{args[--grid]} Greedy basis generation: number of snapshots: {args[SNAPSHOTS]}^({args[XBLOCKS]}x{args[YBLOCKS]}) used estimator: {args[--with-estimator]} estimator norm: {args[--estimator-norm]} extension method: {args[--extension-alg]} prescribed basis size: {args[RBSIZE]} actual basis size: {real_rb_size} elapsed time: {greedy_data[time]} Stochastic error estimation: number of samples: {args[--test]} maximal H1-error: {h1_err_max} (mu = {mumax}) maximal condition of system matrix: {cond_max} (mu = {cond_max_mu}) elapsed time: {t_est} '''.format(**locals())) sys.stdout.flush()
def burgers_demo(args): args['--grid'] = int(args['--grid']) args['--grid-type'] = args['--grid-type'].lower() assert args['--grid-type'] in ('rect', 'tria') args['--initial-data'] = args['--initial-data'].lower() assert args['--initial-data'] in ('sin', 'bump') args['--lxf-lambda'] = float(args['--lxf-lambda']) args['--nt'] = int(args['--nt']) args['--not-periodic'] = bool(args['--not-periodic']) args['--num-flux'] = args['--num-flux'].lower() assert args['--num-flux'] in ('lax_friedrichs', 'engquist_osher') args['--plot-error-landscape-N'] = int(args['--plot-error-landscape-N']) args['--plot-error-landscape-M'] = int(args['--plot-error-landscape-M']) args['--test'] = int(args['--test']) args['--vx'] = float(args['--vx']) args['--vy'] = float(args['--vy']) args['EXP_MIN'] = int(args['EXP_MIN']) args['EXP_MAX'] = int(args['EXP_MAX']) args['EI_SNAPSHOTS'] = int(args['EI_SNAPSHOTS']) args['EISIZE'] = int(args['EISIZE']) args['SNAPSHOTS'] = int(args['SNAPSHOTS']) args['RBSIZE'] = int(args['RBSIZE']) print('Setup Problem ...') grid_type_map = {'rect': RectGrid, 'tria': TriaGrid} domain_discretizer = partial(discretize_domain_default, grid_type=grid_type_map[args['--grid-type']]) problem = Burgers2DProblem(vx=args['--vx'], vy=args['--vy'], initial_data_type=args['--initial-data'], parameter_range=(args['EXP_MIN'], args['EXP_MAX']), torus=not args['--not-periodic']) print('Discretize ...') discretizer = discretize_nonlinear_instationary_advection_fv discretization, _ = discretizer(problem, diameter=m.sqrt(2) / args['--grid'], num_flux=args['--num-flux'], lxf_lambda=args['--lxf-lambda'], nt=args['--nt'], domain_discretizer=domain_discretizer) print(discretization.operator.grid) print('The parameter type is {}'.format(discretization.parameter_type)) if args['--plot-solutions']: print('Showing some solutions') Us = tuple() legend = tuple() for mu in discretization.parameter_space.sample_uniformly(4): print('Solving for exponent = {} ... '.format(mu['exponent'])) sys.stdout.flush() Us = Us + (discretization.solve(mu),) legend = legend + ('exponent: {}'.format(mu['exponent']),) discretization.visualize(Us, legend=legend, title='Detailed Solutions', block=True) ei_discretization, ei_data = interpolate_operators(discretization, ['operator'], discretization.parameter_space.sample_uniformly(args['EI_SNAPSHOTS']), # NOQA error_norm=discretization.l2_norm, target_error=1e-10, max_interpolation_dofs=args['EISIZE'], projection='orthogonal', product=discretization.l2_product) if args['--plot-ei-err']: print('Showing some EI errors') ERRs = tuple() legend = tuple() for mu in discretization.parameter_space.sample_randomly(2): print('Solving for exponent = \n{} ... '.format(mu['exponent'])) sys.stdout.flush() U = discretization.solve(mu) U_EI = ei_discretization.solve(mu) ERR = U - U_EI ERRs = ERRs + (ERR,) legend = legend + ('exponent: {}'.format(mu['exponent']),) print('Error: {}'.format(np.max(discretization.l2_norm(ERR)))) discretization.visualize(ERRs, legend=legend, title='EI Errors', separate_colorbars=True) print('Showing interpolation DOFs ...') U = np.zeros(U.dim) dofs = ei_discretization.operator.interpolation_dofs U[dofs] = np.arange(1, len(dofs) + 1) U[ei_discretization.operator.source_dofs] += int(len(dofs)/2) discretization.visualize(NumpyVectorArray(U), title='Interpolation DOFs') print('RB generation ...') def reductor(discretization, rb, extends=None): return reduce_generic_rb(ei_discretization, rb, extends=extends) extension_algorithm = partial(pod_basis_extension) greedy_data = greedy(discretization, reductor, discretization.parameter_space.sample_uniformly(args['SNAPSHOTS']), use_estimator=False, error_norm=lambda U: np.max(discretization.l2_norm(U)), extension_algorithm=extension_algorithm, max_extensions=args['RBSIZE']) rb_discretization, reconstructor = greedy_data['reduced_discretization'], greedy_data['reconstructor'] print('\nSearching for maximum error on random snapshots ...') tic = time.time() mus = list(discretization.parameter_space.sample_randomly(args['--test'])) def error_analysis(N, M): print('N = {}, M = {}: '.format(N, M), end='') rd, rc, _ = reduce_to_subbasis(rb_discretization, N, reconstructor) rd = rd.with_(operator=rd.operator.projected_to_subbasis(dim_collateral=M)) l2_err_max = -1 mumax = None for mu in mus: print('.', end='') sys.stdout.flush() u = rd.solve(mu) URB = rc.reconstruct(u) U = discretization.solve(mu) l2_err = np.max(discretization.l2_norm(U - URB)) l2_err = np.inf if not np.isfinite(l2_err) else l2_err if l2_err > l2_err_max: l2_err_max = l2_err mumax = mu print() return l2_err_max, mumax error_analysis = np.frompyfunc(error_analysis, 2, 2) real_rb_size = len(greedy_data['basis']) real_cb_size = len(ei_data['basis']) if args['--plot-error-landscape']: N_count = min(real_rb_size - 1, args['--plot-error-landscape-N']) M_count = min(real_cb_size - 1, args['--plot-error-landscape-M']) Ns = np.linspace(1, real_rb_size, N_count).astype(np.int) Ms = np.linspace(1, real_cb_size, M_count).astype(np.int) else: Ns = np.array([real_rb_size]) Ms = np.array([real_cb_size]) N_grid, M_grid = np.meshgrid(Ns, Ms) errs, err_mus = error_analysis(N_grid, M_grid) errs = errs.astype(np.float) l2_err_max = errs[-1, -1] mumax = err_mus[-1, -1] toc = time.time() t_est = toc - tic print(''' *** RESULTS *** Problem: parameter range: ({args[EXP_MIN]}, {args[EXP_MAX]}) h: sqrt(2)/{args[--grid]} grid-type: {args[--grid-type]} initial-data: {args[--initial-data]} lxf-lambda: {args[--lxf-lambda]} nt: {args[--nt]} not-periodic: {args[--not-periodic]} num-flux: {args[--num-flux]} (vx, vy): ({args[--vx]}, {args[--vy]}) Greedy basis generation: number of ei-snapshots: {args[EI_SNAPSHOTS]} prescribed collateral basis size: {args[EISIZE]} actual collateral basis size: {real_cb_size} number of snapshots: {args[SNAPSHOTS]} prescribed basis size: {args[RBSIZE]} actual basis size: {real_rb_size} elapsed time: {greedy_data[time]} Stochastic error estimation: number of samples: {args[--test]} maximal L2-error: {l2_err_max} (mu = {mumax}) elapsed time: {t_est} '''.format(**locals())) sys.stdout.flush() if args['--plot-error-landscape']: import matplotlib.pyplot as plt import mpl_toolkits.mplot3d # NOQA fig = plt.figure() ax = fig.add_subplot(111, projection='3d') # we have to rescale the errors since matplotlib does not support logarithmic scales on 3d plots # https://github.com/matplotlib/matplotlib/issues/209 surf = ax.plot_surface(M_grid, N_grid, np.log(np.minimum(errs, 1)) / np.log(10), rstride=1, cstride=1, cmap='jet') plt.show() if args['--plot-err']: U = discretization.solve(mumax) URB = reconstructor.reconstruct(rb_discretization.solve(mumax)) discretization.visualize((U, URB, U - URB), legend=('Detailed Solution', 'Reduced Solution', 'Error'), title='Maximum Error Solution', separate_colorbars=True)
def perform_standard_rb(config, detailed_discretization, training_samples): # parse config reductor_id = config.get('pymor', 'reductor') if reductor_id == 'generic': reductor = reduce_generic_rb elif reductor_id == 'stationary_affine_linear': reductor_error_product = config.get('pymor', 'reductor_error_product') assert reductor_error_product == 'None' reductor_error_product = None reductor = partial(reduce_stationary_affine_linear, error_product=reductor_error_product) else: raise ConfigError('unknown \'pymor.reductor\' given: \'{}\''.format(reductor_id)) # first the extension algorithm product, if needed extension_algorithm_id = config.get('pymor', 'extension_algorithm') if extension_algorithm_id in {'gram_schmidt', 'pod'}: extension_algorithm_product_id = config.get('pymor', 'extension_algorithm_product') if extension_algorithm_product_id == 'None': extension_algorithm_product = None else: extension_algorithm_product = detailed_discretization.products[extension_algorithm_product_id] # then the extension algorithm extension_algorithm_id = config.get('pymor', 'extension_algorithm') if extension_algorithm_id == 'gram_schmidt': extension_algorithm = partial(gram_schmidt_basis_extension, product=extension_algorithm_product) extension_algorithm_id += ' ({})'.format(extension_algorithm_product_id) elif extension_algorithm_id == 'pod': extension_algorithm = partial(pod_basis_extension, product=extension_algorithm_product) extension_algorithm_id += ' ({})'.format(extension_algorithm_product_id) elif extension_algorithm_id == 'trivial': extension_algorithm = trivial_basis_extension else: raise ConfigError('unknown \'pymor.extension_algorithm\' given: \'{}\''.format(extension_algorithm_id)) greedy_error_norm_id = config.get('pymor', 'greedy_error_norm') assert greedy_error_norm_id in {'l2', 'h1_semi'} greedy_error_norm = induced_norm(detailed_discretization.products[greedy_error_norm_id]) greedy_use_estimator = config.getboolean('pymor', 'use_estimator') greedy_max_rb_size = config.getint('pymor', 'max_rb_size') greedy_target_error = config.getfloat('pymor', 'target_error') # do the actual work greedy_data = greedy(detailed_discretization, reductor, training_samples, initial_basis=detailed_discretization.functionals['rhs'].type_source.empty( dim=detailed_discretization.functionals['rhs'].dim_source), use_estimator=greedy_use_estimator, error_norm=greedy_error_norm, extension_algorithm=extension_algorithm, max_extensions=greedy_max_rb_size, target_error=greedy_target_error) reduced_basis = greedy_data['basis'] rb_size = len(reduced_basis) # perform final compression final_compression = config.getboolean('pymor', 'final_compression') if final_compression: t = time.time() logger.info('Applying final compression ...') # select product compression_product_id = config.get('pymor', 'compression_product') if compression_product_id == 'None': compression_product = None else: compression_product = detailed_discretization.products[compression_product_id] # do the actual work reduced_basis = pod(reduced_basis, product=compression_product) rd, rc, _ = reductor(detailed_discretization, reduced_basis) greedy_data['reduced_discretization'], greedy_data['reconstructor'] = rd, rc time_compression = time.time() - t compressed_rb_size = len(reduced_basis) #report report_string = ''' Greedy basis generation: used estimator: {greedy_use_estimator} error norm: {greedy_error_norm_id} extension method: {extension_algorithm_id} prescribed basis size: {greedy_max_rb_size} prescribed error: {greedy_target_error} actual basis size: {rb_size} greedy time: {greedy_data[time]} compression method: pod ({compression_product_id}) compressed basis size: {compressed_rb_size} final compression time: {time_compression} '''.format(**locals()) else: #report report_string = ''' Greedy basis generation: used estimator: {greedy_use_estimator} error norm: {greedy_error_norm_id} extension method: {extension_algorithm_id} prescribed basis size: {greedy_max_rb_size} prescribed error: {greedy_target_error} actual basis size: {rb_size} elapsed time: {greedy_data[time]} '''.format(**locals()) return report_string, greedy_data
def thermalblock_demo(args): args['XBLOCKS'] = int(args['XBLOCKS']) args['YBLOCKS'] = int(args['YBLOCKS']) args['--grid'] = int(args['--grid']) args['SNAPSHOTS'] = int(args['SNAPSHOTS']) args['RBSIZE'] = int(args['RBSIZE']) args['--test'] = int(args['--test']) args['--estimator-norm'] = args['--estimator-norm'].lower() assert args['--estimator-norm'] in {'trivial', 'h1'} args['--extension-alg'] = args['--extension-alg'].lower() assert args['--extension-alg'] in {'trivial', 'gram_schmidt', 'h1_gram_schmidt'} print('Solving on TriaGrid(({0},{0}))'.format(args['--grid'])) print('Setup Problem ...') problem = ThermalBlockProblem(num_blocks=(args['XBLOCKS'], args['YBLOCKS'])) print('Discretize ...') discretization, _ = discretize_elliptic_cg(problem, diameter=m.sqrt(2) / args['--grid']) print('The parameter type is {}'.format(discretization.parameter_type)) if args['--plot-solutions']: print('Showing some solutions') Us = tuple() legend = tuple() for mu in discretization.parameter_space.sample_randomly(2): print('Solving for diffusion = \n{} ... '.format(mu['diffusion'])) sys.stdout.flush() Us = Us + (discretization.solve(mu),) legend = legend + (str(mu['diffusion']),) discretization.visualize(Us, legend=legend, title='Detailed Solutions for different parameters', block=True) print('RB generation ...') error_product = discretization.h1_product if args['--estimator-norm'] == 'h1' else None reductor = partial(reduce_stationary_affine_linear, error_product=error_product) extension_algorithms = {'trivial': trivial_basis_extension, 'gram_schmidt': gram_schmidt_basis_extension, 'h1_gram_schmidt': partial(gram_schmidt_basis_extension, product=discretization.h1_product)} extension_algorithm = extension_algorithms[args['--extension-alg']] greedy_data = greedy(discretization, reductor, discretization.parameter_space.sample_uniformly(args['SNAPSHOTS']), use_estimator=args['--with-estimator'], error_norm=discretization.h1_norm, extension_algorithm=extension_algorithm, max_extensions=args['RBSIZE']) rb_discretization, reconstructor = greedy_data['reduced_discretization'], greedy_data['reconstructor'] print('\nSearching for maximum error on random snapshots ...') def error_analysis(d, rd, rc, mus): print('N = {}: '.format(rd.operator.dim_source), end='') h1_err_max = -1 h1_est_max = -1 cond_max = -1 for mu in mus: print('.', end='') u = rd.solve(mu) URB = rc.reconstruct(u) U = d.solve(mu) h1_err = d.h1_norm(U - URB)[0] h1_est = rd.estimate(u, mu=mu) cond = np.linalg.cond(rd.operator.assemble(mu)._matrix) if h1_err > h1_err_max: h1_err_max = h1_err mumax = mu if h1_est > h1_est_max: h1_est_max = h1_est mu_est_max = mu if cond > cond_max: cond_max = cond cond_max_mu = mu print() return h1_err_max, mumax, h1_est_max, mu_est_max, cond_max, cond_max_mu tic = time.time() real_rb_size = len(greedy_data['basis']) if args['--plot-error-sequence']: N_count = min(real_rb_size - 1, 25) Ns = np.linspace(1, real_rb_size, N_count).astype(np.int) else: Ns = np.array([real_rb_size]) rd_rcs = [reduce_to_subbasis(rb_discretization, N, reconstructor)[:2] for N in Ns] mus = list(discretization.parameter_space.sample_randomly(args['--test'])) errs, err_mus, ests, est_mus, conds, cond_mus = zip(*(error_analysis(discretization, rd, rc, mus) for rd, rc in rd_rcs)) h1_err_max = errs[-1] mumax = err_mus[-1] cond_max = conds[-1] cond_max_mu = cond_mus[-1] toc = time.time() t_est = toc - tic print(''' *** RESULTS *** Problem: number of blocks: {args[XBLOCKS]}x{args[YBLOCKS]} h: sqrt(2)/{args[--grid]} Greedy basis generation: number of snapshots: {args[SNAPSHOTS]}^({args[XBLOCKS]}x{args[YBLOCKS]}) used estimator: {args[--with-estimator]} estimator norm: {args[--estimator-norm]} extension method: {args[--extension-alg]} prescribed basis size: {args[RBSIZE]} actual basis size: {real_rb_size} elapsed time: {greedy_data[time]} Stochastic error estimation: number of samples: {args[--test]} maximal H1-error: {h1_err_max} (mu = {mumax}) maximal condition of system matrix: {cond_max} (mu = {cond_max_mu}) elapsed time: {t_est} '''.format(**locals())) sys.stdout.flush() if args['--plot-error-sequence']: plt.semilogy(Ns, errs, Ns, ests) plt.legend(('error', 'estimator')) plt.show() if args['--plot-err']: U = discretization.solve(mumax) URB = reconstructor.reconstruct(rb_discretization.solve(mumax)) discretization.visualize((U, URB, U - URB), legend=('Detailed Solution', 'Reduced Solution', 'Error'), title='Maximum Error Solution', separate_colorbars=True, block=True)
def thermalblock_demo(args): args['XBLOCKS'] = int(args['XBLOCKS']) args['YBLOCKS'] = int(args['YBLOCKS']) args['--grid'] = int(args['--grid']) args['SNAPSHOTS'] = int(args['SNAPSHOTS']) args['RBSIZE'] = int(args['RBSIZE']) args['--test'] = int(args['--test']) args['--estimator-norm'] = args['--estimator-norm'].lower() assert args['--estimator-norm'] in {'trivial', 'h1'} args['--extension-alg'] = args['--extension-alg'].lower() assert args['--extension-alg'] in {'trivial', 'gram_schmidt', 'h1_gram_schmidt', 'numpy_trivial', 'numpy_gram_schmidt'} args['--reductor'] = args['--reductor'].lower() assert args['--reductor'] in {'default', 'numpy_default'} print('Solving on TriaGrid(({0},{0}))'.format(args['--grid'])) print('Setup Problem ...') problem = ThermalBlockProblem(num_blocks=(args['XBLOCKS'], args['YBLOCKS'])) print('Discretize ...') discretization, _ = discretize_elliptic_cg(problem, diameter=m.sqrt(2) / args['--grid']) print(discretization.parameter_info()) if args['--plot-solutions']: print('Showing some solutions') for mu in discretization.parameter_space.sample_randomly(2): print('Solving for diffusion = \n{} ... '.format(mu['diffusion'])) sys.stdout.flush() U = discretization.solve(mu) discretization.visualize(U) print('RB generation ...') error_product = discretization.h1_product if args['--estimator-norm'] == 'h1' else None reductors = {'default': partial(reduce_stationary_affine_linear, error_product=error_product), 'numpy_default': partial(numpy_reduce_stationary_affine_linear, error_product=error_product)} reductor = reductors[args['--reductor']] extension_algorithms = {'trivial': trivial_basis_extension, 'gram_schmidt': gram_schmidt_basis_extension, 'h1_gram_schmidt': partial(gram_schmidt_basis_extension, product=discretization.h1_product), 'numpy_trivial': numpy_trivial_basis_extension, 'numpy_gram_schmidt': numpy_gram_schmidt_basis_extension} extension_algorithm = extension_algorithms[args['--extension-alg']] greedy_data = greedy(discretization, reductor, discretization.parameter_space.sample_uniformly(args['SNAPSHOTS']), use_estimator=args['--with-estimator'], error_norm=discretization.h1_norm, extension_algorithm=extension_algorithm, max_extensions=args['RBSIZE']) rb_discretization, reconstructor = greedy_data['reduced_discretization'], greedy_data['reconstructor'] print('\nSearching for maximum error on random snapshots ...') tic = time.time() h1_err_max = -1 cond_max = -1 for mu in discretization.parameter_space.sample_randomly(args['--test']): print('Solving RB-Scheme for mu = {} ... '.format(mu), end='') URB = reconstructor.reconstruct(rb_discretization.solve(mu)) U = discretization.solve(mu) h1_err = discretization.h1_norm(U - URB)[0] cond = np.linalg.cond(rb_discretization.operator.assemble(mu)._matrix) if h1_err > h1_err_max: h1_err_max = h1_err Umax = U URBmax = URB mumax = mu if cond > cond_max: cond_max = cond cond_max_mu = mu print('H1-error = {}, condition = {}'.format(h1_err, cond)) toc = time.time() t_est = toc - tic real_rb_size = len(greedy_data['data']) print(''' *** RESULTS *** Problem: number of blocks: {args[XBLOCKS]}x{args[YBLOCKS]} h: sqrt(2)/{args[--grid]} Greedy basis generation: number of snapshots: {args[SNAPSHOTS]}^({args[XBLOCKS]}x{args[YBLOCKS]}) used estimator: {args[--with-estimator]} estimator norm: {args[--estimator-norm]} extension method: {args[--extension-alg]} prescribed basis size: {args[RBSIZE]} actual basis size: {real_rb_size} elapsed time: {greedy_data[time]} Stochastic error estimation: number of samples: {args[--test]} maximal H1-error: {h1_err_max} (mu = {mumax}) maximal condition of system matrix: {cond_max} (mu = {cond_max_mu}) elapsed time: {t_est} '''.format(**locals())) sys.stdout.flush() if args['--plot-err']: discretization.visualize(U - URB)