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 test_visualize_patch(backend_gridtype):
backend, gridtype = backend_gridtype
domain = LineDomain() if gridtype is OnedGrid else RectDomain()
dim = 1 if gridtype is OnedGrid else 2
rhs = GenericFunction(lambda X: np.ones(X.shape[:-1]) * 10, dim) # NOQA
dirichlet = GenericFunction(lambda X: np.zeros(X.shape[:-1]), dim) # NOQA
diffusion = GenericFunction(lambda X: np.ones(X.shape[:-1]), dim) # NOQA
problem = EllipticProblem(domain=domain, rhs=rhs, dirichlet_data=dirichlet, diffusion_functions=(diffusion,))
grid, bi = discretize_domain_default(problem.domain, grid_type=gridtype)
discretization, data = discretize_elliptic_cg(analytical_problem=problem, grid=grid, boundary_info=bi)
U = discretization.solve()
visualize_patch(data['grid'], U=U, backend=backend)
sleep(2) # so gui has a chance to popup
stop_gui_processes()
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 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': tuple()})
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 test_visualize_patch(backend_gridtype):
backend, gridtype = backend_gridtype
domain = LineDomain() if gridtype is OnedGrid else RectDomain()
dim = 1 if gridtype is OnedGrid else 2
rhs = GenericFunction(lambda X: np.ones(X.shape[:-1]) * 10, dim) # NOQA
dirichlet = GenericFunction(lambda X: np.zeros(X.shape[:-1]), dim) # NOQA
diffusion = GenericFunction(lambda X: np.ones(X.shape[:-1]), dim) # NOQA
problem = EllipticProblem(domain=domain,
rhs=rhs,
dirichlet_data=dirichlet,
diffusion_functions=(diffusion, ))
grid, bi = discretize_domain_default(problem.domain, grid_type=gridtype)
discretization, data = discretize_elliptic_cg(analytical_problem=problem,
grid=grid,
boundary_info=bi)
U = discretization.solve()
visualize_patch(data['grid'], U=U, backend=backend)
sleep(2) # so gui has a chance to popup
for child in multiprocessing.active_children():
child.terminate()
def parabolic_demo():
p = ThermalBlockProblem(parameter_range=(0.01, 1))
d_stat, d_data = discretize_elliptic_cg(p, diameter=1.0 / 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 test_visualize_patch(backend_gridtype):
backend, gridtype = backend_gridtype
domain = LineDomain() if gridtype is OnedGrid else RectDomain()
dim = 1 if gridtype is OnedGrid else 2
rhs = GenericFunction(lambda X: np.ones(X.shape[:-1]) * 10, dim) # NOQA
dirichlet = GenericFunction(lambda X: np.zeros(X.shape[:-1]), dim) # NOQA
diffusion = GenericFunction(lambda X: np.ones(X.shape[:-1]), dim) # NOQA
problem = EllipticProblem(domain=domain,
rhs=rhs,
dirichlet_data=dirichlet,
diffusion_functions=(diffusion, ))
grid, bi = discretize_domain_default(problem.domain, grid_type=gridtype)
discretization, data = discretize_elliptic_cg(analytical_problem=problem,
grid=grid,
boundary_info=bi)
U = discretization.solve()
try:
visualize_patch(data['grid'], U=U, backend=backend)
except PySideMissing as ie:
pytest.xfail("PySide missing")
finally:
stop_gui_processes()
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=(args['XBLOCKS'], args['YBLOCKS']))
# discretize using continuous finite elements
d, _ = discretize_elliptic_cg(problem, diameter=1. / args['--grid'])
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 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['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)
def discretize_parabolic_cg(analytical_problem, diameter=None, domain_discretizer=None,
grid=None, boundary_info=None, num_values=None, time_stepper=None, nt=None):
"""Discretizes an |ParabolicProblem| using finite elements.
Parameters
----------
analytical_problem
The |ParabolicProblem| to discretize.
diameter
If not `None`, `diameter` is passed to the `domain_discretizer`.
domain_discretizer
Discretizer to be used for discretizing the analytical domain. This has
to be a function `domain_discretizer(domain_description, diameter, ...)`.
If further arguments should be passed to the discretizer, use
:func:`functools.partial`. If `None`, |discretize_domain_default| is used.
grid
Instead of using a domain discretizer, the |Grid| can also be passed directly
using this parameter.
boundary_info
A |BoundaryInfo| specifying the boundary types of the grid boundary entities.
Must be provided if `grid` is specified.
num_values
The number of returned vectors of the solution trajectory. If `None`, each
intermediate vector that is calculated is returned.
time_stepper
The time-stepper to be used by :class:`~pymor.discretizations.basic.InstationaryDiscretization.solve`. Has to
satisfy the :class:`~pymor.algorithms.timestepping.TimeStepperInterface`.
nt
The number of time-steps. If provided implicit euler time-stepping is used.
Returns
-------
discretization
The |Discretization| that has been generated.
data
Dictionary with the following entries:
:grid: The generated |Grid|.
:boundary_info: The generated |BoundaryInfo|.
"""
assert isinstance(analytical_problem, ParabolicProblem)
assert grid is None or boundary_info is not None
assert boundary_info is None or grid is not None
assert grid is None or domain_discretizer is None
assert time_stepper is None or nt is None
p = analytical_problem
d, data = discretize_elliptic_cg(p.elliptic_part(), diameter=diameter, domain_discretizer=domain_discretizer,
grid=grid, boundary_info=boundary_info)
if p.initial_data.parametric:
I = InterpolationOperator(data['grid'], p.initial_data)
else:
I = p.initial_data.evaluate(data['grid'].centers(data['grid'].dim))
I = NumpyVectorArray(I, copy=False)
if time_stepper is None:
time_stepper = ImplicitEulerTimeStepper(nt=nt)
mass = d.l2_product if isinstance(time_stepper, ImplicitEulerTimeStepper) else None
discretization = InstationaryDiscretization(operator=d.operator, rhs=d.rhs, mass=mass, initial_data=I, T=p.T,
products=d.products, time_stepper=time_stepper,
parameter_space=d.parameter_space, visualizer=d.visualizer,
num_values=num_values, name='{}_CG'.format(p.name))
return discretization, 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'
}
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)
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)
def discretize_parabolic_cg(analytical_problem, diameter=None, domain_discretizer=None,
grid=None, boundary_info=None, num_values=None, time_stepper=None, nt=None):
"""Discretizes an |ParabolicProblem| using finite elements.
Parameters
----------
analytical_problem
The |ParabolicProblem| to discretize.
diameter
If not `None`, `diameter` is passed to the `domain_discretizer`.
domain_discretizer
Discretizer to be used for discretizing the analytical domain. This has
to be a function `domain_discretizer(domain_description, diameter, ...)`.
If further arguments should be passed to the discretizer, use
:func:`functools.partial`. If `None`, |discretize_domain_default| is used.
grid
Instead of using a domain discretizer, the |Grid| can also be passed directly
using this parameter.
boundary_info
A |BoundaryInfo| specifying the boundary types of the grid boundary entities.
Must be provided if `grid` is specified.
num_values
The number of returned vectors of the solution trajectory. If `None`, each
intermediate vector that is calculated is returned.
time_stepper
The time-stepper to be used by :class:`~pymor.discretizations.basic.InstationaryDiscretization.solve`. Has to
satisfy the :class:`~pymor.algorithms.timestepping.TimeStepperInterface`.
nt
The number of time-steps. If provided implicit euler time-stepping is used.
Returns
-------
discretization
The |Discretization| that has been generated.
data
Dictionary with the following entries:
:grid: The generated |Grid|.
:boundary_info: The generated |BoundaryInfo|.
"""
assert isinstance(analytical_problem, ParabolicProblem)
assert grid is None or boundary_info is not None
assert boundary_info is None or grid is not None
assert grid is None or domain_discretizer is None
assert time_stepper is None or nt is None
p = analytical_problem
d, data = discretize_elliptic_cg(p.elliptic_part(), diameter=diameter, domain_discretizer=domain_discretizer,
grid=grid, boundary_info=boundary_info)
if p.initial_data.parametric:
I = InterpolationOperator(data['grid'], p.initial_data)
else:
I = p.initial_data.evaluate(data['grid'].centers(data['grid'].dim))
I = NumpyVectorArray(I, copy=False)
if time_stepper is None:
time_stepper = ImplicitEulerTimeStepper(nt=nt)
mass = d.l2_0_product
discretization = InstationaryDiscretization(operator=d.operator, rhs=d.rhs, mass=mass, initial_data=I, T=p.T,
products=d.products, time_stepper=time_stepper,
parameter_space=d.parameter_space, visualizer=d.visualizer,
num_values=num_values, name='{}_CG'.format(p.name))
return discretization, data
# License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
from itertools import product
import pytest
import os
from pymor.discretizers.advection import discretize_nonlinear_instationary_advection_fv
from pymor.discretizers.disk import discretize_stationary_from_disk, discretize_instationary_from_disk
from pymor.discretizers.elliptic import discretize_elliptic_cg
from pymortests.fixtures.analyticalproblem import (picklable_thermalblock_problems, non_picklable_thermalblock_problems,
burgers_problems)
picklable_discretizaion_generators = \
[lambda p=p,d=d: discretize_elliptic_cg(p, diameter=d)[0]
for p, d in product(picklable_thermalblock_problems, [1./50., 1./100.])] + \
[lambda p=p,d=d: discretize_nonlinear_instationary_advection_fv(p, diameter=d)[0]
for p, d in product(burgers_problems, [1./10., 1./15.])] + \
[lambda p=p: discretize_stationary_from_disk(parameter_file=p)
for p in (os.path.join(os.path.dirname(__file__), '../../../testdata/parameter_stationary.ini'),)] + \
[lambda p=p: discretize_instationary_from_disk(parameter_file=p)
for p in (os.path.join(os.path.dirname(__file__), '../../../testdata/parameter_instationary.ini'),)]
non_picklable_discretization_generators = \
[lambda p=p,d=d: discretize_elliptic_cg(p, diameter=d)[0]
for p, d in product(non_picklable_thermalblock_problems, [1./20., 1./30.])]
discretization_generators = picklable_discretizaion_generators + non_picklable_discretization_generators
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)
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)
from itertools import product
import pytest
import os
from pymor.discretizers.advection import discretize_nonlinear_instationary_advection_fv
from pymor.discretizers.disk import discretize_stationary_from_disk, discretize_instationary_from_disk
from pymor.discretizers.elliptic import discretize_elliptic_cg
from pymortests.fixtures.analyticalproblem import (
picklable_thermalblock_problems, non_picklable_thermalblock_problems,
burgers_problems)
picklable_discretizaion_generators = \
[lambda p=p,d=d: discretize_elliptic_cg(p, diameter=d)[0]
for p, d in product(picklable_thermalblock_problems, [1./50., 1./100.])] + \
[lambda p=p,d=d: discretize_nonlinear_instationary_advection_fv(p, diameter=d)[0]
for p, d in product(burgers_problems, [1./10., 1./15.])] + \
[lambda p=p: discretize_stationary_from_disk(parameter_file=p)
for p in (os.path.join(os.path.dirname(__file__), '../../../testdata/parameter_stationary.ini'),)] + \
[lambda p=p: discretize_instationary_from_disk(parameter_file=p)
for p in (os.path.join(os.path.dirname(__file__), '../../../testdata/parameter_instationary.ini'),)]
non_picklable_discretization_generators = \
[lambda p=p,d=d: discretize_elliptic_cg(p, diameter=d)[0]
for p, d in product(non_picklable_thermalblock_problems, [1./20., 1./30.])]
discretization_generators = picklable_discretizaion_generators + non_picklable_discretization_generators
