`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. The end time is also allowed to be smaller than the initial time which results in solving the corresponding terminal value problem, i.e. initial_data serves as terminal data in this case and is also stored first in the resulting VectorArray.
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. The end time is also allowed to be smaller than the initial time which results in solving the corresponding terminal value problem, i.e. initial_data serves as terminal data in this case and is also stored first in the resulting VectorArray.
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. The end time is also allowed to be smaller than the initial time which results in solving the corresponding terminal value problem, i.e. initial_data serves as terminal data in this case and is also stored first in the resulting VectorArray.
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. The end time is also allowed to be smaller than the initial time which results in solving the corresponding terminal value problem, i.e. initial_data serves as terminal data in this case and is also stored first in the resulting VectorArray.
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]¶

Bases: pymor.core.base.ImmutableObject

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. The end time is also allowed to be smaller than the initial time which results in solving the corresponding terminal value problem, i.e. initial_data serves as terminal data in this case and is also stored first in the resulting VectorArray.
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. The end time is also allowed to be smaller than the initial time which results in solving the corresponding terminal value problem, i.e. initial_data serves as terminal data in this case and is also stored first in the resulting VectorArray.
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.

pymor.algorithms.timestepping¶

Module Contents¶

`pymor.algorithms.timestepping`¶