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')