A community-maintained Python framework for creating mathematical animations.
More animations for the heat equation
Grant Sandersona1878308e070
diff --git a/active_projects/ode/all_part2_scenes.py b/active_projects/ode/all_part2_scenes.pyindex 9db9861d7..70441f4e3 100644--- a/active_projects/ode/all_part2_scenes.py+++ b/active_projects/ode/all_part2_scenes.py@@ -1,6 +1,7 @@from active_projects.ode.part2.staging import *from active_projects.ode.part2.fourier_series import *from active_projects.ode.part2.heat_equation import *+from active_projects.ode.part2.pi_scenes import *OUTPUT_DIRECTORY = "ode/part2"ALL_SCENE_CLASSES = [@@ -28,4 +29,8 @@ ALL_SCENE_CLASSES = [TwoDBodyWithManyTemperaturesGraph,TwoDBodyWithManyTemperaturesContour,BringTwoRodsTogether,+ ShowEvolvingTempGraphWithArrows,+ WriteHeatEquation,+ ReactionsToInitialHeatEquation,+ TalkThrough1DHeatGraph,]diff --git a/active_projects/ode/part2/fourier_series.py b/active_projects/ode/part2/fourier_series.pyindex c3e0a3bea..86677e70e 100644--- a/active_projects/ode/part2/fourier_series.py+++ b/active_projects/ode/part2/fourier_series.py@@ -387,7 +387,9 @@ class FourierNailAndGear(FourierOfTrebleClef):CONFIG = {"height": 6,"n_circles": 200,- "run_time": 10,+ "run_time": 100,+ "slow_factor": 0.01,+ "parametric_function_step_size": 0.0001,"arrow_config": {"tip_length": 0.1,"stroke_width": 2,diff --git a/active_projects/ode/part2/heat_equation.py b/active_projects/ode/part2/heat_equation.pyindex c1c077682..f56acbf83 100644--- a/active_projects/ode/part2/heat_equation.py+++ b/active_projects/ode/part2/heat_equation.py@@ -153,7 +153,7 @@ class TwoDBodyWithManyTemperaturesContour(ExternallyAnimatedScene):class BringTwoRodsTogether(Scene):CONFIG = {- "step_size": 0.1,+ "step_size": 0.05,"axes_config": {"x_min": -1,"x_max": 11,@@ -162,10 +162,12 @@ class BringTwoRodsTogether(Scene):"y_axis_config": {"unit_size": 0.06,"tick_frequency": 10,- # "numbers_with_elongated_ticks": range(20, 100, 20)},},- "wait_time": 5,+ "graph_x_min": 0,+ "graph_x_max": 10,+ "wait_time": 30,+ "alpha": 1.0,}def construct(self):@@ -173,9 +175,6 @@ class BringTwoRodsTogether(Scene):self.setup_graph()self.setup_clock()- self.add(self.axes)- self.add(self.graph)-self.show_rods()self.show_equilibration()@@ -194,9 +193,9 @@ class BringTwoRodsTogether(Scene):def setup_graph(self):graph = self.axes.get_graph(- lambda x: 90 if x <= 5 else 10,- x_min=0,- x_max=10,+ self.initial_function,+ x_min=self.graph_x_min,+ x_max=self.graph_x_max,step_size=self.step_size,discontinuities=[5],)@@ -229,34 +228,115 @@ class BringTwoRodsTogether(Scene):self.clock = clockdef show_rods(self):- pass+ rod1, rod2 = rods = VGroup(+ self.get_rod(0, 5),+ self.get_rod(5, 10),+ )+ rod1.set_color(rod1[0].get_color())+ rod2.set_color(rod2[-1].get_color())++ rods.save_state()+ rods.space_out_submobjects(1.5)+ rods.center()++ labels = VGroup(+ TexMobject("90^\\circ"),+ TexMobject("10^\\circ"),+ )+ for rod, label in zip(rods, labels):+ label.next_to(rod, DOWN)+ rod.label = label++ self.play(+ FadeInFrom(rod1, UP),+ Write(rod1.label),+ )+ self.play(+ FadeInFrom(rod2, DOWN),+ Write(rod2.label)+ )+ self.wait()++ self.rods = rods+ self.rod_labels = labelsdef show_equilibration(self):- self.add(self.time_group)- self.add(self.clock)+ rods = self.rods+ axes = self.axes+ graph = self.graph+ labels = self.rod_labels+ self.play(+ Write(axes),+ rods.restore,+ rods.space_out_submobjects, 1.1,+ FadeIn(self.time_group),+ FadeIn(self.clock),+ *[+ MaintainPositionRelativeTo(+ rod.label, rod+ )+ for rod in rods+ ],+ )++ br1 = Rectangle(height=0.2, width=1)+ br1.set_stroke(width=0)+ br1.set_fill(BLACK, opacity=1)+ br2 = br1.copy()+ br1.add_updater(lambda b: b.move_to(axes.c2p(0, 90)))+ br1.add_updater(+ lambda b: b.align_to(rods[0].get_right(), LEFT)+ )+ br2.add_updater(lambda b: b.move_to(axes.c2p(0, 10)))+ br2.add_updater(+ lambda b: b.align_to(rods[1].get_left(), RIGHT)+ )++ self.add(graph, br1, br2)+ self.play(+ ShowCreation(graph),+ labels[0].align_to, axes.c2p(0, 87), UP,+ labels[1].align_to, axes.c2p(0, 13), DOWN,+ )+ self.play()+ self.play(+ rods.restore,+ rate_func=rush_into,+ )+ self.remove(br1, br2)- self.graph.add_updater(self.update_graph)+ graph.add_updater(self.update_graph)self.time_label.add_updater(lambda d, dt: d.increment_value(dt))+ rods.add_updater(self.update_rods)self.play(ClockPassesTime(self.clock,run_time=self.wait_time,hours_passed=self.wait_time,- )+ ),+ FadeOut(labels))#- def update_graph(self, graph, dt, alpha=1.0, n_mini_steps=100):+ def initial_function(self, x):+ if x <= 5:+ return 90+ else:+ return 10++ def update_graph(self, graph, dt, alpha=None, n_mini_steps=100):+ if alpha is None:+ alpha = self.alphapoints = np.append(graph.get_start_anchors(),[graph.get_last_point()],axis=0,)for k in range(n_mini_steps):- change = np.zeros(points.shape)+ y_change = np.zeros(points.shape[0])dx = points[1][0] - points[0][0]for i in range(len(points)):p = points[i]@@ -270,12 +350,188 @@ class BringTwoRodsTogether(Scene):second_deriv = 0.5 * d2y / dxsecond_deriv = 0- change[i][1] = alpha * second_deriv * dt / n_mini_steps+ y_change[i] = alpha * second_deriv * dt / n_mini_steps- change[0][1] = change[1][1]- change[-1][1] = change[-2][1]- # change[0][1] = 0- # change[-1][1] = 0- points += change+ # y_change[0] = y_change[1]+ # y_change[-1] = y_change[-2]+ y_change[0] = 0+ y_change[-1] = 0+ y_change -= np.mean(y_change)+ points[:, 1] += y_changegraph.set_points_smoothly(points)return graph++ def get_second_derivative(self, x, dx=0.001):+ graph = self.graph+ x_min = self.graph_x_min+ x_max = self.graph_x_max++ ly, y, ry = [+ graph.point_from_proportion(+ inverse_interpolate(x_min, x_max, alt_x)+ )[1]+ for alt_x in (x - dx, x, x + dx)+ ]+ d2y = ry - 2 * y + ly+ return d2y / (dx**2)++ def get_rod(self, x_min, x_max, n_pieces=20):+ axes = self.axes+ line = Line(axes.c2p(x_min, 0), axes.c2p(x_max, 0))+ rod = VGroup(*[+ Square()+ for n in range(n_pieces)+ ])+ rod.arrange(RIGHT, buff=0)+ rod.match_width(line)+ rod.set_height(0.2, stretch=True)+ rod.move_to(axes.c2p(x_min, 0), LEFT)+ rod.set_fill(opacity=1)+ rod.set_stroke(width=1)+ rod.set_sheen_direction(RIGHT)+ self.color_rod_by_graph(rod)+ return rod++ def update_rods(self, rods):+ for rod in rods:+ self.color_rod_by_graph(rod)++ def color_rod_by_graph(self, rod):+ for piece in rod:+ piece.set_color(color=[+ self.rod_point_to_color(piece.get_left()),+ self.rod_point_to_color(piece.get_right()),+ ])++ def rod_point_to_color(self, point):+ axes = self.axes+ x = axes.x_axis.p2n(point)++ graph = self.graph+ alpha = inverse_interpolate(+ self.graph_x_min,+ self.graph_x_max,+ x,+ )+ y = axes.y_axis.p2n(+ graph.point_from_proportion(alpha)+ )+ return temperature_to_color(+ (y - 45) / 45+ )+++class ShowEvolvingTempGraphWithArrows(BringTwoRodsTogether):+ CONFIG = {+ "alpha": 0.1,+ "n_arrows": 20,+ "wait_time": 30,+ }++ def construct(self):+ self.add_axes()+ self.add_graph()+ self.add_clock()+ self.add_rod()+ self.add_arrows()+ self.let_play()++ def add_axes(self):+ self.setup_axes()+ self.add(self.axes)++ def add_graph(self):+ self.setup_graph()+ self.add(self.graph)++ def add_clock(self):+ self.setup_clock()+ self.add(self.clock)+ self.add(self.time_label)++ def add_rod(self):+ rod = self.rod = self.get_rod(0, 10)+ self.add(rod)++ def add_arrows(self):+ graph = self.graph+ x_min = self.graph_x_min+ x_max = self.graph_x_max++ xs = np.linspace(x_min, x_max, self.n_arrows + 2)[1:-1]+ arrows = VGroup(*[Vector(DOWN) for x in xs])++ def update_arrows(arrows):+ for x, arrow in zip(xs, arrows):+ d2y_dx2 = self.get_second_derivative(x)+ mag = np.sign(d2y_dx2) * np.sqrt(abs(d2y_dx2))+ mag = np.clip(mag, -2, 2)+ arrow.put_start_and_end_on(+ ORIGIN, mag * UP+ )+ point = graph.point_from_proportion(+ inverse_interpolate(x_min, x_max, x)+ )+ arrow.shift(point - arrow.get_start())+ arrow.set_color(+ self.rod_point_to_color(point)+ )++ arrows.add_updater(update_arrows)++ self.add(arrows)+ self.arrows = arrows++ def let_play(self):+ graph = self.graph+ rod = self.rod+ clock = self.clock+ time_label = self.time_label++ graph.add_updater(self.update_graph)+ time_label.add_updater(+ lambda d, dt: d.increment_value(dt)+ )+ rod.add_updater(self.color_rod_by_graph)++ # return+ self.play(+ ClockPassesTime(+ clock,+ run_time=self.wait_time,+ hours_passed=self.wait_time,+ ),+ )++ #+ def initial_function(self, x):+ new_x = TAU * x / 10+ return 50 + 20 * np.sum([+ np.sin(new_x),+ np.sin(2 * new_x),+ 0.5 * np.sin(3 * new_x),+ 0.3 * np.sin(4 * new_x),+ 0.3 * np.sin(5 * new_x),+ 0.2 * np.sin(7 * new_x),+ 0.1 * np.sin(21 * new_x),+ 0.05 * np.sin(41 * new_x),+ ])+++class TalkThrough1DHeatGraph(ShowEvolvingTempGraphWithArrows):+ def construct(self):+ self.add_axes()+ self.add_graph()+ self.add_rod()++ #+ def initial_function(self, x):+ new_x = TAU * x / 10+ return 50 + 20 * np.sum([+ np.sin(new_x),+ np.sin(2 * new_x),+ 0.5 * np.sin(3 * new_x),+ 0.3 * np.sin(4 * new_x),+ 0.3 * np.sin(5 * new_x),+ 0.2 * np.sin(7 * new_x),+ ])diff --git a/active_projects/ode/part2/pi_scenes.py b/active_projects/ode/part2/pi_scenes.pynew file mode 100644index 000000000..ba1d98c17--- /dev/null+++ b/active_projects/ode/part2/pi_scenes.py@@ -0,0 +1,23 @@+from big_ol_pile_of_manim_imports import *+++class ReactionsToInitialHeatEquation(PiCreatureScene):+ def construct(self):+ randy = self.pi_creature+ randy.set_color(BLUE_C)+ randy.center()++ point = VectorizedPoint().next_to(randy, UL, LARGE_BUFF)+ randy.add_updater(lambda r: r.look_at(point))++ self.play(randy.change, "horrified")+ self.wait()+ self.play(randy.change, "pondering")+ self.wait()+ self.play(+ randy.change, "confused",+ point.next_to, randy, UR, LARGE_BUFF,+ )+ self.wait(2)+ self.play(point.shift, 2 * DOWN)+ self.wait(3)diff --git a/active_projects/ode/part2/staging.py b/active_projects/ode/part2/staging.pyindex 526757857..8bfe90ca3 100644--- a/active_projects/ode/part2/staging.py+++ b/active_projects/ode/part2/staging.py@@ -86,3 +86,70 @@ class PartTwoOfTour(TourOfDifferentialEquations):class CompareODEToPDE(Scene):def construct(self):pass+++class WriteHeatEquation(Scene):+ def construct(self):+ d1_words = TextMobject("Heat equation\\\\", "(1 dimension)")+ d3_words = TextMobject("Heat equation\\\\", "(3 dimensions)")++ kwargs = {+ "tex_to_color_map": {+ "{T}": YELLOW,+ "{t}": WHITE,+ "{x}": GREEN,+ "{y}": RED,+ "{z}": BLUE,+ }+ }+ d1_equation = TexMobject(+ "{\\partial {T} \\over \\partial {t}}({x}, {t})="+ "{\\partial^2 {T} \\over \\partial {x}^2} ({x}, {t})",+ **kwargs+ )+ d3_equation = TexMobject(+ "{\\partial {T} \\over \\partial {t}} = ",+ "{\\partial^2 {T} \\over \\partial {x}^2} + ",+ "{\\partial^2 {T} \\over \\partial {y}^2} + ",+ "{\\partial^2 {T} \\over \\partial {z}^2}",+ **kwargs+ )++ d1_group = VGroup(d1_words, d1_equation)+ d3_group = VGroup(d3_words, d3_equation)+ groups = VGroup(d1_group, d3_group)+ for group in groups:+ group.arrange(DOWN, buff=MED_LARGE_BUFF)+ groups.arrange(RIGHT, buff=2)+ groups.to_edge(UP)++ d3_rhs = d3_equation[6:]+ d3_brace = Brace(d3_rhs, DOWN)+ nabla_words = TextMobject("Sometimes written as")+ nabla_words.match_width(d3_brace)+ nabla_words.next_to(d3_brace, DOWN)+ nabla_exp = TexMobject("\\nabla^2 {T}", **kwargs)+ nabla_exp.next_to(nabla_words, DOWN)+ # nabla_group = VGroup(nabla_words, nabla_exp)++ d1_group.save_state()+ d1_group.center().to_edge(UP)++ self.play(+ Write(d1_words),+ FadeInFrom(d1_equation, UP),+ run_time=1,+ )+ self.wait(2)+ self.play(+ Restore(d1_group),+ FadeInFrom(d3_group, LEFT)+ )+ self.wait()+ self.play(+ GrowFromCenter(d3_brace),+ Write(nabla_words),+ TransformFromCopy(d3_rhs, nabla_exp),+ run_time=1,+ )+ self.wait()