pymor.algorithms package¶
Submodules¶
adaptivegreedy module¶

class
pymor.algorithms.adaptivegreedy.
AdaptiveSampleSet
(parameter_space)[source]¶ Bases:
pymor.core.interfaces.BasicInterface
An adaptive parameter sample set.
Used by
adaptive_greedy
.Methods
AdaptiveSampleSet
map_vertex_to_mu
,refine
,visualize
BasicInterface
disable_logging
,enable_logging
,has_interface_name
,implementor_names
,implementors
,lock
,unlock
,__setattr__
Attributes
AdaptiveSampleSet
Element
BasicInterface
locked
,logger
,logging_disabled
,name
,uid

pymor.algorithms.adaptivegreedy.
_estimate
(mu, rd=None, d=None, rc=None, error_norm=None)[source]¶ Called by
adaptive_greedy
.

pymor.algorithms.adaptivegreedy.
adaptive_greedy
(discretization, reductor, parameter_space=None, initial_basis=None, use_estimator=True, error_norm=None, extension_algorithm=<function gram_schmidt_basis_extension>, target_error=None, max_extensions=None, validation_mus=0, rho=1.1, gamma=0.2, theta=0.0, visualize=False, visualize_vertex_size=80, pool=<pymor.parallel.dummy.DummyPool object>)[source]¶ Greedy basis generation algorithm with adaptively refined training set.
This method extends pyMOR’s default
greedy
greedy basis generation algorithm by adaptive refinement of the parameter training set according to [HDO11] to prevent overfitting of the reduced basis to the training set. This is achieved by estimating the reduction error on an additional validation set of parameters. If the ratio between the estimated errors on the validation set and the validation set is larger thanrho
, the training set is refined using standard grid refinement techniques.[HDO11] Haasdonk, B.; Dihlmann, M. & Ohlberger, M., A training set and multiple bases generation approach for parameterized model reduction based on adaptive grids in parameter space, Math. Comput. Model. Dyn. Syst., 2011, 17, 423442 Parameters
 discretization
 See
greedy
.  reductor
 See
greedy
.  parameter_space
 The
ParameterSpace
for which to compute the reduced model. IfNone
, the parameter space of thediscretization
is used.  initial_basis
 See
greedy
.  use_estimator
 See
greedy
.  error_norm
 See
greedy
.  extension_algorithm
 See
greedy
.  target_error
 See
greedy
.  max_extensions
 See
greedy
.  validation_mus
 One of the following:
 a list of
Parameters
to use as validation set,  a positive number indicating the number of random parameters to use as validation set,
 a nonpositive number, indicating the negative number of random parameters to use as validation set in addition to the centers of the elements of the adaptive training set.
 a list of
 rho
 Maximum allowed ratio between maximum estimated error on validation set vs. maximum estimated error on training set. If the ratio is larger, the training set is refined.
 gamma
 Weight of the age penalty term in the training set refinement indicators.
 theta
 Ratio of training set elements to select for refinement. (One element is always refined.)
 visualize
 If
True
, visualize the refinement indicators. (Only available for 2 and 3 dimensional parameter spaces.)  visualize_vertex_size
 Size of the vertices in the visualization.
 pool
 See
greedy
.
Returns
Dict with the following fields
basis: The reduced basis. reduced_discretization: The reduced Discretization
obtained for the computed basis.reconstructor: Reconstructor for reduced_discretization
.extensions: Number of greedy iterations. max_errs: Sequence of maximum errors during the greedy run. max_err_mus: The parameters corresponding to max_errs
.max_val_errs: Sequence of maximum errors on the validation set. max_val_err_mus: The parameters corresponding to max_val_errs
.refinements: Number of refinements made in each extension step. training_set_sizes: The final size of the training set in each extension step. time: Duration of the algorithm. reduction_data: Reduction data returned by the last reductor call.
basic module¶
Module containing some basic but generic linear algebra algorithms.

pymor.algorithms.basic.
almost_equal
(U, V, U_ind=None, V_ind=None, product=None, norm=None, rtol=1e14, atol=1e14)[source]¶ Compare U and V for almost equality.
The vectors of
U
andV
are compared in pairs for almost equality. Two vectorsu
andv
are considered almost equal iffu  v <= atol + v * rtol.The norm to be used can be specified via the
norm
orproduct
parameter.If the length of
U
(U_ind
) resp.V
(V_ind
) is 1, the single specified vector is compared to all vectors of the other array. Otherwise, the lengths of both indexed arrays have to agree.Parameters
 U, V
VectorArrays
to be compared. U_ind, V_ind
 Indices of the vectors that are to be compared (see
VectorArray
).  product
 If specified, use this inner product
Operator
to compute the norm.product
andnorm
are mutually exclusive.  norm
 If specified, must be a callable, which is used to compute the norm
or, alternatively, one of the string ‘l1’, ‘l2’, ‘sup’, in which case the
respective
VectorArray
norm methods are used.product
andnorm
are mutually exclusive. If neither is specified,norm='l2'
is assumed.  rtol
 The relative tolerance.
 atol
 The absolute tolerance.
