# Release Notes¶

## pyMOR 0.4 (September 28, 2016)¶

With the pyMOR 0.4 release we have changed the copyright of pyMOR to

Copyright 2013-2016 pyMOR developers and contributors. All rights reserved.

Moreover, we have added a Contribution guideline to help new users with starting to contribute to pyMOR. Over 800 single commits have entered this release. For a full list of changes see here. pyMOR 0.4 contains contributions by Andreas Buhr, Michael Laier, Falk Meyer, Petar Mlinarić and Michael Schaefer. See here for more details.

### Release highlights¶

#### FEniCS and deal.II support¶

pyMOR now includes wrapper classes for integrating PDE solvers
written with the `dolfin`

library of the FEniCS
project. For a usage example, see `pymordemos.thermalblock_simple.discretize_fenics`

.
Experimental support for deal.II can be
found in the pymor-deal.II
repository of the pyMOR GitHub organization.

#### Parallelization of pyMOR’s reduction algorithms¶

We have added a parallelization framework to pyMOR which allows
parallel execution of reduction algorithms based on a simple
`WorkerPool`

interface [#14].
The `greedy`

[#155]
and `ei_greedy`

algorithms [#162]
have been refactored to utilize this interface.
Two `WorkerPool`

implementations are shipped with pyMOR:
`IPythonPool`

utilizes the parallel
computing features of IPython, allowing
parallel algorithm execution in large heterogeneous clusters of
computing nodes. `MPIPool`

can be used
to benefit from existing MPI-based parallel HPC computing architectures
[#161].

#### Support classes for MPI distributed external PDE solvers¶

While pyMOR’s `VectorArray`

, `Operator`

and `Discretization`

interfaces are agnostic to the concrete (parallel) implementation
of the corresponding objects in the PDE solver, external solvers
are often integrated by creating wrapper classes directly corresponding
to the solvers data structures. However, when the solver is executed
in an MPI distributed context, these wrapper classes will then only
correspond to the rank-local data of a distributed `VectorArray`

or
`Operator`

.

To facilitate the integration of MPI parallel solvers, we have added
MPI helper classes [#163]
in `pymor.vectorarrays.mpi`

, `pymor.operators.mpi`

and `pymor.discretizations.mpi`

that allow an automatic
wrapping of existing sequential bindings for MPI distributed use.
These wrapper classes are based on a simple event loop provided
by `pymor.tools.mpi`

, which is used in the interface methods of
the wrapper classes to dispatch into MPI distributed execution
of the corresponding methods on the underlying MPI distributed
objects.

The resulting objects can be used on MPI rank 0 (including interactive
Python sessions) without any further changes to pyMOR or the user code.
For an example, see `pymordemos.thermalblock_simple.discretize_fenics`

.

#### New reduction algorithms¶

`adaptive_greedy`

uses adaptive parameter training set refinement according to [HDO11] to prevent overfitting of the reduced model to the training set [#213].`reduce_parabolic`

reduces linear parabolic problems using`reduce_generic_rb`

and assembles an error estimator similar to [GP05], [HO08]. The`parabolic_mor`

demo contains a simple sample application using this reductor [#190].- The
`estimate_image`

and`estimate_image_hierarchical`

algorithms can be used to find an as small as possible space in which the images of a given list of operators for a given source space are contained for all possible parameters`mu`

. For possible applications, see`reduce_residual`

which now uses`estimate_image_hierarchical`

for Petrov-Galerkin projection of the residual operator [#223].

#### Copy-on-write semantics for `VectorArrays`

¶

The `copy`

method
of the `VectorArray`

interface is now assumed to have copy-on-write
semantics. I.e., the returned `VectorArray`

will contain a reference to the same
data as the original array, and the actual data will only be copied when one of
the arrays is changed. Both `NumpyVectorArray`

and `ListVectorArray`

have been
updated accordingly [#55].
As a main benefit of this approach, `immutable`

objects having a `VectorArray`

as
an attribute now can safely create copies of the passed `VectorArrays`

(to ensure
the immutability of their state) without having to worry about unnecessarily
increased memory consumption.

#### Improvements to pyMOR’s discretizaion tookit¶

- An unstructured triangular
`Grid`

is now provided by`UnstructuredTriangleGrid`

. Such a`Grid`

can be obtained using the`discretize_gmsh`

method, which can parse Gmsh output files. Moreover, this method can generate`Gmsh`

input files to create unstructured meshes for an arbitrary`PolygonalDomain`

[#9]. - Basic support for parabolic problems has been added.
The
`discretize_parabolic_cg`

and`discretize_parabolic_fv`

methods can be used to build continuous finite element or finite volume`Discretizations`

from a given`pymor.analyticalproblems.parabolic.ParabolicProblem`

. The`parabolic`

demo demonstrates the use of these methods [#189]. - The
`pymor.discretizers.disk`

module contains methods to create stationary and instationary affinely decomposed`Discretizations`

from matrix data files and an`.ini`

file defining the given problem. `EllipticProblems`

can now also contain advection and reaction terms in addition to the diffusion part.`discretize_elliptic_cg`

has been extended accordingly [#211].- The
`continuous Galerkin`

module has been extended to support Robin boundary conditions [#110]. `BitmapFunction`

allows to use grayscale image data as data`Functions`

[#194].- For the visualization of time-dependent data, the colorbars can now be rescaled with each new frame [#91].

#### Caching improvements¶

- state id generation is now based on deterministic pickling.
In previous version of pyMOR, the state id of
`immutable`

objects was computed from the state ids of the parameters passed to the object’s`__init__`

method. This approach was complicated and error-prone. Instead, we now compute the state id as a hash of a deterministic serialization of the object’s state. While this approach is more robust, it is also slightly more expensive. However, due to the object’s immutability, the state id only has to be computed once, and state ids are now only required for storing results in persistent cache regions (see below). Computing such results will usually be much more expensive than the state id calculation [#106]. `CacheRegions`

now have a`persistent`

attribute indicating whether the cache data will be kept between program runs. For persistent cache regions the state id of the object for which the cached method is called has to be computed to obtain a unique persistent id for the given object. For non-persistent regions the object’s`uid`

can be used instead.`pymor.core.cache_regions`

now by default contains`'memory'`

,`'disk'`

and`'persistent'`

cache regions [#182], [#121] .`defaults`

can now be marked to not affect state id computation. In previous version of pyMOR, changing any`default`

value caused a change of the state id pyMOR’s defaults dictionary, leading to cache misses. While this in general is desirable, as, for instance, changed linear solver default error tolerances might lead to different solutions for the same`Discretization`

object, it is clear for many I/O related defaults, that these will not affect the outcome of any computation. For these defaults, the`defaults`

decorator now accepts a`sid_ignore`

parameter, to exclude these defaults from state id computation, preventing changes of these defaults causing cache misses [#81].- As an alternative to using the
`@cached`

decorator,`cached_method_call`

can be used to cache the results of a function call. This is now used in`solve`

to enable parsing of the input parameter before it enters the cache key calculation [#231].

### Additional new features¶

`apply_inverse_adjoint`

has been added to the`Operator`

interface [#133].- Support for complex values in
`NumpyVectorArray`

and`NumpyMatrixOperator`

[#131]. - New
`ProductParameterFunctional`

. - This
`ParameterFunctional`

represents the product of a given list of`ParameterFunctionals`

.

- New
- New
`SelectionOperator`

[#105]. - This
`Operator`

represents one`Operator`

of a given list of`Operators`

, depending on the evaluation of a provided`ParameterFunctional`

,

- New
- New block matrix operators [#215].
`BlockOperator`

and`BlockDiagonalOperator`

represent block matrices of`Operators`

which can be applied to appropriately shaped`BlockVectorArrays`

.

`from_file`

factory method for`NumpyVectorArray`

and`NumpyMatrixOperator`

[#118].`NumpyVectorArray.from_file`

and`NumpyMatrixOperator.from_file`

can be used to construct such objects from data files of various formats (MATLAB, matrix market, NumPy data files, text).

`ListVectorArray`

-based`NumpyMatrixOperator`

[#164].- The
`playground`

now contains`NumpyListVectorArrayMatrixOperator`

which can apply`NumPy`

/`SciPy`

matrices to a`ListVectorArray`

. This`Operator`

is mainly intended for performance testing purposes. The`thermalblock`

demo now has an option`--list-vector-array`

for using this operator instead of`NumpyMatrixOperator`

.

- Log indentation support [#230].
- pyMOR’s log output can now be indented via the
`logger.block(msg)`

context manger to reflect the hierarchy of subalgorithms.

- Default implementation of
`as_vector`

for functionals [#107]. `OperatorBase.as_vector`

now contains a default implementation for functionals by calling`apply_adjoint`

.

- Default implementation of
`pycontracts`

has been removed as a dependency of pyMOR [#127].- Test coverage has been raised to 80 percent.

### Backward incompatible changes¶

`VectorArray`

implementations have been moved to the`pymor.vectorarrays`

sub-package [#89].- The
`dot`

method of the`VectorArray`

interface has been split into`dot`

and`pairwise_dot`

[#76]. - The
`pairwise`

parameter of`dot`

has been removed, always assuming`pairwise == False`

. The method`pairwise_dot`

corresponds to the`pairwise == True`

case. Similarly the`pariwise`

parameter of the`apply2`

method of the`Operator`

interface has been removed and a`pairwise_apply2`

method has been added.

- The
`almost_equal`

has been removed from the`VectorArray`

interface [#143].- As a replacement, the new method
`pymor.algorithms.basic.almost_equal`

can be used to compare`VectorArrays`

for almost equality by the norm of their difference.

`lincomb`

has been removed from the`Operator`

interface [#83].- Instead, a
`LincombOperator`

should be directly instantiated.

- Removal of the
`options`

parameter of`apply_inverse`

in favor of`solver_options`

attribute [#122]. - The
`options`

parameter of`OperatorInterface.apply_inverse`

has been replaced by the`solver_options`

attribute. This attribute controls which fixed (linear) solver options are used when`apply_inverse`

is called. See`here <https://github.com/pymor/pymor/pull/184>`

for more details.

- Removal of the
- Renaming of reductors for coercive problems [#224].
`pymor.reductors.linear.reduce_stationary_affine_linear`

and`pymor.reductors.stationary.reduce_stationary_coercive`

have been renamed to`pymor.reductors.coercive.reduce_coercive`

and`pymor.reductors.coercive.reduce_coercive_simple`

. The old names are deprecated and will be removed in pyMOR 0.5.

- Non-parametric objects have now
`parameter_type`

`{}`

instead of`None`

[#84]. - Sampling methods of
`ParameterSpaces`

now return iterables instead of iterators [#108]. - Caching of
`solve`

is now disabled by default [#178]. - Caching of
`solve`

must now be explicitly enabled by using`pymor.core.cache.CacheableInterface.enable_caching`

.

- Caching of
- The default value for
`extension_algorithm`

parameter of`greedy`

has been removed [#82]. - Changes to
`ei_greedy`

[#159], [#160]. - The default for the
`projection`

parameter has been changed from`'orthogonal'`

to`'ei'`

to let the default algorithm agree with literature. In addition a`copy`

parameter with default`True`

has been added. When`copy`

is`True`

, the input data is copied before executing the algorithm, ensuring, that the original`VectorArray`

is left unchanged. When possible,`copy`

should be set to`False`

in order to reduce memory consumption.

- Changes to
- The
`copy`

parameter of`pymor.algorithms.gram_schmidt.gram_schmidt`

now defaults to`True`

[#123]. `with_`

has been moved from`BasicInterface`

to`ImmutableInterface`

[#154].`BasicInterface.add_attributes`

has been removed [#158].- Python fallbacks to Cython functions have been removed [#145].
- In order to use pyMOR’s discretization toolkit, building of the
`_unstructured`

,`inplace`

,`relations`

Cython extension modules is now required.

### Further improvements¶

- [#78] update apply_inverse signature
- [#115] [algorithms.gram_schmidt] silence numpy warning
- [#144] L2ProductP1 uses wrong quadrature rule in 1D case
- [#147] Debian doc packages have weird title
- [#151] add tests for ‘almost_equal’ using different norms
- [#156] Let thermal block demo use error estimator by default
- [#195] Add more tests / fixtures for operators in pymor.operators.constructions
- [#197] possible problem in caching
- [#207] No useful error message in case PySide.QtOpenGL cannot be imported
- [#209] Allow ‘pip install pymor’ to work even when numpy/scipy are not installed yet
- [#219] add minimum versions for dependencies
- [#228] merge fixes in python3 branch back to master
- [#269] Provide a helpful error message when cython modules are missing
- [#276] Infinite recursion in apply for IdentityOperator * scalar

## pyMOR 0.3 (March 2, 2015)¶

- Introduction of the vector space concept for even simpler integration with external solvers.
- Addition of a generic Newton algorithm.
- Support for Jacobian evaluation of empirically interpolated operators.
- Greatly improved performance of the EI-Greedy algorithm. Addition of the DEIM algorithm.
- A new algorithm for residual operator projection and a new, numerically stable a posteriori error estimator for stationary coercive problems based on this algorithm. (cf. A. Buhr, C. Engwer, M. Ohlberger, S. Rave, ‘A numerically stable a posteriori error estimator for reduced basis approximations of elliptic equations’, proceedings of WCCM 2014, Barcelona, 2014.)
- A new, easy to use mechanism for setting and accessing default values.
- Serialization via the pickle module is now possible for each class in pyMOR. (See the new ‘analyze_pickle’ demo.)
- Addition of generic iterative linear solvers which can be used in conjunction with any operator satisfying pyMOR’s operator interface. Support for least squares solvers and PyAMG (http://www.pyamg.org/).
- An improved SQLite-based cache backend.
- Improvements to the built-in discretizations: support for bilinear finite elements and addition of a finite volume diffusion operator.
- Test coverage has been raised from 46% to 75%.

Over 500 single commits have entered this release. A full list of all changes can be obtained under the following address: https://github.com/pymor/pymor/compare/0.2.2...0.3.0