Damped oscillators are common in engineering. This challenge will help you automate their simulation and analysis. When a mass is attached to a spring and damper, its motion is governed by the balance of restoring, damping, and inertial forces. For underdamped systems, the displacement follows a characteristic exponentially decaying oscillation, which is important for predicting how real-world mechanical systems behave after being disturbed.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import math

class TestTask(unittest.TestCase):
    def test_returns_list_with_correct_length(self):
        import user_code
        importlib.reload(user_code)
        duration = 1.0
        dt = 0.1
        expected_length = int(duration / dt) + 1
        result = user_code.damped_oscillator_displacement(1.0, 10.0, 1.0, 1.0, 0.0, duration, dt)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == expected_length,
            f"Returned list has correct number of elements: {expected_length}",
            f"Expected list of length {expected_length}, got {len(result) if isinstance(result, list) else 'not a list'}",
        )

    def test_initial_displacement(self):
        import user_code
        importlib.reload(user_code)
        x0 = 1.5
        result = user_code.damped_oscillator_displacement(1.0, 10.0, 1.0, x0, 0.0, 1.0, 0.05)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) > 0 and math.isclose(result[0], x0, abs_tol=1e-9),
            "First value equals initial displacement x0",
            f"Expected first value {x0}, got {result[0] if isinstance(result, list) and len(result) > 0 else result}",
        )

    def test_amplitude_decreases(self):
        import user_code
        importlib.reload(user_code)
        # Use a clear underdamped case
        m = 1.0
        k = 10.0
        c = 1.0
        x0 = 2.0
        v0 = 0.0
        duration = 2.0
        dt = 0.05
        result = user_code.damped_oscillator_displacement(m, k, c, x0, v0, duration, dt)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) >= 3,
            "Function returns a list with at least 3 values",
            f"Expected at least 3 values, got {len(result) if isinstance(result, list) else 'not a list'}",
        )
        # Check that the envelope (absolute value) decreases over time
        abs_vals = [abs(x) for x in result]
        decreasing = all(y <= x + 1e-8 for x, y in zip(abs_vals, abs_vals[1:])) or all(y < x for x, y in zip(abs_vals, abs_vals[1:]))
        # However, since oscillations, check if the max of the second half is less than max of first half
        half = len(abs_vals) // 2
        max1 = max(abs_vals[:half])
        max2 = max(abs_vals[half:])
        _dynamic_test(
            self,
            max2 < max1,
            "Oscillation amplitude decreases over time (damping present)",
            f"Expected amplitude to decrease, but max in second half ({max2}) not less than first half ({max1})",
        )

    def test_various_parameters(self):
        import user_code
        importlib.reload(user_code)
        # Try a different set of parameters
        m = 2.0
        k = 20.0
        c = 2.0
        x0 = 0.5
        v0 = 0.2
        duration = 2.0
        dt = 0.2
        result = user_code.damped_oscillator_displacement(m, k, c, x0, v0, duration, dt)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == int(duration/dt)+1,
            "Function handles different parameters and returns correct length list",
            f"Expected list of length {int(duration/dt)+1}, got {len(result) if isinstance(result, list) else 'not a list'}",
        )
        # Check that the first value is x0
        _dynamic_test(
            self,
            math.isclose(result[0], x0, abs_tol=1e-9),
            "First value matches initial displacement for different parameters",
            f"Expected {x0}, got {result[0] if isinstance(result, list) and len(result) > 0 else result}",
        )

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

Explore how Python empowers mechanical engineers to solve real-world engineering problems, automate calculations, analyze data, and visualize results. This course blends mechanical engineering concepts with practical Python programming, focusing on applications such as statics, dynamics, thermodynamics, and data analysis.

Learn to use Python for solving statics problems, automating engineering calculations, and visualizing forces and moments.

Apply Python to model, simulate, and analyze dynamic mechanical systems, including motion, vibration, and system response.

Use Python to analyze thermodynamic processes, automate calculations, and visualize engineering data.

Challenge: Damped Oscillator Simulation

解答