• Author / Uploaded
• Alex Huaraca Yuyali

Citation preview

9. ANEXOS Implemetacion del codigo del programa elaborado # -*- coding: utf-8 -*""" Created on Sat Jun 8 06:13:12 2019 @author: PROFESIONAL """ import sys from PyQt5 import uic, QtWidgets from scipy.io import wavfile from sympy.printing.python import python from sympy import Integral from sympy.abc import x,y,z from sympy import symbols, var import numpy as np import sympy as sp from sympy import integrate, latex,Heaviside,sin,cos,tan,exp,ln,pi,solve,zoo from sympy import MatrixSymbol, Inverse,ZeroMatrix,MatMul,MatAdd,eye,Matrix import matplotlib.pyplot as plt import sympy as simbol from PyQt5.QtWidgets import (QApplication, QGraphicsItem, QGraphicsObject, QGraphicsProxyWidget, QGraphicsRotation, QGraphicsScene, QGraphicsView, QKeyEventTransition, QWidget,QToolButton) from PyQt5.QtCore import (pyqtProperty, QDirIterator, QEasingCurve, QEvent, QEventTransition, QHistoryState, QParallelAnimationGroup, QPointF, QPropertyAnimation, QRectF, QSequentialAnimationGroup, QState, QStateMachine, Qt)

from PyQt5 import uic, QtWidgets, QtSql, QtGui from PyQt5.uic import loadUi import pyqtgraph as pg from PyQt5.QtSql import * import tkinter as tk from tkinter import ttk from tkinter import messagebox as mb #from pyqtgraph.Qt import QtCore, QtGui #from pyqtgraph import Point, ROI from PyQt5.QtCore import (pyqtSignal, QLineF, QRect, QSize, QSizeF)

from numpy import asarray #pg.mkQApp() import matplotlib.pyplot as plt import numpy as np from scipy import linalg

from PyQt5.QtCore import (QFile, QFileInfo, QPoint, QSettings,Qt, QTextStream) from PyQt5.QtGui import QIcon, QKeySequence from PyQt5.QtWidgets import (QAction, QDialog, QFileDialog, QMainWindow, QMessageBox, QTextEdit, QDockWidget,QListWidget)

class MyApp(): def analizar_estructura (apoyos,matriz_de_nodos,matrix_de_conexiones,matriz_de_cargas,matriz_de_fuerzas,matriz_de_mom entos): global lista_de_ecuaciones global reaciones_globales,num_nodos,MN r,L,l,H,p,a=symbols('r,L,l,H,p,a',positive=True) E,I,A=symbols('E,I,A',positive=True) # # # # # # # # #

apoyos=[[1,'empotrado'],[3,'empotrado'],[2,'fijo']] # sinatxis [nodo,typo] matriz_de_nodos=[[0,0],[l,0],[2*l,0]] #sintaxis [[coordx,coordy],[...]] matrix_de_conexiones=[[1,2,1,1,1],[2,3,1,1,1]] #[nodo_inicial,nodo_final,A,E,I] matriz_de_cargas=0 matriz_de_fuerzas=[[l/2,300,90,1]] #sintaxis [dist,magnitud,angulo,elemento] matriz_de_momentos=0 #sintaxis [dist,magnitud,elemento] matriz_de_nodos=Matrix(matriz_de_nodos) dim_conect=np.size(matrix_de_conexiones,0) nuevo_conect=Matrix(np.zeros((dim_conect,8))) LRMEP=[] for i in range(dim_conect): nuevo_conect[i,0]=matrix_de_conexiones[i][0] nuevo_conect[i,1]=matrix_de_conexiones[i][1] ni=int(matrix_de_conexiones[i][0]-1);nf=int(matrix_de_conexiones[i][1]-1); dx=matriz_de_nodos[nf,0]-matriz_de_nodos[ni,0];dy=matriz_de_nodos[nf,1]-

matriz_de_nodos[ni,1] long=(dx**2+dy**2)**0.5 nuevo_conect[i,2]=long nuevo_conect[i,3]=dy/long nuevo_conect[i,4]=dx/long nuevo_conect[i,5]=matrix_de_conexiones[i][2] nuevo_conect[i,6]=matrix_de_conexiones[i][3] nuevo_conect[i,7]=matrix_de_conexiones[i][4] rig=[0,[],[],[],0,0,0] LRMEP+=[rig]

MN=matriz_de_nodos MC=nuevo_conect #

lista_elemento=[]

# #

print("Analizando la estructural") try:

#

# # # # # #

num_elemet=dim_conect num_nodos=np.size(MN,0) LMEP=[] P=[] GLL_global=[] for k in range(num_nodos): GLL_global+=[int((k+1)*3-2),int((k+1)*3-1),int((k+1)*3)] P+=[[[],[],[]]] #print('lista vacia de añad node: ',P) numeros_a_evaluar=[] for k in range(num_elemet): numeros_a_evaluar+=[[]] dash=[[],[],[]] LMEP+=[dash] lista_elemento+=['elemento '+str(k+1)+' de nodo '+str(int(MC[k,0]))+' a '+str(int(MC[k,1]))] GLR_global=[]

for i in range(np.size(apoyos,0)): if apoyos[i][1]=='Apoyo Movil': GLR_global+=[apoyos[i][0]*3-1] elif apoyos[i][1]=='Apoyo Fijo': GLR_global+=[apoyos[i][0]*3-2,apoyos[i][0]*3-1] else: GLR_global+=[apoyos[i][0]*3-2,apoyos[i][0]*3-1,apoyos[i][0]*3]

glr=np.sort(GLR_global)

# # # # #

#

gll=np.setxor1d(GLL_global,GLR_global) gll=np.sort(gll) print('') print("grados de libertad Restringidos") print(glr) print("grados de libertad Libres") print(gll) LRMEP_local_global=[] matriz_de_fuerzas, matriz_de_momentos, matriz_de_cargas if matriz_de_fuerzas==0: pass else: for i in range(np.size(matriz_de_fuerzas,0)): fuerza=[matriz_de_fuerzas[i][0],matriz_de_fuerzas[i][1],matriz_de_fuerzas[i][2]] LRMEP[int(matriz_de_fuerzas[i][3]-1)][2]+=[fuerza] if matriz_de_momentos==0: pass else: for i in range(np.size(matriz_de_momentos,0)): moment=[matriz_de_momentos[i][0],matriz_de_momentos[i][1]] LRMEP[int(matriz_de_momentos[i][2]-1)][3]+=[moment]

# # #

#

if matriz_de_cargas==0: pass else: for i in range(np.size( matriz_de_cargas,0)): carg=[ matriz_de_cargas[i][0], matriz_de_cargas[i][1], matriz_de_cargas[i][2]] LRMEP[int(matriz_de_cargas[i][3]-1)][1]+=[carg] print('') print('lista acomulada de los MEPs') print(LMEP) lista_elementos_RLL=[] lista_elementos_RLG=[] lista_elementos_RG=[] lista_de_transf=[] #rigidez_global=np.zeros((num_nodos*3,num_nodos*3)) suma_RG=Matrix(np.zeros((num_nodos*3,num_nodos*3))) LRMEPF=[] for inc in range(num_elemet): print("analizando elemento: ",inc+1) n=MC[inc,3] u=MC[inc,4] A=MC[inc,5]*MC[inc,6]/MC[inc,2] B=2*MC[inc,7]*MC[inc,6]/MC[inc,2] C=6*MC[inc,7]*MC[inc,6]/MC[inc,2]**2 D=12*MC[inc,7]*MC[inc,6]/MC[inc,2]**3

