def __init__(self, args):
self.args = args
self.first = True
self.problem = ThermalBlockProblem(num_blocks=(args['XBLOCKS'], args['YBLOCKS']),
parameter_range=(PARAM_MIN, PARAM_MAX))
self.discretization, pack = discretize_elliptic_cg(self.problem, diameter=1. / args['--grid'])
self.grid = pack['grid']
def thermalblock_factory(xblocks, yblocks, diameter, seed):
from pymor.analyticalproblems.thermalblock import ThermalBlockProblem
from pymor.discretizers.elliptic import discretize_elliptic_cg
from pymor.functions.basic import GenericFunction
from pymor.operators.cg import InterpolationOperator
p = ThermalBlockProblem((xblocks, yblocks))
d, d_data = discretize_elliptic_cg(p, diameter)
f = GenericFunction(lambda X, mu: X[..., 0]**mu['exp'] + X[..., 1],
dim_domain=2, parameter_type={'exp': ()})
iop = InterpolationOperator(d_data['grid'], f)
U = d.operator.source.empty()
V = d.operator.range.empty()
np.random.seed(seed)
for exp in np.random.random(5):
U.append(iop.as_vector(exp))
for exp in np.random.random(6):
V.append(iop.as_vector(exp))
return d.operator, d.parameter_space.sample_randomly(1, seed=seed)[0], U, V, d.h1_product, d.l2_product
def parabolic_demo():
p = ThermalBlockProblem(parameter_range=(0.01, 1))
d_stat, d_data = discretize_elliptic_cg(p, diameter=1. / 100)
U0 = NumpyVectorArray(np.zeros(d_stat.operator.source.dim))
time_stepper = ImplicitEulerTimeStepper(50)
d = InstationaryDiscretization(operator=d_stat.operator,
rhs=d_stat.rhs,
mass=d_stat.l2_product,
initial_data=U0,
T=1,
products=d_stat.products,
time_stepper=time_stepper,
parameter_space=d_stat.parameter_space,
visualizer=d_stat.visualizer)
mu = next(d.parameter_space.sample_randomly(1))
R = d.solve(mu)
d.visualize(R)
def discretize_pymor(xblocks, yblocks, grid_num_intervals,
use_list_vector_array):
from pymor.analyticalproblems.thermalblock import ThermalBlockProblem
from pymor.discretizers.elliptic import discretize_elliptic_cg
from pymor.playground.discretizers.numpylistvectorarray import convert_to_numpy_list_vector_array
print('Discretize ...')
# setup analytical problem
problem = ThermalBlockProblem(num_blocks=(xblocks, yblocks))
# discretize using continuous finite elements
d, _ = discretize_elliptic_cg(problem, diameter=1. / grid_num_intervals)
if use_list_vector_array:
d = convert_to_numpy_list_vector_array(d)
summary = '''pyMOR discretization:
number of blocks: {xblocks}x{yblocks}
grid intervals: {grid_num_intervals}
ListVectorArray: {use_list_vector_array}
'''.format(**locals())
return d, summary
def thermalblock_demo(args):
args['--grid'] = int(args['--grid'])
args['RBSIZE'] = int(args['RBSIZE'])
args['--test'] = int(args['--test'])
args['--ipython-engines'] = int(args['--ipython-engines'])
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 {'traditional', 'residual_basis'}
args['--cache-region'] = args['--cache-region'].lower()
args['--validation-mus'] = int(args['--validation-mus'])
args['--rho'] = float(args['--rho'])
args['--gamma'] = float(args['--gamma'])
args['--theta'] = float(args['--theta'])
print('Solving on TriaGrid(({0},{0}))'.format(args['--grid']))
print('Setup Problem ...')
problem = ThermalBlockProblem(num_blocks=(2, 2))
functionals = [ExpressionParameterFunctional('diffusion[0]', {'diffusion': (2,)}),
ExpressionParameterFunctional('diffusion[1]**2', {'diffusion': (2,)}),
ExpressionParameterFunctional('diffusion[0]', {'diffusion': (2,)}),
ExpressionParameterFunctional('diffusion[1]', {'diffusion': (2,)})]
problem = EllipticProblem(domain=problem.domain,
diffusion_functions=problem.diffusion_functions,
diffusion_functionals=functionals,
rhs=problem.rhs,
parameter_space=CubicParameterSpace({'diffusion': (2,)}, 0.1, 1.))
print('Discretize ...')
discretization, _ = discretize_elliptic_cg(problem, diameter=1. / args['--grid'])
if args['--list-vector-array']:
from pymor.playground.discretizers.numpylistvectorarray import convert_to_numpy_list_vector_array
discretization = convert_to_numpy_list_vector_array(discretization)
if args['--cache-region'] != 'none':
discretization.enable_caching(args['--cache-region'])
print('The parameter type is {}'.format(discretization.parameter_type))
if args['--plot-solutions']:
print('Showing some solutions')
Us = ()
legend = ()
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 ...')
product = discretization.h1_0_semi_product if args['--estimator-norm'] == 'h1' else None
coercivity_estimator=ExpressionParameterFunctional('min([diffusion[0], diffusion[1]**2])', discretization.parameter_type)
reductors = {'residual_basis': partial(reduce_coercive, product=product,
coercivity_estimator=coercivity_estimator),
'traditional': partial(reduce_coercive_simple, product=product,
coercivity_estimator=coercivity_estimator)}
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_0_semi_product)}
extension_algorithm = extension_algorithms[args['--extension-alg']]
pool = new_parallel_pool(ipython_num_engines=args['--ipython-engines'], ipython_profile=args['--ipython-profile'])
greedy_data = adaptive_greedy(discretization, reductor,
validation_mus=args['--validation-mus'], rho=args['--rho'], gamma=args['--gamma'],
theta=args['--theta'],
use_estimator=not args['--without-estimator'], error_norm=discretization.h1_0_semi_norm,
extension_algorithm=extension_algorithm, max_extensions=args['RBSIZE'],
visualize=args['--visualize-refinement'])
rb_discretization, reconstructor = greedy_data['reduced_discretization'], greedy_data['reconstructor']
if args['--pickle']:
print('\nWriting reduced discretization to file {} ...'.format(args['--pickle'] + '_reduced'))
with open(args['--pickle'] + '_reduced', 'wb') as f:
dump(rb_discretization, f)
print('Writing detailed discretization and reconstructor to file {} ...'.format(args['--pickle'] + '_detailed'))
with open(args['--pickle'] + '_detailed', 'wb') as f:
dump((discretization, reconstructor), f)
print('\nSearching for maximum error on random snapshots ...')
results = reduction_error_analysis(rb_discretization,
discretization=discretization,
reconstructor=reconstructor,
estimator=True,
error_norms=(discretization.h1_0_semi_norm,),
condition=True,
test_mus=args['--test'],
basis_sizes=25 if args['--plot-error-sequence'] else 1,
plot=True,
pool=pool)
real_rb_size = rb_discretization.solution_space.dim
print('''
*** RESULTS ***
Problem:
number of blocks: 2x2
h: sqrt(2)/{args[--grid]}
Greedy basis generation:
estimator disabled: {args[--without-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]}
'''.format(**locals()))
print(results['summary'])
sys.stdout.flush()
if args['--plot-error-sequence']:
from matplotlib import pyplot as plt
plt.show(results['figure'])
if args['--plot-err']:
mumax = results['max_error_mus'][0, -1]
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'
}
args['--reductor'] = args['--reductor'].lower()
assert args['--reductor'] in {'traditional', 'residual_basis'}
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=1. / 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
coercivity_estimator = ExpressionParameterFunctional(
'min(diffusion)', discretization.parameter_type)
reductors = {
'residual_basis':
partial(reduce_stationary_coercive,
error_product=error_product,
coercivity_estimator=coercivity_estimator),
'traditional':
partial(reduce_stationary_affine_linear,
error_product=error_product,
coercivity_estimator=coercivity_estimator)
}
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,
extension_algorithm=extension_algorithm,
max_extensions=args['RBSIZE'])
rb_discretization, reconstructor = greedy_data[
'reduced_discretization'], greedy_data['reconstructor']
if args['--pickle']:
print('\nWriting reduced discretization to file {} ...'.format(
args['--pickle'] + '_reduced'))
with open(args['--pickle'] + '_reduced', 'w') as f:
dump(rb_discretization, f)
print(
'Writing detailed discretization and reconstructor to file {} ...'.
format(args['--pickle'] + '_detailed'))
with open(args['--pickle'] + '_detailed', 'w') as f:
dump((discretization, reconstructor), f)
print('\nSearching for maximum error on random snapshots ...')
def error_analysis(d, rd, rc, mus):
print('N = {}: '.format(rd.operator.source.dim), end='')
h1_err_max = -1
h1_est_max = -1
cond_max = -1
for mu in mus:
print('.', end='')
sys.stdout.flush()
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)
# License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
import numpy as np
import pytest
from pymor.analyticalproblems.advection import InstationaryAdvectionProblem
from pymor.analyticalproblems.burgers import BurgersProblem, Burgers2DProblem
from pymor.analyticalproblems.elliptic import EllipticProblem
from pymor.analyticalproblems.thermalblock import ThermalBlockProblem
from pymor.functions.basic import GenericFunction, ConstantFunction
from pymor.parameters.functionals import ExpressionParameterFunctional
picklable_thermalblock_problems = \
[ThermalBlockProblem(),
ThermalBlockProblem(num_blocks=(3, 2)),
ThermalBlockProblem(num_blocks=(1, 1)),
ThermalBlockProblem(num_blocks=(2, 2), parameter_range=(1., 100.))]
non_picklable_thermalblock_problems = \
[ThermalBlockProblem(num_blocks=(1, 3), parameter_range=(0.4, 0.5),
rhs=GenericFunction(dim_domain=2, mapping=lambda X: X[..., 0] + X[..., 1]))]
thermalblock_problems = picklable_thermalblock_problems + non_picklable_thermalblock_problems
burgers_problems = \
[BurgersProblem(),
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['--pod-norm'] = args['--pod-norm'].lower()
assert args['--pod-norm'] in {'trivial', 'h1'}
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=1. / 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 ...')
tic = time.time()
print('Solving on training set ...')
S_train = list(
discretization.parameter_space.sample_uniformly(args['SNAPSHOTS']))
snapshots = discretization.operator.source.empty(reserve=len(S_train))
for mu in S_train:
snapshots.append(discretization.solve(mu))
print('Performing POD ...')
pod_product = discretization.h1_product if args[
'--pod-norm'] == 'h1' else None
rb = pod(snapshots, modes=args['RBSIZE'], product=pod_product)[0]
print('Reducing ...')
reductor = reduce_generic_rb
rb_discretization, reconstructor, _ = reductor(discretization, rb)
toc = time.time()
t_offline = toc - tic
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
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(rb)
print('''
*** RESULTS ***
Problem:
number of blocks: {args[XBLOCKS]}x{args[YBLOCKS]}
h: sqrt(2)/{args[--grid]}
POD basis generation:
number of snapshots: {args[SNAPSHOTS]}^({args[XBLOCKS]}x{args[YBLOCKS]})
pod norm: {args[--pod-norm]}
prescribed basis size: {args[RBSIZE]}
actual basis size: {real_rb_size}
elapsed time: {t_offline}
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, U - URB),
legend=('Detailed Solution', 'Reduced Solution', 'Error'),
title='Maximum Error Solution',
separate_colorbars=True,
block=True)