Defaults
rtol, atol (see
pymor.core.defaults
)
basisextension module¶
This module contains algorithms for extending a given reduced basis by a new vector.
The methods are mainly designed to be used in conjunction with
the greedy
algorithm. Each method is of the form
extension_algorithm(basis, U, ...)
where basis
and U
are VectorArrays
containing the old basis and new vectors
to be added. The methods return a tuple new_basis, data
where new_basis holds the
extended basis and data is a dict containing additional information about the extension
process. The data
dict at least has the key hierarchic
whose value signifies
if the new basis contains the old basis as its first vectors.
If the basis extension fails, e.g. because the new vector is not linearly
independent from the basis, an ExtensionError
exception is raised.

pymor.algorithms.basisextension.
gram_schmidt_basis_extension
(basis, U, product=None, copy_basis=True, copy_U=True)[source]¶ Extend basis using GramSchmidt orthonormalization.
Parameters
 basis
VectorArray
containing the basis to extend. U
VectorArray
containing the new basis vectors. product
 The inner product w.r.t. which to orthonormalize; if
None
, the Euclidean product is used.  copy_basis
 If
copy_basis
isFalse
, the old basis is extended inplace.  copy_U
 If
copy_U
isFalse
, the new basis vectors are removed fromU
.
Returns
 new_basis
 The extended basis.
 extension_data
Dict containing the following fields:
hierarchic: True
ifnew_basis
containsbasis
as its first vectors.
Raises
 ExtensionError
 GramSchmidt orthonormalization has failed. This is the case when no
vector in
U
is linearly independent of the basis.

pymor.algorithms.basisextension.
pod_basis_extension
(basis, U, count=1, copy_basis=True, product=None, orthonormalize=True)[source]¶ Extend basis with the first
count
POD modes of the defect of the projection ofU
onto the current basis.Warning
The provided basis is assumed to be orthonormal w.r.t. the given inner product!
Parameters
 basis
VectorArray
containing the basis to extend. The basis is expected to be orthonormal w.r.t.product
. U
VectorArray
containing the vectors to which the POD is applied. count
 Number of POD modes that shall be appended to the basis.
 product
 The inner product w.r.t. which to orthonormalize; if
None
, the Euclidean product is used.  copy_basis
 If
copy_basis
isFalse
, the old basis is extended inplace.  orthonormalize
 If
True
, reorthonormalize the new basis vectors obtained by the POD in order to improve numerical accuracy.
Returns
 new_basis
 The extended basis.
 extension_data
Dict containing the following fields:
hierarchic: True
ifnew_basis
containsbasis
as its first vectors.
Raises
 ExtensionError
 POD has produced no new vectors. This is the case when no vector in
U
is linearly independent of the basis.

pymor.algorithms.basisextension.
trivial_basis_extension
(basis, U, copy_basis=True, copy_U=True)[source]¶ Extend basis by simply appending the new vectors.
We check if the new vectors are already contained in the basis, but we do not check for linear independence.
Parameters
 basis
VectorArray
containing the basis to extend. U
VectorArray
containing the new basis vectors. copy_basis
 If
copy_basis
isFalse
, the old basis is extended inplace.  copy_U
 If
copy_U
isFalse
, the new basis vectors are removed fromU
.
Returns
 new_basis
 The extended basis.
 extension_data
Dict containing the following fields:
hierarchic: True
ifnew_basis
containsbasis
as its first vectors.
Raises
 ExtensionError
 Raised when all vectors in
U
are already contained in the basis.
ei module¶
This module contains algorithms for the empirical interpolation of Operators
.
The main work for generating the necessary interpolation data is handled by
the ei_greedy
method. The objects returned by this method can be used
to instantiate an EmpiricalInterpolatedOperator
.
As a convenience, the interpolate_operators
method allows to perform
the empirical interpolation of the Operators
of a given discretization with
a single function call.

pymor.algorithms.ei.
deim
(U, modes=None, error_norm=None, product=None)[source]¶ Generate data for empirical interpolation using DEIM algorithm.
Given a
VectorArray
U
, this method generates a collateral basis and interpolation DOFs for empirical interpolation of the vectors contained inU
. The returned objects can be used to instantiate anEmpiricalInterpolatedOperator
(withtriangular=False
).The collateral basis is determined by the first
pod
modes ofU
.Parameters
 U
 A
VectorArray
of vectors to interpolate.  modes
 Dimension of the collateral basis i.e. number of POD modes of the vectors in
U
.  error_norm
 Norm w.r.t. which to calculate the interpolation error. If
None
, the Euclidean norm is used.  product
 Inner product
Operator
used for the POD.
Returns
 interpolation_dofs
NumPy array
of the DOFs at which the vectors are interpolated. collateral_basis
VectorArray
containing the generated collateral basis. data
Dict containing the following fields:
errors: Sequence of maximum approximation errors during greedy search.

