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) #+(kaa-
kba*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_())