lista_elementos_RLL+=[Matrix([ [A,0,0,-A,0,0],

[0,D,C,0,-D,C], [0,C,2*B,0,-C,B], [-A,0,0,A,0,0], [0,-D,-C,0,D,-C], [0,C,B,0,-C,2*B]])] lista_de_transf+=[Matrix([[u,n,0,0,0,0], [-n,u,0,0,0,0], [0,0,1,0,0,0], [0,0,0,u,n,0], [0,0,0,-n,u,0], [0,0,0,0,0,1]])] inv_T=Inverse(lista_de_transf[inc]) factor_2=lista_elementos_RLL[inc] T=lista_de_transf[inc] prod=inv_T*factor_2*T lista_elementos_RLG+=[prod]

ni=MC[inc,0] nf=MC[inc,1]

#

glg=[3*ni-2,3*ni-1,3*ni,3*nf-2,3*nf-1,3*nf] print("grados de libertad: ", glg) RG=MyApp.matriz_ensab(Matrix(np.zeros((num_nodos*3,num_nodos*3))),prod,glg) lista_elementos_RG+=[RG] suma_RG=Matrix(RG)+suma_RG

#

print(MC[inc,2],LRMEP[inc][1],LRMEP[inc][2],LRMEP[inc][3],MC[inc,6],MC[inc,7],MC[inc,5]) res=MyApp.vigas(MC[inc,2],LRMEP[inc][1],LRMEP[inc][2],LRMEP[inc][3],MC[inc,6],MC [inc,7],MC[inc,5]) # print("los MEP son: ",res) LRMEPF+=[res] res_l_g=MyApp.transpuesta(T)*Matrix(res) LRMEP_local_global+=[res_l_g]

#

suma_n=res_l_g[0,0];suma_n_j=res_l_g[3,0] suma_v=res_l_g[1,0];suma_v_j=res_l_g[4,0] suma_m=res_l_g[2,0];suma_m_j=res_l_g[5,0] P[ni-1][0]+=[suma_n ] P[ni-1][1]+=[suma_v ] P[ni-1][2]+=[suma_m ] LRMEP P[nf-1][0]+=[suma_n_j ] P[nf-1][1]+=[suma_v_j ] P[nf-1][2]+=[suma_m_j ] print("P: ",P) FP=[] for k in range(num_nodos):

añad=[-sum(P[k][0]),-sum(P[k][1]),-sum(P[k][2])] FP+=añad

# #

# # # # #

print("Fp: ",FP) lista_de_rigideces=MyApp.rigidez_por_partes(suma_RG,glr,gll) print('K_aa,K_ab,K_ba,K_bb= ') print(lista_de_rigideces) kbb=lista_de_rigideces[3] kab=lista_de_rigideces[1] kba=np.matrix(lista_de_rigideces[2]) kaa=np.matrix(lista_de_rigideces[0]) print("Fp :",FP) print("glr :",glr) print("gll :",gll) pb=Matrix(MyApp.extracion_de_Q(FP,gll)) pa=Matrix(MyApp.extracion_de_Q(FP,glr)) desp_global=Matrix(np.zeros((num_nodos*3,1))) reactor_global=Matrix(np.zeros((num_nodos*3,1))) list_de_desplazamiento=[] try:

# # #

print("kbb= ",kbb) print("Pb= ",pb) print("Pa= ",pa) desplazamientos_desc=Inverse(kbb)*pb print("desplazamientos_desc: ",desplazamientos_desc) reaciones=kab*desplazamientos_desc-pa reaciones_globales=MyApp.llenando_valores_a_matrix(reactor_global,reaciones,glr)

# L7:={Kaa,kab,kba,kbb,FP_libre,FP_restringido,Mδa=despla_restrin,FFN,FFC}; # M6=inv(MKnn)*MFn-inv(MKnn)*MKna*Mδa; # reaciones=kab*np.matrix(linalg.inv(kbb))*np.matrix(pb) -np.matrix(pb) #+(kaakba*np.matrix(linalg.inv(kaa))*kba)*Mδa# REACIONES # reaciones_globales=MyApp.llenando_valores_a_matrix(reactor_global,reaciones,glr) DESPLAZAMIENTO=MyApp.llenando_valores_a_matrix (desp_global,desplazamientos_desc,gll) for i in range(np.size(DESPLAZAMIENTO,0)): list_de_desplazamiento+=[DESPLAZAMIENTO[i,0]] except: for i in range(np.size(desp_global,0)): list_de_desplazamiento+=[desp_global[i,0]] reaciones=-np.matrix(pa) reaciones_globales=MyApp.llenando_valores_a_matrix(reactor_global,reaciones,glr)

reaciones_globales=Matrix(res)

# # # #

#

print("las reaciones son:") print(reaciones) print("las reaciones globales son:") print(reaciones_globales)

lista_de_reaciones=[] lista_de_fuerzas_N_V_M=[] lista_de_giros_y_flechas=[] lista_de_ecuaciones=[] for k in range(num_elemet): ni=int(MC[k,0]) nf=int(MC[k,1]) longitud=MC[k,2] gl=[3*ni-2,3*ni-1,3*ni,3*nf-2,3*nf-1,3*nf] lista_desp=MyApp.extracion_de_Q(list_de_desplazamiento,gl) D_1=Matrix(lista_desp)

#

# # #

print("d_enesimo= ",D_1) K=lista_elementos_RLL[k] T=lista_de_transf[k] desplazgiros=T*D_1 lista_de_giros_y_flechas+=[desplazgiros] desplaz&giros=np.matrix(D_1)*T print("desplazamientos y firos locales del elemento : ",k+1) print(desplazgiros)

# #

RES=K*T*D_1+Matrix(LRMEPF[k]) RES_n=K*np.matrix(D_1)+np.matrix(MyApp.transpuesta(LRMEP[k])) lista_de_reaciones+=[RES_n]

# # # # # # # #

lista_de_fuerzas_N_V_M+=[RES] carga=LRMEP[k][1] fuerzas=LRMEP[k][2] momentos=LRMEP[k][3] for j in range(np.size(carga,0)): numeros_a_evaluar[k]+=[carga[j][0],carga[j][1]]

for j in range(np.size(fuerzas,0)): numeros_a_evaluar[k]+=[fuerzas[j][0]] for j in range(np.size(momentos,0)): numeros_a_evaluar[k]+=[momentos[j][0]] numeros_a_evaluar[k]+=[0,longitud] ecuaciones=MyApp.calculando_ecuaciones_del_portico (desplazgiros,RES,longitud,carga,fuerzas,momentos,MC[k,6],MC[k,7],MC[k,5]) lista_de_ecuaciones+=[ecuaciones]

print("las ecuaciones son") print(lista_de_ecuaciones) print("Analisis Completo")

