As you continue your journey into structural analysis, you have already explored how to model beams, analyze loads, and even break down forces in truss structures. One of the most critical checks in designing safe and efficient truss systems is ensuring that every joint is in **equilibrium**. This means that the sum of all forces—both horizontal and vertical—acting at a joint must be zero (within a small tolerance to account for rounding errors). If a joint is not in **equilibrium**, the structure could fail or behave unpredictably under load. By calculating the horizontal and vertical components of each force at a joint and verifying their sums, you can confirm whether the structure will remain stable at that point. This approach is a cornerstone of both manual and automated structural design processes.


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

class TestTask(unittest.TestCase):
    def test_equilibrium_case(self):
        import user_code
        importlib.reload(user_code)
        # Equilibrium: 3 forces of equal magnitude, 120 deg apart
        forces = [(10, 0), (10, 120), (10, 240)]
        result = user_code.check_joint_equilibrium(forces)
        _dynamic_test(
            self,
            result is not None and isinstance(result, tuple) and len(result) == 3,
            "Function returns tuple of 3 values",
            f"Expected tuple of 3 values, got {result}",
        )
        sum_h, sum_v, is_eq = result
        _dynamic_test(
            self,
            abs(sum_h) < 1e-5 and abs(sum_v) < 1e-5,
            "Horizontal and vertical sums are near zero for equilibrium forces",
            f"Expected sums near zero, got h: {sum_h}, v: {sum_v}",
        )
        _dynamic_test(
            self,
            is_eq is True,
            "Equilibrium boolean is True for equilibrium case",
            f"Expected equilibrium True, got {is_eq}",
        )

    def test_nonequilibrium_case(self):
        import user_code
        importlib.reload(user_code)
        # Non-equilibrium: Only two forces at 90 deg
        forces = [(5, 0), (5, 90)]
        result = user_code.check_joint_equilibrium(forces)
        _dynamic_test(
            self,
            result is not None and isinstance(result, tuple) and len(result) == 3,
            "Function returns tuple of 3 values",
            f"Expected tuple of 3 values, got {result}",
        )
        sum_h, sum_v, is_eq = result
        _dynamic_test(
            self,
            abs(sum_h - 5) < 1e-5 and abs(sum_v - 5) < 1e-5,
            "Horizontal and vertical sums are correct for non-equilibrium forces",
            f"Expected h: 5, v: 5, got h: {sum_h}, v: {sum_v}",
        )
        _dynamic_test(
            self,
            is_eq is False,
            "Equilibrium boolean is False for non-equilibrium case",
            f"Expected equilibrium False, got {is_eq}",
        )

    def test_different_magnitudes(self):
        import user_code
        importlib.reload(user_code)
        # Forces with different magnitudes
        forces = [(3, 0), (4, 90), (5, 180)]
        result = user_code.check_joint_equilibrium(forces)
        _dynamic_test(
            self,
            result is not None and isinstance(result, tuple) and len(result) == 3,
            "Function returns tuple of 3 values",
            f"Expected tuple of 3 values, got {result}",
        )
        sum_h, sum_v, is_eq = result
        # Horizontal: 3 + (-5) = -2, Vertical: 4
        _dynamic_test(
            self,
            abs(sum_h + 2) < 1e-5 and abs(sum_v - 4) < 1e-5,
            "Horizontal and vertical sums are correct for mixed forces",
            f"Expected h: -2, v: 4, got h: {sum_h}, v: {sum_v}",
        )
        _dynamic_test(
            self,
            is_eq is False,
            "Equilibrium boolean is False for non-equilibrium case",
            f"Expected equilibrium False, got {is_eq}",
        )

    def test_empty_forces(self):
        import user_code
        importlib.reload(user_code)
        # No forces
        forces = []
        result = user_code.check_joint_equilibrium(forces)
        _dynamic_test(
            self,
            result is not None and isinstance(result, tuple) and len(result) == 3,
            "Function returns tuple of 3 values for empty input",
            f"Expected tuple of 3 values, got {result}",
        )
        sum_h, sum_v, is_eq = result
        _dynamic_test(
            self,
            abs(sum_h) < 1e-5 and abs(sum_v) < 1e-5 and is_eq is True,
            "Empty force list returns equilibrium at zero",
            f"Expected zeros and True, got h: {sum_h}, v: {sum_v}, eq: {is_eq}",
        )

    def test_negative_angles(self):
        import user_code
        importlib.reload(user_code)
        # Negative angles
        forces = [(10, -90), (10, 0), (10, 90)]
        result = user_code.check_joint_equilibrium(forces)
        _dynamic_test(
            self,
            result is not None and isinstance(result, tuple) and len(result) == 3,
            "Function returns tuple of 3 values for negative angles",
            f"Expected tuple of 3 values, got {result}",
        )
        sum_h, sum_v, is_eq = result
        # Horizontal: 10 + 0 + 0 = 10, Vertical: -10 + 0 + 10 = 0
        _dynamic_test(
            self,
            abs(sum_h - 10) < 1e-5 and abs(sum_v) < 1e-5,
            "Horizontal and vertical sums are correct for negative angles",
            f"Expected h: 10, v: 0, got h: {sum_h}, v: {sum_v}",
        )
        _dynamic_test(
            self,
            is_eq is False,
            "Equilibrium boolean is False for non-equilibrium negative angle case",
            f"Expected equilibrium False, got {is_eq}",
        )

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: Truss Joint Equilibrium

Solution