Localizing variables within a Manipulate

Question

I have a notebook with several examples of very similar computations, each involving the same variable/parameter names of the ingredients used in a final Manipulate. For example,

(* example 1 *)
c = 1;
L = 1;
f[x_] = 180 x^4 (1 - x);
g[x_] = 1;
\[Lambda][n_] = ((n \[Pi])/L)^2;
a[n_] = 2/L  Integrate[f[x] Sin[Sqrt[\[Lambda][n]] x], {x, 0, L}];
b[n_] = 2/(L Sqrt[\[Lambda][n]] c) Integrate[g[x] Sin[Sqrt[\[Lambda][n]] x], {x, 0, L}];
u[x_, t_] = Sum[(a[i] Cos[Sqrt[\[Lambda][i]] c t] + 
   b[i] Sin[Sqrt[\[Lambda][i]] c t]) Sin[Sqrt[\[Lambda][i]] x], {i, 1, 10}];

Manipulate[Plot[u[x, t], {x, 0, L}, PlotStyle -> {Thick, Blue}, PlotRange -> {-15, 15}, 
   AxesLabel -> {x, "u"}], {t, 0, 5}]

followed by

(* example 2 *)
k = .2;
L = 1;
f[x_] = 180 x (1 - x)^4;
\[Lambda][n_] = (((2 n - 1) \[Pi])/(2 L))^2;
b[n_] = 2/L  Integrate[f[x] Sin[Sqrt[\[Lambda][n]] x], {x, 0, L}];
u[x_, t_] = Sum[b[i] Sin[Sqrt[\[Lambda][i]] x] Exp[-\[Lambda][i] k t], {i, 1, 10}];

Manipulate[Plot[u[x, t], {x, 0, L}, PlotStyle -> {Thick, Blue}, PlotRange -> {-1, 16}, 
   AxesLabel -> {x, "u"}], {t, 0, 5}]

As discussed in the documentation, evaluating the second block of code dynamically updates the output of the first Manipulate since the underlying quantities being plotted share the name $u(x,t)$ (among other parts) in each.

My question then is, what are some good ways to mitigate this behavior other than:

1. Choosing distinct names for all underlying quantities for each problem. (This is intractable since I may have 10+ such exercises in each notebook.)
2. Disabling dynamic updating. (This is unsatisfying since the point here is to see the Manipulate "movies".)
3. Wrapping everything in a DynamicModule,

e.g.,

(* example 1a *)
DynamicModule[{a, b, c, f, g, L, \[Lambda], u},
 c = 1;
 L = 1;
 f[x_] = 180 x^4 (1 - x);
 g[x_] = 1;
 \[Lambda][n_] = ((n \[Pi])/L)^2;
 a[n_] = 2/L  Integrate[f[x] Sin[Sqrt[\[Lambda][n]] x], {x, 0, L}];
 b[n_] = 2/(L Sqrt[\[Lambda][n]] c) Integrate[g[x] Sin[Sqrt[\[Lambda][n]] x], {x, 0, L}];
 u[x_, t_] = Sum[(a[i] Cos[Sqrt[\[Lambda][i]] c t] + 
    b[i] Sin[Sqrt[\[Lambda][i]] c t]) Sin[Sqrt[\[Lambda][i]] x], {i, 1, 10}];

 Manipulate[Plot[u[x, t], {x, 0, L}, PlotStyle -> {Thick, Blue}, PlotRange -> {-15, 15}, 
    AxesLabel -> {x, "u"}], {t, 0, 5}]]

and then

(* example 2a *)
DynamicModule[{a, b, k, f, L, \[Lambda], u},
 k = .2;
 L = 1;
 f[x_] = 180 x (1 - x)^4;
 \[Lambda][n_] = (((2 n - 1) \[Pi])/(2 L))^2;
 b[n_] = 2/L  Integrate[f[x] Sin[Sqrt[\[Lambda][n]] x], {x, 0, L}];
 u[x_, t_] = Sum[b[i] Sin[Sqrt[\[Lambda][i]] x] Exp[-\[Lambda][i] k t], {i, 1, 10}];

 Manipulate[Plot[u[x, t], {x, 0, L}, PlotStyle -> {Thick, Blue}, PlotRange -> {-1, 16}, 
   AxesLabel -> {x, "u"}], {t, 0, 5}]]

This at least does what I am after: the variable/parameter names that are recycled across exercises are localized to its respective Manipulate. This just felt a little clunky and requires quite a bit of explanation to students about why we need to do this.

I was curious if there were other/better ways to accomplish this (that I could then share with them).

Answer 1

In your notebook, do the following:

• Separate the examples into cell groups. You can use, e.g., Section or Subsection cells to do this.
• Choose the menu item Evaluation->Notebook's Default Context->Unique to Each Cell Group.
• Re-evaluate your notebook.

You'll now get the code isolation you're looking for. By using the menu item I point out, you're instructing the FE to automatically create and manage a guaranteed-unique context name for each cell group. You can see the results of this by evaluating $Context in the various cell groups if you're interested in exploring how it works.

Note that, in addition to isolating the context, Mathematica also isolates the line numbering, the history (as accessible by %), and the context path (so a Needs called in one section will not make the package available to other sections or other notebooks).

Answer 2

I haven't looked at whether your code is optimal, just localized everything and made it look like a Manipulate

DynamicModule[{a, b, k, f, L, \[Lambda], u, t},
 k = .2;
 L = 1;
 f[x_] = 180 x (1 - x)^4;
 \[Lambda][n_] = (((2 n - 1) \[Pi])/(2 L))^2;
 b[n_] = 2/L Integrate[f[x] Sin[Sqrt[\[Lambda][n]] x], {x, 0, L}];
 u[x_, t_] = 
  Sum[b[i] Sin[Sqrt[\[Lambda][i]] x] Exp[-\[Lambda][i] k t], {i, 1, 
    10}];

 Panel@Column[{
    Row[{"t", Spacer[5], Manipulator[Dynamic[t], {0, 5}]}],
    Framed[
     Dynamic@Plot[u[x, t], {x, 0, L},
       ImageSize -> 400,
       PlotStyle -> {Thick, Blue},
       PlotRange -> {-1, 16},
       AxesLabel -> {"x", "u"}],
     Background -> White,
     FrameStyle -> LightGray,
     FrameMargins -> 10]
    }]
 ]