pymor.algorithms.ei.
ei_greedy
(U, error_norm=None, atol=None, rtol=None, max_interpolation_dofs=None, projection='ei', product=None, copy=True, pool=<pymor.parallel.dummy.DummyPool object>)[source]¶ Generate data for empirical interpolation using EIGreedy algorithm.
Given a
VectorArray
U
, this method generates a collateral basis and interpolation DOFs for empirical interpolation of the vectors contained inU
. The returned objects can be used to instantiate anEmpiricalInterpolatedOperator
(withtriangular=True
).The interpolation data is generated by a greedy search algorithm, where in each loop iteration the worst approximated vector in
U
is added to the collateral basis.Parameters
 U
 A
VectorArray
of vectors to interpolate.  error_norm
 Norm w.r.t. which to calculate the interpolation error. If
None
, the Euclidean norm is used.  atol
 Stop the greedy search if the largest approximation error is below this threshold.
 rtol
 Stop the greedy search if the largest relative approximation error is below this threshold.
 max_interpolation_dofs
 Stop the greedy search if the number of interpolation DOF (= dimension of the collateral basis) reaches this value.
 projection
 If
'ei'
, compute the approximation error by comparing the given vectors by their interpolants. If'orthogonal'
, compute the error by comparing with the orthogonal projection onto the span of the collateral basis.  product
 If
projection == 'orthogonal'
, the inner product which is used to perform the projection. IfNone
, the Euclidean product is used.  copy
 If
False
,U
will be modified during executing of the algorithm.  pool
 If not
None
, theWorkerPool
to use for parallelization.
Returns
 interpolation_dofs
NumPy array
of the DOFs at which the vectors are evaluated. collateral_basis
VectorArray
containing the generated collateral basis. data
Dict containing the following fields:
errors: Sequence of maximum approximation errors during greedy search. triangularity_errors: Sequence of maximum absolute values of interoplation matrix coefficients in the upper triangle (should be near zero).

pymor.algorithms.ei.
interpolate_operators
(discretization, operator_names, parameter_sample, error_norm=None, atol=None, rtol=None, max_interpolation_dofs=None, projection='ei', product=None, pool=<pymor.parallel.dummy.DummyPool object>)[source]¶ Empirical operator interpolation using the EIGreedy algorithm.
This is a convenience method to facilitate the use of
ei_greedy
. Given aDiscretization
, names ofOperators
, and a sample ofParameters
, first the operators are evaluated on the solution snapshots of the discretization for the provided parameters. These evaluations are then used as input forei_greedy
. Finally the resulting interpolation data is used to createEmpiricalInterpolatedOperators
and a new discretization with the interpolated operators is returned.Note that this implementation creates one common collateral basis for all specified operators, which might not be what you want.
Parameters
 discretization
 The
Discretization
whoseOperators
will be interpolated.  operator_names
 List of keys in the
operators
dict of the discretization. The correspondingOperators
will be interpolated.  parameter_sample
 A list of
Parameters
for which solution snapshots are calculated.  error_norm
 See
ei_greedy
.  atol
 See
ei_greedy
.  rtol
 See
ei_greedy
.  max_interpolation_dofs
 See
ei_greedy
.  projection
 See
ei_greedy
.  product
 See
ei_greedy
.  pool
 If not
None
, theWorkerPool
to use for parallelization.
Returns
 ei_discretization
Discretization
withOperators
given byoperator_names
replaced byEmpiricalInterpolatedOperators
. data
Dict containing the following fields:
dofs: NumPy array
of the DOFs at which theOperators
have to be evaluated.basis: VectorArray
containing the generated collateral basis.errors: Sequence of maximum approximation errors during greedy search. triangularity_errors: Sequence of maximum absolute values of interoplation matrix coefficients in the upper triangle (should be near zero).
error module¶

pymor.algorithms.error.
reduction_error_analysis
(reduced_discretization, discretization=None, reconstructor=None, test_mus=10, basis_sizes=0, random_seed=None, estimator=True, condition=False, error_norms=(), error_norm_names=None, estimator_norm_index=0, custom=(), plot=False, plot_custom_logarithmic=True, pool=<pymor.parallel.dummy.DummyPool object>)[source]¶ Analyze the model reduction error.
The maximum model reduction error is estimated by solving the reduced
Discretization
for given randomParameters
.Parameters
 reduced_discretization
 The reduced
Discretization
.  discretization
 The highdimensional
Discretization
. Must be specified iferror_norms
are given.  reconstructor
 The reconstructor for
reduced_discretization
. Must be specified iferror_norms
are given.  test_mus
 Either a list of
Parameters
to compute the errors for, or the number of parameters which are sampled randomly fromparameter_space
(if given) orreduced_discretization.parameter_space
.  basis_sizes
 Either a list of reduced basis dimensions to consider, or
the number of dimensions (which are then selected equidistantly,
always including the maximum reduced space dimension).
The dimensions are input for
~pymor.reductors.basic.reduce_to_subbasis
to quickly obtain smaller reducedDiscretizations
fromrb_discretization
.  random_seed
 If
test_mus
is a number, use this value as random seed for drawing theParameters
.  estimator
 If
True
evaluate the error estimator ofreduced_discretization
on the testParameters
.  condition
 If
