def setUp(self):
# create materials
steel = Steel()
# create 2d frame analysis object
self.analysis = FrameAnalysis2D()
section1 = Section(area=6e3, ixx=200e6)
section2 = Section(area=4e3, ixx=50e6)
# create nodes
self.node_a = self.analysis.create_node(coords=[0])
self.node_b = self.analysis.create_node(coords=[8000])
self.node_c = self.analysis.create_node(coords=[13000])
# create beam elements
self.element_ab = self.analysis.create_element(
el_type='EB2-2D',
nodes=[self.node_a, self.node_b],
material=steel,
section=section1)
self.element_bc = self.analysis.create_element(
el_type='EB2-2D',
nodes=[self.node_b, self.node_c],
material=steel,
section=section2)
def test_example2_3(self):
# create 2d frame analysis object
analysis = FrameAnalysis2D()
# create sections
steel = Steel()
section1 = Section(area=4000)
section2 = Section(area=1000)
# create nodes
a = analysis.create_node(coords=[0, 0])
b = analysis.create_node(coords=[2000, 2000])
c = analysis.create_node(coords=[-4000, 2000])
# create truss elements
el1 = analysis.create_element(el_type='Bar2-2D',
nodes=[c, a],
material=steel,
section=section1)
el2 = analysis.create_element(el_type='Bar2-2D',
nodes=[a, b],
material=steel,
section=section2)
# add supports
freedom_case = cases.FreedomCase()
freedom_case.add_nodal_support(node=b, val=0, dof=0)
freedom_case.add_nodal_support(node=b, val=0, dof=1)
freedom_case.add_nodal_support(node=c, val=0, dof=0)
freedom_case.add_nodal_support(node=c, val=0, dof=1)
sup1 = freedom_case.add_nodal_support(node=a, val=0, dof=0)
sup2 = freedom_case.add_nodal_support(node=a, val=-5, dof=1)
# add loads
load_case = cases.LoadCase()
# add analysis case
analysis_case = cases.AnalysisCase(freedom_case=freedom_case,
load_case=load_case)
# linear static solver
LinearStatic(analysis=analysis, analysis_cases=[analysis_case]).solve()
# check reactions
self.assertEqual(np.around(sup1.get_reaction(analysis_case) / 1e3, 1),
181.0)
self.assertEqual(np.around(sup2.get_reaction(analysis_case) / 1e3, 1),
-355.7)
from feastruct.solvers.linstatic import LinearStatic
from feastruct.solvers.feasolve import SolverSettings
# ------------
# preprocessor
# ------------
# lists
nodes = [] # list holding the node objects
elements = [] # list holding the element objects
freedom_cases = [] # list holding the freedom cases
load_cases = [] # list holding the load cases
analysis_cases = [] # list holding the analysis cases
# create 2d frame analysis object
analysis = FrameAnalysis2D()
# create materials and sections
steel = Steel()
section = Section(area=3230, ixx=23.6e6)
# create nodes
nodes.append(analysis.create_node(coords=[0, 0]))
nodes.append(analysis.create_node(coords=[1500, 0]))
nodes.append(analysis.create_node(coords=[3000, 1500]))
# create beam elements
for i in range(2):
elements.append(
analysis.create_element(el_type='EB2-2D',
nodes=[nodes[i], nodes[i + 1]],
def test_example2_2(self):
# create 2d frame analysis object
analysis = FrameAnalysis2D()
# create sections
steel = Steel()
section1 = Section(area=5000)
section2 = Section(area=3000)
# create nodes
a = analysis.create_node(coords=[0, 0])
b = analysis.create_node(coords=[3000, 3000])
c = analysis.create_node(coords=[3000, -3000])
d = analysis.create_node(coords=[-3000 / np.tan(np.pi / 6), 3000])
e = analysis.create_node(coords=[-3000 / np.tan(np.pi / 6), -3000])
# create truss elements
el1 = analysis.create_element(el_type='Bar2-2D',
nodes=[e, a],
material=steel,
section=section1)
el2 = analysis.create_element(el_type='Bar2-2D',
nodes=[d, a],
material=steel,
section=section1)
el3 = analysis.create_element(el_type='Bar2-2D',
nodes=[b, a],
material=steel,
section=section2)
el4 = analysis.create_element(el_type='Bar2-2D',
nodes=[c, a],
material=steel,
section=section2)
# add supports
freedom_case = cases.FreedomCase()
freedom_case.add_nodal_support(node=b, val=0, dof=0)
freedom_case.add_nodal_support(node=b, val=0, dof=1)
freedom_case.add_nodal_support(node=c, val=0, dof=0)
freedom_case.add_nodal_support(node=c, val=0, dof=1)
freedom_case.add_nodal_support(node=d, val=0, dof=0)
freedom_case.add_nodal_support(node=d, val=0, dof=1)
freedom_case.add_nodal_support(node=e, val=0, dof=0)
freedom_case.add_nodal_support(node=e, val=0, dof=1)
# add loads
load_case = cases.LoadCase()
load_case.add_nodal_load(node=a, val=1000e3, dof=0)
# add analysis case
analysis_case = cases.AnalysisCase(freedom_case=freedom_case,
load_case=load_case)
# linear static solver
LinearStatic(analysis=analysis, analysis_cases=[analysis_case]).solve()
# check node displacement
dofs = a.get_dofs(a.nfs)
u = dofs[0].get_displacement(analysis_case)
v = dofs[1].get_displacement(analysis_case)
self.assertEqual(np.around(u, 2), 2.55)
self.assertEqual(np.around(v, 2), 0)
# check axial forces
n1 = el1.get_afd(n=1, analysis_case=analysis_case)
n2 = el2.get_afd(n=1, analysis_case=analysis_case)
n3 = el3.get_afd(n=1, analysis_case=analysis_case)
n4 = el4.get_afd(n=1, analysis_case=analysis_case)
self.assertEqual(np.around(n1 / 1e3, 1), 368.8)
self.assertEqual(np.around(n2 / 1e3, 1), 368.8)
self.assertEqual(np.around(n3 / 1e3, 1), -255.5)
self.assertEqual(np.around(n4 / 1e3, 1), -255.5)
def test_example2_1(self):
nodes = [] # list holding the node objects
elements = [] # list holding the element objects
# create 2d frame analysis object
analysis = FrameAnalysis2D()
# create sections
steel = Steel()
section1 = Section(area=6000)
section2 = Section(area=8000)
# create nodes
nodes.append(analysis.create_node(coords=[0, 0]))
nodes.append(analysis.create_node(coords=[6000, 4000]))
nodes.append(analysis.create_node(coords=[9000, 0]))
# create truss elements
elements.append(
analysis.create_element(el_type='Bar2-2D',
nodes=[nodes[0], nodes[1]],
material=steel,
section=section1))
elements.append(
analysis.create_element(el_type='Bar2-2D',
nodes=[nodes[1], nodes[2]],
material=steel,
section=section2))
# add supports
freedom_case = cases.FreedomCase()
freedom_case.add_nodal_support(node=nodes[0], val=0, dof=0)
freedom_case.add_nodal_support(node=nodes[0], val=0, dof=1)
freedom_case.add_nodal_support(node=nodes[2], val=0, dof=0)
freedom_case.add_nodal_support(node=nodes[2], val=0, dof=1)
# add loads
load_case = cases.LoadCase()
load_case.add_nodal_load(node=nodes[1], val=500e3, dof=0)
# add analysis case
analysis_case = cases.AnalysisCase(freedom_case=freedom_case,
load_case=load_case)
# linear static solver
LinearStatic(analysis=analysis, analysis_cases=[analysis_case]).solve()
# check node displacement
node1 = nodes[1]
dofs = node1.get_dofs(node1.nfs)
u = dofs[0].get_displacement(analysis_case)
v = dofs[1].get_displacement(analysis_case)
self.assertEqual(np.around(u, 2), 2.41)
self.assertEqual(np.around(v, 2), 0.72)
# check axial forces
n1 = elements[0].get_afd(n=1, analysis_case=analysis_case)
n2 = elements[1].get_afd(n=1, analysis_case=analysis_case)
self.assertEqual(np.around(n1 / 1e3, 1), 400.6)
self.assertEqual(np.around(n2 / 1e3, 1), -277.8)
def preprocessor(length, depth, panels, freq):
w = 10 # load per unit length [N/mm]
dx = length / panels # length of a truss panel
# create 2d frame analysis object
analysis = FrameAnalysis2D()
# create materials and sections
steel = Steel()
section_deck = Section(area=3230, ixx=23.6e6) # 200UB25
section_vertical = Section(area=3000, ixx=3.91e6) # 100x9 SHS
section_diagonal = Section(area=314) # 20 dia rod
section_tie = Section(area=1018) # 36 dia rod
# create deck nodes
nodes_deck = []
for i in range(panels + 1):
nodes_deck.append(analysis.create_node(coords=[i * dx]))
# create tie nodes - first node coincides with first deck node
nodes_tie = [nodes_deck[0]]
for i in range(panels - 1):
# fit parabola
x = (i + 1) * dx
y = 4 * depth / length / length * x * x - 4 * depth / length * x
nodes_tie.append(analysis.create_node(coords=[x, y]))
# last node coincides with last deck node
nodes_tie.append(nodes_deck[-1])
# create deck (beam) elements
elements_deck = []
for i in range(panels):
elements_deck.append(
analysis.create_element(el_type='EB2-2D',
nodes=[nodes_deck[i], nodes_deck[i + 1]],
material=steel,
section=section_deck))
# create tie (bar) elements
elements_tie = []
for i in range(panels):
elements_tie.append(
analysis.create_element(el_type='Bar2-2D',
nodes=[nodes_tie[i], nodes_tie[i + 1]],
material=steel,
section=section_tie))
# create vertical (beam) elements
elements_vertical = []
for i in range(panels - 1):
elements_vertical.append(
analysis.create_element(
el_type='EB2-2D',
nodes=[nodes_deck[i + 1], nodes_tie[i + 1]],
material=steel,
section=section_vertical))
# create diagonal (bar) elements
elements_diaongal = []
for i in range(panels - 2):
elements_diaongal.append(
analysis.create_element(
el_type='Bar2-2D',
nodes=[nodes_deck[i + 1], nodes_tie[i + 2]],
material=steel,
section=section_diagonal))
elements_diaongal.append(
analysis.create_element(
el_type='Bar2-2D',
nodes=[nodes_deck[i + 2], nodes_tie[i + 1]],
material=steel,
section=section_diagonal))
# add supports
freedom_case = cases.FreedomCase()
freedom_case.add_nodal_support(node=nodes_deck[0], val=0, dof=0)
freedom_case.add_nodal_support(node=nodes_deck[0], val=0, dof=1)
freedom_case.add_nodal_support(node=nodes_deck[-1], val=0, dof=1)
# add loads
load_case = cases.LoadCase()
# if frequency analysis, don't bother adding load
if not freq:
for i in range(panels - 1):
load_case.add_nodal_load(node=nodes_deck[i + 1],
val=-w * dx,
dof=1)
# add analysis case
analysis_case = cases.AnalysisCase(freedom_case=freedom_case,
load_case=load_case)
return (analysis, analysis_case)
def test_example3_2(self):
nodes = [] # list holding the node objects
elements = [] # list holding the element objects
# create 2d frame analysis object
analysis = FrameAnalysis2D()
# create sections
steel = Steel()
section1 = Section(area=15e3)
section2 = Section(area=18e3)
section3 = Section(area=20e3)
# create nodes
nodes.append(analysis.create_node(coords=[0, 0]))
nodes.append(
analysis.create_node(coords=[4000 / np.tan(np.pi / 6), 4000]))
nodes.append(
analysis.create_node(coords=[4000 / np.tan(np.pi / 6) + 4000, 0]))
# create truss elements
elements.append(
analysis.create_element(el_type='Bar2-2D',
nodes=[nodes[0], nodes[1]],
material=steel,
section=section1))
elements.append(
analysis.create_element(el_type='Bar2-2D',
nodes=[nodes[1], nodes[2]],
material=steel,
section=section3))
elements.append(
analysis.create_element(el_type='Bar2-2D',
nodes=[nodes[0], nodes[2]],
material=steel,
section=section2))
# add supports
freedom_case = cases.FreedomCase()
sup1 = freedom_case.add_nodal_support(node=nodes[0], val=0, dof=0)
sup2 = freedom_case.add_nodal_support(node=nodes[0], val=0, dof=1)
sup3 = freedom_case.add_nodal_support(node=nodes[2], val=0, dof=1)
# add loads
load_case = cases.LoadCase()
load_case.add_nodal_load(node=nodes[1],
val=500e3 * np.cos(2 * np.pi / 9),
dof=0)
load_case.add_nodal_load(node=nodes[1],
val=500e3 * np.sin(2 * np.pi / 9),
dof=1)
# add analysis case
analysis_case = cases.AnalysisCase(freedom_case=freedom_case,
load_case=load_case)
# linear static solver
LinearStatic(analysis=analysis, analysis_cases=[analysis_case]).solve()
# check node displacement
node_a = nodes[1]
node_b = nodes[2]
dofs_a = node_a.get_dofs(node_a.nfs)
dofs_b = node_b.get_dofs(node_b.nfs)
u_a = dofs_a[0].get_displacement(analysis_case)
v_a = dofs_a[1].get_displacement(analysis_case)
u_b = dofs_b[0].get_displacement(analysis_case)
self.assertEqual(np.around(u_a, 2), 0.87)
self.assertEqual(np.around(v_a, 2), 1.24)
self.assertEqual(np.around(u_b, 2), -0.19)
# check axial forces
n1 = elements[0].get_afd(n=1, analysis_case=analysis_case)
n2 = elements[1].get_afd(n=1, analysis_case=analysis_case)
n3 = elements[2].get_afd(n=1, analysis_case=analysis_case)
self.assertEqual(np.around(n1 / 1e3, 1), 515.7)
self.assertEqual(np.around(n2 / 1e3, 1), 89.9)
self.assertEqual(np.around(n3 / 1e3, 1), -63.6)
# check reactions
rc_x = sup1.get_reaction(analysis_case=analysis_case)
rc_y = sup2.get_reaction(analysis_case=analysis_case)
rb_y = sup3.get_reaction(analysis_case=analysis_case)
self.assertEqual(np.around(rc_x / 1e3, 1), -383.0)
self.assertEqual(np.around(rc_y / 1e3, 1), -257.8)
self.assertEqual(np.around(rb_y / 1e3, 1), -63.6)
def test_example4_15(self):
# create materials
steel = Material(name='steel_imperial',
elastic_modulus=29e3,
poissons_ratio=0.3,
rho=0)
# create 2d frame analysis object
analysis = FrameAnalysis2D()
analysis.post.n_subdiv = 3
beam = Section(ixx=128.5)
# create nodes
n = 20 # number of beam segments (must be an even number to ensure point load in centre)
L = 300 # length
k_L = 15 # spring length
k = 1.5 # foundation modulus
dx = L / n
spring = Section(area=k * dx * k_L / 29e3)
beam_nodes = []
spring_nodes = []
# beam nodes
for i in range(n + 1):
beam_nodes.append(analysis.create_node(coords=[i * L / n]))
# spring nodes
for i in range(n - 1):
spring_nodes.append(
analysis.create_node(coords=[(i + 1) * L / n, -k_L]))
# create elements
beam_elements = []
spring_elements = []
# create beam elements
for i in range(n):
beam_elements.append(
analysis.create_element(
el_type='EB2-2D',
nodes=[beam_nodes[i], beam_nodes[i + 1]],
material=steel,
section=beam))
# create spring elements
for i in range(n - 1):
spring_elements.append(
analysis.create_element(
el_type='Bar2-2D',
nodes=[beam_nodes[i + 1], spring_nodes[i]],
material=steel,
section=spring))
# add supports
freedom_case = cases.FreedomCase()
spring_supports_x = []
spring_supports_y = []
# add end supports
freedom_case.add_nodal_support(node=beam_nodes[0], val=0, dof=0)
freedom_case.add_nodal_support(node=beam_nodes[0], val=0, dof=1)
freedom_case.add_nodal_support(node=beam_nodes[-1], val=0, dof=1)
# add spring support
for spring_node in spring_nodes:
spring_supports_x.append(
freedom_case.add_nodal_support(node=spring_node, val=0, dof=0))
spring_supports_y.append(
freedom_case.add_nodal_support(node=spring_node, val=0, dof=1))
# add loads
load_case = cases.LoadCase()
load_case.add_nodal_load(node=beam_nodes[int(n / 2)], val=-40, dof=1)
# add analysis case
analysis_case = cases.AnalysisCase(freedom_case=freedom_case,
load_case=load_case)
# linear static solver
LinearStatic(analysis=analysis, analysis_cases=[analysis_case]).solve()
# check node displacement
dof = beam_nodes[int(n / 2)].get_dofs(
[False, True, False, False, False, False])
v_p = dof[0].get_displacement(analysis_case)
self.assertEqual(np.around(v_p, 3), -0.238)
# check bending moment forces
m = beam_elements[int(n / 2)].get_bmd(n=2, analysis_case=analysis_case)
self.assertEqual(np.around(m[0], 0), -547)