A community-maintained Python framework for creating mathematical animations.
Further progress on clacks solution
Grant Sanderson04d5ad2a9fe2
diff --git a/active_projects/clacks.py b/active_projects/clacks.pyindex 575db8fb5..d2f17b5cc 100644--- a/active_projects/clacks.py+++ b/active_projects/clacks.py@@ -3,31 +3,75 @@ import subprocessfrom pydub import AudioSegment+class Block(Square):+ CONFIG = {+ "mass": 1,+ "velocity": 0,+ "width": None,+ "label_text": None,+ "label_scale_value": 0.8,+ "fill_opacity": 1,+ "stroke_width": 3,+ "stroke_color": WHITE,+ "fill_color": None,+ "sheen_direction": UL,+ "sheen": 0.5,+ "sheen_direction": UL,+ }++ def __init__(self, **kwargs):+ digest_config(self, kwargs)+ if self.width is None:+ self.width = self.mass_to_width(self.mass)+ if self.fill_color is None:+ self.fill_color = self.mass_to_color(self.mass)+ if self.label_text is None:+ self.label_text = self.mass_to_label_text(self.mass)+ Square.__init__(self, side_length=self.width, **kwargs)+ self.label = self.get_label()+ self.add(self.label)++ def get_label(self):+ label = TextMobject(self.label_text)+ label.scale(self.label_scale_value)+ label.next_to(self, UP, SMALL_BUFF)+ return label++ def get_points_defining_boundary(self):+ return self.points++ def mass_to_color(self, mass):+ colors = [+ LIGHT_GREY,+ BLUE_B,+ BLUE_D,+ BLUE_E,+ BLUE_E,+ DARK_GREY,+ DARK_GREY,+ BLACK,+ ]+ index = min(int(np.log10(mass)), len(colors) - 1)+ return colors[index]++ def mass_to_width(self, mass):+ return 1 + 0.25 * np.log10(mass)++ def mass_to_label_text(self, mass):+ return "{:,}\\,kg".format(int(mass))++class SlidingBlocks(VGroup):CONFIG = {"block1_config": {- "mass": 1,- "velocity": -2,"distance": 7,- "width": None,- "color": None,- "label_text": None,+ "mass": 1e6,+ "velocity": -2,},"block2_config": {+ "distance": 3,"mass": 1,"velocity": 0,- "distance": 3,- "width": None,- "color": None,- "label_text": None,- },- "block_style": {- "fill_opacity": 1,- "stroke_width": 3,- "stroke_color": WHITE,- "sheen_direction": UL,- "sheen_factor": 0.5,- "sheen_direction": UL,},"collect_clack_data": True,}@@ -51,30 +95,13 @@ class SlidingBlocks(VGroup):if self.collect_clack_data:self.clack_data = self.get_clack_data()- def get_block(self, mass, distance, velocity, width, color, label_text):- if width is None:- width = self.mass_to_width(mass)- if color is None:- color = self.mass_to_color(mass)- if label_text is None:- label_text = "{:,}\\,kg".format(int(mass))- block = Square(side_length=width)- block.mass = mass- block.velocity = velocity-- style = dict(self.block_style)- style["fill_color"] = color-- block.set_style(**style)+ def get_block(self, distance, **kwargs):+ block = Block(**kwargs)block.move_to(self.floor.get_top()[1] * UP +(self.wall.get_right()[0] + distance) * RIGHT,DL,)- label = block.label = TextMobject(label_text)- label.scale(0.8)- label.next_to(block, UP, SMALL_BUFF)- block.add(label)return blockdef get_phase_space_point_tracker(self):@@ -101,36 +128,6 @@ class SlidingBlocks(VGroup):)self.update_blocks_from_phase_space_point_tracker()- def old_update_positions(self, dt):- # Based on velocity diagram bouncing...didn't work for- # large masses, due to frame rate mismatch- blocks = self.submobjects- for block in blocks:- block.shift(block.velocity * dt * RIGHT)- if blocks[0].get_left()[0] < blocks[1].get_right()[0]:- # Two blocks collide- m1 = blocks[0].mass- m2 = blocks[1].mass- v1 = blocks[0].velocity- v2 = blocks[1].velocity- v_phase_space_point = np.array([- np.sqrt(m1) * v1, -np.sqrt(m2) * v2- ])- angle = 2 * np.arctan(np.sqrt(m2 / m1))- new_vps_point = rotate_vector(v_phase_space_point, angle)- for block, value in zip(blocks, new_vps_point):- block.velocity = value / np.sqrt(block.mass)- blocks[1].move_to(blocks[0].get_corner(DL), DR)- self.surrounding_scene.clack(blocks[0].get_left())- if blocks[1].get_left()[0] < self.wall.get_right()[0]:- # Second block hits wall- blocks[1].velocity *= -1- blocks[1].move_to(self.wall.get_corner(DR), DL)- if blocks[0].get_left()[0] < blocks[1].get_right()[0]:- blocks[0].move_to(blocks[1].get_corner(DR), DL)- self.surrounding_scene.clack(blocks[1].get_left())- return self-def update_blocks_from_phase_space_point_tracker(self):block1, block2 = self.block1, self.block2@@ -196,23 +193,6 @@ class SlidingBlocks(VGroup):clack_data.append((location, time))return clack_data- def mass_to_color(self, mass):- colors = [- LIGHT_GREY,- BLUE_B,- BLUE_D,- BLUE_E,- BLUE_E,- DARK_GREY,- DARK_GREY,- BLACK,- ]- index = min(int(np.log10(mass)), len(colors) - 1)- return colors[index]-- def mass_to_width(self, mass):- return 1 + 0.25 * np.log10(mass)-class ClackFlashes(ContinualAnimation):CONFIG = {@@ -254,6 +234,33 @@ class ClackFlashes(ContinualAnimation):self.mobject.remove(flash.mobject)+class Wall(Line):+ CONFIG = {+ "tick_spacing": 0.5,+ "tick_length": 0.25,+ "tick_style": {+ "stroke_width": 1,+ "stroke_color": WHITE,+ },+ }++ def __init__(self, height, **kwargs):+ Line.__init__(self, ORIGIN, height * UP, **kwargs)+ self.height = height+ self.ticks = self.get_ticks()+ self.add(self.ticks)++ def get_ticks(self):+ n_lines = int(self.height / self.tick_spacing)+ lines = VGroup(*[+ Line(ORIGIN, self.tick_length * UR).shift(n * self.tick_spacing * UP)+ for n in range(n_lines)+ ])+ lines.set_style(**self.tick_style)+ lines.move_to(self, DR)+ return lines++class BlocksAndWallScene(Scene):CONFIG = {"include_sound": True,@@ -319,16 +326,10 @@ class BlocksAndWallScene(Scene):self.counter_mob = counter_mobdef get_wall(self):- wall = Line(self.floor_y * UP, FRAME_HEIGHT * UP / 2)+ height = (FRAME_HEIGHT / 2) - self.floor_y+ wall = Wall(height=height)wall.shift(self.wall_x * RIGHT)- lines = VGroup(*[- Line(ORIGIN, 0.25 * UR)- for x in range(self.n_wall_ticks)- ])- lines.set_stroke(width=1)- lines.arrange_submobjects(UP, buff=MED_SMALL_BUFF)- lines.move_to(wall, DR)- wall.add(lines)+ wall.to_edge(UP, buff=0)return walldef get_floor(self):@@ -1151,7 +1152,7 @@ class CompareToGalacticMass(Scene):"velocity": -0.01,"distance": 4.5,"label_text": "$100^{(20 - 1)}$ kg",- "color": BLACK,+ "fill_color": BLACK,},"block2_config": {"distance": 1,diff --git a/active_projects/clacks_solution1.py b/active_projects/clacks_solution1.pyindex 81b5676fb..e7e76539c 100644--- a/active_projects/clacks_solution1.py+++ b/active_projects/clacks_solution1.py@@ -2,7 +2,6 @@ from big_ol_pile_of_manim_imports import *from active_projects.clacks import *-# TODO, add solution imageclass FromPuzzleToSolution(MovingCameraScene):def construct(self):@@ -21,7 +20,7 @@ class FromPuzzleToSolution(MovingCameraScene):images = Group(ImageMobject("BlocksAndWallExampleMass16"),- ImageMobject("SphereSurfaceProof2"), # TODO+ ImageMobject("SphereSurfaceProof2"), # TODO)for title, rect, image in zip(titles, rects, images):title.scale(1.5)@@ -45,7 +44,6 @@ class FromPuzzleToSolution(MovingCameraScene):self.wait()-class BlocksAndWallExampleMass16(BlocksAndWallExample):CONFIG = {"sliding_blocks_config": {@@ -139,3 +137,540 @@ class BlocksAndWallExampleMassTrillion(BlocksAndWallExample):"min_time_between_sounds": 0.001,}++# TODO, add sound+class AskAboutFindingNewVelocities(Scene):+ CONFIG = {+ "sound_file": None,+ "floor_y": -3,+ "wall_x": -6.5,+ "wall_height": 7,+ "block1_config": {+ "mass": 10,+ "fill_color": BLUE_E,+ "velocity": -1,+ },+ "block2_config": {"mass": 1},+ "block1_start_x": 7,+ "block2_start_x": 3,+ "v_arrow_scale_value": 1.0,+ "is_halted": False,+ }++ def construct(self):+ self.add_floor()+ self.add_wall()+ self.add_blocks()+ self.add_velocity_labels()++ self.ask_about_transfer()+ self.show_ms_and_vs()+ self.show_value_on_equations()++ def add_floor(self):+ floor = self.floor = Line(+ self.wall_x * RIGHT,+ (FRAME_WIDTH / 2) * RIGHT,+ )+ floor.shift(self.floor_y * UP)+ self.add(floor)++ def add_wall(self):+ wall = self.wall = Wall(height=self.wall_height)+ wall.move_to(+ self.wall_x * RIGHT + self.floor_y * UP,+ DR,+ )+ self.add(wall)++ def add_blocks(self):+ block1 = self.block1 = Block(**self.block1_config)+ block2 = self.block2 = Block(**self.block2_config)+ blocks = self.blocks = VGroup(block1, block2)+ block1.move_to(self.block1_start_x * RIGHT + self.floor_y * UP, DOWN)+ block2.move_to(self.block2_start_x * RIGHT + self.floor_y * UP, DOWN)++ self.add_velocity_phase_space_point()+ # Add arrows+ for block in blocks:+ arrow = Vector(self.block_to_v_vector(block))+ arrow.set_color(RED)+ arrow.set_stroke(BLACK, 1, background=True)+ arrow.move_to(block.get_center(), RIGHT)+ block.arrow = arrow+ block.add(arrow)++ block.v_label = DecimalNumber(+ block.velocity,+ num_decimal_places=2,+ background_stroke_width=2,+ )+ block.v_label.set_color(RED)+ block.add(block.v_label)++ # Add updater+ blocks.add_updater(self.update_blocks)+ self.add(+ blocks,+ block2.arrow, block1.arrow,+ block2.v_label, block1.v_label,+ )++ def add_velocity_phase_space_point(self):+ self.vps_point = VectorizedPoint([+ np.sqrt(self.block1.mass) * self.block1.velocity,+ np.sqrt(self.block2.mass) * self.block2.velocity,+ 0+ ])++ def add_velocity_labels(self):+ v_labels = self.get_next_velocity_labels()++ self.add(v_labels)++ def ask_about_transfer(self):+ energy_expression, momentum_expression = \+ self.get_energy_and_momentum_expressions()+ energy_words = TextMobject("Conservation of energy:")+ energy_words.move_to(UP)+ energy_words.to_edge(LEFT, buff=1.5)+ momentum_words = TextMobject("Conservation of momentum:")+ momentum_words.next_to(+ energy_words, DOWN,+ buff=0.7,+ )++ energy_expression.next_to(energy_words, RIGHT, MED_LARGE_BUFF)+ momentum_expression.next_to(energy_expression, DOWN)+ momentum_expression.next_to(momentum_words, RIGHT)++ velocity_labels = self.all_velocity_labels+ randy = Randolph(height=2)+ randy.next_to(velocity_labels, DR)+ randy.save_state()+ randy.fade(1)++ # Up to collisions+ self.go_through_next_collision()+ self.play(+ randy.restore,+ randy.change, "pondering", velocity_labels[0],+ )+ self.halt()+ self.play(randy.look_at, velocity_labels[-1])+ self.play(Blink(randy))+ self.play(+ FadeInFrom(energy_words, RIGHT),+ FadeInFromDown(energy_expression),+ FadeOut(randy),+ )+ self.wait()+ self.play(+ FadeInFrom(momentum_words, RIGHT),+ FadeInFromDown(momentum_expression)+ )+ self.wait()++ self.energy_expression = energy_expression+ self.energy_words = energy_words+ self.momentum_expression = momentum_expression+ self.momentum_words = momentum_words++ def show_ms_and_vs(self):+ block1 = self.block1+ block2 = self.block2+ energy_expression = self.energy_expression+ momentum_expression = self.momentum_expression++ for block in self.blocks:+ block.shift_onto_screen()++ m1_labels = VGroup(+ block1.label,+ energy_expression.get_part_by_tex("m_1"),+ momentum_expression.get_part_by_tex("m_1"),+ )+ m2_labels = VGroup(+ block2.label,+ energy_expression.get_part_by_tex("m_2"),+ momentum_expression.get_part_by_tex("m_2"),+ )+ v1_labels = VGroup(+ block1.v_label,+ energy_expression.get_part_by_tex("v_1"),+ momentum_expression.get_part_by_tex("v_1"),+ )+ v2_labels = VGroup(+ block2.v_label,+ energy_expression.get_part_by_tex("v_2"),+ momentum_expression.get_part_by_tex("v_2"),+ )+ label_groups = VGroup(+ m1_labels, m2_labels,+ v1_labels, v2_labels,+ )+ for group in label_groups:+ group.rects = VGroup(*map(+ SurroundingRectangle,+ group+ ))++ for group in label_groups:+ self.play(LaggedStart(+ ShowCreation, group.rects,+ lag_ratio=0.8,+ run_time=1,+ ))+ self.play(FadeOut(group.rects))++ def show_value_on_equations(self):+ energy_expression = self.energy_expression+ momentum_expression = self.momentum_expression+ energy_text = VGroup(energy_expression, self.energy_words)+ momentum_text = VGroup(momentum_expression, self.momentum_words)+ block1 = self.block1+ block2 = self.block2+ block1.save_state()+ block2.save_state()++ v_terms, momentum_v_terms = [+ VGroup(*[+ expr.get_part_by_tex("v_{}".format(d))+ for d in [1, 2]+ ])+ for expr in [energy_expression, momentum_expression]+ ]+ v_braces = VGroup(*[+ Brace(term, UP, buff=SMALL_BUFF)+ for term in v_terms+ ])+ v_decimals = VGroup(*[DecimalNumber(0) for x in range(2)])++ def update_v_decimals(v_decimals):+ values = self.get_velocities()+ for decimal, value, brace in zip(v_decimals, values, v_braces):+ decimal.set_value(value)+ decimal.next_to(brace, UP, SMALL_BUFF)++ update_v_decimals(v_decimals)++ energy_const_brace, momentum_const_brace = [+ Brace(+ expr.get_part_by_tex("const"), UP,+ buff=SMALL_BUFF,+ )+ for expr in [energy_expression, momentum_expression]+ ]++ sqrt_m_vect = np.array([+ np.sqrt(self.block1.mass),+ np.sqrt(self.block2.mass),+ 0+ ])++ def get_energy():+ return 0.5 * get_norm(self.vps_point.get_location())**2++ def get_momentum():+ return np.dot(self.vps_point.get_location(), sqrt_m_vect)++ energy_decimal = DecimalNumber(get_energy())+ energy_decimal.next_to(energy_const_brace, UP, SMALL_BUFF)+ momentum_decimal = DecimalNumber(get_momentum())+ momentum_decimal.next_to(momentum_const_brace, UP, SMALL_BUFF)++ VGroup(+ energy_const_brace, energy_decimal,+ momentum_const_brace, momentum_decimal,+ ).set_color(YELLOW)++ self.play(+ CircleThenFadeAround(energy_expression),+ momentum_text.set_fill, {"opacity": 0.25},+ FadeOut(self.all_velocity_labels),+ )+ self.play(*[+ *map(GrowFromCenter, v_braces),+ *map(VFadeIn, v_decimals),+ GrowFromCenter(energy_const_brace),+ FadeIn(energy_decimal),+ ])+ energy_decimal.add_updater(+ lambda m: m.set_value(get_energy())+ )+ v_decimals.add_updater(update_v_decimals)+ self.add(v_decimals)+ self.unhalt()+ for x in range(4):+ self.go_through_next_collision(+ include_velocity_label_animation=False,+ )+ energy_decimal.clear_updaters()+ momentum_decimal.set_value(get_momentum())+ self.halt()+ self.play(*[+ momentum_text.set_fill, {"opacity": 1},+ FadeOut(energy_text),+ FadeOut(energy_const_brace),+ FadeOut(energy_decimal),+ GrowFromCenter(momentum_const_brace),+ FadeIn(momentum_decimal),+ *[+ ApplyMethod(b.next_to, vt, UP, SMALL_BUFF)+ for b, vt in zip(v_braces, momentum_v_terms)+ ],+ ])+ self.unhalt()+ momentum_decimal.add_updater(+ lambda m: m.set_value(get_momentum())+ )+ momentum_decimal.add_updater(+ lambda m: m.next_to(momentum_const_brace, UP, SMALL_BUFF)+ )+ for x in range(4):+ self.go_through_next_collision(+ include_velocity_label_animation=False,+ )+ self.wait(10)++ # Helpers++ def get_energy_and_momentum_expressions(self):+ tex_to_color_map = {+ "v_1": RED_B,+ "v_2": RED_B,+ "m_1": BLUE_C,+ "m_2": BLUE_C,+ }+ energy_expression = TexMobject(+ "\\frac{1}{2} m_1 (v_1)^2 + ",+ "\\frac{1}{2} m_2 (v_2)^2 = ",+ "\\text{const.}",+ tex_to_color_map=tex_to_color_map,+ )+ momentum_expression = TexMobject(+ "m_1 v_1 + m_2 v_2 =", "\\text{const.}",+ tex_to_color_map=tex_to_color_map+ )+ return VGroup(+ energy_expression,+ momentum_expression,+ )++ def go_through_next_collision(self, include_velocity_label_animation=True):+ block2 = self.block2+ if block2.velocity >= 0:+ self.wait_until(self.blocks_are_hitting)+ self.transfer_momentum()+ edge = RIGHT+ else:+ self.wait_until(self.block2_is_hitting_wall)+ self.reflect_block2()+ edge = LEFT+ anims = [Flash(block2.get_edge_center(edge))]+ if include_velocity_label_animation:+ anims.append(self.get_next_velocity_labels_animation())+ self.play(*anims, run_time=0.5)++ def get_next_velocity_labels_animation(self):+ return FadeInFrom(+ self.get_next_velocity_labels(),+ LEFT,+ run_time=0.5+ )++ def get_next_velocity_labels(self, v1=None, v2=None):+ new_labels = self.get_velocity_labels(v1, v2)+ if hasattr(self, "all_velocity_labels"):+ arrow = Vector(RIGHT)+ arrow.next_to(self.all_velocity_labels)+ new_labels.next_to(arrow, RIGHT)+ new_labels.add(arrow)+ else:+ self.all_velocity_labels = VGroup()+ self.all_velocity_labels.add(new_labels)+ return new_labels++ def get_velocity_labels(self, v1=None, v2=None):+ default_vs = self.get_velocities()+ v1 = v1 or default_vs[0]+ v2 = v2 or default_vs[1]+ labels = VGroup(+ TexMobject("v_1 = {:.2f}".format(v1)),+ TexMobject("v_2 = {:.2f}".format(v2)),+ )+ labels.arrange_submobjects(+ DOWN,+ buff=MED_SMALL_BUFF,+ aligned_edge=LEFT,+ )+ labels.scale(0.9)+ for label in labels:+ label[:2].set_color(RED)+ labels.next_to(self.wall, RIGHT)+ labels.to_edge(UP, buff=MED_SMALL_BUFF)+ return labels++ def update_blocks(self, blocks, dt):+ for block, velocity in zip(blocks, self.get_velocities()):+ block.velocity = velocity+ if not self.is_halted:+ block.shift(block.velocity * dt * RIGHT)+ center = block.get_center()+ block.arrow.put_start_and_end_on(+ center,+ center + self.block_to_v_vector(block),+ )+ max_height = 0.25+ block.v_label.set_value(block.velocity)+ if block.v_label.get_height() > max_height:+ block.v_label.set_height(max_height)+ block.v_label.next_to(+ block.arrow.get_start(), DOWN,+ buff=SMALL_BUFF,+ )+ return blocks++ def block_to_v_vector(self, block):+ return block.velocity * self.v_arrow_scale_value * RIGHT++ def blocks_are_hitting(self):+ x1 = self.block1.get_left()[0]+ x2 = self.block2.get_right()[0]+ buff = 0.01+ return (x1 < x2 + buff)++ def block2_is_hitting_wall(self):+ x2 = self.block2.get_left()[0]+ buff = 0.01+ return (x2 < self.wall_x + buff)++ def get_velocities(self):+ m1 = self.block1.mass+ m2 = self.block2.mass+ vps_coords = self.vps_point.get_location()+ return [+ vps_coords[0] / np.sqrt(m1),+ vps_coords[1] / np.sqrt(m2),+ ]++ def transfer_momentum(self):+ m1 = self.block1.mass+ m2 = self.block2.mass+ theta = np.arctan(np.sqrt(m2 / m1))+ self.reflect_block2()+ self.vps_point.rotate(2 * theta, about_point=ORIGIN)++ def reflect_block2(self):+ self.vps_point.points[:, 1] *= -1++ def halt(self):+ self.is_halted = True++ def unhalt(self):+ self.is_halted = False+++class IntroduceVelocityPhaseSpace(AskAboutFindingNewVelocities):+ CONFIG = {+ "wall_height": 1.5,+ "floor_y": -3.5,+ "block1_start_x": 5,+ "block2_start_x": 0,+ }++ def construct(self):+ self.add_wall_floor_and_blocks()+ self.show_two_equations()+ self.draw_axes()+ self.draw_ellipse()+ self.rescale_axes()+ self.show_starting_point()+ self.show_initial_collide()+ self.ask_about_where_to_land()+ self.show_conservation_of_momentum_equation()+ self.show_momentum_line()+ self.reiterate_meaning_of_line_and_circle()+ self.show_first_jump()+ self.show_bounce_off_wall()+ self.show_reflection_about_x()+ self.show_remaining_collisions()++ def add_wall_floor_and_blocks(self):+ self.add_floor()+ self.add_wall()+ self.add_blocks()+ self.halt()++ def show_two_equations(self):+ equations = self.get_energy_and_momentum_expressions()+ equations.arrange_submobjects(DOWN, buff=LARGE_BUFF)+ equations.shift(UP)+ v1_terms, v2_terms = [+ VGroup(*[+ expr.get_parts_by_tex(tex)+ for expr in equations+ ])+ for tex in ("v_1", "v_2")+ ]++ self.add(equations)+ self.play(LaggedStart(+ AnimationGroup,+ equations.copy().set_stroke(YELLOW, 3).set_fill(opacity=0),+ lambda m: (ShowCreation(m), FadeOut(m)),+ lag_ratio=0.8,+ remover=True,+ ))+ # self.play(*[+ # LaggedStart(+ # ShowCreationThenDestruction,+ # expr.copy().set_stroke(YELLOW, 5),+ # remover=True+ # )+ # for expr in equations+ # ])+ self.play(*map(Indicate, v1_terms))+ self.play(*map(Indicate, v2_terms))+ self.wait()++ self.equations = equations++ def draw_axes(self):+ pass++ def draw_ellipse(self):+ pass++ def rescale_axes(self):+ pass++ def show_starting_point(self):+ pass++ def show_initial_collide(self):+ pass++ def ask_about_where_to_land(self):+ pass++ def show_conservation_of_momentum_equation(self):+ pass++ def show_momentum_line(self):+ pass++ def reiterate_meaning_of_line_and_circle(self):+ pass++ def show_first_jump(self):+ pass++ def show_bounce_off_wall(self):+ pass++ def show_reflection_about_x(self):+ pass++ def show_remaining_collisions(self):+ pass