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)