Tempus: Time Integration and Sensitivity Analysis Package

Introduction

Tempus is a Latin word meaning time as in “tempus fugit” -> “time flies”.

The Tempus package is a time-integration framework for advanced transient analysis, including various time integrators and embedded sensitivity analysis for next-generation code architectures. This framework provides “out-of-the-box” time-integration capabilities, which allows users to supply governing equations and easily switch between various time integrators. Additionally Tempus provides “build-your-own” capabilities, which allows applications to incorporate various Tempus components to augment or replace application transient capabilities. Other capabilities include embedded error analysis, sensitivity analysis, transient optimization with ROL.

Tempus provides a general infrastructure for the time evolution of solutions through a variety of general integration schemes, and can be used from small systems of equations (e.g., single ODEs for the time evolution of plasticity models, and multiple ODEs for coupled chemical reactions) to large-scale transient simulations requiring exascale computing (e.g., flow fields around reentry vehicles and magneto-hydrodynamics).

Capabilities

Tempus provides time-integration methods for first and second-order ODEs in their explicit and implicit forms,

Integrators

Tempus Integrators (e.g., Tempus::IntegratorBasic) are the time loop structure for time integration and provide several features, e.g.,

• Control the advancement of the solution from timestep to the next, e.g., restart from failed timestep, selection of the next timestep size, solution output.
• holds the solution history for the time integration
• Applications can insert application-specific functionality into Tempus::IntegratorBasic through observers, e.g., Tempus::IntegratorObserver.
• Applications can create their own integrators, derived from Tempus::Integrator.

Time Steppers

Some features of Tempus::Stepper are

