def test_insufficient_bconditions(): # Test cases when required number of boundary conditions # are not provided to solve the integration constants. L = symbols('L', positive=True) E, I, P, a3, a4 = symbols('E I P a3 a4') b = Beam(L, E, I, base_char='a') b.apply_load(R2, L, -1) b.apply_load(R1, 0, -1) b.apply_load(-P, L/2, -1) b.solve_for_reaction_loads(R1, R2) p = b.slope() q = P*SingularityFunction(x, 0, 2)/4 - P*SingularityFunction(x, L/2, 2)/2 + P*SingularityFunction(x, L, 2)/4 assert p == q/(E*I) + a3 p = b.deflection() q = P*SingularityFunction(x, 0, 3)/12 - P*SingularityFunction(x, L/2, 3)/6 + P*SingularityFunction(x, L, 3)/12 assert p == q/(E*I) + a3*x + a4 b.bc_deflection = [(0, 0)] p = b.deflection() q = a3*x + P*SingularityFunction(x, 0, 3)/12 - P*SingularityFunction(x, L/2, 3)/6 + P*SingularityFunction(x, L, 3)/12 assert p == q/(E*I) b.bc_deflection = [(0, 0), (L, 0)] p = b.deflection() q = -L**2*P*x/16 + P*SingularityFunction(x, 0, 3)/12 - P*SingularityFunction(x, L/2, 3)/6 + P*SingularityFunction(x, L, 3)/12 assert p == q/(E*I)
def test_max_deflection(): E, I, l, F = symbols('E, I, l, F', positive=True) b = Beam(l, E, I) b.bc_deflection = [(0, 0),(l, 0)] b.bc_slope = [(0, 0),(l, 0)] b.apply_load(F/2, 0, -1) b.apply_load(-F*l/8, 0, -2) b.apply_load(F/2, l, -1) b.apply_load(F*l/8, l, -2) b.apply_load(-F, l/2, -1) assert b.max_deflection() == (l/2, F*l**3/(192*E*I))
def test_apply_support(): E = Symbol('E') I = Symbol('I') b = Beam(4, E, I) b.apply_support(0, "cantilever") b.apply_load(20, 4, -1) M_0, R_0 = symbols('M_0, R_0') b.solve_for_reaction_loads(R_0, M_0) assert b.slope() == (80*SingularityFunction(x, 0, 1) - 10*SingularityFunction(x, 0, 2) + 10*SingularityFunction(x, 4, 2))/(E*I) assert b.deflection() == (40*SingularityFunction(x, 0, 2) - 10*SingularityFunction(x, 0, 3)/3 + 10*SingularityFunction(x, 4, 3)/3)/(E*I) b = Beam(30, E, I) b.apply_support(10, "pin") b.apply_support(30, "roller") b.apply_load(-8, 0, -1) b.apply_load(120, 30, -2) R_10, R_30 = symbols('R_10, R_30') b.solve_for_reaction_loads(R_10, R_30) assert b.slope() == (-4*SingularityFunction(x, 0, 2) + 3*SingularityFunction(x, 10, 2) + 120*SingularityFunction(x, 30, 1) + SingularityFunction(x, 30, 2) + S(4000)/3)/(E*I) assert b.deflection() == (4000*x/3 - 4*SingularityFunction(x, 0, 3)/3 + SingularityFunction(x, 10, 3) + 60*SingularityFunction(x, 30, 2) + SingularityFunction(x, 30, 3)/3 - 12000)/(E*I) P = Symbol('P', positive=True) L = Symbol('L', positive=True) b = Beam(L, E, I) b.apply_support(0, type='fixed') b.apply_support(L, type='fixed') b.apply_load(-P, L/2, -1) R_0, R_L, M_0, M_L = symbols('R_0, R_L, M_0, M_L') b.solve_for_reaction_loads(R_0, R_L, M_0, M_L) assert b.reaction_loads == {R_0: P/2, R_L: P/2, M_0: -L*P/8, M_L: L*P/8}
def test_variable_moment(): E = Symbol('E') I = Symbol('I') b = Beam(4, E, 2*(4 - x)) b.apply_load(20, 4, -1) R, M = symbols('R, M') b.apply_load(R, 0, -1) b.apply_load(M, 0, -2) b.bc_deflection = [(0, 0)] b.bc_slope = [(0, 0)] b.solve_for_reaction_loads(R, M) assert b.slope().expand() == ((10*x*SingularityFunction(x, 0, 0) - 10*(x - 4)*SingularityFunction(x, 4, 0))/E).expand() assert b.deflection().expand() == ((5*x**2*SingularityFunction(x, 0, 0) - 10*Piecewise((0, Abs(x)/4 < 1), (16*meijerg(((3, 1), ()), ((), (2, 0)), x/4), True)) + 40*SingularityFunction(x, 4, 1))/E).expand() b = Beam(4, E - x, I) b.apply_load(20, 4, -1) R, M = symbols('R, M') b.apply_load(R, 0, -1) b.apply_load(M, 0, -2) b.bc_deflection = [(0, 0)] b.bc_slope = [(0, 0)] b.solve_for_reaction_loads(R, M) assert b.slope().expand() == ((-80*(-log(-E) + log(-E + x))*SingularityFunction(x, 0, 0) + 80*(-log(-E + 4) + log(-E + x))*SingularityFunction(x, 4, 0) + 20*(-E*log(-E) + E*log(-E + x) + x)*SingularityFunction(x, 0, 0) - 20*(-E*log(-E + 4) + E*log(-E + x) + x - 4)*SingularityFunction(x, 4, 0))/I).expand()
def test_point_cflexure(): E = Symbol('E') I = Symbol('I') b = Beam(10, E, I) b.apply_load(-4, 0, -1) b.apply_load(-46, 6, -1) b.apply_load(10, 2, -1) b.apply_load(20, 4, -1) b.apply_load(3, 6, 0) assert b.point_cflexure() == [S(10)/3]
def test_apply_support(): E = Symbol('E') I = Symbol('I') b = Beam(4, E, I) b.apply_support(0, "cantilever") b.apply_load(20, 4, -1) M_0, R_0 = symbols('M_0, R_0') b.solve_for_reaction_loads(R_0, M_0) assert b.slope() == (80*SingularityFunction(x, 0, 1) - 10*SingularityFunction(x, 0, 2) + 10*SingularityFunction(x, 4, 2))/(E*I) assert b.deflection() == (40*SingularityFunction(x, 0, 2) - 10*SingularityFunction(x, 0, 3)/3 + 10*SingularityFunction(x, 4, 3)/3)/(E*I) b = Beam(30, E, I) b.apply_support(10, "pin") b.apply_support(30, "roller") b.apply_load(-8, 0, -1) b.apply_load(120, 30, -2) R_10, R_30 = symbols('R_10, R_30') b.solve_for_reaction_loads(R_10, R_30) assert b.slope() == (-4*SingularityFunction(x, 0, 2) + 3*SingularityFunction(x, 10, 2) + 120*SingularityFunction(x, 30, 1) + SingularityFunction(x, 30, 2) + 4000/3)/(E*I) assert b.deflection() == (4000*x/3 - 4*SingularityFunction(x, 0, 3)/3 + SingularityFunction(x, 10, 3) + 60*SingularityFunction(x, 30, 2) + SingularityFunction(x, 30, 3)/3 - 12000)/(E*I)
def test_remove_load(): E = Symbol('E') I = Symbol('I') b = Beam(4, E, I) try: b.remove_load(2, 1, -1) # As no load is applied on beam, ValueError should be returned. except ValueError: assert True else: assert False b.apply_load(-3, 0, -2) b.apply_load(4, 2, -1) b.apply_load(-2, 2, 2, end = 3) b.remove_load(-2, 2, 2, end = 3) assert b.load == -3*SingularityFunction(x, 0, -2) + 4*SingularityFunction(x, 2, -1) assert b.applied_loads == [(-3, 0, -2, None), (4, 2, -1, None)] try: b.remove_load(1, 2, -1) # As load of this magnitude was never applied at # this position, method should return a ValueError. except ValueError: assert True else: assert False b.remove_load(-3, 0, -2) b.remove_load(4, 2, -1) assert b.load == 0 assert b.applied_loads == []
def max_shear_force(self): E = Symbol('E') I = Symbol('I') b = Beam(3, E, I) R, M = symbols('R, M') b.apply_load(R, 0, -1) b.apply_load(M, 0, -2) b.apply_load(2, 3, -1) b.apply_load(4, 2, -1) b.apply_load(2, 2, 0, end=3) b.solve_for_reaction_loads(R, M) assert b.max_shear_force() == (Interval(0, 2), 8) l = symbols('l', positive=True) P = Symbol('P') b = Beam(l, E, I) R1, R2 = symbols('R1, R2') b.apply_load(R1, 0, -1) b.apply_load(R2, l, -1) b.apply_load(P, 0, 0, end=l) b.solve_for_reaction_loads(R1, R2) assert b.max_shear_force() == (0, l*Abs(P)/2)
def test_max_bmoment(): E = Symbol('E') I = Symbol('I') l, P = symbols('l, P', positive=True) b = Beam(l, E, I) R1, R2 = symbols('R1, R2') b.apply_load(R1, 0, -1) b.apply_load(R2, l, -1) b.apply_load(P, l/2, -1) b.solve_for_reaction_loads(R1, R2) b.reaction_loads assert b.max_bmoment() == (l/2, P*l/4) b = Beam(l, E, I) R1, R2 = symbols('R1, R2') b.apply_load(R1, 0, -1) b.apply_load(R2, l, -1) b.apply_load(P, 0, 0, end=l) b.solve_for_reaction_loads(R1, R2) assert b.max_bmoment() == (l/2, P*l**2/8)
def test_variable_moment(): E = Symbol('E') I = Symbol('I') b = Beam(4, E, 2 * (4 - x)) b.apply_load(20, 4, -1) R, M = symbols('R, M') b.apply_load(R, 0, -1) b.apply_load(M, 0, -2) b.bc_deflection = [(0, 0)] b.bc_slope = [(0, 0)] b.solve_for_reaction_loads(R, M) assert b.slope().expand() == ((10 * x * SingularityFunction(x, 0, 0) - 10 * (x - 4) * SingularityFunction(x, 4, 0)) / E).expand() assert b.deflection().expand() == ( (5 * x**2 * SingularityFunction(x, 0, 0) - 10 * Piecewise( (0, Abs(x) / 4 < 1), (16 * meijerg( ((3, 1), ()), ((), (2, 0)), x / 4), True)) + 40 * SingularityFunction(x, 4, 1)) / E).expand() b = Beam(4, E - x, I) b.apply_load(20, 4, -1) R, M = symbols('R, M') b.apply_load(R, 0, -1) b.apply_load(M, 0, -2) b.bc_deflection = [(0, 0)] b.bc_slope = [(0, 0)] b.solve_for_reaction_loads(R, M) assert b.slope().expand() == ( (-80 * (-log(-E) + log(-E + x)) * SingularityFunction(x, 0, 0) + 80 * (-log(-E + 4) + log(-E + x)) * SingularityFunction(x, 4, 0) + 20 * (-E * log(-E) + E * log(-E + x) + x) * SingularityFunction(x, 0, 0) - 20 * (-E * log(-E + 4) + E * log(-E + x) + x - 4) * SingularityFunction(x, 4, 0)) / I).expand()
def test_statically_indeterminate(): E = Symbol('E') I = Symbol('I') M1, M2 = symbols('M1, M2') F = Symbol('F') l = Symbol('l', positive=True) b5 = Beam(l, E, I) b5.bc_deflection = [(0, 0),(l, 0)] b5.bc_slope = [(0, 0),(l, 0)] b5.apply_load(R1, 0, -1) b5.apply_load(M1, 0, -2) b5.apply_load(R2, l, -1) b5.apply_load(M2, l, -2) b5.apply_load(-F, l/2, -1) b5.solve_for_reaction_loads(R1, R2, M1, M2) p = b5.reaction_loads q = {R1: F/2, R2: F/2, M1: -F*l/8, M2: F*l/8} assert p == q
def test_statically_indeterminate(): E = Symbol('E') I = Symbol('I') M1, M2 = symbols('M1, M2') F = Symbol('F') l = Symbol('l', positive=True) b5 = Beam(l, E, I) b5.bc_deflection = [(0, 0),(l, 0)] b5.bc_slope = [(0, 0),(l, 0)] b5.apply_load(R1, 0, -1) b5.apply_load(M1, 0, -2) b5.apply_load(R2, l, -1) b5.apply_load(M2, l, -2) b5.apply_load(-F, l/2, -1) b5.solve_for_reaction_loads(R1, R2, M1, M2) p = b5.reaction_loads q = {R1: F/2, R2: F/2, M1: -F*l/8, M2: F*l/8} assert p == q
def test_Beam(): E = Symbol('E') E_1 = Symbol('E_1') I = Symbol('I') I_1 = Symbol('I_1') b = Beam(1, E, I) assert b.length == 1 assert b.elastic_modulus == E assert b.second_moment == I assert b.variable == x # Test the length setter b.length = 4 assert b.length == 4 # Test the E setter b.elastic_modulus = E_1 assert b.elastic_modulus == E_1 # Test the I setter b.second_moment = I_1 assert b.second_moment is I_1 # Test the variable setter b.variable = y assert b.variable is y # Test for all boundary conditions. b.bc_deflection = [(0, 2)] b.bc_slope = [(0, 1)] assert b.boundary_conditions == {'deflection': [(0, 2)], 'slope': [(0, 1)]} # Test for slope boundary condition method b.bc_slope.extend([(4, 3), (5, 0)]) s_bcs = b.bc_slope assert s_bcs == [(0, 1), (4, 3), (5, 0)] # Test for deflection boundary condition method b.bc_deflection.extend([(4, 3), (5, 0)]) d_bcs = b.bc_deflection assert d_bcs == [(0, 2), (4, 3), (5, 0)] # Test for updated boundary conditions bcs_new = b.boundary_conditions assert bcs_new == { 'deflection': [(0, 2), (4, 3), (5, 0)], 'slope': [(0, 1), (4, 3), (5, 0)]} b1 = Beam(30, E, I) b1.apply_load(-8, 0, -1) b1.apply_load(R1, 10, -1) b1.apply_load(R2, 30, -1) b1.apply_load(120, 30, -2) b1.bc_deflection = [(10, 0), (30, 0)] b1.solve_for_reaction_loads(R1, R2) # Test for finding reaction forces p = b1.reaction_loads q = {R1: 6, R2: 2} assert p == q # Test for load distribution function. p = b1.load q = -8*SingularityFunction(x, 0, -1) + 6*SingularityFunction(x, 10, -1) + 120*SingularityFunction(x, 30, -2) + 2*SingularityFunction(x, 30, -1) assert p == q # Test for shear force distribution function p = b1.shear_force() q = -8*SingularityFunction(x, 0, 0) + 6*SingularityFunction(x, 10, 0) + 120*SingularityFunction(x, 30, -1) + 2*SingularityFunction(x, 30, 0) assert p == q # Test for bending moment distribution function p = b1.bending_moment() q = -8*SingularityFunction(x, 0, 1) + 6*SingularityFunction(x, 10, 1) + 120*SingularityFunction(x, 30, 0) + 2*SingularityFunction(x, 30, 1) assert p == q # Test for slope distribution function p = b1.slope() q = -4*SingularityFunction(x, 0, 2) + 3*SingularityFunction(x, 10, 2) + 120*SingularityFunction(x, 30, 1) + SingularityFunction(x, 30, 2) + 4000/3 assert p == q/(E*I) # Test for deflection distribution function p = b1.deflection() q = 4000*x/3 - 4*SingularityFunction(x, 0, 3)/3 + SingularityFunction(x, 10, 3) + 60*SingularityFunction(x, 30, 2) + SingularityFunction(x, 30, 3)/3 - 12000 assert p == q/(E*I) # Test using symbols l = Symbol('l') w0 = Symbol('w0') w2 = Symbol('w2') a1 = Symbol('a1') c = Symbol('c') c1 = Symbol('c1') d = Symbol('d') e = Symbol('e') f = Symbol('f') b2 = Beam(l, E, I) b2.apply_load(w0, a1, 1) b2.apply_load(w2, c1, -1) b2.bc_deflection = [(c, d)] b2.bc_slope = [(e, f)] # Test for load distribution function. p = b2.load q = w0*SingularityFunction(x, a1, 1) + w2*SingularityFunction(x, c1, -1) assert p == q # Test for shear force distribution function p = b2.shear_force() q = w0*SingularityFunction(x, a1, 2)/2 + w2*SingularityFunction(x, c1, 0) assert p == q # Test for bending moment distribution function p = b2.bending_moment() q = w0*SingularityFunction(x, a1, 3)/6 + w2*SingularityFunction(x, c1, 1) assert p == q # Test for slope distribution function p = b2.slope() q = (w0*SingularityFunction(x, a1, 4)/24 + w2*SingularityFunction(x, c1, 2)/2)/(E*I) + (E*I*f - w0*SingularityFunction(e, a1, 4)/24 - w2*SingularityFunction(e, c1, 2)/2)/(E*I) assert p == q # Test for deflection distribution function p = b2.deflection() q = x*(E*I*f - w0*SingularityFunction(e, a1, 4)/24 - w2*SingularityFunction(e, c1, 2)/2)/(E*I) + (w0*SingularityFunction(x, a1, 5)/120 + w2*SingularityFunction(x, c1, 3)/6)/(E*I) + (E*I*(-c*f + d) + c*w0*SingularityFunction(e, a1, 4)/24 + c*w2*SingularityFunction(e, c1, 2)/2 - w0*SingularityFunction(c, a1, 5)/120 - w2*SingularityFunction(c, c1, 3)/6)/(E*I) assert p == q b3 = Beam(9, E, I) b3.apply_load(value=-2, start=2, order=2, end=3) b3.bc_slope.append((0, 2)) C3 = symbols('C3') C4 = symbols('C4') p = b3.load q = -2*SingularityFunction(x, 2, 2) + 2*SingularityFunction(x, 3, 0) + 4*SingularityFunction(x, 3, 1) + 2*SingularityFunction(x, 3, 2) assert p == q p = b3.slope() q = 2 + (-SingularityFunction(x, 2, 5)/30 + SingularityFunction(x, 3, 3)/3 + SingularityFunction(x, 3, 4)/6 + SingularityFunction(x, 3, 5)/30)/(E*I) assert p == q p = b3.deflection() q = 2*x + (-SingularityFunction(x, 2, 6)/180 + SingularityFunction(x, 3, 4)/12 + SingularityFunction(x, 3, 5)/30 + SingularityFunction(x, 3, 6)/180)/(E*I) assert p == q + C4 b4 = Beam(4, E, I) b4.apply_load(-3, 0, 0, end=3) p = b4.load q = -3*SingularityFunction(x, 0, 0) + 3*SingularityFunction(x, 3, 0) assert p == q p = b4.slope() q = -3*SingularityFunction(x, 0, 3)/6 + 3*SingularityFunction(x, 3, 3)/6 assert p == q/(E*I) + C3 p = b4.deflection() q = -3*SingularityFunction(x, 0, 4)/24 + 3*SingularityFunction(x, 3, 4)/24 assert p == q/(E*I) + C3*x + C4 # can't use end with point loads raises(ValueError, lambda: b4.apply_load(-3, 0, -1, end=3)) with raises(TypeError): b4.variable = 1
from sympy.physics.continuum_mechanics.beam import Beam from sympy import symbols R1, R2 = symbols('R1, R2') b = Beam(8, 200*(10**9), 400*(10**-6)) b.apply_load(5000, 2, -1) b.apply_load(R1, 0, -1) b.apply_load(R2, 8, -1) b.apply_load(10000, 4, 0, end=8) b.bc_deflection = [(0, 0), (8, 0)] b.solve_for_reaction_loads(R1, R2) b.plot_deflection() # Plot object containing: # [0]: cartesian line: 0.00138541666666667*x - 2.86458333333333e-5*SingularityFunction(x, 0, 3) # + 1.04166666666667e-5*SingularityFunction(x, 2, 3) + 5.20833333333333e-6*SingularityFunction(x, 4, 4) # - 6.51041666666667e-5*SingularityFunction(x, 8, 3) - 5.20833333333333e-6*SingularityFunction(x, 8, 4) # for x over (0.0, 8.0)
def test_cross_section(): I = Symbol('I') l = Symbol('l') E = Symbol('E') C3, C4 = symbols('C3, C4') a, c, g, h, r, n = symbols('a, c, g, h, r, n') # test for second_moment and cross_section setter b0 = Beam(l, E, I) assert b0.second_moment == I assert b0.cross_section == None b0.cross_section = Circle((0, 0), 5) assert b0.second_moment == pi*Rational(625, 4) assert b0.cross_section == Circle((0, 0), 5) b0.second_moment = 2*n - 6 assert b0.second_moment == 2*n-6 assert b0.cross_section == None with raises(ValueError): b0.second_moment = Circle((0, 0), 5) # beam with a circular cross-section b1 = Beam(50, E, Circle((0, 0), r)) assert b1.cross_section == Circle((0, 0), r) assert b1.second_moment == pi*r*Abs(r)**3/4 b1.apply_load(-10, 0, -1) b1.apply_load(R1, 5, -1) b1.apply_load(R2, 50, -1) b1.apply_load(90, 45, -2) b1.solve_for_reaction_loads(R1, R2) assert b1.load == (-10*SingularityFunction(x, 0, -1) + 82*SingularityFunction(x, 5, -1)/S(9) + 90*SingularityFunction(x, 45, -2) + 8*SingularityFunction(x, 50, -1)/9) assert b1.bending_moment() == (-10*SingularityFunction(x, 0, 1) + 82*SingularityFunction(x, 5, 1)/9 + 90*SingularityFunction(x, 45, 0) + 8*SingularityFunction(x, 50, 1)/9) q = (-5*SingularityFunction(x, 0, 2) + 41*SingularityFunction(x, 5, 2)/S(9) + 90*SingularityFunction(x, 45, 1) + 4*SingularityFunction(x, 50, 2)/S(9))/(pi*E*r*Abs(r)**3) assert b1.slope() == C3 + 4*q q = (-5*SingularityFunction(x, 0, 3)/3 + 41*SingularityFunction(x, 5, 3)/27 + 45*SingularityFunction(x, 45, 2) + 4*SingularityFunction(x, 50, 3)/27)/(pi*E*r*Abs(r)**3) assert b1.deflection() == C3*x + C4 + 4*q # beam with a recatangular cross-section b2 = Beam(20, E, Polygon((0, 0), (a, 0), (a, c), (0, c))) assert b2.cross_section == Polygon((0, 0), (a, 0), (a, c), (0, c)) assert b2.second_moment == a*c**3/12 # beam with a triangular cross-section b3 = Beam(15, E, Triangle((0, 0), (g, 0), (g/2, h))) assert b3.cross_section == Triangle(Point2D(0, 0), Point2D(g, 0), Point2D(g/2, h)) assert b3.second_moment == g*h**3/36 # composite beam b = b2.join(b3, "fixed") b.apply_load(-30, 0, -1) b.apply_load(65, 0, -2) b.apply_load(40, 0, -1) b.bc_slope = [(0, 0)] b.bc_deflection = [(0, 0)] assert b.second_moment == Piecewise((a*c**3/12, x <= 20), (g*h**3/36, x <= 35)) assert b.cross_section == None assert b.length == 35 assert b.slope().subs(x, 7) == 8400/(E*a*c**3) assert b.slope().subs(x, 25) == 52200/(E*g*h**3) + 39600/(E*a*c**3) assert b.deflection().subs(x, 30) == 537000/(E*g*h**3) + 712000/(E*a*c**3)
def test_Beam(): E = Symbol("E") E_1 = Symbol("E_1") I = Symbol("I") I_1 = Symbol("I_1") b = Beam(1, E, I) assert b.length == 1 assert b.elastic_modulus == E assert b.second_moment == I assert b.variable == x # Test the length setter b.length = 4 assert b.length == 4 # Test the E setter b.elastic_modulus = E_1 assert b.elastic_modulus == E_1 # Test the I setter b.second_moment = I_1 assert b.second_moment is I_1 # Test the variable setter b.variable = y assert b.variable is y # Test for all boundary conditions. b.bc_deflection = [(0, 2)] b.bc_slope = [(0, 1)] assert b.boundary_conditions == {"deflection": [(0, 2)], "slope": [(0, 1)]} # Test for slope boundary condition method b.bc_slope.extend([(4, 3), (5, 0)]) s_bcs = b.bc_slope assert s_bcs == [(0, 1), (4, 3), (5, 0)] # Test for deflection boundary condition method b.bc_deflection.extend([(4, 3), (5, 0)]) d_bcs = b.bc_deflection assert d_bcs == [(0, 2), (4, 3), (5, 0)] # Test for updated boundary conditions bcs_new = b.boundary_conditions assert bcs_new == {"deflection": [(0, 2), (4, 3), (5, 0)], "slope": [(0, 1), (4, 3), (5, 0)]} b1 = Beam(30, E, I) b1.apply_load(-8, 0, -1) b1.apply_load(R1, 10, -1) b1.apply_load(R2, 30, -1) b1.apply_load(120, 30, -2) b1.bc_deflection = [(10, 0), (30, 0)] b1.solve_for_reaction_loads(R1, R2) # Test for finding reaction forces p = b1.reaction_loads q = {R1: 6, R2: 2} assert p == q # Test for load distribution function. p = b1.load q = ( -8 * SingularityFunction(x, 0, -1) + 6 * SingularityFunction(x, 10, -1) + 120 * SingularityFunction(x, 30, -2) + 2 * SingularityFunction(x, 30, -1) ) assert p == q # Test for shear force distribution function p = b1.shear_force() q = ( -8 * SingularityFunction(x, 0, 0) + 6 * SingularityFunction(x, 10, 0) + 120 * SingularityFunction(x, 30, -1) + 2 * SingularityFunction(x, 30, 0) ) assert p == q # Test for bending moment distribution function p = b1.bending_moment() q = ( -8 * SingularityFunction(x, 0, 1) + 6 * SingularityFunction(x, 10, 1) + 120 * SingularityFunction(x, 30, 0) + 2 * SingularityFunction(x, 30, 1) ) assert p == q # Test for slope distribution function p = b1.slope() q = ( -4 * SingularityFunction(x, 0, 2) + 3 * SingularityFunction(x, 10, 2) + 120 * SingularityFunction(x, 30, 1) + SingularityFunction(x, 30, 2) + 4000 / 3 ) assert p == q / (E * I) # Test for deflection distribution function p = b1.deflection() q = ( 4000 * x / 3 - 4 * SingularityFunction(x, 0, 3) / 3 + SingularityFunction(x, 10, 3) + 60 * SingularityFunction(x, 30, 2) + SingularityFunction(x, 30, 3) / 3 - 12000 ) assert p == q / (E * I) # Test using symbols l = Symbol("l") w0 = Symbol("w0") w2 = Symbol("w2") a1 = Symbol("a1") c = Symbol("c") c1 = Symbol("c1") d = Symbol("d") e = Symbol("e") f = Symbol("f") b2 = Beam(l, E, I) b2.apply_load(w0, a1, 1) b2.apply_load(w2, c1, -1) b2.bc_deflection = [(c, d)] b2.bc_slope = [(e, f)] # Test for load distribution function. p = b2.load q = w0 * SingularityFunction(x, a1, 1) + w2 * SingularityFunction(x, c1, -1) assert p == q # Test for shear force distribution function p = b2.shear_force() q = w0 * SingularityFunction(x, a1, 2) / 2 + w2 * SingularityFunction(x, c1, 0) assert p == q # Test for bending moment distribution function p = b2.bending_moment() q = w0 * SingularityFunction(x, a1, 3) / 6 + w2 * SingularityFunction(x, c1, 1) assert p == q # Test for slope distribution function p = b2.slope() q = ( f - w0 * SingularityFunction(e, a1, 4) / 24 + w0 * SingularityFunction(x, a1, 4) / 24 - w2 * SingularityFunction(e, c1, 2) / 2 + w2 * SingularityFunction(x, c1, 2) / 2 ) assert p == q / (E * I) # Test for deflection distribution function p = b2.deflection() q = ( -c * f + c * w0 * SingularityFunction(e, a1, 4) / 24 + c * w2 * SingularityFunction(e, c1, 2) / 2 + d + f * x - w0 * x * SingularityFunction(e, a1, 4) / 24 - w0 * SingularityFunction(c, a1, 5) / 120 + w0 * SingularityFunction(x, a1, 5) / 120 - w2 * x * SingularityFunction(e, c1, 2) / 2 - w2 * SingularityFunction(c, c1, 3) / 6 + w2 * SingularityFunction(x, c1, 3) / 6 ) assert p == q / (E * I) b3 = Beam(9, E, I) b3.apply_load(value=-2, start=2, order=2, end=3) b3.bc_slope.append((0, 2)) p = b3.load q = -2 * SingularityFunction(x, 2, 2) + 2 * SingularityFunction(x, 3, 0) + 2 * SingularityFunction(x, 3, 2) assert p == q p = b3.slope() q = -SingularityFunction(x, 2, 5) / 30 + SingularityFunction(x, 3, 3) / 3 + SingularityFunction(x, 3, 5) / 30 + 2 assert p == q / (E * I) p = b3.deflection() q = ( 2 * x - SingularityFunction(x, 2, 6) / 180 + SingularityFunction(x, 3, 4) / 12 + SingularityFunction(x, 3, 6) / 180 ) assert p == q / (E * I) b4 = Beam(4, E, I) b4.apply_load(-3, 0, 0, end=3) p = b4.load q = -3 * SingularityFunction(x, 0, 0) + 3 * SingularityFunction(x, 3, 0) assert p == q p = b4.slope() q = -3 * SingularityFunction(x, 0, 3) / 6 + 3 * SingularityFunction(x, 3, 3) / 6 assert p == q / (E * I) p = b4.deflection() q = -3 * SingularityFunction(x, 0, 4) / 24 + 3 * SingularityFunction(x, 3, 4) / 24 assert p == q / (E * I) raises(ValueError, lambda: b4.apply_load(-3, 0, -1, end=3)) with raises(TypeError): b4.variable = 1
from sympy import symbols from sympy.physics.continuum_mechanics.beam import Beam E, I = symbols('E, I') R_0, R_7 = symbols('R_0, R_7') b = Beam(10, E, I) b.apply_support(0, 'roller') b.apply_support(7, 'roller') b.apply_load(5,4,-1) b.solve_for_ild_reactions(1,R_0,R_7) b.ild_reactions # {R_0: x/7 - 22/7, R_7: -x/7 - 20/7} b.plot_ild_reactions() # PlotGrid object containing: # Plot[0]:Plot object containing: # [0]: cartesian line: x/7 - 22/7 for x over (0.0, 10.0) # Plot[1]:Plot object containing: # [0]: cartesian line: -x/7 - 20/7 for x over (0.0, 10.0)
class Panel(FloatLayout): def __init__(self, **kwargs): super(Panel, self).__init__(**kwargs) self.E = "210E9" self.I = "1.71E-6" self.Len = '10' self.reaction_vars = [] self.BEAM = Beam(self.Len, self.E, self.I) self.i = 0 self.add_widget(Label(text = 'MAKE BEAM', size_hint = (.25, 0.1), pos_hint = {'x' : 0, 'y' : 0.9})) layout = GridLayout(cols=1, spacing=10, size_hint_y=None, size_hint_x = 1) layout.bind(minimum_height = layout.setter('height')) default_val = Button(text = 'SET E, I, L', size_hint_y=None, height=40) layout.add_widget(default_val) default_val.bind(on_press = self.popup_default_value) layout.add_widget(Label(text = 'SUPPORTS', size_hint_y=None, height=40)) Fix = Button(text = 'FIX', size_hint_y=None, height=40) layout.add_widget(Fix) Fix.bind(on_press = self.popup_fix) Roller = Button(text = 'ROLLER', size_hint_y=None, height=40) layout.add_widget(Roller) Roller.bind(on_press = self.popup_roller) Pin = Button(text = 'PIN', size_hint_y=None, height=40) layout.add_widget(Pin) Pin.bind(on_press = self.popup_pin) layout.add_widget(Label(text = 'LOADS', size_hint_y=None, height=40)) layout.add_widget(Label(text = 'CONCENTRATED', size_hint_y=None, height=40)) Vertical = Button(text = 'VERTICAL', size_hint_y=None, height=40) layout.add_widget(Vertical) Vertical.bind(on_press = self.popup_vertical) Moment = Button(text = 'MOMENT', size_hint_y=None, height=40) layout.add_widget(Moment) Moment.bind(on_press = self.popup_moment) layout.add_widget(Label(text = 'DISTRIBUTED', size_hint_y=None, height=40)) Linear = Button(text = 'LINEAR', size_hint_y=None, height=40) layout.add_widget(Linear) Linear.bind(on_press = self.popup_linear) NewBeam = Button(text = 'NEW BEAM', size_hint_y=None, height=40) layout.add_widget(NewBeam) NewBeam.bind(on_press = self.popup_newbeam) MakeBeam = ScrollView(size_hint=(.25, .9)) MakeBeam.add_widget(layout) self.add_widget(MakeBeam) self.add_widget(Label(text = 'ANALYSE BEAM', size_hint = (.75, .1), pos_hint = {'x' : .25, 'y' : .9})) layout_analysis = GridLayout(cols=2, spacing=10, size_hint = (.75, .3), pos_hint = {'x' : .25, 'y' : .6}) Shear = Button(text = 'SHEAR FORCE DIAGRAM', size_hint_y=None, height=20) layout_analysis.add_widget(Shear) Shear.bind(on_press = self.popup_shear) Bending = Button(text = 'BENDING MOMENT DIAGRAM', size_hint_y=None, height=20) layout_analysis.add_widget(Bending) Bending.bind(on_press = self.popup_bending) Slope = Button(text = 'SLOPE DIAGRAM', size_hint_y=None, height=20) layout_analysis.add_widget(Slope) Slope.bind(on_press = self.popup_slope) Deflection = Button(text = 'DEFLECTION DIAGRAM', size_hint_y=None, height=20) layout_analysis.add_widget(Deflection) Deflection.bind(on_press = self.popup_deflection) PlotAll = Button(text = 'PLOT ALL 4', size_hint_y=None, height=20) layout_analysis.add_widget(PlotAll) PlotAll.bind(on_press = self.popup_plotall) Reaction = Button(text = 'REACTION LOADS', size_hint_y=None, height=15) layout_analysis.add_widget(Reaction) Reaction.bind(on_press = self.popup_reaction) self.add_widget(layout_analysis) def popup_default_value(self, instance): #layout = BoxLayout(orientation = 'vertical') #layout1 is our child wiget of layout and is GridLayout with coloumn = 2 layout1 = GridLayout(cols = 2) #layout1's child widget Label layout1.add_widget(Label(text = 'E () = ')) #layout1's child widget having value of E self.E_text = TextInput(text = self.E,multiline = False) layout1.add_widget(self.E_text) #layout1's child widget Label layout1.add_widget(Label(text = 'I () = ')) #layout1's another child widget having value of E self.I_text = TextInput(text = self.I,multiline = False) layout1.add_widget(self.I_text) #layout1's child widget Label layout1.add_widget(Label(text = 'LENGTH (m) = ')) #layout1's another child widget having value of length of beam self.len_text = TextInput(text = self.Len,multiline = False) layout1.add_widget(self.len_text) #Button to save the changes done btn = Button(text = 'SAVE') layout1.add_widget(btn) btn.bind(on_press = self.set_E_I_Len) #Button to accept the default values and close the popup btn2 = Button(text = 'CLOSE') layout1.add_widget(btn2) btn2.bind(on_press = self.popup_dismiss) #layout.add_widget(layout1) #Instantiating the Popup self.popup = Popup(title = 'SET E, I AND LENGTH FOR BEAM', content = layout1, size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup.open() def popup_fix(self, instance): layout = GridLayout(cols = 2) layout.add_widget(Label(text = 'X (m) = ')) self.fix_text = TextInput(multiline = False) layout.add_widget(self.fix_text) btn = Button(text = 'SAVE') layout.add_widget(btn) btn.bind(on_press = self.add_fix) btn2 = Button(text = 'CLOSE') layout.add_widget(btn2) btn2.bind(on_press = self.popup_dismiss) self.popup = Popup(title = 'FIX SUPPPORT (m)', content = layout, size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup.open() def popup_roller(self, instance): layout = GridLayout(cols = 2) layout.add_widget(Label(text = 'X (m) = ')) self.roller_text = TextInput(multiline = False) layout.add_widget(self.roller_text) btn = Button(text = 'SAVE') layout.add_widget(btn) btn.bind(on_press = self.add_roller) btn2 = Button(text = 'CLOSE') layout.add_widget(btn2) btn2.bind(on_press = self.popup_dismiss) self.popup = Popup(title = 'ROLLER SUPPORT (m)', content = layout, size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup.open() def popup_pin(self, instance): layout = GridLayout(cols = 2) layout.add_widget(Label(text = 'X (m) = ')) self.pin_text = TextInput(multiline = False) layout.add_widget(self.pin_text) btn = Button(text = 'SAVE') layout.add_widget(btn) btn.bind(on_press = self.add_pin) btn2 = Button(text = 'CLOSE') layout.add_widget(btn2) btn2.bind(on_press = self.popup_dismiss) self.popup = Popup(title = 'PIN SUPPORT ', content = layout, size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup.open() def popup_vertical(self, instance): layout = BoxLayout(orientation = 'vertical') layout1 = GridLayout(cols = 2) layout1.add_widget(Label(text = 'X(m) = ')) self.vertical_load_pos_text = TextInput(multiline = False) layout1.add_widget(self.vertical_load_pos_text) layout1.add_widget(Label(text = 'LOAD(kN) = ')) self.vertical_load_mag_text = TextInput(multiline = False) layout1.add_widget(self.vertical_load_mag_text) layout.add_widget(layout1) self.load_dir = Toggle_btn() layout.add_widget(self.load_dir) layout2 = GridLayout(cols = 2) btn = Button(text = 'SAVE') layout2.add_widget(btn) btn.bind(on_press = self.add_vertical_load) btn2 = Button(text = 'CLOSE') layout2.add_widget(btn2) btn2.bind(on_press = self.popup_dismiss) layout.add_widget(layout2) self.popup = Popup(title = 'POINT LOAD ', content = layout, size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup.open() def popup_moment(self, instance): layout = BoxLayout(orientation = 'vertical') layout1 = GridLayout(cols = 2) layout1.add_widget(Label(text = 'X(m) = ')) self.moment_pos_text = TextInput(multiline = False) layout1.add_widget(self.moment_pos_text) layout1.add_widget(Label(text = 'MOMENT (kN * m)= ')) self.moment_mag_text = TextInput(multiline = False) layout1.add_widget(self.moment_mag_text) layout.add_widget(layout1) self.moment_dir = Toggle_btn_moment() layout.add_widget(self.moment_dir) layout2 = GridLayout(cols = 2) btn = Button(text = 'SAVE') layout2.add_widget(btn) btn.bind(on_press = self.add_moment) btn2 = Button(text = 'CLOSE') layout2.add_widget(btn2) btn2.bind(on_press = self.popup_dismiss) layout.add_widget(layout2) self.popup = Popup(title = 'MOMENT MAG. ', content = layout, size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup.open() def popup_linear(self, instance): layout = BoxLayout(orientation = 'vertical') layout1 = GridLayout(cols = 2) layout1.add_widget(Label(text = 'X1 (m) = ')) self.starting_pos_text = TextInput(multiline = False) layout1.add_widget(self.starting_pos_text) layout1.add_widget(Label(text = 'X2 (m) = ')) self.ending_pos_text = TextInput(multiline = False) layout1.add_widget(self.ending_pos_text) layout1.add_widget(Label(text = 'LOAD(kN) = ')) self.load_per_m_text = TextInput(multiline = False) layout1.add_widget(self.load_per_m_text) layout.add_widget(layout1) self.load_dir_linear = Toggle_btn() layout.add_widget(self.load_dir_linear) layout2 = GridLayout(cols = 2) btn = Button(text = 'SAVE') layout2.add_widget(btn) btn.bind(on_press = self.add_linear_load) btn2 = Button(text = 'CLOSE') layout2.add_widget(btn2) btn2.bind(on_press = self.popup_dismiss) layout.add_widget(layout2) self.popup = Popup(title = 'DISTRIBUTED LINEAR LOAD ', content = layout, size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup.open() def popup_shear(self, instance): pass def popup_bending(self, instance): pass def popup_slope(self, instance): pass def popup_deflection(self, instance): pass def popup_plotall(self, instance): self.BEAM.solve_for_reaction_loads(*self.reaction_vars) d = self.BEAM.reaction_loads for i, j in d.items(): print(j) pass def popup_reaction(self, instance): if self.i > 0: layout_react = BoxLayout(orientation = 'vertical') for i, j in self.d.items(): alphabet, distance = str(i).split('_') if alphabet == 'R': text1 = 'Reaction Force at x = {} m is {} N'.format(distance, j) elif alphabet == 'M': text1 = 'Reaction Moment at x = {} m is {} N*m'.format(distance, j) layout_react.add_widget(Label(text = text1)) btn = Button(text = 'CLOSE') layout_react.add_widget(btn) btn.bind(on_press = self.popup_in_popup_dismiss) self.popup_in_popup = Popup(title = "SUPPPORT REACTIONS",content = layout_react , size_hint = (.8, .8), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup_in_popup.open() else: self.i += 1 try: self.BEAM.solve_for_reaction_loads(*self.reaction_vars) except: layout = BoxLayout(orientation = 'vertical') layout.add_widget(Label(text = "INSUFFICIENT DATA GIVEN!!")) btn = Button(text = 'CLOSE') layout.add_widget(btn) btn.bind(on_press = self.popup_in_popup_dismiss) self.popup_in_popup = Popup(title = "BEAM UNSTABLE!",content = layout , size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup_in_popup.open() else: layout_react = BoxLayout(orientation = 'vertical') #self.BEAM.solve_for_reaction_loads(*self.reaction_vars) self.d = self.BEAM.reaction_loads #react_name = list(d.keys()) #react_value = list(d.values()) #print(self.BEAM.reaction_loads, d, react_name, react_value) #more_than_once_call: for i, j in self.d.items(): alphabet, distance = str(i).split('_') if alphabet == 'R': text1 = 'Reaction Force at x = {} m is {} N'.format(distance, j) elif alphabet == 'M': text1 = 'Reaction Moment at x = {} m is {} N*m'.format(distance, j) layout_react.add_widget(Label(text = text1)) btn = Button(text = 'CLOSE') layout_react.add_widget(btn) btn.bind(on_press = self.popup_in_popup_dismiss) self.popup_in_popup = Popup(title = "SUPPPORT REACTIONS",content = layout_react , size_hint = (.8, .8), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup_in_popup.open() def popup_cflexure(self, instance): pass def popup_newbeam(self, instance): del self.BEAM self.E = "210E9" self.I = "1.71E-6" self.Len = '10' self.reaction_vars = [] self.i = 0 self.BEAM = Beam(self.Len, self.E, self.I) layout = BoxLayout(orientation = 'vertical') layout.add_widget(Label(text = "ANALYSE A NEW BEAM NOW!!!")) btn = Button(text = 'CLOSE') layout.add_widget(btn) btn.bind(on_press = self.popup_in_popup_dismiss) self.popup_in_popup = Popup(title = "!!NEW!!",content = layout , size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup_in_popup.open() """def len_of_beam(self, instance): self.BEAM = Beam(self.len_text.text, self.E, self.I) self.popup.dismiss() print(type(self.len_text.text)) print(self.E) print(self.I) """ def set_E_I_Len(self, instance): #print(self.E_text.text, "\n", self.I_text.text, "\n",self.len_text.text) self.E = self.E_text.text self.I = self.I_text.text self.Len = self.len_text.text self.BEAM = Beam(self.Len, self.E, self.I) self.popup.dismiss() def add_fix(self, instance): if self.fix_text.text: self.reaction_vars.append(symbols('R_{}'.format(self.fix_text.text))) self.reaction_vars.append(symbols('M_{}'.format(self.fix_text.text))) self.BEAM.apply_support(self.fix_text.text, 'fixed') self.BEAM.bc_deflection.append((self.fix_text.text, 0)) self.BEAM.bc_slope.append((self.fix_text.text, 0)) self.popup.dismiss() else: layout = BoxLayout(orientation = 'vertical') layout.add_widget(Label(text = "YOU HAVEN'T ENTERED POSITION")) btn = Button(text = 'CLOSE') layout.add_widget(btn) btn.bind(on_press = self.popup_in_popup_dismiss) self.popup_in_popup = Popup(title = "NOTHING TO SAVE",content = layout , size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup_in_popup.open() def add_roller(self, instance): if self.roller_text.text: self.reaction_vars.append(symbols('R_{}'.format(self.roller_text.text))) self.BEAM.apply_support(self.roller_text.text, 'roller') self.BEAM.bc_deflection.append((self.roller_text.text, 0)) self.popup.dismiss() else: layout = BoxLayout(orientation = 'vertical') layout.add_widget(Label(text = "YOU HAVEN'T ENTERED POSITION")) btn = Button(text = 'CLOSE') layout.add_widget(btn) btn.bind(on_press = self.popup_in_popup_dismiss) self.popup_in_popup = Popup(title = "NOTHING TO SAVE",content = layout , size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup_in_popup.open() def add_pin(self, instance): if self.pin_text.text: self.reaction_vars.append(symbols('R_{}'.format(self.pin_text.text))) self.BEAM.apply_support(self.pin_text.text, 'pin') self.BEAM.bc_deflection.append((self.pin_text.text, 0)) self.popup.dismiss() else: layout = BoxLayout(orientation = 'vertical') layout.add_widget(Label(text = "YOU HAVEN'T ENTERED POSITION")) btn = Button(text = 'CLOSE') layout.add_widget(btn) btn.bind(on_press = self.popup_in_popup_dismiss) self.popup_in_popup = Popup(title = "NOTHING TO SAVE",content = layout , size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup_in_popup.open() def add_vertical_load(self, instance): if self.vertical_load_mag_text.text != '' and self.vertical_load_pos_text.text != '': states = self.load_dir.get_state() print(states) if (states[0] == 'normal' and states[1] == 'down') or (states[0] == 'down' and states[1] == 'normal'): if states[0] == 'normal' and states[1] == 'down': self.BEAM.apply_load(self.vertical_load_mag_text.text, self.vertical_load_pos_text.text, -1) self.popup.dismiss() else: self.BEAM.apply_load('-' + self.vertical_load_mag_text.text, self.vertical_load_pos_text.text, -1) self.popup.dismiss() else: layout = BoxLayout(orientation = 'vertical') layout.add_widget(Label(text = "YOU MUST CHOOSE ONE DIRECTION")) btn = Button(text = 'CLOSE') layout.add_widget(btn) btn.bind(on_press = self.popup_in_popup_dismiss) self.popup_in_popup = Popup(title = "IN WHICH DIR. DO I APPLY LOAD ?",content = layout , size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup_in_popup.open() else: layout = BoxLayout(orientation = 'vertical') layout.add_widget(Label(text = "ENTER BOTH LOAD MAG. AND POS.")) btn = Button(text = 'CLOSE') layout.add_widget(btn) btn.bind(on_press = self.popup_in_popup_dismiss) self.popup_in_popup = Popup(title = "INSUFFICIENT INFO !",content = layout , size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup_in_popup.open() def add_moment(self, instance): if self.moment_pos_text.text != '' and self.moment_mag_text.text != '': states = self.moment_dir.get_state() print(states) if (states[0] == 'normal' and states[1] == 'down') or (states[0] == 'down' and states[1] == 'normal'): if states[0] == 'normal' and states[1] == 'down': self.BEAM.apply_load(self.moment_mag_text.text, self.moment_pos_text.text, -2) self.popup.dismiss() else: self.BEAM.apply_load('-' + self.moment_mag_text.text, self.moment_pos_text.text, -2) self.popup.dismiss() else: layout = BoxLayout(orientation = 'vertical') layout.add_widget(Label(text = "YOU MUST CHOOSE ONE DIRECTION")) btn = Button(text = 'CLOSE') layout.add_widget(btn) btn.bind(on_press = self.popup_in_popup_dismiss) self.popup_in_popup = Popup(title = "IN WHICH DIR. DO I APPLY MOMENT ?",content = layout , size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup_in_popup.open() else: layout = BoxLayout(orientation = 'vertical') layout.add_widget(Label(text = "ENTER BOTH MOMENT MAG. AND POS.")) btn = Button(text = 'CLOSE') layout.add_widget(btn) btn.bind(on_press = self.popup_in_popup_dismiss) self.popup_in_popup = Popup(title = "INSUFFICIENT INFO !",content = layout , size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup_in_popup.open() def add_linear_load(self, instance): if self.starting_pos_text.text != '' and self.ending_pos_text.text != '' and self.load_per_m_text.text != '': states = self.load_dir_linear.get_state() print(states) if (states[0] == 'normal' and states[1] == 'down') or (states[0] == 'down' and states[1] == 'normal'): if states[0] == 'normal' and states[1] == 'down': self.BEAM.apply_load(self.load_per_m_text.text, self.starting_pos_text.text, 0, self.ending_pos_text.text) self.popup.dismiss() else: self.BEAM.apply_load('-' + self.load_per_m_text.text, self.starting_pos_text.text, 0, int(self.ending_pos_text.text)) self.popup.dismiss() else: layout = BoxLayout(orientation = 'vertical') layout.add_widget(Label(text = "YOU MUST CHOOSE ONE DIRECTION")) btn = Button(text = 'CLOSE') layout.add_widget(btn) btn.bind(on_press = self.popup_in_popup_dismiss) self.popup_in_popup = Popup(title = "IN WHICH DIR. DO I APPLY THE LOAD ?",content = layout , size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup_in_popup.open() else: layout = BoxLayout(orientation = 'vertical') layout.add_widget(Label(text = "ENTER ALL START, END AND LOAD")) btn = Button(text = 'CLOSE') layout.add_widget(btn) btn.bind(on_press = self.popup_in_popup_dismiss) self.popup_in_popup = Popup(title = "INSUFFICIENT INFO !",content = layout , size_hint = (.4, .4), pos_hint = {'center_x' : .5, 'center_y' : .5}) self.popup_in_popup.open() def popup_dismiss(self, instance): self.popup.dismiss() def popup_in_popup_dismiss(self, instance): self.popup_in_popup.dismiss()
from sympy.physics.continuum_mechanics.beam import Beam from sympy import symbols, plot, S E, I = symbols('E, I') R1, R2 = symbols('R1, R2') b = Beam(6, E, I) b.apply_load(R1, 0, -1) b.apply_load(-S(3) / 2, 3, -2) b.apply_load(3, 3, 0) b.apply_load(1, 3, 1) b.apply_load(R2, 6, -1) b.bc_deflection.append((0, 0)) b.bc_deflection.append((6, 0)) b.solve_for_reaction_loads(R1, R2) b.reaction_loads # {R₁: -11/4, R₂: -43/4} b.load # -1 -2 -1 # 11⋅<x> 3⋅<x - 3> 0 1 43⋅<x - 6> # - ──────── - ─────────── + 3⋅<x - 3> + <x - 3> - ──────────── # 4 2 4
def calc_sympy(self): self.cal_flag = 'CALCULATE BY SYMPY' # change flag to CALCULATE BY SYMPY if (self.tie_release == 1): self.listAnchor = self.alt_release_tie(self.listAnchor0) else: self.listAnchor = self.listAnchor0 # total deflection by external load moment = self.topLoad[0] force_horizontal = self.topLoad[1] force_verticle = self.topLoad[2] E, I = symbols('E, I') # create tuple for constrain: base translation constrain, base rotation constrain, constrain of anchorage[1,2,3,...] # R1: assign force reaction at foundation, M1: assign moment reaction at foundation R1, M1 = symbols('R1,M1') # Assign anchorage force sysbols programically listAnchorSym = [] for countA in range(0, len(self.listAnchor)): listAnchorSym.append(symbols('A' + str(countA + 1))) beam = Beam(float(self.mastHeight), E, I) beam.apply_load(R1, 0, -1) # apply reaction force at height=0 beam.apply_load(M1, 0, -2) # apply reaction moment at height=0 beam.bc_slope.append( (self.windForceRegion[0], 0)) # boundary condition at h=0, slope=0 beam.bc_deflection.append( (self.windForceRegion[0], 0)) # boundary condition at h=0, deflection=0 for countAA in range(1, len(self.listAnchor) + 1): # apply reaction force at each anchorage beam.apply_load(listAnchorSym[countAA - 1], self.listAnchor[countAA - 1], -1) # apply boundary condition at each anchorage, deflection=0 beam.bc_deflection.append((self.listAnchor[countAA - 1], 0)) # apply external loads beam.apply_load(moment, float(self.mastHeight), -2) # apply moment beam.apply_load(force_horizontal, float(self.topWindHeight), -1) # apply horizontal force windRegn = self.windForceRegion[:] windRegn.append(self.mastHeight) # print(windRegn) nc = 0 # apply wind pressure for f_w in self.windForce: # print('1st: '+str(windRegn[nc])) # print('2nd: '+str(windRegn[nc+1])) # print('Force: '+str(f_w)) exStr = 'beam.apply_load(f_w,' + str( windRegn[nc]) + ',0,end=' + str(windRegn[nc + 1]) + ')' print(exStr) exec(exStr) # beam.apply_load(f_w,windRegn[nc],0,end=windRegn[nc+1]) nc += 1 # solve for reaction # l_anc=[R1,M1]+list(dict_anc.values()) # get value in dict_anc to list ### beam.solve_for_reaction_loads(tup) strOfAncSym = '' for countAB in range(0, len(self.listAnchor)): strOfAncSym += ', listAnchorSym[{}]'.format(str(countAB)) exec('beam.solve_for_reaction_loads(R1, M1{})'.format(strOfAncSym)) print(beam._reaction_loads) self.tab_fa = list( zip(self.listAnchor, list(beam._reaction_loads.values())[2:]))
def test_parabolic_loads(): E, I, L = symbols('E, I, L', positive=True, real=True) R, M, P = symbols('R, M, P', real=True) # cantilever beam fixed at x=0 and parabolic distributed loading across # length of beam beam = Beam(L, E, I) beam.bc_deflection.append((0, 0)) beam.bc_slope.append((0, 0)) beam.apply_load(R, 0, -1) beam.apply_load(M, 0, -2) # parabolic load beam.apply_load(1, 0, 2) beam.solve_for_reaction_loads(R, M) assert beam.reaction_loads[R] == -L**3 / 3 # cantilever beam fixed at x=0 and parabolic distributed loading across # first half of beam beam = Beam(2 * L, E, I) beam.bc_deflection.append((0, 0)) beam.bc_slope.append((0, 0)) beam.apply_load(R, 0, -1) beam.apply_load(M, 0, -2) # parabolic load from x=0 to x=L beam.apply_load(1, 0, 2, end=L) beam.solve_for_reaction_loads(R, M) # result should be the same as the prior example assert beam.reaction_loads[R] == -L**3 / 3 # check constant load beam = Beam(2 * L, E, I) beam.apply_load(P, 0, 0, end=L) loading = beam.load.xreplace({L: 10, E: 20, I: 30, P: 40}) assert loading.xreplace({x: 5}) == 40 assert loading.xreplace({x: 15}) == 0 # check ramp load beam = Beam(2 * L, E, I) beam.apply_load(P, 0, 1, end=L) assert beam.load == (P*SingularityFunction(x, 0, 1) - P*SingularityFunction(x, L, 1) - P*L*SingularityFunction(x, L, 0)) # check higher order load: x**8 load from x=0 to x=L beam = Beam(2 * L, E, I) beam.apply_load(P, 0, 8, end=L) loading = beam.load.xreplace({L: 10, E: 20, I: 30, P: 40}) assert loading.xreplace({x: 5}) == 40 * 5**8 assert loading.xreplace({x: 15}) == 0
def computeBeam(E_mod, I_inertia, blen, sup_types, sup_locs, pl_forces, pl_locs, mom_moments, mom_locs, dl_loads, dl_orders, dl_starts, dl_stops): print("debug: ", debug) global s1 s1 = time.time() if (debug): print("S1: ", s1, time.time() - s1) E, I = symbols('E, I') E = E_mod I = I_inertia print(blen, E, I) b = Beam(blen, E, I) #creating beam object #support conditions if (len(sup_types) > 0): for index in range(0, len(sup_types)): location = float(sup_locs[index]) sup = sup_types[index] b.apply_support( location, sup.lower()) #sup is in the form 'Fixed' or 'Roller' or 'Pin' #applying point loads if (pl_forces != ['']): for index in range(0, len(pl_forces)): b.apply_load(float(pl_forces[index]), float(pl_locs[index]), -1) #applying moments if (mom_moments != ['']): for index in range(0, len(mom_moments)): b.apply_load(float(mom_moments[index]), float(mom_locs[index]), -2) #applying distributed loads if (dl_loads != ['']): for index in range(0, len(dl_loads)): w = float(dl_loads[index]) start = float(dl_starts[index]) stop = float(dl_stops[index]) order = int(dl_orders[index]) b.apply_load(w, start, order, end=stop) #------------------------------------------------------------------------------------------------------------------------- # at this stage we have a beam object with all the support and loading conditions finalized. Time to calculate... #------------------------------------------------------------------------------------------------------------------------- #dictionary with all the reaction load variables load_func = str(b.load) if (debug): print("\nTIME:", time.time() - s1) print("LOAD FUNC: ", load_func) reactions = getReactionVarsDict(load_func) #preparing parameters to pass to b.solve_for_reaction_loads() params = '' for key in reactions: params = params + "reactions['" + key + "']," params = params.rstrip(',') #creating command to solve for reaction loads solve_for_reacs = "b.solve_for_reaction_loads(" + params + ")" eval(solve_for_reacs) #------------------------------------------------------------------------------------------------------------------------- # at this stage all the calculations are done and the beam is solved. Time to extract the results... #------------------------------------------------------------------------------------------------------------------------- maxflag = False if (len(pl_forces) < 2 and len(mom_moments) < 2 and dl_loads[0] == '' and len(sup_types) == 1): maxflag = True load_func = str(b.load) if (debug): print("\nTIME:", time.time() - s1) print("\nload_func: ", load_func) reactions = str(b.reaction_loads) sf, max_sf_loc, max_sf = getShearForce(b, maxflag) bm, max_bm_loc, max_bm = getBendingMoment(b, maxflag) defl, max_defl_loc, max_defl = getDeflection(b, maxflag) #Shear Force and Bending Moment Functions sf_func = str(sf) if (debug): print("\nProblem 5:", time.time() - s1) print("\nsf_func: ", sf_func) bm_func = str(bm) if (debug): print("\nTIME:", time.time() - s1) print("\nbm_func: ", bm_func) slope_func = str(getSlope(b)) if (debug): print("\nTIME:", time.time() - s1) print("\nslope_func: ", slope_func) defl_func = str(defl) if (debug): print("\nTIME:", time.time() - s1) print("\defl_func: ", defl_func) getDrawing(b) tot_time = time.time() - s1 #final results res_beam = SolvedBeam(E, I, blen, load_func, reactions,\ sf_func, max_sf, max_sf_loc,\ bm_func,max_bm, max_bm_loc,\ slope_func,\ defl_func, max_defl, max_defl_loc, tot_time) return res_beam
def test_Beam(): E = Symbol('E') E_1 = Symbol('E_1') I = Symbol('I') I_1 = Symbol('I_1') b = Beam(1, E, I) assert b.length == 1 assert b.elastic_modulus == E assert b.second_moment == I assert b.variable == x # Test the length setter b.length = 4 assert b.length == 4 # Test the E setter b.elastic_modulus = E_1 assert b.elastic_modulus == E_1 # Test the I setter b.second_moment = I_1 assert b.second_moment is I_1 # Test the variable setter b.variable = y assert b.variable is y # Test for all boundary conditions. b.bc_deflection = [(0, 2)] b.bc_slope = [(0, 1)] assert b.boundary_conditions == {'deflection': [(0, 2)], 'slope': [(0, 1)]} # Test for slope boundary condition method b.bc_slope.extend([(4, 3), (5, 0)]) s_bcs = b.bc_slope assert s_bcs == [(0, 1), (4, 3), (5, 0)] # Test for deflection boundary condition method b.bc_deflection.extend([(4, 3), (5, 0)]) d_bcs = b.bc_deflection assert d_bcs == [(0, 2), (4, 3), (5, 0)] # Test for updated boundary conditions bcs_new = b.boundary_conditions assert bcs_new == { 'deflection': [(0, 2), (4, 3), (5, 0)], 'slope': [(0, 1), (4, 3), (5, 0)]} b1 = Beam(30, E, I) b1.apply_load(-8, 0, -1) b1.apply_load(R1, 10, -1) b1.apply_load(R2, 30, -1) b1.apply_load(120, 30, -2) b1.bc_deflection = [(10, 0), (30, 0)] b1.solve_for_reaction_loads(R1, R2) # Test for finding reaction forces p = b1.reaction_loads q = {R1: 6, R2: 2} assert p == q # Test for load distribution function. p = b1.load q = -8*SingularityFunction(x, 0, -1) + 6*SingularityFunction(x, 10, -1) + 120*SingularityFunction(x, 30, -2) + 2*SingularityFunction(x, 30, -1) assert p == q # Test for shear force distribution function p = b1.shear_force() q = -8*SingularityFunction(x, 0, 0) + 6*SingularityFunction(x, 10, 0) + 120*SingularityFunction(x, 30, -1) + 2*SingularityFunction(x, 30, 0) assert p == q # Test for bending moment distribution function p = b1.bending_moment() q = -8*SingularityFunction(x, 0, 1) + 6*SingularityFunction(x, 10, 1) + 120*SingularityFunction(x, 30, 0) + 2*SingularityFunction(x, 30, 1) assert p == q # Test for slope distribution function p = b1.slope() q = -4*SingularityFunction(x, 0, 2) + 3*SingularityFunction(x, 10, 2) + 120*SingularityFunction(x, 30, 1) + SingularityFunction(x, 30, 2) + S(4000)/3 assert p == q/(E*I) # Test for deflection distribution function p = b1.deflection() q = 4000*x/3 - 4*SingularityFunction(x, 0, 3)/3 + SingularityFunction(x, 10, 3) + 60*SingularityFunction(x, 30, 2) + SingularityFunction(x, 30, 3)/3 - 12000 assert p == q/(E*I) # Test using symbols l = Symbol('l') w0 = Symbol('w0') w2 = Symbol('w2') a1 = Symbol('a1') c = Symbol('c') c1 = Symbol('c1') d = Symbol('d') e = Symbol('e') f = Symbol('f') b2 = Beam(l, E, I) b2.apply_load(w0, a1, 1) b2.apply_load(w2, c1, -1) b2.bc_deflection = [(c, d)] b2.bc_slope = [(e, f)] # Test for load distribution function. p = b2.load q = w0*SingularityFunction(x, a1, 1) + w2*SingularityFunction(x, c1, -1) assert p == q # Test for shear force distribution function p = b2.shear_force() q = w0*SingularityFunction(x, a1, 2)/2 + w2*SingularityFunction(x, c1, 0) assert p == q # Test for bending moment distribution function p = b2.bending_moment() q = w0*SingularityFunction(x, a1, 3)/6 + w2*SingularityFunction(x, c1, 1) assert p == q # Test for slope distribution function p = b2.slope() q = (w0*SingularityFunction(x, a1, 4)/24 + w2*SingularityFunction(x, c1, 2)/2)/(E*I) + (E*I*f - w0*SingularityFunction(e, a1, 4)/24 - w2*SingularityFunction(e, c1, 2)/2)/(E*I) assert p == q # Test for deflection distribution function p = b2.deflection() q = x*(E*I*f - w0*SingularityFunction(e, a1, 4)/24 - w2*SingularityFunction(e, c1, 2)/2)/(E*I) + (w0*SingularityFunction(x, a1, 5)/120 + w2*SingularityFunction(x, c1, 3)/6)/(E*I) + (E*I*(-c*f + d) + c*w0*SingularityFunction(e, a1, 4)/24 + c*w2*SingularityFunction(e, c1, 2)/2 - w0*SingularityFunction(c, a1, 5)/120 - w2*SingularityFunction(c, c1, 3)/6)/(E*I) assert p == q b3 = Beam(9, E, I) b3.apply_load(value=-2, start=2, order=2, end=3) b3.bc_slope.append((0, 2)) C3 = symbols('C3') C4 = symbols('C4') p = b3.load q = -2*SingularityFunction(x, 2, 2) + 2*SingularityFunction(x, 3, 0) + 4*SingularityFunction(x, 3, 1) + 2*SingularityFunction(x, 3, 2) assert p == q p = b3.slope() q = 2 + (-SingularityFunction(x, 2, 5)/30 + SingularityFunction(x, 3, 3)/3 + SingularityFunction(x, 3, 4)/6 + SingularityFunction(x, 3, 5)/30)/(E*I) assert p == q p = b3.deflection() q = 2*x + (-SingularityFunction(x, 2, 6)/180 + SingularityFunction(x, 3, 4)/12 + SingularityFunction(x, 3, 5)/30 + SingularityFunction(x, 3, 6)/180)/(E*I) assert p == q + C4 b4 = Beam(4, E, I) b4.apply_load(-3, 0, 0, end=3) p = b4.load q = -3*SingularityFunction(x, 0, 0) + 3*SingularityFunction(x, 3, 0) assert p == q p = b4.slope() q = -3*SingularityFunction(x, 0, 3)/6 + 3*SingularityFunction(x, 3, 3)/6 assert p == q/(E*I) + C3 p = b4.deflection() q = -3*SingularityFunction(x, 0, 4)/24 + 3*SingularityFunction(x, 3, 4)/24 assert p == q/(E*I) + C3*x + C4 # can't use end with point loads raises(ValueError, lambda: b4.apply_load(-3, 0, -1, end=3)) with raises(TypeError): b4.variable = 1
def test_beam_units(): E = Symbol('E') I = Symbol('I') R1, R2 = symbols('R1, R2') b = Beam(8*meter, 200*giga*newton/meter**2, 400*1000000*(milli*meter)**4) b.apply_load(5*kilo*newton, 2*meter, -1) b.apply_load(R1, 0*meter, -1) b.apply_load(R2, 8*meter, -1) b.apply_load(10*kilo*newton/meter, 4*meter, 0, end=8*meter) b.bc_deflection = [(0*meter, 0*meter), (8*meter, 0*meter)] b.solve_for_reaction_loads(R1, R2) assert b.reaction_loads == {R1: -13750*newton, R2: -31250*newton} b = Beam(3*meter, E*newton/meter**2, I*meter**4) b.apply_load(8*kilo*newton, 1*meter, -1) b.apply_load(R1, 0*meter, -1) b.apply_load(R2, 3*meter, -1) b.apply_load(12*kilo*newton*meter, 2*meter, -2) b.bc_deflection = [(0*meter, 0*meter), (3*meter, 0*meter)] b.solve_for_reaction_loads(R1, R2) assert b.reaction_loads == {R1: -28000*newton/3, R2: 4000*newton/3} assert b.deflection().subs(x, 1*meter) == 62000*meter/(9*E*I)
from sympy.physics.continuum_mechanics.beam import Beam from sympy import symbols R1, R2 = symbols('R1, R2') E, I = symbols('E, I') b = Beam(50, 20, 30) b.apply_load(10, 2, -1) b.apply_load(R1, 10, -1) b.apply_load(R2, 30, -1) b.apply_load(90, 5, 0, 23) b.apply_load(10, 30, 1, 50) b.apply_support(50, "pin") b.apply_support(0, "fixed") b.apply_support(20, "roller") p = b.draw() p # Plot object containing: # [0]: cartesian line: 25*SingularityFunction(x, 5, 0) - 25*SingularityFunction(x, 23, 0) # + SingularityFunction(x, 30, 1) - 20*SingularityFunction(x, 50, 0) # - SingularityFunction(x, 50, 1) + 5 for x over (0.0, 50.0) # [1]: cartesian line: 5 for x over (0.0, 50.0) p.show()
def test_parabolic_loads(): E, I, L = symbols('E, I, L', positive=True, real=True) R, M, P = symbols('R, M, P', real=True) # cantilever beam fixed at x=0 and parabolic distributed loading across # length of beam beam = Beam(L, E, I) beam.bc_deflection.append((0, 0)) beam.bc_slope.append((0, 0)) beam.apply_load(R, 0, -1) beam.apply_load(M, 0, -2) # parabolic load beam.apply_load(1, 0, 2) beam.solve_for_reaction_loads(R, M) assert beam.reaction_loads[R] == -L**3 / 3 # cantilever beam fixed at x=0 and parabolic distributed loading across # first half of beam beam = Beam(2 * L, E, I) beam.bc_deflection.append((0, 0)) beam.bc_slope.append((0, 0)) beam.apply_load(R, 0, -1) beam.apply_load(M, 0, -2) # parabolic load from x=0 to x=L beam.apply_load(1, 0, 2, end=L) beam.solve_for_reaction_loads(R, M) # result should be the same as the prior example assert beam.reaction_loads[R] == -L**3 / 3 # check constant load beam = Beam(2 * L, E, I) beam.apply_load(P, 0, 0, end=L) loading = beam.load.xreplace({L: 10, E: 20, I: 30, P: 40}) assert loading.xreplace({x: 5}) == 40 assert loading.xreplace({x: 15}) == 0 # check ramp load beam = Beam(2 * L, E, I) beam.apply_load(P, 0, 1, end=L) assert beam.load == (P*SingularityFunction(x, 0, 1) - P*SingularityFunction(x, L, 1) - P*L*SingularityFunction(x, L, 0)) # check higher order load: x**8 load from x=0 to x=L beam = Beam(2 * L, E, I) beam.apply_load(P, 0, 8, end=L) loading = beam.load.xreplace({L: 10, E: 20, I: 30, P: 40}) assert loading.xreplace({x: 5}) == 40 * 5**8 assert loading.xreplace({x: 15}) == 0
def test_beam_units(): E = Symbol('E') I = Symbol('I') R1, R2 = symbols('R1, R2') b = Beam(8*meter, 200*giga*newton/meter**2, 400*1000000*(milli*meter)**4) b.apply_load(5*kilo*newton, 2*meter, -1) b.apply_load(R1, 0*meter, -1) b.apply_load(R2, 8*meter, -1) b.apply_load(10*kilo*newton/meter, 4*meter, 0, end=8*meter) b.bc_deflection = [(0*meter, 0*meter), (8*meter, 0*meter)] b.solve_for_reaction_loads(R1, R2) assert b.reaction_loads == {R1: -13750*newton, R2: -31250*newton} b = Beam(3*meter, E*newton/meter**2, I*meter**4) b.apply_load(8*kilo*newton, 1*meter, -1) b.apply_load(R1, 0*meter, -1) b.apply_load(R2, 3*meter, -1) b.apply_load(12*kilo*newton*meter, 2*meter, -2) b.bc_deflection = [(0*meter, 0*meter), (3*meter, 0*meter)] b.solve_for_reaction_loads(R1, R2) assert b.reaction_loads == {R1: -28000*newton/3, R2: 4000*newton/3} assert b.deflection().subs(x, 1*meter) == 62000*meter/(9*E*I)