A community-maintained Python framework for creating mathematical animations.
Latest animations for diffyq part 3
Grant Sanderson9e7619844f1c
diff --git a/active_projects/ode/all_part3_scenes.py b/active_projects/ode/all_part3_scenes.pyindex 96d5274e8..36f9236ee 100644--- a/active_projects/ode/all_part3_scenes.py+++ b/active_projects/ode/all_part3_scenes.py@@ -39,6 +39,16 @@ SCENES_IN_ORDER = [FlatEdgesForDiscreteEvolutionTinySteps,FlatEdgesContinuousEvolution,FlatAtBoundaryWords,+ SlopeToHeatFlow,+ CloserLookAtStraightLine,+ WriteOutBoundaryCondition,+ TeacherStudentsScene,+ ManipulateSinExpSurface,+ HeatEquationFrame,+ ShowFreq1CosExpDecay,+ ShowFreq2CosExpDecay,+ ShowFreq4CosExpDecay,+ CompareFreqDecays,# SimpleCosExpGraph,# AddMultipleSolutions,diff --git a/active_projects/ode/part2/heat_equation.py b/active_projects/ode/part2/heat_equation.pyindex 402c9c231..ebfdad39c 100644--- a/active_projects/ode/part2/heat_equation.py+++ b/active_projects/ode/part2/heat_equation.py@@ -523,25 +523,24 @@ class ShowEvolvingTempGraphWithArrows(BringTwoRodsTogether):self.arrows = arrowsdef initialize_updaters(self):- graph = self.graph- rod = self.rod- 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)+ if hasattr(self, "graph"):+ self.graph.add_updater(self.update_graph)+ if hasattr(self, "rod"):+ self.rod.add_updater(self.color_rod_by_graph)+ if hasattr(self, "time_label"):+ self.time_label.add_updater(+ lambda d, dt: d.increment_value(dt)+ )def let_play(self):- clock = self.clock+ self.run_clock(self.wait_time)- # return+ def run_clock(self, time):self.play(ClockPassesTime(- clock,- run_time=self.wait_time,- hours_passed=self.wait_time,+ self.clock,+ run_time=time,+ hours_passed=time,),)diff --git a/active_projects/ode/part3/pi_creature_scenes.py b/active_projects/ode/part3/pi_creature_scenes.pyindex 782496fd7..61b8f7c09 100644--- a/active_projects/ode/part3/pi_creature_scenes.py+++ b/active_projects/ode/part3/pi_creature_scenes.py@@ -137,3 +137,39 @@ class IfOnly(TeacherStudentsScene):)self.wait(3)++class SoWeGotNowhere(TeacherStudentsScene):+ def construct(self):+ self.student_says(+ "So we've gotten\\\\nowhere!",+ target_mode="angry",+ added_anims=[+ self.teacher.change, "guilty"+ ]+ )+ self.change_all_student_modes("angry")+ self.wait()+ text = TexMobject(+ "&\\text{Actually,}\\\\",+ "&\\sin\\left({x}\\right)"+ "e^{-\\alpha {t}}\\\\",+ "&\\text{isn't far off.}",+ tex_to_color_map={+ "{x}": GREEN,+ "{t}": YELLOW,+ }+ )+ text.scale(0.8)+ self.teacher_says(+ text,+ content_introduction_class=FadeIn,+ bubble_kwargs={+ "width": 4,+ "height": 3.5,+ }+ )+ self.change_all_student_modes(+ "pondering",+ look_at_arg=self.screen+ )+ self.wait(3)diff --git a/active_projects/ode/part3/temperature_graphs.py b/active_projects/ode/part3/temperature_graphs.pyindex 024972882..28460ebbc 100644--- a/active_projects/ode/part3/temperature_graphs.py+++ b/active_projects/ode/part3/temperature_graphs.py@@ -74,10 +74,10 @@ class TemperatureGraphScene(SpecialThreeDScene):x_axis = axes.x_axisy_axis = axes.y_axistex_vals = [- ("\\pi \\over 2", PI / 2),- ("\\pi", PI),- ("3 \\pi \\over 2", 3 * PI / 2),- ("\\tau", TAU)+ ("\\pi \\over 2", TAU / 4),+ ("\\pi", TAU / 2),+ ("3\\pi \\over 2", 3 * TAU / 4),+ ("2\\pi", TAU)]x_labels = VGroup()for tex, val in tex_vals:@@ -100,7 +100,7 @@ class TemperatureGraphScene(SpecialThreeDScene):t_label = TextMobject("Time")t_label.rotate(90 * DEGREES, OUT)- t_label.next_to(axes.y_axis.get_top(), DL)+ t_label.next_to(axes.y_axis.get_end(), UP)axes.y_axis.label = t_labeltemp_label = TextMobject("Temperature")@@ -1686,7 +1686,7 @@ class SimulateLinearGraph(SimulateRealSineCurve):axes = self.axesy_max = axes.y_maxx_max = axes.x_max- slope = y_max/ x_max+ slope = y_max / x_maxreturn slope * x@@ -1768,7 +1768,6 @@ class FlatEdgesContinuousEvolution(ShowEvolvingTempGraphWithArrows):self.add_graph()self.add_clock()self.add_rod()- # self.add_arrows()self.initialize_updaters()self.add_boundary_lines()self.let_play()@@ -1795,3 +1794,705 @@ class FlatEdgesContinuousEvolution(ShowEvolvingTempGraphWithArrows):def initial_function(self, x):return ShowEvolvingTempGraphWithArrows.initial_function(self, x)+++class SlopeToHeatFlow(FlatEdgesContinuousEvolution):+ CONFIG = {+ "wait_time": 20,+ "xs": [1.75, 5.25, 7.8],+ "axes_config": {+ "x_min": 0,+ "x_max": 10,+ "x_axis_config": {+ "include_tip": False,+ }+ },+ "n_arrows": 10,+ "random_seed": 1,+ }++ def construct(self):+ self.add_axes()+ self.add_graph()+ self.add_rod()+ #+ self.show_slope_labels()+ self.show_heat_flow()++ def show_slope_labels(self):+ axes = self.axes+ # axes.x_axis.add_numbers()+ graph = self.graph+ xs = self.xs++ lines = VGroup(*[+ TangentLine(+ graph,+ inverse_interpolate(+ axes.x_min,+ axes.x_max,+ x+ ),+ length=2,+ stroke_opacity=0.75,+ )+ for x in xs+ ])++ slope_words = VGroup()+ for line in lines:+ slope = line.get_slope()+ word = TextMobject(+ "Slope =",+ "${:.2}$".format(slope)+ )+ if slope > 0:+ word[1].set_color(GREEN)+ else:+ word[1].set_color(RED)++ word.set_width(line.get_length())+ word.next_to(ORIGIN, UP, SMALL_BUFF)+ word.rotate(+ line.get_angle(),+ about_point=ORIGIN,+ )+ word.shift(line.get_center())+ slope_words.add(word)++ self.play(+ LaggedStartMap(ShowCreation, lines),+ LaggedStartMap(Write, slope_words),+ lag_ratio=0.5,+ run_time=1,+ )+ self.wait()++ self.lines = lines+ self.slope_words = slope_words++ def show_heat_flow(self):+ axes = self.axes+ xs = self.xs+ slope_words = self.slope_words+ tan_lines = self.lines++ slopes = map(Line.get_slope, self.lines)+ flow_rates = [-s for s in slopes]++ points = list(map(axes.x_axis.n2p, xs))+ v_lines = VGroup(*[+ Line(+ line.get_center(), point,+ stroke_width=1,+ )+ for point, line in zip(points, tan_lines)+ ])++ flow_words = VGroup(*[+ TextMobject("Heat flow").next_to(+ point, DOWN+ ).scale(0.8)+ for point in points+ ])+ flow_mobjects = VGroup(*[+ self.get_flow(x, flow_rate)+ for x, flow_rate in zip(xs, flow_rates)+ ])++ self.add(flow_mobjects)+ self.wait()+ self.play(+ LaggedStart(*[+ TransformFromCopy(+ sw[0], fw[0]+ )+ for sw, fw in zip(slope_words, flow_words)+ ]),+ LaggedStartMap(ShowCreation, v_lines),+ lag_ratio=0.4,+ run_time=2,+ )+ self.wait(self.wait_time)++ def get_flow(self, x, flow_rate):+ return VGroup(*[+ self.get_single_flow_arrow(+ x, flow_rate,+ t_offset=to+ )+ for to in np.linspace(0, 5, self.n_arrows)+ ])++ def get_single_flow_arrow(self, x, flow_rate, t_offset):+ axes = self.axes+ point = axes.x_axis.n2p(x)++ h_shift = 0.5+ v_shift = 0.4 * np.random.random() + 0.1++ arrow = Vector(0.5 * RIGHT * np.sign(flow_rate))+ arrow.move_to(point)+ arrow.shift(v_shift * UP)+ lp = arrow.get_center() + h_shift * LEFT+ rp = arrow.get_center() + h_shift * RIGHT+ lc = self.rod_point_to_color(lp)+ rc = self.rod_point_to_color(rp)++ run_time = 3 / flow_rate+ animation = UpdateFromAlphaFunc(+ arrow,+ lambda m, a: m.move_to(+ interpolate(lp, rp, a)+ ).set_color(+ interpolate_color(lc, rc, a)+ ).set_opacity(there_and_back(a)),+ run_time=run_time,+ )+ result = cycle_animation(animation)+ animation.total_time += t_offset+ return result+++class CloserLookAtStraightLine(SimulateLinearGraph):+ def construct(self):+ self.add_axes()+ self.add_graph()+ self.add_clock()+ self.add_rod()+ # self.initialize_updaters()+ #+ self.show_t_eq_0_state()+ self.show_t_gt_0_state()++ def show_t_eq_0_state(self):+ t_eq = TexMobject("t", "=", "0")+ t_eq.next_to(self.time_label, DOWN)++ circles = VGroup(*[+ Circle(+ radius=0.25,+ stroke_color=YELLOW,+ )+ for x in range(2)+ ])+ circles.add_updater(self.attach_to_endpoints)++ self.play(Write(t_eq))+ self.play(ShowCreation(circles))+ self.wait()+ self.play(FadeOut(circles))++ self.circles = circles+ self.t_eq = t_eq++ def show_t_gt_0_state(self):+ # circles = self.circles+ t_eq = self.t_eq++ t_ineq = TexMobject("t", ">", "0")+ t_ineq.move_to(t_eq)++ slope_lines = VGroup(*[+ Line(LEFT, RIGHT)+ for x in range(2)+ ])+ slope_lines.set_opacity(0.5)+ slope_lines.add_updater(self.attach_to_endpoints)++ self.remove(t_eq)+ self.add(t_ineq)++ self.initialize_updaters()+ self.run_clock(0.1)+ for mob in self.mobjects:+ mob.suspend_updating()+ self.wait()++ self.add(slope_lines)+ self.add(self.clock, self.time_label, t_ineq)+ self.play(ShowCreation(slope_lines))+ for mob in self.mobjects:+ mob.resume_updating()++ self.run_clock(self.wait_time)++ #+ def attach_to_endpoints(self, mobs):+ points = [+ self.graph.get_start(),+ self.graph.get_end(),+ ]+ for mob, point in zip(mobs, points):+ mob.move_to(point)+ return mobs+++class ManipulateSinExpSurface(TemperatureGraphScene):+ CONFIG = {+ "axes_config": {+ "z_max": 1.25,+ "z_min": -1.25,+ "z_axis_config": {+ "unit_size": 2.5,+ "tick_frequency": 0.5,+ },+ "x_axis_config": {+ # "unit_size": 1.5,+ "unit_size": 1.0,+ "tick_frequency": 1,+ },+ "x_max": 10,+ "y_max": 15,+ },+ "alpha": 0.2,+ "tex_mobject_config": {+ "tex_to_color_map": {+ "{x}": GREEN,+ "{t}": YELLOW,+ "\\omega": MAROON_B,+ "^2": WHITE,+ },+ },+ }++ def construct(self):+ self.setup_axes()+ self.add_sine_wave()+ self.shift_sine_to_cosine()+ self.show_derivatives_of_cos()+ self.show_cos_exp_surface()+ self.change_frequency()+ self.talk_through_omega()+ self.show_cos_omega_derivatives()+ self.show_rebalanced_exp()++ def setup_axes(self):+ axes = self.get_three_d_axes(include_numbers=True)+ axes.x_axis.remove(axes.x_axis.numbers)+ L = TexMobject("L")+ L.rotate(90 * DEGREES, RIGHT)+ L.next_to(axes.x_axis.get_end(), IN)+ axes.x_axis.add(L)++ axes.shift(5 * LEFT + 0.5 * IN)+ axes.z_axis.label[0].remove(+ *axes.z_axis.label[0][1:]+ )+ axes.z_axis.label.next_to(+ axes.z_axis.get_end(), OUT+ )+ axes.z_axis.add_numbers(+ *np.arange(-1, 1.5, 0.5),+ direction=LEFT,+ number_config={+ "num_decimal_places": 1,+ }+ )+ for number in axes.z_axis.numbers:+ number.rotate(90 * DEGREES, RIGHT)++ self.set_camera_orientation(+ phi=90 * DEGREES,+ theta=-90 * DEGREES,+ distance=100,+ )++ self.add(axes)+ self.remove(axes.y_axis)+ self.axes = axes++ def add_sine_wave(self):+ self.initialize_parameter_trackers()+ graph = always_redraw(+ lambda: self.get_time_slice_graph(+ self.axes, self.func,+ t=self.t_tracker.get_value(),+ )+ )+ sin_label = TexMobject(+ "\\sin\\left({x}\\right)",+ **self.tex_mobject_config,+ )+ sin_label.shift(2 * LEFT + 2.75 * UP)++ self.add_fixed_in_frame_mobjects(sin_label)+ graph.suspend_updating()+ self.play(+ ShowCreation(graph),+ Write(sin_label),+ )+ graph.resume_updating()+ self.wait()++ self.sin_label = sin_label+ self.graph = graph++ def shift_sine_to_cosine(self):+ graph = self.graph+ sin_label = self.sin_label++ sin_cross = Cross(sin_label)+ sin_cross.add_updater(+ lambda m: m.move_to(sin_label)+ )+ cos_label = TexMobject(+ "\\cos\\left({x}\\right)",+ **self.tex_mobject_config,+ )+ cos_label.move_to(sin_label, LEFT)+ cos_label.shift(LEFT)+ # cos_label.shift(+ # axes.c2p(0, 0) - axes.c2p(PI / 2, 0),+ # )++ left_tangent = Line(ORIGIN, RIGHT)+ left_tangent.set_stroke(WHITE, 5)++ self.add_fixed_in_frame_mobjects(cos_label)+ self.play(+ ApplyMethod(+ self.phi_tracker.set_value, 0,+ ),+ FadeOutAndShift(sin_label, LEFT),+ FadeInFrom(cos_label, RIGHT),+ run_time=2,+ )+ left_tangent.move_to(graph.get_start(), LEFT)+ self.play(ShowCreation(left_tangent))+ self.play(FadeOut(left_tangent))++ self.cos_label = cos_label++ def show_derivatives_of_cos(self):+ cos_label = self.cos_label+ cos_exp_label = TexMobject(+ "\\cos\\left({x}\\right)",+ "e^{-\\alpha {t}}",+ **self.tex_mobject_config+ )+ cos_exp_label.move_to(cos_label, LEFT)++ ddx_group, ddx_exp_group = [+ self.get_ddx_computation_group(+ label,+ *[+ TexMobject(+ s + "\\left({x}\\right)" + exp,+ **self.tex_mobject_config,+ )+ for s in ["-\\sin", "-\\cos"]+ ]+ )+ for label, exp in [+ (cos_label, ""),+ (cos_exp_label, "e^{-\\alpha {t}}"),+ ]+ ]++ self.add_fixed_in_frame_mobjects(ddx_group)+ self.play(FadeIn(ddx_group))+ self.wait()++ # Cos exp+ transforms = [+ ReplacementTransform(+ cos_label, cos_exp_label,+ ),+ ReplacementTransform(+ ddx_group, ddx_exp_group,+ ),+ ]+ for trans in transforms:+ trans.begin()+ self.add_fixed_in_frame_mobjects(trans.mobject)+ self.play(*transforms)+ self.add_fixed_in_frame_mobjects(+ cos_exp_label, ddx_exp_group+ )+ self.remove_fixed_in_frame_mobjects(+ cos_label,+ *[+ trans.mobject+ for trans in transforms+ ]+ )++ self.cos_exp_label = cos_exp_label+ self.ddx_exp_group = ddx_exp_group++ def show_cos_exp_surface(self):+ axes = self.axes++ max_t_tracker = ValueTracker(0)+ surface = always_redraw(+ lambda: self.get_surface(+ self.axes, self.func,+ v_max=max_t_tracker.get_value(),+ )+ )+ self.add(surface)+ self.move_camera(+ phi=85 * DEGREES,+ theta=-80 * DEGREES,+ added_anims=[+ ApplyMethod(+ max_t_tracker.set_value,+ axes.y_max,+ run_time=4,+ ),+ Write(axes.y_axis),+ ]+ )+ self.wait()++ self.surface = surface++ def change_frequency(self):+ cos_exp_label = self.cos_exp_label+ ddx_exp_group = self.ddx_exp_group+ omega_tracker = self.omega_tracker++ cos_omega = TexMobject(+ "\\cos\\left(",+ "\\omega", "\\cdot", "{x}",+ "\\right)",+ **self.tex_mobject_config+ )+ cos_omega.move_to(cos_exp_label, LEFT)++ omega = cos_omega.get_part_by_tex("\\omega")+ brace = Brace(omega, UP, buff=SMALL_BUFF)+ omega_decimal = always_redraw(+ lambda: DecimalNumber(+ omega_tracker.get_value(),+ color=omega.get_color(),+ ).next_to(brace, UP, SMALL_BUFF)+ )++ self.add_fixed_in_frame_mobjects(+ cos_omega,+ brace,+ omega_decimal,+ )+ self.play(+ self.camera.phi_tracker.set_value, 90 * DEGREES,+ self.camera.theta_tracker.set_value, -90 * DEGREES,+ FadeOut(self.surface),+ FadeOut(self.axes.y_axis),+ FadeOut(cos_exp_label),+ FadeOut(ddx_exp_group),+ FadeIn(cos_omega),+ GrowFromCenter(brace),+ FadeInFromDown(omega_decimal)+ )+ for n in [2, 6, 1, 4]:+ freq = n * PI / self.axes.x_max+ self.play(+ omega_tracker.set_value, freq,+ run_time=2+ )+ self.wait()+ self.wait()++ self.cos_omega = cos_omega+ self.omega_brace = brace++ def talk_through_omega(self):+ axes = self.axes++ x_tracker = ValueTracker(0)+ get_x = x_tracker.get_value+ v_line = always_redraw(lambda: DashedLine(+ axes.c2p(get_x(), 0, 0),+ axes.c2p(get_x(), 0, self.func(get_x(), 0)),+ ))++ x = self.cos_omega.get_part_by_tex("{x}")+ brace = Brace(x, DOWN)+ x_decimal = always_redraw(+ lambda: DecimalNumber(+ get_x(),+ color=x.get_color()+ ).next_to(brace, DOWN, SMALL_BUFF)+ )++ self.add(v_line)+ self.add_fixed_in_frame_mobjects(brace, x_decimal)+ self.play(+ x_tracker.set_value, 5,+ run_time=5,+ rate_func=linear,+ )+ self.play(+ FadeOut(v_line),+ FadeOut(brace),+ FadeOut(x_decimal),+ )+ self.remove_fixed_in_frame_mobjects(+ brace, x_decimal+ )++ def show_cos_omega_derivatives(self):+ cos_omega = self.cos_omega+ ddx_omega_group = self.get_ddx_computation_group(+ cos_omega,+ *[+ TexMobject(+ s + "\\left(\\omega \\cdot {x}\\right)",+ **self.tex_mobject_config,+ )+ for s in ["-\\omega \\sin", "-\\omega^2 \\cos"]+ ]+ )++ omega_squared = ddx_omega_group[-1][1:3]+ rect = SurroundingRectangle(omega_squared)++ self.add_fixed_in_frame_mobjects(ddx_omega_group)+ self.play(FadeIn(ddx_omega_group))+ self.wait()+ self.add_fixed_in_frame_mobjects(rect)+ self.play(ShowCreationThenFadeOut(rect))+ self.wait()++ self.ddx_omega_group = ddx_omega_group++ def show_rebalanced_exp(self):+ cos_omega = self.cos_omega+ ddx_omega_group = self.ddx_omega_group++ cos_exp = TexMobject(+ "\\cos\\left(",+ "\\omega", "\\cdot", "{x}",+ "\\right)",+ "e^{-\\alpha \\omega^2 {t}}",+ **self.tex_mobject_config+ )+ cos_exp.move_to(cos_omega, DL)++ self.add_fixed_in_frame_mobjects(cos_exp)+ self.play(+ FadeOut(cos_omega),+ FadeOut(ddx_omega_group),+ FadeIn(cos_exp),+ )+ self.remove_fixed_in_frame_mobjects(+ cos_omega,+ ddx_omega_group,+ )++ self.play(+ FadeIn(self.surface),+ FadeIn(self.axes.y_axis),+ VGroup(+ cos_exp,+ self.omega_brace,+ ).shift, 4 * RIGHT,+ self.camera.phi_tracker.set_value, 80 * DEGREES,+ self.camera.theta_tracker.set_value, -80 * DEGREES,+ )+ self.wait()+ self.play(+ self.omega_tracker.set_value, TAU / 10,+ run_time=6,+ )++ #+ def initialize_parameter_trackers(self):+ self.phi_tracker = ValueTracker(-90 * DEGREES)+ self.omega_tracker = ValueTracker(1)+ self.t_tracker = ValueTracker(0)++ def func(self, x, t):+ phi = self.phi_tracker.get_value()+ omega = self.omega_tracker.get_value()+ alpha = self.alpha+ return op.mul(+ np.cos(omega * (x + phi)),+ np.exp(-alpha * (omega**2) * t)+ )++ def get_ddx_computation_group(self, f, df, ddf):+ arrows = VGroup(*[+ Vector(0.5 * RIGHT) for x in range(2)+ ])+ group = VGroup(+ arrows[0], df, arrows[1], ddf+ )+ group.arrange(RIGHT)+ group.next_to(f, RIGHT)++ for arrow in arrows:+ label = TexMobject(+ "\\partial \\over \\partial {x}",+ **self.tex_mobject_config,+ )+ label.scale(0.5)+ label.next_to(arrow, UP, SMALL_BUFF)+ arrow.add(label)++ group.arrows = arrows+ group.funcs = VGroup(df, ddf)++ return group+++class ShowFreq1CosExpDecay(ManipulateSinExpSurface):+ CONFIG = {+ "freq": 1,+ "alpha": 0.1,+ }++ def construct(self):+ self.setup_axes()+ self.initialize_parameter_trackers()+ self.phi_tracker.set_value(0)+ self.omega_tracker.set_value(self.freq)+ #+ self.show_decay()++ def show_decay(self):+ axes = self.axes+ t_tracker = self.t_tracker+ t_max = self.axes.y_max++ graph = always_redraw(+ lambda: self.get_time_slice_graph(+ axes,+ self.func,+ t=t_tracker.get_value(),+ stroke_width=5,+ )+ )++ surface = self.get_surface(+ self.axes, self.func,+ )+ plane = self.get_const_time_plane(axes)++ self.add(surface, plane, graph)+ self.add(axes.y_axis)+ self.set_camera_orientation(+ phi=85 * DEGREES,+ theta=-80 * DEGREES,+ )+ self.play(+ t_tracker.set_value, t_max,+ plane.t_tracker.set_value, t_max,+ # run_time=t_max,+ run_time=5,+ rate_func=linear,+ )+++class ShowFreq2CosExpDecay(ShowFreq1CosExpDecay):+ CONFIG = {+ "freq": 2,+ }+++class ShowFreq4CosExpDecay(ShowFreq1CosExpDecay):+ CONFIG = {+ "freq": 4,+ }diff --git a/active_projects/ode/part3/wordy_scenes.py b/active_projects/ode/part3/wordy_scenes.pyindex 98d4bb456..50022c996 100644--- a/active_projects/ode/part3/wordy_scenes.py+++ b/active_projects/ode/part3/wordy_scenes.py@@ -152,6 +152,11 @@ class ThreeConstraints(WriteHeatEquationTemplate):self.play(Write(items[2][1]))self.wait(2)+ self.title = title+ self.items = items+ self.pde = equation+ self.bc_paren = bc_paren+class EquationAboveSineAnalysis(WriteHeatEquationTemplate):def construct(self):@@ -545,9 +550,113 @@ class DerivativesOfLinearFunction(WriteHeatEquationTemplate):class FlatAtBoundaryWords(Scene):def construct(self):- words = TextMobject(+ words = self.get_bc_words()+ self.play(Write(words))+ self.wait()++ def get_bc_words(self):+ return TextMobject("Flat at boundary\\\\"- "for all $t > 0$"+ "for all", "${t}$", "$> 0$",)- self.play(Write(words))+++class WriteOutBoundaryCondition(FlatAtBoundaryWords, ThreeConstraints, MovingCameraScene):+ def construct(self):+ self.force_skipping()+ ThreeConstraints.construct(self)+ self.revert_to_original_skipping_status()++ self.add_ic()+ self.write_bc_words()+ self.write_bc_equation()++ def add_ic(self):+ image = ImageMobject("temp_initial_condition_example")+ image.set_width(3)+ border = SurroundingRectangle(image, buff=SMALL_BUFF)+ border.shift(SMALL_BUFF * UP)+ border.set_stroke(WHITE, 2)+ group = Group(image, border)+ group.next_to(self.items[2], DOWN)+ self.add(group)++ def write_bc_words(self):+ bc_paren = self.bc_paren+ bc_words = self.get_bc_words()+ bc_words.match_width(self.items[1][1])+ bc_words.move_to(bc_paren, UP)+ bc_words.set_color_by_tex("{t}", YELLOW)++ self.play(ShowCreationThenFadeAround(+ VGroup(self.items[0], self.pde)+ ))+ self.play(+ FadeOutAndShift(bc_paren, UP),+ FadeInFrom(bc_words, DOWN),+ )+ self.wait()++ self.bc_words = bc_words++ def write_bc_equation(self):+ bc_words = self.bc_words++ equation = TexMobject(+ "{\\partial {T} \\over \\partial {x}}(0, {t}) = ",+ "{\\partial {T} \\over \\partial {x}}(L, {t}) = ",+ "0",+ **self.tex_mobject_config,+ )+ equation.next_to(bc_words, DOWN, MED_LARGE_BUFF)++ self.play(+ self.camera_frame.shift, 0.8 * DOWN,+ )+ self.play(FadeInFrom(equation, UP))+ self.wait()+++class HeatEquationFrame(WriteHeatEquationTemplate):+ def construct(self):+ equation = self.get_d1_equation()+ equation.to_edge(UP, buff=MED_SMALL_BUFF)++ ddx = equation[-11:]+ dt = equation[:11]++ full_rect = FullScreenFadeRectangle(+ fill_color=DARK_GREY,+ fill_opacity=1,+ )+ smaller_rect = ScreenRectangle(+ height=6,+ fill_color=BLACK,+ fill_opacity=1,+ stroke_color=WHITE,+ stroke_width=2,+ )+ smaller_rect.next_to(equation, DOWN)++ self.add(full_rect)+ self.add(smaller_rect)+ self.add(equation)+ self.wait()+ self.play(ShowCreationThenFadeAround(+ ddx,+ surrounding_rectangle_config={+ "stroke_color": GREEN,+ }+ ))+ self.wait()+ self.play(ShowCreationThenFadeAround(dt))self.wait()+++class CompareFreqDecays(Scene):+ CONFIG = {+ "freqs": [1, 2]+ }++ def construct(self):+ pass