VC.11 3D Flow Along
 LITERACY

\(Off[General::spell]; 
Off[General::spell1]; 

    \(Off[ParametricPlot3D::ppcom]; \)\)Off[ParametricPlot::ppcom]; Off[Plot::plnr]; \(SetOptions[Limit, Analytic -> True]; 
$Pre\  = \ Chop; \)

CMView = {2.7, 1.6, 1.2};

Vector Drawer

BeginPackage["Vector3D`", "Graphics`Colors`"];

\(Axes3D::"usage" = 
      "Axes3D[a, b] creates a Graphics3D object of cartesian axes with x, y, and z running from -a/3 to a, and with axes labels b units beyond the tips of the axes.  Axes3D[a] is Axes3D[a, a/8]."; 

    \(Perpend::"usage" = 
      "Perpend[a] returns a unit vector which is perpendicular to the vector a."; \)\)Arrow::"usage" = 
      "Arrow[a] produces a 2 or 3 dimensional vector from the origin to a. \
Arrow[a, Tail -> tail] gives a vector from tail to a."; Vector::"usage" = 
      "Vector[a, b] gives a 2D or 3D vector from a to b."; ArrowHead::"usage" = 
      "ArrowHead[a, vec] produces an arrowhead with its tip placed at the \
point a, pointing in the direction of the vector vec."; Tail::"usage" = 
      "Tail -> point puts the tail of the vector at point."; Norm::"usage" = 
      "Norm[vec] returns the Euclidean length of vec."; Normalize::"usage" = 
      "Normalize[vec] returns a unit vector in the direction of vec, \
provided vec is nonzero."; Aperture::"usage" = 
      "Aperture is the ratio of the radius of the base to the length of the \
head of a vector."; TipSize::"usage" = 
      "TipSize specifies an absolute size for the inner tip length of the \
head of a vector."; TipRatio::"usage" = 
      "TipRatio is the ratio of the inner length of the arrowhead to the \
length of the shaft of a vector."; HeadRatio::"usage" = 
      "HeadRatio is the ratio of the outer length of the arrowhead to the \
length of the shaft of a vector."; HeadSize::"usage" = 
      "HeadSize specifies an absolute size for the head of a vector."; 
    ScaleFactor::"usage" = 
      "ScaleFactor specifies the amount to scale a vector in length and may \
be either a number or a pure function."; ZeroVectorPointSize::"usage" = 
      "ZeroVectorPointSize is the size of the point used to represent a \
zero vector."; Options[Vector] = 
      Options[Arrow] = 
        Options[ArrowHead] = {HeadRatio -> 0.18, 
            TipRatio -> 0.14, Aperture -> 0.3, 
            ScaleFactor -> 1, HeadType -> Polygon, 
            ShaftQ -> True, EdgesQ -> True, 
            VectorColor -> RGBColor[0, 0, 1], ShaftWidth -> 0.005, 
            ZeroVectorPointSize -> 0.01}; Begin["`Private`"]; SetOptions[ParametricPlot, AspectRatio -> Automatic]; SetOptions[Plot, AspectRatio -> Automatic]; SetOptions[Graphics, AspectRatio -> Automatic]; Axes3D[u_, v_] := 
      Graphics3D[{{Blue, Line[{{-(u/3), 0, 0}, {u, 0, 0}}]}, 
          Text["x", {u + v, 0, 0}], {Blue, 
            Line[{{0, -(u/3), 0}, {0, u, 0}}]}, 
          Text["y", {0, u + v, 0}], {Blue, 
            Line[{{0, 0, -(u/3)}, {0, 0, u}}]}, 
          Text["z", {0, 0, u + v}]}]; Axes3D[u_] := Axes3D[u, (u/8)]; Norm[a_?VectorQ] := N[(Sqrt[a . a])]; Normalize[a_?VectorQ] := If[a . a == 0, a, (a/Norm)[a]]; Perpend[a_?VectorQ] := 
      Normalize[{a[[2]], 
            -a[[1]]}] /; 
        Length[a] == 2Perpend[a_?VectorQ] := 
      Normalize[
          If[a[[1]] == 0, {1, 0, 0}, {0, 
              a[[3]], 
              -a[[2]]}]] /; 
        Length[a] == 3Base3D = 
      Table[{Cos[((2 k π)/8.) ], Sin[((2 k π)/8.) ]}, {k, 0, 
          8}]; Vector[from_?VectorQ, to_?VectorQ, opts___] := 
      Module[{sq, sw, ht, hs, hr, tr, ap, sf, vc, zvps, diff = to - from, 
            tip}, {sq, sw, ht, hs, hr, ts, tr, ap, sf, vc, zvps} = 
            {ShaftQ, ShaftWidth, HeadType, HeadSize, HeadRatio, TipSize, 
                  TipRatio, Aperture, ScaleFactor, VectorColor, 
                  ZeroVectorPointSize} /. {opts} /. Options[Vector]; 
          If[from == to, 
            Return[Graphics[{PointSize[zvps], vc, Point[from]}]]]; 
          diff = If[NumberQ[N[sf]], sf diff, sf[diff]]; tip = from + diff; 
          If[NumberQ[hs], hr = (hs/Norm)[diff]; tr = 0.75 hr]; 
          If[NumberQ[ts], tr = (ts/Norm)[diff]]; 
          Graphics[{
              If[sq, {vc, Thickness[sw], Line[{from, tip - tr diff}]}, {}], 
              With[{trans = ap hr Norm[diff] Perpend[diff]}, {vc, 
                  Thickness[sw], 
                  ht[{tip, tip - hr diff + trans, tip - tr diff, 
                      tip - hr diff - trans, tip}]}]}]] /; 
        Length[from] == Length[to] == 2Vector[from_?VectorQ, to_?VectorQ, opts___] := 
      Module[{sq, eq, sw, hs, hr, tr, ap, sf, vc, zvps, diff = to - from, 
            tip}, {sq, eq, sw, hs, hr, ap, sf, vc, zvps} = 
            {ShaftQ, EdgesQ, ShaftWidth, HeadSize, HeadRatio, Aperture, 
                  ScaleFactor, VectorColor, ZeroVectorPointSize} /. {opts}
                   /. Options[Vector]; 
          If[from == to, 
            Return[Graphics3D[{PointSize[zvps], vc, Point[from]}]]]; 
          diff = If[NumberQ[N[sf]], sf diff, sf[diff]]; tip = from + diff; 
          If[NumberQ[hs], hr = (hs/Norm)[diff]]; tr = (hr/2); 
          Graphics3D[{
              If[sq, {vc, Thickness[sw], Line[{from, tip - tr diff}]}, {}], 
              If[eq, {}, EdgeForm[]], {SurfaceColor[vc], 
                With[{temp = Perpend[diff]}, 
                  (Polygon[Append[#1, tip]]&)/@
                    Partition[
                      (tip - hr diff + #1&)/@
                        ((ap hr Norm[diff] Base3D) . {temp, 
                              Normalize[temp\[Cross]diff]}), 2, 1]]}}]] /; 
        Length[from] == Length[to] == 3Arrow[a_, Tail -> b_, opts___] := Vector[b, a + b, opts]Arrow[a_, opts___] := Vector[Table[0, {Length[a]}], a, opts]\(ArrowHead[a_, b_, opts___] := 
      Vector[a - b, a, ShaftQ -> False, opts]; 

End[]; 

    \(EndPackage[]; \)\)

Graphics`Colors`GosiaGreen = RGBColor[0,  0.392187,  0];

Spherical Setup

\(Clear[polar]; 

    polar[{x_, y_, z_}] := {\@\(x\^2 + y\^2 + z\^2\), ArcTan[y\/x], 
        ArcCos[z\/\@\(x\^2 + y\^2 + z\^2\)]}; 
Clear[X, length]; 

    length[X_] := \@\(X . X\); 
\(rr = 3; \)\)R = 5; scale = 0.8; red = RGBColor[1, 0, 0]; blue = RGBColor[0, 0, 1]; color1 = RGBColor[0.8, 0.2, 0.8]; color2 = RGBColor[0.2, 0.8, 0.2]; black = RGBColor[0, 0, 0]; \(Clear[axes]; 

    axes := Graphics3D[{Line[{X, {1.5\ rr, 0, 0}}], 
          Line[{X, {0, 1.5\ rr, 0}}], Line[{X, {0, 0, 2\ rr}}]}]; 

    Clear[xyplane]; 

    xyplane := 
      Graphics3D[
        Polygon[{{\(-2\)\ rr, \(-2\)\ rr, 0}, {\(-2\)\ rr, 2\ rr, 0}, {2\ rr, 
              2\ rr, 0}, {2\ rr, \(-2\)\ rr, 0}}]]; 
\(X = {0, 0, 0}; \)\)origin = Graphics3D[{black, Point[X]}]; Z = {2, 3, 5}; \(Clear[point]; 

    point := Graphics3D[{red, PointSize[0.03], Point[scale\ Z]}]; 

    \(Z0 = {0, 0, length[0.8\ Z]}; \)\)\(Clear[zpoint]; 
zpoint = Graphics3D[{black, Point[Z0]}]; 

    \(XY = scale\ Z\ {1, 1, 0}; \)\)\(Clear[xypoint]; 
xypoint := Graphics3D[{black, Point[XY]}]; 

    \(X0 = {length[scale\ Z\ {1, 1, 0}], 0, 0}; \)\)xpoint = Graphics3D[{black, Point[X0]}]; Y0 = {0, length[scale Z {1, 1, 0}], 0}; ypoint = Graphics3D[{black, Point[Y0]}]; \(Clear[ray]; 
ray := Graphics3D[{blue, Line[{X, scale\ Z}]}]; 

    Clear[ray1]; 
ray1 := Graphics3D[{color1, Line[{scale\ Z, Z}]}]; 

    Clear[xyray]; 
xyray := Graphics3D[{red, Line[{X, Z\ {1, 1, 0}}]}]; 

    \(rays := {ray, xyray}; \)\)xyaux = 
      (length[0.8 Z] (0.8 Z {1, 1, 0}))/
        length[0.8 Z {1, 1, 0}]; \(Clear[zarc]; 

    zarc = Graphics3D[{blue, 
          Line[Table[
              \(Cos[t]\ \) {0, 0, length[0.8\ Z]} + Sin[t]\ xyaux, {t, 0, 
                \(polar[0.8\ Z]\)[[3
                  ]],  .1}]]}]; 
Clear[zarc1]; 

    zarc1 = Graphics3D[{color1, 
          Line[Table[
              \(Cos[t]\ \) {0, 0, length[0.8\ Z]} + Sin[t]\ xyaux, {t, 
                \(polar[0.8\ Z]\)[[3]], 
                1,  .1}]]}]; 
Clear[zarc2]; 

    zarc2 = Graphics3D[{color1, 
          Line[Table[
              \(Cos[t]\ \) {0, 0, length[0.8\ Z]} + Sin[t]\ xyaux, {t, 
                \(-0.8\), 0,  .1}]]}]; 
Clear[xyarc]; 

    xyarc = Graphics3D[{blue, 
          Line[Table[
              Cos[t]\ X0 + Sin[t]\ Y0, {t, 0, 
                \(polar[XY]\)[[2
                  ]],  .1}]]}]; 
Clear[xyarc1]; 

    xyarc1 = Graphics3D[{color1, 
          Line[Table[Cos[t]\ X0 + Sin[t]\ Y0, {t, \(- .5\), 0,  .1}]]}]; 

    Clear[xyarc2]; 

    xyarc2 = Graphics3D[{color1, 
          Line[Table[
              Cos[t]\ X0 + Sin[t]\ Y0, {t, 
                \(polar[XY]\)[[2]], 
                \(polar[XY]\)[[2]] + 
                  0.3,  .1}]]}]; 
Clear[stick]; 

    stick = Graphics3D[{red, Line[{scale\ Z, XY}]}]; 

    \(xaxislabel = Text["x", {0.363, 0.26}]; \)\)yaxislabel = Text["y", {0.73, 0.3}]; zaxislabel = Text["z", { .5, 0.67}]; stickplot = 
      Show[xyplane, axes, ray, point, Boxed -> False, 
        ViewPoint -> {2.747, 1.594, 1.168}, 
        Epilog -> {xaxislabel, yaxislabel, zaxislabel}, 
        DisplayFunction -> Identity]; rho = Text["r", {0.53, 0.45}]; rlabel = 
      Show[xyplane, axes, ray, point, Boxed -> False, 
        ViewPoint -> {2.747, 1.594, 1.168}, 
        Epilog -> {rho, xaxislabel, yaxislabel, zaxislabel}, 
        DisplayFunction -> Identity]; phi = Text["s", {0.55, 0.57}]; slabel = 
      Show[xyplane, zpoint, axes, ray, point, zarc, zarc1, zarc2, 
        Boxed -> False, ViewPoint -> {2.747, 1.594, 1.168}, 
        Epilog -> {phi, xaxislabel, yaxislabel, zaxislabel}, 
        DisplayFunction -> Identity]; theta = Text["t", { .5, 0.3}]; tlabel = 
      Show[xyplane, axes, xypoint, xpoint, ray, stick, point, xyarc, xyarc1, 
        xyarc2, Boxed -> False, ViewPoint -> {2.747, 1.594, 1.168}, 
        Epilog -> {theta, xaxislabel, yaxislabel, zaxislabel}, 
        DisplayFunction -> Identity]; all = 
      Show[xyplane, axes, ray, stick, point, zpoint, xpoint, xypoint, xyarc, 
        xyarc1, xyarc2, zarc, zarc1, zarc2, Boxed -> False, 
        ViewPoint -> {2.747, 1.594, 1.168}, 
        Epilog -> {theta, phi, rho, xaxislabel, yaxislabel, zaxislabel}, 
        DisplayFunction -> Identity];

Crisscross

\(Clear[x]; 

    crisscross = 
      Plot[{Cos[x], Sin[x]}, {x, π\/8, \(3\ π\)\/8}, 
        PlotStyle -> {{RGBColor[1, 0, 0], Thickness[0.02]}}, 
        Axes -> None, AspectRatio -> 1\/3, 
        DisplayFunction -> Identity]; \)

L.1)

A 3D vector field 
       Field[x, y, z] = {m[x, y, z], n[x, y, z], p[x, y, z]}
comes into your hands. You calculate curlField[1, 0, 0] and learn 
       curlField[1, 0, 0] = {-2, 0, 1}. 
You stick the tail of the unit vector 
       V = {(1/(Sqrt[2])), (1/(Sqrt[2])), 0}
at the point {1, 0, 0} and push your finger onto V so that V spikes through the center of your finger, and the tip of your finger is at {1, 0, 0}.  Does the tip of your finger feel a net clockwise or counterclockwise swirl?
What happens when you take 
       V = {0, (1/(Sqrt[2])), (1/(Sqrt[2]))}?
What unit vector V do you take if you want to feel the biggest possible net counterclockwise swirl at the point {1, 0, 0}?
What unit vector V do you take if you want to feel the biggest possible net clockwise swirl at the point {1, 0, 0}?

L.2)

You are given a certain 3D vector field Field[x, y, z]. 
You calculate curlField[1, 2, 1] and show it with a little disk plotted in the plane through {1, 2, 1} that is perpendicular to curlField[1, 2, 1].  
It turns out like this:

\(Clear[r, t, P]; 
k = 1.0; 

    \(P[t_, r_] = {1, 2, 1} + r\ Cos[t]\ {Cos[k]\/\@2, Sin[k], Cos[k]\/\@2} + 
        r\ Sin[t]\ {Sin[k]\/\@2, \(-Cos[k]\), Sin[k]\/\@2}; \)\)disk = 
      ParametricPlot3D[P[t, r], {t, 0, 2 π}, {r, 0, 0.2}, 
        PlotPoints -> {Automatic, 2}, DisplayFunction -> Identity]; 
    curl = 
      Det[{{i, j, k}, {Cos[k]/(Sqrt[2]), Sin[k], Cos[k]/(Sqrt[2])}, {Sin[k]/(Sqrt[2]), 
              -Cos[k], Sin[k]/(Sqrt[2])}}] /. {i -> {1, 0, 0}, 
          j -> {0, 1, 0}, k -> {0, 0, 1}}setup = 
      Show[disk, Graphics3D[{PointSize[0.03], Point[{1, 2, 1}]}], 
        Arrow[2 curl, Tail -> {1, 2, 1}], Boxed -> False, 
        ViewPoint -> CMView, 
        AxesLabel -> {"x", "y", "z"}, PlotRange -> All, 
        DisplayFunction -> $DisplayFunction];

From this viewpoint, the disk does not block your view of any part of the vector.  The question is, which of the following plots do you expect to indicate the direction of the net flow of the given vector field along the boundary curve of the disk?

\(Clear[tan]; 
tan[t_] = ∂\_t P[t, 0.2]; 

    \(tans = Table[
        Arrow[2\ tan[t], Tail -> P[t, 0.2]], {t, 0, 2\ π, 
          π\/4}]; \)\)counterclock = 
      Show[setup, tans, Axes -> None, DisplayFunction -> Identity]; 
    negtans = 
      Table[Arrow[-2 tan[t], Tail -> P[t, 0.2]], {t, 0, 2 π, 
          (π/4)}]; clock = 
      Show[setup, negtans, Axes -> None, 
        DisplayFunction -> Identity]; Show[GraphicsArray[{counterclock, clock}]];

L.3)

Here is a calculation of 
       curlField[0.3, 0.9, 0.2] . V
for a given 3D vector field and a given unit vector V:

V = {0.205092, 0.489097, 0.847774}; \(Clear[Field, x, y, z, m, n, p, curlField]; 

    Field[x_, y_, z_] = {x, \(-y\), z}\/\(x\^2 + y\^2 + z\^2\); 

    \({m[x_, y_, z_], n[x_, y_, z_], p[x_, y_, z_]} = Field[x, y, z]; \)\)\(curlField[x_, y_, z_] = {D[p[x, y, z], y] - D[n[x, y, z], z], 
        D[m[x, y, z], z] - D[p[x, y, z], x], 
        D[n[x, y, z], x] - D[m[x, y, z], y]}; 

    curlField[0.3, 0.9, 0.2] . V\)

When you push your finger onto V so that V spikes through the center of your finger, and the tip of your finger is at {0.3, 0.9, 0.2}, does the tip of your finger feel a net clockwise or net counterclockwise swirl?

L.4)

