Simple multi-thread simulations

As I have stated in previous updates, we believe that a single-thread simulation --even one with a variable width-- is not a good representation of a river like the Missouri, for the following reasons:

• The MNRR is a wide river, and varies considerably in width, from a minimum of 186.79 m to a maximum of 1647.97 m, with a mean of 747.84 m, as digitized from 1957-1996 USGS topographic maps.
  
  
• The 59-mile segment of the MNRR from Gavins Point Dam to Kensler's bend contains numerous islands, bifurcations, and chutes, none of which can be accomodated by a single-thread model (and which partly account for the large width).
  
  
• In addition, the 'wild' river (prior to human intervention --see 1890 maps) is considerably braided in areas.
  
  
• Depending on water level, the MNRR contains many submerged or surface bars, and shallow areas near the banks and away from the actively flowing channel(s).
  
  
• We hypothesize that the width suggested by the banks is misleadingly large, and that the actual active, meandering, channel is much narrower, possibly on the order of from 400-800 m or narrower.
  
  
• It is clear that the MNRR bed does not have an idealized trapezoidal cross-stream profile, as is expected by the Johannesson-Parker and other meandering models.
  
  
• We further hypothesize that there may be several narrow, eroding, and sediment carrying 'cores' submerged within the observable banks and water surface of the MNRR, and that these multiple threads are responsible for the actual geometry and dynamics of the river.

To begin to explore the ideas listed above, I have created a very simple multiple thread simulation program derived from the MNRR simulation used previously. It combines the vector-based meandering approach we have been using with a cell or grid-based background which represents the depth of the river at every point (or, in this case, in every 50x50 m square):

Threads can meander as before (although in the simulations which follow, only simple curvature is used to produce thread migration --see discussion below). At present, threads interact only through the common depth of the water (again, see discussion below). The migration rate of each point on a thread is based on the depth of the water there. When a thread is surrounded by water of the same depth, it can migrate at the maximum rate. When the depth to one side (based on the depth of the next 'cell' in the direction of meandering) is less than that of the thread (possibly dry land), the migration rate is attenuated by a non-linear function having the following shape:

I must admit that I just made this function up; it didn't come from any well-defined theory. However, its shape is based on the following ideas:

• The function should not be linear.
• Migration should be easiest when the thread is surrounded by water at the same depth, and hardest (but not zero) when there is dry land to one side.
• Migration should be easier when the depth to one or both sides is similar to the thread depth, and progressively harder as the depth decreases. Depths near to zero should retard migration nearly as much as dry land.

In any case, it is easy to substitute another function mapping depth to migration rate, to see what the effect of different functions would be. I am also not modeling sediment transport. Migrating threads 'scour' the river bed to their depth in each cell they occupy. Depth of cells not occupied by a thread 'decay' at a constant exponential rate, typically 0.99 (i.e. depth(t + dt) = depth(t) * 0.99). This serves to simulate sedimentation without having to perform all the computational bookkeeping otherwise required.

Here is an example of a single thread meandering unconstrained. The color of the background indicates depth (blue = 0, red = 2.5 m, although the thread is also drawn in blue but is always at maximum depth). In this case, the thread goes everywhere at the maximum migration rate, and the depth remains constant over the extent of its motion. Loop cutoffs are removed as they happen, but are not accumulated since they occur in water. Both endpoints of the thread are fixed. Each small square of the grid is 100 m. Depths are saved for every 50 x 50 m sub-square. The thread is 25 m wide. Actually, the distances are unimportant, since the particular meandering model used does not make use of scaled physical quantities (e.g. flow volume), but only geometry. After each motion step, the thread is re-interpolated at 50 m resolution using circular arcs. In general, the length of the thread continues to increase during the simulation, except when cutoffs are removed:

Here is an example of an unconstrained thread meandering against a background whose depth decays at a rate of 0.99:

Here are two different examples of a single thread whose migration rate is constrained at each point along its length by the function shown above, depending on the depth of the water in the cells toward which the thread wishes to meander cross-stream. Thus, it is easier (faster) for the thread to meander toward deeper water, and harder (slower) for the thread to meander toward shallower water, or dry land. The depth of each cell occupied by the thread is set to 2.5 m, while the depths of all unoccupied cells decrease to depth(x, y, t) * 0.99 every dt, simulating the effect of re-sedimenting the river bed. Currently no effort is made to keep track of or balance the amount of sediment removed by the thread, or replaced by the decay effect:

Here is the example at left above shown as a color DEM, monochrome DEM with contour lines every 0.25 m, and as a 3d wire frame. Each DEM has been interpolated by 4x from the original 50 m grid. Note that the colors are reversed from the simulation program, so that red is ground level and blue is the deepest water. This is a more visualy appealing way to display the resulting river:

A single thead with depth-restricted motion and re-sedimentation will in general produce a gently meandering channel like this. Note that there are 2 kinds of migration going on: (1) The migration of the submerged thread, which in this case is given as a constant times the local curvature of the thread, where the value of the constant changes according to the depth of the water, and (2) the overall migration of the eroded chanel, which is in general both wider and considerably less sinuous than that of the thread. The meandering of the channel in (2) is not the result of any specifically programmed meandering model, but is an indirect, aggregate, emergent process resulting from the underlying action of the thread.

Here are two steps from the same simulation in which 3 threads of equal depth were initialized 'mostly' straight with slight random perturbations, 500 m apart. The final step configuration is also shown with depth contours and in 3d:

