def calculate(self, loadProfileFromDB):
'''Se ejecuta el calculo de las propiedades de la seccion.
Referencia
----------
rx, ry : radio de giro del miembro | sqrt(I/A)
c_i : coordenada del centroide de la seccion
sc_i : coordenada del centro de corte
A : Area de la seccion
Cw : Constante torsional de warping de la seccion
J : Constante de torsion de St. Venant
Si : modulo elastico
j : mitad de la constante monociclica a compresion en eje -y- (beta22-)
'''
if loadProfileFromDB:
try:
self.load()
except:
loadProfileFromDB = False
pass
if not loadProfileFromDB:
## CALCULO PROPIEDADES A PARTIR DEL PAQUETE sectionproperties
geometry = sections.CeeSection(d=self.H, b=self.B+self.r_out, l=self.r_out, t=self.t, r_out=self.r_out, n_r=8)
# corto los labios y el radio
p1 = geometry.add_point([self.B, 0])
p2 = geometry.add_point([self.B, self.t])
p3 = geometry.add_point([self.B, self.H])
p4 = geometry.add_point([self.B, self.H-self.t])
geometry.add_facet([p1, p2])
geometry.add_facet([p3, p4])
geometry.add_hole([self.B+self.r_out/10, self.t/2]) # add hole
geometry.add_hole([self.B+self.r_out/10, self.H-self.t/2]) # add hole
geometry.clean_geometry() # clean the geometry
# create mesh
mesh = geometry.create_mesh(mesh_sizes=[self.t/4.0])
# creo la seccion
section = CrossSection(geometry, mesh)
# calculo las propiedades
section.calculate_geometric_properties()
section.calculate_warping_properties()
(self.c_x, self.c_y) = section.get_c() # centroides
(self.sc_x, self.sc_y) = section.get_sc() # shear center
self.Cw = section.get_gamma() # warping
(self.rx, self.ry) = section.get_rc() # radios de giro
self.J = section.get_j()
self.A = section.get_area()
self.Ae = section.get_area()
(self.Ix, self.Iy, _) = section.get_ic()
(self.Sx, _, _, _) = section.get_z() # modulo elastico
self.j = section.get_beta_p()[3]/2.0
self.save(section)
self.section = section
def calculate(self, loadProfileFromDB):
'''Se ejecuta el calculo de las propiedades de la seccion.
Parameters
----------
loadProfileFromDB: bool
indica si se debe intentar cargar el perfil desde la base de datos
Referencia
----------
rx, ry : radio de giro del miembro | sqrt(I/A)
c_i : coordenada del centroide de la seccion
sc_i : coordenada del centro de corte
A : Area de la seccion
Cw : Constante torsional de warping de la seccion
J : Constante de torsion de St. Venant
Si : modulo elastico
j : mitad de la constante monociclica a compresion en eje -y- (beta22-)
'''
if loadProfileFromDB:
try:
self.load()
except:
loadProfileFromDB = False
pass
if not loadProfileFromDB:
## CALCULO PROPIEDADES A PARTIR DEL PAQUETE sectionproperties
geometry = sections.CeeSection(d=self.H, b=self.B, l=self.D, t=self.t, r_out=self.r_out, n_r=8)
# create mesh
mesh = geometry.create_mesh(mesh_sizes=[self.t/4.0])
# creo la seccion
section = CrossSection(geometry, mesh)
# calculo las propiedades
section.calculate_geometric_properties()
section.calculate_warping_properties()
(self.c_x, self.c_y) = section.get_c() # centroides
(self.sc_x, self.sc_y) = section.get_sc() # shear center
self.Cw = section.get_gamma() # warping
(self.rx, self.ry) = section.get_rc() # radios de giro
self.J = section.get_j() # St Venant
self.A = section.get_area()
self.Ae = section.get_area()
(self.Ix, self.Iy, _) = section.get_ic()
(self.Sx, _, _, _) = section.get_z() # modulo elastico
self.j = section.get_beta_p()[3]/2.0
self.save(section)
self.section = section
def calculate(self, loadProfileFromDB):
'''Se ejecuta el calculo de las propiedades de la seccion.
Referencia
----------
rx, ry : radio de giro de la seccion | sqrt(I/A)
ri : radio de giro en -y- de un solo perfil c
c_x, c_y : coordenada del centroide de la seccion
sc_x, sc_y : coordenada del centro de corte
A : Area de la seccion
Cw : Constante torsional de warping de la seccion
J : Constante de torsion de St. Venant
Si : modulo elastico
j : mitad de la constante monociclica a compresion en eje -y- (beta22-)
'''
if loadProfileFromDB:
try:
self.load()
except:
loadProfileFromDB = False
pass
if not loadProfileFromDB:
c0 = c_profile(H= self.H, B= self. B, t= self.t, r_out= self.r_out)
c0.calculate(loadProfileFromDB)
c1 = sections.CeeSection(d=self.H, b=self.B+self.r_out, l=self.r_out, t=self.t, r_out=self.r_out, n_r=8)
c2 = deepcopy(c1)
# corto los labios y el radio c1
p1 = c1.add_point([self.B, 0])
p2 = c1.add_point([self.B, self.t])
p3 = c1.add_point([self.B, self.H])
p4 = c1.add_point([self.B, self.H-self.t])
c1.add_facet([p1, p2])
c1.add_facet([p3, p4])
c1.add_hole([self.B+self.r_out/10, self.t/2]) # add hole
c1.add_hole([self.B+self.r_out/10, self.H-self.t/2]) # add hole
c1.clean_geometry() # clean the geometry
c2 = deepcopy(c1)
c2.mirror_section(axis= 'y', mirror_point=[0, 0])
if self.s:
c1.shift = [self.s/2, 0]
c1.shift_section()
c2.shift = [-self.s/2, 0]
c2.shift_section()
# soldadura en los extremos del alma
if self.wld:
h = self.wld*self.r_out # weld length
a = self.wld*self.r_out*2 + self.s # base de la soldadura
weld1 = sections.CustomSection(
points=[[a/2,0], [-a/2, 0], [0, h]],
facets=[[0,1], [1,2], [2,0]],
holes=[],
control_points=[[h / 3, h / 3]]
)
weld2 = deepcopy(weld1)
weld2.mirror_section(axis= 'x', mirror_point=[0, 0])
weld2.shift = [0, self.H]
weld2.shift_section()
geometry = sections.MergedSection([c1, c2, weld1, weld2])
geometry.clean_geometry(verbose= False)
if self.s:
geometry.add_hole([0, self.H/2])
mesh = geometry.create_mesh(mesh_sizes=[self.mesh_size, self.mesh_size, self.mesh_size, self.mesh_size])
else:
geometry = sections.MergedSection([c1, c2])
geometry.clean_geometry()
mesh = geometry.create_mesh(mesh_sizes=[self.mesh_size, self.mesh_size])
section = CrossSection(geometry, mesh)
#mesh_c1 = c1.create_mesh(mesh_sizes=[self.mesh_size])
#section_c1 = CrossSection(c1, mesh_c1)
#section_c1.calculate_geometric_properties()
#section_c1.calculate_warping_properties()
section.calculate_geometric_properties()
section.calculate_warping_properties()
(self.c_x, self.c_y) = section.get_c() # centroides
(self.sc_x, self.sc_y) = section.get_sc() # shear center
self.Cw = section.get_gamma() # warping
(self.rx, self.ry) = section.get_rc() # radios de giro
self.J = section.get_j()
self.A = section.get_area()
self.Ae = self.A
self.ri = c0.ry # radios de giro y de c1
(self.Ix, self.Iy, _) = section.get_ic()
(self.Sx, _, _, _) = section.get_z() # modulo elastico
self.j = section.get_beta_p()[3]/2.0
self.save(section)
self.section = section
def process_geometry(geometry, mesh_sizes, loadcases):
# update this to receive the geometry, mesh info, material and loads
# generate a finite element mesh
mesh = geometry.create_mesh(mesh_sizes=mesh_sizes)
# generate material - can be overwritten if needed --all in N and cm
# create a CrossSection object for analysis
section = CrossSection(geometry, mesh)
# calculate various cross-section properties
section.calculate_geometric_properties()
section.calculate_warping_properties()
section.calculate_plastic_properties()
# Area
area = section.get_area()
sheararea = section.get_As()
asx = sheararea[0]
asy = sheararea[1]
# Second Moment of Area about centroid
(ixx, iyy, ixy) = section.get_ic()
# Centroid
(xg, yg) = section.get_c()
# Radii of Gyration
(rxx, ryy) = section.get_rc()
# Principal bending axis angle
phi = section.get_phi()
# St. Venant torsion constant
ipp = section.get_j()
# Warping Constant
cw = section.get_gamma()
# Elastic Section Moduli
(welx_top, welx_bottom, wely_top, wely_bottom) = section.get_z()
# Plastic Section Moduli
(wplx, wply) = section.get_s()
# plot centroid to image
section.plot_centroids(pause=False)
buf = io.BytesIO()
plt.savefig(buf, format='png', bbox_inches='tight')
buf.seek(0)
plot_centroid = base64.b64encode(buf.getvalue()).decode()
plt.close()
# calculate torsion resistance from stress and torque
#from the below can also return torsional stress if wanted
stress_post = section.calculate_stress(Mzz=10)
unit_mzz_zxy = []
maxstress = []
for group in stress_post.material_groups:
maxstress.append(max(group.stress_result.sig_zxy_mzz))
unit_mzz_zxy.append(group.stress_result.sig_zxy_mzz.tolist())
#there should be only one maxstress value therefore:
wt = 10 / maxstress[0]
#plot this image
stress_post.plot_stress_mzz_zxy(pause=False)
buf = io.BytesIO()
plt.savefig(buf, format='png', bbox_inches='tight')
buf.seek(0)
plot_unittorsionstress = base64.b64encode(buf.getvalue()).decode()
plt.close()
#foreach load case submitted calculate vm stress state and create image
vmStressImages = {}
vmStressStates = {}
for loadcase in loadcases:
lc_name = loadcase[0]
s_n = loadcase[1]
s_vx = loadcase[2]
s_vy = loadcase[3]
s_mxx = loadcase[4]
s_myy = loadcase[5]
s_mzz = loadcase[6]
stress_post = section.calculate_stress(N=s_n,
Vx=s_vx,
Vy=s_vy,
Mxx=s_mxx,
Myy=s_myy,
Mzz=s_mzz)
stress_state = []
for group in stress_post.material_groups:
stress_state.append(group.stress_result.sig_vm.tolist())
vmStressStates['lc_' + str(lc_name) + '_vm_stress'] = stress_state
#plot this image
stress_post.plot_stress_vm(pause=False)
buf = io.BytesIO()
plt.savefig(buf, format='png', bbox_inches='tight')
buf.seek(0)
vmStressImages['lc_' + str(lc_name) + '_vm_stress'] = base64.b64encode(
buf.getvalue()).decode()
plt.close()
# create rhino mesh
rmesh = rhino_mesh_from_meshpy(mesh)
# return send_file(path, as_attachment=True)
# get some of the calculated section properties
return_data = {}
return_data['properties'] = {
'area': area,
'Avx': asx,
'Avy': asy,
'xg': xg,
'yg': yg,
'rxx': rxx,
'ryy': ryy,
'phi': phi,
'ixx': ixx,
'iyy': iyy,
'ipp': ipp,
'cw': cw,
'welx+': welx_top,
'welx-': welx_bottom,
'wely+': wely_top,
'wely-': wely_bottom,
'wplx': wplx,
'wply': wply,
'wt': wt,
}
return_data['geometry'] = {
'mesh': rhino.CommonObject.Encode(rmesh),
}
return_data['images'] = {
'centroids': plot_centroid,
'unittorsion_vxy_stress': plot_unittorsionstress,
}
return_data['images'].update(vmStressImages)
return_data['stress_results'] = {
'unittorsion_vxy_stress': unit_mzz_zxy,
}
return_data['stress_results'].update(vmStressStates)
return return_data