hidrauliproject.files.wordpress.com€¦ · web viewprint("opción [1]:sección trapecial de...

import math

## Definición de funciones para canal trapecial

def Area_tr (b,h,m): A = float(h*(b+m*h)) return A

def PM_tr (b,h,m): Pm=float(b+(2*h)*((1+m**2)**0.5)) return Pm

def Radioh_tr (b,h,m): Rh = float (Area_tr (b,h,m)/PM_tr(b,h,m)) return Rh

def Velocidad_tr (Q,b,h,m): U_tr = float (Q/Area_tr(b,h,m)) return U_tr

def Energia_tr (Q,b,h,m): E = float (h+(Velocidad_tr(Q,b,h,m))**2/(2*9.81)) return E

def Ji_tr (Q,b,h,m,n): Ji = float (((Velocidad_tr(Q,b,h,m))**2*n**2)/(Radioh_tr(b,h,m))**(4/3)) return Ji

def Ancho_sup_tr (b,h,m): l = float(b + 2*m*h) return l

def Momenta_rec (Q,b,h):

M = Q**2 / (9.81*b*h) + h**2 * b / 2 return M

def Momenta_tr (Q,b,h,m,d): W = b*h nA = m/3*(h+d)**3 + b/2 * (h+d)**2 if m > 0: M = Q**2 / (9.81* W) + nA return M

## Definición de funciones para canal cirular

def Area_ci (D,teta): A = float(((D**2)/8)*(teta-math.sin(teta))) return A

def PM_ci (D,teta): Pm = float(teta*D)/2 return Pm

def Radioh_ci (D,teta):Rh = float(Area_ci(D,teta)/PM_ci(D,teta))return Rh

def Velocidad_ci (Q,D,teta):

U_ci = float (Q/Area_ci(D,teta))return U_ci

def Energia_ci (Q,D,teta,h):E = float (h+(Velocidad_ci(Q,D,teta)**2/(2*9.81)))return E

def Ji_ci (Q,D,teta,n):Ji = float ((Velocidad_ci(Q,D,teta))**2*n**2/(Radioh_ci(D,teta))**(4/3))return Ji

def Ancho_sup_ci (D, teta): l = math.sin(teta/2) * D return ldef teta_ci (D,h): teta = 2*math.acos(1-2*h/D) return teta

## Otras funciones úitles

def Largo_R (hR,hT): L_R = 13* (hR-hT) return L_R

# EULERdef dh_dx (Q,b,h,m,n,i): dh_dx = (i - Ji_tr(Q,b,h,m,n)) / (1 - ((Q**2*Ancho_sup_tr(b,h,m))/ (9.81 * (Area_tr(b,h,m))**3))) return dh_dx

def dh_dx_ci (Q,D,teta,n,i): dh_dx = (i- Ji_ci(Q,D,teta,n)) / (1-((Q**2*Ancho_sup_ci(D,teta))/ (9.81 * (Area_ci(D,teta))**3))) return dh_dx

while True: print("Elija opción de sección del canal: ") print("Opción [1]:Sección trapecial de ancho b y taludes m [m] / Sección rectangular de ancho b [m] y asignarle el valor 0 a los taludes m ") print("Opción [2]:Sección circular de diámetro D [m] (Esta opción no será necesaria para este problema, ya que se tiene un tramo de sección rectangular y otro de sección trapecial) ") elección=input()

if int (elección)==1: print ("Sección trapecial de ancho b y taludes m") # while True: # h = float(input("Ingrese el valor de la altura [m]: ")) # if h < 0: # print ("Ingrese altura válida") # else: # break while True: b = float(input("Ingrese el valor de la base [m]: ")) if b < 0: print ("Ingrese base valida") else: break m = float(input("Ingrese el valor de los taludes [m]:")) while True: Q=float(input("Ingrese el valor del caudal que circula por el cauce [m^3/s]: "))

if Q <= 0: print ("Ingrese caudal que circula válido") else: break while True: n = float(input("Ingrese el valor de la rugosidad del canal: ")) if n < 0: print ("Ingrese rugosidad válida") else: break i = float (input ("Ingrese el valor de la pendiente de fondo: ")) Largo = float (input ("ingrese largo total del tramo [m]: "))

''' print ("El valor del área de la sección transversal es " +str(Area_tr(b,h,m))+"[m^2]") print ("El valor del perímetro mojado de la sección transversal es "+str(PM_tr(b,h,m)) + "[m]") print ("El valor del radio hidraúlico de la sección transversal es "+str(Radioh_tr(b,h,m))+"[m]") print ("El valor de la velocidad de la sección transversal es "+str(Velocidad_tr(Q,b,h,m))+"[m/s]") print ("El valor de la energía de la sección transversal es "+str(Energia_tr(Q,b,h,m))+"[m/s]") print ("El valor de Ji de la sección transversal es "+str(Ji_tr(Q,b,h,m,n))) '''

lista = [.0001] lista_1 = [0] k = .0001 z= 0 for w in (lista_1): if round ((Q**2 * Ancho_sup_tr(b,lista[w],m))/(9.81 * (Area_tr(b,lista[w],m))**3),3) > 1: k+=0.0001 z+=1 # print ("iteración número " + str(z)) # print (str ((Q**2 * Ancho_sup_tr(b,lista[w],m))/(9.81 * (Area_tr(b,lista[w],m))**3))) lista.append (k) lista_1.append (z)

else: hc = round (k,2) print ("La altura crítica es: " + str (hc) + "[m]") break

lista = [.0001] lista_1 = [0] k = .0001 z= 0

for w in (lista_1): if round (Velocidad_tr(Q,b,lista[w],m),3) > round((Radioh_tr(b,lista[w],m))**(2/3)*i**(0.5)/n,3): k+=0.0001 z+=1 # print ("iteración número " + str(z)) # print ("caudal = " + str(Q) + ", Manning = " +str((Radioh_tr(b,lista[w],m))**(2/3)*i**(0.5)/n)) lista.append (k) lista_1.append (z)

else: hn = round (k,2) print ("La altura normal es: " + str (hn) + "[m]") break

print("Elija un método para calcular el eje hidráulico:") print("Opción [1]:Método directo por etapas ") print("Opción [2]:Método de etapas fijas ") print("Opción [3]:Método de Euler ") print("Opción [4]:Método de Runge-Kutta de cuarto orden ")

elección2=input() if int(elección2)==1: print("Método directo por etapas" ) print ("El delta_h que se utilizará es 0.01 [m]") h_o = float (input ("ingrese el valor de la altura inicial [m]: ")) # h_f = float (input ("ingrese el valor de la altura final del tramo (aquella que está más aguas abajo) [m]: ")) delta_h= 0.01

################################ METODO DIRECTO POR ETAPAS ################################

z = 0 x_T = 0 x_R = 0 h_R = h_o

print("Se encuentra después de un ensanche?") print("Opción [1]: Sí ") print("Opción [2]: No ") elección3=input() if int(elección3)==1: print ("Asumiremos que la altura conjugada de río es igual a la normal") d = float (input ("Cuánto es la bajada de grada [m]?"))

lista = [.001] lista_1 = [0] k = .001 z= 0 for w in (lista_1): if round (Momenta_tr(Q,b,lista[w],m,0),2) > round (Momenta_tr(Q,b,1.46,m,0),2): print (Momenta_tr(Q,b,lista[w],m,0)) # print (Momenta_tr(Q,b,1.46,m,0)) # print ("----------------------------") k+=0.001 z+=1 # print ("iteración número " + str(z)) # print (str ((Q**2 * Ancho_sup_tr(b,lista[w],m))/(9.81 * (Area_tr(b,lista[w],m))**3))) lista.append (k) lista_1.append (z)

else: h_T = round (k,2) print ("La altura de torrente conjugada es " + str(h_T)) print ("Así, se tiene un resalto hidráulico de un largo de " + str(round(13*(hn-k),2))) break

print ("No es necesario calcular el eje hidráulico, puesto que este llega a altura normal, como se mencionó anteriormente") break # h_T = h_f

print ("Tramo recorrido [m] | Altura río [m] | Altura torrente [m]") while True:

# Método comienza a resolver aguas abajo '''

if hn < hc and h_f > hc and round (h_o,2) <= round(hc,2): # Suponiendo que hay resalto -> h_o < hc if round (h_o,2) <= hc and round (h_o,2) != round(hn,2): z+=1 # print (str(z)) # print (str(round(h_o,2))) # print (str(h_R))

# print ("PARTE POR TORRENTE") # print ("la altura en este punto es " +str(h_o) + "[m]") # print ("el área en este punto es " +str(Area_tr(b,h_o,m)) + "[^2]") # print ("El perimetro mojado en este punto es " +str(PM_tr(b,h_o,m)) + "[m]") # print ("el Radio hidráulico en este punto es " +str(Radioh_tr(b,h_o,m)) +"[m]") # print ("La velocidad en este punto es " +str(Velocidad_tr(Q,b,h_o,m)) + "[m/s]") # print ("La energia es " +str (Energia_tr(Q,b,h_o,m))) # print ("La pendiente de la línea de energía Ji en esta iteración es " +str(Ji_tr(Q,b,h_o,m,n))) Jm = (Ji_tr(Q,b,h_o,m,n) + Ji_tr(Q,b,h_o-delta_h,m,n))/2 #print ("Valor de Jm en esta iteración es "+str(Jm)) delta_x = abs((Energia_tr(Q,b,h_o,m) - Energia_tr(Q,b,h_o-delta_h,m))/(i-Jm)) #print ("Distancia avanzada en esta iteración es de " + str(delta_x) + "[m]") x_T+=delta_x # print ("X_T tiene un valor de " + str(x_T)) L_R = Largo_R(h_R,h_o) # print ("Distancia total avanzada: " +str(x_T) + "[m]") print ("| h | A | Pm | Rh | U | E | Ji | Jm | delta_x | x | hR | LR |") print ("| " +str(round(h_o,2)) + " | " +str(round(Area_tr(b,h_o,m),2))) #print ("El largo del resalto actual es de " + str(L_R))

if round(h_o,2) < round(hn,2): h_o += delta_h h_R -= delta_h #print ("la altura de río conjugada es: " + str(h_R))

elif round(h_o,2) > round(hn,2): h_o -= delta_h h_R += delta_h #print ("la altura de río conjugada es: " + str(h_R)) else: h_o = hn print ("Se llegó a altura normal!!: " + str(h_o) + "[m]") L_R = Largo_R(h_R,h_o)

if (h_f) > hc:

''' ''' print ("PARTE POR RIO")

print ("la altura en este punto es " +str(h_f) + " [m]") print ("el área en este punto es " +str(Area_tr(b,h_f,m)) + " [m^2]") print ("El perimetro mojado en este punto es " +str(PM_tr(b,h_f,m)) + " [m]") print ("el Radio hidráulico en este punto es " +str(Radioh_tr(b,h_f,m)) +" [m]") print ("La velocidad en este punto es " +str(Velocidad_tr(Q,b,h_f,m)) + " [m/s]") print ("La energia es " +str (Energia_tr(Q,b,h_f,m)))

print ("La pendiente de la línea de energía Ji en esta iteración es " +str(Ji_tr(Q,b,h_f,m,n))) ''' ''' Jm = (Ji_tr(Q,b,h_f,m,n) + Ji_tr(Q,b,h_f-delta_h,m,n))/2

#print ("Valor de Jm en esta iteración es "+str(Jm)) delta_x = 0 delta_x = abs((Energia_tr(Q,b,h_f,m) - Energia_tr(Q,b,h_f-delta_h,m))/(i-Jm))

#print ("Distancia avanzada en esta iteración es de " + str(delta_x) + " [m]") x_R+=delta_x print ("Distancia total avanzada: " +str(x_R) + "[m]") L_R = Largo_R(h_f,h_o) print ("Largo del resalto: " + str(L_R))

if round(h_f,2) < hn and round (h_f,2) != h_R: h_f += delta_h

elif round(h_f,2) > hn and round (h_f,2) != h_R: h_f -= delta_h

if round((x_T + x_R+ L_R),0) >= round(Largo,0):

print ("No se alcanza altura normal. La altura de torrente es de " + str (h_o) + "[m]") print ("Altura de río conjugada: " + str(h_f)) print ("La distancia a la cual esta el resalto hidráulico, desde el incio del canal es: " +str(x_T)) print ("El largo del resalto es de " + str(L_R)) print ("El largo que hay después del resalto hidráulico es de " + str(x_R)) break

elif round((x_T + x_R+ L_R),0) < round(Largo,0) and round(h_o,2) == round(hn,2) and round((h_f),2) == round(h_R,2): x_N = Largo - (x_R+ L_R) print ("Se alcanza altura normal a los " + str (x_T) + "[m]") print ("Altura de torrente conjugada: " + str(h_o)) print ("Altura de río conjugada: " + str(h_f)) print ("La distancia a la cual esta el resalto hidráulico, desde el incio del canal es: " +str(x_N)) print ("El largo del resalto es de " + str(L_R)) print ("El largo que hay después del resalto hidráulico es de " + str(x_R)) break

'''

# Método comienza a resolver aguas arriba

'''

if hn > hc: # Suponiendo que hay resalto -> h_o < hc if round (h_f,2) >= hc and round (h_f,2) != round(hn,2) and h_o <= hc: z+=1 # print (str(z)) # print (str(round(h_f,2))) # print (str(h_R)) delta_x = 0

# print ("ALTURA DE RIO") # print ("la altura en este punto es " +str(h_f) + "[m]") # print ("el área en este punto es " +str(Area_tr(b,h_f,m)) + "[^2]") # print ("El perimetro mojado en este punto es " +str(PM_tr(b,h_f,m)) + "[m]") # print ("el Radio hidráulico en este punto es " +str(Radioh_tr(b,h_f,m)) +"[m]") # print ("La velocidad en este punto es " +str(Velocidad_tr(Q,b,h_f,m)) + "[m/s]") # print ("La energia es " +str (Energia_tr(Q,b,h_f,m))) # print ("La pendiente de la línea de energía Ji en esta iteración es " +str(Ji_tr(Q,b,h_f,m,n))) Jm = (Ji_tr(Q,b,h_f,m,n) + Ji_tr(Q,b,h_f-delta_h,m,n))/2 #print ("Valor de Jm en esta iteración es "+str(Jm)) delta_x = abs((Energia_tr(Q,b,h_f,m) - Energia_tr(Q,b,h_f-delta_h,m))/(i-Jm)) #print ("Distancia avanzada en esta iteración es de " + str(delta_x) + "[m]") x_R+=delta_x # print ("Distancia total avanzada: " +str(x_R) + "[m]") # print ("altura final: " + str(h_f)) #print ("El largo del resalto actual es de " + str(L_R))

if round(h_f,2) < round (hn,2): h_f += delta_h h_T -= delta_h

elif round(h_f,2) > round (hn,2): h_f -= delta_h h_T += delta_h else: h_f = hn print ("Se llegó a altura normal!!: " + str(h_f) + "[m]") L_R = Largo_R(h_R,h_o)

if (h_o) < hc and round(h_o,2) != round (h_T,2) :

print ("ALTURA DE TORRENTE") # print ("la altura en este punto es " +str(h_o) + " [m]") # print ("el área en este punto es " +str(Area_tr(b,h_o,m)) + " [m^2]") # print ("El perimetro mojado en este punto es " +str(PM_tr(b,h_o,m)) + " [m]") # print ("el Radio hidráulico en este punto es " +str(Radioh_tr(b,h_o,m)) +" [m]") # print ("La velocidad en este punto es " +str(Velocidad_tr(Q,b,h_o,m)) + " [m/s]") # print ("La energia es " +str (Energia_tr(Q,b,h_o,m)))

#print ("La pendiente de la línea de energía Ji en esta iteración es " +str(Ji_tr(Q,b,h_o,m,n))) Jm = (Ji_tr(Q,b,h_o,m,n) + Ji_tr(Q,b,h_o-delta_h,m,n))/2

#print ("Valor de Jm en esta iteración es "+str(Jm)) delta_x = 0 delta_x = abs((Energia_tr(Q,b,h_o,m) - Energia_tr(Q,b,h_o-delta_h,m))/(i-Jm))

#print ("Distancia avanzada en esta iteración es de " + str(delta_x) + " [m]") x_T+=delta_x print ("Distancia total avanzada: " +str(x_T) + "[m]") print ("altura final: " + str(h_o))

if round(h_o,2) < hn and round (h_o,2) != h_T: h_o += delta_h

L_R = Largo_R(h_f,h_o)

if (x_T + x_R+ L_R) >= Largo: print ("No se alcanzó altura normal. La altura de Rio conjugada es " + str (h_f)) print ("La altura de río torrente es: " + str(h_o)) print ("El resalto comienza a una distancia de " + str(x_T)) print ("El resalto tiene un largo de " + str (L_R)) print ("La distancia que hay después del resalto es de " + str (x_R)) break

elif round((x_T + x_R+ L_R),0) < round(Largo,0) and round(h_f,2) == round(hn,2) and (round(h_o,2) == round(h_T,2) or round (h_o,2) == round(hc,2)):

x_N = Largo - (x_T+ L_R) print ("Se alcanza altura normal a los " + str (x_T) + "[m]") print ("Altura de torrente conjugada: " + str(h_o)) print ("Altura de río conjugada: " + str(h_f)) print ("La distancia que hay desde el resalto hasta qeu se alcanza hn es " +str(x_N)) print ("El largo del resalto es de " + str(L_R)) print ("El largo que hay después del resalto hidráulico es de " + str(x_R)) break '''

if round(h_o,2) <= round(hc,2) and hn < hc: Jm = (Ji_tr(Q,b,h_o,m,n) + Ji_tr(Q,b,h_o-delta_h,m,n))/2 delta_x = abs((Energia_tr(Q,b,h_o,m) - Energia_tr(Q,b,h_o-delta_h,m))/(i-Jm)) x_T+=delta_x

if round(h_o,2) < round(hn,2): h_o += delta_h #print ("la altura de río conjugada es: " + str(h_R))

if round(h_o,2) > round(hn,2): h_o -= delta_h if round (h_o,2) == round (h_f,2) and x_T <= Largo: print ("Se llegó a la altura final que se necesitaba") print ("La distancia necesaria fue de " + str(x_T)) break elif x_T > Largo: print ("Se alcanzó el largo total del tramo") print ("La altura que se alcnazó es de " + str(h_o)) break

if round(h_o,2) >= round(hc,2) and round(hn,2) > round(hc,2): Jm = (Ji_tr(Q,b,h_o,m,n) + Ji_tr(Q,b,h_o-delta_h,m,n))/2

delta_x = abs((Energia_tr(Q,b,h_o,m) - Energia_tr(Q,b,h_o-delta_h,m))/(i-Jm)) x_R+=delta_x

if round(h_o,2) < round(hn,2): h_o += delta_h #print ("la altura de río conjugada es: " + str(h_R))

if round(h_o,2) > round(hn,2): h_o -= delta_h

lista = [.0001] lista_1 = [0] k = .0001 z= 0 for w in (lista_1): if round (Momenta_rec(Q,b,lista[w]),2) > round (Momenta_rec(Q,b,h_o),2): k+=0.0001 z+=1 # print ("iteración número " + str(z)) # print (str ((Q**2 * Ancho_sup_tr(b,lista[w],m))/(9.81 * (Area_tr(b,lista[w],m))**3))) lista.append (k) lista_1.append (z)

else: h_T = round (k,2) break

if (x_R + 13*(h_o - h_T)) <= Largo: print (" " +str(x_R) + " " + str(h_o) + " " + str(h_T))

if round (h_o,2) == round (hn,2) and (x_R + 13*(x_R - h_T)) <= Largo: print ("Se llegó a la altura final que se necesitaba") print ("La distancia necesaria fue de " + str(x_T)) print break elif (x_R + 13*(h_o - h_T)) > Largo: print ("Se alcanzó el largo total del tramo") print ("Tramo antes del resalto: " + str(round(Largo - 13*(h_o - h_T) - (x_R-delta_x),2)) + "[m]") print ("Tramo despúes del resalto [m] | Altura río [m] | Altura torrente [m]") print (" " +str((x_R-delta_x)) + " " + str(round(h_o-delta_h,2)) + " " + str(round(h_T,2))) print ("Largo del resalto: " + str(round(13*(h_o - h_T),2)) + "[m]")

break

################################ METODO DIRECTO POR ETAPAS ################################ ''' -------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------

'''

################################# METODO POR ETAPAS FIJAS ##################################

elif int(elección2)==2: print("Método por etapas fijas" )

delta_x = float(input("ingrese la distancia que se avanzará en cada iteración [m]: " )) h1 = float(input("ingrese altura inicial [m]: ")) z_1 = Largo * i z_2 = (Largo - delta_x) * i

cota1 = z_1 + h_1

h_R = h1 h_T = 0 x_T = 0 x_R = 0 while True:

if hc > hn: if round (h_1,2) == round(hn,2): delta_h2 = 0.01 h2 = h_1 + 1 J1 = Ji_tr(Q,b,h1,m,n) J2 = Ji_tr(Q,b,h2,m,n)

B2 = z_2 + h_2 + (Velocidad_tr(Q,b,h2,m))**2 /2 B1 = cota1 + Velocidad_tr(Q,b,h1,m) B_2_ = B_1 + delta_x* (J1 + J2) / 2

if round(B2,2) != round(B_2_,1): h_2_ = h2 - delta_h2 else: print (( "h_2}}"))

''' --------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------- '''

elif int(elección2)==3: print("Método de Euler" )

delta_x = float(input("ingrese la distancia que se avanzará en cada iteración [m]: " )) print ("En caso de que no haya resalto, se necesitará solamente una altura, por lo que usted debe escribir en h2 y h1 la misma altura") h_o = float(input("ingrese altura inicial [m]: ")) h_f = float(input("ingrese altura final [m]: ")) x = 0 k = 1

h_R = h_o h_T = h_f x_T = 0 x_R = 0 h_nueva = 0

for k in range(99999): if (h_f > hn and round(hn,2) > round(hc,2)): #CHECK if delta_x >0: delta_x = (-1)* delta_x # print (delta_x) # print ("deltax: " +str(delta_x)) print ("TIPO I") k+=1 h_nueva = h_f + dh_dx(Q,b,h_f,m,n,i) * delta_x print ("dh / dx es " + str(dh_dx(Q,b,h_f,m,n,i))) print ("iteración numero " +str(k)) print ("La altura en ese punto es " +str(h_f) +" [m]") h_f = (h_nueva) print ("x es " +str(x)) x += delta_x if round(h_f,2) == round(hn,2): print ("Se alcanzó altura normal a los " + str(x) + "[m]") break if abs(round (x,0)) >= round(Largo,0): print ("No se alcanzó altura normal, pues se recorrió todo el tramo") print ("Altura alcanzada después de haber recorrido todo el tramo: " + str(h_f)) break

if ((h_f > hn) and (round(hn,2) <= round(hc,2))): print ("TIPO II") print ("iteración numero " +str(k)) if (dh_dx(Q,b,h_f,m,n,i))*delta_x > 0: delta_x = (-1)*delta_x print (str((dh_dx(Q,b,h_f,m,n,i))*delta_x)) # print (delta_x) # print ("deltax: " +str(delta_x)) k+=1 h_nueva = h_f + dh_dx(Q,b,h_f,m,n,i) * delta_x print ("h_nueva es " + str(h_nueva)) print ("dh / dx es " + str(dh_dx(Q,b,h_f,m,n,i))) print ("La altura en ese punto es " +str(h_f) +" [m]") h_f = (h_nueva) print ("x es " +str(x)) x += delta_x if round(h_f,2) == round(hn,2): print ("Se alcanzó altura normal a los " + str(x) + "[m]") break if abs(round (x,0)) >= round(Largo,0): print ("No se alcanzó altura normal, pues se recorrió todo el tramo") print ("Altura alcanzada después de haber recorrido todo el tramo: " + str(h_f)) break

elif (h_f < hn and round(h_f,2) >= hc) or (h_f < hn and hn < hc): #CHECK EN LA PRIMERA Y SEGUNDA PARTE if dh_dx(Q,b,h_f,m,n,i)*delta_x < 0: delta_x = (-1)*delta_x print ("TIPO III")

k+=1 h_nueva = h_f + dh_dx(Q,b,h_f,m,n,i) * delta_x print ("h_nueva es " + str(h_nueva)) print ("delta x es " + str(delta_x)) print ("dh / dx es " + str(dh_dx(Q,b,h_f,m,n,i))) print ("iteración numero " +str(k)) print ("La altura en ese punto es " +str(h_f) +" [m]") h_f = round(h_nueva,2) print ("x es " +str(x)) x += delta_x if h_f == hn: print ("Se alcanzó altura normal a los " + str(x) + "[m]") print ("Numero de iteraciones: " + str(k)) break

if abs(round (x,0)) >= round(Largo,0): print ("No se alcanzó altura normal, pues se recorrió todo el tramo") print ("Altura alcanzada después de haber recorrido todo el tramo: " + str(h_f)) break

elif hn < hc: # Suponiendo que hay resalto -> h_o < hc if round (h_o,2) <= hc and round (h_o,2) != round(hn,2): if delta_x < 0: delta_x = (-1)* delta_x #print ("Valor de Jm en esta iteración es "+str(Jm)) k+=1 h_nueva = h_o + dh_dx(Q,b,h_o,m,n,i) * delta_x print ("PARTE DE TORRENTE") print ("dh/dx es " + str(dh_dx(Q,b,h_o,m,n,i))) print ("iteración numero " +str(k)) print ("La altura en ese punto es " +str(h_o) +" [m]") h_o = round(h_nueva,2) print ("x es " +str(x)) #print ("Distancia avanzada en esta iteración es de " + str(delta_x) + "[m]") x_T+=delta_x print ("X_T tiene un valor de " + str(x_T)) h_R += (h_nueva-h_o) h_T = h_o

if (h_f) > hc and round (h_f,2) != round(h_R,2): if delta_x > 0: delta_x = (-1)* delta_x

# Jm = (Ji_tr(Q,b,h_f,m,n) + Ji_tr(Q,b,h_f-delta_h,m,n))/2

k+=1 h_nueva = h_f + dh_dx(Q,b,h_f,m,n,i) * delta_x print ("PARTE DE RIO") print ("valor de dh/dx es " +str(dh_dx(Q,b,h_f,m,n,i))) print ("iteración numero " +str(k)) print ("La altura en ese punto es " +str(h_f) +" [m]") h_f = round(h_nueva,2) print ("x es " +str(x)) #print ("Distancia avanzada en esta iteración es de " + str(delta_x) + " [m]") x_R += abs(delta_x) print ("Distancia total avanzada: " +str(x_R) + "[m]") L_R = Largo_R(h_f,h_o)

print ("Largo del resalto: " + str(L_R))




elif int(elección2)==4: print ("Método de Runge-Kutta de cuarto orden" )

h_R = h_o x_R = 0 x_T = 0

elif int(elección)==2: print("Sección circular de diámetro D") teta=float(input("Ingrese el valor del ángulo [rad]: ")) while True: D=float(input("Ingrese el valor del diámetro del círculo [m]: ")) if D <=0: print ("Ingrese diámetro válido") else: break while True: Q=float(input("Ingrese el valor del caudal que circula por el cauce [m^3/s]: ")) if Q <0: print ("ingrese caudal que circula válido") else: break while True: n=float(input("Ingrese el valor de la rugosidad del canal: ")) if n<0:

print ("Ingrese rugosidad válida") else: break i=float(input("Ingrese la pendiente de fondo: ")) Largo = float (input ("ingrese largo total del tramo [m]: "))

h = (D/2) * (1 - math.cos(teta/2))

print ("El valor de la altura es " + str(h) + "[m]") print ("El valor del área de la sección transversal es " +str(Area_ci(D,teta))+"[m^2]") print ("El valor del perímetro mojado de la sección transversal es "+str(PM_ci(D,teta))+"[m]") print ("El valor del radio hidraúlico de la sección transversal es "+str(Radioh_ci(D,teta))+"[m]") print ("El valor de la velocidad de la sección transversal es "+str(Velocidad_ci(Q,D,teta))+"[m/s]") print ("El valor de la energía de la sección transversal es "+str(Energia_ci(Q,D,teta,h))+"[m/s]") print ("El valor de Ji de la sección transversal es "+str(Ji_ci(Q,D,teta,n)))

lista = [.0001] lista_1 = [0] k = .0001 z= 0 for w in (lista_1): teta = teta_ci(D,lista[w])

if round ((Q**2 * Ancho_sup_ci (D, teta))/(9.81 * (Area_ci(D,teta))**3),3) > 1: k+=0.0001 z+=1 # print ("iteración número " + str(z)) # print (str ((Q**2 * Ancho_sup_ci(D,teta))/(9.81 * (Area_ci(D,teta))**3))) lista.append (k) lista_1.append (z)

else: hc = round (k,2) print ("La altura crítica es: " + str (hc) + "[m]") # print (str(round ((Q**2 * Ancho_sup_ci (D, teta))/(9.81 * (Area_ci(D,teta))**3),3))) break

lista = [.0001] lista_1 = [0] k = .0001 z= 0

for w in (lista_1): teta = teta_ci (D, lista[w]) if round (Velocidad_ci(Q,D,teta),3) > round((Radioh_ci(D,teta))**(2/3)*i**(0.5)/n,3): k+=0.0001 z+=1 # print ("iteración número " + str(z)) # print ("velocidad = " + str(Velocidad_ci(Q,D,teta)) + ", Manning = " +str((Radioh_ci(D,teta))**(2/3)*i**(0.5)/n)) lista.append (k) lista_1.append (z)

else: hn = round (k,2) print ("La altura normal es: " + str (hn) + "[m]")

# print (str(round((Radioh_ci(D,teta))**(2/3)*i**(0.5)/n))) break

print("Elija un método para calcular el eje hidráulico:") print("Opción [1]:Método directo por etapas ") print("Opción [2]:Método de etapas fijas ") print("Opción [3]:Método de Euler ") print("Opción [4]:Método de Runge-Kutta de cuarto orden ") elección2=input() if int(elección2)==1: print("Método directo por etapas" ) delta_h= 0.01 print ("Se utilizará un delta_h de un centímetro") h_o = float (input ("ingrese el valor de la altura inicial [m]: ")) h_f = float (input ("ingrese el valor de la altura final [m]: "))

################################ METODO DIRECTO POR ETAPAS ################################ z = 0 x_T = 0 x_R = 0 h_R = h_o h_T = h_f while True:

# Método comienza a resolver aguas abajo

if hn < hc: # Suponiendo que hay resalto -> h_o < hc if round (h_o,2) <= hc and round (h_o,2) != round(hn,2): teta = teta_ci(D,h_o) z+=1 # print (str(z)) # print (str(round(h_o,2))) # print (str(h_R))

# print ("PARTE POR TORRENTE") # print ("la altura en este punto es " +str(h_o) + "[m]") # print ("el área en este punto es " +str(Area_ci(D,teta)) + "[^2]") # print ("El perimetro mojado en este punto es " +str(PM_ci(b,h_o,m)) + "[m]") # print ("el Radio hidráulico en este punto es " +str(Radioh_ci(b,h_o,m)) +"[m]") # print ("La velocidad en este punto es " +str(Velocidad_ci(Q,b,h_o,m)) + "[m/s]") # print ("La energia es " +str (Energia_ci(Q,b,h_o,m))) # print ("La pendiente de la línea de energía Ji en esta iteración es " +str(Ji_ci(Q,b,h_o,m,n))) Jm = (Ji_ci(Q,D,teta,n) + Ji_ci(Q,D,teta_ci(D,h_o-delta_h),n))/2 #print ("Valor de Jm en esta iteración es "+str(Jm)) delta_x = abs((Energia_ci(Q,D,teta,h_o) - Energia_ci(Q,D,teta_ci(D,h_o-delta_h),h_o-delta_h))/(i-Jm)) #print ("Distancia avanzada en esta iteración es de " + str(delta_x) + "[m]") x_T+=delta_x print ("X_T tiene un valor de " + str(x_T)) L_R = Largo_R(h_R,h_o)

print ("Distancia total avanzada: " +str(x_T) + "[m]") #print ("El largo del resalto actual es de " + str(L_R))

if round(h_o,2) < round(hn,2): h_o += delta_h h_R -= delta_h #print ("la altura de río conjugada es: " + str(h_R))

elif round(h_o,2) > round(hn,2): h_o -= delta_h h_R += delta_h #print ("la altura de río conjugada es: " + str(h_R)) else: h_o = hn print ("Se llegó a altura normal!!: " + str(h_o) + "[m]") L_R = Largo_R(h_R,h_o)

if (h_f) > hc:

teta = teta_ci(D,h_f)

''' print ("PARTE POR RIO") print ("la altura en este punto es " +str(h_f) + " [m]") print ("el área en este punto es " +str(Area_ci(b,h_f,m)) + " [m^2]") print ("El perimetro mojado en este punto es " +str(PM_ci(b,h_f,m)) + " [m]") print ("el Radio hidráulico en este punto es " +str(Radioh_ci(b,h_f,m)) +" [m]") print ("La velocidad en este punto es " +str(Velocidad_ci(Q,b,h_f,m)) + " [m/s]") print ("La energia es " +str (Energia_ci(Q,b,h_f,m)))

print ("La pendiente de la línea de energía Ji en esta iteración es " +str(Ji_ci(Q,b,h_f,m,n))) ''' Jm = (Ji_ci(Q,D,teta,n) + Ji_ci(Q,D,teta_ci(D,h_f-delta_h),n))/2

#print ("Valor de Jm en esta iteración es "+str(Jm)) delta_x = 0 delta_x = abs((Energia_ci(Q,D,teta,h) - Energia_ci(Q,D,teta_ci(D,h_f-delta_h),h))/(i-Jm))

#print ("Distancia avanzada en esta iteración es de " + str(delta_x) + " [m]") x_R+=delta_x print ("Distancia total avanzada: " +str(x_R) + "[m]") L_R = Largo_R(h_f,h_o) print ("Largo del resalto: " + str(L_R))

if round(h_f,2) < hn and round (h_f,2) != h_R: h_f += delta_h

elif round(h_f,2) > hn and round (h_f,2) != h_R: h_f -= delta_h


print ("No se alcanza altura normal. La altura de torrente es de " + str (h_o) + "[m]") print ("Altura de río conjugada: " + str(h_f)) print ("La distancia a la cual esta el resalto hidráulico, desde el incio del canal es: " +str(x_T))

print ("El largo del resalto es de " + str(L_R)) print ("El largo que hay después del resalto hidráulico es de " + str(x_R)) break


# Método comienza a resolver aguas arriba

if hn > hc: # Suponiendo que hay resalto -> h_o < hc if round (h_f,2) >= hc and round (h_f,2) != round(hn,2): z+=1 # print (str(z)) # print (str(round(h_f,2))) # print (str(h_R)) delta_x = 0

# print ("ALTURA DE RIO") # print ("la altura en este punto es " +str(h_f) + "[m]") # print ("el área en este punto es " +str(Area_ci(b,h_f,m)) + "[^2]") # print ("El perimetro mojado en este punto es " +str(PM_ci(b,h_f,m)) + "[m]") # print ("el Radio hidráulico en este punto es " +str(Radioh_ci(b,h_f,m)) +"[m]") # print ("La velocidad en este punto es " +str(Velocidad_ci(Q,b,h_f,m)) + "[m/s]") # print ("La energia es " +str (Energia_ci(Q,b,h_f,m))) # print ("La pendiente de la línea de energía Ji en esta iteración es " +str(Ji_ci(Q,b,h_f,m,n))) Jm = (Ji_ci(Q,D,teta,n) + Ji_ci(Q,D,teta_ci(D,h_f-delta_h),n))/2 #print ("Valor de Jm en esta iteración es "+str(Jm)) delta_x = abs((Energia_ci(Q,D,teta,h_f) - Energia_ci(Q,D,teta_ci(D,h_f-delta_h),h_f-delta_h))/(i-Jm)) #print ("Distancia avanzada en esta iteración es de " + str(delta_x) + "[m]") x_R+=delta_x # print ("Distancia total avanzada: " +str(x_R) + "[m]") # print ("altura final: " + str(h_f)) #print ("El largo del resalto actual es de " + str(L_R))

if round(h_f,2) < round (hn,2): h_f += delta_h h_T -= delta_h

elif round(h_f,2) > round (hn,2): h_f -= delta_h h_T += delta_h

else: h_f = hn print ("Se llegó a altura normal!!: " + str(h_f) + "[m]") L_R = Largo_R(h_R,h_o)

if (h_o) < hc and round(h_o,2) != round (h_T,2) :

print ("ALTURA DE TORRENTE") # print ("la altura en este punto es " +str(h_o) + " [m]") # print ("el área en este punto es " +str(Area_ci(b,h_o,m)) + " [m^2]") # print ("El perimetro mojado en este punto es " +str(PM_ci(b,h_o,m)) + " [m]") # print ("el Radio hidráulico en este punto es " +str(Radioh_ci(b,h_o,m)) +" [m]") # print ("La velocidad en este punto es " +str(Velocidad_ci(Q,b,h_o,m)) + " [m/s]") # print ("La energia es " +str (Energia_ci(Q,b,h_o,m)))

#print ("La pendiente de la línea de energía Ji en esta iteración es " +str(Ji_ci(Q,b,h_o,m,n))) Jm = (Ji_ci(Q,D,teta,n) + Ji_ci(Q,D,teta_ci(D,h_o-delta_h),n))/2

#print ("Valor de Jm en esta iteración es "+str(Jm)) delta_x = 0 delta_x = abs((Energia_ci(Q,D,teta,h_o) - Energia_ci(Q,D,teta_ci(D,h_o-delta_h),h_o-delta_h))/(i-Jm))

#print ("Distancia avanzada en esta iteración es de " + str(delta_x) + " [m]") x_T+=delta_x print ("Distancia total avanzada: " +str(x_T) + "[m]") print ("altura final: " + str(h_o))

if round(h_o,2) < hn and round (h_o,2) != h_T: h_o += delta_h

L_R = Largo_R(h_f,h_o)

if (x_T + x_R+ L_R) >= Largo: print ("No se alcanzó altura normal. La altura de Rio conjugada es " + str (h_f)) print ("La altura de río torrente es: " + str(h_o)) print ("El resalto comienza a una distancia de " + str(x_T)) print ("El resalto tiene un largo de " + str (L_R)) print ("La distancia que hay después del resalto es de " + str (x_R)) break

elif round((x_T + x_R+ L_R),0) < round(Largo,0) and round(h_f,2) == round(hn,2) and (round(h_o,2) == round(h_T,2) or round (h_o,2) == round(hc,2)):

x_N = Largo - (x_T+ L_R) print ("Se alcanza altura normal a los " + str (x_T) + "[m]") print ("Altura de torrente conjugada: " + str(h_o)) print ("Altura de río conjugada: " + str(h_f)) print ("La distancia que hay desde el resalto hasta qeu se alcanza hn es " +str(x_N)) print ("El largo del resalto es de " + str(L_R)) print ("El largo que hay después del resalto hidráulico es de " + str(x_R)) break

################################ METODO DIRECTO POR ETAPAS ################################ ''' ----------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------- '''

break if int(elección2)==2: print("Método por etapas fijas" ) if int(elección2)==3: print("Método de Euler" ) delta_x = float(input("ingrese la distancia que se avanzará en cada iteración [m]: " )) print ("En caso de que no haya resalto, se necesitará solamente una altura, por lo que usted debe escribir en h2 y h1 la misma altura") h_o = float(input("ingrese altura inicial [m]: ")) h_f = float(input("ingrese altura final [m]: ")) x = 0 k = 1 h_R = h_o h_T = h_f x_T = 0 x_R = 0 h_nueva = 0

for k in range(99999): if (h_f > hn and round(hn,2) > round(hc,2)): #CHECK if dh_dx_ci(Q,D,teta,n,i) *delta_x > 0: delta_x = (-1)* delta_x # print (delta_x) # print ("deltax: " +str(delta_x)) print ("TIPO I") k+=1 h_nueva = h_f + dh_dx_ci(Q,D,teta,n,i) * delta_x print ("dh / dx es " + str(dh_dx_ci(Q,D,teta,n,i))) print ("iteración numero " +str(k)) print ("La altura en ese punto es " +str(h_f) +" [m]") h_f = (h_nueva) teta = teta_ci(D,h_f) print ("x es " +str(x)) x += delta_x if round(h_f,2) == round(hn,2): print ("Se alcanzó altura normal a los " + str(x) + "[m]") break if abs(round (x,0)) >= round(Largo,0): print ("No se alcanzó altura normal, pues se recorrió todo el tramo") print ("Altura alcanzada después de haber recorrido todo el tramo: " + str(h_f)) break

if ((h_f > hn) and (round(hn,2) <= round(hc,2))): print ("TIPO II")

print ("iteración numero " +str(k)) if (dh_dx_ci(Q,D,teta,n,i))*delta_x > 0: delta_x = (-1)*delta_x print (str((dh_dx_ci(Q,D,teta,n,i))*delta_x)) # print (delta_x) # print ("deltax: " +str(delta_x)) k+=1 h_nueva = h_f + dh_dx_ci(Q,D,teta,n,i) * delta_x print ("h_nueva es " + str(h_nueva)) print ("dh / dx es " + str(dh_dx_ci(Q,D,teta,n,i))) print ("La altura en ese punto es " +str(h_f) +" [m]") h_f = (h_nueva) teta = teta_ci(D,h_f) print ("teta es " + str(teta)) print ("x es " +str(x)) x += delta_x if round(h_f,2) == round(hn,2): print ("Se alcanzó altura normal a los " + str(x) + "[m]") break if abs(round (x,0)) >= round(Largo,0): print ("No se alcanzó altura normal, pues se recorrió todo el tramo") print ("Altura alcanzada después de haber recorrido todo el tramo: " + str(h_f)) break

elif (h_f < hn and round(h_f,2) >= hc) or (h_f < hn and hn < hc): #CHECK EN LA PRIMERA Y SEGUNDA PARTE if dh_dx_ci(Q,D,teta,n,i)*delta_x < 0: delta_x = (-1)*delta_x print ("TIPO III") k+=1 h_nueva = h_f + dh_dx_ci(Q,D,teta,n,i) * delta_x print ("h_nueva es " + str(h_nueva)) print ("delta x es " + str(delta_x)) print ("dh / dx es " + str(dh_dx_ci(Q,D,teta,n,i))) print ("iteración numero " +str(k)) print ("La altura en ese punto es " +str(h_f) +" [m]") h_f = round(h_nueva,2) teta = teta_ci(D,h_f) print ("x es " +str(x)) x += delta_x if h_f == hn: print ("Se alcanzó altura normal a los " + str(x) + "[m]") print ("Numero de iteraciones: " + str(k)) break

if abs(round (x,0)) >= round(Largo,0): print ("No se alcanzó altura normal, pues se recorrió todo el tramo") print ("Altura alcanzada después de haber recorrido todo el tramo: " + str(h_f)) break

elif hn < hc: # Suponiendo que hay resalto -> h_o < hc if round (h_o,2) <= hc and round (h_o,2) != round(hn,2): if delta_x < 0: delta_x = (-1)* delta_x #print ("Valor de Jm en esta iteración es "+str(Jm)) k+=1 h_nueva = h_o + dh_dx(Q,b,h_o,m,n,i) * delta_x

print ("PARTE DE TORRENTE") print ("dh/dx es " + str(dh_dx(Q,b,h_o,m,n,i))) print ("iteración numero " +str(k)) print ("La altura en ese punto es " +str(h_o) +" [m]") h_o = round(h_nueva,2) print ("x es " +str(x)) #print ("Distancia avanzada en esta iteración es de " + str(delta_x) + "[m]") x_T+=delta_x print ("X_T tiene un valor de " + str(x_T)) h_R += (h_nueva-h_o) h_T = h_o

if (h_f) > hc and round (h_f,2) != round(h_R,2): if delta_x > 0: delta_x = (-1)* delta_x

# Jm = (Ji_tr(Q,b,h_f,m,n) + Ji_tr(Q,b,h_f-delta_h,m,n))/2

k+=1 h_nueva = h_f + dh_dx(Q,b,h_f,m,n,i) * delta_x print ("PARTE DE RIO") print ("valor de dh/dx es " +str(dh_dx(Q,b,h_f,m,n,i))) print ("iteración numero " +str(k)) print ("La altura en ese punto es " +str(h_f) +" [m]") h_f = round(h_nueva,2) print ("x es " +str(x)) #print ("Distancia avanzada en esta iteración es de " + str(delta_x) + " [m]") x_R += abs(delta_x) print ("Distancia total avanzada: " +str(x_R) + "[m]") L_R = Largo_R(h_f,h_o) print ("Largo del resalto: " + str(L_R))




if int(elección2)==4: print("Método de Runge-Kutta de cuarto orden" )

else: print ("Elija una opción válida")

hidrauliproject.files.wordpress.com€¦ · web viewprint("opción [1]:sección trapecial de...

Documents