Comparing system responses is essential for design decisions. This challenge will help you automate comparative analysis using Python. You will use your knowledge of **mass-spring-damper system simulation** and **plotting** to directly compare the time-domain responses of two different systems. By visualizing both displacement curves on the same graph, you can quickly identify differences in performance, such as **damping**, **oscillation frequency**, or **settling time**.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import math
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

class TestTask(unittest.TestCase):
    def setUp(self):
        # Reload user module for each test
        import user_code
        importlib.reload(user_code)
        self.uc = user_code
        self.t = [i*0.01 for i in range(1001)]

    def test_displacement_first_system(self):
        # The function must compute the displacement for the first system using the provided parameters and time vector
        x1 = self.uc.simulate_mass_spring_damper(1.0, 0.2, 2.0, 1.0, 0.0, self.t)
        _dynamic_test(
            self,
            isinstance(x1, list) and len(x1) == len(self.t) and abs(x1[0] - 1.0) < 1e-6,
            "First system displacement computed and starts at correct initial value",
            f"Displacement for first system not computed correctly. Length: {len(x1)}; First value: {x1[0] if x1 else None}"
        )
        # Check that the displacement decreases over time (damped)
        _dynamic_test(
            self,
            x1[100] < x1[0],
            "First system displacement shows decay (damping present)",
            f"Displacement for first system does not show decay: x1[0]={x1[0]}, x1[100]={x1[100]}"
        )

    def test_displacement_second_system(self):
        # The function must compute the displacement for the second system using the provided parameters and time vector
        x2 = self.uc.simulate_mass_spring_damper(1.0, 0.8, 2.0, 1.0, 0.0, self.t)
        _dynamic_test(
            self,
            isinstance(x2, list) and len(x2) == len(self.t) and abs(x2[0] - 1.0) < 1e-6,
            "Second system displacement computed and starts at correct initial value",
            f"Displacement for second system not computed correctly. Length: {len(x2)}; First value: {x2[0] if x2 else None}"
        )
        # Should decay faster due to higher damping
        _dynamic_test(
            self,
            abs(x2[100]) < abs(x2[100] + 0.1),
            "Second system shows expected decay in displacement",
            f"Displacement for second system does not show expected decay: x2[0]={x2[0]}, x2[100]={x2[100]}"
        )

    def test_displacement_same_length(self):
        # Both displacement lists must have the same length as the time vector
        x1 = self.uc.simulate_mass_spring_damper(1.0, 0.2, 2.0, 1.0, 0.0, self.t)
        x2 = self.uc.simulate_mass_spring_damper(1.0, 0.8, 2.0, 1.0, 0.0, self.t)
        _dynamic_test(
            self,
            len(x1) == len(self.t) and len(x2) == len(self.t),
            "Both displacement lists have the same length as the time vector",
            f"x1 length: {len(x1)}, x2 length: {len(x2)}, t length: {len(self.t)}"
        )

    def test_plot_labels_and_legend(self):
        # The script must plot both displacement curves with clear labeling and a legend
        import sys
        import types
        import builtins
        # Patch plt.show to prevent blocking
        plt_show_called = {'called': False}
        orig_show = plt.show
        def fake_show(*args, **kwargs):
            plt_show_called['called'] = True
        plt.show = fake_show

        # Reload user_code and run script
        import user_code
        importlib.reload(user_code)
        # Check that both lines are in the axes
        found_labels = []
        for ax in plt.gcf().axes:
            for line in ax.get_lines():
                found_labels.append(line.get_label())
        # Check for axis labels, title, and legend
        xlabel = plt.gca().get_xlabel()
        ylabel = plt.gca().get_ylabel()
        title = plt.gca().get_title()
        legend = plt.gca().get_legend()
        _dynamic_test(
            self,
            "System 1 (c=0.2)" in found_labels and "System 2 (c=0.8)" in found_labels,
            "Both system curves are plotted with correct labels",
            f"Expected curve labels not found. Found: {found_labels}"
        )
        _dynamic_test(
            self,
            xlabel.lower().startswith("time"),
            "X-axis is labeled as time",
            f"X-axis label is not correct: {xlabel}"
        )
        _dynamic_test(
            self,
            ylabel.lower().startswith("displacement"),
            "Y-axis is labeled as displacement",
            f"Y-axis label is not correct: {ylabel}"
        )
        _dynamic_test(
            self,
            "mass-spring-damper" in title.lower(),
            "Plot title contains 'mass-spring-damper'",
            f"Plot title is not correct: {title}"
        )
        _dynamic_test(
            self,
            legend is not None,
            "Legend is present on the plot",
            "Legend is missing from the plot"
        )
        plt.show = orig_show

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: Compare System Responses

Solution