`pymor.algorithms.timestepping`¶

Generic time-stepping 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 `Model` provided by an external library into an instationary `Model`.

The `TimeStepper` defines a common interface that has to be fulfilled by the time-steppers used by `InstationaryModel`.

Module Contents¶

class pymor.algorithms.timestepping.DiscreteTimeStepper[source]

Bases: `TimeStepper`

Discrete time-stepper.

Solves equations of the form

```M(mu) * u_k+1 + A(u_k, mu, k) = F(mu, k).
u(mu, k_0) = u_0(mu).
```

by direct time stepping.

Methods

 `estimate_time_step_count` Estimate the number of time steps. `iterate` Iterate time-stepper to the equation.
estimate_time_step_count(initial_time, end_time)[source]

Estimate the number of time steps.

Parameters

initial_time

The time at which to begin time-stepping.

end_time

The time until which to perform time-stepping.

iterate(initial_time, end_time, initial_data, operator, rhs=None, mass=None, mu=None, num_values=None)[source]

Iterate time-stepper to the equation.

The equation is of the form

```M(mu) * d_t u + A(u, mu, t) = F(mu, t),
u(mu, t_0) = u_0(mu).
```

Parameters

initial_time

The time at which to begin time-stepping.

end_time

The time until which to perform time-stepping.

initial_data

The solution vector at `initial_time`.

operator

The `Operator` A.

rhs

The right-hand side F (either `VectorArray` of length 1 or `Operator` with `source.dim == 1`). If `None`, zero right-hand side is assumed.

mass

The `Operator` M. If `None`, the identity operator is assumed.

mu

`Parameter values` for which `operator` and `rhs` are evaluated. The current time is added to `mu` 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

Generator yielding tuples (U, t) of snapshots and times.

class pymor.algorithms.timestepping.ExplicitEulerTimeStepper(nt)[source]

Bases: `TimeStepper`

Explicit Euler time-stepper.

Solves equations of the form

```M(mu) * d_t u + A(u, mu, t) = F(mu, t),
u(mu, t_0) = u_0(mu).
```

by explicit Euler time integration.

Parameters

nt

The number of time-steps the time-stepper will perform.

Methods

 `estimate_time_step_count` Estimate the number of time steps. `iterate` Iterate time-stepper to the equation.
estimate_time_step_count(initial_time, end_time)[source]

Estimate the number of time steps.

Parameters

initial_time

The time at which to begin time-stepping.

end_time

The time until which to perform time-stepping.

iterate(initial_time, end_time, initial_data, operator, rhs=None, mass=None, mu=None, num_values=None)[source]

Iterate time-stepper to the equation.

The equation is of the form

```M(mu) * d_t u + A(u, mu, t) = F(mu, t),
u(mu, t_0) = u_0(mu).
```

Parameters

initial_time

The time at which to begin time-stepping.

end_time

The time until which to perform time-stepping.

initial_data

The solution vector at `initial_time`.

operator

The `Operator` A.

rhs

The right-hand side F (either `VectorArray` of length 1 or `Operator` with `source.dim == 1`). If `None`, zero right-hand side is assumed.

mass

The `Operator` M. If `None`, the identity operator is assumed.

mu

`Parameter values` for which `operator` and `rhs` are evaluated. The current time is added to `mu` 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

Generator yielding tuples (U, t) of snapshots and times.

class pymor.algorithms.timestepping.ImplicitEulerTimeStepper(nt, solver_options='operator')[source]

Bases: `TimeStepper`

Implicit Euler time-stepper.

Solves equations of the form

```M(mu) * d_t u + A(u, mu, t) = F(mu, t),
u(mu, t_0) = u_0(mu).
```

by implicit Euler time integration.

Parameters

nt

The number of time-steps the time-stepper will perform.

solver_options

The `solver_options` used to invert `M + dt*A`. The special values `'mass'` and `'operator'` are recognized, in which case the solver_options of M (resp. A) are used.

Methods

 `estimate_time_step_count` Estimate the number of time steps. `iterate` Iterate time-stepper to the equation.
estimate_time_step_count(initial_time, end_time)[source]

Estimate the number of time steps.

Parameters

initial_time

The time at which to begin time-stepping.

end_time

The time until which to perform time-stepping.

iterate(initial_time, end_time, initial_data, operator, rhs=None, mass=None, mu=None, num_values=None)[source]

Iterate time-stepper to the equation.

The equation is of the form

```M(mu) * d_t u + A(u, mu, t) = F(mu, t),
u(mu, t_0) = u_0(mu).
```

Parameters

initial_time

The time at which to begin time-stepping.

end_time

The time until which to perform time-stepping.

initial_data