Here's a surface shown with a selection of normal vectors with tails planted at the points at which the normals are calculated:

\(Clear[x, y, z, s, t]; 
x[s_, t_] = 2\ s\ Cos[t]; 

    \(y[s_, t_] = 2\ s\ Sin[t]; \)\)z[s_, t_] = 1 - Sin[((π s)/2)]; {{slow, shigh}, {tlow, thigh}} = {{0, 1}, {0, 2 π}}; surface = 
      ParametricPlot3D[
        Evaluate[{x[s, t], y[s, t], z[s, t]}], {s, slow, shigh}, {t, tlow, 
          thigh}, DisplayFunction -> Identity]; \(Clear[normal]; 

    normal[s_, t_] = 
      N[Det[{{i, j, k}, ∂\_s{x[s, t], y[s, t], z[s, t]}, 
              ∂\_t{x[s, t], y[s, t], z[s, t]}}] /. {
            i -> {1, 0, 0}, j -> {0, 1, 0}, k -> {0, 0, 1}}]; 
    
\(sjump = 0.2; \)\)tjump = (π/4); scalefactor = 0.2; normals = 
      Table[Arrow[scalefactor normal[s, t], 
          Tail -> {x[s, t], y[s, t], z[s, t]}], {s, slow + sjump, shigh, 
          sjump}, {t, tlow + tjump, thigh, tjump}]; Show[surface, normals, 
      Graphics3D[Text["surface and selection of normals", {0, 0, 1.5}]], 
      PlotRange -> All, ViewPoint -> CMView, Boxed -> False, 
      AxesLabel -> {"x", "y", "z"}, 
      DisplayFunction -> $DisplayFunction];

