def test_timoshenko_discrete():
system = SystemElements()
system.add_element(location=[[0.25, 0]],
EA=1.4e8,
EI=1.167e5,
GA=0.8333 * 8.75e6)
system.add_element(location=[[0.5, 0]],
EA=1.4e8,
EI=1.167e5,
GA=0.8333 * 8.75e6)
system.add_element(location=[[0.75, 0]],
EA=1.4e8,
EI=1.167e5,
GA=0.8333 * 8.75e6)
system.add_element(location=[[1, 0]],
EA=1.4e8,
EI=1.167e5,
GA=0.8333 * 8.75e6)
system.q_load(element_id=1, q=5000, direction="y")
system.q_load(element_id=2, q=5000, direction="y")
system.q_load(element_id=3, q=5000, direction="y")
system.q_load(element_id=4, q=5000, direction="y")
system.add_support_hinged(node_id=1)
system.add_support_roll(node_id=5)
system.solve()
assert np.isclose(abs(system.system_displacement_vector[7]),
6.44e-4,
rtol=1e-2)
def results():
# add section data and loads of the dialog
E = float(ui.editE.text())
I = float(ui.editI.text())
A = float(ui.editA.text())
ss = SystemElements()
frame = FreeCAD.ActiveDocument.getObjectsByLabel(
ui.comboBox.currentText())[0]
sk = frame.Base
for l in sk.Geometry:
sp = [i * 1e-3 for i in list(l.StartPoint)[:2]]
ep = [i * 1e-3 for i in list(l.EndPoint)[:2]]
ss.add_element([sp, ep], EA=E * A, EI=E * I)
for i in list(range(len(sk.Geometry))):
if ui.table.item(i, 1):
item = ui.table.item(i, 1)
try:
load = float(item.text())
ss.q_load(element_id=(i + 1), q=load)
except:
pass
for i in list(range(ss.id_last_node)):
if ui.table_2.item(i, 1):
if ui.table_2.item(i, 1).text() == 'fix':
ss.add_support_fixed(node_id=i + 1)
elif ui.table_2.item(i, 1).text() == 'hinge':
ss.add_support_hinged(node_id=i + 1)
elif ui.table_2.item(i, 1).text() == 'roll':
ss.add_support_roll(node_id=i + 1)
ss.solve()
ss.show_results()
def test_parallel_q_load():
system = SystemElements()
system.add_element(location=[[0, 0], [1, 0]], EA=5e9, EI=8000)
system.q_load(element_id=1, q=-10, direction="x")
system.add_support_hinged(node_id=1)
system.add_support_roll(node_id=2)
system.solve()
assert system.element_map[1].N_1 == -10
assert system.element_map[1].N_2 == 0
def test_linear_parallel_q_load():
system = SystemElements()
system.add_element(location=[[0, 0], [1, 0]], EA=5e2, EI=800)
system.add_element(location=[[1, 0], [2, 0]], EA=5e2, EI=800)
system.q_load(element_id=1, q=10, q2=20, direction="x")
system.add_support_hinged(node_id=1)
system.add_support_roll(node_id=3)
system.solve()
assert np.isclose(system.reaction_forces[1].Fx, -15)
assert np.isclose(np.max(system.system_displacement_vector), 0.01666667)
def test_bernoulli():
system = SystemElements()
system.add_element(location=[[0, 0], [1, 0]], EA=1.4e8, EI=1.167e5)
system.q_load(element_id=1, q=5000, direction="y")
system.add_support_hinged(node_id=1)
system.add_support_roll(node_id=2)
system.solve()
assert np.isclose(np.max(abs(system.element_map[1].deflection)),
5.58e-4,
rtol=1e-2)
def build_struct(nodes):
ss = SystemElements()
for i in range(len(nodes) - 1):
ss.add_element(location=[nodes[i], nodes[i + 1]])
ss.add_support_fixed(node_id=1)
if nodes.count(end_xy) > 0:
print("End point reached")
ss.add_support_fixed(node_id=nodes.index(end_xy) + 1)
ss.q_load(element_id=1, q=-1)
ss.solve()
ss.show_structure()
ss.show_displacement()
def test_linear_q_load():
system = SystemElements()
system.add_element(location=[[0, 0], [1, 0]], EA=5e8, EI=800)
system.add_element(location=[[1, 0], [2, 0]], EA=5e8, EI=800)
system.q_load(element_id=1, q=-10, q2=-20, direction="y")
system.add_support_hinged(node_id=1)
system.add_support_roll(node_id=3)
system.solve()
assert np.isclose(np.max(abs(system.element_map[1].shear_force)), 10.87, rtol=1e-2)
assert np.isclose(np.max(abs(system.element_map[2].shear_force)), 4.17, rtol=1e-2)
assert np.isclose(np.max(abs(system.element_map[1].bending_moment)), 4.62, rtol=1e-2)
assert np.isclose(np.max(abs(system.system_displacement_vector)), 3.7673e-3, rtol=1e-2)
def Beam_objective_funciton_BD(depths):
#def fn(*args):
#beam1 = Beam(depth,breadth,Asc,Ast,15,415,415,3.14*10**2/4,spacing);
#beam1.moment_capcity()
#beam1.min_spacing()
#beam1.max_spacing()
FS = SystemElements()
# Add beams to the system.
FS.add_element(location=[0, 5], EA=15000, EI=5000)
FS.add_element(location=[[0, 5], [5, 5]], EA=15000, EI=5000)
FS.add_element(location=[[5, 5], [5, 0]], EA=15000, EI=5000)
# Add a fixed support at node 1.
FS.add_support_fixed(node_id=1)
# Add a rotational spring support at node 4.
FS.add_support_spring(node_id=4, translation=3, k=4000)
# Add loads.
FS.point_load(Fx=30, node_id=2)
FS.q_load(q=-10, element_id=2)
FS.q_load(q=-10, element_id=1)
#ss.q_load(q=-10, element_id=4)
#print(ss.node_ranges())
# Solve
FS.solve()
FS.get_element_results(element_id=1)['length']
FS.get_element_results(element_id=1)['Mmin']
deno = FS.get_element_results(element_id=1)['Mmax']
#breadth = randgen(300,600)
#Asc = 0
#Ast = 0
#spacing = 150
#beam = Beam(depth,breadth,Asc,Ast,15,415,415,3.14*10**2/4,spacing)
#Asc = beam.p_min()
#Ast = beam.p_min()
#beam1 = Beam(depth,breadth,Asc,Ast,15,415,415,3.14*10**2/4,spacing)
#beam1.moment_capcity()
#beam1.min_spacing()
#beam1.max_spacing()
#print(beam1.moment_capcity()*10**(-3))
#print(FS.get_element_results(element_id=1)['Mmax'])
res, depth_f = Beam_gene(depths, deno)
C_D = res / deno
#print()
return C_D
def pressed(self):
x1 = int(self.x1value.text())
x2 = int(self.x2value.text())
y1 = int(self.y1value.text())
y2 = int(self.y2value.text())
movel = (int(self.movelvalue.text()))
fixo = (int(self.fixovalue.text()))
from anastruct import SystemElements
ss = SystemElements()
ss.add_element(location=[[x1, y1], [x2, y2]])
ss.add_support_hinged(node_id=movel)
ss.add_support_fixed(node_id=fixo)
ss.q_load(element_id=1, q=-10)
ss.solve()
ss.show_structure()
ss.show_reaction_force()
def test_timoshenko_continuous():
system = SystemElements()
system.add_element(location=[[0, 0], [1, 0]],
EA=1.4e8,
EI=1.167e5,
GA=0.8333 * 8.75e6)
system.q_load(element_id=1, q=5000, direction="y")
system.add_support_hinged(node_id=1)
system.add_support_roll(node_id=2)
system.solve()
assert np.isclose(np.max(abs(system.element_map[1].deflection)),
6.44e-4,
rtol=1e-2)
def test_example():
system = SystemElements()
system.add_element(location=[[0, 0], [3, 4]], EA=5e9, EI=8000)
system.add_element(location=[[3, 4], [8, 4]], EA=5e9, EI=4000)
system.q_load(element_id=2, q=-10)
system.add_support_hinged(node_id=1)
system.add_support_fixed(node_id=3)
sol = np.fromstring(
"""0.00000000e+00 0.00000000e+00 1.30206878e-03 1.99999732e-08
5.24999402e-08 -2.60416607e-03 0.00000000e+00 0.00000000e+00
0.00000000e+00""",
float,
sep=" ",
)
system.solve
assert np.allclose(system.solve(), sol)
def Beam_objective_funciton(breadth):
depth = randgen(300,600)
Asc = 0
Ast = 0
spacing = 150
beam = Beam(depth,breadth,Asc,Ast,15,415,415,3.14*10**2/4,spacing);
Asc = beam.p_min
Ast = beam.p_min
beam1 = Beam(depth,breadth,Asc,Ast,15,415,415,3.14*10**2/4,spacing);
beam1.moment_capcity()
beam1.min_spacing()
beam1.max_spacing()
FS = SystemElements()
# Add beams to the system.
FS.add_element(location=[0, 5],EA=15000, EI=5000)
FS.add_element(location=[[0, 5], [5, 5]],EA=15000, EI=5000)
FS.add_element(location=[[5, 5], [5, 0]],EA=15000, EI=5000)
# Add a fixed support at node 1.
FS.add_support_fixed(node_id=1)
# Add a rotational spring support at node 4.
FS.add_support_spring(node_id=4, translation=3, k=4000)
# Add loads.
FS.point_load(Fx=30, node_id=2)
FS.q_load(q=-10, element_id=2)
FS.q_load(q=-10, element_id=1)
#ss.q_load(q=-10, element_id=4)
#print(ss.node_ranges())
# Solve
FS.solve()
FS.get_element_results(element_id=1)['length']
FS.get_element_results(element_id=1)['Mmin']
FS.get_element_results(element_id=1)['Mmax']
print(beam1.moment_capcity()*10**(-3))
print(FS.get_element_results(element_id=1)['Mmax'])
def test_moment_load_benchmark():
system = SystemElements()
system.add_element(location=[[3.75, 0]], EA=5e12, EI=5e12)
system.add_element(location=[[7.5,0]], EA=5e12, EI=5e12)
system.q_moment(element_id=1, Ty=1.91)
system.q_moment(element_id=2, Ty=1.91)
system.q_load(element_id=1, q=3.62, direction="y")
system.q_load(element_id=2, q=3.62, direction="y")
system.add_support_spring(1, 2, 5)
system.add_support_spring(2, 2, 2.5)
system.add_support_spring(3, 2, 2.5)
system.solve()
assert np.isclose(np.max(abs(system.element_map[1].bending_moment)), 13.89,rtol=1e-2)
assert np.isclose(system.reaction_forces[1].Fz, 11.93,rtol=1e-2)
def test_moment_load_benchmark_2():
system = SystemElements()
system.add_element(location=[[3.125, 0]], EA=5e12, EI=5e12)
system.add_element(location=[[5.625+3.125,0]], EA=5e12, EI=5e12)
system.q_moment(element_id=1, Ty=1.836)
system.q_moment(element_id=2, Ty=1.836)
system.q_load(element_id=1, q=4.08, direction="y")
system.q_load(element_id=2, q=4.08, direction="y")
system.add_support_spring(1, 2, 3.75)
system.add_support_spring(2, 2, 2.5)
system.add_support_spring(3, 2, 2.5)
#system.add_support_hinged(1)
#system.add_support_hinged(2)
#system.add_support_hinged(3)
system.solve()
assert np.isclose(np.max(abs(system.element_map[2].bending_moment)), 24.87,rtol=1e-2)
assert np.isclose(np.max(abs(system.element_map[1].shear_force)), 13.2,rtol=1e-2)
def test_struct():
ss = SystemElements()
ss.add_element([[0, 0], [1, 0]])
ss.add_element([[1, 0], [1, 1]])
ss.add_element([[1, 0], [2, 0]])
ss.add_element([[2, 0], [3, 0]])
ss.add_element([[3, 0], [4, 1]])
ss.add_element([[4, 1], [5, 1]])
ss.point_load(2, Fy=10)
ss.point_load(3, Fy=-20, Fx=5)
ss.point_load(4, Fy=-30)
ss.point_load(5, Fx=-40)
ss.moment_load(2, Ty=-9)
ss.moment_load(1, 7)
ss.moment_load(3, 3)
ss.q_load(element_id=3, q=(-10, -20))
ss.q_load(element_id=5, q=(-10, -20))
ss.add_support_roll(4)
ss.add_support_hinged(5)
# ss.add_support_fixed(3)
mn = Manager(ss)
mn.generate_pdf(pdf_path=r"C:\testfolder")
def test_struct2():
ss = SystemElements()
ss.add_element([[0, 0], [1, 0]])
ss.add_element([[1, 0], [1, 1]])
ss.add_element([[1, 0], [2, 0]])
ss.add_element([[2, 0], [3, 0]])
ss.add_element([[3, 0], [4, 1]])
ss.add_element([[4, 1], [5, 1]])
ss.point_load(2, Fy=10)
ss.point_load(3, Fy=-20)
ss.point_load(4, Fy=-30)
ss.point_load(5, Fx=-40)
ss.moment_load(2, Ty=-9)
ss.moment_load(1, 7)
ss.moment_load(3, 3)
ss.q_load(element_id=3, q=(-10, -20))
ss.add_support_roll(4)
ss.add_support_hinged(5)
# ss.show_structure()
ss.solve()
ss.show_reaction_force(show=False)
ass = Assembler(ss)
ass.assemble_structure(main_path=Setting.longest)
[print(element.id, values) for element, values in ass.internal_stresses_dict.items()]
class Artist:
fig_counter = 0
def __init__(
self,
system_elements,
node_order=None,
assemble_order=None,
target_dir="tmp",
):
self.ss = system_elements
self.branch_ss = SystemElements()
self.assemble_order = assemble_order
self.node_order = node_order
self.target_dir = target_dir
def draw_structure(self,
show=False,
save_figure=True,
plotting_start_node=0,
element_id=0):
plot_iterations = False
node_index = 0
figure = plt.figure(figsize=(12, 8))
subplot = figure.add_subplot(111)
plt.tight_layout()
for branch in self.assemble_order:
self.draw_element(branch)
first_node = next(i for i in self.node_order
if i == branch[0] or i == branch[1])
for roll in self.ss.supports_roll:
if roll.id == first_node:
self.draw_support(first_node, subplot)
for hinged in self.ss.supports_hinged:
if hinged.id == first_node:
self.draw_support(first_node, subplot)
for fixed in self.ss.supports_fixed:
if fixed.id == first_node:
self.draw_support(first_node, subplot)
if self.ss.loads_point.get(first_node):
self.draw_point_load(first_node)
if self.ss.loads_moment.get(first_node):
self.draw_moment(first_node)
elements_node1 = self.ss.node_element_map.get(branch[0])
elements_node2 = self.ss.node_element_map.get(branch[1])
for element in elements_node1:
if element in elements_node2:
q_load = self.ss.loads_q.get(element.id)
if q_load:
if branch == self.assemble_order[-1]:
self.draw_q_load(
get_relative_element_by_coordinates(
self.ss, self.branch_ss, element.id),
q_load)
else:
xi = element.vertex_1.x
yi = element.vertex_1.y
xf = element.vertex_2.x
yf = element.vertex_2.y
x_average = (xi + xf) / 2
y_average = (yi + yf) / 2
base = ((xf - xi)**2 + (yf - yi)**2)**0.5
load = ((-q_load[0][0] + -q_load[1][0]) * base) / 2
Fz = load * math.cos(element.angle)
Fx = load * math.cos(element.angle -
(90 * math.pi / 180))
h = 0.2 * self.ss.plotter.max_val_structure
x, y, len_x, len_y, point_load = get_arrow_patch_values(
Fx, Fz, (x_average, y_average), h)
plot_arrow(subplot, point_load,
[h, h, [x, y, len_x, len_y]])
# needs further testing
break
node_index += 1
if plotting_start_node in branch:
plot_iterations = True
if show and plot_iterations:
self.branch_ss.show_structure(show=False,
figure=(figure, subplot))
figure.show()
if save_figure and plot_iterations:
fig = self.branch_ss.show_structure(show=False,
figure=(figure, subplot))
fig.savefig(fr'{self.target_dir}\figs\structure{element_id}')
def generate_figures_for_pdf(self):
fig = self.ss.show_structure(show=False)
fig.savefig(fr'{self.target_dir}\figs\structure')
fig = self.ss.show_structure(show=False, free_body_diagram=3)
fig.savefig(fr'{self.target_dir}\figs\diagram1')
fig = self.ss.show_structure(show=False, free_body_diagram=2)
fig.savefig(fr'{self.target_dir}\figs\diagram2')
fig = self.ss.show_reaction_force(show=False)
fig.savefig(fr'{self.target_dir}\figs\supports')
fig = self.ss.show_axial_force(show=False)
fig.savefig(fr'{self.target_dir}\figs\axial')
fig = self.ss.show_shear_force(show=False)
fig.savefig(fr'{self.target_dir}\figs\shear')
fig = self.ss.show_bending_moment(show=False)
fig.savefig(fr'{self.target_dir}\figs\moment')
def draw_support(self, node_id, subplot, roll_direction=None):
support_node = self.ss.reaction_forces.get(node_id)
if round(support_node.Fx, 2):
plot_arrow(subplot, support_node.Fx,
self.ss.reaction_vectors_data.get(f"{node_id}Fx"))
if round(support_node.Fz, 2):
plot_arrow(subplot, support_node.Fz,
self.ss.reaction_vectors_data.get(f"{node_id}Fz"))
if round(support_node.Ty, 2):
plot_moment(subplot, self.ss.node_map.get(node_id),
support_node.Ty,
self.ss.reaction_vectors_data.get(f"{node_id}Ty"))
def draw_element(self, branch):
self.add_element_to_plot(branch)
def add_element_to_plot(self, element):
for node in range(len(element) - 1):
self.branch_ss.add_element(
[[
self.ss.node_map.get(element[node]).vertex.x,
self.ss.node_map.get(element[node]).vertex.y
],
[
self.ss.node_map.get(element[node + 1]).vertex.x,
self.ss.node_map.get(element[node + 1]).vertex.y
]])
def draw_point_load(self, node_id):
point_load = self.ss.loads_point[node_id]
self.branch_ss.point_load(
node_id=self.get_relative_node_by_coordinates(node_id),
Fx=point_load[0],
Fy=-point_load[1])
def draw_q_load(self, element_id, q_load):
self.branch_ss.q_load(element_id=element_id,
q=(q_load[0][0], q_load[1][0]))
def draw_moment(self, node_id):
moment_load = self.ss.loads_moment.get(node_id)
self.branch_ss.moment_load(
node_id=self.get_relative_node_by_coordinates(node_id),
Ty=moment_load)
def get_relative_node_by_coordinates(self, node_id):
coords = (self.ss.node_map.get(node_id).vertex.x,
self.ss.node_map.get(node_id).vertex.y)
for node_key in self.branch_ss.node_map:
node = self.branch_ss.node_map.get(node_key)
if coords[0] == node.vertex.x and coords[1] == node.vertex.y:
return node.id
return None
def shear_design(Ast, B, D, Vu, fck, fy):
FS = SystemElements()
# Add beams to the system.
FS.add_element(location=[0, 5], EA=15000, EI=5000)
FS.add_element(location=[[0, 5], [5, 5]], EA=15000, EI=5000)
FS.add_element(location=[[5, 5], [5, 0]], EA=15000, EI=5000)
# Add a fixed support at node 1.
FS.add_support_fixed(node_id=1)
# Add a rotational spring support at node 4.
FS.add_support_spring(node_id=4, translation=3, k=4000)
# Add loads.
FS.point_load(Fx=30, node_id=2)
FS.q_load(q=-10, element_id=2)
FS.q_load(q=-10, element_id=1)
#ss.q_load(q=-10, element_id=4)
#print(ss.node_ranges())
# Solve
FS.solve()
FS.get_element_results(element_id=1)['length']
FS.get_element_results(element_id=1)['Mmin']
deno = FS.get_element_results(element_id=1)['shear']
#breadth = randgen(300,600)
#Asc = 0
#Ast = 0
#spacing = 150
#beam = Beam(depth,breadth,Asc,Ast,15,415,415,3.14*10**2/4,spacing)
#Asc = beam.p_min()
#Ast = beam.p_min()
#beam1 = Beam(depth,breadth,Asc,Ast,15,415,415,3.14*10**2/4,spacing)
#beam1.moment_capcity()
#beam1.min_spacing()
#beam1.max_spacing()
#print(beam1.moment_capcity()*10**(-3))
#print(FS.get_element_results(element_id=1)['Mmax'])
res = Beam_gene(depths)
beam1 = Beam(depth, breadth, Asc, Ast, 15, 415, 415, 3.14 * 10**2 / 4,
spacing)
beam1.moment_capcity()
beam1.min_spacing()
beam1.max_spacing()
# Add a fixed support at node 1.
FS.add_support_fixed(node_id=1)
# Add a rotational spring support at node 4.
FS.add_support_spring(node_id=4, translation=3, k=4000)
# Add loads.
FS.point_load(Fx=30, node_id=2)
FS.q_load(q=-10, element_id=2)
FS.q_load(q=-10, element_id=1)
#ss.q_load(q=-10, element_id=4)
#print(ss.node_ranges())
# Solve
FS.solve()
FS.get_element_results(element_id=1)['length']
FS.get_element_results(element_id=1)['Mmin']
FS.get_element_results(element_id=1)['Mmax']
FS.get_element_results(element_id=1)['shear']
#print(beam1.moment_capcity()*10**(-3))
#print(FS.get_element_results(element_id=1)['Mmax'])
C_D = ((beam1.moment_capcity()) *
10**(-3)) / (FS.get_element_results(element_id=1)['Mmax'])
print(C_D)
from StructuresExplained.solutions.structure.reactions.assembler import Assembler
if __name__ == "__main__":
from anastruct import SystemElements
from sympy import sympify
ss = SystemElements()
ss.add_element([[0, 0], [1, 0]])
ss.add_element([[1, 0], [1, 1]])
ss.add_element([[1, 0], [2, 0]])
ss.add_element([[2, 0], [3, 0]])
ss.point_load(2, Fy=10)
ss.point_load(3, Fy=-20)
ss.point_load(4, Fy=-30)
ss.point_load(5, Fx=-40)
ss.moment_load(2, Ty=-9)
ss.moment_load(1, 7)
ss.moment_load(3, 3)
ss.q_load(element_id=3, q=(-10, -20))
ss.add_support_roll(4)
ss.add_support_hinged(5)
ss.solve()
ass = Assembler(ss)
ass.assemble_structure()
print(
f"{sympify(ass.res.point_sum_y, evaluate=False)}\n{sympify(ass.res.point_sum_x, evaluate=False)}\n{ass.res.moments_sum}\n")
from anastruct import SystemElements import random def randgen(lb,ub): return lb - float(float(random.randint(0,100))/100)*(lb-ub) ss = SystemElements() ss.add_element(location=[[0, 0], [0, 3]]) ss.add_element(location=[[0, 3], [3, 3]]) ss.add_element(location=[[3, 3], [3, 0]]) ss.add_element(location=[[0, 3], [0, 6]]) ss.add_element(location=[[0, 6], [3, 6]]) ss.add_element(location=[[3, 6], [3, 3]]) ss.add_support_fixed(node_id=1) ss.add_support_fixed(node_id=4) ss.q_load(element_id=2, q=-10) ss.q_load(element_id=5, q=-10) ss.solve() ss.show_structure() #ss.show_reaction_force() ss.show_bending_moment() print(ss.get_element_results(element_id=1)['length']) print(ss.get_element_results(element_id=1)['Mmin']) print(ss.get_element_results(element_id=1)['Mmax']) print(ss.get_element_results(element_id=2)['length']) print(ss.get_element_results(element_id=2)['Mmin']) print(ss.get_element_results(element_id=2)['Mmax']) #ss = SystemElements() #
def get_diagram():
'''
Recebe um parâmetro numerico que identifica o tipo de diagrama a ser retornado
0 = Estrutural
1 = Forças de reação
2 = Axial
3 = Cortante
4 = Fletor
5 = Displacement ?
Requisita os parâmetros, via json:
apoio1 e apoio2, que são os tipos dos apoios
apoio1pos e apoio2pos, que são as posições dos dois apoios
cargap, que é a posição da carga
cargam, que é o módulo da carga
Tipo dos apoios:
0 = Primeiro gênerio (roll)
1 = Segundo gênero (hinged)
2 = Tercêiro Gênero (fixed)
'''
tipo = int(request.args.get('tipo'))
r = requests.get('https://calculusapi.herokuapp.com/test')
apoio1tipo, apoio2tipo = r.json().get('apoio1'), r.json().get('apoio2')
apoio1pos, apoio2pos = r.json().get('apoio1p'), r.json().get('apoio2p')
cargapos = r.json().get('cargap')
cargamod = r.json().get('cargam')
ss = SystemElements()
#criação da barra
ss.add_element(location=[[0, 0], [3, 0]])
ss.add_element(location=[[3, 0], [8, 0]])
#adição do primeiro apoio
if apoio1tipo == 0:
ss.add_support_roll(node_id=apoio1pos)
elif apoio1tipo == 1:
ss.add_support_hinged(node_id=apoio1pos)
else:
ss.add_support_fixed(node_id=apoio1pos)
#adição do segundo apoio
if apoio2tipo == 0:
ss.add_support_roll(node_id=apoio2pos)
elif apoio2tipo == 1:
ss.add_support_hinged(node_id=apoio2pos)
else:
ss.add_support_fixed(node_id=apoio2pos)
#adição da carga
ss.q_load(element_id=cargapos, q=cargamod)
#geração dos diagramas
ss.solve()
img = io.BytesIO()
if tipo == 0:
ss.show_structure(show=False).savefig(img)
elif tipo == 1:
ss.show_reaction_force(show=False).savefig(img)
elif tipo == 2:
ss.show_axial_force(show=False).savefig(img)
elif tipo == 3:
ss.show_shear_force(show=False).savefig(img)
elif tipo == 4:
ss.show_bending_moment(show=False).savefig(img)
elif tipo == 5:
ss.show_displacement(show=False).savefig(img)
img.seek(0)
return send_file(img, mimetype='image/png')
class connections:
def __init__(self, main_window, main_window_functions):
self.mw = main_window
self.fn = main_window_functions
self.ss = SystemElements()
self.ss.color_scheme = "dark"
self.was_solved = False
self.states = []
def add_beam(self):
try:
self.workaround()
e = self.mw.elementtype.currentIndex()
if self.mw.utilizeinfo.isChecked():
EI = float(self.fn.filter(self.mw.beam_E.text())) * float(
self.fn.filter(self.mw.beam_I.text()))
EA = float(self.fn.filter(self.mw.beam_E.text())) * float(
self.fn.filter(self.mw.beam_A.text()))
element_types = ["beam", "truss"]
self.ss.add_element(location=[
[
float(self.fn.filter(self.mw.beam_x1.text())),
float(self.fn.filter(self.mw.beam_y1.text()))
],
[
float(self.fn.filter(self.mw.beam_x2.text())),
float(self.fn.filter(self.mw.beam_y2.text()))
]
],
EI=EI,
EA=EA,
element_type=element_types[e])
else:
self.ss.add_element(
location=[[
float(self.fn.filter(self.mw.beam_x1.text())),
float(self.fn.filter(self.mw.beam_y1.text()))
],
[
float(self.fn.filter(
self.mw.beam_x2.text())),
float(self.fn.filter(self.mw.beam_y2.text()))
]])
self.visualize_structure()
self.states.append(pickle.dumps(self.ss))
except:
self.fn.warning()
def beam_info(self):
if self.mw.utilizeinfo.isChecked():
self.mw.frame_4.setHidden(False)
else:
self.mw.frame_4.setHidden(True)
def element_type_list(self):
if self.mw.elementtype.currentIndex() == 1:
self.mw.beam_I.setEnabled(False)
elif self.mw.elementtype.currentIndex() == 0:
self.mw.beam_I.setEnabled(True)
def add_node(self):
try:
if int(self.mw.node_id.text()) in self.ss.node_map.keys():
self.workaround()
self.ss.insert_node(element_id=int(self.mw.node_id.text()),
location=[
self.fn.filter(self.mw.node_x.text()),
self.fn.filter(self.mw.node_y.text())
])
self.mw.last_figure.click()
self.states.append(pickle.dumps(self.ss))
else:
self.fn.invalid_id_warning()
except:
self.fn.warning()
def add_support(self):
try:
if int(self.mw.support_pos.text()) in self.ss.node_map.keys():
self.workaround()
if self.mw.support_hinged.isChecked():
self.ss.add_support_hinged(
node_id=int(self.mw.support_pos.text()))
elif self.mw.support_roll.isChecked():
self.ss.add_support_roll(
node_id=int(self.mw.support_pos.text()),
angle=float(
self.fn.filter(self.mw.support_angle.text())))
elif self.mw.support_fixed.isChecked():
self.ss.add_support_fixed(
node_id=int(self.mw.support_pos.text()))
elif self.mw.support_spring.isChecked():
self.ss.add_support_spring(
node_id=int(self.mw.support_pos.text()),
translation=self.mw.spring_translation.text(),
k=self.mw.spring_k.text())
elif self.mw.support_internal_hinge.isChecked():
pass
self.mw.last_figure.click()
self.states.append(pickle.dumps(self.ss))
self.fn.enable_buttons()
else:
self.fn.invalid_id_warning()
except:
self.fn.warning()
def show_support_stuff(self):
if self.mw.support_roll.isChecked():
self.mw.support_angle.setHidden(
True) # Always true due to anaStruct bug
self.mw.label_113.setHidden(
True) # Always true due to anaStruct bug
self.mw.label_27.setHidden(
True) # Always true due to anaStruct bug
self.mw.label_71.setHidden(True)
self.mw.label_73.setHidden(True)
self.mw.spring_k.setHidden(True)
self.mw.spring_translation.setHidden(True)
elif self.mw.support_spring.isChecked():
self.mw.label_71.setHidden(False)
self.mw.label_73.setHidden(False)
self.mw.spring_k.setHidden(False)
self.mw.spring_translation.setHidden(False)
self.mw.support_angle.setHidden(
True) # Always true due to anaStruct bug
self.mw.label_27.setHidden(True)
self.mw.label_127.setHidden(False)
else:
self.mw.support_angle.setHidden(
True) # Always true due to anaStruct bug
self.mw.label_27.setHidden(True)
self.mw.label_71.setHidden(True)
self.mw.label_73.setHidden(True)
self.mw.spring_k.setHidden(True)
self.mw.label_113.setHidden(True)
self.mw.label_127.setHidden(True)
self.mw.spring_translation.setHidden(True)
def add_point_load(self):
try:
if int(self.mw.load_pos.text()) in self.ss.node_map.keys():
self.workaround()
if self.mw.load_moment.text() != '' and float(
self.mw.load_moment.text()) != 0:
self.ss.moment_load(
node_id=int(self.mw.load_pos.text()),
Ty=float(self.fn.filter(self.mw.load_moment.text())))
if float(self.mw.load_y.text()) == 0 and float(
self.mw.load_x.text()) == 0 and float(
self.mw.load_angle.text()) == 0:
pass
elif self.mw.load_y.text() != '' and self.mw.load_x.text(
) != '' and self.mw.load_angle.text() != '':
self.ss.point_load(
node_id=int(self.mw.load_pos.text()),
Fy=float(self.fn.filter(self.mw.load_y.text())),
Fx=float(self.fn.filter(self.mw.load_x.text())),
rotation=float(
self.fn.filter(self.mw.load_angle.text())))
self.mw.last_figure.click()
self.states.append(pickle.dumps(self.ss))
self.fn.enable_buttons()
else:
self.fn.invalid_id_warning()
except:
self.fn.warning()
def add_q_load(self):
try:
if int(self.mw.qload_pos.text()) in self.ss.node_map.keys():
if float(self.mw.qload_initial.text()) >= 0 and float(self.mw.qload_final.text()) >= 0 or \
float(self.mw.qload_initial.text()) <= 0 and float(self.mw.qload_final.text()) <= 0:
self.workaround()
if self.mw.qload_initial.text() == '':
self.mw.qload_final.setText(
self.fn.filter(self.mw.qload_final.text()))
if self.mw.qload_final.text() == '':
self.mw.qload_final.setText(
self.fn.filter(self.mw.qload_initial.text()))
self.ss.q_load(
element_id=int(self.mw.qload_pos.text()),
q=(float(self.fn.filter(self.mw.qload_initial.text())),
float(self.fn.filter(self.mw.qload_final.text()))))
self.mw.last_figure.click()
self.states.append(pickle.dumps(self.ss))
self.fn.enable_buttons()
else:
msg = QMessageBox()
msg.setWindowTitle(self.mw.warning_title)
msg.setText(self.mw.qload_warning)
msg.setIcon(QMessageBox.Warning)
x = msg.exec_()
else:
self.fn.invalid_id_warning()
except:
self.fn.warning()
def visualize_structure(self):
if self.ss.element_map:
self.mw.MplWidget.canvas.figure.clear()
ax = self.mw.MplWidget.canvas.figure.add_subplot(111)
self.fn.visualize(
self.ss.show_structure(show=False,
figure=(self.mw.MplWidget.canvas.figure,
ax)))
ax.patch.set_alpha(0.2)
self.mw.last_figure = self.mw.show_structure
else:
self.mw.MplWidget.plot(has_grid=self.mw.gridBox.isChecked())
self.fn.figurefix()
self.mw.last_figure = None
def visualize_diagram(self):
self.solve()
self.mw.MplWidget.canvas.figure.clear()
ax = self.mw.MplWidget.canvas.figure.add_subplot(111)
ax.patch.set_alpha(0.2)
self.fn.visualize(
self.ss.show_structure(show=False,
free_body_diagram=1,
figure=(self.mw.MplWidget.canvas.figure,
ax)))
self.mw.last_figure = self.mw.show_diagram
def visualize_supports(self):
self.solve()
self.mw.MplWidget.canvas.figure.clear()
ax = self.mw.MplWidget.canvas.figure.add_subplot(111)
ax.patch.set_alpha(0.2)
self.fn.visualize(
self.ss.show_reaction_force(
show=False, figure=(self.mw.MplWidget.canvas.figure, ax)))
self.mw.last_figure = self.mw.show_supports
def visualize_normal(self):
self.solve()
self.mw.MplWidget.canvas.figure.clear()
ax = self.mw.MplWidget.canvas.figure.add_subplot(111)
ax.patch.set_alpha(0.2)
self.fn.visualize(
self.ss.show_axial_force(show=False,
figure=(self.mw.MplWidget.canvas.figure,
ax)))
self.mw.last_figure = self.mw.show_normal
def visualize_shear(self):
self.solve()
self.mw.MplWidget.canvas.figure.clear()
ax = self.mw.MplWidget.canvas.figure.add_subplot(111)
ax.patch.set_alpha(0.2)
self.fn.visualize(
self.ss.show_shear_force(show=False,
figure=(self.mw.MplWidget.canvas.figure,
ax)))
self.mw.last_figure = self.mw.show_shear
def visualize_moment(self):
self.solve()
self.mw.MplWidget.canvas.figure.clear()
ax = self.mw.MplWidget.canvas.figure.add_subplot(111)
ax.patch.set_alpha(0.2)
self.fn.visualize(
self.ss.show_bending_moment(
show=False, figure=(self.mw.MplWidget.canvas.figure, ax)))
self.mw.last_figure = self.mw.show_moment
def visualize_displacement(self):
self.solve()
self.mw.MplWidget.canvas.figure.clear()
ax = self.mw.MplWidget.canvas.figure.add_subplot(111)
ax.patch.set_alpha(0.2)
self.fn.visualize(
self.ss.show_displacement(show=False,
figure=(self.mw.MplWidget.canvas.figure,
ax)))
self.mw.last_figure = self.mw.show_displacement
def solve(self):
self.was_solved = True
self.ss.solve()
def static_solver(self, clean=True):
if find_executable('latex'):
if self.mw.show_moment.isEnabled():
if (len(self.ss.supports_roll) == 1 and len(self.ss.supports_hinged) == 1) \
or (len(self.ss.supports_fixed) == 1):
dialog = QDialog()
prompt = PathPrompt(self.mw.language, dialog)
dialog.exec_()
if not prompt.userTerminated:
solve_path = prompt.path
file, ok = QFileDialog.getSaveFileName(
self.mw, self.mw.pdf_title, self.mw.pdf_text,
"PDF (*.pdf)")
if ok:
try:
self.mw.toolBox.setCurrentIndex(0)
pdf_dir, filename = split_dir_filename(file)
make_pdf_folders(pdf_dir)
self.ss.color_scheme = "bright"
plt.style.use('default')
mn = Manager(self.ss)
pdf_generator_thread = PDFGeneratorThread(
mn.generate_pdf,
self.mw.language,
pdf_path=pdf_dir,
filename=filename,
solve_path=solve_path,
path_warning=self.fn.path_warning,
)
self.fn.setupLoading(pdf_generator_thread)
pdf_generator_thread.finished.connect(
self.on_finished)
pdf_generator_thread.start()
self.mw.loadingScreen.exec_()
if not self.mw.loadingUi.userTerminated:
self.fn.pdf_generated_prompt()
if clean:
delete_folder(pdf_dir)
self.ss.color_scheme = "dark"
plt.style.use('dark_background')
except:
self.fn.latex_packages_warning()
else:
self.fn.static_warning()
else:
self.fn.warning()
else:
self.fn.latex_warning()
def on_finished(self):
self.mw.loadingScreen.close()
def reset_struct_elems(self):
self.ss = SystemElements()
self.ss.color_scheme = "dark"
self.states.clear()
self.mw.MplWidget.plot(has_grid=self.mw.gridBox.isChecked())
self.mw.MplWidget.set_background_alpha()
self.mw.MplWidget.set_subplot_alpha()
self.fn.figurefix()
self.was_solved = False
self.fn.disable_buttons()
def load_structure_aux(self, file):
with open(f'{file}', 'rb') as f:
self.ss, _, _ = pickle.load(f)
self.mw.struct_loaded = True
def workaround(self):
if self.was_solved:
self.ss = pickle.loads(self.states[-1])
self.was_solved = False
def reset(self):
self.workaround()
self.ss.remove_loads()
self.mw.MplWidget.canvas.figure.clear()
ax = self.mw.MplWidget.canvas.figure.add_subplot(111)
ax.patch.set_alpha(0.2)
self.fn.visualize(
self.ss.show_structure(show=False,
figure=(self.mw.MplWidget.canvas.figure,
ax)))
self.states.append(pickle.dumps(self.ss))
self.fn.disable_buttons()
# Add a fixed support at node 1. ss.add_support_fixed(node_id=1) ss.add_support_fixed(node_id=4) #ss.add_support_fixed(node_id=1) # Add a rotational spring support at node 4. #ss.add_support_spring(node_id=4, translation=3, k=4000) # Add loads. #ss.point_load(Fx=, node_id=2) #ss.point_load(Fx=30, node_id=5) #ss.point_load(Fx=30, node_id=7) #ss.point_load(Fx=30, node_id=9) #ss.point_load(Fx=30, node_id=11) # ss.q_load(q=-10, element_id=2) ss.q_load(q=-10, element_id=5) ss.q_load(q=-10, element_id=8) ss.q_load(q=-10, element_id=11) ss.q_load(q=-10, element_id=14) ss.q_load(q=-10, element_id=17) ss.q_load(q=-10, element_id=20) #ss.q_load(q=-10, element_id=4) #print(ss.node_ranges()) ss.point_load(Fx=2.477, node_id=2) ss.point_load(Fx=9.991, node_id=5) ss.point_load(Fx=15.032, node_id=7) ss.point_load(Fx=15.032, node_id=9) ss.point_load(Fx=20.477, node_id=11) ss.point_load(Fx=32.991, node_id=13) ss.point_load(Fx=48.032, node_id=15)
ss = SystemElements()
# Add beams to the system.
ss.add_element(location=[0, 5], EA=15000, EI=5000)
ss.add_element(location=[[0, 5], [5, 5]], EA=15000, EI=5000)
ss.add_element(location=[[5, 5], [5, 0]], EA=15000, EI=5000)
# Add a fixed support at node 1.
ss.add_support_fixed(node_id=1)
# Add a rotational spring support at node 4.
ss.add_support_spring(node_id=4, translation=3, k=4000)
# Add loads.
ss.point_load(Fx=30, node_id=2)
ss.q_load(q=-10, element_id=2)
ss.q_load(q=-10, element_id=1)
#ss.q_load(q=-10, element_id=4)
#print(ss.node_ranges())
# Solve
ss.solve()
#print(ss.get_element_results(element_id=1))
#result = (ss.get_element_results(element_id=0, verbose=False))
##for el_result in result:
## print(el_result['length'])
## print(el_result['Mmin'])
## print(el_result['Mmax'])
for i in range(1, 4):
print("element_id" + str(i))
def accept(self):
try:
E = float(self.form.editE.text()) # N/mm2
I = float(self.form.editI.text()) # mm4
A = float(self.form.editA.text()) # mm2
ss = SystemElements()
frame = FreeCAD.ActiveDocument.getObjectsByLabel(
self.form.comboBox.currentText())[0]
sk = frame.Base
j = 0
# CREATE MEMBERS OF STRUCTURE
for l in sk.Geometry:
sp = [i * 1e-3 for i in list(l.StartPoint)[:2]]
ep = [i * 1e-3 for i in list(l.EndPoint)[:2]]
if self.combotypes[j].currentText() == 'beam':
ss.add_element([sp, ep], EA=E * A * 1e-3, EI=E * I * 1e-9)
elif self.combotypes[j].currentText() == 'brace':
ss.add_truss_element([sp, ep], EA=E * A * 1e-3)
j += 1
# SET DISTRIBUTED LOADS
if self.form.radioFrame.isChecked():
for i in list(range(len(sk.Geometry))):
if self.form.tableDistrib.item(i, 2):
item = self.form.tableDistrib.item(i, 2)
try:
load = float(item.text()) # kN/m
ss.q_load(element_id=(i + 1), q=load)
except:
pass
for c in self.combos:
i = self.combos.index(c) + 1
# SET NODE CONSTRAINTS
if c.currentText() == 'fix': ss.add_support_fixed(node_id=i)
elif c.currentText() == 'hinge':
ss.add_support_hinged(node_id=i)
elif c.currentText() == 'roll':
ss.add_support_roll(node_id=i)
# SET NODE FORCES
if self.form.tableConc.item(
i - 1, 1) or self.form.tableConc.item(i - 1, 2):
itemX = self.form.tableConc.item(i - 1, 1)
try:
loadX = float(itemX.text()) # kN
except:
loadX = 0
itemY = self.form.tableConc.item(i - 1, 2) # kN
try:
loadY = float(itemY.text())
except:
loadY = 0
ss.point_load(node_id=(i), Fx=loadX, Fy=loadY)
# SOLVE AND VALIDATE
ss.solve()
# stable=ss.validate(.0000001)
# SHOW RESULTS ACCORDING THE CALC TYPE
if True: #stable:
if self.form.radioFrame.isChecked():
ss.show_results()
elif self.form.radioTruss.isChecked():
ss.show_axial_force()
else:
FreeCAD.Console.PrintError('The structure is not stable.\n')
except:
FreeCAD.Console.PrintError('Invalid input\n')
for l in self.labNodes + self.labEl:
l.removeLabel()
