Animate flow lines of time-dependent 3D dynamical system

Question

I've spent a bunch of time perusing Stack Exchange to try to find an answer and found nothing; hopefully this isn't a duplicate.

I have a time-dependent vector field $\Phi_t(x,y,z)=(x\lambda^t,y\lambda^{-t},z+t)$, $\lambda>1$ arbitrary; for my example, I'm restricting to the region $[0,1]\times[0,1]\times\mathbb{R}$. What I would like to do is:

• fix some $\lambda>1$;
• generate some number of random initial points;
• compute / store the orbits of these points over some length of time;
• plot these orbits in 3D with animation.

I've currently managed to do all of this except animate the flow lines.

Here's my current code:

seeds = RandomReal[{-1, 1}, {250, 3}]; (* 250 random initial points *)
lam = 1.5; (* \[Lambda]>1 fixed *)

func[{x_, y_, z_}, t_] := {x lam^t, y lam^(-t), z + t}; (* the vector field itself *)
orbit[k_] := Table[func[seeds[[k]], n], {n, 0, 9.75, 0.25}]; (* function to compute the orbit for a single initial point *)
orbits = orbit[#] & /@ Range[1, Length[seeds], 1]; (* computes orbits for all initial points *)

Graphics3D[{
    {Red, Arrowheads[{-.01, .01}], Arrow[BezierCurve[orbits[[#]]]] & /@ Range[1, Length[seeds], 1]}
}, PlotRange -> {{-1, 1}, {-1, 1}, {-1, 1}}, Boxed -> False, Axes -> True, AxesEdge -> {{-1, -1}, {-1, -1}, {-1, -1}}, ViewPoint -> {2.6056479300835718`, 2.1387445365836095`, 0.29388887642263006`}, ViewVertical -> {0.3985587476649791`, 0.332086389794556`, 0.8549090912915488`}, ImageSize -> 400]

Here's the output:

This is okay, but what I'd really like is something that can either

1. animate one entire flow line a little at a time, then the next flow line a little at a time, etc. (in the same plot); or
2. animate all flow lines simultaneously, a little at a time.

Can anyone help me with this?

Note: By defining an auxiliary function buildorbits[k_,n_]:=orbits[[k, 1 ;; n]];, I can animate single orbits using a very "hackish-feeling" implementation of ListAnimate. For instance:

; is this really my best option, though?

Answer 1

You can use ParametricPlot3D to get smoother orbits:

SeedRandom[1]
n = 50;
seeds = RandomReal[{-1, 1}, {n, 3}];
tbar = 10;

Animate[ParametricPlot3D[Evaluate[func[seeds[[#]], t] & /@ Range[Length@seeds]], 
   {t, 0, tmax}, 
    BoxRatios -> 1, 
    PlotStyle -> Arrowheads[Medium],
    ImageSize -> 400,
    PlotRange -> {{-60, 60}, {-1, 1}, {-10, 10}}] /. Line -> Arrow,
  {tmax, .01, tbar}]

Update: "Is there a way to use this this implementation to animate as all of orbit 1, followed by all of orbit 2, followed by....?"

colors = Table[Hue@RandomReal[], {n}];

Animate[ParametricPlot3D[Evaluate[ConditionalExpression[func[seeds[[#]], t - (#-1) tbar],
      (# - 1) tbar <= t <= # tbar] & /@ Range[n]], 
   {t, 0, tmax}, 
   BaseStyle -> Arrowheads[Medium], 
   BoxRatios -> 1, 
   ImageSize -> 400, 
   PlotStyle -> colors,
   PerformanceGoal -> "Quality", 
   PlotRange -> {{-50, 60}, {-1, 1}, {-5, 15}}] /. Line -> Arrow, 
 {tmax, .01, n tbar}, 
 AnimationRate -> 10]

Answer 2

Not exactly what was asked, but another way to visualize the flow, based on How can I create a fountain effect?:

DynamicModule[
 {x0, y0, z0, last = 0, lam = 1.5, n = 500, colors, replace},
 last = Clock[Infinity];
 {x0, y0, z0} = RandomReal[{-1, 1}, {3, n}];
 colors = RandomColor[n];

 Graphics3D[GraphicsComplex[
   Dynamic@ With[{t = Clock[Infinity]},
     With[{dt = (t - last)/2}, With[{dl = lam^dt},
       last = t;
       x0 = x0*dl; y0 = y0/dl; z0 = z0 + dt; (* integration of velocity *)
       replace = Pick[Range@n, UnitStep[z0 - 1], 1];
       x0[[replace]] = RandomReal[{-1, 1}, Length@replace];
       y0[[replace]] = RandomReal[{-1, 1}, Length@replace];
       z0[[replace]] = RandomReal[{-1, -1 + dt}, Length@replace];
       Transpose@{x0, y0, z0}
       ]]],
   Point[Range@n, VertexColors -> colors]], 
  PlotRange -> {{-2, 2}, {-2, 2}, {-1, 1}}, Axes -> True, 
  AxesLabel -> {x, y, z}],

 Initialization :> ({x0, y0, z0} = RandomReal[{-1, 1}, {3, n}])
 ]

The integration is based on the ODE for $\Phi$, which is autonomous and linear and can be done by scalings and translation: $${d \over dt}\,(x,y,z) = (x \log \lambda, -y \log \lambda, 1)$$