class UniformCantileverWithLinearTwist_Test:
"""Values from R.H. MacNeal, R.L. Harder: "Proposed standard set of
problems to test FE accuracy"
"""
length = 12.0
width = 1.1
depth = 0.32
E = 29.0e6
tip_twist = np.pi / 2
num_elements = 12
def setup(self):
x = np.linspace(0, self.length, self.num_elements)
twist = x * self.tip_twist / self.length
EIy = self.E * self.width * self.depth ** 3 / 12
EIz = self.E * self.depth * self.width ** 3 / 12
self.fe = BeamFE(x, 0, 0, EIy, EIz, twist=twist)
self.fe.set_boundary_conditions('C', 'F')
def test_deflection_under_tip_load_y(self):
Q = transverse_load(self.num_elements, magnitude=1, only_tip=True)
defl, reactions = self.fe.static_deflection(Q=Q)
assert_allclose(defl[-6:][1], 0.001754, atol=1e-5)
def test_deflection_under_tip_load_z(self):
Q = transverse_load(self.num_elements, magnitude=1,
angle=(np.pi / 2), only_tip=True)
defl, reactions = self.fe.static_deflection(Q=Q)
assert_allclose(defl[-6:][2], 0.005424, atol=1e-5)
class UniformCantileverWithLinearTwist_Test:
"""Values from R.H. MacNeal, R.L. Harder: "Proposed standard set of
problems to test FE accuracy"
"""
length = 12.0
width = 1.1
depth = 0.32
E = 29.0e6
tip_twist = np.pi / 2
num_elements = 12
def setup(self):
x = np.linspace(0, self.length, self.num_elements)
twist = x * self.tip_twist / self.length
EIy = self.E * self.width * self.depth**3 / 12
EIz = self.E * self.depth * self.width**3 / 12
self.fe = BeamFE(x, 0, 0, EIy, EIz, twist=twist)
self.fe.set_boundary_conditions('C', 'F')
def test_deflection_under_tip_load_y(self):
Q = transverse_load(self.num_elements, magnitude=1, only_tip=True)
defl, reactions = self.fe.static_deflection(Q=Q)
assert_allclose(defl[-6:][1], 0.001754, atol=1e-5)
def test_deflection_under_tip_load_z(self):
Q = transverse_load(self.num_elements,
magnitude=1,
angle=(np.pi / 2),
only_tip=True)
defl, reactions = self.fe.static_deflection(Q=Q)
assert_allclose(defl[-6:][2], 0.005424, atol=1e-5)
class UniformCantileverWithConstantTwist_Test:
length = 3.2
density = 54.3
EIy = 494.2
EIz = 654.2
twist = np.radians(76.4)
def setup(self):
x = np.linspace(0, self.length, 10)
self.fe = BeamFE(x,
self.density,
0,
self.EIy,
self.EIz,
twist=self.twist)
self.fe.set_boundary_conditions('C', 'F')
def test_mass(self):
mass = self.length * self.density
assert_allclose(self.fe.mass, mass, atol=0.5)
def test_moment_of_mass(self):
I = self.density * self.length**2 / 2
m = np.dot(self.fe.S1, self.fe.q0)
assert_allclose(m[0], I, atol=0.5)
def test_moment_of_inertia(self):
Iyy = self.density * self.length**3 / 3
J = np.einsum('p, ijpq, q -> ij', self.fe.q0, self.fe.S2, self.fe.q0)
assert_allclose(J[0, 0], Iyy, atol=0.5)
assert_allclose(J[1:, 1:], 0)
def test_deflection_under_uniform_load(self):
w = 34.2 # N/m
Q = self.fe.distribute_load(transverse_load(10, w))
defl, reactions = self.fe.static_deflection(Q)
print(reactions)
x, y, z = defl[0::6], defl[1::6], defl[2::6]
# Resolve into local blade coordinates
tw = self.twist
wy = +w * np.cos(tw)
wz = -w * np.sin(tw)
local_y = wy * self.length**4 / (8 * self.EIz) # NB y defl -> EIzz
local_z = wz * self.length**4 / (8 * self.EIy)
assert_allclose(x, 0)
assert_allclose(y[-1], local_y * np.cos(tw) - local_z * np.sin(tw))
assert_allclose(z[-1], local_z * np.cos(tw) + local_y * np.sin(tw))
assert_allclose(reactions[1], -w * self.length)
class TestBeamFE_Example42(unittest.TestCase):
def setUp(self):
x = array([0.0, 4.0, 10.0])
EI = 144.0
# Using the z axis as the transverse direction gives the same
# sign convention as Reddy uses in 2D, namely that rotations
# are positive clockwise.
self.fe = BeamFE(x, density=0, EA=0, EIy=EI, EIz=0)
self.fe.set_boundary_conditions('C', 'F')
self.fe.set_dofs([False, False, True, False, True, False])
def test_stiffness(self):
# Reddy1993, p 164
expected = array([
[27, 0, 0, 0, 0, 0],
[-54, 144, 0, 0, 0, 0],
[-27, 54, 27 + 8, 0, 0, 0],
[-54, 72, 54 - 24, 144 + 96, 0, 0],
[0, 0, -8, 24, 8, 0],
[0, 0, -24, 48, 24, 96],
])
expected += expected.T - np.diag(expected.diagonal()) # make symmetric
expected_II = expected[2:6, 2:6]
expected_IB = expected[2:6, 0:2]
assert_allclose(self.fe.K_II, expected_II)
assert_allclose(self.fe.K_IB, expected_IB)
def test_distributed_load(self):
# Distributed force on second element:
load = array([0, 0, 0, 0, 0, 0, 0, 0, -100, 0, 0, 0])
Q = self.fe.distribute_load_on_element(1, load)
Q = Q[[2, 4, 8, 10, 14, 16]]
assert_allclose(Q, [0, 0, -90, 120, -210, -180])
def test_solution_without_spring(self):
# Distributed force on first element:
load = array([0, 0, 0, 0, 0, 0, 0, 0, -100, 0, 0, 0])
QF = self.fe.distribute_load_on_element(1, load)
# Solve static deflection
deflections, reactions = self.fe.static_deflection(QF)
# Expected values from Reddy
expected_deflections = zeros_like(deflections)
expected_deflections[[
8, 10, 14, 16
]] = array([-1.6, 0.72, -7.108, 0.99]) * 1e4 / 143.0
assert_allclose(deflections, expected_deflections, atol=1e1)
class TestBeamFE_Example42(unittest.TestCase):
def setUp(self):
x = array([0.0, 4.0, 10.0])
EI = 144.0
# Using the z axis as the transverse direction gives the same
# sign convention as Reddy uses in 2D, namely that rotations
# are positive clockwise.
self.fe = BeamFE(x, density=0, EA=0, EIy=EI, EIz=0)
self.fe.set_boundary_conditions('C', 'F')
self.fe.set_dofs([False, False, True, False, True, False])
def test_stiffness(self):
# Reddy1993, p 164
expected = array([
[27, 0, 0, 0, 0, 0],
[-54, 144, 0, 0, 0, 0],
[-27, 54, 27+8, 0, 0, 0],
[-54, 72, 54-24, 144+96, 0, 0],
[0, 0, -8, 24, 8, 0],
[0, 0, -24, 48, 24, 96],
])
expected += expected.T - np.diag(expected.diagonal()) # make symmetric
expected_II = expected[2:6, 2:6]
expected_IB = expected[2:6, 0:2]
assert_allclose(self.fe.K_II, expected_II)
assert_allclose(self.fe.K_IB, expected_IB)
def test_distributed_load(self):
# Distributed force on second element:
load = array([0, 0, 0, 0, 0, 0, 0, 0, -100, 0, 0, 0])
Q = self.fe.distribute_load_on_element(1, load)
Q = Q[[2, 4, 8, 10, 14, 16]]
assert_allclose(Q, [0, 0, -90, 120, -210, -180])
def test_solution_without_spring(self):
# Distributed force on first element:
load = array([0, 0, 0, 0, 0, 0, 0, 0, -100, 0, 0, 0])
QF = self.fe.distribute_load_on_element(1, load)
# Solve static deflection
deflections, reactions = self.fe.static_deflection(QF)
# Expected values from Reddy
expected_deflections = zeros_like(deflections)
expected_deflections[[8, 10, 14, 16]] = array(
[-1.6, 0.72, -7.108, 0.99]) * 1e4 / 143.0
assert_allclose(deflections, expected_deflections, atol=1e1)
class UniformCantileverWithConstantTwist_Test:
length = 3.2
density = 54.3
EIy = 494.2
EIz = 654.2
twist = np.radians(76.4)
def setup(self):
x = np.linspace(0, self.length, 10)
self.fe = BeamFE(x, self.density, 0, self.EIy, self.EIz,
twist=self.twist)
self.fe.set_boundary_conditions('C', 'F')
def test_mass(self):
mass = self.length * self.density
assert_allclose(self.fe.mass, mass, atol=0.5)
def test_moment_of_mass(self):
I = self.density * self.length ** 2 / 2
m = np.dot(self.fe.S1, self.fe.q0)
assert_allclose(m[0], I, atol=0.5)
def test_moment_of_inertia(self):
Iyy = self.density * self.length ** 3 / 3
J = np.einsum('p, ijpq, q -> ij', self.fe.q0, self.fe.S2, self.fe.q0)
assert_allclose(J[0, 0], Iyy, atol=0.5)
assert_allclose(J[1:, 1:], 0)
def test_deflection_under_uniform_load(self):
w = 34.2 # N/m
Q = self.fe.distribute_load(transverse_load(10, w))
defl, reactions = self.fe.static_deflection(Q)
print(reactions)
x, y, z = defl[0::6], defl[1::6], defl[2::6]
# Resolve into local blade coordinates
tw = self.twist
wy = +w * np.cos(tw)
wz = -w * np.sin(tw)
local_y = wy * self.length**4 / (8 * self.EIz) # NB y defl -> EIzz
local_z = wz * self.length**4 / (8 * self.EIy)
assert_allclose(x, 0)
assert_allclose(y[-1], local_y * np.cos(tw) - local_z * np.sin(tw))
assert_allclose(z[-1], local_z * np.cos(tw) + local_y * np.sin(tw))
assert_allclose(reactions[1], -w * self.length)
def test_static_deflection(self):
x = array([0.0, 4.0, 10.0])
EI = 144.0
# Using the z axis as the transverse direction gives the same
# sign convention as Reddy uses in 2D, namely that rotations
# are positive clockwise.
fe = BeamFE(x, density=10, EA=0, EIy=EI, EIz=0)
fe.set_boundary_conditions('C', 'F')
fe.set_dofs([False, False, True, False, True, False])
element = ModalElementFromFE('elem', fe)
# Distributed load, linearly interpolated
load = np.zeros((3, 3))
load[-1, 2] = -100 # Load in z direction at tip
element.apply_distributed_loading(load)
defl = -element.applied_stress / np.diag(element.K)
# Check against directly calculating static deflection from FE
Q = fe.distribute_load(interleave(load, 6))
defl_fe, reactions_fe = fe.static_deflection(Q)
assert_aae(dot(element.shapes, defl), defl_fe, decimal=2)
def test_static_deflection(self):
x = array([0.0, 4.0, 10.0])
EI = 144.0
# Using the z axis as the transverse direction gives the same
# sign convention as Reddy uses in 2D, namely that rotations
# are positive clockwise.
fe = BeamFE(x, density=10, EA=0, EIy=EI, EIz=0)
fe.set_boundary_conditions('C', 'F')
fe.set_dofs([False, False, True, False, True, False])
element = ModalElementFromFE('elem', fe)
# Distributed load, linearly interpolated
load = np.zeros((3, 3))
load[-1, 2] = -100 # Load in z direction at tip
element.apply_distributed_loading(load)
defl = -element.applied_stress / np.diag(element.K)
# Check against directly calculating static deflection from FE
Q = fe.distribute_load(interleave(load, 6))
defl_fe, reactions_fe = fe.static_deflection(Q)
assert_aae(dot(element.shapes, defl), defl_fe, decimal=2)
class TestBeamFE_Example41(unittest.TestCase):
def setUp(self):
x = array([0.0, 10.0, 22.0, 28.0])
EI = array([[2e7, 2e7],
[1e7, 1e7],
[1e7, 1e7]])
# Using the z axis as the transverse direction gives the same
# sign convention as Reddy uses in 2D, namely that rotations
# are positive clockwise.
self.fe = BeamFE(x, density=0, EA=0, EIy=EI, EIz=0)
self.fe.set_boundary_conditions('P', 'C')
self.fe.set_dofs([False, False, True, False, True, False])
def test_stiffness(self):
# Reddy1993, pp 161-162
expected = 1e7 * array([
[0.024, -0.12, -0.024, -0.12, 0, 0, 0, 0],
[0, 0.80, 0.12, 0.40, 0, 0, 0, 0],
[0, 0, 0.0309, 0.0783, -0.00694, -0.04167, 0, 0],
[0, 0, 0, 1.133, 0.0417, 0.167, 0, 0],
[0, 0, 0, 0, 0.0625, -0.125, -0.0556, -0.167],
[0, 0, 0, 0, 0, 1, 0.1667, 0.333],
[0, 0, 0, 0, 0, 0, 0.0556, 0.1667],
[0, 0, 0, 0, 0, 0, 0, 0.6667],
])
expected += expected.T - np.diag(expected.diagonal()) # make symmetric
expected_II = expected[1:6, 1:6]
expected_IB = expected[1:6, [0, 6, 7]]
assert_allclose(expected_II, self.fe.K_II, atol=1e-2 * 1e7)
assert_allclose(expected_IB, self.fe.K_IB, atol=1e-3 * 1e7)
def test_distributed_load(self):
# Distributed force on first element:
load = array([0, 0, -2400, 0, 0, 0, 0, 0, -2400, 0, 0, 0])
Q = self.fe.distribute_load_on_element(0, load)
Q = Q[[2, 4, 8, 10, 14, 16, 20, 22]]
assert_allclose(Q / 1e3, [-12, 20, -12, -20, 0, 0, 0, 0])
def test_solution(self):
# Distributed force on first element:
load = array([0, 0, -2400, 0, 0, 0, 0, 0, -2400, 0, 0, 0])
QF = self.fe.distribute_load_on_element(0, load)
# Nodal forces:
Q = np.zeros(self.fe.K.shape[0])
Q[14] = -10000 # z force at 3rd node
# Solve static deflection
deflections, reactions = self.fe.static_deflection(QF + Q)
# Expected values from Reddy
expected_deflections = zeros_like(deflections)
expected_deflections[[4, 8, 10, 14, 16]] = [0.03856, -0.2808, 0.01214,
-0.1103, -0.02752]
assert_allclose(deflections, expected_deflections, atol=1e-4)
expected_reactions = zeros_like(reactions)
expected_reactions[[2, 20, 22]] = [18565.54, 15434.46, 92164.83]
assert_allclose(reactions, expected_reactions, atol=1e-2)
def test_load_matrix_gives_same_result_as_method(self):
# Distributed force on all elements
load = np.zeros(4 * 6)
load[2::6] = [350, 324, 654, 54] # Z component
Q1 = self.fe.distribute_load(load)
Q2 = dot(self.fe.F, load)
assert_allclose(Q1, Q2)
class UniformCantilever_Test:
length = 3.2
density = 54.3
EI = 494.2
def setup(self):
x = np.linspace(0, self.length, 10)
self.fe = BeamFE(x, self.density, 0, self.EI, self.EI)
self.fe.set_boundary_conditions('C', 'F')
def test_mass(self):
mass = self.length * self.density
assert_allclose(self.fe.mass, mass, atol=0.5)
def test_moment_of_mass(self):
I = self.density * self.length ** 2 / 2
m = np.dot(self.fe.S1, self.fe.q0)
assert_allclose(m[0], I, atol=0.5)
def test_moment_of_inertia(self):
Iyy = self.density * self.length ** 3 / 3
J = np.einsum('p, ijpq, q -> ij', self.fe.q0, self.fe.S2, self.fe.q0)
assert_allclose(J[0, 0], Iyy, atol=0.5)
assert_allclose(J[1:, 1:], 0)
def test_deflection_with_tip_load(self):
# Simple tip load should produce databook tip deflection
W = 54.1 # N
Q = transverse_load(10, W, only_tip=True)
defl, reactions = self.fe.static_deflection(Q=Q)
x, y, z = defl[0::6], defl[1::6], defl[2::6]
assert_allclose(x, 0)
assert_allclose(z, 0)
assert_allclose(y[-1], W * self.length**3 / (3 * self.EI))
def test_deflection_under_uniform_load(self):
# Simple uniform load should produce databook tip deflection
w = 34.2 # N/m
Q = self.fe.distribute_load(transverse_load(10, magnitude=w))
defl, reactions = self.fe.static_deflection(Q)
x, y, z = defl[0::6], defl[1::6], defl[2::6]
assert_allclose(x, 0)
assert_allclose(z, 0)
assert_allclose(y[-1], w * self.length**4 / (8 * self.EI))
def test_deflection_is_parallel_to_uniform_loading(self):
w = 67.4 # distributed load (N/m)
theta = np.radians(35.4) # angle from y axis of load
Q = self.fe.distribute_load(transverse_load(10, w, theta))
defl, reactions = self.fe.static_deflection(Q)
x, y, z = defl[0::6], defl[1::6], defl[2::6]
assert_allclose(x, 0)
load_angle = np.arctan2(z, y)
assert_allclose(load_angle[1:], theta)
def test_reaction_force(self):
# Simple uniform load should produce databook tip deflection
w = 34.2 # N/m
F = transverse_load(10, w)
# Reaction force is F1 * F
R = np.dot(self.fe.F1, F)
assert_allclose(R, [0, w * self.length, 0])
class UniformCantilever_Test:
length = 3.2
density = 54.3
EI = 494.2
def setup(self):
x = np.linspace(0, self.length, 10)
self.fe = BeamFE(x, self.density, 0, self.EI, self.EI)
self.fe.set_boundary_conditions('C', 'F')
def test_mass(self):
mass = self.length * self.density
assert_allclose(self.fe.mass, mass, atol=0.5)
def test_moment_of_mass(self):
I = self.density * self.length**2 / 2
m = np.dot(self.fe.S1, self.fe.q0)
assert_allclose(m[0], I, atol=0.5)
def test_moment_of_inertia(self):
Iyy = self.density * self.length**3 / 3
J = np.einsum('p, ijpq, q -> ij', self.fe.q0, self.fe.S2, self.fe.q0)
assert_allclose(J[0, 0], Iyy, atol=0.5)
assert_allclose(J[1:, 1:], 0)
def test_deflection_with_tip_load(self):
# Simple tip load should produce databook tip deflection
W = 54.1 # N
Q = transverse_load(10, W, only_tip=True)
defl, reactions = self.fe.static_deflection(Q=Q)
x, y, z = defl[0::6], defl[1::6], defl[2::6]
assert_allclose(x, 0)
assert_allclose(z, 0)
assert_allclose(y[-1], W * self.length**3 / (3 * self.EI))
def test_deflection_under_uniform_load(self):
# Simple uniform load should produce databook tip deflection
w = 34.2 # N/m
Q = self.fe.distribute_load(transverse_load(10, magnitude=w))
defl, reactions = self.fe.static_deflection(Q)
x, y, z = defl[0::6], defl[1::6], defl[2::6]
assert_allclose(x, 0)
assert_allclose(z, 0)
assert_allclose(y[-1], w * self.length**4 / (8 * self.EI))
def test_deflection_is_parallel_to_uniform_loading(self):
w = 67.4 # distributed load (N/m)
theta = np.radians(35.4) # angle from y axis of load
Q = self.fe.distribute_load(transverse_load(10, w, theta))
defl, reactions = self.fe.static_deflection(Q)
x, y, z = defl[0::6], defl[1::6], defl[2::6]
assert_allclose(x, 0)
load_angle = np.arctan2(z, y)
assert_allclose(load_angle[1:], theta)
def test_reaction_force(self):
# Simple uniform load should produce databook tip deflection
w = 34.2 # N/m
F = transverse_load(10, w)
# Reaction force is F1 * F
R = np.dot(self.fe.F1, F)
assert_allclose(R, [0, w * self.length, 0])
class TestBeamFE_Example41(unittest.TestCase):
def setUp(self):
x = array([0.0, 10.0, 22.0, 28.0])
EI = array([[2e7, 2e7], [1e7, 1e7], [1e7, 1e7]])
# Using the z axis as the transverse direction gives the same
# sign convention as Reddy uses in 2D, namely that rotations
# are positive clockwise.
self.fe = BeamFE(x, density=0, EA=0, EIy=EI, EIz=0)
self.fe.set_boundary_conditions('P', 'C')
self.fe.set_dofs([False, False, True, False, True, False])
def test_stiffness(self):
# Reddy1993, pp 161-162
expected = 1e7 * array([
[0.024, -0.12, -0.024, -0.12, 0, 0, 0, 0],
[0, 0.80, 0.12, 0.40, 0, 0, 0, 0],
[0, 0, 0.0309, 0.0783, -0.00694, -0.04167, 0, 0],
[0, 0, 0, 1.133, 0.0417, 0.167, 0, 0],
[0, 0, 0, 0, 0.0625, -0.125, -0.0556, -0.167],
[0, 0, 0, 0, 0, 1, 0.1667, 0.333],
[0, 0, 0, 0, 0, 0, 0.0556, 0.1667],
[0, 0, 0, 0, 0, 0, 0, 0.6667],
])
expected += expected.T - np.diag(expected.diagonal()) # make symmetric
expected_II = expected[1:6, 1:6]
expected_IB = expected[1:6, [0, 6, 7]]
assert_allclose(expected_II, self.fe.K_II, atol=1e-2 * 1e7)
assert_allclose(expected_IB, self.fe.K_IB, atol=1e-3 * 1e7)
def test_distributed_load(self):
# Distributed force on first element:
load = array([0, 0, -2400, 0, 0, 0, 0, 0, -2400, 0, 0, 0])
Q = self.fe.distribute_load_on_element(0, load)
Q = Q[[2, 4, 8, 10, 14, 16, 20, 22]]
assert_allclose(Q / 1e3, [-12, 20, -12, -20, 0, 0, 0, 0])
def test_solution(self):
# Distributed force on first element:
load = array([0, 0, -2400, 0, 0, 0, 0, 0, -2400, 0, 0, 0])
QF = self.fe.distribute_load_on_element(0, load)
# Nodal forces:
Q = np.zeros(self.fe.K.shape[0])
Q[14] = -10000 # z force at 3rd node
# Solve static deflection
deflections, reactions = self.fe.static_deflection(QF + Q)
# Expected values from Reddy
expected_deflections = zeros_like(deflections)
expected_deflections[[4, 8, 10, 14, 16]] = [
0.03856, -0.2808, 0.01214, -0.1103, -0.02752
]
assert_allclose(deflections, expected_deflections, atol=1e-4)
expected_reactions = zeros_like(reactions)
expected_reactions[[2, 20, 22]] = [18565.54, 15434.46, 92164.83]
assert_allclose(reactions, expected_reactions, atol=1e-2)
def test_load_matrix_gives_same_result_as_method(self):
# Distributed force on all elements
load = np.zeros(4 * 6)
load[2::6] = [350, 324, 654, 54] # Z component
Q1 = self.fe.distribute_load(load)
Q2 = dot(self.fe.F, load)
assert_allclose(Q1, Q2)