print("---------------------------------------------") print('los desplazamientos generales en cada nodo son:') print(list_de_desplazamiento) print('') print("---------------------------------------------") print('fuerzas internas en cada elemento') print(lista_de_fuerzas_N_V_M) print("---------------------------------------------") print("las reaciones son:") print(reaciones) print("---------------------------------------------") print("las reaciones globales son:") print(reaciones_globales) # #

except: QMessageBox.question(self, "Correcto","!Analisis estructural con exito¡" )

def llenando_valores_a_matrix(vac,data,gl): dim=np.size(data,0) for i in range(dim): vac[int(gl[i]-1),0]=data[i] return vac

def matriz_ensab(mak,matu,gl): nk=np.size(matu,0)

#

for i in range(nk): for j in range(nk): xt=int(gl[i]) yt=int(gl[j]) mak[xt-1,yt-1]=matu[i,j] print("rigidez asociado K:")

#

print(mak) return mak

# Analisis para el momento calculo del empotramiento perfecto def subs_hard(expr,var,vals): dim=np.size(var) for element in range(dim): expr=expr.subs({var[element]:vals[element]}) return expr

def vigas(long,lcd,lfp,lmp,elasty,iner,area): r1x,r2x,r1y,r2y,m1,m2,c1,c2=symbols('r1x,r2x,r1y,r2y,m1,m2,c1,c2') #programando para la carga distribuida Qx=0 vx=0 fpx=0 mpx=0 sumatoria_de_momentos=0 sumatoria_de_fuerzas_result=0 sumatoria_fx=0 Nx=0 # integral para la carga distribuida if np.sum(lcd)==0: pass else: dim_de_lcd=np.size(lcd,0) sumatoria_de_momentos=0 sumatoria_de_fuerzas_result=0 for k in range(dim_de_lcd): qx=lcd[k][2]*Heaviside(x-lcd[k][0]) - lcd[k][2]*Heaviside(x-lcd[k][1]) Qx=qx+Qx vx=vx+integrate(-qx,x,meijerg=False) fuerza_result=-integrate(lcd[k][2],(x,lcd[k][0],lcd[k][1])) if fuerza_result==0: xcentro=0 else: xcentro=-integrate(x*lcd[k][2],(x,lcd[k][0],lcd[k][1]))/fuerza_result sumatoria_de_momentos=(fuerza_result)*( xcentro)+sumatoria_de_momentos sumatoria_de_fuerzas_result=fuerza_result+sumatoria_de_fuerzas_result;

# Integral para fuerza puntual if np.sum(lfp)==0: Vx=vx int_Nx=0

else: dim_de_lfp=np.size(lfp,0) for k in range(dim_de_lfp): ang=np.pi/180 fy=-lfp[k][1]*sin(lfp[k][2]*ang) fxx=-lfp[k][1]*cos(lfp[k][2]*ang) fpx=fpx+fy*Heaviside(x-lfp[k][0]) sumatoria_fx=fxx+sumatoria_fx sumatoria_de_fuerzas_result=fy+sumatoria_de_fuerzas_result sumatoria_de_momentos=fy*lfp[k][0]+sumatoria_de_momentos

Nx=fxx*Heaviside(x-lfp[k][0])+Nx Vx=vx+fpx #fuerza cortante Vx Vx=Vx+r1y*Heaviside(x)+r2y*Heaviside(x-long) Nx=Nx+r1x*Heaviside(x)+r2x*Heaviside(x-long) int_Nx=integrate(Nx/(elasty*area),(x,0,long),meijerg=False) # Integral para el momento puntual if np.sum(lmp)==0: pass else: dim_de_lmp=np.size(lmp,0) for k in range(dim_de_lmp): mpx=mpx-lmp[k][1]*Heaviside(x-lmp[k][0]) sumatoria_de_momentos=lmp[k][1]+sumatoria_de_momentos mpx=mpx-m1*Heaviside(x)-m2*Heaviside(x-long) Mx=mpx+integrate(Vx,x,meijerg=False) gx=integrate(Mx,x,meijerg=False)+c1 fx=integrate(gx,x,meijerg=False)+c2

# ecuaciones fundamentales de la estatica sfx=sumatoria_fx+r1x+r2x sfy=sumatoria_de_fuerzas_result+r1y+r2y smo=sumatoria_de_momentos+r2y*long+m1+m2 ecuacion1=gx.subs({x:0});ecuacion2=gx.subs({x:long}) ecuacion3=fx.subs({x:0});ecuacion4=fx.subs({x:long}) #reemplazando en las ecuaciones H(0) por 1 ecuacion1=ecuacion1.replace(Heaviside(0),1);ecuacion2=ecuacion2.replace(Heaviside(0),1) ecuacion3=ecuacion3.replace(Heaviside(0),1);ecuacion4=ecuacion4.replace(Heaviside(0),1) int_Nx=int_Nx.replace(Heaviside(0),1) print("resolviendo el sistema de ecuaciones no lineales....") solucion=solve([ecuacion1,ecuacion2,ecuacion3,ecuacion4,sfy,smo,int_Nx,sfx], [r1x,r2x,r1y,r2y,m1,m2,c1,c2],dict=True) #print("las solucion es:",solucion) solucion_symplificada=[solucion[0][r1x],solucion[0][r1y],solucion[0][m1],solucion[0] [r2x],solucion[0][r2y],solucion[0][m2]]

return solucion_symplificada

def calculando_ecuaciones_del_portico(lista_desplaz,lista,long,lcd,lfp,lmp,elasty,iner,area) : x,c1,c2,c3=symbols('x,c1,c2,c3') Qx=0;vx=0;fpx=0;mpx=0;Nx=0

# #

# integral para la carga distribuida if np.sum(lcd)==0: print('') else: dim_de_lcd=np.size(lcd,0) sumatoria_de_momentos=0 sumatoria_de_fuerzas_result=0 for k in range(dim_de_lcd): qx=lcd[k][2]*Heaviside(x-lcd[k][0]) - lcd[k][2]*Heaviside(x-lcd[k][1]) Qx=qx+Qx vx=vx+integrate(-qx,x,meijerg=False) # Integral para fuerza puntual if np.sum(lfp)==0: Vx=vx else: dim_de_lfp=np.size(lfp,0) for k in range(dim_de_lfp): ang=np.pi/180 fy=-lfp[k][1]*sin(lfp[k][2]*ang) fxx=-lfp[k][1]*cos(lfp[k][2]*ang) if long!=lfp[k][0]: fpx=fpx+fy*Heaviside(x-lfp[k][0]) Nx=fxx*Heaviside(x-lfp[k][0])+Nx Vx=vx+fpx #fuerza cortante Vx lista_desplaz[0,0]+ Vx=Vx+lista[1,0]*Heaviside(x)#+lista[4,0]*Heaviside(x-long) Nx=Nx+lista[0,0]*Heaviside(x)#+lista[3,0]*Heaviside(x-long) delta_lx=-integrate(Nx/(elasty*area),(x,0,x),meijerg=False)+lista_desplaz[0,0]#+c3 if np.sum(lmp)==0: print('') else: dim_de_lmp=np.size(lmp,0) for k in range(dim_de_lmp): if long!=lmp[k][0]: mpx=mpx-lmp[k][1]*Heaviside(x-lmp[k][0]) mpx=mpx-lista[2,0]*Heaviside(x)#-lista[5,0]*Heaviside(x-long) Mx=mpx+integrate(Vx,x,meijerg=False) gx=integrate(Mx,x,meijerg=False)/(elasty*iner)+c1 fx=integrate(gx,x,meijerg=False)+c2

