The Lorenz Attractor
A MRKISS Library Example Program

The code for this example is found in examples/lorenz.f90. Additionally the code may be found at the end of this document in the section Full Code Listing.

One strange thing when visualizing strange attracters is that we are frequently less concerned with the absolute accuracy of the solution curves than we are with the spacing of the solution points. This example uses the Lorenz attractor to explore some of the tools MRKISS provides for these kinds of problems.

For animations of the evolution of the curve we normally use a fixed \(\Delta{t}\) because this preserves time in the animation. That is to say we can see the point tracing the curve speed up and slow down as the derivative changes. We can produce such a solution with the fixed_t_steps solvers. Here is an example of such a curve:

Notice the way some of the steps are much longer than others. This is especially apparent in the upper left:

Many path animation tools have the ability to interpolate intermediate points on piecewise curves. Some even have the ability to use derivative information and do Hermite interpolation. Having a few longer steps when using such a tool is no issue. OTOH, when simply animating successive solution steps, large steps can make the animation jerky. When this happens, if you still want to preserve time in the animation, the only real solution is to decrease the value used for \(\Delta{t}\).

The solutions used in the images above were created by this snippet of examples/lorenz.f90:

call fixed_t_steps(status, istats, solution, eq, y_iv, param, a, b, c, t_delta_o=t_delta, t_max_o=t_max)
print '(a)', status_to_message(status)
call print_istats(status, istats)
call print_solution(status, solution, filename_o="lorenz_fixed.csv", end_o=istats(1), t_min_o=50.0_rk)

Ray tracing tools can render scenes made up of spheres orders of magnitude faster than they can deal with things like triangles. Because of this fact it is common practice to represent curves in space as thousands, or millions, of spheres tightly packed along the curve – this is called a "sphere sweep". In order for this to work out the spheres need to be close together so that the angles of intersection are very small. Still we don't want too many spheres as every sphere adds time to the overall render. What we really want is to compute the optimal distance between the sphere centers, and then use this distance for all the spheres. That means we want steps of constant \(\mathbf{\Delta{y}}\).

Solutions with constant \(\mathbf{\Delta{y}}\) steps are also used for constant velocity animations of curve evolution. These can be interesting when done with groups of stream lines.

MRKISS provides two solvers for this situation:

fixed_y_steps

This solver uses considerable compute resources to insure that every step is the same length to a user provided tolerance. It requires the user provide minimum and maximum bounds for \(\Delta{t}\) which will bracket the correct value. The resulting curves are perfect for high quality sphere sweep renders.

sloppy_fixed_y_steps

This solver only approximates optimal \(\Delta{t}\). In exchange for this inaccuracy, this routine is much faster than the previous option. The resulting solutions frequently good enough for a sphere sweep.

Here are some representative samples:

These images were created by the following snippet of examples/lorenz.f90:

call sloppy_fixed_y_steps(status, istats, solution, eq, y_iv, param, a, b, c, 1.0_rk, t_delta, t_max_o=t_max)
print '(a)', status_to_message(status)
call print_istats(status, istats)
call print_solution(status, solution, filename_o="lorenz_sloppy_condy.csv", end_o=istats(1), t_min_o=50.0_rk)

! This solution will have y-delta approximately equal to 1.0 for all steps.
print '(a)', repeat('*', 120)
print '(a)', "sloppy_fixed_y_steps short"
call sloppy_fixed_y_steps(status, istats, solution, eq, y_iv, param, a, b, c, 1.0_rk, t_delta, t_max_o=t_max, &
                                adj_short_o=1)
print '(a)', status_to_message(status)
call print_istats(status, istats)
call print_solution(status, solution, filename_o="lorenz_sloppy_condy_short.csv", end_o=istats(1), t_min_o=50.0_rk)

When drawing line plots of curves we normally want them to be appear smooth which means we must avoid large values for \(\mathbf{\Delta{y}}\). For curve line drawing we normally are not terribly concerned with having a few short intervals because they don't have a huge impact on rendering speed.

When rendering curves as tubes most tools render a sphere at each point and a cylinder connecting the points. As with line drawings we want the curve to appear smooth, and so we wish to avoid large values for \(\mathbf{\Delta{y}}\). When rendering tubes we are more sensitive to excessive numbers of short intervals because every point impacts rendering speed. In addition, with some tools, very short intervals can introduce rendering glitches.

Of course we can use fixed_y_steps and sloppy_fixed_y_steps(..., adj_short_o=1) as we did in the previous section; however, sloppy_fixed_y_steps without the adj_short_o=1 argument that may be more useful. Without this option only steps longer than the target are adjusted.

Here is the result:

The solution used in the image above was created by this snippet of examples/lorenz.f90:

call fixed_y_steps(status, istats, solution, eq, y_iv, param, a, b, c, 1.0_rk, t_delta*7, t_max_o=t_max)
print '(a)', status_to_message(status)
call print_istats(status, istats)
call print_solution(status, solution, filename_o="lorenz_condy.csv", end_o=istats(1), t_min_o=50.0_rk)