Script: Cálculo de caudal Método de integración área – velocidad
#IMPORTACIÓN DE MÓDULOS
import pandas as pd
import numpy as np
import matplotlib as mpl
import [Link] as plt
from scipy import interpolate
import math
import PySimpleGUI as sg
import os
from [Link].backend_pdf import PdfPages
#DEFINICIÓN DE VARIABLES GLOBALES
xf = []
yf = []
xv = []
yv = []
cv = []
nFinalAgua = []
nInicialAgua = []
yTot = []
nivIniReal=[]
nivFinReal=[]
errores = []
X = []
Y = []
Z = []
Z2 = []
dic = {}
sizeMatrix = 100 #tamaño de matriz de datos de interpolación
caudal = 0.0 #variable tipo numerica
#CREACIÓN DE FUNCIONES
#LECTURA DE DATOS
def readData(pathFrontera):
global xf, yf, xv, yv, cv, nFinalAgua, nInicialAgua, yTot,
nivIniReal, nivFinReal
try:
frontera = pd.read_excel(pathFrontera)
xf = [Link][:,[2]]
yf = [Link][:,[4]]*-1
xv = [Link][:,[2]]
yv = [Link][:,[5]]*-1
cv = [Link][:,[6]]
nInicialAgua = [Link][:,[4]].values
nFinalAgua = [Link][:,[7]].values
yTot= [Link][:,[3]]*-1
nivIniReal=yTot+nInicialAgua
nivFinReal=yTot+nFinalAgua
[Link]('Cargando Datos', 'Se han cargado los datos
correctamente')
except Exception:
[Link]('No se puede cargar, revise el formato de los
archivos')
#ANÁLISIS DE DATOS
#Variación temporal del nivel del agua
def fluctuation():
fig,ax =[Link](figsize=(10, 4))
[Link]('FLUCTUACIÓN DEL NIVEL DEL AGUA'+'\n'+'Variación
temporal porcentual: '+str(round(100-calculateConfiability(),
2))+'%'+'\n', weight='bold')
[Link](xf,yTot, color='brown',label='Frontera sólida')
[Link](xf,nivIniReal, color='green',label='Nivel de agua inicial')
[Link](xf,nivFinReal, color='orange',label='Nivel de agua final')
ax.set_ylabel('Profundidad (m)')
ax.set_xlabel('Distancia desde el margen de referencia (m)')
[Link](loc='best', title='Leyenda', frameon=False)
[Link]('Fluctuación temporal del nivel del [Link]',
bbox_inches='tight')
[Link]()
#Detección de errores absolutos con respecto al área de la sección
def checkPointsY(key,valor):
global yv
global xv
salida = 'Revisar punto: '
for i in range (len([Link])):
if ([Link][i] == valor and [Link][i] == key):
salida += " "+str(i+1)+"-"
return salida[:-1]
def checkPointsX(key):
global yv
global xv
salida = 'Revisar punto: '
for i in range (len([Link])):
if ([Link][i] == key):
salida += " "+str(i+1)+"-"
return salida[:-1]
def findAbsoluteErrors(x, y, xf, yf):
global dic
xli = xf[:]
yli = yf[:]
minx = {}
for i in range(len(xli)):
minx[xli[i][0]] = yli[i][0]
minXf = min(xf)
maxXf = max(xf)
ex = ""
for i in x:
if i < minXf or i > maxXf:
ex += checkPointsX(i[0])
ey = ""
if(len(ex) > 0):
[Link]('Errores absolutos:', 'Existen valores fuera de los
límites horizontales de la sección'+'\n'+ex)
else:
for i in [Link]():
for j in dic[i]:
if j > 0 or j < minx[i]:
ey += checkPointsY(i, j)
if(len(ey) > 0):
[Link]('Errores absolutos:', 'Existen valores fuera de
los límites verticales de la sección'+'\n'+ey)
else:
[Link]('Errores absolutos:', 'Todos los puntos se
encuentran dentro de los límites de la sección')
#Detección de velocidades negativas
def negativeSpeedDetection(x,y,v):
band = 0
negVel = ""
for i in range(len(v)):
if(v[i] < 0):
band = 1
negVel += 'Revisar punto:' + str(i+1) + '\n'
return 'No existen velocidades negativas ' if band == 0 else 'Existen
velocidades negativas' + '\n' + negVel
#Detección de Outliers de velocidad
def maxSizeDic(dic):
size = 0
for i in [Link]():
size = len(dic[i]) if len(dic[i]) > size else size
return size
def dataSet(lista_original):
lista_nueva = []
for i in lista_original:
if i not in lista_nueva:
lista_nueva.append([i][0][0])
return lista_nueva
#Etiqueta de número de punto de Outlier
def searchOutliers(velo):
global cv
salida = ' [Link]:'
for i in range(len([Link])):
if ([Link][i] == velo):
salida += " "+str(i+1)+"-"
return salida[:-1]
#Etiquetas de datos de BoxPlot
def make_labels(ax, boxplot):
iqr = boxplot['boxes'][0]
caps = boxplot['caps']
med = boxplot['medians'][0]
fly = boxplot['fliers'][0]
xpos = med.get_xdata()
xoff = 0.10 * (xpos[1] - xpos[0])
xlabel = xpos[1] + xoff
median = med.get_ydata()[1]
pc25 = iqr.get_ydata().min()
pc75 = iqr.get_ydata().max()
capbottom = caps[0].get_ydata()[0]
captop = caps[1].get_ydata()[0]
[Link](xlabel, median,
'Mediana = {:6.3g}'.format(median), va='center')
[Link](xlabel, pc25,
'Qinf = {:6.3g}'.format(pc25), va='center')
[Link](xlabel, pc75,
'Qsup = {:6.3g}'.format(pc75), va='center')
[Link](xlabel, capbottom,
'Valor mínimo = {:6.3g}'.format(capbottom), va='center')
[Link](xlabel, captop,
'Valor máximo = {:6.3g}'.format(captop), va='center')
flag = 0
for flier in fly.get_ydata():
[Link](1 + xoff, flier,
' Valor ext. = '+str(flier)+searchOutliers(flier),
va='center')
flag = 1
if flag == 1:
[Link]('Existen datos externos en las magnitudes de
velocidades, se recomienda revisar. Para visualizar presione sobre el
boton Error.')
flag = 0
#Gráfico de análisis visual de datos
def showData():
fig, ax = [Link](figsize=(10, 3))
[Link]([Link],[Link], s=5, marker="o", c=[Link],
cmap=[Link])
[Link](xf, yf)
[Link]('Gráfico de datos', weight='bold')
[Link]('Profundidad (m)')
[Link]('Distancia desde el margen de referencia (m)')
cbar = [Link]()
cbar.set_label('Velocidad (m/s)', labelpad=+2)
[Link]('Gráfico de [Link]', bbox_inches='tight')
[Link]()
#INTERPOLACIÓN
#Creación de matríz de datos de ingreso
def pushMatrix(x, y, v):
global dic
dicY = {}
dicZ = {}
for i in range(len(x)):
elem = [Link](x[i][0], [])
[Link](y[i][0])
dicY[x[i][0]] = elem
elem = [Link](x[i][0], [])
[Link](v[i][0])
dicZ[x[i][0]] = elem
xdata = [[i for i in [Link]()]]*len(dicY[0.0])
ydata = [Link]((len(dicY[0.0]), len([Link]())))
zdata = [Link]((len(dicY[0.0]), len([Link]())))
cont = 0
for i in [Link]():
for j in range(len(dicY[i])):
ydata[j][cont] = dicY[i][j]
zdata[j][cont] = dicZ[i][j]
cont += 1
return xdata, ydata, zdata
#CÁLCULO DE CAUDAL
#Agrupación de datos
def createDicCalculation(x, y, xf, yf):
global dic
dic = {}
for i in range(len(x)):
elem = [Link](x[i][0], [])
[Link](y[i][0])
dic[x[i][0]] = elem
#Cálculo
def calculationFlow(ma, x, y):
global sizeMatrix, caudal
if len(ma) < 1:
[Link]('Visualizar el gráfico de interpolación para
realizar el cálculo')
else:
dic = {}
for i in ma:
for j in i:
if not([Link](j)):
num = [Link](j, 0)
num += 1
dic[j] = num
caudal = 0
area = x*y
for i in [Link]():
caudal += (area * dic[i] * i)
return round((caudal[0]/sizeMatrix), 3)
#Confiabilidad de la variación temporal del nivel del agua
def calculateConfiability():
global nFinalAgua
global nInicialAgua
iMean = [Link](nInicialAgua)
fMean = [Link](nFinalAgua)
return (iMean/fMean)*100 if iMean < fMean else (fMean/iMean)*100
#INFORME DE RESULTADOS
def createPdf(name, seccion, fecha, tecnico):
with PdfPages(r''+name+'.pdf') as export_pdf:
xdata, ydata, zdata = pushMatrix([Link], [Link], [Link])
fig = [Link](figsize=(11.69,8.27)) #11.69,8.27 TAMAÑO A4
HORIZONTAL
#GRÁFICO DE DISTRIBUCIÓN TRANSVERSAL DE VELOCIDADES
ax1 = [Link](3, 1, 1)
[Link](x=0.6, y=1.1, s='Proyecto: '+name+'\n'+'Sección:
'+seccion+'\n'+'Fecha: '+fecha+'\n'+'Técnico: '+tecnico+'\n',
fontsize=14, weight='bold', ha='center', va='bottom',
transform=[Link])
x = [Link](xdata)
y = [Link](ydata)
z = [Link](zdata)
X, Y = [Link]([Link](min([Link]), max([Link]),
sizeMatrix), [Link](min([Link]), max([Link]), sizeMatrix))
Z2 = [Link]((x, y), z, (X, Y), method='linear')
for i in range(len(Z2)):
for k in range(len(Z2[i])):
if(Z2[i][k] < 0):
Z2[i][k] = None
c = [Link](X, Y, Z2, 20, cmap=[Link]);
ax1.set_title('Distribución transversal de
velocidades',weight='bold')
ax1.set_xlabel('Distancia desde el margen de referencia (m)',
fontsize=10)
ax1.set_ylabel('Profundidad (m)', fontsize=10)
cb = [Link](c, ax=ax1)
cb.set_label('Velocidad (m/s)', fontsize=10)
[Link](xf, yf)
#GRÁFICOS DE DISTRIBUCIÓN LONGITUDINAL DE VELOCIDADES
ax2 = [Link](3, 2, 3)
y = []
num = min([Link])[0] * -1
for i in range(sizeMatrix):
[Link](round(num, 3) * -1)
num -= abs((min([Link])[0])/sizeMatrix)
#GRÁFICO DE PERFIL LONGITUDINAL AL 25%
ax2.set_title('Perfil logitudinal al '+
str(round(sizeMatrix/4))+'%', weight='bold')
[Link](Z2[:, round(sizeMatrix/4)], y)
ax2.set_xlabel('Velocidad (m/s)', fontsize=10)
ax2.set_ylabel('Profundidad (m)', fontsize=10)
[Link]()
#GRÁFICO DE PERFIL LONGITUDINAL AL 50%
ax3 = [Link](3, 2, 4)
ax3.set_title('Perfil logitudinal al '+
str(round((sizeMatrix/4)*2))+'%', weight='bold')
[Link](Z2[:, round((sizeMatrix/4)*2)], y)
ax3.set_xlabel('Velocidad (m/s)', fontsize=10)
ax3.set_ylabel('Profundidad (m)', fontsize=10)
[Link]()
#GRÁFICO DE PERFIL LONGITUDINAL AL 75%
ax4 = [Link](3, 2, 5)
ax4.set_title('Perfil logitudinal al '+
str(round((sizeMatrix/4)*3))+'%', weight='bold')
[Link](Z2[:, round((sizeMatrix/4)*3)], y)
ax4.set_xlabel('Velocidad (m/s)', fontsize=10)
ax4.set_ylabel('Profundidad (m)', fontsize=10)
[Link]()
#CARACTERÍSTICAS HIDRÁULICAS DE LA SECCIÓN
ax5 = [Link](3, 2, 6)
[Link](x=0.65, y=-0.3, s='Universidad Católica de
Cuenca'+'\n'+'Copyright © 2020 por Johanna
Jaramillo'+'\n'+'johannajaramillo25@[Link]', fontsize=10, ha='center',
va='bottom', transform=[Link])
ax5.set_title('Características de la sección
hidráulica',fontsize=13,weight='bold')
caudal = calculationFlow(Z2, ((max([Link]) -
min([Link])/sizeMatrix)), ((max([Link]) -
min([Link])/sizeMatrix)))
veloMedia = round([Link]([Link](Z2)), 3)
[Link](x=0,y=0.85,s='Caudal aforado = '+str(caudal)+' [m3/s]',
fontsize=12, va='bottom', transform=[Link])
[Link](x=0,y=0.7,s='Tirante máximo = '+str(min([Link])[0]*-
1)+' [m]', fontsize=12, va='bottom', transform=[Link])
[Link](x=0,y=0.55,s='Velocidad media = '+str(veloMedia)+'
[m/s]', fontsize=12, va='bottom', transform=[Link])
[Link](x=0,y=0.4,s='Área media del flujo =
'+str(round(caudal/veloMedia,3))+' [m2]', fontsize=12, va='bottom',
transform=[Link])
[Link](x=0,y=0.25,s='% Confiabilidad de medición =
'+str(round(calculateConfiability(), 2)), fontsize=12, va='bottom',
transform=[Link])
[Link]('off')
plt.tight_layout()
export_pdf.savefig()
[Link]()
[Link]('Se ha generado su archivo', 'El informe se encuentra
en: '+str([Link]())+'\\'+name+'.pdf')
#CREACIÓN DE PANTALLA DE INTERACCIÓN Y PROCESOS
#Distribucion de la ventana
layout = [[[Link]('')],
[[Link]('SELECCIONAR ARCHIVO DE ENTRADA',
size=(40, 1)), [Link](), [Link]()],
[[Link]('', size=(55,1)), [Link]('Cargar
datos', key="cargar")],
[[Link]('ANÁLISIS DE DATOS')],
[[Link]('Fluctuación temporal del nivel del
agua', key='grafVariación'),[Link]('Detectar errores absolutos',
key='erroresAb'), [Link]('Detectar velocidades negativas',
key='velocidades') ,
[Link]('Detectar Outliers', key='boxplot'),
[Link]('Graficar datos', key= 'datos')],
[[Link]('CÁLCULO DEL CAUDAL')],
[[Link]('Isotacas de velocidad',
key='contornos'), [Link]('Distribución transversal de velocidades',
key='interpolación'), [Link]('Calcular caudal', key='caudal')],
[[Link]('Seleccionar a qué % del ancho de
sección desea visualizar el perfil longitudinal de velocidades')],
[
[Link](
values=[], enable_events=True, size=(20,
10), key="-FILE LIST-"
)
],
[[Link]('DATOS DEL PROYECTO')],
[[Link]('Título:',size=(20, 1)),
[Link]()],
[[Link]('Sección:',size=(20, 1)),
[Link]()],
[[Link]('Fecha:',size=(20, 1)), [Link]()],
[[Link]('Técnico:', size=(20, 1)),
[Link]()],
[[Link]('', size=(35,1)),[Link]('Imprimir
informe', key='reporte')],
[],
]
#Creación de ventana
window = [Link]('Cálculo de caudal: Método de integración área-
velocidad', layout)
#Creación de eventos y acciones
while True:
event, values = [Link]()
if event is None:
break
elif event == 'cargar':
pathFrontera = values[0]
readData(pathFrontera)
createDicCalculation([Link],[Link], [Link], [Link])
window["-FILE LIST-"].update([x+1 for x in range(sizeMatrix)])
elif event == 'grafVariación':
fluctuation()
elif event == 'erroresAb':
findAbsoluteErrors([Link], [Link], [Link], [Link])
elif event == 'velocidades':
[Link]('Velocidades negativas:',
negativeSpeedDetection([Link],[Link], [Link]))
elif event == 'boxplot':
dummy_data = [Link]
dummy_data = [i[0] for i in dummy_data if i != 0]
dummy_data += [0 for i in range(len([Link]()))]
red_diamond = dict(markerfacecolor='r', marker='D')
fig3, ax = [Link]()
ax.set_title('BoxPlot Velocidades', weight='bold')
ax.set_ylabel('Velocidad (m/s)', fontsize=10)
my_boxes = [Link](dummy_data, flierprops=red_diamond)
make_labels(ax, my_boxes)
[Link]('BoxPlot(Análisis de velocidades).png',
bbox_inches='tight')
[Link]()
elif event == 'datos':
showData()
elif event == 'contornos':
xdata, ydata, zdata = pushMatrix([Link], [Link], [Link])
x = [Link](xdata)
y = [Link](ydata)
z = [Link](zdata)
X, Y = [Link]([Link](min([Link]), max([Link]),
sizeMatrix), [Link](min([Link]), max([Link]), sizeMatrix))
fig, ax = [Link](figsize=(10, 3))
norm = [Link](-abs(zdata).max(), abs(zdata).max())
c = [Link](xdata, ydata, zdata, 10, norm=norm,
cmap=[Link]);
ax.set_title('Isotacas de velocidad', weight='bold')
ax.set_xlabel('Distancia desde el margen de referencia (m)',
fontsize=10)
ax.set_ylabel('Profundidad (m)', fontsize=10)
cb = [Link](c, ax=ax)
cb.set_label('Velocidad (m/s)', fontsize=10)
[Link](xf, yf,'brown')
[Link]('Isotacas de [Link]', bbox_inches='tight')
[Link]()
elif event == 'interpolación':
xdata, ydata, zdata = pushMatrix([Link], [Link], [Link])
x = [Link](xdata)
y = [Link](ydata)
z = [Link](zdata)
X, Y = [Link]([Link](min([Link]), max([Link]),
sizeMatrix), [Link](min([Link]), max([Link]), sizeMatrix))
Z1 = [Link]((x, y), z, (X, Y), method='nearest')
Z2 = [Link]((x, y), z, (X, Y), method='linear')
Z3 = [Link]((x, y), z, (X, Y), method='cubic')
for i in range(len(Z2)):
for k in range(len(Z2[i])):
if(Z2[i][k] < 0):
Z2[i][k] = None
fig, ax = [Link](figsize=(10, 3))
c = [Link](X, Y, Z2, 20, cmap=[Link]);
ax.set_title('Distribución transversal de velocidades',
weight='bold')
ax.set_xlabel('Distancia desde el margen de referencia (m)',
fontsize=10)
ax.set_ylabel('Profundidad (m)', fontsize=10)
cb = [Link](c, ax=ax)
cb.set_label('Velocidad (m/s)', fontsize=10)
[Link](xf, yf)
[Link]('Distribución transversal de [Link]',
bbox_inches='tight')
[Link]()
elif event == 'caudal':
[Link]('Resultado del caudal: ', str(calculationFlow(Z2,
((max([Link]) - min([Link])/sizeMatrix)), ((max([Link]) -
min([Link])/sizeMatrix)))) + 'm3/s')
elif event == 'reporte':
createPdf(values[1], values[2], values[3], values[4])
elif event == '-FILE LIST-':
try:
val = values['-FILE LIST-'][0] -1
xdata, ydata, zdata = pushMatrix([Link], [Link],
[Link])
fig, ax = [Link](figsize=(10, 3))
y = []
num = min([Link])[0] * -1
for i in range(sizeMatrix):
[Link](round(num, 3) * -1)
num -= abs((min([Link])[0])/sizeMatrix)
ax.set_title('Distribución longitudinal de velocidades',
weight='bold')
[Link](Z2[:, val], y)
ax.set_xlabel('Velocidad (m/s)', fontsize=10)
ax.set_ylabel('Profundidad (m)', fontsize=10)
[Link]()
[Link]()
except:
pass
[Link]()