gx_eval=fx.replace(x,long) gx_eval=gx_eval.replace(Heaviside(0),1)-lista_desplaz[4,0] fx_eval=fx.replace(x,0) fx_eval=fx_eval.replace(Heaviside(0),1)-lista_desplaz[1,0] solucion=solve([gx_eval,fx_eval],[c1,c2],dict=True) k1=solucion[0][c1] k2=solucion[0][c2] gx=gx.replace(c1,k1) fx=fx.replace(c1,k1) fx=fx.replace(c2,k2) lista_de_ecuaciones=[-Nx,Vx,-Mx,gx,fx,delta_lx] return lista_de_ecuaciones

def rigidez_por_partes(rg,glr,gll): lista_de_rigideces=[] dim_glr=np.size(glr,0) dim_gll=np.size(gll,0) kaa=Matrix(np.zeros((dim_glr,dim_glr))) kab=Matrix(np.zeros((dim_glr,dim_gll))) kba=Matrix(np.zeros((dim_gll,dim_glr))) kbb=Matrix(np.zeros((dim_gll,dim_gll))) #para: Kaa for i in range(dim_glr): for j in range(dim_glr): kaa[i,j]=rg[glr[i]-1,glr[j]-1] #para: Kab for i in range(dim_glr): for j in range(dim_gll): kab[i,j]=rg[glr[i]-1,gll[j]-1] #para: Kba for i in range(dim_gll): for j in range(dim_glr): kba[i,j]=rg[gll[i]-1,glr[j]-1] #para: Kbb for i in range(dim_gll): for j in range(dim_gll): kbb[i,j]=rg[gll[i]-1,gll[j]-1] lista_de_rigideces=[kaa,kab,kba,kbb] return lista_de_rigideces def extracion_de_Q(Qt,gl): dim=np.size(gl)

nQ=[] for i in range(dim): nQ+=[Qt[gl[i]-1]] return nQ def transpuesta(matwork): das=Matrix(matwork) n=np.size(das,0) m=np.size(das,1) new=Matrix(np.zeros((m,n))) for i in range(m): for j in range(n): new[i,j]=das[j,i] return new def extracion_de_Q_matrix(Qt,gl): dim=np.size(gl) nQ=[] for i in range(dim): nQ+=[Qt[gl[i]-1,0]] return nQ

qtCreatorFile = "evaluar.ui" # Nombre del archivo aquí. Ui_MainWindow, QtBaseClass = uic.loadUiType(qtCreatorFile) class ventana(QtWidgets.QMainWindow, Ui_MainWindow): def __init__(self): global typs QtWidgets.QMainWindow.__init__(self) Ui_MainWindow.__init__(self) self.setupUi(self) self.createMenus() self.createDockWindows() typs=[] # c = QtGui.QComboBox() # c.addItems(['Apoyo Movil','Apoyo Fijo','Apoyo Empotrado']) # i = self.tabladeapoyos.model().index(0,1) # self.tabladeapoyos.setIndexWidget(i,c) # self.btn_regresar.clicked.connect(self.regresar_atras) self.actionexit.triggered.connect(self.salir) self.actionnormal.triggered.connect(self.plot_n) self.actioncortante.triggered.connect(self.plot_v)

self.actionflector.triggered.connect(self.plot_m) self.actiongiro.triggered.connect(self.plot_g) self.actionflecha.triggered.connect(self.plot_dx) self.actiondeformada_vertical.triggered.connect(self.plot_dy) self.actionEvaluar.triggered.connect(self.evaluaciones) self.btn_calc.clicked.connect(self.eval_f) # para los nodos self.menos_nodos.clicked.connect(self.eliminar_nodos) self.mas_nodos.clicked.connect(self.agregar_nodos) # para los apoyos self.del_apoyo.clicked.connect(self.eliminar_apoyos) self.mas_apoyo.clicked.connect(self.agregar_apoyos) # para las coneciones self.del_conecion.clicked.connect(self.eliminar_conec) self.mas_conecion.clicked.connect(self.agregar_conec) # para las fuerzas puntuales self.del_fuerzas.clicked.connect(self.eliminar_fuerzas) self.mas_fuerzas.clicked.connect(self.agregar_fuerzas) # para las cargas self.del_cargas.clicked.connect(self.eliminar_cargas) self.mas_cargas.clicked.connect(self.agregar_cargas) # para las cargas self.del_mom.clicked.connect(self.eliminar_mom) self.mas_mom.clicked.connect(self.agregar_mom) self.actionanalizar.triggered.connect(self.analizar) self.actionnormal.setEnabled(False) self.actioncortante.setEnabled(False) self.actionflector.setEnabled(False) self.actiongiro.setEnabled(False) self.actionflecha.setEnabled(False) self.actiondeformada_vertical.setEnabled(False) def rotacion_de_sis_coord(xxxx,yyyy,angulo): ndim=np.size(xxxx) lista_x=[] lista_y=[] for k in range(ndim): xo=xxxx[k];yo=yyyy[k] x_nuevo=xo*np.cos(angulo)-yo*np.sin(angulo) y_nuevo=yo*np.cos(angulo)+xo*np.sin(angulo) x_nuevo=float(x_nuevo);y_nuevo=float(y_nuevo) lista_x=np.append(lista_x,[x_nuevo],0) lista_y=np.append(lista_y,[y_nuevo],0) return lista_x,lista_y

def calculo_de_pendiente(xo,yo,xf,yf): if xo!=xf and yo!=yf: m=(yf-yo)/(xf-xo) ang=np.arctan(m) return ang else: if xo== xf : #print("la pendiente es: ",90) return np.pi/2 else: #print("la pendiente es: ",0) return 0

def añadir_db_de_reaciones_y_momentos(): global reaciones_globales,num_nodos,MN for i in range(num_nodos): k=i+1 dir_x=round(reaciones_globales[int(3*k-3),0],2) dir_y=round(reaciones_globales[int(3*k-2),0],2) print("Reaciones en el nodo "+str(i+1)) print("-----------------------") print(dir_x,dir_y) # moment=round(reaciones_globales[int(3*k-1),0],2) if dir_x!=0: xn=float(MN[i,0]);yn=float(MN[i,1]) if dir_x>0: # ventana_de_diagramas.plot_resultado_fp(self,x,y,np.pi,round(dir_x,2)) plt.annotate(str(round(dir_x,2)), xy=(xn,yn), xytext=(xn-2,yn), bbox=dict(boxstyle='square', fc='blue', linewidth=0.1), arrowprops=dict(facecolor='red', shrink=0.01, width=0.1), fontsize=12, color='white', horizontalalignment='center') # #

