Role and Impact of Time Integrators in Time to Solution

# Time Integration & Non-Linear Solvers

## At a Glance

Questions | Objectives | Key Points | |

How does the choice of explicit vs. implicit impact step size. | Compare performance of explicit and implicit methods at step sizes near the stability limit. | Time integration considerations play a role in time to solution. | |

What is the impact of an adaptive time integrator? | Compare fixed and adaptive time integrator techniques. | The PETSc package has robust and flexible methods for time integration. | |

How does time integration order impact cost? | Observe impact of order on time to solution/flop and number of steps. | In well-designed packages, changing between methods does not require a lot of effort. | |

Observe quadratic convergence of Newton’s method | Observe mesh independent convergence of Newton’s method |

**Note:** To begin this lesson…

```
cd HandsOnLessons/time_integrators
```

## The problem being solved

The example application here, advection-ode.cpp uses a discontinuous Galerkin discretization from MFEM and the ODE solvers from PETSc to demonstrate the use of PETSc in both serial and parallel for more robust and flexible control over *time integration* (e.g. discretization in time) of PDEs.

The first application has been designed to solve the *Advection Equation* in 1, 2 or 3 dimensions as well as to work in a scalable, parallel way. \[\frac{\partial u}{\partial t} + \vec{v} \cdot \nabla u = 0\]

where \(v\) is a given fluid velocity and \(u(t=0,x)=u_0(x)\) is a given initial condition.

Here, all the runs solve a problem on a periodic, hexagonally bounded mesh with an initial rounded step function of amplitude 1.0 slightly off-center as pictured in Figure 1.

Figure 1 | Figure 2 | Figure 3 |
---|---|---|

### Getting Help

You can get help on all the command-line options to this application like so…

```
./advection-ode --help
Usage: ./advection-ode [options] ...
Options:
-h, --help
Print this help message and exit.
-m <string>, --mesh <string>, current value: ../../../data/periodic-hexagon.mesh
Mesh file to use.
-p <int>, --problem <int>, current value: 0
Problem setup to use. See options in velocity_function().
-rs <int>, --refine-serial <int>, current value: 2
Number of times to refine the mesh uniformly in serial.
-rp <int>, --refine-parallel <int>, current value: 0
Number of times to refine the mesh uniformly in parallel.
-o <int>, --order <int>, current value: 3
Order (degree) of the finite elements.
-s <int>, --ode-solver <int>, current value: 4
ODE solver: 1 - Forward Euler,
2 - RK2 SSP, 3 - RK3 SSP, 4 - RK4, 6 - RK6.
-tf <double>, --t-final <double>, current value: 10
Final time; start time is 0.
-dt <double>, --time-step <double>, current value: 0.01
Time step.
-vis, --visualization, -no-vis, --no-visualization, current option: --visualization
Enable or disable GLVis visualization.
-visit, --visit-datafiles, -no-visit, --no-visit-datafiles, current option: --visit-datafiles
Save data files for VisIt (visit.llnl.gov) visualization.
-vs <int>, --visualization-steps <int>, current value: 50
Visualize every n-th timestep.
-usestep, --usestep, -no-step, --no-step, current option: --usestep
Use the Step() or Run() method to solve the ODE system.
-implicit, --implicit, -no-implicit, --no-implicit, current option: --no-implicit
Use or not an implicit method in PETSc to solve the ODE system.
```

### Run 1: Explicit Method Default Options

```
PETSC_OPTIONS="-ts_view -ts_adapt_monitor no" ./advection-ode -no-vis
```

The L2 error at the final timestep is printed for each run below.

### Run 2: Explicit, with Euler and fixed timestep \(\Delta t\) of 0.001

```
PETSC_OPTIONS="-ts_view -ts_monitor :/dev/null -ts_type euler -ts_dt .001" ./advection-ode -no-vis
```

### Run 3: Explicit, with Euler and fixed timestep \(\Delta t\) of .01

```
PETSC_OPTIONS="-ts_view -ts_adapt_monitor no -ts_type euler -ts_dt .01" ./advection-ode -no-vis
```

The explicit algorithm is unstable for the specified timestep size.

We can shrink the timestep or use an implicit method.

### Run 4: Implicit, Fixed \(\Delta t\) at 0.01

Now, lets switch to an *implicit* method and see how that effects behavior of the numerical algorithms.

```
PETSC_OPTIONS="-ts_view -ts_adapt_monitor no -ts_dt .01" ./advection-ode -implicit -no-vis
```

### Run 5: Implicit, Fixed \(\Delta t\) at 0.1

Now, use a very large time-step and note the scheme remains stable.

```
PETSC_OPTIONS="-ts_view -ts_adapt_monitor no -ts_dt .1 -log_view :/dev/null" ./advection-ode -implicit -no-vis
```

### Run 6: Implicit, Adaptive \(\Delta t\), Tolerances 1e-4, 4th Order

In this run, we’ll combine **both** the advantages of an *implicit* algorithm and an *adaptive* time step.

```
PETSC_OPTIONS="-ts_view -ts_adapt_monitor no -ts_type arkimex -ts_dt .1 -log_view :/dev/null" ./advection-ode -implicit -no-vis
```

### Run 7: View a summary of the operations for Implicit, Adaptive \(\Delta t\), Tolerances 1e-4, 4th Order

The `-log_view`

option

```
PETSC_OPTIONS="-ts_view -ts_adapt_monitor no -ts_type arkimex -ts_dt .1 -log_view " ./advection-ode -implicit -no-vis
```

## The problem being solved

The example application here, elasticity-snes.cpp uses MFEM and the ODE solvers from PETSc to solve a time-dependent nonlinear elasticity problem.

### Run 8: Quadratic convergence of Newton’s method

```
make elasticity-snes
./elasticity-snes
```

### Run 9: Mesh independent convergence of Newton’s method

```
./elasticity-snes -rs 2
./elasticity-snes -rs 4
```

## Out-Brief

We have used MFEM and PETSc as a demonstration vehicle for illustrating the value in robust, time integration methods in numerical algorithms. In particular, we have used the PETSc integrators to compare and contrast both the effects of *adaptive* time stepping as well as the role the order of the time integration plays in time to solution and number of time steps in the adaptive case. In addition, we have demonstrated the ability of implicit methods to run at higher time steps than explicit and also demonstrated the cost of nonlinear solvers in implicit approaches.

The use of *adaptation* here was confined to *discretization* of time. Other lessons here demonstrate the advantages *adaptation* can play in the *discretization* of *space* (e.g. meshing).

Finally, it is worth reminding the learner that the application demonstrated here can be run on 1, 2 and 3 dimensional meshes and in scalable, parallel settings and on meshes of extremely high spatial resolution if so desired.

## Evening Hands On Session

Run the two examples with a different number of levels of refinement using `-rs n`

and the `-log_view`

option introduced above to explore the scalability of the algorithms. For example

```
PETSC_OPTIONS="-ts_adapt_monitor no -ts_type arkimex -ts_monitor :/dev/null -log_view " ./elasticity-snes -rs 2 -no-vis
```

then again

```
PETSC_OPTIONS="-ts_adapt_monitor no -ts_type arkimex -ts_monitor :/dev/null -log_view " mpiexec -n 4 ./elasticity-snes -rs 2 -no-vis
```

Try other combinations of levels of refinement and number of processes. Produce a small *scaling* plot showing scaling of algorithms from say 1..32 mpi ranks.

When you are done, be sure to submit a Show Your Work using the hands-on activity name *Time Integrators Scalability* and upload evidence of your completed solutions.