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
.
Currently, implementations of explicit_euler
and implicit_euler
time-stepping are provided. The TimeStepper
defines a
common interface that has to be fulfilled by the time-steppers used
by InstationaryModel
. The classes ExplicitEulerTimeStepper
and ImplicitEulerTimeStepper
encapsulate explicit_euler
and
implicit_euler
to provide this interface.
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).
Methods
Apply time-stepper to the equation.
- 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 * d_t u + A(u, mu, t) = F(mu, t).
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 orOperator
withsource.dim == 1
). IfNone
, zero right-hand side is assumed.- mass
The
Operator
M. IfNone
, the identity operator is assumed.- mu
Parameter values
for whichoperator
andrhs
are evaluated. The current time is added tomu
with keyt
.- 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.ExplicitEulerTimeStepper(nt)[source]¶
Bases:
TimeStepper
Explicit Euler time-stepper.
Solves equations of the form
M * d_t u + A(u, mu, t) = F(mu, t).
Parameters
- nt
The number of time-steps the time-stepper will perform.
Methods
Apply time-stepper to the equation.
- 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 * d_t u + A(u, mu, t) = F(mu, t).
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 orOperator
withsource.dim == 1
). IfNone
, zero right-hand side is assumed.- mass
The
Operator
M. IfNone
, the identity operator is assumed.- mu
Parameter values
for whichoperator
andrhs
are evaluated. The current time is added tomu
with keyt
.- 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:
TimeStepper
Implicit Euler time-stepper.
Solves equations of the form
M * d_t u + A(u, mu, t) = F(mu, t).
Parameters
- nt
The number of time-steps the time-stepper 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
Apply time-stepper to the equation.
- 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 * d_t u + A(u, mu, t) = F(mu, t).
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 orOperator
withsource.dim == 1
). IfNone
, zero right-hand side is assumed.- mass
The
Operator
M. IfNone
, the identity operator is assumed.- mu
Parameter values
for whichoperator
andrhs
are evaluated. The current time is added tomu
with keyt
.- 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.ImplicitMidpointTimeStepper(nt, solver_options='operator')[source]¶
Bases:
TimeStepper
Implicit midpoint rule time-stepper. Symplectic integrator + preserves quadratic invariants.
Solves equations of the form
M * d_t u + A(u, mu, t) = F(mu, t).
Parameters
- nt
The number of time-steps the time-stepper will perform.
- solver_options
The
solver_options
used to invertM - dt/2*A
. The special values'mass'
and'operator'
are recognized, in which case the solver_options of M (resp. A) are used.
Methods
Apply time-stepper to the equation.
- 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 * d_t u + A(u, mu, t) = F(mu, t).
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 orOperator
withsource.dim == 1
). IfNone
, zero right-hand side is assumed.- mass
The
Operator
M. IfNone
, the identity operator is assumed.- mu
Parameter values
for whichoperator
andrhs
are evaluated. The current time is added tomu
with keyt
.- 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.TimeStepper[source]¶
Bases:
pymor.core.base.ImmutableObject
Interface for time-stepping algorithms.
Algorithms implementing this interface solve time-dependent problems of the form
M * d_t u + A(u, mu, t) = F(mu, t).
Time-steppers used by
InstationaryModel
have to fulfill this interface.Methods
Apply time-stepper to the equation.
- abstract 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 * d_t u + A(u, mu, t) = F(mu, t).
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 orOperator
withsource.dim == 1
). IfNone
, zero right-hand side is assumed.- mass
The
Operator
M. IfNone
, the identity operator is assumed.- mu
Parameter values
for whichoperator
andrhs
are evaluated. The current time is added tomu
with keyt
.- 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]¶