plt.arrow(0, 0, 0.5, 0.5, head_width=0.05, head_length=0.1, fc='k', ec='k') else: ventana_de_diagramas.plot_resultado_fp(self,x,y,0,round(abs(dir_x),2)) plt.annotate(str(round(dir_x,2)), xy=(xn,yn), xytext=(xn+2,yn), bbox=dict(boxstyle='square', fc='blue', linewidth=0.1), arrowprops=dict(facecolor='red', shrink=0.01, width=0.1), fontsize=12, color='white', horizontalalignment='center') if dir_y!=0: xn=float(MN[i,0]);yn=float(MN[i,1]) if dir_y>0: plt.annotate(str(round(dir_y,2)), xy=(xn,yn), xytext=(xn,yn-2), bbox=dict(boxstyle='square', fc='blue', linewidth=0.1), arrowprops=dict(facecolor='red', shrink=0.01, width=0.1), fontsize=12, color='white', horizontalalignment='center') else: plt.annotate(str(round(dir_y,2)), xy=(xn,yn), xytext=(xn,yn+2), bbox=dict(boxstyle='square', fc='blue', linewidth=0.1), arrowprops=dict(facecolor='red', shrink=0.01, width=0.1),

fontsize=12, color='white', horizontalalignment='center') # # # # # #

if moment!=0: x=MN[i,1];y=MN[i,2] if moment>0: ventana_de_diagramas.plot_resultado_antihorario(self,x,y,round(moment,2)) else: ventana_de_diagramas.plot_resultado_horario(self,x,y,round(abs(moment),2))

def plot_n(self): global matriz_de_nodos,matrix_de_conexiones,lista_de_ecuaciones #Configurar las características del gráfico ventana.añadir_db_de_reaciones_y_momentos() for j in range(np.size(matrix_de_conexiones,0)): ni=int(matrix_de_conexiones[j][0]-1) nf=int(matrix_de_conexiones[j][1]-1) xo=float(matriz_de_nodos[ni][0]) xf=float(matriz_de_nodos[nf][0]) yo=float(matriz_de_nodos[ni][1]) yf=float(matriz_de_nodos[nf][1]) long=float(((xf-xo)**2+(yf-yo)**2)**0.5) ang=ventana.calculo_de_pendiente(xo,yo,xf,yf) xx=[matriz_de_nodos[ni][0],matriz_de_nodos[nf][0]] yy=[matriz_de_nodos[ni][1],matriz_de_nodos[nf][1]]

plt.plot(xx, yy, label = 'Línea 1', linewidth = 6, color = 'blue') plt.scatter(xx, yy,label = 'Datos 2', color = 'red') fun=lista_de_ecuaciones[j][0] xc = np.arange(0,long, 0.01) yc=[] xcc=[] yang=[] vlav=[] for l in np.arange(0,long, 1): try: tg=fun.subs({x:l}) tg=tg.replace(zoo,0) vlav+=[float(tg)] except: vlav+=[0] mini=min(vlav) maxi=max(vlav) new_maxi=max(maxi,abs(mini)) if new_maxi!=0: for i in xc:

try: dx=xo+i xcc+=[dx] yang+=[float(yo+i*np.tan(ang))] evalf = yo+fun.subs({x:i})/new_maxi evalf=evalf.replace(zoo,0) yc+= [float(evalf.replace(Heaviside(0),1))] except: yc+= [0]

xcc, yc = ventana.rotacion_de_sis_coord(xcc, yc, ang) xt=[xo,xcc[0]] yt=[yo,yc[0]] xtt=[xf,xcc[-1]] ytt=[yf,yc[-1]] plt.plot(xt, yt, linewidth = 2, color = 'green') plt.plot(xtt, ytt, linewidth = 2, color = 'green') else: xcc, yc = ventana.rotacion_de_sis_coord(xcc, yc, ang) plt.plot(xcc,yc)

plt.title('Diagrama de la fuerza axial') plt.ylabel('Eje Y') plt.xlabel('Eje X') #Mostrar leyenda, cuadrícula y figura plt.grid() plt.show() def plot_v(self): global matriz_de_nodos,matrix_de_conexiones,lista_de_ecuaciones #Configurar las características del gráfico ventana.añadir_db_de_reaciones_y_momentos() for j in range(np.size(matrix_de_conexiones,0)): ni=int(matrix_de_conexiones[j][0]-1) nf=int(matrix_de_conexiones[j][1]-1) xo=float(matriz_de_nodos[ni][0]) xf=float(matriz_de_nodos[nf][0]) yo=float(matriz_de_nodos[ni][1]) yf=float(matriz_de_nodos[nf][1]) long=float(((xf-xo)**2+(yf-yo)**2)**0.5) ang=ventana.calculo_de_pendiente(xo,yo,xf,yf) xx=[matriz_de_nodos[ni][0],matriz_de_nodos[nf][0]] yy=[matriz_de_nodos[ni][1],matriz_de_nodos[nf][1]]

plt.plot(xx, yy, label = 'Línea 1', linewidth = 6, color = 'blue') plt.scatter(xx, yy,label = 'Datos 2', color = 'red') fun=lista_de_ecuaciones[j][1] xc = np.arange(0,long, 0.01) yc=[] xcc=[] yang=[] vlav=[] for l in np.arange(0,long, 1): try: tg=fun.subs({x:l}) tg=tg.replace(zoo,0) vlav+=[float(tg)] except: vlav+=[0] mini=min(vlav) maxi=max(vlav) new_maxi=max(maxi,abs(mini)) if new_maxi!=0: for i in xc: try: dx=xo+i xcc+=[dx] yang+=[float(yo+i*np.tan(ang))] evalf = yo+fun.subs({x:i})/new_maxi evalf=evalf.replace(zoo,0) yc+= [float(evalf.replace(Heaviside(0),1))] except: yc+= [0]

xcc, yc = ventana.rotacion_de_sis_coord(xcc, yc, ang) xt=[xo,xcc[0]] yt=[yo,yc[0]] xtt=[xf,xcc[-1]] ytt=[yf,yc[-1]] plt.plot(xt, yt, linewidth = 2, color = 'green') plt.plot(xtt, ytt, linewidth = 2, color = 'green') else: xcc, yc = ventana.rotacion_de_sis_coord(xcc, yc, ang) plt.plot(xcc,yc)

plt.title('Diagrama de la fuerza cortante')

plt.ylabel('Eje Y') plt.xlabel('Eje X') #Mostrar leyenda, cuadrícula y figura plt.grid() plt.show() def plot_m(self): global matriz_de_nodos,matrix_de_conexiones,lista_de_ecuaciones #Configurar las características del gráfico ventana.añadir_db_de_reaciones_y_momentos() for j in range(np.size(matrix_de_conexiones,0)): ni=int(matrix_de_conexiones[j][0]-1) nf=int(matrix_de_conexiones[j][1]-1) xo=float(matriz_de_nodos[ni][0]) xf=float(matriz_de_nodos[nf][0]) yo=float(matriz_de_nodos[ni][1]) yf=float(matriz_de_nodos[nf][1]) long=float(((xf-xo)**2+(yf-yo)**2)**0.5) ang=ventana.calculo_de_pendiente(xo,yo,xf,yf) xx=[matriz_de_nodos[ni][0],matriz_de_nodos[nf][0]] yy=[matriz_de_nodos[ni][1],matriz_de_nodos[nf][1]]