The threads migrate independently of one another, and interact only through the depth background. Nevertheless, there is a tendency for threads to synergistically merge and separate due to their combined effect on the depth of the bed, and to create a braided pattern which changes over time. Note again that the overall effect of several threads is to create a wide system of braids or multiple channels and islands which itself gently meanders across the landscape.

Simulations can also be performed with 5 (first series of plots) and 7 (second series of plots) independent threads having the same depth:

The threads don't need to be the same depth, and we expect that multiple threads in a river might be distributed in {x, y, z} space, so that they can pass one another without touching (in the current simulations, thread pair intersections are simply ignored). In the following 7 (left and right images) and 5 (center) thread simulations, threads are created with the following depths: {0.625 m, 1.25 m, 1.875 m, 2.5 m, 1.875 m, 1.25 m, 0.625 m} and {0.833 m, 1.666 m, 2.5 m, 1.666 m, 0.833 m}. Threads maintain a constant depth, and migrate at the maximum rate if the current depth is equal to or greater than their own. This adds an additional level of synergy, as a shallow thread can 'piggyback' over a deeper thread and move at the maximum rate while the deeper thread is attenuated by scouring the bottom. The threads have also been created 250 m apart (10x their width) rather than at 500 m. Simulations using threads at different depths have, in general (a) a single discernable thalweg, and (b) a more naturally sculpted basin:

Click HERE for a much larger imge of the 5 thread simulation (recommended).

Discussion

The simulations shown above are the simplest I could think of that make use of some of the work I have already done (and that I could reasonably accomplish in only 2 weeks). Obvious improvements to these might include the following:

• The threads need to meander by some physical mechanism other than simple curvature. Actually, there should probably be two such mechanisms: one when the thread is submerged and another when it is eroding a bank. The latter might be one of the speed-based methods such as JP89, etc... However, the mechanism for meandering within the submerged flow should probably be based on force rather than speed, in that a 'tube of water flowing within water' which creates expanding loops must:
  
  
  1. Perform work as its loops increase in size (as the changing radius entails a centripetal force which acts through a distance (the changing radius)). The energy for this expansion could come from 3 sources:
     
     
     1. The speed (kinetic energy) of the flow could slow, which, for an incompressible flow such as water, would require an increase in thread radius (cross-sectional area), moving against a depth pressure which would require an additional loss of speed, and cause the thread to 'die out' quite quicky. Since we are positing long-distance-stable threads, this is not a tenable mechanism, and we are 'axiomatically' requiring the thread speed to remain constant throughout its length.
     2. The thread could become colder (thermal energy). Actually, I suspect that this does happen, and I would like to see some relevant observations of flow speed, temperature, and depth.
     3. Primarily, the energy for thread motion comes from the gravitational (potential energy) difference between the river inlet and outlet. All of the simulations shown above were performed on a completely flat level plane, and assumed that the specified rate of water flow could be maintained by whatever means necessary.
     
     
  2. Provide a change in linear momentum as a thread of water changes direction, which must be accompanied by an equivalent change in momentum of the surrounding water (i.e. it affects the flow field downstream).
     
     
  3. Provide a change in angular momentum of a curved, expanding thread loop which must be accompanied by a torque at right angles to the momentum: i.e. the thread must also be helical along any length which is curved and accelerating (in direction), and changing in radius.
  
  
• The threads should interact with one another. Threads could cutoff one another, or they could 'crossover' like chromosomes at their intersections (in which segments of threads are exchanged). I know of no hydrodynamic reason they might attract or repel one another like electrical currents flowing through wires, but perhaps there is a way for them to close distance or merge along short segments. Threads must also be allowed to bifurcate and join.
  
  
• The threads should very their depth over time and distance, based on some mechanism which is different from that of {xy} meandering. Currently threads maintain a specific depth, without reason. Actual threads should be able to change their depth depending on bed geometry and other conditions (e.g. temperature and pressure). However, I suspect that the mechanism for varying thread depth in z is different from that of thread migration in x and y. Nevertheless, a suitable physical process should be sought.
  
  
• Sediment eroded by threads (or provided at inlets) should be tracked and used to 'decay' the downstream depth by exponential accumulation which is potentially different at each point. This might be based on the speed of flow, as determined by a manner discussed next. Simply, flow speed above an average or threshold would pick up sediment from the bed or banks, while flow below the average speed or another threshold would deposit a fraction of whatever sediment the flow is carrying at that point.
  
  
• Thread velocity should be used to extrapolate a 'flow field' over the entire depth domain, which should in turn be used to calculate sediment pickup, transport, and downflow accumulation. For example, previous and unrelated work (by Sky Coyote) has been used to calculate the flow of the atmosphere on Venus from Earth-based telescope images:
  
  
  
  A similar procedure could be used to calculate the vector flow (direction and magnitude) at every {x, y} or {x, y, z} point in the basin, both near to and away from the individual threads. With this field, additional calcultions concerning localized sediment buildup and removal, vorticity, and departure from laminar flow could be performed, or a solution to the Navier-Stokes equations could be performed.

Conclusion

This update represents the last of the 'real work' on the MNRR project. During December I will work only on the final report and website. Updates of work on the final report will be posted at the parent site as they are available. Nevertheless, I think this is a good conclusion to the project, as it clearly indicates what should be done next. This has been both an interesting and a worthwhile project to work on, and I hope that someone makes use of this work (or at least it helps me get another job! :-) ).