Here's the same surface shown with a selection of curlField[x, y, z] vectors for a certain 3D vector field, Field[x, y, z], with tails planted at the same place the tails of the normal vectors are planted above:

sjump = 0.2; tjump = (π/4); scalefactor = 0.2; curls = 
      Table[Arrow[scalefactor {0, 0, 2 z[s, t] + 2}, 
          Tail -> {x[s, t], y[s, t], z[s, t]}], {s, slow + sjump, shigh, 
          sjump}, {t, tlow + tjump, thigh, tjump}]; Show[surface, curls, 
      Graphics3D[Text["surface and selection of curls", {0, 0, 1.7}]], 
      PlotRange -> All, ViewPoint -> CMView, Boxed -> False, 
      AxesLabel -> {"x", "y", "z"}, 
      DisplayFunction -> $DisplayFunction];

Here they are together:

Show[surface, curls, normals, 
      Graphics3D[
        Text["surface and selection of curls and normals", {0, 0, 1.7}]], 
      PlotRange -> All, ViewPoint -> CMView, Boxed -> False, 
      AxesLabel -> {"x", "y", "z"}, 
      DisplayFunction -> $DisplayFunction];

On the basis of these two plots, which of the following plots do you expect to indicate the direction of the net flow of the given 3D vector field along the boundary curve of the surface?