True
, compute the condition of the reduced system matrix for the given testParameters
(can only be specified ifrb_discretization
is an instance ofStationaryDiscretization
andrb_discretization.operator
is linear).  error_norms
 List of norms in which to compute the model reduction error.
 error_norm_names
 Names of the norms given by
error_norms
. IfNone
, thename
attributes of the given norms are used.  estimator_norm_index
 When
estimator
isTrue
anderror_norms
are specified, this is the index of the norm inerror_norms
w.r.t. which to compute the effectivity of the estimator.  custom
List of custom functions which are evaluated for each test
Parameter
and basis size. The functions must have the signaturedef custom_value(reduced_discretization, discretization=d, reconstructor, mu, dim): pass
 plot
 If
True
, generate a plot of the computed quantities w.r.t. the basis size.  plot_custom_logarithmic
 If
True
, use a logarithmic yaxis to plot the computed custom values.  pool
 If not
None
, theWorkerPool
to use for parallelization.
Returns
Dict with the following fields
mus: The test Parameters
which have been considered.basis_sizes: The reduced basis dimensions which have been considered. norms: NumPy array
of the norms of the highdimensional solutions w.r.t. all given testParameters
, reduced basis dimensions and norms inerror_norms
. (Only present whenerror_norms
has been specified.)max_norms: Maxima of norms
over the given testParameters
.max_norm_mus: Parameters
corresponding tomax_norms
.errors: NumPy array
of the norms of the model reduction errors w.r.t. all given testParameters
, reduced basis dimensions and norms inerror_norms
. (Only present whenerror_norms
has been specified.)max_errors: Maxima of errors
over the given testParameters
.max_error_mus: Parameters
corresponding tomax_errors
.rel_errors: errors
divided bynorms
. (Only present whenerror_norms
has been specified.)max_rel_errors: Maxima of rel_errors
over the given testParameters
.max_rel_error_mus: Parameters
corresponding tomax_rel_errors
.error_norm_names: Names of the given error_norms
. (Only present whenerror_norms
has been specified.)estimates: NumPy array
of the model reduction error estimates w.r.t. all given testParameters
and reduced basis dimensions. (Only present whenestimator
isTrue
.)max_estimate: Maxima of estimates
over the given testParameters
.max_estimate_mus: Parameters
corresponding tomax_estimates
.effectivities: errors
divided byestimates
. (Only present whenestimator
isTrue
anderror_norms
has been specified.)min_effectivities: Minima of effectivities
over the given testParameters
.min_effectivity_mus: Parameters
corresponding tomin_effectivities
.max_effectivities: Maxima of effectivities
over the given testParameters
.max_effectivity_mus: Parameters
corresponding tomax_effectivities
.errors: NumPy array
of the reduced system matrix conditions w.r.t. all given testParameters
and reduced basis dimensions. (Only present whenconditions
isTrue
.)max_conditions: Maxima of conditions
over the given testParameters
.max_condition_mus: Parameters
corresponding tomax_conditions
.custom_values: NumPy array
of custom function evaluations w.r.t. all given testParameters
, reduced basis dimensions and functions incustom
. (Only present whencustom
has been specified.)max_custom_values: Maxima of custom_values
over the given testParameters
.max_custom_values_mus: Parameters
corresponding tomax_custom_values
.time: Time (in seconds) needed for the error analysis. summary: String containing a summary of all computed quantities for the largest (last) considered basis size. figure: The figure containing the generated plots. (Only present when plot
isTrue
.)
genericsolvers module¶
This module contains some iterative linear solvers which only use the Operator
interface

pymor.algorithms.genericsolvers.
apply_inverse
(op, rhs, options=None)[source]¶ Solve linear equation system.
Applies the inverse of
op
to the vectors inrhs
.Parameters
 op
 The linear, nonparametric
Operator
to invert.  rhs
VectorArray
of righthand sides for the equation system. options
 The solver options to use. (See
options
.)
Returns
VectorArray
of the solution vectors.

pymor.algorithms.genericsolvers.
lgmres
(A, b, x0=None, tol=1e05, maxiter=1000, M=None, callback=None, inner_m=30, outer_k=3, outer_v=None, store_outer_Av=True)[source]¶

pymor.algorithms.genericsolvers.
lsmr
(A, b, damp=0.0, atol=1e06, btol=1e06, conlim=100000000.0, maxiter=None, show=False)[source]¶

pymor.algorithms.genericsolvers.
lsqr
(A, b, damp=0.0, atol=1e08, btol=1e08, conlim=100000000.0, iter_lim=None, show=False)[source]¶

