NDSolve`StateData

The first stage of any solution using NDSolve is processing the equations specified into a form that can be efficiently accessed by the actual integration algorithms. This stage minimally involves determining the differential order of each variable, making substitutions needed to get a first-order system, solving for the time derivatives of the functions in terms of the functions, and forming the result into a NumericalFunction object. If you want to save the time of repeating this process for the same set of equations or if you want more control over the numerical integration process, the processing stage can be executed separately with NDSolve`ProcessEquations.

It is not uncommon that the solution to a more sophisticated problem involves solving the same differential equation repeatedly, but with different initial conditions. In some cases, processing equations may be as time-consuming as numerically integrating the differential equations. In these situations, it is a significant advantage to be able to simply give new initial values.

Using NDSolve`Reinitialize may save computation time when you need to solve the same differential equation for many different initial conditions, as you might in a shooting method for boundary value problems.

A subset of NDSolve options can be specified as options to NDSolve`Reinitialize.

One important use of NDSolve`StateData objects is to have more control of the integration. For some problems, it is appropriate to check the solution and start over or change parameters, depending on certain conditions.

Note that when you use NDSolve`ProcessEquations, you do not need to give the range of the t variable explicitly because that information is not needed to set up the equations in a form ready to solve. (For PDEs, you do have to give the ranges of all spatial variables, however, since that information is essential for determining an appropriate discretization.)

NDSolve`Iterate does not return a value because it modifies the NDSolve`StateData object assigned to the variable state. Thus, the command affects the value of the variable in a manner similar to setting parts of a list, as described in "Manipulating Lists by Their Indices". You can see that the value of state has changed since it now displays the current time to which it is integrated.

If you want to integrate further, you can call NDSolve`Iterate again, but with a larger value for time.

You can specify a time that is earlier than the first current time, in which case the integration proceeds backwards with respect to time.

NDSolve`Iterate allows you to specify intermediate times at which to stop. This can be useful, for example, to avoid discontinuities. Typically, this strategy is more effective with so-called one-step methods, such as the explicit Runge-Kutta method used in this example. However, it generally works with the default NDSolve method as well.

Once you have integrated a system up to a certain time, typically you want to be able to look at the current solution values and to generate an approximate function representing the solution computed so far. The command NDSolve`ProcessSolutions allows you to do both.

Just as when using NDSolve directly, there will be a rule for each function you specified in the second argument to NDSolve`ProcessEquations. Only the specified components of the solutions are saved in such a way that an InterpolatingFunction object can be created.

The choices you can give for the direction dir are "Forward" and "Backward", which refer to the integration forward and backward from the initial condition.

The output given by NDSolve`ProcessSolution is always given in terms of the dependent variables, either at a specific value of the independent variable, or interpolated over all of the saved values. This means that when a partial differential equation is being integrated, you will get results representing the dependent variables over the spatial variables.

The solution is given as an InterpolatingFunction object that interpolates over the spatial variable x.

When you process the current solution for partial differential equations, the spatial error estimate is checked. (It is not generally checked except when solutions are produced because doing so would be quite time consuming.) Since it is excessive, the NDSolve::eerr message is issued. The typical association of the word "backward" with the heat equation as implying instability gives a clue to what is wrong in this example.

The plot of the solution shows that instability is indeed the problem.

Even though the heat equation example is simple enough to know that the solution backward in time is problematic, using NDSolve`Iterate and NDSolve`ProcessSolutions to monitor the solution of a PDE can be used to save computing a solution which turns out not to be as accurate as desired. Another simple form of monitoring follows.

When you monitor a solution in this way, it is usually possible to interrupt the computation if you see that the solution found is sufficient. You can still use the NDSolve`StateData object to get the solutions that have been computed.

An NDSolve`StateData object contains a lot of information, but it is arranged in a manner which makes it easy to iterate solutions, and not in a manner which makes it easy to understand where the information is kept. However, sometimes you will want to get information from the state data object: for this reason several method functions have been defined to make accessing the information easy.

Much of the available information depends on the current solution values. Each NDSolve`StateData object keeps solution information for solutions in both the forward and backward direction. At the initial condition these are the same, but once the problem has been iterated in either direction, these will be different.

If the direction argument is omitted, the functions will return a list with the data for both directions (a list with a single element at the initial condition). Otherwise, the direction can be Forward, Backward, or Active as specified in the previous subsection.

"Current" refers to the most recent point reached in the integration.

The method functions are relatively low-level hooks into the data structure; they do little processing on the data returned to you. Thus, unlike NDSolve`ProcessSolutions, the solutions given are simply vectors of data points relating to the system of ordinary differential equations NDSolve is solving.

This plot does not show the correspondence with the x-grid values correctly. To get the correspondence with the spatial grid correctly, you must use NDSolve`ProcessSolutions.

There is a tremendous amount of control provided by these methods, but an exhaustive set of examples is beyond the scope of this documentation.

One of the most important uses of the information from an NDSolve`StateData object is to initialize integration methods. Examples are shown in "The NDSolve Method Plug-in Framework".