from __future__ import absolute_import, division, print_function
import sys
import time
import numpy as np
from docopt import docopt
from pymor.core import logger
logger.MAX_HIERACHY_LEVEL = 2
from pymor.algorithms.pod import pod
from pymor.analyticalproblems.thermalblock import ThermalBlockProblem
from pymor.discretizers.elliptic import discretize_elliptic_cg
from pymor.reductors.basic import reduce_generic_rb
logger.set_log_levels({'pymor.discretizations': 'INFO'})
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 ...')
from PySide import QtGui
import OpenGL
OpenGL.ERROR_ON_COPY = True
from pymor.core import logger
logger.MAX_HIERACHY_LEVEL = 2
from pymor.algorithms.basisextension import gram_schmidt_basis_extension
from pymor.algorithms.greedy import greedy
from pymor.analyticalproblems.thermalblock import ThermalBlockProblem
from pymor.discretizers.elliptic import discretize_elliptic_cg
from pymor.gui.gl import ColorBarWidget, GLPatchWidget
from pymor.reductors.linear import reduce_stationary_affine_linear
from pymor import gui
logger.set_log_levels({'pymor.algorithms': 'INFO',
'pymor.discretizations': 'INFO'})
PARAM_STEPS = 10
PARAM_MIN = 0.1
PARAM_MAX = 1
class ParamRuler(QtGui.QWidget):
def __init__(self, parent, sim):
super(ParamRuler, self).__init__(parent)
self.sim = sim
self.setMinimumSize(200, 100)
box = QtGui.QGridLayout()
self.spins = []
for j in xrange(args['YBLOCKS']):
for i in xrange(args['XBLOCKS']):
#This file is part of the pyMOR project (http://www.pymor.org).
#Copyright 2013-2020 pyMOR developers and contributors. All rights reserved.
#License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
# In[ ]:
import numpy as np
import scipy.linalg as spla
import matplotlib.pyplot as plt
import matplotlib as mpl
from pymor.basic import *
from pymor.core.config import config
from pymor.core.logger import set_log_levels
set_log_levels({'pymor.algorithms.gram_schmidt.gram_schmidt': 'WARNING'})
# # Model
# In[ ]:
p = InstationaryProblem(
StationaryProblem(
domain=LineDomain([0.,1.], left='robin', right='robin'),
diffusion=LincombFunction([ExpressionFunction('(x[...,0] <= 0.5) * 1.', 1),
ExpressionFunction('(0.5 < x[...,0]) * 1.', 1)],
[1,
ProjectionParameterFunctional('diffusion', ())]),
robin_data=(ConstantFunction(1., 1), ExpressionFunction('(x[...,0] < 1e-10) * 1.', 1)),
#!/usr/bin/env python
import numpy as np
import mpi4py
np.seterr(all='raise')
from pymor.core.exceptions import ExtensionError
from pymor.core.logger import getLogger, set_log_levels
set_log_levels({
'online_adaptive_lrbms': 'DEBUG',
'OS2015_academic_problem': 'INFO',
'discretize_elliptic_block_swipdg': 'INFO',
'offline': 'INFO',
'online_enrichment': 'INFO',
'lrbms': 'INFO'
})
logger = getLogger('online_adaptive_lrbms.online_adaptive_lrbms')
from dune.xt.common import logging
logging.create(63)
from pymor.discretizations.basic import StationaryDiscretization
from dune.pylrbms.OS2015_academic_problem import init_grid_and_problem
# from dune.pylrbms.non_parametric_problem import init_grid_and_problem
# from local_thermalblock_problem import init_grid_and_problem
# from dune.pylrbms.discretize_elliptic_swipdg import discretize
from dune.pylrbms.discretize_elliptic_block_swipdg import discretize
# max discretization error, to derive enrichment_target_error
# ===========================================================
# OS2015_academic_problem
# [4, 4], 2, [2, 2], 4: 0.815510144764
#!/usr/bin/env python
import numpy as np
from pymor.core.exceptions import ExtensionError
# from thermalblock_problem import init_grid_and_problem
from OS2015_academic_problem import init_grid_and_problem
from discretize_elliptic import discretize
from lrbms import LRBMSReductor
from pymor.core.logger import set_log_levels
set_log_levels({'discretize_elliptic': 'INFO', 'lrbms': 'INFO'})
config = {
'num_coarse_grid_elements': [4, 4],
'num_grid_refinements': 6,
'num_grid_subdomains': [8, 8],
'num_grid_oversampling_layers': 4
} # num_grid_oversampling_layers has to exactly cover one subdomain!
grid_and_problem_data = init_grid_and_problem(config)
grid = grid_and_problem_data['grid']
# grid.visualize('grid', False)
d, block_space = discretize(grid_and_problem_data)
# mu = d.parse_parameter([1, 1., 1., 1.])
mu = d.parse_parameter(1.)
U = d.solve(mu)
#!/usr/bin/env python
import sys
import numpy as np
np.warnings.filterwarnings('ignore')
import itertools
from dune.gdt.discretefunction import make_discrete_function
from dune.gdt import (
prolong, )
from dune.gdt.playground.operators.rs2017 import RS2017_residual_indicator_subdomain_diameter as subdomain_diameter
from pymor.core.logger import set_log_levels
set_log_levels({
'pymor.discretizations.basic': 'WARN',
})
from pymor.grids.oned import OnedGrid
from dune.pylrbms.discretize_elliptic_swipdg import discretize as discretize_elliptic_swipdg
from dune.pylrbms.discretize_parabolic_swipdg import discretize as discretize_parabolic_swipdg
class EocStudy:
level_info_title = None
accuracies = None
norms = None
indicators = None
estimates = None
max_levels = None
def main(
n: int = Argument(
101, help='Order of the full second-order model (odd number).'),
r: int = Argument(5, help='Order of the ROMs.'),
):
"""String equation example."""
set_log_levels({'pymor.algorithms.gram_schmidt.gram_schmidt': 'ERROR'})
# Assemble matrices
assert n % 2 == 1, 'The order has to be an odd integer.'
n2 = (n + 1) // 2
d = 10 # damping
k = 0.01 # stiffness
M = sps.eye(n, format='csc')
E = d * sps.eye(n, format='csc')
K = sps.diags(
[n * [2 * k * n**2], (n - 1) * [-k * n**2],
(n - 1) * [-k * n**2]], [0, -1, 1],
format='csc')
B = np.zeros((n, 1))
B[n2 - 1, 0] = n
Cp = np.zeros((1, n))
Cp[0, n2 - 1] = 1
# Second-order system
so_sys = SecondOrderModel.from_matrices(M, E, K, B, Cp)
print(f'order of the model = {so_sys.order}')
print(f'number of inputs = {so_sys.dim_input}')
print(f'number of outputs = {so_sys.dim_output}')
poles = so_sys.poles()
fig, ax = plt.subplots()
ax.plot(poles.real, poles.imag, '.')
ax.set_title('System poles')
plt.show()
w = np.logspace(-4, 2, 200)
fig, ax = plt.subplots()
so_sys.mag_plot(w, ax=ax)
ax.set_title('Magnitude plot of the full model')
plt.show()
psv = so_sys.psv()
vsv = so_sys.vsv()
pvsv = so_sys.pvsv()
vpsv = so_sys.vpsv()
fig, ax = plt.subplots(2, 2, figsize=(12, 8), sharey=True)
ax[0, 0].semilogy(range(1, len(psv) + 1), psv, '.-')
ax[0, 0].set_title('Position singular values')
ax[0, 1].semilogy(range(1, len(vsv) + 1), vsv, '.-')
ax[0, 1].set_title('Velocity singular values')
ax[1, 0].semilogy(range(1, len(pvsv) + 1), pvsv, '.-')
ax[1, 0].set_title('Position-velocity singular values')
ax[1, 1].semilogy(range(1, len(vpsv) + 1), vpsv, '.-')
ax[1, 1].set_title('Velocity-position singular values')
plt.show()
print(f'FOM H_2-norm: {so_sys.h2_norm():e}')
if config.HAVE_SLYCOT:
print(f'FOM H_inf-norm: {so_sys.hinf_norm():e}')
else:
print('H_inf-norm calculation is skipped due to missing slycot.')
print(f'FOM Hankel-norm: {so_sys.hankel_norm():e}')
# Model order reduction
run_mor_method(so_sys, w, SOBTpReductor(so_sys), 'SOBTp', r)
run_mor_method(so_sys, w, SOBTvReductor(so_sys), 'SOBTv', r)
run_mor_method(so_sys, w, SOBTpvReductor(so_sys), 'SOBTpv', r)
run_mor_method(so_sys, w, SOBTvpReductor(so_sys), 'SOBTvp', r)
run_mor_method(so_sys, w, SOBTfvReductor(so_sys), 'SOBTfv', r)
run_mor_method(so_sys, w, SOBTReductor(so_sys), 'SOBT', r)
run_mor_method(so_sys,
w,
SORIRKAReductor(so_sys),
'SOR-IRKA',
r,
irka_options={'maxit': 10})
run_mor_method(so_sys, w, BTReductor(so_sys.to_lti()), 'BT', r)
run_mor_method(so_sys, w, IRKAReductor(so_sys.to_lti()), 'IRKA', r)
def main(
diameter: float = Argument(
0.1, help='Diameter option for the domain discretizer.'),
r: int = Argument(5, help='Order of the ROMs.'),
):
r"""2D heat equation demo.
Discretization of the PDE:
.. math::
:nowrap:
\begin{align*}
\partial_t z(x, y, t) &= \Delta z(x, y, t), & 0 < x, y < 1,\ t > 0 \\
-\nabla z(0, y, t) \cdot n &= z(0, y, t) - u(t), & 0 < y < 1, t > 0 \\
-\nabla z(1, y, t) \cdot n &= z(1, y, t), & 0 < y < 1, t > 0 \\
-\nabla z(0, x, t) \cdot n &= z(0, x, t), & 0 < x < 1, t > 0 \\
-\nabla z(1, x, t) \cdot n &= z(1, x, t), & 0 < x < 1, t > 0 \\
z(x, y, 0) &= 0 & 0 < x, y < 1 \\
y(t) &= \int_0^1 z(1, y, t) dy, & t > 0 \\
\end{align*}
where :math:`u(t)` is the input and :math:`y(t)` is the output.
"""
set_log_levels({'pymor.algorithms.gram_schmidt.gram_schmidt': 'WARNING'})
p = InstationaryProblem(StationaryProblem(
domain=RectDomain([[0., 0.], [1., 1.]],
left='robin',
right='robin',
top='robin',
bottom='robin'),
diffusion=ConstantFunction(1., 2),
robin_data=(ConstantFunction(1., 2),
ExpressionFunction('(x[...,0] < 1e-10) * 1.', 2)),
outputs=[('l2_boundary',
ExpressionFunction('(x[...,0] > (1 - 1e-10)) * 1.', 2))]),
ConstantFunction(0., 2),
T=1.)
fom, _ = discretize_instationary_cg(p, diameter=diameter, nt=100)
fom.visualize(fom.solve())
lti = fom.to_lti()
print(f'order of the model = {lti.order}')
print(f'number of inputs = {lti.dim_input}')
print(f'number of outputs = {lti.dim_output}')
# System poles
poles = lti.poles()
fig, ax = plt.subplots()
ax.plot(poles.real, poles.imag, '.')
ax.set_title('System poles')
plt.show()
# Magnitude plot of the full model
w = np.logspace(-1, 3, 100)
fig, ax = plt.subplots()
lti.mag_plot(w, ax=ax)
ax.set_title('Magnitude plot of the full model')
plt.show()
# Hankel singular values
hsv = lti.hsv()
fig, ax = plt.subplots()
ax.semilogy(range(1, len(hsv) + 1), hsv, '.-')
ax.set_title('Hankel singular values')
plt.show()
# Norms of the system
print(f'FOM H_2-norm: {lti.h2_norm():e}')
if config.HAVE_SLYCOT:
print(f'FOM H_inf-norm: {lti.hinf_norm():e}')
else:
print('Skipped H_inf-norm calculation due to missing slycot.')
print(f'FOM Hankel-norm: {lti.hankel_norm():e}')
# Model order reduction
run_mor_method(lti, w, BTReductor(lti), 'BT', r, tol=1e-5)
run_mor_method(lti, w, LQGBTReductor(lti), 'LQGBT', r, tol=1e-5)
run_mor_method(lti, w, BRBTReductor(lti), 'BRBT', r, tol=1e-5)
run_mor_method(lti, w, IRKAReductor(lti), 'IRKA', r)
run_mor_method(lti, w, TSIAReductor(lti), 'TSIA', r)
run_mor_method(lti, w, OneSidedIRKAReductor(lti, 'V'), 'OS-IRKA', r)
#!/usr/bin/env python
import numpy as np
import time
from pymor.core.exceptions import ExtensionError
# from thermalblock_problem import init_grid_and_problem
from dune.pylrbms.OS2015_academic_problem import init_grid_and_problem
from dune.pylrbms.discretize_elliptic_block_swipdg import discretize
from dune.pylrbms.estimators import LRBMSReductor
from pymor.core.logger import set_log_levels
set_log_levels({'discretize_elliptic_block_swipdg': 'INFO',
'lrbms': 'INFO'})
config = {'num_subdomains': [4, 4],
'half_num_fine_elements_per_subdomain_and_dim': 1,
'grid_type': 'alu'}
grid_and_problem_data = init_grid_and_problem(config)
grid = grid_and_problem_data['grid']
# grid.visualize('grid', False)
d, d_data = discretize(grid_and_problem_data)
block_space = d_data['block_space']
# mu = d.parse_parameter([1, 1., 1., 1.])
mu = d.parse_parameter(1.)
"""
from __future__ import absolute_import, division, print_function
from docopt import docopt
import numpy as np
from pymor.analyticalproblems.elliptic import EllipticProblem
from pymor.core.logger import set_log_levels
from pymor.discretizers.elliptic import discretize_elliptic_cg, discretize_elliptic_fv
from pymor.domaindescriptions.basic import LineDomain
from pymor.functions.basic import GenericFunction, ConstantFunction
from pymor.parameters.functionals import ProjectionParameterFunctional, GenericParameterFunctional
from pymor.parameters.spaces import CubicParameterSpace
set_log_levels({'pymor.discretizations': 'INFO'})
def elliptic_oned_demo(args):
args['PROBLEM-NUMBER'] = int(args['PROBLEM-NUMBER'])
assert 0 <= args['PROBLEM-NUMBER'] <= 1, ValueError('Invalid problem number.')
args['N'] = int(args['N'])
rhss = [GenericFunction(lambda X: np.ones(X.shape[:-1]) * 10, dim_domain=1),
GenericFunction(lambda X: (X[..., 0] - 0.5) ** 2 * 1000, dim_domain=1)]
rhs = rhss[args['PROBLEM-NUMBER']]
d0 = GenericFunction(lambda X: 1 - X[..., 0], dim_domain=1)
d1 = GenericFunction(lambda X: X[..., 0], dim_domain=1)
parameter_space = CubicParameterSpace({'diffusionl': 0}, 0.1, 1)
from pymor.core.logger import set_log_levels
from lmor.problems import helmholtz
from lmor.localize_problem import localize_problem
from lmor.generate_solution import create_bases, create_bases2, create_bases3, reconstruct_solution, operator_svd2
from lmor.constants import (calculate_continuity_constant,
calculate_inf_sup_constant2, calculate_csis,
calculate_Psi_norm)
import multiprocessing as mp
import time
import os
import numpy as np
import sys
if not os.path.exists("dats"):
os.makedirs("dats")
set_log_levels(levels={'pymor': 'WARN'})
process_count = 10
def evaluation(it,
lim,
k,
boundary,
save,
cglob=0,
cloc=0,
plot=False,
resolution=200,
coarse_grid_resolution=10):
p = helmholtz(boundary=boundary)
#!/usr/bin/env python
import numpy as np
from pymor.core.exceptions import ExtensionError
from dune.pylrbms.artificial_channels_problem import init_grid_and_problem
from dune.pylrbms.discretize_parabolic_block_swipdg import discretize
from dune.pylrbms.estimators import ParabolicLRBMSReductor
from pymor.core.logger import set_log_levels
set_log_levels({
'discretize_elliptic_block_swipdg': 'INFO',
'lrbms': 'INFO',
'pymor.algorithms.gram_schmidt': 'WARN'
})
config = {
'num_subdomains': [8, 8],
'half_num_fine_elements_per_subdomain_and_dim': 2,
'grid_type': 'alu'
}
grid_and_problem_data = init_grid_and_problem(config)
grid = grid_and_problem_data['grid']
# d, _ = discretize(grid_and_problem_data, 1, 100)
# for mu in d.parameter_space.sample_uniformly(2):
# U = d.solve(mu)
# d.visualize(U, filename='mu_{}'.format(mu['switch'][0]))
def main(
n: int = Argument(
101, help='Order of the full second-order model (odd number).'),
r: int = Argument(5, help='Order of the ROMs.'),
):
"""Parametric string example."""
set_log_levels({'pymor.algorithms.gram_schmidt.gram_schmidt': 'WARNING'})
# Assemble M, D, K, B, C_p
assert n % 2 == 1, 'The order has to be an odd integer.'
n2 = (n + 1) // 2
k = 0.01 # stiffness
M = sps.eye(n, format='csc')
E = sps.eye(n, format='csc')
K = sps.diags(
[n * [2 * k * n**2], (n - 1) * [-k * n**2],
(n - 1) * [-k * n**2]], [0, -1, 1],
format='csc')
B = np.zeros((n, 1))
B[n2 - 1, 0] = n
Cp = np.zeros((1, n))
Cp[0, n2 - 1] = 1
# Second-order system
Mop = NumpyMatrixOperator(M)
Eop = NumpyMatrixOperator(E) * ProjectionParameterFunctional('damping')
Kop = NumpyMatrixOperator(K)
Bop = NumpyMatrixOperator(B)
Cpop = NumpyMatrixOperator(Cp)
so_sys = SecondOrderModel(Mop, Eop, Kop, Bop, Cpop)
print(f'order of the model = {so_sys.order}')
print(f'number of inputs = {so_sys.dim_input}')
print(f'number of outputs = {so_sys.dim_output}')
mu_list = [1, 5, 10]
w = np.logspace(-3, 2, 200)
# System poles
fig, ax = plt.subplots()
for mu in mu_list:
poles = so_sys.poles(mu=mu)
ax.plot(poles.real, poles.imag, '.', label=fr'$\mu = {mu}$')
ax.set_title('System poles')
ax.legend()
plt.show()
# Magnitude plots
fig, ax = plt.subplots()
for mu in mu_list:
so_sys.mag_plot(w, ax=ax, mu=mu, label=fr'$\mu = {mu}$')
ax.set_title('Magnitude plot of the full model')
ax.legend()
plt.show()
# "Hankel" singular values
fig, ax = plt.subplots(2,
2,
figsize=(12, 8),
sharey=True,
constrained_layout=True)
for mu in mu_list:
psv = so_sys.psv(mu=mu)
vsv = so_sys.vsv(mu=mu)
pvsv = so_sys.pvsv(mu=mu)
vpsv = so_sys.vpsv(mu=mu)
ax[0, 0].semilogy(range(1,
len(psv) + 1),
psv,
'.-',
label=fr'$\mu = {mu}$')
ax[0, 1].semilogy(range(1, len(vsv) + 1), vsv, '.-')
ax[1, 0].semilogy(range(1, len(pvsv) + 1), pvsv, '.-')
ax[1, 1].semilogy(range(1, len(vpsv) + 1), vpsv, '.-')
ax[0, 0].set_title('Position singular values')
ax[0, 1].set_title('Velocity singular values')
ax[1, 0].set_title('Position-velocity singular values')
ax[1, 1].set_title('Velocity-position singular values')
fig.legend(loc='upper center', ncol=len(mu_list))
plt.show()
# System norms
for mu in mu_list:
print(f'mu = {mu}:')
print(f' H_2-norm of the full model: {so_sys.h2_norm(mu=mu):e}')
if config.HAVE_SLYCOT:
print(
f' H_inf-norm of the full model: {so_sys.hinf_norm(mu=mu):e}'
)
print(
f' Hankel-norm of the full model: {so_sys.hankel_norm(mu=mu):e}'
)
# Model order reduction
run_mor_method_param(so_sys, r, w, mu_list, SOBTpReductor, 'SOBTp')
run_mor_method_param(so_sys, r, w, mu_list, SOBTvReductor, 'SOBTv')
run_mor_method_param(so_sys, r, w, mu_list, SOBTpvReductor, 'SOBTpv')
run_mor_method_param(so_sys, r, w, mu_list, SOBTvpReductor, 'SOBTvp')
run_mor_method_param(so_sys, r, w, mu_list, SOBTfvReductor, 'SOBTfv')
run_mor_method_param(so_sys, r, w, mu_list, SOBTReductor, 'SOBT')
run_mor_method_param(so_sys, r, w, mu_list, SORIRKAReductor, 'SOR-IRKA')
run_mor_method_param(so_sys.to_lti(), r, w, mu_list, BTReductor, 'BT')
run_mor_method_param(so_sys.to_lti(), r, w, mu_list, IRKAReductor, 'IRKA')
if not os.path.exists(fn):
raise IOError('Cannot load defaults from file ' + fn)
print('Loading defaults from file ' + fn +
' (set by PYMOR_DEFAULTS)')
load_defaults_from_file(fn)
else:
filename = os.path.join(os.getcwd(), 'pymor_defaults.py')
if os.path.exists(filename):
if os.stat(filename).st_uid != os.getuid():
raise IOError('Cannot load defaults from config file ' + filename +
': not owned by user running Python interpreter')
print('Loading defaults from file ' + filename)
load_defaults_from_file(filename)
from pymor.core.logger import set_log_levels, set_log_format
set_log_levels()
set_log_format()
from pymor.tools import mpi
if mpi.parallel and mpi.event_loop_settings()['auto_launch']:
if mpi.rank0:
import atexit
@atexit.register
def quit_event_loop():
if not mpi.finished:
mpi.quit()
else:
print('Rank {}: MPI parallel run detected. Launching event loop ...'.
format(mpi.rank))
mpi.event_loop()
})
prod_levels = ({
'online_adaptive_lrbms': 'INFO',
'OS2015_academic_problem': 'INFO',
'discretize_elliptic_block_swipdg': 'INFO',
'offline': 'INFO',
'pymor.operators.constructions': 'ERROR',
'dune.pylrbms.discretize_elliptic_block_swipdg': 'INFO',
'dune.pylrbms': 'ERROR',
'pymor.bindings.dunext': 'ERROR',
'online_enrichment': 'INFO',
'lrbms': 'INFO',
'DXTC': 54
})
log_levels = dbg_levels #prod_levels
set_log_levels(log_levels)
logger = getLogger('online_adaptive_lrbms.online_adaptive_lrbms')
from dune.xt.common import logging
logging.create(log_levels['DXTC'])
from pymor.discretizations.basic import StationaryDiscretization
from dune.pylrbms.OS2015_academic_problem import init_grid_and_problem
# from local_thermalblock_problem import init_grid_and_problem
from dune.pylrbms.discretize_elliptic_block_swipdg import discretize
from dune.pylrbms.online_enrichment import AdaptiveEnrichment
from dune.pylrbms.reductor import LRBMSReductor, ParallelLRBMSReductor
# max discretization error, to derive enrichment_target_error
# ===========================================================
# OS2015_academic_problem
# [4, 4], 2, [2, 2], 4: 0.815510144764
'''.format(e.output, e.returncode))
revstring = NO_VERSIONSTRING
finally:
version = Version(revstring)
VERSION = version
print('Loading pymor version {}'.format(VERSION))
import os
if 'PYMOR_DEFAULTS' in os.environ:
filename = os.environ['PYMOR_DEFAULTS']
if filename in ('', 'NONE'):
print('Not loading any defaults from config file')
else:
if not os.path.exists(filename):
raise IOError('Cannot load defaults from file ' + filename)
print('Loading defaults from file ' + filename + ' (set by PYMOR_DEFAULTS)')
load_defaults_from_file(filename)
else:
filename = os.path.join(os.getcwd(), 'pymor_defaults.py')
if os.path.exists(filename):
if os.stat(filename).st_uid != os.getuid():
raise IOError('Cannot load defaults from config file ' + filename
+ ': not owned by user running Python interpreter')
print('Loading defaults from file ' + filename)
load_defaults_from_file(filename)
from pymor.core.logger import set_log_levels
set_log_levels()
def main(
diameter: float = Argument(
0.01, help='Diameter option for the domain discretizer.'),
r: int = Argument(5, help='Order of the ROMs.'),
):
"""Parametric 1D heat equation example."""
set_log_levels({'pymor.algorithms.gram_schmidt.gram_schmidt': 'WARNING'})
# Model
p = InstationaryProblem(StationaryProblem(
domain=LineDomain([0., 1.], left='robin', right='robin'),
diffusion=LincombFunction([
ExpressionFunction('(x[...,0] <= 0.5) * 1.', 1),
ExpressionFunction('(0.5 < x[...,0]) * 1.', 1)
], [1, ProjectionParameterFunctional('diffusion')]),
robin_data=(ConstantFunction(1., 1),
ExpressionFunction('(x[...,0] < 1e-10) * 1.', 1)),
outputs=(('l2_boundary',
ExpressionFunction('(x[...,0] > (1 - 1e-10)) * 1.', 1)), ),
),
ConstantFunction(0., 1),
T=3.)
fom, _ = discretize_instationary_cg(p, diameter=diameter, nt=100)
fom.visualize(fom.solve(mu=0.1))
fom.visualize(fom.solve(mu=1))
fom.visualize(fom.solve(mu=10))
lti = fom.to_lti()
print(f'order of the model = {lti.order}')
print(f'number of inputs = {lti.dim_input}')
print(f'number of outputs = {lti.dim_output}')
mu_list = [0.1, 1, 10]
w_list = np.logspace(-1, 3, 100)
# System poles
fig, ax = plt.subplots()
for mu in mu_list:
poles = lti.poles(mu=mu)
ax.plot(poles.real, poles.imag, '.', label=fr'$\mu = {mu}$')
ax.set_title('System poles')
ax.legend()
plt.show()
# Magnitude plots
fig, ax = plt.subplots()
for mu in mu_list:
lti.mag_plot(w_list, ax=ax, mu=mu, label=fr'$\mu = {mu}$')
ax.set_title('Magnitude plot of the full model')
ax.legend()
plt.show()
# Hankel singular values
fig, ax = plt.subplots()
for mu in mu_list:
hsv = lti.hsv(mu=mu)
ax.semilogy(range(1, len(hsv) + 1), hsv, label=fr'$\mu = {mu}$')
ax.set_title('Hankel singular values')
ax.legend()
plt.show()
# System norms
for mu in mu_list:
print(f'mu = {mu}:')
print(f' H_2-norm of the full model: {lti.h2_norm(mu=mu):e}')
if config.HAVE_SLYCOT:
print(
f' H_inf-norm of the full model: {lti.hinf_norm(mu=mu):e}')
print(f' Hankel-norm of the full model: {lti.hankel_norm(mu=mu):e}')
# Model order reduction
run_mor_method_param(lti, r, w_list, mu_list, BTReductor, 'BT')
run_mor_method_param(lti, r, w_list, mu_list, LQGBTReductor, 'LQGBT')
run_mor_method_param(lti, r, w_list, mu_list, BRBTReductor, 'BRBT')
run_mor_method_param(lti, r, w_list, mu_list, IRKAReductor, 'IRKA')
run_mor_method_param(lti, r, w_list, mu_list, TSIAReductor, 'TSIA')
run_mor_method_param(lti,
r,
w_list,
mu_list,
OneSidedIRKAReductor,
'OS-IRKA',
version='V')
