SelfStart Namespace Reference

Definition of the integrator self-starting procedure. More...

## Namespaces | |

Actions | |

Self-start actions. | |

Tags | |

Self-start tags. | |

## Typedefs | |

template<typename ComputeRhs , typename UpdateVariables > | |

using | self_start_procedure = tmpl::flatten< tmpl::list< SelfStart::Actions::Initialize, ::Actions::Label< detail::PhaseStart >, SelfStart::Actions::CheckForCompletion< detail::PhaseEnd >, ::Actions::AdvanceTime, SelfStart::Actions::CheckForOrderIncrease, ComputeRhs, SelfStart::Actions::StartNextOrderIfReady< detail::PhaseStart >, UpdateVariables, ::Actions::Goto< detail::PhaseStart >, ::Actions::Label< detail::PhaseEnd >, SelfStart::Actions::Cleanup > > |

The list of actions required to self-start an integrator. More... | |

Definition of the integrator self-starting procedure.

The self-start procedure generates \(N\) function values of accuracy \(O\left((\Delta t)^N\right)\), where \(N\) is the negative of the initial slab number. To generate values, it requires the time stepper to be a multistep integrator that will produce an order- \(k\)-accurate result given \(k-1\) history values.

If the integrator is started from analytic history data or requires no history (such as for a substep integrator), then the initial slab number can be set to zero and no self-start steps will be taken.

To self-start a multistep integrator, the function is integrated repeatedly with increasing accuracy. A first order integrator (Euler's method) requires no history values, so it can be used, starting from the initial point, to generate a first-order-accurate value at a later time. We then reset to the start conditions and use the new "history" value (at a discarded point later in time) to take two steps with a second-order method. These values are second-order-accurate despite the history only being first-order because the calculation of the change in the value multiplies the previous derivatives by a factor of \(\Delta t\). The time and value are then again reset to their starting values and we start again at third order, and so on.

The choice of performing the low-order integrations in the same direction as the main integration makes this a *forward* self-start procedure, as opposed to a *backward* procedure that produces values for times before the start time. The primary advantage of the forward version is that the solution is guaranteed to exist after the start time, but not before. It also makes bookkeeping easier, as the reset after each order increase is to the initial state, rather than to a time one step further back for each order. It does have the disadvantage, however, of leaving a non-monotonic history at the end of the procedure, which the main evolution loop must be able to handle.

Each time the state is reset the slab number is increased by one. This ensures that the evaluations are considered to be ordered in their evaluation order, even though they are not monotonic in time. When the slab number reaches zero the initialization procedure is complete and history appropriate for use for an integrator of order \(N+1\) has been generated.

The self-start procedure performs all its evaluations before the end of the first time step of the main evolution. It is important that none of the early steps fall at the same time as the self-start history values, so the main evolution should not decrease its step size on the first step after the procedure. Additionally, the history times will not be monotonicly increasing until \(N\) steps have been taken. The local-time-stepping calculations require monotonic time, so local time-stepping should not be initiated until the self-start values have expired from the history. These restrictions on step-size changing are checked in the TimeStepper::can_change_step_size method.

© Copyright 2017 - 2019 SXS Collaboration, Distributed under the MIT License