In this challenge, you will work with displacement versus time data collected from a spring-mass system in oscillation. Your goal is to fit a **sinusoidal model** to the data, visualize both the raw measurements and the fitted curve, and analyze the quality of your fit by examining the **residuals**. This exercise will help you develop practical skills in model fitting and validation, which are essential for analyzing real experimental data in physics.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import numpy as np
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def setUp(self):
        np.random.seed(42)
        self.t = np.linspace(0, 10, 100)
        self.true_params = [1.2, 2.0, 0.5, 0.0]
        self.y_clean = self.true_params[0] * np.sin(self.true_params[1] * self.t + self.true_params[2]) + self.true_params[3]
        self.y_noisy = self.y_clean + np.random.normal(0, 0.1, size=self.t.shape)

    def test_returns_fitted_params_type_and_length(self):
        import user_code
        importlib.reload(user_code)
        params, residuals = user_code.fit_and_plot_spring_data(self.t, self.y_noisy)
        cond = (isinstance(params, (np.ndarray, list)) and len(params) == 4)
        _dynamic_test(
            self,
            cond,
            "Function returns four fitted parameters as list or numpy array",
            f"Expected 4 fit parameters, got: {params}"
        )

    def test_returns_residuals_shape(self):
        import user_code
        importlib.reload(user_code)
        params, residuals = user_code.fit_and_plot_spring_data(self.t, self.y_noisy)
        cond = (isinstance(residuals, np.ndarray) and residuals.shape == self.t.shape)
        _dynamic_test(
            self,
            cond,
            "Residuals returned as numpy array with correct shape",
            f"Expected residuals shape {self.t.shape}, got: {getattr(residuals, 'shape', None)}"
        )

    def test_fit_curve_matches_data_features(self):
        import user_code
        importlib.reload(user_code)
        params, residuals = user_code.fit_and_plot_spring_data(self.t, self.y_noisy)
        # Reconstruct fitted curve
        y_fit = user_code.sinusoidal_model(self.t, *params)
        # Compute mean squared error
        mse = np.mean((self.y_noisy - y_fit) ** 2)
        _dynamic_test(
            self,
            mse < 0.05,
            "Fitted curve closely matches the main features of the input data (MSE < 0.05)",
            f"Fitted curve MSE too high: {mse}"
        )

    def test_residuals_are_difference(self):
        import user_code
        importlib.reload(user_code)
        params, residuals = user_code.fit_and_plot_spring_data(self.t, self.y_noisy)
        y_fit = user_code.sinusoidal_model(self.t, *params)
        diff = np.abs(residuals - (self.y_noisy - y_fit))
        _dynamic_test(
            self,
            np.all(diff < 1e-7),
            "Residuals are computed as difference between measured and fitted values",
            f"Residuals not correct: max diff = {np.max(diff)}"
        )

    def test_plots_are_generated(self):
        import user_code
        importlib.reload(user_code)
        import matplotlib
        matplotlib.use('Agg')
        # Capture output to ensure plt.show() is called
        f = io.StringIO()
        with redirect_stdout(f):
            params, residuals = user_code.fit_and_plot_spring_data(self.t, self.y_noisy)
        # Check that at least two figures are created
        from matplotlib import pyplot as plt
        num_figures = len(plt.get_fignums())
        _dynamic_test(
            self,
            num_figures >= 2,
            "Both data/fit and residuals plots are generated and displayed",
            f"Expected at least 2 plots, got {num_figures}"
        )
        # Close all figures
        plt.close('all')

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: Fit a Spring's Oscillation Data

解答