\(Clear[tan, P]; 
P[t_] = {x[shigh, t], y[shigh, t], z[shigh, t]}; 

    \(tan[t_] = ∂\_t P[t]; \)\)tans = 
      Table[Arrow[tan[t], Tail -> P[t]], {t, 0, 2 π, (π/4)}]; 
    counterclock = 
      Show[surface, tans, Ticks -> None, 
        AxesLabel -> {"x", "y", "z"}, 
        ViewPoint -> CMView, DisplayFunction -> Identity]; negtans = 
      Table[Arrow[-tan[t], Tail -> P[t]], {t, 0, 2 π, 
          (π/4)}]; clock = 
      Show[surface, negtans, Ticks -> None, 
        AxesLabel -> {"x", "y", "z"}, 
        ViewPoint -> CMView, DisplayFunction -> Identity]; Show[GraphicsArray[{counterclock, clock}]];

L.5)

Here's a calculation of 
       curlField[x, y, z]
for a a given 3D vector field:

\(Clear[Field, x, y, z, m, n, p, curlField]; 

    Field[x_, y_, z_] = {x\^2, y\^2, z\^2}; 
    
{m[x_, y_, z_], n[x_, y_, z_], p[x_, y_, z_]} = Field[x, y, z]; 


    curlField[x_, y_, z_] = {D[p[x, y, z], y] - D[n[x, y, z], z], 
        D[m[x, y, z], z] - D[p[x, y, z], x], 
        D[n[x, y, z], x] - D[m[x, y, z], y]}\)