• Timesteppers take a single timestep (PASS/FAIL) and operate on the supplied solution.
• Steppers are stateless (i.e., do not hold on to data related to the solution), which indicates if the same solution is given to the Stepper multiple times, the same result would be obtained.
• Steppers hold the governing equations/physics (e.g., ModelEvaulator).
• Timesteppers can make the initial conditions "consistent" (i.e., ensure that and (and optionally satisfy the governing equation at the beginning of the time integration, e.g., .
• Many Steppers take advantage of the First-Same-As-Last (FSAL) property, when possible, to reduce computational costs.
• Applications can insert application-specific functionality into the Tempus::Stepper through application actions, e.g., Tempus::StepperRKAppAction.
• Applications can create their own steppers, derived from Stepper, that can be used with other Tempus capabilities, e.g., Integrator Basic and Solution History.
• Steppers can mark solutions as failed (e.g., failure to reach solver tolerances), suggest timestep sizes, and calculate error estimates.

A variety of time steppers are available (also see Tempus::Stepper).

• One-Step Methods:
  • Forward Euler
  • Backward Euler
  • Trapezoidal Method
• Explicit Runge-Kutta Methods:
  • General ERK
  • RK Forward Euler (RK1)
  • RK Explicit 4 Stage (RK4)
  • RK Explicit 3/8 Rule
  • RK Explicit 4 Stage 3rd order by Runge
  • RK Explicit 5 Stage 3rd order by Kinnmark and Gray
  • RK Explicit 3 Stage 3rd order
  • RK Explicit 3 Stage 3rd order TVD or SSPERK33 (SSPRK3)
  • RK Explicit 3 Stage 3rd order by Heun
  • RK Explicit Midpoint
  • RK Explicit Trapezoidal or Heuns Method or SSPERK22 (SSPRK2)
  • Bogacki-Shampine 3(2) Pair
  • Merson 4(5) Pair
  • RK Explicit Ralston
  • SSPERK54
• Diagonally Implicit Runge-Kutta (DIRK) Methods:
  • General DIRK
  • RK Backward Euler
  • RK Implicit Midpoint
  • RK Implicit 1 Stage 1st order Radau IA
  • DIRK 1 Stage Theta Method
  • SDIRK 2 Stage 2nd order
  • SDIRK 2 Stage 3rd order
  • EDIRK 2 Stage 3rd order
  • EDIRK 2 Stage Theta Method
  • SDIRK 3 Stage 2nd order
  • SDIRK 3 Stage 4th order
  • SDIRK 5 Stage 4th order
  • SDIRK 5 Stage 5th order
  • SSPDIRK22
  • SSPDIRK32
  • SSPDIRK23
  • SSPDIRK33
  • SDIRK 2(1) Pair
  • RK Trapezoidal Rule or RK Crank-Nicolson
  • RK Implicit 2 Stage 2nd order Lobatto IIIB
• Implicit-Explicit (IMEX) Runge-Kutta Methods:
  • General Partitioned IMEX RK
  • IMEX RK 1st order
  • SSP1_111
  • IMEX RK SSP2 (SSP2_222)
  • IMEX RK SSP3 (SSP3_332)
  • IMEX RK ARS 233
  • General IMEX RK
  • Partitioned IMEX RK 1st order
  • Partitioned IMEX RK SSP2
  • Partitioned IMEX RK ARS 233
• Multi-Step Methods:
  • BDF2
• Second-order ODE Methods:
  • Leapfrog
  • Newmark Implicit a-Form
  • Newmark Implicit d-Form
  • Newmark Explicit a-Form
  • HHT-Alpha
• Steppers with subSteppers:
  • Operator Split
  • Subcycling

Solution State and Solution History

Solutions in Tempus are maintained in Tempus::SolutionState and incapsulate the complete state of the solution for a particular time. The primary requirement for SolutionState is that it contains all the information needed to restart the solution from scratch, e.g., check-pointing and recover from a failed timestep. The four primary components of the Tempus::SolutionState are

• The state - , (optional), and (optional)
• The metastate - timestep, time, order, error, etc.
• The StepperState - any data needed by the stepper
• The PhysicsState - any application-specific data

Tempus::SolutionState are stored in a Tempus::SolutionHistory, which is simply a container of SolutionStates, and

• allows chronological and index access to SolutionStates
• has multiple methods to handle the number of SolutionStates, e.g., all and last two states.
• supports access patterns, e.g., adjoint sensitivities for checkpointing, and past timesteps for BDF methods.
• provides interpolation capabilities (note: interpolated solutions may not satisfy governing-equation conservation principles).

Timestep Control and Strategies

Tempus::TimeStepControl is used by the Tempus::IntegratorBasic to select the next timestep size, and has several basic capabilities:

• simulation time min/max bounding
• time index min/max bounding
• timestep size min/max bounding
• relative/absolute maximum error
• timestep adjustments for output and checkpointing
• maximum number of failures and consecutive failures
• ensure constant time steps
• incorporate Stepper suggested time step

Additionally, Tempus provides timestep control strategies (e.g., Tempus::TimeStepControlStrategy) for various variable-timestepping capabilities, and include

• constant and variable timestep control
• PID integral timestep controller
• composite strategy, which can apply multiple control strategies
• ability to incorporate application-specific control strategies

Tutorials

Here are some basic tutorials to illustrate how convert an application use Tempus, and some of the features available.

Title	Description
Example 0: Basic Problem	Introduces the problem used in following examples.
Example 1: Utilize Thyra	Utilize Thyra Vectors instead of C++ arrays.
Example 2: Use ModelEvaluator	Use ModelEvaluator for the problem description.
Example 3: Introduce SolutionState	Introduce SolutionState to manage the solution evoluation. Covers: solution vectors ( , , and ) and metadata.
Adding SolutionHistory	Adding SolutionHistory to store and interpolate solutions. (under construction).
Use Steppers	Use Steppers to enable various time steppers. Covers: explicit and implicit ODE time steppers, consistent initial conditions, and AppActions.
Introduce Time-step Controllers	Introduce TimeStepControllers to change the timestep size for variable timestepping. Covers: time step strategies and TimeEvents.
Utilize IntegratorBasic	utilize IntegratorBasic to provide all the basic features for Tempus time integrators. Covers: IntegratorBasic and IntegratorObservers.

Also, one can look at the tests and unit tests for examples of usage, but these may not show standard usage or context as they are meant for testing.