pymor.algorithms.genericsolvers.
options
(default_solver='generic_lgmres', default_least_squares_solver='least_squares_generic_lsmr', generic_lgmres_tol=1e05, generic_lgmres_maxiter=1000, generic_lgmres_inner_m=39, generic_lgmres_outer_k=3, least_squares_generic_lsmr_damp=0.0, least_squares_generic_lsmr_atol=1e06, least_squares_generic_lsmr_btol=1e06, least_squares_generic_lsmr_conlim=100000000.0, least_squares_generic_lsmr_maxiter=None, least_squares_generic_lsmr_show=False, least_squares_generic_lsqr_damp=0.0, least_squares_generic_lsqr_atol=1e06, least_squares_generic_lsqr_btol=1e06, least_squares_generic_lsqr_conlim=100000000.0, least_squares_generic_lsqr_iter_lim=None, least_squares_generic_lsqr_show=False)[source]¶ Returns
solver_options
(with default values) for arbitrary linearOperators
.Parameters
 default_solver
 Default solver to use (generic_lgmres, least_squares_generic_lsmr, least_squares_generic_lsqr).
 default_least_squares_solver
 Default solver to use for least squares problems (least_squares_generic_lsmr, least_squares_generic_lsqr).
 generic_lgmres_tol
 See
scipy.sparse.linalg.lgmres
.  generic_lgmres_maxiter
 See
scipy.sparse.linalg.lgmres
.  generic_lgmres_inner_m
 See
scipy.sparse.linalg.lgmres
.  generic_lgmres_outer_k
 See
scipy.sparse.linalg.lgmres
.  least_squares_generic_lsmr_damp
 See
scipy.sparse.linalg.lsmr
.  least_squares_generic_lsmr_atol
 See
scipy.sparse.linalg.lsmr
.  least_squares_generic_lsmr_btol
 See
scipy.sparse.linalg.lsmr
.  least_squares_generic_lsmr_conlim
 See
scipy.sparse.linalg.lsmr
.  least_squares_generic_lsmr_maxiter
 See
scipy.sparse.linalg.lsmr
.  least_squares_generic_lsmr_show
 See
scipy.sparse.linalg.lsmr
.  least_squares_generic_lsqr_damp
 See
scipy.sparse.linalg.lsqr
.  least_squares_generic_lsqr_atol
 See
scipy.sparse.linalg.lsqr
.  least_squares_generic_lsqr_btol
 See
scipy.sparse.linalg.lsqr
.  least_squares_generic_lsqr_conlim
 See
scipy.sparse.linalg.lsqr
.  least_squares_generic_lsqr_iter_lim
 See
scipy.sparse.linalg.lsqr
.  least_squares_generic_lsqr_show
 See
scipy.sparse.linalg.lsqr
.
Returns
A tuple of possible values for
solver_options
.Defaults
default_solver, default_least_squares_solver, generic_lgmres_tol, generic_lgmres_maxiter, generic_lgmres_inner_m, generic_lgmres_outer_k, least_squares_generic_lsmr_damp, least_squares_generic_lsmr_atol, least_squares_generic_lsmr_btol, least_squares_generic_lsmr_conlim, least_squares_generic_lsmr_maxiter, least_squares_generic_lsmr_show, least_squares_generic_lsqr_atol, least_squares_generic_lsqr_btol, least_squares_generic_lsqr_conlim, least_squares_generic_lsqr_iter_lim, least_squares_generic_lsqr_show (see
pymor.core.defaults
)
gram_schmidt module¶

pymor.algorithms.gram_schmidt.
gram_schmidt
(A, product=None, atol=1e13, rtol=1e13, offset=0, find_duplicates=True, reiterate=True, reiteration_threshold=0.1, check=True, check_tol=0.001, copy=True)[source]¶ Orthonormalize a
VectorArray
using the stabilized GramSchmidt algorithm.Parameters
 A
 The
VectorArray
which is to be orthonormalized.  product
 The inner product
Operator
w.r.t. which to orthonormalize. IfNone
, the Euclidean product is used.  atol
 Vectors of norm smaller than
atol
are removed from the array.  rtol
 Relative tolerance used to detect linear dependent vectors (which are then removed from the array).
 offset
 Assume that the first
offset
vectors are already orthonormal and start the algorithm at theoffset + 1
th vector.  reiterate
 If
True
, orthonormalize again if the norm of the orthogonalized vector is much smaller than the norm of the original vector.  reiteration_threshold
 If
reiterate
isTrue
, reorthonormalize if the ratio between the norms of the orthogonalized vector and the original vector is smaller than this value.  check
 If
True
, check if the resultingVectorArray
is really orthonormal.  check_tol
 Tolerance for the check.
 copy
 If
True
, create a copy ofA
instead of modifyingA
inplace.
Returns
The orthonormalized
VectorArray
.Defaults
atol, rtol, reiterate, reiteration_threshold, check, check_tol (see
pymor.core.defaults
)
greedy module¶

pymor.algorithms.greedy.
greedy
(discretization, reductor, samples, initial_basis=None, use_estimator=True, error_norm=None, extension_algorithm=<function gram_schmidt_basis_extension>, atol=None, rtol=None, max_extensions=None, pool=None)[source]¶ Greedy basis generation algorithm.
This algorithm generates a reduced basis by iteratively adding the worst approximated solution snapshot for a given training set to the reduced basis. The approximation error is computed either by directly comparing the reduced solution to the detailed solution or by using an error estimator (
use_estimator == True
). The reduction and basis extension steps are performed by calling the methods provided by thereductor
andextension_algorithm
arguments.Parameters
 discretization
 The