Is there any way to stick your finger into this vector field so that the tip of your finger feels a net clockwise or net counterclockwise swirl?  How do you know?

L.6)

You are given a certain 3D vector field
       Field[x, y, z] = {m[x, y, z], n[x, y, z], p[x, y, z]},
and learn that no matter what point {x, y, z} you go with, curlField[x, y, z] points in the same direction as {0, 0, 1}. 
You drop some paddle wheels into the flow represented by this vector field so that the axis of each paddle wheel is parallel to the vector {0, 0, 1} like this:

{slow, shigh} = {0, 0.1}; {hlow, hhigh} = {-0.1, 0.1}; point1 = {0.5, 0, 0}; point2 = {0, 0.5, 0}; point3 = {0, 0, 0.5}; point4 = {0, 0, 0}; Show[
      Table[Graphics3D[
          Polygon[{point1 + {slow Cos[t], slow Sin[t], hlow}, 
              point1 + {shigh Cos[t], shigh Sin[t], hlow}, 
              point1 + {shigh Cos[t], shigh Sin[t], hhigh}, 
              point1 + {slow Cos[t], slow Sin[t], hhigh}}]], {t, 0, 
          2 π, (π/4)}], 
      Table[Graphics3D[
          Polygon[{point2 + {slow Cos[t], slow Sin[t], hlow}, 
              point2 + {shigh Cos[t], shigh Sin[t], hlow}, 
              point2 + {shigh Cos[t], shigh Sin[t], hhigh}, 
              point2 + {slow Cos[t], slow Sin[t], hhigh}}]], {t, 0, 
          2 π, (π/4)}], 
      Table[Graphics3D[
          Polygon[{point3 + {slow Cos[t], slow Sin[t], hlow}, 
              point3 + {shigh Cos[t], shigh Sin[t], hlow}, 
              point3 + {shigh Cos[t], shigh Sin[t], hhigh}, 
              point3 + {slow Cos[t], slow Sin[t], hhigh}}]], {t, 0, 
          2 π, (π/4)}], 
      Table[Graphics3D[
          Polygon[{point4 + {slow Cos[t], slow Sin[t], hlow}, 
              point4 + {shigh Cos[t], shigh Sin[t], hlow}, 
              point4 + {shigh Cos[t], shigh Sin[t], hhigh}, 
              point4 + {slow Cos[t], slow Sin[t], hhigh}}]], {t, 0, 
          2 π, (π/4)}], Axes -> True, 
      AxesLabel -> {"x", "y", "z"}, 
      ViewPoint -> CMView];

