Inefficient Manipulate code with plots and integrals

Question

I did this manipulation piece based on Boltzmann distribution but I noticed that is rather slow, any ideas how to improve this code?

kb = 1.381*10^-23;
Nav = 6.022*10^23;
m = 0.032/Nav;

Manipulate[
  Show[
     Plot[(E^(-((m v^2)/(2 kb T))) Sqrt[2/π] v^2)/((kb T)/m)^(3/2), {v, 0, 4000}, 
       PlotRange -> {{0, 1300}, {0, 0.0055}}, 
       AxesLabel -> {"m/s", "Frequency"}, 
       Epilog -> 
         Inset[Framed[
           Style[
             Integrate[(
               E^(-((m v^2)/(2 kb T))) Sqrt[2/π] v^2)/((kb T)/m)^(3/2), 
               {v, a, Infinity}] /
             Integrate[(
               E^(-((m v^2)/(2 kb T))) Sqrt[2/π] v^2)/((kb T)/m)^(3/2), 
               {v, 0, Infinity}]*100, 
             10]]]], 
     Plot[(E^(-((m v^2)/(2 kb T))) Sqrt[2/π] v^2)/((kb T)/m)^(3/2), {v, a, 1300}, 
       PlotRange -> {{0, 1300}, {0, 0.0055}}, 
       Filling -> Bottom]], 
  {T, 50, 500}, 
  {a, 0, 1300}]

Answer 1

Actually, g[a,T] have analytic expression.

Integrate[f[v, T], {v, a, Infinity}, Assumptions -> T > 0]

$$1.\, -\frac{1. \sqrt{a^2} \text{erf}\left(0.0438624 \sqrt{\frac{a^2}{T}}\right)}{a}+\frac{0.0494935 a e^{-\frac{0.00192391 a^2}{T}}}{\sqrt{T}}$$

Integrate[f[v, T], {v, 0, Infinity}, Assumptions -> T > 0]

1

kb = 1.381*10^-23;
Nav = 6.022*10^23;
m = 0.032/Nav;
f[v_, T_] = (E^(-((m v^2)/(2 kb T))) Sqrt[2/π] v^2)/((kb T)/m)^(3/
      2);
g[a_, T_] = Integrate[f[v, T], {v, a, Infinity}, Assumptions -> T > 0 && a>0];
Manipulate[
 Show[Plot[f[v, T], {v, 0, 4000}, 
   PlotRange -> {{0, 1300}, {0, 0.0055}}, 
   AxesLabel -> {"m/s", "Frequency"}, 
   Epilog -> Inset[Framed[Style[g[a, T]*100, 10]]]], 
  Plot[f[v, T], {v, a, 1300}, PlotRange -> {{0, 1300}, {0, 0.0055}}, 
   Filling -> Bottom]], {T, 50, 500}, {a, 0, 1300}]

Another way is use NIntegrate instead of Integrate .

kb = 1.381*10^-23;
Nav = 6.022*10^23;
m = 0.032/Nav;
f[v_, T_] = (E^(-((m v^2)/(2 kb T))) Sqrt[2/π] v^2)/((kb T)/
      m)^(3/2);
g[a_?NumericQ, T_?NumericQ] := 
  NIntegrate[f[v, T], {v, a, Infinity}]/
   Integrate[f[v, T], {v, 0, Infinity}];
Manipulate[
 Show[Plot[f[v, T], {v, 0, 4000}, 
   PlotRange -> {{0, 1300}, {0, 0.0055}}, 
   AxesLabel -> {"m/s", "Frequency"}, 
   Epilog -> Inset[Framed[Style[g[a, T]*100, 10]]]], 
  Plot[f[v, T], {v, a, 1300}, PlotRange -> {{0, 1300}, {0, 0.0055}}, 
   Filling -> Bottom]], {T, 50, 500}, {a, 0, 1300}]

Answer 2

Evaluating the integrals used to produce the value shown in the inset will produce, as is pointed out in cvgnt's answer, a major improvement in your code's performance, but there are other improvements you can make. The following code shows how I would refactor your Manipulate, not only to improve performance, but also to improve the user experience.

kb = 1.381*10^-23;
Nav = 6.022*10^23;
m = 0.032/Nav;
vMax = 1300;

g[a_][T_] =
   Assuming[T > 0, 
     100 
       Integrate[(E^(-((m v^2)/(2 kb T))) Sqrt[2/π] v^2)/((kb T)/m)^(3/2), {v, a, ∞}] /
       Integrate[(E^(-((m v^2)/(2 kb T))) Sqrt[2/π] v^2)/((kb T)/m)^(3/2), {v, 0, ∞}]];

Manipulate[
  Show[
    Plot[(E^(-((m v^2)/(2 kb T))) Sqrt[2/π] v^2)/((kb T)/m)^(3/2), {v, 0, a}],
    Plot[(E^(-((m v^2)/(2 kb T))) Sqrt[2/π] v^2)/((kb T)/m)^(3/2), {v, a, vMax},
      PlotRange -> {Automatic, {0, 0.0055}},
      Filling -> Bottom],
    PlotRange -> {{0, vMax}, {0, 0.0055}},
    AxesLabel -> {"m/s", "Frequency"},
    Epilog -> Inset[Framed[Style[g[a][T ], 10]]],
    ImageSize -> 450],
  {T, 50, 500, 5, Appearance -> "Labeled", ImageSize -> Large},
  {a, 1, vMax - 1, Appearance -> "Labeled", ImageSize -> Large}]

The main improvement in the above code, other than the one-time evaluation of the integrals in g, is in moving several plot options from the Plot functions to the higher level of Show. I have improved the Manipulator controls so they are easier to use and show their values.