Discretization
to reduce.  reductor
 Reductor for reducing the given
Discretization
. This has to be a function of the formreductor(discretization, basis, extends=None)
. The method has to return a tuple(reduced_discretization, reconstructor, reduction_data)
. In case the last basis extension washierarchic
(seeextension_algorithm
), the extends argument is set to(last_reduced_discretization, last_reconstructor, last_reduction_data)
which can be used by the reductor to speed up the reduction process. For an example seereduce_coercive
.  samples
 The set of
Parameter
samples on which to perform the greedy search.  initial_basis
 The initial reduced basis at the start of the algorithm. If
None
, an empty basis is used as initial basis.  use_estimator
 If
True
, usereduced_discretization.estimate()
to estimate the errors on the sample set. Otherwisediscretization.solve()
is called to compute the exact model reduction error.  error_norm
 If
use_estimator == False
, use this function to calculate the norm of the error. IfNone
, the Euclidean norm is used.  extension_algorithm
 The extension algorithm to be used to extend the current reduced
basis with the maximum error snapshot. This has to be a function
of the form
extension_algorithm(old_basis, new_vector)
, which returns a tuple(new_basis, extension_data)
, whereextension_data
is a dict at least containing the keyhierarchic
.hierarchic
should be set toTrue
ifnew_basis
containsold_basis
as its first vectors.  atol
 If not
None
, stop the algorithm if the maximum (estimated) error on the sample set drops below this value.  rtol
 If not
None
, stop the algorithm if the maximum (estimated) relative error on the sample set drops below this value.  max_extensions
 If not
None
, stop the algorithm aftermax_extensions
extension steps.  pool
 If not
None
, theWorkerPool
to use for parallelization.
Returns
Dict with the following fields
basis: The reduced basis. reduced_discretization: The reduced Discretization
obtained for the computed basis.reconstructor: Reconstructor for reduced_discretization
.max_errs: Sequence of maximum errors during the greedy run. max_err_mus: The parameters corresponding to max_errs
.extensions: Number of performed basis extensions. time: Total runtime of the algorithm. reduction_data: The reduction_data
returned by the lastreductor
call.
image module¶

pymor.algorithms.image.
estimate_image
(operators=(), vectors=(), domain=None, extends=False, orthonormalize=True, product=None, riesz_representatives=False)[source]¶ Estimate the image of given
Operators
for all mu.Let
operators
be a list ofOperators
with common source and range, and letvectors
be a list ofVectorArrays
or vectorlikeOperators
in the range of these operators. Given aVectorArray
domain
of vectors in the source of the operators, this algorithms determines aVectorArray
image
of range vectors such that the linear span ofimage
contains:op.apply(U, mu=mu)
for all operatorsop
inoperators
, for all possibleParameters
mu
and for allVectorArrays
U
contained in the linear span ofdomain
,U
for allVectorArrays
invectors
,v.as_vector(mu)
for allOperators
invectors
and all possibleParameters
mu
.
The algorithm will try to choose
image
as small as possible. However, no optimality is guaranteed.Parameters
 operators
 See above.
 vectors
 See above.
 domain
 See above. If
None
, an emptydomain
VectorArray
is assumed.  extends
 For some operators, e.g.
EmpiricalInterpolatedOperator
, as well as for all elements ofvectors
,image
is estimated independently from the choice ofdomain
. Ifextends
isTrue
, such operators are ignored. (This is useful in case these vectors have already been obtained by earlier calls to this function.)  orthonormalize
 Compute an orthonormal basis for the linear span of
image
using thegram_schmidt
algorithm.  product
 Inner product
Operator
w.r.t. which to orthonormalize.  riesz_representatives
 If
True
, compute Riesz representatives of the vectors inimage
before orthonormalizing (useful for dual norm computation when the range of theoperators
is a dual space).
Returns
The
VectorArray
image
.Raises
 ImageCollectionError
 Is raised when for a given
Operator
no image estimate is possible.

pymor.algorithms.image.
estimate_image_hierarchical
(operators=(), vectors=(), domain=None, extends=None, orthonormalize=True, product=None, riesz_representatives=False)[source]¶ Estimate the image of given
Operators
for all mu.This is an extended version of
estimate_image
, which callsestimate_image
individually for each vector ofdomain
.As a result, the vectors in the returned
image
VectorArray
will be ordered by thedomain
vector they correspond to (starting with vectors which correspond to thefunctionals
and toOperators
for which the image is estimated independently fromdomain
).This function also returns an
image_dims
list, such that the firstimage_dims[i+1]
vectors ofimage
correspond to the firsti
vectors ofdomain
(the firstimage_dims[0]
vectors correspond tovectors
and toOperators
with fixed image estimate).Parameters
 operators
 See
estimate_image
.  vectors
 See
estimate_image
.  domain
 See
estimate_image
.  extends
 When additional vectors have been appended to the
domain
VectorArray
afterestimate_image_hierarchical
has been called, andestimate_image_hierarchical
shall be called again for the extendeddomain
array,extends
can be set to(image, image_dims)
, whereimage
,image_dims
are the return values of the lastestimate_image_hierarchical
call. The olddomain
vectors will then be skipped during computation andimage
,image_dims
will be modified inplace.  orthonormalize
 See
