You are about to model the motion of a roller coaster and analyze its energy transformations as it moves along a track. In this challenge, you will calculate the kinetic and potential energy at various positions, and visualize how energy is conserved throughout the ride. This task will help you see how physics principles like **conservation of energy** play out in a real-world scenario, reinforcing your understanding of **kinetic** and **potential energy** from the previous chapters.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

class TestTask(unittest.TestCase):
    def setUp(self):
        self.mass = 500
        self.heights = np.array([30, 25, 20, 15, 10, 5, 0, 5, 10, 15])
        self.velocities = np.array([0, 5, 10, 15, 20, 22, 24, 20, 15, 10])
        self.g = 9.81

    def test_returns_length(self):
        import user_code
        importlib.reload(user_code)
        pe, ke, te = user_code.roller_coaster_energy_analysis(self.mass, self.heights, self.velocities, self.g)
        _dynamic_test(
            self,
            all(isinstance(arr, np.ndarray) and len(arr) == len(self.heights) for arr in [pe, ke, te]),
            "All returned arrays have the correct length.",
            f"Returned arrays should have length {len(self.heights)}. Got lengths: {[len(arr) if isinstance(arr, np.ndarray) else type(arr) for arr in [pe, ke, te]]}.",
        )

    def test_potential_energy(self):
        import user_code
        importlib.reload(user_code)
        pe, _, _ = user_code.roller_coaster_energy_analysis(self.mass, self.heights, self.velocities, self.g)
        expected_pe = self.mass * self.g * self.heights
        _dynamic_test(
            self,
            np.allclose(pe, expected_pe),
            "Potential energy is calculated correctly for all positions.",
            f"Potential energy incorrect. Expected: {expected_pe}, got: {pe}",
        )

    def test_kinetic_energy(self):
        import user_code
        importlib.reload(user_code)
        _, ke, _ = user_code.roller_coaster_energy_analysis(self.mass, self.heights, self.velocities, self.g)
        expected_ke = 0.5 * self.mass * self.velocities ** 2
        _dynamic_test(
            self,
            np.allclose(ke, expected_ke),
            "Kinetic energy is calculated correctly for all positions.",
            f"Kinetic energy incorrect. Expected: {expected_ke}, got: {ke}",
        )

    def test_total_energy(self):
        import user_code
        importlib.reload(user_code)
        pe, ke, te = user_code.roller_coaster_energy_analysis(self.mass, self.heights, self.velocities, self.g)
        expected_te = (self.mass * self.g * self.heights) + (0.5 * self.mass * self.velocities ** 2)
        _dynamic_test(
            self,
            np.allclose(te, expected_te),
            "Total energy is the sum of kinetic and potential energy at each position.",
            f"Total energy incorrect. Expected: {expected_te}, got: {te}",
        )

    def test_plot_created(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.roller_coaster_energy_analysis(self.mass, self.heights, self.velocities, self.g)
        figs = [plt.figure(n) for n in plt.get_fignums()]
        _dynamic_test(
            self,
            len(figs) > 0,
            "A plot is generated by the function.",
            "No plot was generated by the function.",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

A hands-on Python course designed specifically for physics students, focusing on applying Python programming to solve real-world physics problems. Each section blends engaging theory with practical challenges, covering topics from kinematics to data analysis and visualization.

Explore the fundamentals of motion using Python, from basic displacement calculations to simulating projectile trajectories and analyzing real-world movement data.

Dive into the world of forces and energy, using Python to model Newton's laws, simulate collisions, and analyze energy transformations.

Master the use of Python for analyzing, interpreting, and visualizing experimental and simulated physics data.

Challenge: Roller Coaster Energy Analysis

解答