Descarga la aplicación para disfrutar aún más
Lea materiales sin conexión, sin usar Internet. Además de muchas otras características!
Rayleigh_Ritz_viga_v1 1
milagrosmareco187
Esta es una vista previa del archivo. Inicie sesión para ver el archivo original
import Tkinter as tk
import ttk
import sys
import os
import math
from sympy import *
import numpy
from fractions import Fraction
#para poder realizar cocientes:
R=Rational
#Defino los simbolos (no podran ser utilizados como variables)
x, L, E, I, d, h, K1, K2, Kl, Kt, Kleq, Kteq, C1, P, M, q, q0, q1, q2 = symbols('x L E I d h K1 K2 Kl Kt Kleq Kteq C1 P M q q0 q1 q2')
#Seteo variables de tipo y banderas de seleccion en 0
t_a1 = 0
t_a2 = 0
t_k1 = 0
t_k2 = 0
t_q = 0
b_a1 = 0
b_a2 = 0
b_k1 = 0
b_k2 = 0
b_kleq = 0
b_kteq = 0
b_P = 0
b_q = 0
b_M = 0
x_qi = 0
x_qf = 0
def reiniciar_programa():
python = sys.executable
os.execl(python, python, * sys.argv)
def condiciones_minimas(): #funcion para confirmar si se cumplen las condiciones minimas para poder resolver el ejercicio
global t_a1
global t_a2
global b_P
global b_q
global b_M
global t_q
global x_qi
global x_qf
c_m_a = t_a1 + t_a2 #condicion minima de los apoyos: c_m_a >= 3
c_m_c = b_P + t_q*b_q + b_M #condicion minima de las cargas externas c_m_c >= 1
if c_m_a >= 3 and c_m_c >= 1: #Si se cumplen las condiciones minimas
elif b_q == 0: # y si no esta seleccionado q
resol.config(state='normal') # se habilita el boton de resolver
elif t_q > 0 and x_qi != x_qf: # pero si esta seleccionado tipo de q y esta distribuida:
resol.config(state='normal') # se habilita el boton de resolver
else: resol.config(state='disabled') #Sino, se deshabilita el boton de resolver
def resolver_ejercicio(): #Funcion que imprime los resultados de las ecuaciones, cuando correspondan
if b_a1*t_a1 > 1 :
print 'Vinculo 1 - v(x)=',v_1(x)
if b_a2*t_a2 > 1 :
print 'Vinculo 2 - v(x)=',v_2(x)
print 'v(x)=',v_x(x)
print "v'(x)=",v__1(x)
print "v''(x)=",v__2(x)
print 'Uviga=',Uviga(x)
if b_k1 == 1 :
print 'UK1=',Uk1()
if b_k2 == 1 :
print 'UK2=',Uk2()
if b_kleq == 1 :
print 'Kleq = Kt/h^2'
print 'UKleq=',Ukleq()
if b_kteq == 1 :
print 'Kteq = Kl*h^2'
print 'UKteq=',Ukteq()
if b_P == 1 :
print 'Vp=',Vp()
if b_q == 1 :
print 'Vq=',Vq()
if b_M == 1 :
print 'Vm=',Vm()
print 'Pi* = U + V = ',p_i()
print 'dPi*/dC1 = ',dpi_dc1() ,' = 0'
print 'C1=',c1()
print 'v(x)=',V_X()
print '##############################################'
######
### Transformo a float y luego a fraccion el valor ingresado en el deslizador
def pos_a1(X):
global x_a1
x_a1 = Fraction.from_float(float(X))*L
def pos_a2(X):
global x_a2
x_a2 = Fraction.from_float(float(X))*L
def pos_k1(X):
global x_k1
x_k1 = Fraction.from_float(float(X))*L
def pos_k2(X):
global x_k2
x_k2 = Fraction.from_float(float(X))*L
def pos_kleq(X):
global x_kleq
x_kleq = Fraction.from_float(float(X))*L
def pos_kteq(X):
global x_kteq
x_kteq = Fraction.from_float(float(X))*L
def pos_P(X):
global x_P
x_P = Fraction.from_float(float(X))*L
def pos_qi(X):
global x_qi
x_qi = Fraction.from_float(float(X))*L
condiciones_minimas()
def pos_qf(X):
global x_qf
x_qf = Fraction.from_float(float(X))*L
condiciones_minimas()
def pos_M(X):
global x_M
x_M = Fraction.from_float(float(X))*L
######
### Almacena banderas de seleccion en variables globales
# Habilita mas campos (posicion, tipo) si se selecciona el elemento (apoyo, resorte, carga)
# Al des-seleccionar el elemento, se vuelve a 0 el valor de la regla (ubicacion)
def sel_a1():
global b_a1
b_a1=a1_flag.get()
if b_a1 == 1:
apoyo1tipo.config(state='normal')
simple1.config(state='normal')
fijo1.config(state='normal')
empotrado1.config(state='normal')
apoyo1ubicacion.config(state='normal')
regla_a1.config(state='normal')
else:
apoyo1tipo.config(state='disabled')
simple1.config(state='disabled')
fijo1.config(state='disabled')
empotrado1.config(state='disabled')
apoyo1ubicacion.config(state='disabled')
regla_a1.set(0.00)
regla_a1.config(state='disabled')
def sel_a2():
global b_a2
global t_a2
b_a2=a2_flag.get()
if b_a2 == 1:
apoyo2tipo.config(state='normal')
simple2.config(state='normal')
fijo2.config(state='normal')
empotrado2.config(state='normal')
apoyo2ubicacion.config(state='normal')
regla_a2.config(state='normal')
else:
apoyo2tipo.config(state='disabled')
simple2.config(state='disabled')
fijo2.config(state='disabled')
empotrado2.config(state='disabled')
apoyo2ubicacion.config(state='disabled')
regla_a2.set(0.00)
regla_a2.config(state='disabled')
def sel_k1():
global b_k1
b_k1=k1_flag.get()
if b_k1 == 1:
k1tipo.config(state='normal')
lin_1.config(state='normal')
tor_1.config(state='normal')
k1_pos.config(state='normal')
regla_k1.config(state='normal')
else:
k1tipo.config(state='disabled')
lin_1.config(state='disabled')
tor_1.config(state='disabled')
k1_pos.config(state='disabled')
regla_k1.set(0.00)
regla_k1.config(state='disabled')
def sel_k2():
global b_k2
b_k2=k2_flag.get()
if b_k2 == 1:
k2tipo.config(state='normal')
lin_2.config(state='normal')
tor_2.config(state='normal')
k2_pos.config(state='normal')
regla_k2.config(state='normal')
else:
k2tipo.config(state='disabled')
lin_2.config(state='disabled')
tor_2.config(state='disabled')
k2_pos.config(state='disabled')
regla_k2.set(0.00)
regla_k2.config(state='disabled')
def sel_kleq():
global b_kleq
b_kleq=kleq_flag.get()
if b_kleq == 1:
kleq_pos.config(state='normal')
regla_kleq.config(state='normal')
else:
kleq_pos.config(state='disabled')
regla_kleq.set(0.00)
regla_kleq.config(state='disabled')
def sel_kteq():
global b_kteq
b_kteq=kteq_flag.get()
if b_kteq == 1:
kteq_pos.config(state='normal')
regla_kteq.config(state='normal')
else:
kteq_pos.config(state='disabled')
regla_kteq.set(0.00)
regla_kteq.config(state='disabled')
#Ejecuta 'condiciones_minimas()' para ver si con los nuevos datos, estoy en habilitado a resolver el ejercicio
def sel_P():
global b_P
b_P=P_flag.get()
condiciones_minimas()
if b_P == 1:
P_pos.config(state='normal')
regla_P.config(state='normal')
else:
P_pos.config(state='disabled')
regla_P.set(0.00)
regla_P.config(state='disabled')
def sel_q():
global b_q
b_q = q_flag.get()
if b_q == 1:
q_cte.config(state='normal')
q_var.config(state='normal')
regla_qi.config(state='normal')
q_ini.config(state='normal')
regla_qf.config(state='normal')
q_fin.config(state='normal')
condiciones_minimas()
else:
regla_qi.set(0.00)
regla_qf.set(0.00)
q_cte.config(state='disabled')
q_var.config(state='disabled')
regla_qi.config(state='disabled')
q_ini.config(state='disabled')
regla_qf.config(state='disabled')
q_fin.config(state='disabled')
condiciones_minimas()
def sel_M():
global b_M
b_M=M_flag.get()
condiciones_minimas()
if b_M == 1:
regla_M.config(state='normal')
M_pos.config(state='normal')
else:
regla_M.set(0.00)
regla_M.config(state='normal')
M_pos.config(state='normal')
######
### Almacena banderas de tipo en variables globales
# Ejecuta 'condiciones_minimas()' para ver si con los nuevos datos, estoy en habilitado a resolver el ejercicio
def tipo_a1():
global t_a1
t_a1=a1_t.get()
condiciones_minimas()
def tipo_a2():
global t_a2
t_a2=a2_t.get()
condiciones_minimas()
# Los resortes no son condicion necesaria para resolver un ejercicio
def tipo_k1():
global t_k1
t_k1=k1_t.get()
def tipo_k2():
global t_k2
t_k2=k2_t.get()
# q(x) como condicion necesaria se contempla en 'sel_q()'
def tipo_q():
global t_q
t_q = q_t.get()
######
### Condiciones de Contorno
# Las condiciones de contorno esenciales son hasta 1 grado menos que la maxima del funcional,
# por esto trabajamos hasta las derivadas primeras.
#Simple --> t_a1, t_a2 = 1
# v(x)=0
# v''(x)=0 <-- No la utilizamos
#Fijo --> t_a1, t_a2 = 2
# v(x)=0
# v''(x)=0 <-- No la utilizamos
#Empotramiento --> t_a1, t_a2 = 3
# v(x)=0
# v'(x)=0
######
### Formacion de ecuacion de desplazamientos v(x)
def v_1(X): #Ecuacion que satisface las cc del vinculo 1
global t_a1
global b_a1
while b_a1==1: #Solo carga valores si esta activa la casilla 'Vinculo 1'
if t_a1 == 1:
return (X - x_a1) #Apoyo simple
elif t_a1 == 2:
return (X - x_a1) #Apoyo fijo
elif t_a1 == 3:
return (X - x_a1)**2 #Empotramiento
else:
return 1
else: #Esto es para que al multiplicarlas y se completa 1 solo vinculo, el producto no de error.
return 1
def v_2(X): #Ecuacion que satisface las cc del vinculo 2, idem vinculo 1
global t_a2
global b_a2
while b_a2==1:
if t_a2 == 1:
return (X - x_a2)
elif t_a2 == 2:
return (X - x_a2)
elif t_a2 == 3:
return (X-x_a2)**2
else:
return 1
else:
return 1
def v_x(X): # v(x)
return v_1(X) * v_2(X) * C1
def v__1(X): # v'(x)
return diff(v_x(X),X)
def v__2(X): # v''(x)
return diff(v_x(X),X,2)
def Uviga(X): #Energia interna de la viga
return R(1,2)*E*I*integrate((v__2(X)**2),(X,0,L))
def Ukl(k,X): #Energia interna de un resorte lineal 'k' en la posicion 'x'
return R(1,2)*k*(v_x(X))**2
def Ukt(k,X): #Energia interna de un resorte torsor 'k' en la posicion 'x'
return R(1,2)*k*(v__1(X))**2
def Uk1(): #Energia interna de K1
global b_k1
global t_k1
global x_k1
while b_k1==1:
if t_k1 == 1: #K1 es lineal
return Ukl(K1,x).subs(x,x_k2)
elif t_k1 == 2: #K1 es torsor
return Ukt(K1,x).subs(x,x_k1)
else:
return 0
def Uk2(): #Energia interna de K2
global b_k2
global t_k2
global x_k2
while b_k2==1:
if t_k2 == 1: #K2 es lineal
return Ukl(K2,x).subs(x,x_k2)
elif t_k2 == 2: #K2 es torsor
return Ukt(K2,x).subs(x,x_k2)
else:
return 0
def Ukteq(): #Energia interna de K torsor equivalente
global x_kteq
while b_kteq == 1:
return R(1,2)*Kteq*(v__1(x).subs(x,x_kteq))**2
else:
return 0
def Ukleq(): #Energia interna de K lineal equivalente
global x_kleq
while b_kleq == 1:
return R(1,2)*Kleq*(v_x(x).subs(x,x_kleq))**2
else:
return 0
#Potenciales de carga
def Vp(): # carga puntual P
global b_P
global x_P
while b_P == 1:
return - P * v_x(x).subs(x,x_P)
else:
return 0
def Vq(): #carga distribuida q(x)
global b_q
global t_q
global x_qi
global x_qf
while b_q == 1:
if t_q == 1: #La carga es constante
return -integrate(q0 * v_x(x),(x,x_qi,x_qf))
if t_q == 2: #La carga es variable
return -integrate((x*(q2-q1)/(x_qf-x_qi)) * v_x(x),(x,x_qi,x_qf))
else:
return 0
def Vm(): #momento M
global b_M
global x_M
while b_M == 1:
return - M*v__1(x).subs(x,x_M)
else:
return 0
def p_i(): #PI* = U + V
global b_k1
global b_k2
global b_kteq
global b_kleq
global b_P
global b_q
global b_M
return Uviga(x)+Uk1()*b_k1+Uk2()*b_k2+Ukteq()*b_kteq+Ukleq()*b_kleq+Vp()*b_P+Vq()*b_q+Vm()*b_M
def dpi_dc1(): #dPI*/dC1=0
return diff(p_i(),C1)
def c1(): #Hallo el valor de C1
cte=solve(dpi_dc1(),C1)
return cte[0]
def V_X(): #Ecuacion de desplazamiento completa
return v_x(x)/C1*c1()
######################
###### Interfaz ######
###### Grafica ######
######################
#Raiz
root = tk.Tk()
root.title('Rayleigh-Ritz')
root.geometry('570x350')
#Solapas
tab_parent=ttk.Notebook(root)
tab1 = ttk.Frame(tab_parent)
tab2 = ttk.Frame(tab_parent)
tab3 = ttk.Frame(tab_parent)
#Checkbuttons son botones de seleccion: pueden seleccionarse varios a la vez
#Radiobuttons son botones de opcion: puede seleccionarse solo 1
######################
###### APOYOS ######
#Solapa Vinculos
tab_parent.add(tab1, text = 'Vinculos')
######
### Apoyo 1
a1_t = tk.IntVar() #Almacena el tipo de apoyo
a1_flag = tk.IntVar() #Bandera de seleccion
cuadroapoyo1 = tk.Frame(tab1,height=2, bd=1, relief='sunken') #Crea un cuadro en tab1
cuadroapoyo1.pack(side='left',fill='both', padx=5, pady=5) #Lo ubica hacia la izquierda
boton_a1 = tk.Checkbutton(cuadroapoyo1, text='Vinculo 1', variable = a1_flag, command = sel_a1) #Crea boton de seleccion
boton_a1.pack(anchor=tk.W)
apoyo1tipo = tk.Label(cuadroapoyo1,text = 'Tipo de vinculo', padx = 20, pady=15, state = 'disabled') #Crea etiqueta
apoyo1tipo.pack(anchor=tk.W)
simple1 = tk.Radiobutton (cuadroapoyo1, text='Simple', padx = 30, variable = a1_t, value = 1, command = tipo_a1, state = 'disabled') #Crea boton de opcion, que al seleccionarlo modifica la variable a1_t con valor =1 y realiza el comando tipo_a1() que la almacena en una variable global. Su estado inicial es desactivado (sombreado)
simple1.pack(anchor=tk.W)
fijo1 = tk.Radiobutton (cuadroapoyo1, text='Fijo', padx = 30, variable = a1_t, value = 2, command = tipo_a1,state = 'disabled')
fijo1.pack(anchor=tk.W)
empotrado1 = tk.Radiobutton (cuadroapoyo1, text='Empotramiento', padx = 30, variable = a1_t, value = 3, command = tipo_a1,state = 'disabled')
empotrado1.pack(anchor=tk.W)
apoyo1ubicacion = tk.Label(cuadroapoyo1, text = 'Ubicacion:', padx = 20, pady=15, state = 'disabled')
apoyo1ubicacion.pack(anchor=tk.W)
regla_a1=tk.Scale(cuadroapoyo1,orient="horizontal", command=pos_a1,from_=0.0,to=1.0,resolution=0.05, state = 'disabled') #Crea una regla que va de 0 a 1, en pasos de 0.05
regla_a1.pack(padx =35,anchor=tk.W)
######
### Apoyo 2
a2_t = tk.IntVar()
a2_flag = tk.IntVar()
cuadroapoyo2 = tk.Frame(tab1,height=2, bd=1, relief='sunken')
cuadroapoyo2.pack(side='left',fill='both', padx=5, pady=5)
boton_a2 = tk.Checkbutton(cuadroapoyo2, text='Vinculo 2', variable=a2_flag, command = sel_a2)
boton_a2.pack(anchor=tk.W)
apoyo2tipo = tk.Label(cuadroapoyo2,text = 'Tipo de vinculo', padx = 20, pady=15, state = 'disabled')
apoyo2tipo.pack(anchor=tk.W)
simple2 = tk.Radiobutton (cuadroapoyo2, text='Simple', padx = 30, variable = a2_t, value = 1, command = tipo_a2, state = 'disabled')
simple2.pack(anchor=tk.W)
fijo2 = tk.Radiobutton (cuadroapoyo2, text='Fijo', padx = 30, variable = a2_t, value = 2, command = tipo_a2, state = 'disabled')
fijo2.pack(anchor=tk.W)
empotrado2 = tk.Radiobutton (cuadroapoyo2, text='Empotramiento', padx = 30, variable = a2_t, value = 3, command = tipo_a2, state = 'disabled')
empotrado2.pack(anchor=tk.W)
apoyo2ubicacion = tk.Label(cuadroapoyo2, text = 'Ubicacion:', padx = 20, pady=15, state = 'disabled')
apoyo2ubicacion.pack(anchor=tk.W)
regla_a2=tk.Scale(cuadroapoyo2,orient="horizontal",command=pos_a2,from_=0.0,to=1.0,resolution=0.05, state = 'disabled')
regla_a2.pack(padx =35,anchor=tk.W)
######
###Leyenda
cuadroleyenda = tk.Frame(tab1,height=2, bd=1, relief='sunken')
cuadroleyenda.pack(side='left',fill='both', padx=2, pady=5)
leyendatitulo = tk.Text(cuadroleyenda, height=16)
leyendatitulo.insert (tk.INSERT,"Las condiciones de contorno esenciales son hasta un grado menos que la maxima del funcional,por esto trabajamos hasta las derivadas primeras (giros)\n\nUna sola viga con E e I constantes\n\nUbicacion expresada en x/L." )
leyendatitulo.pack(anchor=tk.W)
##############################
###### RESORTES ######
tab_parent.add(tab2, text = 'Resortes')
######
### K1
k1_t = tk.IntVar() #almacena el tipo de resorte k1
k1_flag = tk.IntVar()
cuadrok1 = tk.Frame(tab2,height=2, bd=1, relief='sunken')
cuadrok1.pack(side='left',fill='both', padx=5, pady=5)
boton_k1 = tk.Checkbutton(cuadrok1, text='K1', variable = k1_flag , command = sel_k1)
boton_k1.pack(anchor=tk.CENTER)
k1tipo = tk.Label(cuadrok1,text = 'Tipo de resorte', padx = 10, pady=15, state = 'disabled')
k1tipo.pack(anchor=tk.W)
lin_1 = tk.Radiobutton (cuadrok1, text='Lineal', padx = 15, variable = k1_t, value = 1, command = tipo_k1, state = 'disabled')
lin_1.pack(anchor=tk.W)
tor_1 = tk.Radiobutton (cuadrok1, text='Torsor', padx = 15, variable =
k1_t, value = 2, command = tipo_k1, state = 'disabled')
tor_1.pack(anchor=tk.W)
k1_pos = tk.Label(cuadrok1, text = 'Ubicacion:', padx = 10, pady=15, state = 'disabled')
k1_pos.pack(anchor=tk.W)
regla_k1=tk.Scale(cuadrok1,orient="horizontal", command=pos_k1,from_=0.0,to=1.0,resolution=0.05, state = 'disabled')
regla_k1.pack(padx =15,anchor=tk.W)
######
### K2
k2_t = tk.IntVar()
k2_flag = tk.IntVar()
cuadrok2 = tk.Frame(tab2,height=2, bd=1, relief='sunken')
cuadrok2.pack(side='left',fill='both', padx=5, pady=5)
boton_k2 = tk.Checkbutton(cuadrok2, text='K2', variable = k2_flag, command = sel_k2)
boton_k2.pack(anchor=tk.CENTER)
k2tipo = tk.Label(cuadrok2,text = 'Tipo de resorte', padx = 10, pady=15, state = 'disabled')
k2tipo.pack(anchor=tk.W)
lin_2 = tk.Radiobutton (cuadrok2, text='Lineal', padx = 15, variable = k2_t, value = 1, command = tipo_k2, state = 'disabled')
lin_2.pack(anchor=tk.W)
tor_2 = tk.Radiobutton (cuadrok2, text='Torsor', padx = 15, variable = k2_t, value = 2, command = tipo_k2, state = 'disabled')
tor_2.pack(anchor=tk.W)
k2_pos = tk.Label(cuadrok2, text = 'Ubicacion:', padx = 10, pady=15, state = 'disabled')
k2_pos.pack(anchor=tk.W)
regla_k2=tk.Scale(cuadrok2,orient="horizontal", command=pos_k2,from_=0.0,to=1.0,resolution=0.05, state = 'disabled')
regla_k2.pack(padx =15,anchor=tk.W)
######
### K equivalentes
cuadroequi = tk.Frame(tab2,height=2, bd=1, relief='sunken')
cuadroequi.pack(side='left',fill='both', padx=5, pady=5)
equititulo = tk.Label(cuadroequi,text = 'Resortes equivalentes')
equititulo.pack(anchor=tk.W)
######
### Kleq
cuadrokleq = tk.Frame(cuadroequi,height=2, bd=1, relief='sunken')
cuadrokleq.pack(side='top',fill='both', padx=5, pady=5)
kleq_flag = tk.IntVar()
boton_kleq = tk.Checkbutton(cuadrokleq, text='Lineal Equivalente (Parametros Kt,d)', variable=kleq_flag, command = sel_kleq)
boton_kleq.pack(anchor=tk.W)
kleq_pos = tk.Label(cuadrokleq, text = 'Ubicacion:', padx = 10, pady=8, state = 'disabled')
kleq_pos.pack(anchor=tk.CENTER)
regla_kleq=tk.Scale(cuadrokleq,orient="horizontal", command=pos_kleq,from_=0.0,to=1.0,resolution=0.05, state = 'disabled')
regla_kleq.pack(padx =18,anchor=tk.CENTER)
######
### Kteq
cuadrokteq = tk.Frame(cuadroequi,height=2, bd=1, relief='sunken')
cuadrokteq.pack(side='bottom',fill='both', padx=5, pady=5)
kteq_flag = tk.IntVar()
boton_kteq = tk.Checkbutton(cuadrokteq, text='Torsor Equivalente (Parametros Kl,h)', variable=kteq_flag, command = sel_kteq)
boton_kteq.pack(anchor=tk.W)
kteq_pos = tk.Label(cuadrokteq, text = 'Ubicacion:', padx = 10, pady=8, state = 'disabled')
kteq_pos.pack(anchor=tk.CENTER)
regla_kteq=tk.Scale(cuadrokteq,orient="horizontal", command =pos_kteq,from_=0.0,to=1.0,resolution=0.05, state = 'disabled')
regla_kteq.pack(padx =18,anchor=tk.CENTER)
##############################
###### Cargas ext ######
tab_parent.add(tab3, text = 'Cargas externas')
cuadroPqM = tk.Frame(tab3,height=2)
cuadroPqM.pack(side='top',fill='both', padx=2, pady=2)
cuadrotexto = tk.Frame(tab3,height=2, bd=1, relief='sunken')
cuadrotexto.pack(side='top',fill='both', padx=2, pady=2)
titulotexto = tk.Text(cuadrotexto, height=4)
titulotexto.insert (tk.INSERT," Los calculos se realizan con P, q(x),y M en direccion positiva segun la terna de la mano derecha, ubicada en el extremo izquierdo del sistema. Cuando la carga externa sea negativa, sustituirla por su opuesto en el resultado obtenido.")
titulotexto.pack(anchor=tk.W)
######
### P
cuadroP = tk.Frame(cuadroPqM,height=2, bd=1, relief='sunken')
cuadroP.pack(side='top',fill='both', padx=2, pady=2)
P_flag = tk.IntVar()
boton_P = tk.Checkbutton(cuadroP, text="P ", variable=P_flag, command = sel_P)
boton_P.pack(side='left')
P_pos = tk.Label(cuadroP, text = 'Ubicacion:', padx = 30, pady=8, state = 'disabled')
P_pos.pack(side='left')
regla_P=tk.Scale(cuadroP,orient="horizontal", command=pos_P,from_=0.0,to=1.0,resolution=0.05, state = 'disabled')
regla_P.pack(padx =18,anchor=tk.N)
######
### q(x)
cuadrocarga = tk.Frame(cuadroPqM,height=2, bd=1,relief='sunken')
cuadrocarga.pack(side='top',fill='both', padx=2, pady=2)
cuadroq = tk.Frame(cuadrocarga,height=2)
cuadroq.pack(side='left')
q_flag = tk.IntVar()
boton_q = tk.Checkbutton(cuadroq, text= 'q(x)', variable=q_flag, command = sel_q)
boton_q.pack(anchor=tk.W)
cuadroqi = tk.Frame(cuadrocarga,height=2)
cuadroqi.pack(side='top',fill='both')
cuadroqf = tk.Frame(cuadrocarga,height=2)
cuadroqf.pack(side='top',fill='both')
q_t=tk.IntVar()
q_cte = tk.Radiobutton (cuadroqi, text='Constante: q(x) = q0', padx = 15, variable = q_t, value = 1, command = tipo_q, state = 'disabled')
q_cte.pack(side='left')
regla_qi=tk.Scale(cuadroqi,orient="horizontal", command=pos_qi,from_=0.0,to=1.0,resolution=0.05, state = 'disabled')
regla_qi.pack(padx =43,side='right')
q_ini = tk.Label(cuadroqi, text = 'Inicio:', padx = 30, pady=8, state = 'disabled')
q_ini.pack(side='right')
q_var = tk.Radiobutton (cuadroqf, text='Variable: q(x) = (q2-q1)/x2-x1', padx = 15, variable = q_t, value = 2, command = tipo_q, state = 'disabled')
q_var.pack(side='left')
regla_qf=tk.Scale(cuadroqf,orient="horizontal", command=pos_qf,from_=0.0,to=1.0,resolution=0.05, state = 'disabled')
regla_qf.pack(padx =35,side='right')
q_fin = tk.Label(cuadroqf, text = 'Final:', padx = 42, pady=8, state = 'disabled')
q_fin.pack(side='right')
######
### M
cuadroM = tk.Frame(cuadroPqM,height=2, bd=1, relief='sunken')
cuadroM.pack(side='top',fill='both', padx=2, pady=2)
M_flag = tk.IntVar()
boton_M = tk.Checkbutton(cuadroM, text="M", variable=M_flag, command = sel_M)
boton_M.pack(side='left')
M_pos = tk.Label(cuadroM, text = 'Ubicacion:', padx = 30, pady=8, state = 'disabled')
M_pos.pack(side='left')
regla_M=tk.Scale(cuadroM,orient="horizontal", command=pos_M,from_=0.0,to=1.0,resolution=0.05, state = 'disabled')
regla_M.pack(padx =18,anchor=tk.N)
tab_parent.pack(expand=1, fill='both')
##############
### Botones Ventana
#Activeforeground es el color del texto al ser presionado
#Activebackground es el color del boton al ser presionado
#fg es el color del texto
#bg es el color del fondo
#Boton resolver. Inicia deshabilitado, habilitandose cuando se cumplan las condiciones minimas para poder resolver el ejercicio
resol = tk.Button(root, text = 'RESOLVER',fg='green',activeforeground='black',activebackground='green', command = resolver_ejercicio, width=80, state = 'disabled')
resol.pack(anchor=tk.CENTER)
#Boton de salida. Cierra la aplicacion con el comando 'quit'
salida = tk.Button(root, text='SALIR',fg='red',activeforeground='black',activebackground='red',command=quit, width=39)
salida.pack(side=tk.LEFT)
#Boton de reinicio. Letra naranja fondo gris, al ser presionado se pone de color naranja con letra negra. Realiza el comando reiniciar_programa()
resetear = tk.Button(root, text = 'REINICIAR',fg='orange',activeforeground='black',activebackground='orange', command = reiniciar_programa, width=40)
resetear.pack(side=tk.RIGHT)
root.mainloop()Compartir
Continuar navegando
Materiales relacionados
Preguntas relacionadas
Compartir