Calculating support reactions is a common requirement in structural analysis. Automating this process with Python can save significant time. You will now apply your understanding of static equilibrium and moments to compute the vertical reaction forces at the supports of a simply supported beam loaded with several point forces. This exercise will reinforce the principles of equilibrium and introduce you to structuring such calculations programmatically.


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

class TestTask(unittest.TestCase):
    def test_returns_tuple_of_two(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.calculate_beam_reactions(
            beam_length=10,
            support_positions=(0, 10),
            point_loads=[(2, 5), (7, 10)]
        )
        _dynamic_test(
            self,
            isinstance(result, tuple) and len(result) == 2,
            "Function returns a tuple of two reaction forces.",
            f"Expected tuple of two, got: {result}",
        )

    def test_force_balance(self):
        import user_code
        importlib.reload(user_code)
        point_loads = [(2, 5), (7, 10)]
        total_load = sum(F for (x, F) in point_loads)
        result = user_code.calculate_beam_reactions(
            beam_length=10,
            support_positions=(0, 10),
            point_loads=point_loads
        )
        _dynamic_test(
            self,
            result is not None and abs(sum(result) - total_load) < 1e-8,
            "Sum of reaction forces equals sum of point loads.",
            f"Sum of reactions {result} does not equal total load {total_load}.",
        )

    def test_moment_balance_about_A(self):
        import user_code
        importlib.reload(user_code)
        support_positions = (0, 10)
        point_loads = [(2, 5), (7, 10)]
        xA, xB = support_positions
        result = user_code.calculate_beam_reactions(
            beam_length=10,
            support_positions=support_positions,
            point_loads=point_loads
        )
        RB = result[1] if result is not None else None
        moment_about_A = sum(F * (x - xA) for (x, F) in point_loads)
        expected_RB = moment_about_A / (xB - xA)
        _dynamic_test(
            self,
            RB is not None and abs(RB - expected_RB) < 1e-8,
            "Reaction at support B satisfies moment equilibrium about A.",
            f"RB={RB}, expected {expected_RB} for moment equilibrium.",
        )

    def test_arbitrary_support_positions(self):
        import user_code
        importlib.reload(user_code)
        support_positions = (1, 7)
        point_loads = [(3, 4), (5, 6)]
        xA, xB = support_positions
        total_load = sum(F for (x, F) in point_loads)
        moment_about_A = sum(F * (x - xA) for (x, F) in point_loads)
        expected_RB = moment_about_A / (xB - xA)
        expected_RA = total_load - expected_RB
        result = user_code.calculate_beam_reactions(
            beam_length=8,
            support_positions=support_positions,
            point_loads=point_loads
        )
        _dynamic_test(
            self,
            result is not None and abs(result[0] - expected_RA) < 1e-8 and abs(result[1] - expected_RB) < 1e-8,
            "Function works for arbitrary support positions.",
            f"Expected ({expected_RA},{expected_RB}), got {result}.",
        )

    def test_multiple_point_loads(self):
        import user_code
        importlib.reload(user_code)
        support_positions = (0, 8)
        point_loads = [(1, 3), (3, 2), (5, 7)]
        xA, xB = support_positions
        total_load = sum(F for (x, F) in point_loads)
        moment_about_A = sum(F * (x - xA) for (x, F) in point_loads)
        expected_RB = moment_about_A / (xB - xA)
        expected_RA = total_load - expected_RB
        result = user_code.calculate_beam_reactions(
            beam_length=8,
            support_positions=support_positions,
            point_loads=point_loads
        )
        _dynamic_test(
            self,
            result is not None and abs(result[0] - expected_RA) < 1e-8 and abs(result[1] - expected_RB) < 1e-8,
            "Function handles multiple point loads at arbitrary positions.",
            f"Expected ({expected_RA},{expected_RB}), got {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: Beam Reaction Forces

Ratkaisu

Challenge: Beam Reaction Forces

Ratkaisu