How do you know in advance that the flow represented by the given vector field will make these paddle wheels rotate?  Which way will they rotate?
How about in the case that curlField[x, y, z] points in the same direction as {0, 0, -1} at all points {x, y, z}?

L.7)

You are given a 3D vector field
       Field[x, y, z] = {m[x, y, z], n[x, y, z], p[x, y, z]},
and learn that no matter what point {x, y, z} you go with, curlField[x, y, z] points in the same direction as {0, 0, 1}. 
You drop some small paddle wheels into the flow represented by this vector field so that the axis of each paddle wheel is parallel to the vector {0, 1, 0} like this:

{slow, shigh} = {0, 0.1}; {hlow, hhigh} = {-0.1, 0.1}; point1 = {0.5, 0, 0}; point2 = {0, 0.5, 0}; point3 = {0, 0, 0.5}; point4 = {0, 0, 0}; Show[
      Table[Graphics3D[
          Polygon[{point1 + {slow Cos[t], hlow, slow Sin[t]}, 
              point1 + {shigh Cos[t], hlow, shigh Sin[t]}, 
              point1 + {shigh Cos[t], hhigh, shigh Sin[t]}, 
              point1 + {slow Cos[t], hhigh, slow Sin[t]}}]], {t, 0, 
          2 π, (π/4)}], 
      Table[Graphics3D[
          Polygon[{point2 + {slow Cos[t], hlow, slow Sin[t]}, 
              point2 + {shigh Cos[t], hlow, shigh Sin[t]}, 
              point2 + {shigh Cos[t], hhigh, shigh Sin[t]}, 
              point2 + {slow Cos[t], hhigh, slow Sin[t]}}]], {t, 0, 
          2 π, (π/4)}], 
      Table[Graphics3D[
          Polygon[{point3 + {slow Cos[t], hlow, slow Sin[t]}, 
              point3 + {shigh Cos[t], hlow, shigh Sin[t]}, 
              point3 + {shigh Cos[t], hhigh, shigh Sin[t]}, 
              point3 + {slow Cos[t], hhigh, slow Sin[t]}}]], {t, 0, 
          2 π, (π/4)}], 
      Table[Graphics3D[
          Polygon[{point4 + {slow Cos[t], hlow, slow Sin[t]}, 
              point4 + {shigh Cos[t], hlow, shigh Sin[t]}, 
              point4 + {shigh Cos[t], hhigh, shigh Sin[t]}, 
              point4 + {slow Cos[t], hhigh, slow Sin[t]}}]], {t, 0, 
          2 π, (π/4)}], Axes -> True, 
      AxesLabel -> {"x", "y", "z"}, 
      ViewPoint -> CMView];

