Visualizing truss structures and applied forces is crucial for understanding load paths. This challenge will help you automate truss visualization. In structural engineering, a **truss** is a framework composed of straight members connected at nodes. Being able to plot these elements and show how **forces** act on the structure makes analysis and communication much clearer. Using `python` and `matplotlib`, you can quickly generate accurate diagrams from data, making your workflow more efficient and your results more understandable.


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

class TestTask(unittest.TestCase):
    def setUp(self):
        global user_code
        import user_code
        importlib.reload(user_code)
        self.user_code = user_code
        # Sample data for tests
        self.nodes = [(0, 0), (2, 0), (1, 1.5)]
        self.members = [(0, 1), (1, 2), (2, 0)]
        self.forces = [(1, 0, -1), (2, 1, 0)]

    def test_plot_truss_members(self):
        # Patch plt.subplots to capture lines
        lines_drawn = []
        orig_plot = plt.Axes.plot
        def fake_plot(axself, x, y, *args, **kwargs):
            lines_drawn.append((tuple(x), tuple(y)))
            return orig_plot(axself, x, y, *args, **kwargs)
        plt.Axes.plot = fake_plot
        try:
            self.user_code.plot_truss(self.nodes, self.members, [])
        finally:
            plt.Axes.plot = orig_plot
        # Check that each member line is drawn between correct nodes
        expected_lines = set()
        for n1, n2 in self.members:
            x_vals = (self.nodes[n1][0], self.nodes[n2][0])
            y_vals = (self.nodes[n1][1], self.nodes[n2][1])
            expected_lines.add((x_vals, y_vals))
        actual_lines = set(lines_drawn)
        _dynamic_test(
            self,
            expected_lines.issubset(actual_lines),
            "Function draws all truss members as lines between the specified nodes.",
            f"Expected lines: {expected_lines}, but got: {actual_lines}"
        )

    def test_plot_truss_nodes_and_labels(self):
        # Patch plt.Axes.plot and plt.Axes.text to capture node points and labels
        node_points = []
        node_labels = []
        orig_plot = plt.Axes.plot
        orig_text = plt.Axes.text
        def fake_plot(axself, x, y, *args, **kwargs):
            if args and args[0] == 'ko':
                node_points.append((x[0], y[0]))
            return orig_plot(axself, x, y, *args, **kwargs)
        def fake_text(axself, x, y, s, *args, **kwargs):
            node_labels.append((x, y, s))
            return orig_text(axself, x, y, s, *args, **kwargs)
        plt.Axes.plot = fake_plot
        plt.Axes.text = fake_text
        try:
            self.user_code.plot_truss(self.nodes, self.members, [])
        finally:
            plt.Axes.plot = orig_plot
            plt.Axes.text = orig_text
        # Each node point should be drawn
        node_coords = set(self.nodes)
        actual_points = set(node_points)
        _dynamic_test(
            self,
            node_coords.issubset(actual_points),
            "Function marks each node as a point.",
            f"Expected node points: {node_coords}, got: {actual_points}"
        )
        # Each node label should be present
        expected_labels = {f'N{i}' for i in range(len(self.nodes))}
        actual_labels = {label for _, _, label in node_labels}
        _dynamic_test(
            self,
            expected_labels.issubset(actual_labels),
            "Function labels each node with the correct index.",
            f"Expected node labels: {expected_labels}, got: {actual_labels}"
        )

    def test_plot_truss_forces_and_labels(self):
        # Patch ax.arrow and ax.text to capture arrows and force labels
        arrows = []
        force_labels = []
        orig_subplots = plt.subplots
        orig_arrow = plt.Axes.arrow
        orig_text = plt.Axes.text
        def fake_arrow(axself, x, y, dx, dy, *args, **kwargs):
            arrows.append((x, y, dx, dy))
            return orig_arrow(axself, x, y, dx, dy, *args, **kwargs)
        def fake_text(axself, x, y, s, *args, **kwargs):
            force_labels.append((x, y, s))
            return orig_text(axself, x, y, s, *args, **kwargs)
        plt.Axes.arrow = fake_arrow
        plt.Axes.text = fake_text
        try:
            self.user_code.plot_truss(self.nodes, self.members, self.forces)
        finally:
            plt.Axes.arrow = orig_arrow
            plt.Axes.text = orig_text
        # Each force should be drawn as an arrow at the correct node with correct direction
        expected_arrows = set()
        for node_idx, fx, fy in self.forces:
            x, y = self.nodes[node_idx]
            expected_arrows.add((x, y, fx, fy))
        actual_arrows = set(arrows)
        _dynamic_test(
            self,
            expected_arrows.issubset(actual_arrows),
            "Function draws arrows for all applied forces at the correct node positions, with direction and magnitude matching the force components.",
            f"Expected arrows: {expected_arrows}, got: {actual_arrows}"
        )
        # Each force label should be present
        expected_force_labels = {f'F{node_idx}' for node_idx, _, _ in self.forces}
        actual_force_labels = {label for _, _, label in force_labels if label and label.startswith('F')}
        _dynamic_test(
            self,
            expected_force_labels.issubset(actual_force_labels),
            "Function labels each force arrow with the correct node index.",
            f"Expected force labels: {expected_force_labels}, got: {actual_force_labels}"
        )

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: Visualize Truss Forces

解答