Understanding how beams deflect under load is a fundamental part of structural engineering, as it helps ensure that structures remain safe, serviceable, and comfortable for users. Earlier, you explored how to model beams and apply loads in Python. Now, you will build on that knowledge by focusing on the calculation of maximum deflection for a simply supported beam subjected to a uniform distributed load. This calculation is vital in real-world design, as excessive deflection may compromise both the safety and usability of a structure. The standard formula for the maximum deflection of such a beam is:

\[
\delta_{max} = \frac{5 w L^4}{384 E I}
\]

where `w` is the load per unit length, `L` is the length of the beam, `E` is the modulus of elasticity, and `I` is the moment of inertia.


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

class TestTask(unittest.TestCase):
    def test_correct_deflection(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'max_beam_deflection', None)
        _dynamic_test(
            self,
            callable(func),
            "Function 'max_beam_deflection' is defined.",
            "Function 'max_beam_deflection' is not defined."
        )
        if func:
            result = func(10.0, 6.0, 200e6, 8e-4)
            expected = (5 * 10.0 * 6.0 ** 4) / (384 * 200e6 * 8e-4)
            _dynamic_test(
                self,
                abs(result - expected) < 1e-9,
                "Function returns correct maximum deflection for sample values.",
                f"Expected {expected}, got {result}."
            )

    def test_zero_load(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'max_beam_deflection', None)
        if func:
            result = func(0, 6.0, 200e6, 8e-4)
            _dynamic_test(
                self,
                result == 0,
                "Function returns zero when load is zero.",
                f"Expected 0 for zero load, got {result}."
            )
        else:
            _dynamic_test(self, False, "", "Function 'max_beam_deflection' is not defined.")

    def test_zero_length(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'max_beam_deflection', None)
        if func:
            result = func(10.0, 0, 200e6, 8e-4)
            _dynamic_test(
                self,
                result == 0,
                "Function returns zero when length is zero.",
                f"Expected 0 for zero length, got {result}."
            )
        else:
            _dynamic_test(self, False, "", "Function 'max_beam_deflection' is not defined.")

    def test_various_inputs(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'max_beam_deflection', None)
        test_cases = [
            (5, 4, 210e6, 1e-3),
            (2.5, 3, 180e6, 2e-4),
            (15, 5.5, 200e6, 9e-4),
        ]
        for w, L, E, I in test_cases:
            if func:
                expected = (5 * w * L ** 4) / (384 * E * I)
                result = func(w, L, E, I)
                _dynamic_test(
                    self,
                    abs(result - expected) < 1e-9,
                    f"Correct result for w={w}, L={L}, E={E}, I={I}.",
                    f"Expected {expected}, got {result} for w={w}, L={L}, E={E}, I={I}."
                )
            else:
                _dynamic_test(self, False, "", "Function 'max_beam_deflection' is not defined.")

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: Calculate Beam Deflection

Soluzione