plt.plot(xx, yy, label = 'Línea 1', linewidth = 6, color = 'blue') plt.scatter(xx, yy,label = 'Datos 2', color = 'red') fun=lista_de_ecuaciones[j][2] xc = np.arange(0,long, 0.01) yc=[] xcc=[] yang=[] vlav=[] for l in np.arange(0,long, 1): try: tg=fun.subs({x:l}) tg=tg.replace(zoo,0) vlav+=[float(tg)] except: vlav+=[0] mini=min(vlav) maxi=max(vlav) new_maxi=max(maxi,abs(mini)) if new_maxi!=0: for i in xc: try: dx=xo+i xcc+=[dx] yang+=[float(yo+i*np.tan(ang))]

evalf = yo+fun.subs({x:i})/new_maxi evalf=evalf.replace(zoo,0) yc+= [float(evalf.replace(Heaviside(0),1))] except: yc+= [0]

xcc, yc = ventana.rotacion_de_sis_coord(xcc, yc, ang) xt=[xo,xcc[0]] yt=[yo,yc[0]] xtt=[xf,xcc[-1]] ytt=[yf,yc[-1]] plt.plot(xt, yt, linewidth = 2, color = 'green') plt.plot(xtt, ytt, linewidth = 2, color = 'green') else: xcc, yc = ventana.rotacion_de_sis_coord(xcc, yc, ang) plt.plot(xcc,yc)

plt.title('Diagrama de momento flector') plt.ylabel('Eje Y') plt.xlabel('Eje X') #Mostrar leyenda, cuadrícula y figura plt.grid() plt.show() def plot_g(self): global matriz_de_nodos,matrix_de_conexiones,lista_de_ecuaciones #Configurar las características del gráfico ventana.añadir_db_de_reaciones_y_momentos() for j in range(np.size(matrix_de_conexiones,0)): ni=int(matrix_de_conexiones[j][0]-1) nf=int(matrix_de_conexiones[j][1]-1) xo=float(matriz_de_nodos[ni][0]) xf=float(matriz_de_nodos[nf][0]) yo=float(matriz_de_nodos[ni][1]) yf=float(matriz_de_nodos[nf][1]) long=float(((xf-xo)**2+(yf-yo)**2)**0.5) ang=ventana.calculo_de_pendiente(xo,yo,xf,yf) xx=[matriz_de_nodos[ni][0],matriz_de_nodos[nf][0]] yy=[matriz_de_nodos[ni][1],matriz_de_nodos[nf][1]]

plt.plot(xx, yy, label = 'Línea 1', linewidth = 6, color = 'blue') plt.scatter(xx, yy,label = 'Datos 2', color = 'red')

fun=lista_de_ecuaciones[j][3] xc = np.arange(0,long, 0.01) yc=[] xcc=[] yang=[] vlav=[] for l in np.arange(0,long, 1): try: tg=fun.subs({x:l}) tg=tg.replace(zoo,0) vlav+=[float(tg)] except: vlav+=[0] mini=min(vlav) maxi=max(vlav) new_maxi=max(maxi,abs(mini)) if new_maxi!=0: for i in xc: try: dx=xo+i xcc+=[dx] yang+=[float(yo+i*np.tan(ang))] evalf = yo+fun.subs({x:i})/new_maxi evalf=evalf.replace(zoo,0) yc+= [float(evalf.replace(Heaviside(0),1))] except: yc+= [0]

xcc, yc = ventana.rotacion_de_sis_coord(xcc, yc, ang) xt=[xo,xcc[0]] yt=[yo,yc[0]] xtt=[xf,xcc[-1]] ytt=[yf,yc[-1]] plt.plot(xt, yt, linewidth = 2, color = 'green') plt.plot(xtt, ytt, linewidth = 2, color = 'green') else: xcc, yc = ventana.rotacion_de_sis_coord(xcc, yc, ang) plt.plot(xcc,yc)

plt.title('Diagrama de slope defleccion') plt.ylabel('Eje Y') plt.xlabel('Eje X') #Mostrar leyenda, cuadrícula y figura

plt.grid() plt.show() def plot_dy(self): global matriz_de_nodos,matrix_de_conexiones,lista_de_ecuaciones #Configurar las características del gráfico ventana.añadir_db_de_reaciones_y_momentos() for j in range(np.size(matrix_de_conexiones,0)): ni=int(matrix_de_conexiones[j][0]-1) nf=int(matrix_de_conexiones[j][1]-1) xo=float(matriz_de_nodos[ni][0]) xf=float(matriz_de_nodos[nf][0]) yo=float(matriz_de_nodos[ni][1]) yf=float(matriz_de_nodos[nf][1]) long=float(((xf-xo)**2+(yf-yo)**2)**0.5) ang=ventana.calculo_de_pendiente(xo,yo,xf,yf) xx=[matriz_de_nodos[ni][0],matriz_de_nodos[nf][0]] yy=[matriz_de_nodos[ni][1],matriz_de_nodos[nf][1]]

plt.plot(xx, yy, label = 'Línea 1', linewidth = 6, color = 'blue') plt.scatter(xx, yy,label = 'Datos 2', color = 'red') fun=lista_de_ecuaciones[j][5] xc = np.arange(0,long, 0.01) yc=[] xcc=[] yang=[] vlav=[] for l in np.arange(0,long, 1): try: tg=fun.subs({x:l}) tg=tg.replace(zoo,0) vlav+=[float(tg)] except: vlav+=[0] mini=min(vlav) maxi=max(vlav) new_maxi=max(maxi,abs(mini)) if new_maxi!=0: for i in xc: try: dx=xo+i xcc+=[dx] yang+=[float(yo+i*np.tan(ang))] evalf = yo+fun.subs({x:i})/new_maxi evalf=evalf.replace(zoo,0) yc+= [float(evalf.replace(Heaviside(0),1))]

except: yc+= [0]

xcc, yc = ventana.rotacion_de_sis_coord(xcc, yc, ang) xt=[xo,xcc[0]] yt=[yo,yc[0]] xtt=[xf,xcc[-1]] ytt=[yf,yc[-1]] plt.plot(xt, yt, linewidth = 2, color = 'green') plt.plot(xtt, ytt, linewidth = 2, color = 'green') else: xcc, yc = ventana.rotacion_de_sis_coord(xcc, yc, ang) plt.plot(xcc,yc)

plt.title('Diagrama de la deformada axial') plt.ylabel('Eje Y') plt.xlabel('Eje X') #Mostrar leyenda, cuadrícula y figura plt.grid() plt.show() def plot_dx(self): global matriz_de_nodos,matrix_de_conexiones,lista_de_ecuaciones #Configurar las características del gráfico ventana.añadir_db_de_reaciones_y_momentos() for j in range(np.size(matrix_de_conexiones,0)): ni=int(matrix_de_conexiones[j][0]-1) nf=int(matrix_de_conexiones[j][1]-1) xo=float(matriz_de_nodos[ni][0]) xf=float(matriz_de_nodos[nf][0]) yo=float(matriz_de_nodos[ni][1]) yf=float(matriz_de_nodos[nf][1]) long=float(((xf-xo)**2+(yf-yo)**2)**0.5) ang=ventana.calculo_de_pendiente(xo,yo,xf,yf) xx=[matriz_de_nodos[ni][0],matriz_de_nodos[nf][0]] yy=[matriz_de_nodos[ni][1],matriz_de_nodos[nf][1]]