The solution vector at `initial_time`.

operator

The `Operator` A.

rhs

The right-hand side F (either `VectorArray` of length 1 or `Operator` with `source.dim == 1`). If `None`, zero right-hand side is assumed.

mass

The `Operator` M. If `None`, the identity operator is assumed.

mu

`Parameter values` for which `operator` and `rhs` are evaluated. The current time is added to `mu` 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

Generator yielding tuples (U, t) of snapshots and times.

class pymor.algorithms.timestepping.ImplicitMidpointTimeStepper(nt, solver_options='operator')[source]

Bases: `TimeStepper`

Implicit midpoint rule time-stepper. Symplectic integrator + preserves quadratic invariants.

Solves equations of the form

```M(mu) * d_t u + A(u, mu, t) = F(mu, t),
u(mu, t_0) = u_0(mu).
```

by implicit midpoint time integration.

Parameters

nt

The number of time-steps the time-stepper will perform.

solver_options

The `solver_options` used to invert `M - dt/2*A`. The special values `'mass'` and `'operator'` are recognized, in which case the solver_options of M (resp. A) are used.

Methods

 `estimate_time_step_count` Estimate the number of time steps. `iterate` Iterate time-stepper to the equation.
estimate_time_step_count(initial_time, end_time)[source]

Estimate the number of time steps.

Parameters

initial_time

The time at which to begin time-stepping.

end_time

The time until which to perform time-stepping.

iterate(initial_time, end_time, initial_data, operator, rhs=None, mass=None, mu=None, num_values=None)[source]

Iterate time-stepper to the equation.

The equation is of the form

```M(mu) * d_t u + A(u, mu, t) = F(mu, t),
u(mu, t_0) = u_0(mu).
```

Parameters

initial_time

The time at which to begin time-stepping.

end_time

The time until which to perform time-stepping.

initial_data

The solution vector at `initial_time`.

operator

The `Operator` A.

rhs

The right-hand side F (either `VectorArray` of length 1 or `Operator` with `source.dim == 1`). If `None`, zero right-hand side is assumed.

mass

The `Operator` M. If `None`, the identity operator is assumed.

mu

`Parameter values` for which `operator` and `rhs` are evaluated. The current time is added to `mu` 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

Generator yielding tuples (U, t) of snapshots and times.

class pymor.algorithms.timestepping.TimeStepper[source]

Interface for time-stepping algorithms.

Algorithms implementing this interface solve time-dependent initial value problems of the form

```M(mu) * d_t u + A(u, mu, t) = F(mu, t),
u(mu, t_0) = u_0(mu).
```

Time-steppers used by `InstationaryModel` have to fulfill this interface.

Methods

 `estimate_time_step_count` Estimate the number of time steps. `iterate` Iterate time-stepper to the equation. `solve` Apply time-stepper to the equation.
abstract estimate_time_step_count(initial_time, end_time)[source]

Estimate the number of time steps.

Parameters

initial_time

The time at which to begin time-stepping.

end_time

The time until which to perform time-stepping.

abstract iterate(initial_time, end_time, initial_data, operator, rhs=None, mass=None, mu=None, num_values=None)[source]

Iterate time-stepper to the equation.

The equation is of the form

```M(mu) * d_t u + A(u, mu, t) = F(mu, t),
u(mu, t_0) = u_0(mu).
```

Parameters

initial_time

The time at which to begin time-stepping.

end_time

The time until which to perform time-stepping.

initial_data

The solution vector at `initial_time`.

operator

The `Operator` A.

rhs

The right-hand side F (either `VectorArray` of length 1 or `Operator` with `source.dim == 1`). If `None`, zero right-hand side is assumed.

mass

The `Operator` M. If `None`, the identity operator is assumed.

mu

`Parameter values` for which `operator` and `rhs` are evaluated. The current time is added to `mu` 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

Generator yielding tuples (U, t) of snapshots and times.

solve(initial_time, end_time, initial_data, operator, rhs=None, mass=None, mu=None, num_values=None)[source]

Apply time-stepper to the equation.

The equation is of the form

```M(mu) * d_t u + A(u, mu, t) = F(mu, t),
u(mu, t_0) = u_0(mu).
```

Parameters

initial_time

The time at which to begin time-stepping.

end_time

The time until which to perform time-stepping.

initial_data

The solution vector at `initial_time`.

operator

The `Operator` A.

rhs

The right-hand side F (either `VectorArray` of length 1 or `Operator` with `source.dim == 1`). If `None`, zero right-hand side is assumed.

mass

The `Operator` M. If `None`, the identity operator is assumed.

mu

`Parameter values` for which `operator` and `rhs` are evaluated. The current time is added to `mu` 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.