estimate_image
.  product
 See
estimate_image
.  riesz_representatives
 See
estimate_image
.
Returns
 image
 See above.
 image_dims
 See above.
Raises
 ImageCollectionError
 Is raised when for a given
Operator
no image estimate is possible.
newton module¶

pymor.algorithms.newton.
newton
(operator, rhs, initial_guess=None, mu=None, error_norm=None, least_squares=False, miniter=0, maxiter=100, rtol=1.0, atol=1.0, stagnation_window=3, stagnation_threshold=0.9, return_stages=False, return_residuals=False)[source]¶ Basic Newton algorithm.
This method solves the nonlinear equation
A(U, mu) = V
for
U
using the Newton method.Parameters
 operator
 The
Operator
A
.A
must implement thejacobian
interface method.  rhs
VectorArray
of length 1 containing the vectorV
. initial_guess
 If
None
, aVectorArray
of length 1 containing an initial guess for the solutionU
.  mu
 The
Parameter
for which to solve the equation.  error_norm
 The norm with which the norm of the residual is computed. If
None
, the Euclidean norm is used.  least_squares
 If
True
, use a least squares linear solver (e.g. for residual minimization).  miniter
 Minimum amount of iterations to perform.
 maxiter
 Fail if the iteration count reaches this value without converging.
 rtol
 Finish when the residual norm has been reduced by this factor relative to the norm of the initial residual.
 atol
 Finish when the residual norm is below this threshold.
 stagnation_window
 Finish when the residual norm has not been reduced by a factor of
stagnation_threshold
during the laststagnation_window
iterations.  stagnation_threshold
 See
stagnation_window
.  return_stages
 If
True
, return aVectorArray
of the intermediate approximations ofU
after each iteration.  return_residuals
 If
True
, return aVectorArray
of all residual vectors which have been computed during the Newton iterations.
Returns
 U
VectorArray
of length 1 containing the computed solution data
Dict containing the following fields:
error_sequence: NumPy array
containing the residual norms after each iteration.stages: See return_stages
.residuals: See return_residuals
.
Raises
 NewtonError
 Raised if the Netwon algorithm failed to converge.
Defaults
miniter, maxiter, rtol, atol, stagnation_window, stagnation_threshold (see
pymor.core.defaults
)
pod module¶

pymor.algorithms.pod.
pod
(A, modes=None, product=None, rtol=4e08, atol=0.0, l2_mean_err=0.0, symmetrize=False, orthonormalize=True, check=True, check_tol=1e10)[source]¶ Proper orthogonal decomposition of
A
.Viewing the
VectorArray
A
as aA.dim
xlen(A)
matrix, the return value of this method is theVectorArray
of leftsingular vectors of the singular value decomposition ofA
, where the inner product on R^(dim(A)
) is given byproduct
and the inner product on R^(len(A)
) is the Euclidean inner product.Parameters
 A
 The
VectorArray
for which the POD is to be computed.  modes
 If not
None
, only the firstmodes
POD modes (singular vectors) are returned.  product
 Inner product
Operator
w.r.t. which the POD is computed.  rtol
 Singular values smaller than this value multiplied by the largest singular value are ignored.
 atol
 Singular values smaller than this value are ignored.
 l2_mean_err
Do not return more modes than needed to bound the mean l2approximation error by this value. I.e. the number of returned modes is at most
argmin_N { 1 / len(A) * sum_{n=N+1}^{infty} s_n^2 <= l2_mean_err^2 }
where
s_n
denotes the nth singular value. symmetrize
 If
True
, symmetrize the Gramian again before proceeding.  orthonormalize
 If
True
, orthonormalize the computed POD modes again using thegram_schmidt
algorithm.  check
 If
True
, check the computed POD modes for orthonormality.  check_tol
 Tolerance for the orthonormality check.
Returns
 POD
VectorArray
of POD modes. SVALS
 Sequence of singular values.
Defaults
rtol, atol, l2_mean_err, symmetrize, orthonormalize, check, check_tol (see
pymor.core.defaults
)
timestepping module¶
This module provides generic timestepping algorithms for the solution of instationary problems.
The algorithms are generic in the sense that each algorithms operates exclusively
on Operators
and VectorArrays
. In particular, the algorithms
can also be used to turn an arbitrary stationary Discretization
provided
by an external library into an instationary Discretization
.
Currently, implementations of explicit_euler
and implicit_euler
timestepping are provided. The TimeStepperInterface
defines a
common interface that has to be fulfilled by the timesteppers used
by InstationaryDiscretization
. The classes ExplicitEulerTimeStepper
and ImplicitEulerTimeStepper
encapsulate explicit_euler
and
implicit_euler
to provide this interface.

class
pymor.algorithms.timestepping.
ExplicitEulerTimeStepper
(nt)[source]¶ Bases:
pymor.algorithms.timestepping.TimeStepperInterface
Explicit Euler timestepper.
Solves equations of the form
M * d_t u + A(u, mu, t) = F(mu, t).
Parameters
 nt
 The number of timesteps the timestepper will perform.