plt.plot(xx, yy, label = 'Línea 1', linewidth = 6, color = 'blue') plt.scatter(xx, yy,label = 'Datos 2', color = 'red') fun=lista_de_ecuaciones[j][4] xc = np.arange(0,long, 0.01) yc=[]

xcc=[] yang=[] vlav=[] for l in np.arange(0,long, 1): try: tg=fun.subs({x:l}) tg=tg.replace(zoo,0) vlav+=[float(tg)] except: vlav+=[0] mini=min(vlav) maxi=max(vlav) new_maxi=max(maxi,abs(mini)) if new_maxi!=0: for i in xc: try: dx=xo+i xcc+=[dx] yang+=[float(yo+i*np.tan(ang))] evalf = yo+fun.subs({x:i})/new_maxi evalf=evalf.replace(zoo,0) yc+= [float(evalf.replace(Heaviside(0),1))] except: yc+= [0]

xcc, yc = ventana.rotacion_de_sis_coord(xcc, yc, ang) xt=[xo,xcc[0]] yt=[yo,yc[0]] xtt=[xf,xcc[-1]] ytt=[yf,yc[-1]] plt.plot(xt, yt, linewidth = 2, color = 'green') plt.plot(xtt, ytt, linewidth = 2, color = 'green') else: xcc, yc = ventana.rotacion_de_sis_coord(xcc, yc, ang) plt.plot(xcc,yc)

plt.title('Diagrama de la deformada vertical') plt.ylabel('Eje Y') plt.xlabel('Eje X') #Mostrar leyenda, cuadrícula y figura plt.grid() plt.show() def analizar(self): global typs,matriz_de_nodos,matrix_de_conexiones

from sympy.parsing.sympy_parser import parse_expr # tabladenodos,tabladeapoyos,tabla_de_coneccion,tabladefuerzas,tablademomentos,tabladecargasdist r try: numero_de_nodos=self.tabladenodos.rowCount() matriz_de_nodos=[] for i in range(numero_de_nodos): dx=parse_expr(self.tabladenodos.item(i, 0).text()) dy=parse_expr(self.tabladenodos.item(i, 1).text()) nodos=[dx,dy] matriz_de_nodos+=[nodos] print("Matrix de nodos: ") print("-----------------------") print(matriz_de_nodos) #---------------------------------------------------------------------numero_de_apoyos=self.tabladeapoyos.rowCount() apoyos=[] for i in range(numero_de_apoyos): nodo=int(self.tabladeapoyos.item(i, 0).text()) typo=typs[i] nodos=[nodo,typo] apoyos+=[nodos] print("Matrix de Apoyos: ") print("-----------------------") print(apoyos) #---------------------------------------------------------------------numero_de_conect=self.tabla_de_coneccion.rowCount() matrix_de_conexiones=[] for i in range(numero_de_conect): ni=int(self.tabla_de_coneccion.item(i, 0).text()) nf=int(self.tabla_de_coneccion.item(i, 1).text()) A=parse_expr(self.tabla_de_coneccion.item(i, 2).text()) E=parse_expr(self.tabla_de_coneccion.item(i, 3).text()) I=parse_expr(self.tabla_de_coneccion.item(i, 4).text()) cone=[ni,nf,A,E,I] matrix_de_conexiones+=[cone] print("Matrix de CONECIONES: ") print("-----------------------") print(matrix_de_conexiones) #---------------------------------------------------------------------numero_de_FUERZA=self.tabladefuerzas.rowCount() matriz_de_fuerzas=[] for i in range(numero_de_FUERZA): dist=parse_expr(self.tabladefuerzas.item(i, 0).text()) fuer=parse_expr(self.tabladefuerzas.item(i,1).text()) angle=parse_expr(self.tabladefuerzas.item(i, 2).text()) ele=int(self.tabladefuerzas.item(i, 3).text())

cone=[dist,fuer,angle,ele] matriz_de_fuerzas+=[cone] print("Matrix de fuerzas: ") print("-----------------------") print(matriz_de_fuerzas) #---------------------------------------------------------------------numero_de_momentos=self.tablademomentos.rowCount() matriz_de_momentos=[] for i in range(numero_de_momentos): dist=parse_expr(self.tablademomentos.item(i, 0).text()) fuer=parse_expr(self.tablademomentos.item(i,1).text()) ele=int(self.tablademomentos.item(i,2).text()) cone=[dist,fuer,ele] matriz_de_momentos+=[cone] print("Matrix de Momentos: ") print("-----------------------") print(matriz_de_momentos) #---------------------------------------------------------------------numero_de_cargas=self.tabladecargasdistr.rowCount() matriz_de_cargas=[] for i in range(numero_de_cargas): dist_ini=parse_expr(self.tabladecargasdistr.item(i, 0).text()) dist_fin=parse_expr(self.tabladecargasdistr.item(i,1).text()) qx=parse_expr(self.tabladecargasdistr.item(i,2).text()) ele=int(self.tabladecargasdistr.item(i,3).text()) cone=[dist_ini,dist_fin,qx,ele] matriz_de_cargas+=[cone] print("Matrix de Cargas: ") print("-----------------------") print(matriz_de_cargas) try: MyApp.analizar_estructura (apoyos,matriz_de_nodos,matrix_de_conexiones,matriz_de_cargas,matriz_de_fuerzas,matriz_de_mom entos) self.actionnormal.setEnabled(True) self.actioncortante.setEnabled(True) self.actionflector.setEnabled(True) self.actiongiro.setEnabled(True) self.actionflecha.setEnabled(True) self.actiondeformada_vertical.setEnabled(True) QMessageBox.question(self, "exito","!Analisis estructural con exito ¡" ) except: QMessageBox.question(self, "warning","!la estructura es indeterminado¡" ) except:

QMessageBox.question(self, "Los datos son incorrectos","!ingrese bien los datos¡" )

def Combo_indexchanged(self): global typs combo = self.sender() fila = combo.property('row') tipo = combo.currentText() typs[fila]=tipo

def adsendecuaciones(self,N): global lista_de_ecuaciones tipo_de_selecion='elemento'

try: if tipo_de_selecion=='elemento': self.lista_de_ecuaciones_widgets.clear() ecuaciones=lista_de_ecuaciones[N] self.lista_de_ecuaciones_widgets.addItems(('✔ Nx= '+str(ecuaciones[0]), '✔ Vx= '+str(ecuaciones[1]), '✔ Mx= '+str(ecuaciones[2]), '✔ θx= '+str(ecuaciones[3]), '✔ Δx= '+str(ecuaciones[5]), '✔ Δy= '+str(ecuaciones[4]))) else: self.lista_de_ecuaciones_widgets.clear() self.lista_de_ecuaciones_widgets.addItems(('Selecione un elemento para visualizar las ecuaciones',)) except: self.lista_de_ecuaciones_widgets.clear() self.lista_de_ecuaciones_widgets.addItems(("Para Ver las ecuaciones, primero tiene que analizar la estructura",))