How do you know in advance that the flow represented by the given vector field will not make these paddle wheels rotate?

L.8)

For a given 3D vector field
       Field[x, y, z] = {m[x, y, z], n[x, y, z], p[x, y, z]},
you calculate 
       \(curlField[x, y, z] = 

        	{D[p[x, y, z], y] - \ D[n[x, y, z], z], 
		
          D[m[x, y, z], z] - \ D[p[x, y, z], x], 
		
          D[n[x, y, z], x] - \ D[m[x, y, z], y]}\).
You are asked to manufacture your own choice of special functions m[x, y, z], n[x, y, z] and p[x, y, z] so that no matter what point {x, y, z} you go with, 
       curlField[x, y, z] = {0, 0, positive}. 
In other words, no matter what point {x, y, z} you go with, curlField[x, y, z] points in the same direction as {0, 0, 1}. 
How would you align paddle wheels to be driven by the flow?

L.9)

What is the gradient test for a 3D vector field?

L.10)

You are given a certain 3D vector field
       Field[x, y, z] = {m[x, y, z], n[x, y, z], p[x, y, z]},
with the extra information that it is a gradient field.
Is there any way to drop a small paddle wheel into the flow represented by this vector field and align it so that the given vector field will make the paddle rotate? (Assume no singularities.)

L.11)

Is there any way to stick your finger into the flow described by a 3D gradient field so that the tip of your finger feels a net clockwise or net counterclockwise swirl?  How do you know? (Assume no singularities.)

L.12)

Take a surface R with boundary curve C.  If you are given a 3D vector field Field[x, y, z] with the extra property that       
       curlField[x, y, z]  
is tangent to the surface R at all points {x, y, z} on the surface R, then how do you use Stokes's formula to tell you once and for all the net flow of Field[x, y, z] along C is 0?

L.13)

The curve C is parameterized by
       {x[t], y[t], z[t]} = {2  (t^2), 2 +  (t^2), 1 -  (t^2)}  
with 0 ≤ t ≤ 2.
This tells you that C starts at {0, 2, 1} and ends at {8, 6, -3}.
Measure the flow of the 3D vector field
       Field[x, y, z] = {z, y, x} 
along C and interpret the result. 
Use hand calculation to determine whether the net flow of Field[x, y, z] along C is in the direction of the parameterization, or against the direction of the parameterization.

L.14)

You plot a surface R and you get:

\(Clear[x, y, z, s, t]; 
x[s_, t_] = 2\ s\ Sin[t]; 

    \(y[s_, t_] = 4\ s\ Cos[t]; \)\)z[s_, t_] = Sin[x[s, t] - y[s, t]]; surface = 
      ParametricPlot3D[{x[s, t], y[s, t], z[s, t]}, {s, 0, 1}, {t, 0, 
          2 π}, PlotPoints -> {Automatic, 48}, Boxed -> False, 
        PlotRange -> All, ViewPoint -> CMView, 
        AxesLabel -> {"x", "y", "z"}, 
        DisplayFunction -> $DisplayFunction];

Then you parameterize the boundary curve of R, plot a few tangents to see the direction your parameterization takes, and you get:

\(Clear[P]; 
P[t_] = {x[1, t], y[1, t], z[1, t]}; 

    \(Cplot = 
      ParametricPlot3D[Evaluate[P[t]], {t, 0, 2\ π}, 
        DisplayFunction -> Identity]; \)\)tangents=Table[Arrow[0.5 P'[t],Tail -> P[t]],{t, (π/8), 2 π, (π/8)}];Show[surface, Cplot, tangents, Boxed -> False, 
      PlotRange -> All, ViewPoint -> CMView, 
      AxesLabel -> {"x", "y", "z"}, 
      DisplayFunction -> $DisplayFunction];

If you want to call your parameterization of the boundary curve counterclockwise in accordance with the agreement made to understand the meaning of Stokes's formula, then which side of the surface must you designate as the top side?

L.15)

A 3D vector field 
       Field[x, y, z] = {m[x, y, z], n[x, y, z], p[x, y, z]} 
comes into your hands. You are given two curves (Subscript[C, 1]) and (Subscript[C, 2]), both parameterized to start at a given point {(Subscript[a, s]), (Subscript[b, s]), (Subscript[c, s])} and end at a given point {(Subscript[a, e]), (Subscript[b, e]), (Subscript[c, e])} You calculate curlField[x, y, z] and are pleased to find that 
       curlField[x, y, z] = {0, 0, 0} 
