def _projection_matrices(self, rom, projection):
if self.fom.parametric:
fom = self.fom.with_(**{
op: getattr(self.fom, op).assemble(mu=self.mu)
for op in ['A', 'B', 'C', 'D', 'E']
},
parameter_space=None)
else:
fom = self.fom
self.V, self.W = solve_sylv_schur(fom.A,
rom.A,
E=fom.E,
Er=rom.E,
B=fom.B,
Br=rom.B,
C=fom.C,
Cr=rom.C)
if projection == 'orth':
self.V = gram_schmidt(self.V, atol=0, rtol=0)
self.W = gram_schmidt(self.W, atol=0, rtol=0)
elif projection == 'biorth':
self.V, self.W = gram_schmidt_biorth(self.V, self.W, product=fom.E)
self._pg_reductor = LTIPGReductor(fom, self.W, self.V,
projection == 'biorth')
def reduce(self, r=None, tol=None, projection='bfsr'):
"""Generic Balanced Truncation.
Parameters
----------
r
Order of the reduced model if `tol` is `None`, maximum order if `tol` is specified.
tol
Tolerance for the error bound if `r` is `None`.
projection
Projection method used:
- `'sr'`: square root method
- `'bfsr'`: balancing-free square root method (default, since it avoids scaling by
singular values and orthogonalizes the projection matrices, which might make it more
accurate than the square root method)
- `'biorth'`: like the balancing-free square root method, except it biorthogonalizes the
projection matrices (using :func:`~pymor.algorithms.gram_schmidt.gram_schmidt_biorth`)
Returns
-------
rom
Reduced-order model.
"""
assert r is not None or tol is not None
assert r is None or 0 < r < self.fom.order
assert projection in ('sr', 'bfsr', 'biorth')
cf, of = self._gramians()
sv, sU, sV = self._sv_U_V()
# find reduced order if tol is specified
if tol is not None:
error_bounds = self.error_bounds()
r_tol = np.argmax(error_bounds <= tol) + 1
r = r_tol if r is None else min(r, r_tol)
if r > min(len(cf), len(of)):
raise ValueError(
'r needs to be smaller than the sizes of Gramian factors.')
# compute projection matrices
self.V = cf.lincomb(sV[:r])
self.W = of.lincomb(sU[:r])
if projection == 'sr':
alpha = 1 / np.sqrt(sv[:r])
self.V.scal(alpha)
self.W.scal(alpha)
elif projection == 'bfsr':
self.V = gram_schmidt(self.V, atol=0, rtol=0)
self.W = gram_schmidt(self.W, atol=0, rtol=0)
elif projection == 'biorth':
self.V, self.W = gram_schmidt_biorth(self.V,
self.W,
product=self.fom.E)
# find reduced-order model
self._pg_reductor = LTIPGReductor(self.fom, self.W, self.V, projection
in ('sr', 'biorth'))
rom = self._pg_reductor.reduce()
return rom
def _projection_matrix(self, r, sigma, b, c, projection):
if self.fom.parametric:
fom = self.fom.with_(**{
op: getattr(self.fom, op).assemble(mu=self.mu)
for op in ['A', 'B', 'C', 'D', 'E']
},
parameter_space=None)
else:
fom = self.fom
if self.version == 'V':
V = fom.A.source.empty(reserve=r)
else:
W = fom.A.source.empty(reserve=r)
for i in range(r):
if sigma[i].imag == 0:
sEmA = sigma[i].real * fom.E - fom.A
if self.version == 'V':
Bb = fom.B.apply(b.real[i])
V.append(sEmA.apply_inverse(Bb))
else:
CTc = fom.C.apply_adjoint(c.real[i])
W.append(sEmA.apply_inverse_adjoint(CTc))
elif sigma[i].imag > 0:
sEmA = sigma[i] * fom.E - fom.A
if self.version == 'V':
Bb = fom.B.apply(b[i])
v = sEmA.apply_inverse(Bb)
V.append(v.real)
V.append(v.imag)
else:
CTc = fom.C.apply_adjoint(c[i].conj())
w = sEmA.apply_inverse_adjoint(CTc)
W.append(w.real)
W.append(w.imag)
if self.version == 'V':
self.V = gram_schmidt(
V,
atol=0,
rtol=0,
product=None if projection == 'orth' else fom.E)
else:
self.V = gram_schmidt(
W,
atol=0,
rtol=0,
product=None if projection == 'orth' else fom.E)
self._pg_reductor = LTIPGReductor(fom, self.V, self.V,
projection == 'Eorth')
def _projection_matrix(self, r, sigma, b, c, projection):
fom = self.fom
if self.version == 'V':
V = fom.A.source.empty(reserve=r)
else:
W = fom.A.source.empty(reserve=r)
for i in range(r):
if sigma[i].imag == 0:
sEmA = sigma[i].real * self.fom.E - self.fom.A
if self.version == 'V':
Bb = fom.B.apply(b.real[i])
V.append(sEmA.apply_inverse(Bb))
else:
CTc = fom.C.apply_adjoint(c.real[i])
W.append(sEmA.apply_inverse_adjoint(CTc))
elif sigma[i].imag > 0:
sEmA = sigma[i] * self.fom.E - self.fom.A
if self.version == 'V':
Bb = fom.B.apply(b[i])
v = sEmA.apply_inverse(Bb)
V.append(v.real)
V.append(v.imag)
else:
CTc = fom.C.apply_adjoint(c[i].conj())
w = sEmA.apply_inverse_adjoint(CTc)
W.append(w.real)
W.append(w.imag)
if self.version == 'V':
self.V = gram_schmidt(V, atol=0, rtol=0, product=None if projection == 'orth' else fom.E)
else:
self.V = gram_schmidt(W, atol=0, rtol=0, product=None if projection == 'orth' else fom.E)
self._pg_reductor = LTIPGReductor(fom, self.V, self.V, projection == 'Eorth')
def _set_V_reductor(self, sigma, b, c, projection):
fom = (
self.fom.with_(
**{op: getattr(self.fom, op).assemble(mu=self.mu)
for op in ['A', 'B', 'C', 'D', 'E']},
parameter_space=None,
)
if self.fom.parametric
else self.fom
)
if self.version == 'V':
self.V = tangential_rational_krylov(fom.A, fom.E, fom.B, b, sigma,
orth=False)
gram_schmidt(self.V, atol=0, rtol=0,
product=None if projection == 'orth' else fom.E,
copy=False)
else:
self.V = tangential_rational_krylov(fom.A, fom.E, fom.C, c, sigma, trans=True,
orth=False)
gram_schmidt(self.V, atol=0, rtol=0,
product=None if projection == 'orth' else fom.E,
copy=False)
self.W = self.V
self._pg_reductor = LTIPGReductor(fom, self.V, self.V,
projection == 'Eorth')
def _projection_matrices(self, rom, projection):
fom = self.fom
self.V, self.W = solve_sylv_schur(fom.A,
rom.A,
E=fom.E,
Er=rom.E,
B=fom.B,
Br=rom.B,
C=fom.C,
Cr=rom.C)
if projection == 'orth':
self.V = gram_schmidt(self.V, atol=0, rtol=0)
self.W = gram_schmidt(self.W, atol=0, rtol=0)
elif projection == 'biorth':
self.V, self.W = gram_schmidt_biorth(self.V, self.W, product=fom.E)
self._pg_reductor = LTIPGReductor(fom, self.W, self.V,
projection == 'biorth')
def reduce(self, r=None, tol=None, projection='bfsr'):
"""Generic Balanced Truncation.
Parameters
----------
r
Order of the reduced model if `tol` is `None`, maximum order if `tol` is specified.
tol
Tolerance for the error bound if `r` is `None`.
projection
Projection method used:
- `'sr'`: square root method
- `'bfsr'`: balancing-free square root method (default, since it avoids scaling by
singular values and orthogonalizes the projection matrices, which might make it more
accurate than the square root method)
- `'biorth'`: like the balancing-free square root method, except it biorthogonalizes the
projection matrices (using :func:`~pymor.algorithms.gram_schmidt.gram_schmidt_biorth`)
Returns
-------
rom
Reduced-order model.
"""
assert r is not None or tol is not None
assert r is None or 0 < r < self.fom.order
assert projection in ('sr', 'bfsr', 'biorth')
cf, of = self._gramians()
sv, sU, sV = self._sv_U_V()
# find reduced order if tol is specified
if tol is not None:
error_bounds = self.error_bounds()
r_tol = np.argmax(error_bounds <= tol) + 1
r = r_tol if r is None else min(r, r_tol)
if r > min(len(cf), len(of)):
raise ValueError('r needs to be smaller than the sizes of Gramian factors.')
# compute projection matrices
self.V = cf.lincomb(sV[:r])
self.W = of.lincomb(sU[:r])
if projection == 'sr':
alpha = 1 / np.sqrt(sv[:r])
self.V.scal(alpha)
self.W.scal(alpha)
elif projection == 'bfsr':
self.V = gram_schmidt(self.V, atol=0, rtol=0)
self.W = gram_schmidt(self.W, atol=0, rtol=0)
elif projection == 'biorth':
self.V, self.W = gram_schmidt_biorth(self.V, self.W, product=self.fom.E)
# find reduced-order model
self._pg_reductor = LTIPGReductor(self.fom, self.W, self.V, projection in ('sr', 'biorth'))
rom = self._pg_reductor.reduce()
return rom
def _projection_matrix(self, r, sigma, b, c, projection):
fom = self.fom
if self.version == 'V':
V = fom.A.source.empty(reserve=r)
else:
W = fom.A.source.empty(reserve=r)
for i in range(r):
if sigma[i].imag == 0:
sEmA = sigma[i].real * self.fom.E - self.fom.A
if self.version == 'V':
Bb = fom.B.apply(b.real[i])
V.append(sEmA.apply_inverse(Bb))
else:
CTc = fom.C.apply_adjoint(c.real[i])
W.append(sEmA.apply_inverse_adjoint(CTc))
elif sigma[i].imag > 0:
sEmA = sigma[i] * self.fom.E - self.fom.A
if self.version == 'V':
Bb = fom.B.apply(b[i])
v = sEmA.apply_inverse(Bb)
V.append(v.real)
V.append(v.imag)
else:
CTc = fom.C.apply_adjoint(c[i].conj())
w = sEmA.apply_inverse_adjoint(CTc)
W.append(w.real)
W.append(w.imag)
if self.version == 'V':
self.V = gram_schmidt(
V,
atol=0,
rtol=0,
product=None if projection == 'orth' else fom.E)
else:
self.V = gram_schmidt(
W,
atol=0,
rtol=0,
product=None if projection == 'orth' else fom.E)
self._pg_reductor = LTIPGReductor(fom, self.V, self.V,
projection == 'Eorth')
def _projection_matrices(self, rom, projection):
fom = self.fom
self.V, self.W = solve_sylv_schur(fom.A, rom.A,
E=fom.E, Er=rom.E,
B=fom.B, Br=rom.B,
C=fom.C, Cr=rom.C)
if projection == 'orth':
self.V = gram_schmidt(self.V, atol=0, rtol=0)
self.W = gram_schmidt(self.W, atol=0, rtol=0)
elif projection == 'biorth':
self.V, self.W = gram_schmidt_biorth(self.V, self.W, product=fom.E)
self._pg_reductor = LTIPGReductor(fom, self.W, self.V, projection == 'biorth')
def _set_V_W_reductor(self, rom, projection):
fom = (
self.fom.with_(
**{op: getattr(self.fom, op).assemble(mu=self.mu)
for op in ['A', 'B', 'C', 'D', 'E']}
)
if self.fom.parametric
else self.fom
)
self.V, self.W = solve_sylv_schur(fom.A, rom.A,
E=fom.E, Er=rom.E,
B=fom.B, Br=rom.B,
C=fom.C, Cr=rom.C)
if projection == 'orth':
gram_schmidt(self.V, atol=0, rtol=0, copy=False)
gram_schmidt(self.W, atol=0, rtol=0, copy=False)
elif projection == 'biorth':
gram_schmidt_biorth(self.V, self.W, product=fom.E, copy=False)
self._pg_reductor = LTIPGReductor(fom, self.W, self.V,
projection == 'biorth')
class GenericBTReductor(BasicInterface):
"""Generic Balanced Truncation reductor.
Parameters
----------
fom
The full-order |LTIModel| to reduce.
"""
def __init__(self, fom):
assert isinstance(fom, LTIModel)
self.fom = fom
self.V = None
self.W = None
self._pg_reductor = None
self._sv_U_V_cache = None
def _gramians(self):
"""Return low-rank Cholesky factors of Gramians."""
raise NotImplementedError
def _sv_U_V(self):
"""Return singular values and vectors."""
if self._sv_U_V_cache is None:
cf, of = self._gramians()
U, sv, Vh = spla.svd(self.fom.E.apply2(of, cf), lapack_driver='gesvd')
self._sv_U_V_cache = (sv, U.T, Vh)
return self._sv_U_V_cache
def error_bounds(self):
"""Returns error bounds for all possible reduced orders."""
raise NotImplementedError
def reduce(self, r=None, tol=None, projection='bfsr'):
"""Generic Balanced Truncation.
Parameters
----------
r
Order of the reduced model if `tol` is `None`, maximum order if `tol` is specified.
tol
Tolerance for the error bound if `r` is `None`.
projection
Projection method used:
- `'sr'`: square root method
- `'bfsr'`: balancing-free square root method (default, since it avoids scaling by
singular values and orthogonalizes the projection matrices, which might make it more
accurate than the square root method)
- `'biorth'`: like the balancing-free square root method, except it biorthogonalizes the
projection matrices (using :func:`~pymor.algorithms.gram_schmidt.gram_schmidt_biorth`)
Returns
-------
rom
Reduced-order model.
"""
assert r is not None or tol is not None
assert r is None or 0 < r < self.fom.order
assert projection in ('sr', 'bfsr', 'biorth')
cf, of = self._gramians()
sv, sU, sV = self._sv_U_V()
# find reduced order if tol is specified
if tol is not None:
error_bounds = self.error_bounds()
r_tol = np.argmax(error_bounds <= tol) + 1
r = r_tol if r is None else min(r, r_tol)
if r > min(len(cf), len(of)):
raise ValueError('r needs to be smaller than the sizes of Gramian factors.')
# compute projection matrices
self.V = cf.lincomb(sV[:r])
self.W = of.lincomb(sU[:r])
if projection == 'sr':
alpha = 1 / np.sqrt(sv[:r])
self.V.scal(alpha)
self.W.scal(alpha)
elif projection == 'bfsr':
self.V = gram_schmidt(self.V, atol=0, rtol=0)
self.W = gram_schmidt(self.W, atol=0, rtol=0)
elif projection == 'biorth':
self.V, self.W = gram_schmidt_biorth(self.V, self.W, product=self.fom.E)
# find reduced-order model
self._pg_reductor = LTIPGReductor(self.fom, self.W, self.V, projection in ('sr', 'biorth'))
rom = self._pg_reductor.reduce()
return rom
def reconstruct(self, u):
"""Reconstruct high-dimensional vector from reduced vector `u`."""
return self._pg_reductor.reconstruct(u)
class OneSidedIRKAReductor(BasicInterface):
"""One-Sided Iterative Rational Krylov Algorithm reductor.
Parameters
----------
fom
The full-order |LTIModel| to reduce.
version
Version of the one-sided IRKA:
- `'V'`: Galerkin projection using the input Krylov subspace,
- `'W'`: Galerkin projection using the output Krylov subspace.
"""
def __init__(self, fom, version):
assert isinstance(fom, LTIModel)
assert version in ('V', 'W')
self.fom = fom
self.version = version
self.V = None
self._pg_reductor = None
self.conv_crit = None
self.sigmas = None
self.R = None
self.L = None
self.errors = None
def reduce(self,
r,
sigma=None,
b=None,
c=None,
rd0=None,
tol=1e-4,
maxit=100,
num_prev=1,
force_sigma_in_rhp=False,
projection='orth',
conv_crit='sigma',
compute_errors=False):
r"""Reduce using one-sided IRKA.
Parameters
----------
r
Order of the reduced order model.
sigma
Initial interpolation points (closed under conjugation).
If `None`, interpolation points are log-spaced between 0.1 and 10.
If `sigma` is an `int`, it is used as a seed to generate it randomly.
Otherwise, it needs to be a one-dimensional array-like of length `r`.
`sigma` and `rd0` cannot both be not `None`.
b
Initial right tangential directions.
If `None`, if is chosen as all ones.
If `b` is an `int`, it is used as a seed to generate it randomly.
Otherwise, it needs to be a |VectorArray| of length `r` from `fom.B.source`.
`b` and `rd0` cannot both be not `None`.
c
Initial left tangential directions.
If `None`, if is chosen as all ones.
If `c` is an `int`, it is used as a seed to generate it randomly.
Otherwise, it needs to be a |VectorArray| of length `r` from `fom.C.range`.
`c` and `rd0` cannot both be not `None`.
rd0
Initial reduced order model.
If `None`, then `sigma`, `b`, and `c` are used.
Otherwise, it needs to be an |LTIModel| of order `r` and it is used to construct
`sigma`, `b`, and `c`.
tol
Tolerance for the largest change in interpolation points.
maxit
Maximum number of iterations.
num_prev
Number of previous iterations to compare the current iteration to.
A larger number can avoid occasional cyclic behavior.
force_sigma_in_rhp
If 'False`, new interpolation are reflections of reduced order model's poles.
Otherwise, they are always in the right half-plane.
projection
Projection method:
- `'orth'`: projection matrix is orthogonalized with respect to the Euclidean inner
product,
- `'Eorth'`: projection matrix is orthogonalized with respect to the E product.
conv_crit
Convergence criterion:
- `'sigma'`: relative change in interpolation points,
- `'h2'`: relative :math:`\mathcal{H}_2` distance of reduced order models.
compute_errors
Should the relative :math:`\mathcal{H}_2`-errors of intermediate reduced order models be
computed.
.. warning::
Computing :math:`\mathcal{H}_2`-errors is expensive.
Use this option only if necessary.
Returns
-------
rom
Reduced |LTIModel| model.
"""
fom = self.fom
if not fom.cont_time:
raise NotImplementedError
assert 0 < r < fom.order
assert isinstance(num_prev, int) and num_prev >= 1
assert projection in ('orth', 'Eorth')
assert conv_crit in ('sigma', 'h2')
# initial interpolation points and tangential directions
assert sigma is None or isinstance(sigma, int) or len(sigma) == r
assert b is None or isinstance(
b, int) or b in fom.B.source and len(b) == r
assert c is None or isinstance(c,
int) or c in fom.C.range and len(c) == r
assert (rd0 is None or isinstance(rd0, LTIModel) and rd0.order == r
and rd0.input_space == fom.input_space
and rd0.output_space == fom.output_space)
assert sigma is None or rd0 is None
assert b is None or rd0 is None
assert c is None or rd0 is None
if rd0 is not None:
poles, b, c = _poles_and_tangential_directions(rd0)
sigma = np.abs(
poles.real) + poles.imag * 1j if force_sigma_in_rhp else -poles
else:
if sigma is None:
sigma = np.logspace(-1, 1, r)
elif isinstance(sigma, int):
np.random.seed(sigma)
sigma = np.abs(np.random.randn(r))
if self.version == 'V':
if b is None:
b = fom.B.source.ones(r)
elif isinstance(b, int):
b = fom.B.source.random(r, distribution='normal', seed=b)
else:
if c is None:
c = fom.C.range.ones(r)
elif isinstance(c, int):
c = fom.C.range.random(r, distribution='normal', seed=c)
self.logger.info('Starting one-sided IRKA')
self.conv_crit = []
self.sigmas = [np.array(sigma)]
if self.version == 'V':
self.R = [b]
else:
self.L = [c]
self.errors = [] if compute_errors else None
# main loop
for it in range(maxit):
# interpolatory reduced order model
self._projection_matrix(r, sigma, b, c, projection)
rom = self._pg_reductor.reduce()
# new interpolation points and tangential directions
poles, b, c = _poles_and_tangential_directions(rom)
sigma = np.abs(
poles.real) + poles.imag * 1j if force_sigma_in_rhp else -poles
self.sigmas.append(sigma)
if self.version == 'V':
self.R.append(b)
else:
self.L.append(c)
# compute convergence criterion
if conv_crit == 'sigma':
dist = _convergence_criterion(self.sigmas[:-num_prev - 2:-1],
conv_crit)
self.conv_crit.append(dist)
elif conv_crit == 'h2':
if it == 0:
rom_list = (num_prev + 1) * [None]
rom_list[0] = rom
self.conv_crit.append(np.inf)
else:
rom_list[1:] = rom_list[:-1]
rom_list[0] = rom
dist = _convergence_criterion(rom_list, conv_crit)
self.conv_crit.append(dist)
# report convergence
self.logger.info(
f'Convergence criterion in iteration {it + 1}: {self.conv_crit[-1]:e}'
)
if compute_errors:
if np.max(rom.poles().real) < 0:
err = fom - rom
rel_H2_err = err.h2_norm() / fom.h2_norm()
else:
rel_H2_err = np.inf
self.errors.append(rel_H2_err)
self.logger.info(
f'Relative H2-error in iteration {it + 1}: {rel_H2_err:e}')
# check if convergence criterion is satisfied
if self.conv_crit[-1] < tol:
break
# final reduced order model
self._projection_matrix(r, sigma, b, c, projection)
rom = self._pg_reductor.reduce()
return rom
def _projection_matrix(self, r, sigma, b, c, projection):
fom = self.fom
if self.version == 'V':
V = fom.A.source.empty(reserve=r)
else:
W = fom.A.source.empty(reserve=r)
for i in range(r):
if sigma[i].imag == 0:
sEmA = sigma[i].real * self.fom.E - self.fom.A
if self.version == 'V':
Bb = fom.B.apply(b.real[i])
V.append(sEmA.apply_inverse(Bb))
else:
CTc = fom.C.apply_adjoint(c.real[i])
W.append(sEmA.apply_inverse_adjoint(CTc))
elif sigma[i].imag > 0:
sEmA = sigma[i] * self.fom.E - self.fom.A
if self.version == 'V':
Bb = fom.B.apply(b[i])
v = sEmA.apply_inverse(Bb)
V.append(v.real)
V.append(v.imag)
else:
CTc = fom.C.apply_adjoint(c[i].conj())
w = sEmA.apply_inverse_adjoint(CTc)
W.append(w.real)
W.append(w.imag)
if self.version == 'V':
self.V = gram_schmidt(
V,
atol=0,
rtol=0,
product=None if projection == 'orth' else fom.E)
else:
self.V = gram_schmidt(
W,
atol=0,
rtol=0,
product=None if projection == 'orth' else fom.E)
self._pg_reductor = LTIPGReductor(fom, self.V, self.V,
projection == 'Eorth')
def reconstruct(self, u):
"""Reconstruct high-dimensional vector from reduced vector `u`."""
return self._pg_reductor.reconstruct(u)
class TSIAReductor(BasicInterface):
"""Two-Sided Iteration Algorithm reductor.
Parameters
----------
fom
The full-order |LTIModel| to reduce.
"""
def __init__(self, fom):
assert isinstance(fom, LTIModel)
self.fom = fom
self.V = None
self.W = None
self._pg_reductor = None
self.conv_crit = None
self.errors = None
def reduce(self, rom0, tol=1e-4, maxit=100, num_prev=1, projection='orth', conv_crit='sigma',
compute_errors=False):
r"""Reduce using TSIA.
See [XZ11]_ (Algorithm 1) and [BKS11]_.
In exact arithmetic, TSIA is equivalent to IRKA (under some
assumptions on the poles of the reduced model). The main
difference in implementation is that TSIA computes the Schur
decomposition of the reduced matrices, while IRKA computes the
eigenvalue decomposition. Therefore, TSIA might behave better
for non-normal reduced matrices.
Parameters
----------
rom0
Initial reduced order model.
tol
Tolerance for the convergence criterion.
maxit
Maximum number of iterations.
num_prev
Number of previous iterations to compare the current
iteration to. Larger number can avoid occasional cyclic
behavior of TSIA.
projection
Projection method:
- `'orth'`: projection matrices are orthogonalized with
respect to the Euclidean inner product
- `'biorth'`: projection matrices are biorthogolized with
respect to the E product
conv_crit
Convergence criterion:
- `'sigma'`: relative change in interpolation points
- `'h2'`: relative :math:`\mathcal{H}_2` distance of
reduced-order models
compute_errors
Should the relative :math:`\mathcal{H}_2`-errors of
intermediate reduced order models be computed.
.. warning::
Computing :math:`\mathcal{H}_2`-errors is expensive. Use
this option only if necessary.
Returns
-------
rom
Reduced |LTIModel|.
"""
fom = self.fom
assert isinstance(rom0, LTIModel) and rom0.B.source == fom.B.source and rom0.C.range == fom.C.range
r = rom0.order
assert 0 < r < fom.order
assert isinstance(num_prev, int) and num_prev >= 1
assert projection in ('orth', 'biorth')
assert conv_crit in ('sigma', 'h2')
# begin logging
self.logger.info('Starting TSIA')
# find initial projection matrices
self._projection_matrices(rom0, projection)
data = (num_prev + 1) * [None]
data[0] = rom0.poles() if conv_crit == 'sigma' else rom0
self.conv_crit = []
self.errors = [] if compute_errors else None
# main loop
for it in range(maxit):
# project the full order model
rom = self._pg_reductor.reduce()
# compute convergence criterion
data[1:] = data[:-1]
data[0] = rom.poles() if conv_crit == 'sigma' else rom
dist = _convergence_criterion(data, conv_crit)
self.conv_crit.append(dist)
# report convergence
self.logger.info(f'Convergence criterion in iteration {it + 1}: {self.conv_crit[-1]:e}')
if compute_errors:
if np.max(rom.poles().real) < 0:
err = fom - rom
rel_H2_err = err.h2_norm() / fom.h2_norm()
else:
rel_H2_err = np.inf
self.errors.append(rel_H2_err)
self.logger.info(f'Relative H2-error in iteration {it + 1}: {rel_H2_err:e}')
# new projection matrices
self._projection_matrices(rom, projection)
# check convergence criterion
if self.conv_crit[-1] < tol:
break
# final reduced order model
rom = self._pg_reductor.reduce()
return rom
def _projection_matrices(self, rom, projection):
fom = self.fom
self.V, self.W = solve_sylv_schur(fom.A, rom.A,
E=fom.E, Er=rom.E,
B=fom.B, Br=rom.B,
C=fom.C, Cr=rom.C)
if projection == 'orth':
self.V = gram_schmidt(self.V, atol=0, rtol=0)
self.W = gram_schmidt(self.W, atol=0, rtol=0)
elif projection == 'biorth':
self.V, self.W = gram_schmidt_biorth(self.V, self.W, product=fom.E)
self._pg_reductor = LTIPGReductor(fom, self.W, self.V, projection == 'biorth')
def reconstruct(self, u):
"""Reconstruct high-dimensional vector from reduced vector `u`."""
return self._pg_reductor.reconstruct(u)
class GenericBTReductor(BasicObject):
"""Generic Balanced Truncation reductor.
Parameters
----------
fom
The full-order |LTIModel| to reduce.
mu
|Parameter|.
"""
def __init__(self, fom, mu=None):
assert isinstance(fom, LTIModel)
self.fom = fom
self.mu = fom.parse_parameter(mu)
self.V = None
self.W = None
self._pg_reductor = None
self._sv_U_V_cache = None
def _gramians(self):
"""Return low-rank Cholesky factors of Gramians."""
raise NotImplementedError
def _sv_U_V(self):
"""Return singular values and vectors."""
if self._sv_U_V_cache is None:
cf, of = self._gramians()
U, sv, Vh = spla.svd(self.fom.E.apply2(of, cf, mu=self.mu),
lapack_driver='gesvd')
self._sv_U_V_cache = (sv, U.T, Vh)
return self._sv_U_V_cache
def error_bounds(self):
"""Returns error bounds for all possible reduced orders."""
raise NotImplementedError
def reduce(self, r=None, tol=None, projection='bfsr'):
"""Generic Balanced Truncation.
Parameters
----------
r
Order of the reduced model if `tol` is `None`, maximum order if `tol` is specified.
tol
Tolerance for the error bound if `r` is `None`.
projection
Projection method used:
- `'sr'`: square root method
- `'bfsr'`: balancing-free square root method (default, since it avoids scaling by
singular values and orthogonalizes the projection matrices, which might make it more
accurate than the square root method)
- `'biorth'`: like the balancing-free square root method, except it biorthogonalizes the
projection matrices (using :func:`~pymor.algorithms.gram_schmidt.gram_schmidt_biorth`)
Returns
-------
rom
Reduced-order model.
"""
assert r is not None or tol is not None
assert r is None or 0 < r < self.fom.order
assert projection in ('sr', 'bfsr', 'biorth')
cf, of = self._gramians()
sv, sU, sV = self._sv_U_V()
# find reduced order if tol is specified
if tol is not None:
error_bounds = self.error_bounds()
r_tol = np.argmax(error_bounds <= tol) + 1
r = r_tol if r is None else min(r, r_tol)
if r > min(len(cf), len(of)):
raise ValueError(
'r needs to be smaller than the sizes of Gramian factors.')
# compute projection matrices
self.V = cf.lincomb(sV[:r])
self.W = of.lincomb(sU[:r])
if projection == 'sr':
alpha = 1 / np.sqrt(sv[:r])
self.V.scal(alpha)
self.W.scal(alpha)
elif projection == 'bfsr':
gram_schmidt(self.V, atol=0, rtol=0, copy=False)
gram_schmidt(self.W, atol=0, rtol=0, copy=False)
elif projection == 'biorth':
gram_schmidt_biorth(self.V, self.W, product=self.fom.E, copy=False)
# find reduced-order model
if self.fom.parametric:
fom_mu = self.fom.with_(**{
op: getattr(self.fom, op).assemble(mu=self.mu)
for op in ['A', 'B', 'C', 'D', 'E']
},
parameter_space=None)
else:
fom_mu = self.fom
self._pg_reductor = LTIPGReductor(fom_mu, self.W, self.V, projection
in ('sr', 'biorth'))
rom = self._pg_reductor.reduce()
return rom
def reconstruct(self, u):
"""Reconstruct high-dimensional vector from reduced vector `u`."""
return self._pg_reductor.reconstruct(u)
class OneSidedIRKAReductor(BasicInterface):
"""One-Sided Iterative Rational Krylov Algorithm reductor.
Parameters
----------
fom
The full-order |LTIModel| to reduce.
version
Version of the one-sided IRKA:
- `'V'`: Galerkin projection using the input Krylov subspace,
- `'W'`: Galerkin projection using the output Krylov subspace.
"""
def __init__(self, fom, version):
assert isinstance(fom, LTIModel)
assert version in ('V', 'W')
self.fom = fom
self.version = version
self.V = None
self._pg_reductor = None
self.conv_crit = None
self.sigmas = None
self.R = None
self.L = None
self.errors = None
def reduce(self, r, sigma=None, b=None, c=None, rd0=None, tol=1e-4, maxit=100, num_prev=1,
force_sigma_in_rhp=False, projection='orth', conv_crit='sigma',
compute_errors=False):
r"""Reduce using one-sided IRKA.
Parameters
----------
r
Order of the reduced order model.
sigma
Initial interpolation points (closed under conjugation).
If `None`, interpolation points are log-spaced between 0.1 and 10.
If `sigma` is an `int`, it is used as a seed to generate it randomly.
Otherwise, it needs to be a one-dimensional array-like of length `r`.
`sigma` and `rd0` cannot both be not `None`.
b
Initial right tangential directions.
If `None`, if is chosen as all ones.
If `b` is an `int`, it is used as a seed to generate it randomly.
Otherwise, it needs to be a |VectorArray| of length `r` from `fom.B.source`.
`b` and `rd0` cannot both be not `None`.
c
Initial left tangential directions.
If `None`, if is chosen as all ones.
If `c` is an `int`, it is used as a seed to generate it randomly.
Otherwise, it needs to be a |VectorArray| of length `r` from `fom.C.range`.
`c` and `rd0` cannot both be not `None`.
rd0
Initial reduced order model.
If `None`, then `sigma`, `b`, and `c` are used.
Otherwise, it needs to be an |LTIModel| of order `r` and it is used to construct
`sigma`, `b`, and `c`.
tol
Tolerance for the largest change in interpolation points.
maxit
Maximum number of iterations.
num_prev
Number of previous iterations to compare the current iteration to.
A larger number can avoid occasional cyclic behavior.
force_sigma_in_rhp
If 'False`, new interpolation are reflections of reduced order model's poles.
Otherwise, they are always in the right half-plane.
projection
Projection method:
- `'orth'`: projection matrix is orthogonalized with respect to the Euclidean inner
product,
- `'Eorth'`: projection matrix is orthogonalized with respect to the E product.
conv_crit
Convergence criterion:
- `'sigma'`: relative change in interpolation points,
- `'h2'`: relative :math:`\mathcal{H}_2` distance of reduced order models.
compute_errors
Should the relative :math:`\mathcal{H}_2`-errors of intermediate reduced order models be
computed.
.. warning::
Computing :math:`\mathcal{H}_2`-errors is expensive.
Use this option only if necessary.
Returns
-------
rom
Reduced |LTIModel| model.
"""
fom = self.fom
if not fom.cont_time:
raise NotImplementedError
assert 0 < r < fom.order
assert isinstance(num_prev, int) and num_prev >= 1
assert projection in ('orth', 'Eorth')
assert conv_crit in ('sigma', 'h2')
# initial interpolation points and tangential directions
assert sigma is None or isinstance(sigma, int) or len(sigma) == r
assert b is None or isinstance(b, int) or b in fom.B.source and len(b) == r
assert c is None or isinstance(c, int) or c in fom.C.range and len(c) == r
assert (rd0 is None
or isinstance(rd0, LTIModel)
and rd0.order == r and rd0.input_space == fom.input_space and rd0.output_space == fom.output_space)
assert sigma is None or rd0 is None
assert b is None or rd0 is None
assert c is None or rd0 is None
if rd0 is not None:
poles, b, c = _poles_and_tangential_directions(rd0)
sigma = np.abs(poles.real) + poles.imag * 1j if force_sigma_in_rhp else -poles
else:
if sigma is None:
sigma = np.logspace(-1, 1, r)
elif isinstance(sigma, int):
np.random.seed(sigma)
sigma = np.abs(np.random.randn(r))
if self.version == 'V':
if b is None:
b = fom.B.source.ones(r)
elif isinstance(b, int):
b = fom.B.source.random(r, distribution='normal', seed=b)
else:
if c is None:
c = fom.C.range.ones(r)
elif isinstance(c, int):
c = fom.C.range.random(r, distribution='normal', seed=c)
self.logger.info('Starting one-sided IRKA')
self.conv_crit = []
self.sigmas = [np.array(sigma)]
if self.version == 'V':
self.R = [b]
else:
self.L = [c]
self.errors = [] if compute_errors else None
# main loop
for it in range(maxit):
# interpolatory reduced order model
self._projection_matrix(r, sigma, b, c, projection)
rom = self._pg_reductor.reduce()
# new interpolation points and tangential directions
poles, b, c = _poles_and_tangential_directions(rom)
sigma = np.abs(poles.real) + poles.imag * 1j if force_sigma_in_rhp else -poles
self.sigmas.append(sigma)
if self.version == 'V':
self.R.append(b)
else:
self.L.append(c)
# compute convergence criterion
if conv_crit == 'sigma':
dist = _convergence_criterion(self.sigmas[:-num_prev-2:-1], conv_crit)
self.conv_crit.append(dist)
elif conv_crit == 'h2':
if it == 0:
rom_list = (num_prev + 1) * [None]
rom_list[0] = rom
self.conv_crit.append(np.inf)
else:
rom_list[1:] = rom_list[:-1]
rom_list[0] = rom
dist = _convergence_criterion(rom_list, conv_crit)
self.conv_crit.append(dist)
# report convergence
self.logger.info(f'Convergence criterion in iteration {it + 1}: {self.conv_crit[-1]:e}')
if compute_errors:
if np.max(rom.poles().real) < 0:
err = fom - rom
rel_H2_err = err.h2_norm() / fom.h2_norm()
else:
rel_H2_err = np.inf
self.errors.append(rel_H2_err)
self.logger.info(f'Relative H2-error in iteration {it + 1}: {rel_H2_err:e}')
# check if convergence criterion is satisfied
if self.conv_crit[-1] < tol:
break
# final reduced order model
self._projection_matrix(r, sigma, b, c, projection)
rom = self._pg_reductor.reduce()
return rom
def _projection_matrix(self, r, sigma, b, c, projection):
fom = self.fom
if self.version == 'V':
V = fom.A.source.empty(reserve=r)
else:
W = fom.A.source.empty(reserve=r)
for i in range(r):
if sigma[i].imag == 0:
sEmA = sigma[i].real * self.fom.E - self.fom.A
if self.version == 'V':
Bb = fom.B.apply(b.real[i])
V.append(sEmA.apply_inverse(Bb))
else:
CTc = fom.C.apply_adjoint(c.real[i])
W.append(sEmA.apply_inverse_adjoint(CTc))
elif sigma[i].imag > 0:
sEmA = sigma[i] * self.fom.E - self.fom.A
if self.version == 'V':
Bb = fom.B.apply(b[i])
v = sEmA.apply_inverse(Bb)
V.append(v.real)
V.append(v.imag)
else:
CTc = fom.C.apply_adjoint(c[i].conj())
w = sEmA.apply_inverse_adjoint(CTc)
W.append(w.real)
W.append(w.imag)
if self.version == 'V':
self.V = gram_schmidt(V, atol=0, rtol=0, product=None if projection == 'orth' else fom.E)
else:
self.V = gram_schmidt(W, atol=0, rtol=0, product=None if projection == 'orth' else fom.E)
self._pg_reductor = LTIPGReductor(fom, self.V, self.V, projection == 'Eorth')
def reconstruct(self, u):
"""Reconstruct high-dimensional vector from reduced vector `u`."""
return self._pg_reductor.reconstruct(u)
class GenericBTReductor(BasicInterface):
"""Generic Balanced Truncation reductor.
Parameters
----------
fom
The system which is to be reduced.
"""
def __init__(self, fom):
assert isinstance(fom, LTIModel)
self.fom = fom
self.V = None
self.W = None
self.sv = None
self.sU = None
self.sV = None
def gramians(self):
"""Return low-rank Cholesky factors of Gramians."""
raise NotImplementedError
def sv_U_V(self):
"""Return singular values and vectors."""
if self.sv is None or self.sU is None or self.sV is None:
cf, of = self.gramians()
U, sv, Vh = spla.svd(self.fom.E.apply2(of, cf), lapack_driver='gesvd')
self.sv = sv
self.sU = U.T
self.sV = Vh
return self.sv, self.sU, self.sV
def error_bounds(self):
"""Returns error bounds for all possible reduced orders."""
raise NotImplementedError
def reduce(self, r=None, tol=None, projection='bfsr'):
"""Generic Balanced Truncation.
Parameters
----------
r
Order of the reduced model if `tol` is `None`, maximum order
if `tol` is specified.
tol
Tolerance for the error bound if `r` is `None`.
projection
Projection method used:
- `'sr'`: square root method
- `'bfsr'`: balancing-free square root method (default,
since it avoids scaling by singular values and
orthogonalizes the projection matrices, which might make
it more accurate than the square root method)
- `'biorth'`: like the balancing-free square root method,
except it biorthogonalizes the projection matrices (using
:func:`~pymor.algorithms.gram_schmidt.gram_schmidt_biorth`)
Returns
-------
rom
Reduced system.
"""
assert r is not None or tol is not None
assert r is None or 0 < r < self.fom.order
assert projection in ('sr', 'bfsr', 'biorth')
cf, of = self.gramians()
sv, sU, sV = self.sv_U_V()
# find reduced order if tol is specified
if tol is not None:
error_bounds = self.error_bounds()
r_tol = np.argmax(error_bounds <= tol) + 1
r = r_tol if r is None else min(r, r_tol)
if r > min(len(cf), len(of)):
raise ValueError('r needs to be smaller than the sizes of Gramian factors.')
# compute projection matrices and find the reduced model
self.V = cf.lincomb(sV[:r])
self.W = of.lincomb(sU[:r])
if projection == 'sr':
alpha = 1 / np.sqrt(sv[:r])
self.V.scal(alpha)
self.W.scal(alpha)
elif projection == 'bfsr':
self.V = gram_schmidt(self.V, atol=0, rtol=0)
self.W = gram_schmidt(self.W, atol=0, rtol=0)
elif projection == 'biorth':
self.V, self.W = gram_schmidt_biorth(self.V, self.W, product=self.fom.E)
self.pg_reductor = LTIPGReductor(self.fom, self.W, self.V, projection in ('sr', 'biorth'))
rom = self.pg_reductor.reduce()
return rom
def reconstruct(self, u):
"""Reconstruct high-dimensional vector from reduced vector `u`."""
self.pg_reductor.reconstruct(u)
class TSIAReductor(BasicInterface):
"""Two-Sided Iteration Algorithm reductor.
Parameters
----------
fom
The full-order |LTIModel| to reduce.
"""
def __init__(self, fom):
assert isinstance(fom, LTIModel)
self.fom = fom
self.V = None
self.W = None
self._pg_reductor = None
self.conv_crit = None
self.errors = None
def reduce(self,
rom0,
tol=1e-4,
maxit=100,
num_prev=1,
projection='orth',
conv_crit='sigma',
compute_errors=False):
r"""Reduce using TSIA.
See [XZ11]_ (Algorithm 1) and [BKS11]_.
In exact arithmetic, TSIA is equivalent to IRKA (under some
assumptions on the poles of the reduced model). The main
difference in implementation is that TSIA computes the Schur
decomposition of the reduced matrices, while IRKA computes the
eigenvalue decomposition. Therefore, TSIA might behave better
for non-normal reduced matrices.
Parameters
----------
rom0
Initial reduced order model.
tol
Tolerance for the convergence criterion.
maxit
Maximum number of iterations.
num_prev
Number of previous iterations to compare the current
iteration to. Larger number can avoid occasional cyclic
behavior of TSIA.
projection
Projection method:
- `'orth'`: projection matrices are orthogonalized with
respect to the Euclidean inner product
- `'biorth'`: projection matrices are biorthogolized with
respect to the E product
conv_crit
Convergence criterion:
- `'sigma'`: relative change in interpolation points
- `'h2'`: relative :math:`\mathcal{H}_2` distance of
reduced-order models
compute_errors
Should the relative :math:`\mathcal{H}_2`-errors of
intermediate reduced order models be computed.
.. warning::
Computing :math:`\mathcal{H}_2`-errors is expensive. Use
this option only if necessary.
Returns
-------
rom
Reduced |LTIModel|.
"""
fom = self.fom
assert isinstance(
rom0, LTIModel
) and rom0.B.source == fom.B.source and rom0.C.range == fom.C.range
r = rom0.order
assert 0 < r < fom.order
assert isinstance(num_prev, int) and num_prev >= 1
assert projection in ('orth', 'biorth')
assert conv_crit in ('sigma', 'h2')
# begin logging
self.logger.info('Starting TSIA')
# find initial projection matrices
self._projection_matrices(rom0, projection)
data = (num_prev + 1) * [None]
data[0] = rom0.poles() if conv_crit == 'sigma' else rom0
self.conv_crit = []
self.errors = [] if compute_errors else None
# main loop
for it in range(maxit):
# project the full order model
rom = self._pg_reductor.reduce()
# compute convergence criterion
data[1:] = data[:-1]
data[0] = rom.poles() if conv_crit == 'sigma' else rom
dist = _convergence_criterion(data, conv_crit)
self.conv_crit.append(dist)
# report convergence
self.logger.info(
f'Convergence criterion in iteration {it + 1}: {self.conv_crit[-1]:e}'
)
if compute_errors:
if np.max(rom.poles().real) < 0:
err = fom - rom
rel_H2_err = err.h2_norm() / fom.h2_norm()
else:
rel_H2_err = np.inf
self.errors.append(rel_H2_err)
self.logger.info(
f'Relative H2-error in iteration {it + 1}: {rel_H2_err:e}')
# new projection matrices
self._projection_matrices(rom, projection)
# check convergence criterion
if self.conv_crit[-1] < tol:
break
# final reduced order model
rom = self._pg_reductor.reduce()
return rom
def _projection_matrices(self, rom, projection):
fom = self.fom
self.V, self.W = solve_sylv_schur(fom.A,
rom.A,
E=fom.E,
Er=rom.E,
B=fom.B,
Br=rom.B,
C=fom.C,
Cr=rom.C)
if projection == 'orth':
self.V = gram_schmidt(self.V, atol=0, rtol=0)
self.W = gram_schmidt(self.W, atol=0, rtol=0)
elif projection == 'biorth':
self.V, self.W = gram_schmidt_biorth(self.V, self.W, product=fom.E)
self._pg_reductor = LTIPGReductor(fom, self.W, self.V,
projection == 'biorth')
def reconstruct(self, u):
"""Reconstruct high-dimensional vector from reduced vector `u`."""
return self._pg_reductor.reconstruct(u)