SelfStart Namespace Reference

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

Namespaces
namespace	Actions
	Self-start actions.
namespace	Tags
	Self-start tags.

Typedefs
template<typename StepActions , typename System >
using	self_start_procedure = implementation defined
	The list of actions required to self-start an integrator. More...

Functions
bool	is_self_starting (const TimeStepId &time_id)
	Reports whether the time_id is during self start. More...
bool	step_unused (const TimeStepId &time_id, const TimeStepId &next_time_id)
	Returns whether the result of the step from time_id to next_time_id is unused because of a self-start reset.

Detailed Description

Definition of the integrator self-starting procedure.

The self-start procedure generates $N$ function values of accuracy $O((\mathrm{\Delta }t{)}^N)$, 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.

Details

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 $\mathrm{\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.

Function Documentation

is_self_starting()

bool SelfStart::is_self_starting

(

const TimeStepId &

time_id

)

Reports whether the time_id is during self start.

This currently assumes that the slab number of the time_id will be negative if and only if self-start is in progress. If self start is modified to alter that behavior, this utility must also be modified.