at all points {x, y, z}. 
What is the relationship between the flow along the curve measurements
       (∫_( (Subscript[C, 1])))m[x, y, z] dx  +  
        n[x, y, z] dy  +  p[x, y, z] dz
and
       (∫_( (Subscript[C, 2])))m[x, y, z] dx  +  
        n[x, y, z] dy  +  p[x, y, z] dz?
Do you expect this relationship to hold up in the case that curlField[x, y, z] is not {0, 0, 0} at all points {x, y, z}?

L.16)

Here is the 3D electric field resulting from an electrical charge of strength q placed at a point {a, b, c}:

\(Clear[x, y, z, m, n, p, a, b, c, Field]; 
    
{m[x_, y_, z_], n[x_, y_, z_], p[x_, y_, z_]} = 
      \(q\ \(({x, y, z} - {a, b, c})\)\)\/\((
            \((x - a)\)\^2 + \((y - b)\)\^2 + \((z - c)\)\^2)\)\^\(3/2\)\)

Here is a calculation of DivField[x, y, z]:

Together[D[m[x, y, z], x] + D[n[x, y, z], y] + D[p[x, y, z], z]]

And here is a calculation of curlField[x, y, z]:

{D[p[x, y, z], y] - D[n[x, y, z], z], 
      D[m[x, y, z], z] - D[p[x, y, z], x], 
      D[n[x, y, z], x] - D[m[x, y, z], y]}

Discuss what information you get from these two calculations.

L.17)

Write down Stokes's formula and say how the formula is to be interpreted.

L.18)

If C is a closed curve in three dimensions, and 
       Field[x, y, z] = {m[x, y, z], n[x, y, z], p[x, y, z]} 
with 
       curlField[x, y, z] = {0, 0, 0} 
at all points, then what is the flow along C measurement
       (∮_( C)) m[x, y, z] dx  +  
        n[x, y, z] dy  +  p[x, y, z] dz?
How does Stokes's formula help you to back up your answer?

L.19)

A force field 
       Field[x, y, z] = {m[x, y, z], n[x, y, z], p[x, y, z]} 
comes into your hands. You are required to send an object through this force field starting at a given point {(Subscript[a, s]), (Subscript[b, s]), (Subscript[c, s])} and ending at a given point {(Subscript[a, e]), (Subscript[b, e]), (Subscript[c, e])}.  You can send the object along any curve C you desire, provided it is parameterized to start at {(Subscript[a, s]), (Subscript[b, s]), (Subscript[c, s])} and to end at {(Subscript[a, e]), (Subscript[b, e]), (Subscript[c, e])}.
Naturally you want to pick the curve C that makes the force field do as much of the work as possible.
You evaluate curlField[x, y, z], and are pleased to find that 
       curlField[x, y, z] = {0, 0, 0} 
at all points {x, y, z}.  Armed with this information, you say, "What the hell, I'll send it on a straight line segment running from 
{(Subscript[a, s]), (Subscript[b, s]), (Subscript[c, s])} to {(Subscript[a, e]), (Subscript[b, e]), (Subscript[c, e])}."
Why are you right?
Why does picking the right curve become much more complicated if curlField[x, y, z] is not {0, 0, 0} at all points {x, y, z}?

L.20)

Lots of folks say that a three-dimensional vector field 
       Field[x, y, z] = {m[x, y, z], n[x, y, z], p[x, y, z]} 
represents ideal fluid flow if
       divField[x, y, z] = 0 
and 
       curlField[x, y, z] = {0, 0, 0} 
at all points {x, y, z}. What do these folks have in mind?

L.21)

Is a 3D parallel flow necessarily irrotational?
Is a 3D gradient flow necessarily irrotational?

L.22)

Give a hand calculation of curlField[x, y, z] by calculating
       ∇×Field[x, y, z] 
for Field[x, y, z] = {x, y, z}.

L.23)

Calculate 
       ∇ . Field[x, y, z] 
for Field[x, y, z] = {x, y, z} by hand, and interpret the result in terms of divField[x, y, z].

L.24)

Calculate the Laplacian 
       △f[x, y, z] = ∇ . ∇f[x, y, z] 
for 
       f[x, y, z] = (e^x) Cos[y] +  (z^2) 
by hand, and interpret the result in terms of 
       (∂^2)f[x, y, z]/∂(x^2)+ (∂^2)f[x, y, z]/∂(y^2)+ (∂^2)f[x, y, z]/∂(z^2),
and the divergence of the gradient field of f[x, y, z].