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 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_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 __init__(self,
x,
y,
connections,
loads,
supports,
density=880,
unit='m',
width=0.95 / 100,
thick=1.8 / 1000,
pop_compressive_strength=18100,
pop_tensile_strength=70000):
pop_cross_area = width * thick
pop_mpl = pop_cross_area * density
g = pop_mpl * 9.81 / 1000
unit_conv = 1
if (unit == 'cm'):
unit_conv = (1 / 100)
nodes = [[x[i] * unit_conv, y[i] * unit_conv] for i in range(len(x))]
ss = SystemElements(EA=pop_cross_area * 8600000)
for node1, node2 in connections:
ss.add_element([nodes[node1], nodes[node2]],
element_type='truss',
g=g)
for node in supports:
id = ss.find_node_id(nodes[node])
ss.add_support_fixed(id)
for node, load in loads:
id = ss.find_node_id(nodes[node])
ss.point_load(id, Fy=-9.81 * load / 1000)
ss.solve()
self.ss = ss
self.nodes = nodes
self.connections = connections
self.loads = loads
self.supports = supports
self.pop_mpl = pop_mpl
self.cross_area = pop_cross_area
self.compress = pop_compressive_strength
self.tensile = pop_tensile_strength
ss.add_element(location=[[10.5, 1.2], [10.5, 0.7]]) #36 ss.add_element(location=[[9.9, 1.5], [10.5, 0.7]]) #37 ss.add_element(location=[[10.5, 0.7], [11, 1.1]]) #38 ss.add_element(location=[[10.5, 1.2], [11, 1.1]]) #39 ss.add_element(location=[[9.9, 2.6], [11, 1.1]]) #40 ss.add_element(location=[[10.5, 0.7], [11.5, 0]]) #41 ss.add_element(location=[[11, 1.1], [11.5, 0]]) #supports and loads ss.add_support_fixed(node_id=[1]) ss.point_load(10, Fx=10, rotation=90) ss.add_support_fixed(node_id=ss.id_last_node) #ss.q_load(q=-20, element_id=23, direction='element') #ss.q_load(q=-20, element_id=16, direction='element') #ss.q_load(q=-20, element_id=13, direction='element') #ss.q_load(q=-20, element_id=28, direction='element') ss.show_structure() ss.solve() #ss.show_bending_moment() ss.show_displacement() #ss.show_reaction_force() #ss.show_shear_force() plt.gca() line = ax.lines[0] line.get_xydata()
import random
def randgen(lb, ub):
return lb - float(float(random.randint(0, 100)) / 100) * (lb - ub)
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))
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()
from anastruct import SystemElements import math width = 15 height = 4 ss = SystemElements(EA=15000, EI=5000) ss.add_truss_element(location=[[0, 0], [0, height]]) ss.add_truss_element(location=[[0, 0], [width, 0]]) ss.add_truss_element(location=[[0, 4], [width, height]]) ss.add_truss_element(location=[[width, height], [width, 0]]) ss.add_truss_element(location=[[0, height], [width/4, 0]]) ss.add_truss_element(location=[[width/4*2, height], [width/4, 0]]) ss.add_truss_element(location=[[width/4*2, height], [width/4*3, 0]]) ss.add_truss_element(location=[[width, height], [width/4*3, 0]]) ss.add_support_fixed(node_id=ss.find_node_id(vertex=[0, 0])) ss.add_support_fixed(node_id=ss.find_node_id(vertex=[15, 0])) ss.point_load(Fy=-300, node_id=ss.find_node_id(vertex=[width/2, height])) ss.solve() # Get visual results. ss.show_structure() # ss.show_reaction_force() # ss.show_axial_force() # ss.show_shear_force() # ss.show_bending_moment() # ss.show_displacement()
def initializeLatticeShell(startPoint,
latticeParam,
xHexagons,
yHexagons,
force=10,
theta=0,
elasticModulus=17000000000,
moment=5000000,
area=0.0005,
g=0,
invertHex=True,
saveDir=None):
'''
This function takes in initial parameters for a hexagon lattice, creates
a mesh structure using the anaStruct library object SystemElements(). First,
the center points of hexagons in the lattice will be generated, the hexagon
vertices will be saved in a custom NumPy array to save the center points and
al 6 vertices.
The numpy array will hold 7 tuples( 1 tuple for the center-point, 6 tuples for
coordinates of each hexagon vertex. )
Args:
(startPoint):
(tuple): Tuple of dtype=np.float64 or dtype=np.float32 housing the
original start point (bottom left) of the hexagon lattice to be constructed.
(latticeParam):
(float): The length of each 'sub triangle' length starting from the center
of the hexagon to each vertex.
(xHexagons):
(int): Number of hexagons to be constructed in the x-direction in the lattice.
(yHexagons):
(int): Number of hexagons to be constructed in the y-direction in the lattice.
Returns:
(lattice):
(SystemElements() Object): The system elements object containing all trusses
defined and fully constrained.
(lattice_coordinatews):
(numpy array): Custom numpy array of shape=( xHexagons, yHexagons, 7, 2 ).
Contains 7 coordinates per hexagon: Center coords, and vertex coordinates.
'''
# Initialize finite element material parameters
EA = elasticModulus * area
EI = elasticModulus * moment
# Initialize timer
start = timeit.default_timer()
# Initialize anaStruct.py SystemElements() object...
# ss = SystemElements(figsize=(12,8), EA=15000.0, EI=5e3)
ss = SystemElements(EA=EA, EI=EI)
'''
EA - Standard axial stiffness of element
EI - Standard bending stiffness of elements
figsize - Matplotlibs standard figure size (inches)
'''
# Initialize custom numpy array...
lattice_coordinates = np.empty(shape=(xHexagons + 1, yHexagons, 7, 2))
# Take not of all elements that are already saved so we don't repeat them
# Save initialized system elements points as an array to be referenfced when
# creating new system elements to the FEM mesh.
old_ss = []
# Initialize hexagon lattice centers:
lattice_centers = getHexagonLatticeCenters(startPoint,
latticeParam,
xHexagons,
yHexagons,
invertHex=invertHex)
print(lattice_centers)
# Iterate through each hexagon center and fill lattice_coordinates numpy array
for j in range(yHexagons):
# Every odd numbered row (0 start counting) will have 1 extra hexagon to be drawn in.
if j % 2 != 0:
xHexagonCount = xHexagons + 1
else:
xHexagonCount = xHexagons
for i in range(xHexagonCount):
# Get hexagon points
curr_hexPoints = hexagonPoints(lattice_centers[i, j],
latticeParam,
invertHex=invertHex)
# Initialize start point
lattice_coordinates[i, j, 0] = lattice_centers[i, j]
lattice_coordinates[i, j, 1:] = curr_hexPoints
# Iterating through first hexagon being drawn
if i == 0:
# For even values:
if j % 2 != 0:
# Finds the point pair list of the right half of the hexagon
point_pair_list = [
(curr_hexPoints[1], curr_hexPoints[0]),
(curr_hexPoints[0], curr_hexPoints[5]),
(curr_hexPoints[5], curr_hexPoints[4]),
]
for k in range(3):
# Check if current element is already added
is_added, index = checkSystemElement(
point_pair_list[k][0], point_pair_list[k][1],
old_ss)
# Check if element exists
if is_added == False:
ss.add_element(location=[
point_pair_list[k][0], point_pair_list[k][1]
],
EA=EA,
EI=EI,
g=g)
old_ss.append(
(point_pair_list[k][0], point_pair_list[k][1]))
else:
print(
"Point Pair {} has already been added at index {} of old_ss list."
.format(curr_point_pair, index))
else:
# Iterate through all point pairs:
for k in range(6):
curr_point_pair = (curr_hexPoints[k - 1],
curr_hexPoints[k])
is_added, index = checkSystemElement(
curr_point_pair[0], curr_point_pair[1], old_ss)
# If element doesn't already exist, add it to the mesh
if is_added == False:
ss.add_element(location=[
curr_hexPoints[k - 1], curr_hexPoints[k]
],
EA=EA,
EI=EI,
g=g)
old_ss.append(
(curr_hexPoints[k - 1], curr_hexPoints[k]))
else:
# save elements added
# old_ss.append( curr_hexPoints[k-1], curr_hexPoints[k] )
# testing line --------------------
print(
"Point Pair {} has already been added at index {} of old_ss list."
.format(curr_point_pair, index))
# end testing line ------------------
elif j % 2 != 0 and i == xHexagons:
# Uneven row numbers
if j % 2 != 0:
# Finds the point pair list of the right half of the hexagon
point_pair_list = [
(curr_hexPoints[1], curr_hexPoints[2]),
(curr_hexPoints[2], curr_hexPoints[3]),
(curr_hexPoints[3], curr_hexPoints[4]),
]
for k in range(3):
# Check if current element is already added
is_added, index = checkSystemElement(
point_pair_list[k][0], point_pair_list[k][1],
old_ss)
# Check if element exists
if is_added == False:
ss.add_element(location=[
point_pair_list[k][0], point_pair_list[k][1]
],
EA=EA,
EI=EI,
g=g)
old_ss.append(
(point_pair_list[k][0], point_pair_list[k][1]))
else:
print(
"Point Pair {} has already been added at index {} of old_ss list."
.format(curr_point_pair, index))
# Even hexagon values:
else:
for k in range(6):
# check if current element is already added...if not, add it!
curr_point_pair = (curr_hexPoints[k - 1],
curr_hexPoints[k])
is_added, index = checkSystemElement(
curr_point_pair[0], curr_point_pair[1], old_ss)
# If element doesn't already exist, add it to the mesh
if is_added == False:
ss.add_element(location=[
curr_hexPoints[k - 1], curr_hexPoints[k]
],
EA=EA,
EI=EI,
g=g)
old_ss.append(
(curr_hexPoints[k - 1], curr_hexPoints[k]))
else:
# save elements added
# old_ss.append( curr_hexPoints[k-1], curr_hexPoints[k] )
# testing line --------------------
print(
"Point Pair {} has already been added at index {} of old_ss list."
.format(curr_point_pair, index))
# end testing line ------------------
# add all system elements and save point pairs
else:
for k in range(6):
# check if current element is already added...if not, add it!
curr_point_pair = (curr_hexPoints[k - 1],
curr_hexPoints[k])
is_added, index = checkSystemElement(
curr_point_pair[0], curr_point_pair[1], old_ss)
# If element doesn't already exist, add it to the mesh
if is_added == False:
ss.add_element(location=[
curr_hexPoints[k - 1], curr_hexPoints[k]
],
EA=EA,
EI=EI,
g=g)
old_ss.append(
(curr_hexPoints[k - 1], curr_hexPoints[k]))
else:
# save elements added
# old_ss.append( curr_hexPoints[k-1], curr_hexPoints[k] )
# testing line --------------------
print(
"Point Pair {} has already been added at index {} of old_ss list."
.format(curr_point_pair, index))
# end testing line ------------------
end = timeit.default_timer()
total_time = np.round((end - start), 2)
print(
"\n\nGenerating hexagon mesh of x-y dimensions, {}-{}, lattice parameter, {}, took {} seconds.\n\n"
.format(xHexagons, yHexagons, latticeParam, total_time))
lowest_nodes = findLowestNodes(ss, startPoint, latticeParam, xHexagons,
yHexagons)
highest_nodes = findHighestNodes(ss, startPoint, latticeParam, xHexagons,
yHexagons)
# add supports and flattening elements
for i in range(len(lowest_nodes)):
ss.add_element(location=[lowest_nodes[i - 1][1], lowest_nodes[i][1]])
old_ss.append((lowest_nodes[i - 1], lowest_nodes[i]))
# add fixed support on lowest nodes...
ss.add_support_fixed(node_id=lowest_nodes[i][0])
# add forces and node locations
for i in range(len(highest_nodes)):
ss.add_element(location=[highest_nodes[i - 1][1], highest_nodes[i][1]])
old_ss.append((highest_nodes[i - 1], highest_nodes[i]))
# add forces at highest nodes...
# ss.q_load(q=-1, element_id=highest_nodes[i], direction='element')
ss.point_load(node_id=highest_nodes[i][0],
Fx=0,
Fy=force,
rotation=theta)
# Solve and time it
solveTimeStart = np.round(timeit.default_timer(), 2)
ss.solve()
solveTimeEnd = np.round(timeit.default_timer(), 2)
total_solve_time = solveTimeEnd - solveTimeStart
print(
"\n\nSolving beam element model of x-y dimensions, {}-{}, lattice parameter, {}, took {} seconds.\n\n"
.format(xHexagons, yHexagons, latticeParam, total_solve_time))
# Calculate average displacement of nodes
totalDisplacement = 0
displacements = ss.get_node_displacements(node_id=0)
for i in range(len(displacements)):
totalDisplacement += np.sqrt(displacements[i][1]**2 +
displacements[i][2]**2)
averageDisplacements = totalDisplacement / len(displacements)
print("\n\nAverage Node Displacement: {}mm".format(averageDisplacements *
1000))
if saveDir != None:
diagnosticData = []
diagnosticData.append(
"Hexagon Lattice ({}-x-hexagons,{}-y-hexagons)\n".format(
xHexagons, yHexagons))
diagnosticData.append("Lattice Parameter: {}mm\n".format(latticeParam))
diagnosticData.append("Force: {}N\n".format(force))
diagnosticData.append("Elastic Modulus: {}MPa\n".format(
elasticModulus / 1000))
diagnosticData.append("Second Moment of Area: {}\n".format(moment))
diagnosticData.append("Area: {}mm\n".format(area * 1000))
diagnosticData.append("Bending Stiffness: {}\n".format(elasticModulus *
moment))
diagnosticData.append(
"Average Displacement: {}mm\n".format(averageDisplacements))
diagnosticData.append("Mesh Generated in {}s\n".format(total_time))
diagnosticData.append(
"Beam Element Model Solved in {}s\n".format(total_solve_time))
folderDir = snr.createFolder(
saveDir,
"a={}mm A={}mm f={}N E={}MPa".format(latticeParam, area, force,
elasticModulus / 1000))
textFile = open("{}\\diagnostics.txt".format(folderDir), 'w')
textFile.writelines(diagnosticData)
textFile.close()
# beam element model is solved in the call of this function.
saveElementModel(
ss, folderDir,
"a={}mm A={}mm f={}N E={}MPa".format(latticeParam, area, force,
elasticModulus / 1000))
return ss
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)
# j = i+1
# for j in range(len(point_list)+1):
# for element in element_list:
# inicial = element.incidences_i
# final = element.incidences_f
# if i == int(inicial.name) and j == int(final.name):
# ss.add_element(location=[[inicial.x,inicial.y], [final.x, final.y]])
for i in point_list:
ponto = ss.find_node_id([i.x, i.y])
if i.x_fixed == True and i.y_fixed == False:
ss.add_support_roll(node_id=ponto, direction=1)
elif i.x_fixed == False and i.y_fixed == True:
ss.add_support_roll(node_id=ponto, direction=2)
elif i.x_fixed == True and i.y_fixed == True:
ss.add_support_fixed(node_id=ponto)
for i in load_list:
ponto = ss.find_node_id(
[point_list[int(i.point)-1].x, point_list[int(i.point)-1].y])
ss.point_load(node_id=ponto, Fx=int(
i.intensity_x), Fy=int(i.intensity_y))
ss.show_structure()
ss.solve()
ss.show_displacement()
# point_list, element_list, load_list = calc(point_list, element_list, load_list)
point_list, element_list, load_list = calc(
point_list, element_list, load_list, args.m, args.ite)
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')
ss.add_element([nodes[6],nodes_mid[5]], element_type='truss', g=g)
ss.add_element([nodes[6],nodes_mid[6]], element_type='truss', g=g)
ss.add_element([nodes[7],nodes_mid[6]], element_type='truss', g=g)
ss.add_element([nodes[7],nodes_mid[7]], element_type='truss', g=g)
ss.add_element([nodes[8],nodes_mid[7]], element_type='truss', g=g)
ss.add_element([nodes[8],nodes_mid[8]], element_type='truss', g=g)
ss.add_element([nodes[9],nodes_mid[8]], element_type='truss', g=g)
#vertical beams at midpoints of triangles
ss.add_element([nodes_mid[9],nodes_mid[4]], element_type='truss', g=g)
ss.add_element([nodes[4],nodes[13]], element_type='truss', g=g)
ss.add_element([nodes[5],nodes[14]], element_type='truss', g=g)
for node in supports:
id = ss.find_node_id(nodes[node])
ss.add_support_fixed(id)
loads = [(4,9),(5,9)]
for node, load in loads:
id = ss.find_node_id(nodes_mid[node])
ss.point_load(id, Fy=-9.81*load/1000)
ss.solve()
def test(verbose=False):
arr = ss.get_element_results()
forces = [x['N'] for x in arr]
if (verbose):
print("Difference between maximum tens. pressure and tensile strength: {}".format(max(forces)/pop_cross_area - pop_tensile_strength))
print("Difference between maximum comp. pressure and compressive strength: {}".format(-1*min(forces)/pop_cross_area - pop_compressive_strength))
def initializeLatticeShell(startPoint,
latticeParam,
xHexagons,
yHexagons,
force,
theta=0,
EA=15000,
EI=5000,
g=0,
flushBottomTop=True):
'''
This function takes in initial parameters for a hexagon lattice, creates
a mesh structure using the anaStruct library object SystemElements(). First,
the center points of hexagons in the lattice will be generated, the hexagon
vertices will be saved in a custom NumPy array to save the center points and
al 6 vertices.
The numpy array will hold 7 tuples( 1 tuple for the center-point, 6 tuples for
coordinates of each hexagon vertex. )
Args:
(startPoint):
(tuple): Tuple of dtype=np.float64 or dtype=np.float32 housing the
original start point (bottom left) of the hexagon lattice to be constructed.
(latticeParam):
(float): The length of each 'sub triangle' length starting from the center
of the hexagon to each vertex.
(xHexagons):
(int): Number of hexagons to be constructed in the x-direction in the lattice.
(yHexagons):
(int): Number of hexagons to be constructed in the y-direction in the lattice.
Returns:
(lattice):
(SystemElements() Object): The system elements object containing all trusses
defined and fully constrained.
(lattice_coordinatews):
(numpy array): Custom numpy array of shape=( xHexagons, yHexagons, 7, 2 ).
Contains 7 coordinates per hexagon: Center coords, and vertex coordinates.
'''
# Initialize timer
start = timeit.default_timer()
# Initialize anaStruct.py SystemElements() object...
# ss = SystemElements(figsize=(12,8), EA=15000.0, EI=5e3)
ss = SystemElements(EA=EA, EI=EI)
'''
EA - Standard axial stiffness of element
EI - Standard bending stiffness of elements
figsize - Matplotlibs standard figure size (inches)
'''
# Initialize custom numpy array...
lattice_coordinates = np.empty(shape=(xHexagons, yHexagons, 7, 2))
# Take not of all elements that are already saved so we don't repeat them
# Save initialized system elements points as an array to be referenfced when
# creating new system elements to the FEM mesh.
old_ss = []
# Initialize hexagon lattice centers:
lattice_centers = getHexagonLatticeCenters(startPoint, latticeParam,
xHexagons, yHexagons)
print(lattice_centers)
# Iterate through each hexagon center and fill lattice_coordinates numpy array
for i in range(yHexagons):
for j in range(xHexagons):
# Get hexagon points
curr_hexPoints = hexagonPoints(lattice_centers[i, j], latticeParam)
# Initialize start point
lattice_coordinates[i, j, 0] = lattice_centers[i, j]
lattice_coordinates[i, j, 1:] = curr_hexPoints
# add all system elements and save point pairs
for k in range(6):
# check if current element is already added...if not, add it!
curr_point_pair = (curr_hexPoints[k - 1], curr_hexPoints[k])
is_added, index = checkSystemElement(curr_point_pair[0],
curr_point_pair[1],
old_ss)
# If element doesn't already exist, add it to the mesh
if is_added == False:
ss.add_element(
location=[curr_hexPoints[k - 1], curr_hexPoints[k]],
EA=EA,
EI=EI,
g=g)
old_ss.append((curr_hexPoints[k - 1], curr_hexPoints[k]))
else:
# save elements added
# old_ss.append( curr_hexPoints[k-1], curr_hexPoints[k] )
# testing line --------------------
print(
"Point Pair {} has already been added at index {} of old_ss list."
.format(curr_point_pair, index))
# end testing line ------------------
end = timeit.default_timer()
total_time = np.round((end - start), 2)
print(
"\n\nGenerating hexagon mesh of x-y dimensions, {}-{}, lattice parameter, {}, took {} seconds.\n\n"
.format(xHexagons, yHexagons, latticeParam, total_time))
lowest_nodes = findLowestNodes(ss, startPoint, latticeParam, xHexagons,
yHexagons)
highest_nodes = findHighestNodes(ss, startPoint, latticeParam, xHexagons,
yHexagons)
# add supports here...
for i in range(len(lowest_nodes)):
# add fixed support on lowest nodes...
ss.add_support_fixed(node_id=lowest_nodes[i])
# add forces here...
for i in range(len(highest_nodes)):
# add forces at highest nodes...
# ss.q_load(q=-1, element_id=highest_nodes[i], direction='element')
ss.point_load(node_id=highest_nodes[i], Fx=0, Fy=force, rotation=theta)
return ss
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()
