def test_inertia_specification_overlap():
"""Test if the inertia is specified in all lengths."""
with pytest.raises(RuntimeError):
a = beam("l", x0=0)
a.set_inertia(0, "l/2", "I")
a.set_inertia("l/2", "3*l/4", 4 * I)
a.solve(output=False)
def test_hyperstatic_2():
"""Test if hyperstatic beams are detected."""
with pytest.raises(RuntimeError):
a = beam("l", x0=0)
a.add_support(0, "fixed")
a.add_support("l", "roller")
a.solve(output=False)
def test_young_specification_overlap():
"""Test if the Young modulus is specified in all lengths."""
with pytest.raises(RuntimeError):
a = beam("l", x0=0)
a.set_young(0, "l/2", E)
a.set_young("l/2", "3*l/4", 4 * E)
a.solve(output=False)
def test_cantilever_point():
"""Test classical cantilever beam with point load."""
a = beam("L", x0=0)
a.add_support(0, "fixed")
a.add_point_load(L, -P)
a.solve(output=False)
errors = []
length_points = len(a.points) == 2
length_segments = len(a.segments) == 1
x0_coord = a.points[0].x_coord == sym.sympify(0)
xl_coord = a.points[1].x_coord == L
x_start_coord = a.segments[0].x_start == sym.sympify(0)
x_end_coord = a.segments[0].x_end == L
young = a.segments[0].young == E
inertia = a.segments[0].inertia == I
reaction_force = (a.points[0].reaction_force
== P) and (a.points[1].reaction_force == sym.sympify(0))
reaction_moment = (a.points[0].reaction_moment == P *
L) and (a.points[1].reaction_moment == sym.sympify(0))
shear_force = a.segments[0].shear_force == -P
bending_moment = a.segments[0].bending_moment == -L * P + P * x
deflection = a.segments[0].deflection == -L * P * x**2 / (
2 * E * I) + P * x**3 / (6 * E * I)
rotation = a.segments[0].rotation == -L * P * x / (E * I) + P * x**2 / (
2 * E * I)
if not (length_points):
errors.append("Error in the length of the list of points.")
if not (length_segments):
errors.append("Error in the length if the list of segments.")
if not (x0_coord) or not (xl_coord):
errors.append("Error in point coordinates.")
if not (x_start_coord) or not (x_end_coord):
errors.append("Error in the segment coordinates.")
if not (young) or not (inertia):
errors.append("Error in the segment properties.")
if not (reaction_force):
errors.append("Error in reaction force computation.")
if not (reaction_moment):
errors.append("Error in reaction moment computation.")
if not (shear_force):
errors.append("Error in shear force diagram.")
if not (bending_moment):
errors.append("Error in bending moment diagram.")
if not (deflection):
errors.append("Error in deflection.")
if not (rotation):
errors.append("Error in rotation.")
# An empty list is False for Python
assert not errors, "The following errors ocurred:\n{}".format(
"\n".join(errors))
def test_plot_distributed_loads_fixed_right():
"""Test the plotting function for distributed loads and fixed support on the right."""
a = beam(L)
a.add_support(L, "fixed")
a.add_distributed_load(0, L / 2, "-q * x")
a.add_distributed_load(L / 2, L, "q * (L - x)")
a.solve()
fig, ax = a.plot(subs={"q": 1000})
return fig
def test_plot_distributed_loads_fixed_left():
"""Test the plotting function for distributed loads and fixed support on the left.
Additionally, test plotting of continuity points.
"""
a = beam(L)
a.add_support(0, "fixed")
a.add_distributed_load(0, L / 2, "-q * x")
a.add_distributed_load(L / 2, L, "q * (L - x)")
a.solve()
fig, ax = a.plot(subs={"q": 1000})
return fig
def test_plot_point_loads():
"""Test the plotting function for pins, rollers, hinges and point forces and moments.
The figures generated with the current version are compared against reference files.
"""
a = beam(L)
a.add_support(0, "pin")
a.add_support(L / 4, "roller")
a.add_support(L / 2, "hinge")
a.add_support(L, "roller")
a.add_point_load(L / 4, -P)
a.add_point_load(3 * L / 4, P / 2)
a.add_point_moment(L / 8, M)
a.add_point_moment(7 * L / 8, -M / 2)
a.solve()
fig, ax = a.plot(subs={"P": 1000, "L": 2, "M": 1000})
return fig
def test_inertia_specification_missing():
"""Test if the inertia is specified in all lengths."""
with pytest.raises(RuntimeError):
a = beam("l", x0=0)
a.set_inertia(0, "l/2", I)
a.solve(output=False)
def test_support_inside_beam():
"""Test if an error is raised when the supports lies outside the beam."""
with pytest.raises(RuntimeError):
a = beam("l")
a.add_support("2*l", "fixed")
def test_beam_numeric_length():
"""Test if a numeric length is accepted for the beam."""
a = beam(1)
assert a.length == 1
def test_beam_two_symbols():
"""Test if an error is reaised if more than one symbols is used to initialise the beam."""
with pytest.raises(RuntimeError):
a = beam("L * a", x0=0)
def test_half_span_force():
"""Test classical problem of pin-roller beam with half-span point force."""
a = beam("L", x0=0)
a.add_support(0, "pin")
a.add_support("L", "roller")
a.add_point_load("L/2", "-P")
a.solve(output=False)
errors = []
length_points = len(a.points) == 3
length_segments = len(a.segments) == 2
x_coord = (a.points[0].x_coord == sym.sympify(0)
and a.points[1].x_coord == L / 2 and a.points[2].x_coord == L)
x_start_coord = (a.segments[0].x_start == sym.sympify(0)
and a.segments[1].x_start == L / 2)
x_end_coord = a.segments[0].x_end == L / 2 and a.segments[0].x_end == L
young = a.segments[0].young == E and a.segments[1].young == E
inertia = a.segments[0].inertia == I and a.segments[1].inertia == I
reaction_force = (a.points[0].reaction_force == P / 2
and a.points[1].reaction_force == sym.sympify(0)
and a.points[2].reaction_force == P / 2)
reaction_moment = (a.points[0].reaction_moment == sym.sympify(0)
and a.points[1].reaction_moment == sym.sympify(0)
and a.points[2].reaction_moment == sym.sympify(0))
shear_force = a.segments[0].shear_force == -P / 2 and a.segments[
1].shear_force == P / 2
bending_moment = (a.segments[0].bending_moment == P * x / 2 and
a.segments[1].bending_moment == P * L / 2 - P * x / 2)
deflection_1 = -P * L**2 * x / (16 * E * I) + P * x**3 / (12 * E * I)
deflection_2 = (P * L**3 / (48 * E * I) - 3 * P * L**2 * x / (16 * E * I) +
P * L * x**2 / (4 * E * I) - P * x**3 / (12 * E * I))
rotation_1 = -P * L**2 / (16 * E * I) + P * x**2 / (4 * E * I)
rotation_2 = (-3 * P * L**2 / (16 * E * I) + P * L * x / (2 * E * I) -
P * x**2 / (4 * E * I))
deflection = (a.segments[0].deflection == deflection_1
and a.segments[1].deflection == deflection_2)
rotation = a.segments[0].rotation == rotation_1 and a.segments[
1].rotation == rotation_2
if not (length_points):
errors.append("Error in the length of the list of points.")
if not (length_segments):
errors.append("Error in the length if the list of segments.")
if not (x_coord):
errors.append("Error in point coordinates.")
if not (x_start_coord or x_end_coord):
errors.append("Error in the segment coordinates.")
if not (young) or not (inertia):
errors.append("Error in the segment properties.")
if not (reaction_force):
errors.append("Error in reaction force computation.")
if not (reaction_moment):
errors.append("Error in reaction moment computation.")
if not (shear_force):
errors.append("Error in shear force diagram.")
if not (bending_moment):
errors.append("Error in bending moment diagram.")
if not (deflection):
errors.append("Error in deflection.")
if not (rotation):
errors.append("Error in rotation.")
# An empty list is False for Python
assert not errors, "The following errors ocurred:\n{}".format(
"\n".join(errors))
def test_distributed_load_coordinates():
"""Test if the coordinates of the distributed load are consistent."""
with pytest.raises(RuntimeError):
a = beam(1)
a.add_distributed_load(1, 0.5, "q")
def test_point_moment_inside_beam():
"""Test if an error is raised when the point moment lies outside the beam."""
with pytest.raises(RuntimeError):
a = beam("l")
a.add_point_moment("2*l", "M")
def test_beam_symbolic_length():
"""Test if a symbolic length is accepted for the beam."""
a = beam("l")
assert a.length == sym.sympify("l")
def test_beam_distinct_symbols():
"""Test if an error is reaised if the symbols used for the inital position and length
are distinct.
"""
with pytest.raises(RuntimeError):
a = beam("L * a", x0="b")
def test_invalid_symbol_load():
"""Test if errors are raised when the coordinate of a load include the x variable."""
with pytest.raises(RuntimeError):
a = beam("l")
a.add_point_load("2*x", 1)
def test_discontinuous_properties():
"""Test a beam with discontinuous inertia and Young modulus."""
a = beam(3, x0=0)
a.add_support(0.5, "pin")
a.add_support(2.5, "roller")
a.add_point_load(0, "-P")
a.add_point_load(3, "-P")
a.set_young(0, 1.5, E / 1000)
a.set_young(1.5, 3, E)
a.set_inertia(0, 1, I)
a.set_inertia(1, 3, 100 * I)
a.solve(output=False)
errors = []
length_points = len(a.points) == 6
length_segments = len(a.segments) == 5
x_coord = (a.points[0].x_coord == sym.sympify(0)
and a.points[1].x_coord == sym.sympify(0.5)
and a.points[2].x_coord == sym.sympify(1)
and a.points[3].x_coord == sym.sympify(1.5)
and a.points[4].x_coord == sym.sympify(2.5)
and a.points[5].x_coord == sym.sympify(3))
x_start_coord = (a.segments[0].x_start == sym.sympify(0)
and a.segments[1].x_start == sym.sympify(0.5)
and a.segments[2].x_start == sym.sympify(1)
and a.segments[3].x_start == sym.sympify(1.5)
and a.segments[4].x_start == sym.sympify(2.5))
x_end_coord = (a.segments[0].x_end == sym.sympify(0.5)
and a.segments[1].x_end == sym.sympify(1)
and a.segments[2].x_end == sym.sympify(1.5)
and a.segments[3].x_end == sym.sympify(2.5)
and a.segments[4].x_end == sym.sympify(3))
young = (a.segments[0].young == E / 1000
and a.segments[1].young == E / 1000
and a.segments[2].young == E / 1000 and a.segments[3].young == E
and a.segments[4].young == E)
inertia = (a.segments[0].inertia == I and a.segments[1].inertia == I
and a.segments[2].inertia == I * 100
and a.segments[3].inertia == I * 100
and a.segments[4].inertia == I * 100)
reaction_force = (a.points[0].reaction_force == sym.sympify(0)
and a.points[1].reaction_force == P
and a.points[2].reaction_force == sym.sympify(0)
and a.points[3].reaction_force == sym.sympify(0)
and a.points[4].reaction_force == P
and a.points[5].reaction_force == sym.sympify(0))
reaction_moment = (a.points[0].reaction_moment == sym.sympify(0)
and a.points[1].reaction_moment == sym.sympify(0)
and a.points[2].reaction_moment == sym.sympify(0)
and a.points[3].reaction_moment == sym.sympify(0)
and a.points[4].reaction_moment == sym.sympify(0)
and a.points[5].reaction_moment == sym.sympify(0)
and a.points[5].reaction_moment == sym.sympify(0))
shear_force1 = P
shear_force2 = sym.sympify(0)
shear_force3 = -P
shear_force = (a.segments[0].shear_force == shear_force1
and a.segments[1].shear_force == shear_force2
and a.segments[2].shear_force == shear_force2
and a.segments[3].shear_force == shear_force2
and a.segments[4].shear_force == shear_force3)
bending_moment1 = -P * x
bending_moment2 = -0.5 * P
bending_moment3 = P * x - 3.0 * P
bending_moment = (a.segments[0].bending_moment == bending_moment1
and a.segments[1].bending_moment == bending_moment2
and a.segments[2].bending_moment == bending_moment2
and a.segments[3].bending_moment == bending_moment2
and a.segments[4].bending_moment == bending_moment3)
deflection_1 = (-500 * P * x**3 / (3 * E * I) + 345.31375 * P * x /
(E * I) - 151.823541666667 * P / (E * I))
deflection_2 = (-250.0 * P * x**2 / (E * I) + 470.31375 * P * x / (E * I) -
172.656875 * P / (E * I))
deflection_3 = (-2.5 * P * x**2 / (E * I) - 24.68625 * P * x / (E * I) +
74.843125 * P / (E * I))
deflection_4 = (-0.0025 * P * x**2 / (E * I) - 32.17875 * P * x / (E * I) +
80.4625 * P / (E * I))
deflection_5 = (0.0016666666666666 * P * x**3 / (E * I) -
0.015 * P * x**2 / (E * I) - 32.1475 * P * x / (E * I) +
80.4364583333333 * P / (E * I))
deflection = (a.segments[0].deflection.evalf(10) == deflection_1.evalf(10)
and a.segments[1].deflection == deflection_2
and a.segments[2].deflection == deflection_3
and a.segments[3].deflection == deflection_4 and
a.segments[4].deflection.evalf(10) == deflection_5.evalf(10))
rotation_1 = -500 * P * x**2 / (E * I) + 345.31375 * P / (E * I)
rotation_2 = -500.0 * P * x / (E * I) + 470.31375 * P / (E * I)
rotation_3 = -5.0 * P * x / (E * I) - 24.68625 * P / (E * I)
rotation_4 = -0.005 * P * x / (E * I) - 32.17875 * P / (E * I)
rotation_5 = (0.005 * P * x**2 / (E * I) - 0.03 * P * x / (E * I) -
32.1475 * P / (E * I))
rotation = (a.segments[0].rotation == rotation_1
and a.segments[1].rotation == rotation_2
and a.segments[2].rotation == rotation_3
and a.segments[3].rotation == rotation_4
and a.segments[4].rotation == rotation_5)
if not (length_points):
errors.append("Error in the length of the list of points.")
if not (length_segments):
errors.append("Error in the length if the list of segments.")
if not (x_coord):
errors.append("Error in point coordinates.")
if not (x_start_coord or x_end_coord):
errors.append("Error in the segment coordinates.")
if not (young) or not (inertia):
errors.append("Error in the segment properties.")
if not (reaction_force):
errors.append("Error in reaction force computation.")
if not (reaction_moment):
errors.append("Error in reaction moment computation.")
if not (shear_force):
errors.append("Error in shear force diagram.")
if not (bending_moment):
errors.append("Error in bending moment diagram.")
if not (deflection):
errors.append("Error in deflection.")
if not (rotation):
errors.append("Error in rotation.")
# An empty list is False for Python
assert not errors, "The following errors ocurred:\n{}".format(
"\n".join(errors))
def test_repeated_support():
"""Test if an error is raised when a repeated support is specified."""
with pytest.raises(RuntimeError):
a = beam("l")
a.add_support(0, "fixed")
a.add_support(0, "pin")
def test_complex_beam_hinge():
"""Test a complex structure with distributed loadings and hinges."""
a = beam(6, x0=0)
a.add_support(0, "fixed")
a.add_support(4, "hinge")
a.add_support(6, "roller")
a.add_point_moment(6, 20)
a.add_distributed_load(0, 2, "-5*x")
a.add_distributed_load(2, 4, "-(20-5*x)")
a.solve(output=False)
errors = []
length_points = len(a.points) == 4
length_segments = len(a.segments) == 3
x_coord = (a.points[0].x_coord == sym.sympify(0)
and a.points[1].x_coord == sym.sympify(2)
and a.points[2].x_coord == sym.sympify(4)
and a.points[3].x_coord == sym.sympify(6))
x_start_coord = (a.segments[0].x_start == sym.sympify(0)
and a.segments[1].x_start == sym.sympify(2)
and a.segments[2].x_start == sym.sympify(4))
x_end_coord = (a.segments[0].x_end == sym.sympify(2)
and a.segments[1].x_end == sym.sympify(4)
and a.segments[2].x_end == sym.sympify(6))
young = (a.segments[0].young == E and a.segments[1].young == E
and a.segments[2].young == E)
inertia = (a.segments[0].inertia == I and a.segments[1].inertia == I
and a.segments[2].inertia == I)
reaction_force = (a.points[0].reaction_force == sym.sympify(30)
and a.points[1].reaction_force == sym.sympify(0)
and a.points[3].reaction_force == sym.sympify(-10))
reaction_moment = (a.points[0].reaction_moment == sym.sympify(80)
and a.points[1].reaction_moment == sym.sympify(0)
and a.points[2].reaction_moment == sym.sympify(0))
shear_force1 = sym.sympify(5 * x**2 / 2 - 30)
shear_force2 = sym.sympify(-5 * x**2 / 2 + 20 * x - 50)
shear_force3 = sym.sympify(-10)
shear_force = (a.segments[0].shear_force == shear_force1
and a.segments[1].shear_force == shear_force2
and a.segments[2].shear_force == shear_force3)
bending_moment1 = sym.sympify("-5*x**3/6 + 30*x - 80")
bending_moment2 = sym.sympify("5*x**3/6 - 10*x**2 + 50*x - 280/3")
bending_moment3 = sym.sympify("10*x - 40")
bending_moment = (a.segments[0].bending_moment == bending_moment1
and a.segments[1].bending_moment == bending_moment2
and a.segments[2].bending_moment == bending_moment3)
deflection_1 = -(x**5) / (24 * E *
I) + 5 * x**3 / (E * I) - 40 * x**2 / (E * I)
deflection_2 = (x**5 / (24 * E * I) - 5 * x**4 / (6 * E * I) + 25 * x**3 /
(3 * E * I) - 140 * x**2 / (3 * E * I) + 20 * x /
(3 * E * I) - 8 / (3 * E * I))
deflection_3 = (5 * x**3 / (3 * E * I) - 20 * x**2 / (E * I) + 760 * x /
(3 * E * I) - 1160 / (E * I))
deflection = (a.segments[0].deflection == deflection_1
and a.segments[1].deflection == deflection_2
and a.segments[2].deflection == deflection_3)
rotation_1 = -5 * x**4 / (24 * E * I) + 15 * x**2 / (E * I) - 80 * x / (E *
I)
rotation_2 = (5 * x**4 / (24 * E * I) - 10 * x**3 / (3 * E * I) +
25 * x**2 / (E * I) - 280 * x / (3 * E * I) + 20 /
(3 * E * I))
rotation_3 = 5 * x**2 / (E * I) - 40 * x / (E * I) + 760 / (3 * E * I)
rotation = (a.segments[0].rotation == rotation_1
and a.segments[1].rotation == rotation_2
and a.segments[2].rotation == rotation_3)
if not (length_points):
errors.append("Error in the length of the list of points.")
if not (length_segments):
errors.append("Error in the length if the list of segments.")
if not (x_coord):
errors.append("Error in point coordinates.")
if not (x_start_coord or x_end_coord):
errors.append("Error in the segment coordinates.")
if not (young) or not (inertia):
errors.append("Error in the segment properties.")
if not (reaction_force):
errors.append("Error in reaction force computation.")
if not (reaction_moment):
errors.append("Error in reaction moment computation.")
if not (shear_force):
errors.append("Error in shear force diagram.")
if not (bending_moment):
errors.append("Error in bending moment diagram.")
if not (deflection):
errors.append("Error in deflection.")
if not (rotation):
errors.append("Error in rotation.")
# An empty list is False for Python
assert not errors, "The following errors ocurred:\n{}".format(
"\n".join(errors))