Methods
ExplicitEulerTimeStepper
solve
ImmutableInterface
generate_sid
,unlock
,with_
BasicInterface
disable_logging
,enable_logging
,has_interface_name
,implementor_names
,implementors
,lock
,__setattr__
Attributes
ImmutableInterface
add_with_arguments
,sid
,sid_ignore
,with_arguments
BasicInterface
locked
,logger
,logging_disabled
,name
,uid

solve
(initial_time, end_time, initial_data, operator, rhs=None, mass=None, mu=None, num_values=None)[source]¶ Apply timestepper to the equation
M * d_t u + A(u, mu, t) = F(mu, t).
Parameters
 initial_time
 The time at which to begin timestepping.
 end_time
 The time until which to perform timestepping.
 initial_data
 The solution vector at
initial_time
.  operator
 The
Operator
A.  rhs
 The righthand side F (either
VectorArray
of length 1 orOperator
withrange.dim == 1
). IfNone
, zero righthand side is assumed.  mass
 The
Operator
M. IfNone
, the identity operator is assumed.  mu
Parameter
for whichoperator
andrhs
are evaluated. The current time is added tomu
with key_t
. num_values
 The number of returned vectors of the solution trajectory. If
None
, each intermediate vector that is calculated is returned.
Returns
VectorArray
containing the solution trajectory.

class
pymor.algorithms.timestepping.
ImplicitEulerTimeStepper
(nt, solver_options='operator')[source]¶ Bases:
pymor.algorithms.timestepping.TimeStepperInterface
Implict Euler timestepper.
Solves equations of the form
M * d_t u + A(u, mu, t) = F(mu, t).
Parameters
 nt
 The number of timesteps the timestepper will perform.
 solver_options
 The
solver_options
used to invertM + dt*A
. The special values'mass'
and'operator'
are recognized, in which case the solver_options of M (resp. A) are used.
Methods
ImplicitEulerTimeStepper
solve
ImmutableInterface
generate_sid
,unlock
,with_
BasicInterface
disable_logging
,enable_logging
,has_interface_name
,implementor_names
,implementors
,lock
,__setattr__
Attributes
ImmutableInterface
add_with_arguments
,sid
,sid_ignore
,with_arguments
BasicInterface
locked
,logger
,logging_disabled
,name
,uid

solve
(initial_time, end_time, initial_data, operator, rhs=None, mass=None, mu=None, num_values=None)[source]¶ Apply timestepper to the equation
M * d_t u + A(u, mu, t) = F(mu, t).
Parameters
 initial_time
 The time at which to begin timestepping.
 end_time
 The time until which to perform timestepping.
 initial_data
 The solution vector at
initial_time
.  operator
 The
Operator
A.  rhs
 The righthand side F (either
VectorArray
of length 1 orOperator
withrange.dim == 1
). IfNone
, zero righthand side is assumed.  mass
 The
Operator
M. IfNone
, the identity operator is assumed.  mu
Parameter
for whichoperator
andrhs
are evaluated. The current time is added tomu
with key_t
. num_values
 The number of returned vectors of the solution trajectory. If
None
, each intermediate vector that is calculated is returned.
Returns
VectorArray
containing the solution trajectory.

class
pymor.algorithms.timestepping.
TimeStepperInterface
[source]¶ Bases:
pymor.core.interfaces.ImmutableInterface
Interface for timestepping algorithms.
Algorithms implementing this interface solve timedependent problems of the form
M * d_t u + A(u, mu, t) = F(mu, t).
Timesteppers used by
InstationaryDiscretization
have to fulfill this interface.Methods
TimeStepperInterface
solve
ImmutableInterface
generate_sid
,unlock
,with_
BasicInterface
disable_logging
,enable_logging
,has_interface_name
,implementor_names
,implementors
,lock
,__setattr__
Attributes
ImmutableInterface
add_with_arguments
,sid
,sid_ignore
,with_arguments
BasicInterface
locked
,logger
,logging_disabled
,name
,uid

solve
(initial_time, end_time, initial_data, operator, rhs=None, mass=None, mu=None, num_values=None)[source]¶ Apply timestepper to the equation
M * d_t u + A(u, mu, t) = F(mu, t).
Parameters
 initial_time
 The time at which to begin timestepping.
 end_time
 The time until which to perform timestepping.
 initial_data
 The solution vector at
initial_time
.  operator
 The
Operator
A.  rhs
 The righthand side F (either
VectorArray
of length 1 orOperator
withrange.dim == 1
). IfNone
, zero righthand side is assumed.  mass
 The
Operator
M. IfNone
, the identity operator is assumed.  mu
Parameter
for whichoperator
andrhs
are evaluated. The current time is added tomu
with key_t
. num_values
 The number of returned vectors of the solution trajectory. If
None
, each intermediate vector that is calculated is returned.
Returns
VectorArray
containing the solution trajectory.


pymor.algorithms.timestepping.
explicit_euler
(A, F, U0, t0, t1, nt, mu=None, num_values=None)[source]¶