CÓDIGO DESARROLLADO EN LENGUAJE PYTHON

January 23, 2021

[ ]: import sys
import math
import self as self
from PyQt5 import *
from PyQt5 import uic
from PyQt5.QtWidgets import*

class gg(QMainWindow):
def __init__(self):
super(gg, self).__init__()
uic.loadUi("clear.ui", self)

#botones

self.btncalcular.clicked.connect(self.calcular)
self.btncalcular2.clicked.connect(self.calcular2)
self.btncalcular3.clicked.connect(self.calcular3)

#funciones

def calcular(self):
Q=self.txtentrada1.toPlainText()
b=self.txtentrada2.toPlainText()
z=self.txtentrada3.toPlainText()
n=self.txtentrada4.toPlainText()
s=self.txtentrada5.toPlainText()

Q = float(Q)
b = float(b)
z = float(z)
n = float(n)
s = float(s)

# tirante

def f(x, b, z, Q, s, n):

A = b * x + z * (x ** 2)

1
 P = b + 2 * x * ((1 + z ** 2) ** (1 / 2))
f = (A ** (5 / 3)) / (P ** (2 / 3)) - (Q * n) / (s ** (1 / 2))
return f

# Definiendo la derivada de la Funcion

def df(x, b, z):

A = b * x + z * (x ** 2)
P = b + 2 * x * ((1 + z ** 2) ** (1 / 2))
df = (1 / (P ** (2 / 3))) * ((5 / 3) * (A ** (2 / 3)) * (b + 2 * x *
,→z)) + (A ** (5 / 3)) * (

(-2 / 3) * (P ** (-5 / 3))) * 2 * ((1 + (z ** 2)) ** (1 / 2))

return df

# Método de Newton Raphson

def NewtonRaphson(x):
error = 1
tol = 1e-4
while error >= tol:
xi = x - f(x, b, z, Q, s, n) / df(x, b, z)
error = abs((xi - x) / xi)
x = xi
return xi

y = round(NewtonRaphson(1), 4)

self.txtsalida1.setText(str(y))

# area hidraulica

def area(y, b, z):

A = y * (b + z * y)
return A

a = round(area(y, b, z), 4)

self.txtsalida2.setText(str(a))

# espejo de agua

def espejo(y, b, z):

T = b + 2 * z * y
return T

e = round(espejo(y, b, z), 4)

2
self.txtsalida3.setText(str(e))

# perimetro mojado

def perimetro(y, b, z):

P = b + 2 * y * ((1 + z ** 2) ** (1 / 2))
return P

pe = round(perimetro(y, b, z), 4)

self.txtsalida6.setText(str(pe))

# radio hidraulico

def radio(a, pe):

R = a / pe
return R

r = round(radio(a, pe), 4)

self.txtsalida7.setText(str(r))

# velocidad

def veloc(n, r, s):

V = (1 / n) * (r ** (2 / 3)) * (s ** (1 / 2))
return V

v = round(veloc(n, r, s), 4)

self.txtsalida8.setText(str(v))

# numero de froud

def Froud(a, e, v):

DH = a / e
Fr = v / ((9.807 * DH) ** (1 / 2))
return Fr

fr = round(Froud(a, e, v), 4)

self.txtsalida4.setText(str(fr))

# tipo de flujo

f1 = str("supercrítico")
f2 = str("crítico")

3
 f3 = str("subcrítico")

if fr > 1:
fl = f1
if fr == 1:
fl = f2
if fr < 1:
fl = f3

self.txtsalida5.setText(fl)

# para la ventana 2

def calcular2(self):
Qc = self.txtentrada11.toPlainText()
Dc = self.txtentrada12.toPlainText()
nc = self.txtentrada13.toPlainText()
sc = self.txtentrada14.toPlainText()

Qc = float(Qc)
Dc = float(Dc)
nc = float(nc)
sc = float(sc)

# tirante

def f(y, Dc, Qc, sc, nc):

Ac = ((Dc ** 2) / 8) * (y - math.sin(y))
Pc = y * Dc / 2
f = (Ac ** (5 / 3)) / (Pc ** (2 / 3)) - (Qc * nc) / (sc ** (1 / 2))
return f

# Definiendo la derivada de la Funcion

def df(y, Dc):

Ac = ((Dc ** 2) / 8) * (y - math.sin(y))
Pc = y * Dc / 2
df = (1 / (Pc ** (2 / 3))) * ((5 / 3) * (Ac ** (2 / 3)) * (((Dc **
,→2) / 8) * (1 - math.cos(y)))) + (Ac ** (5 / 3)) * ((-2 / 3) * (Pc ** (-5 /

,→3))) * (Dc / 2)

return df

# Método de Newton Raphson

def NewtonRaphson(y):
error = 1
tol = 1e-4

4
 while error >= tol:
yi = y - f(y, Dc, Qc, sc, nc) / df(y, Dc)
error = abs((yi - y) / yi)
y = yi
return yi

aa=NewtonRaphson(1)

#tirante