def eliminar_mom(self): numrows = self.tablademomentos.rowCount() self.tablademomentos.removeRow(numrows-1) def agregar_mom(self): numrows = self.tablademomentos.rowCount() #contamos self.tablademomentos.insertRow(numrows) #agregamos al final etiq_de_nodos=[] for i in range(numrows+1): etiq_de_nodos+=['M-'+str(i+1)] self.tablademomentos.setVerticalHeaderLabels(etiq_de_nodos) #etiquetamos las filas

def eliminar_cargas(self): numrows = self.tabladecargasdistr.rowCount() self.tabladecargasdistr.removeRow(numrows-1) def agregar_cargas(self): numrows = self.tabladecargasdistr.rowCount() #contamos self.tabladecargasdistr.insertRow(numrows) #agregamos al final etiq_de_nodos=[] for i in range(numrows+1): etiq_de_nodos+=['C-'+str(i+1)] self.tabladecargasdistr.setVerticalHeaderLabels(etiq_de_nodos) #etiquetamos las filas def eliminar_fuerzas(self): numrows = self.tabladefuerzas.rowCount() self.tabladefuerzas.removeRow(numrows-1) def agregar_fuerzas(self): numrows = self.tabladefuerzas.rowCount() #contamos self.tabladefuerzas.insertRow(numrows) #agregamos al final etiq_de_nodos=[] for i in range(numrows+1): etiq_de_nodos+=['F-'+str(i+1)] self.tabladefuerzas.setVerticalHeaderLabels(etiq_de_nodos) #etiquetamos las filas

def eliminar_conec(self): numrows = self.tabla_de_coneccion.rowCount() self.tabla_de_coneccion.removeRow(numrows-1) def agregar_conec(self): numrows = self.tabla_de_coneccion.rowCount() #contamos self.tabla_de_coneccion.insertRow(numrows) #agregamos al final

etiq_de_nodos=[] for i in range(numrows+1): etiq_de_nodos+=['Elemento-'+str(i+1)] self.tabla_de_coneccion.setVerticalHeaderLabels(etiq_de_nodos) #etiquetamos las filas def eliminar_nodos(self): numrows = self.tabladenodos.rowCount() self.tabladenodos.removeRow(numrows-1)

def agregar_nodos(self): numrows = self.tabladenodos.rowCount() #contamos self.tabladenodos.insertRow(numrows) #agregamos al final etiq_de_nodos=[] for i in range(numrows+1): etiq_de_nodos+=['N-'+str(i+1)] self.tabladenodos.setVerticalHeaderLabels(etiq_de_nodos) #etiquetamos las filas

#

valor=self.tableWidget.item(1, 0).text() #PARA EXTRAER VALOR DE UNA CELDA def eliminar_apoyos(self): global typs numrows = self.tabladeapoyos.rowCount() self.tabladeapoyos.removeRow(numrows-1) typs=np.delete(typs,numrows-1) print("tipos de apoyo que quedan: ",typs) if numrows-1==0: typs=[]

def agregar_apoyos(self): global typs numrows = self.tabladeapoyos.rowCount() #contamos self.tabladeapoyos.insertRow(numrows) #agregamos al final etiq_de_nodos=[] typs+=['Apoyo Movil'] print("los tipos de apoyos son:",typs) for i in range(numrows+1): etiq_de_nodos+=['A-'+str(i+1)] # #

c = QtGui.QComboBox() c.addItems(['Apoyo Movil','Apoyo Fijo','Apoyo Empotrado'])

combobox = QtGui.QComboBox() for txt in ['Apoyo Movil','Apoyo Fijo','Apoyo Empotrado']: combobox.addItem(txt) combobox.setProperty('row', i) combobox.currentIndexChanged.connect(self.Combo_indexchanged) self.tabladeapoyos.setCellWidget(i, 1, combobox)

# # #

c.currentIndexChanged.connect(self.Combo_indexchanged) i = self.tabladeapoyos.model().index(i,1) self.tabladeapoyos.setIndexWidget(i,c)

self.tabladeapoyos.setVerticalHeaderLabels(etiq_de_nodos) #etiquetamos las filas

def evaluaciones(self): self.dockWidget_EVAL.setVisible(True)

def salir(self): mensaje = QMessageBox.question(self, 'Desea salir de la App', "Sí o No ?", QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if mensaje == QMessageBox.Yes: self.close() def regresar_atras(self): self.dockWidget_EVAL.setVisible(False) def eval_f(self): global lista_de_ecuaciones

tipo_de_selecion='elemento' if tipo_de_selecion=='elemento': try: valor_x=float(self.widgets_eval.text()) N=int(int(self.elemento.text())-1) ventana.adsendecuaciones(self,N) nx=lista_de_ecuaciones[N][0] vx=lista_de_ecuaciones[N][1] mx=lista_de_ecuaciones[N][2] gx=lista_de_ecuaciones[N][3] fy=lista_de_ecuaciones[N][4]

fx=lista_de_ecuaciones[N][5] eval_axial=nx.replace(x,valor_x) eval_axial=eval_axial.replace(Heaviside(0),1) eval_vx=vx.replace(x,valor_x) eval_vx=eval_vx.replace(Heaviside(0),1) eval_mx=mx.replace(x,valor_x) eval_mx=eval_mx.replace(Heaviside(0),1) eval_gx=gx.replace(x,valor_x) eval_gx=eval_gx.replace(Heaviside(0),1) eval_fy=fy.replace(x,valor_x) eval_fy=eval_fy.replace(Heaviside(0),1) eval_fx=fx.replace(x,valor_x) eval_fx=eval_fx.replace(Heaviside(0),1) eval_axial=nx.replace(x,valor_x) eval_axial=eval_axial.replace(Heaviside(0),1) self.lineEdit_2.setText(str(eval_axial)) self.lineEdit_3.setText(str(eval_vx)) self.lineEdit_4.setText(str(-eval_mx)) self.lineEdit_5.setText(str(eval_gx)) self.lineEdit_6.setText(str(eval_fy)) self.lineEdit_7.setText(str(eval_fx)) except: QMessageBox.question(self, 'Error de casilla', "íngrese una distancia?", QMessageBox.Yes | QMessageBox.No, QMessageBox.No)

else: QMessageBox.question(self, 'Error de selecion', "Selecione un elemento?", QMessageBox.Yes | QMessageBox.No, QMessageBox.No)

def createMenus(self): self.viewMenu = self.menuBar().addMenu("&ver")

def createDockWindows(self):

self.menuDatos.addAction(self.dockWidget_DATOS_2.toggleViewAction()) self.menufuerzas.addAction(self.dockWidget_carga.toggleViewAction()) self.menuMomentos.addAction(self.dockWidget_moment.toggleViewAction()) self.menuEvaluar.addAction(self.dockWidget_EVAL.toggleViewAction())

self.dockWidget_EVAL.setVisible(False)

dock = QDockWidget("Ecuaciones fundamentales", self) dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea) self.lista_de_ecuaciones_widgets = QListWidget(dock) self.lista_de_ecuaciones_widgets.addItems(( 'Selecione un elemento para visualizar las ecuaciones',)) dock.setWidget(self.lista_de_ecuaciones_widgets) self.addDockWidget(Qt.RightDockWidgetArea, dock) self.viewMenu.addAction(dock.toggleViewAction()) if __name__ == "__main__": app = QtWidgets.QApplication(sys.argv) window = ventana() window.show() sys.exit(app.exec_())