In structural engineering, accurately modeling beams and their loadings is crucial for safe and efficient design. A beam subjected to various loads—such as point loads at specific positions—requires careful analysis to determine its structural response. Visualizing the distribution of these loads along the beam is a foundational step before proceeding to calculations like shear force or bending moment diagrams. Such visualizations help you quickly identify load locations and magnitudes, improving both communication and understanding during design and review.


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 user_code

class TestTask(unittest.TestCase):
    def setUp(self):
        importlib.reload(user_code)
        self.func = getattr(user_code, 'plot_beam_loads', None)

    def test_function_exists(self):
        _dynamic_test(
            self,
            callable(self.func),
            "Function 'plot_beam_loads' is defined.",
            "Function 'plot_beam_loads' is not defined.",
        )

    def test_beam_line_drawn(self):
        # Patch plt.subplots to capture plot calls
        called = {'beam': False}
        orig_subplots = plt.subplots
        def fake_subplots(*args, **kwargs):
            fig, ax = orig_subplots(*args, **kwargs)
            orig_plot = ax.plot
            def fake_plot(x, y, *a, **k):
                # Check if this is the beam line
                if x == [0, 8] and y == [0, 0]:
                    called['beam'] = True
                return orig_plot(x, y, *a, **k)
            ax.plot = fake_plot
            return fig, ax
        plt.subplots = fake_subplots
        try:
            self.func(8, [1, 3.5, 6.5], [10, 15, 8])
        finally:
            plt.subplots = orig_subplots
        _dynamic_test(
            self,
            called['beam'],
            "Beam line drawn from 0 to beam_length at y=0.",
            "Beam line not drawn correctly from 0 to beam_length.",
        )

    def test_arrows_and_labels(self):
        # Patch plt.subplots and ax.arrow/text to capture calls
        arrows = []
        texts = []
        orig_subplots = plt.subplots
        def fake_subplots(*args, **kwargs):
            fig, ax = orig_subplots(*args, **kwargs)
            def fake_arrow(x, y, dx, dy, **k):
                arrows.append((x, y, dx, dy, k))
            def fake_text(x, y, s, **k):
                texts.append((x, y, s, k))
            ax.arrow = fake_arrow
            ax.text = fake_text
            return fig, ax
        plt.subplots = fake_subplots
        try:
            self.func(8, [1, 3.5, 6.5], [10, 15, 8])
        finally:
            plt.subplots = orig_subplots
        # Check arrows
        expected_arrows = [(1, 0.2, 0, -0.15), (3.5, 0.2, 0, -0.15), (6.5, 0.2, 0, -0.15)]
        found = 0
        for x, y, dx, dy, k in arrows:
            if (x, y, dx, dy) in expected_arrows:
                found += 1
        _dynamic_test(
            self,
            found == 3,
            "All three downward arrows for loads are drawn at correct positions.",
            f"Expected 3 downward arrows, found {found}.",
        )
        # Check labels
        mags = ["10 kN", "15 kN", "8 kN"]
        mags_found = 0
        for _, y, s, _ in texts:
            if y > 0 and s in mags:
                mags_found += 1
        _dynamic_test(
            self,
            mags_found == 3,
            "Each load magnitude is labeled above its arrow.",
            f"Expected 3 magnitude labels above arrows, found {mags_found}.",
        )
        # Check positions
        pos_labels = ["1 m", "3.5 m", "6.5 m"]
        pos_found = 0
        for _, y, s, _ in texts:
            if y < 0 and s in pos_labels:
                pos_found += 1
        _dynamic_test(
            self,
            pos_found == 3,
            "Each load position is labeled below the beam.",
            f"Expected 3 position labels below the beam, found {pos_found}.",
        )

    def test_works_for_any_input(self):
        # Test with different input lengths
        arrows = []
        texts = []
        orig_subplots = plt.subplots
        def fake_subplots(*args, **kwargs):
            fig, ax = orig_subplots(*args, **kwargs)
            def fake_arrow(x, y, dx, dy, **k):
                arrows.append((x, y, dx, dy, k))
            def fake_text(x, y, s, **k):
                texts.append((x, y, s, k))
            ax.arrow = fake_arrow
            ax.text = fake_text
            return fig, ax
        plt.subplots = fake_subplots
        try:
            self.func(5, [0, 2.5, 5], [7, 12, 5])
        finally:
            plt.subplots = orig_subplots
        # Check correct number of arrows and labels
        _dynamic_test(
            self,
            len(arrows) == 3,
            "Function works for any valid input size (arrows drawn).",
            f"Expected 3 arrows for loads, found {len(arrows)}.",
        )
        mags = ["7 kN", "12 kN", "5 kN"]
        pos_labels = ["0 m", "2.5 m", "5 m"]
        mag_count = sum(1 for _, y, s, _ in texts if y > 0 and s in mags)
        pos_count = sum(1 for _, y, s, _ in texts if y < 0 and s in pos_labels)
        _dynamic_test(
            self,
            mag_count == 3 and pos_count == 3,
            "Function correctly labels magnitude and position for any valid input.",
            f"Expected 3 magnitude and 3 position labels, found {mag_count} and {pos_count}.",
        )

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 civil engineers to solve real-world engineering problems, automate calculations, and analyze data. This course blends practical coding with civil engineering scenarios, focusing on structural analysis, materials, and project management.

Learn how Python can be used to automate and solve common structural analysis problems in civil engineering, including beam calculations, load analysis, and visualization of structural responses.

Apply Python to analyze and visualize data related to construction materials, quality control, and site measurements, supporting better engineering decisions.

Use Python to automate project management tasks, optimize resource allocation, and support decision-making in civil engineering projects.

Challenge: Plot Load Distribution

Solução