def tirante(aa,Dc):
yc = (Dc / 2) * (1 - math.cos(aa / 2))
return yc
ti=round(tirante(aa, Dc),4)

self.txtsalida11.setText(str(ti))

# area hidraulica

def areac(aa,Dc):
Arc=((Dc**2)/8)*(aa-math.sin(aa))
return Arc
ac=round(areac(aa, Dc),4)

self.txtsalida12.setText(str(ac))

# espejo de agua

def espejoc(aa,Dc):
Tcc=(math.sin(aa/2))*Dc
return Tcc
ec=round(espejoc(aa, Dc),4)

self.txtsalida13.setText(str(ec))

#perimetro mojado

def perimetroc(aa,Dc):
Pcc = aa * Dc / 2
return Pcc
pc=round(perimetroc(aa, Dc),4)

self.txtsalida16.setText(str(pc))

# radio hidraulico

def radioc(ac,pc):

5
 Rcc=ac/pc
return Rcc
rc=round(radioc(ac, pc),4)

self.txtsalida17.setText(str(rc))

# velocidad

def velocidadc(nc,rc,sc):
Vcc=(1/nc)*(rc**(2/3))*(sc**(1/2))
return Vcc
vc=round(velocidadc(nc,rc,sc),4)

self.txtsalida18.setText(str(vc))

#Numero de froud

def froudc(ac,ec,vc):
DH = ac / ec
frcc = vc / ((9.807 * DH) ** (1 / 2))
return frcc
frc=round(froudc(ac,ec,vc),4)

self.txtsalida14.setText(str(frc))

# tipo de flujo

f1c = str("supercrítico")
f2c = str("crítico")
f3c = str("subcrítico")

if frc > 1:
flc = f1c
if frc == 1:
flc = f2c
if frc < 1:
flc = f3c

self.txtsalida15.setText(flc)

# para la ventana 3

def calcular3(self):
Qp = self.txtentrada21.toPlainText()
Tp = self.txtentrada22.toPlainText()
np = self.txtentrada23.toPlainText()
sp = self.txtentrada24.toPlainText()

6
 Qp = float(Qp)
Tp = float(Tp)
np = float(np)
sp = float(sp)

# tirante

def f(yp, Qp, Tp, np, sp):

Ap = (2 / 3) * Tp * yp
Pp = Tp + (8 * (yp ** 2)) / (3 * (Tp ** 2))
f = (Ap ** (5 / 3)) / (Pp ** (2 / 3)) - (Qp * np) / (sp ** (1 / 2))
return f

# Definiendo la derivada de la Funcion

def df(yp, Tp):

Ap = (2 / 3) * Tp * yp
Pp = Tp + (8 * (yp ** 2)) / (3 * (Tp ** 2))
df = (1 / (Pp ** (2 / 3))) * ((5 / 3) * (Ap ** (2 / 3)) * ((2 / 3) *
,→Tp)) + (Ap ** (5 / 3)) * ((-2 / 3) * (Pp ** (-5 / 3))) * ((16 * yp * Tp - 8 *

,→(yp ** 2)) / (3 * (Tp ** 2)))

return df

# Método de Newton Raphson

def NewtonRaphson(yp):
error = 1
tol = 1e-6
while error >= tol:
ypi = yp - f(yp, Qp, Tp, np, sp) / df(yp, Tp)
error = abs((ypi - yp) / ypi)
yp = ypi
return ypi

# tirante
ypp = round(NewtonRaphson(1), 4)

self.txtsalida21.setText(str(ypp))

# Area hidraulica

def areap(Tp, ypp):

App=(2/3)*Tp*ypp
return App

ap = round(areap(Tp, ypp), 4)

7
self.txtsalida22.setText(str(ap))

# Perimetro mojado

def perimetrop(Tp, ypp):

Ppp = Tp + (8 * (ypp ** 2)) / (3 * (Tp ** 2))
return Ppp

pp = round(perimetrop(Tp, ypp), 4)

self.txtsalida25.setText(str(pp))

# Radio Hidraulico

def radiop(ap, pp):

Rpp=ap/pp
return Rpp

rp = round(radiop(ap, pp), 4)

self.txtsalida26.setText(str(rp))

# Velocidad

def velop(np, rp, sp):

Vpp=(1/np)*(rp**(2/3))*(sp**(1/2))
return Vpp

vp = round(velop(np, rp, sp), 4)

self.txtsalida27.setText(str(vp))

# Numero de Froud

def Frp(ap, Tp, vp):

DH = ap / Tp
frp = vp / ((9.807 * DH) ** (1 / 2))

return frp

fp = round(Frp(ap, Tp, vp), 4)

self.txtsalida23.setText(str(fp))

# tipo de flujo

8
 f1p = str("supercrítico")
f2p = str("crítico")
f3p = str("subcrítico")

if fp > 1:
flp = f1p
if fp == 1:
flp = f2p
if fp < 1:
flp = f3p

self.txtsalida24.setText(flp)

if __name__ == "__main__":
pass
app=QApplication(sys.argv)
mainWin = gg()
mainWin.show()
sys.exit(app.exec_())