# Importación de librerias import time from datetime import date, datetime, timedelta import pandas as pd import warnings from random import randint import re import numpy as np import pymysql import psycopg2 import psycopg2.extras as extras from sys import argv #recibir parametros #--- import traceback import math from itertools import zip_longest#agrupar array #Primero se reciben los parametros #Nombre_Archivo, inicio, fin, condicion= argv #fin de recibir parametros #----------------------------- ################################################################################################################################# #Inicio-----------------------Funciones con conexion a la base de datos----------------------------------INICIO------------------ ################################################################################################################################# def loadtosql(table, data, funcion): start_time2 = time.time() connection = pymysql.connect( host='82.163.176.111', user='mgmrenso_voldemort', password='RHd1&n%=@V2@', db='mgmrenso_wyndham' ) cursor = connection.cursor() data.columns = data.columns.str.replace(r'\[|\]', '') # Eliminar corchetes de los nombres de columna # Verificar si la tabla ya existe en la base de datos cursor.execute("SHOW TABLES LIKE '{}'".format(table)) table_exists = cursor.fetchone() if not table_exists: # Si la tabla no existe, se insertan los datos en lugar de actualizar cols = ",".join([str(i) for i in data.columns.tolist()]) placeholders = ",".join(["%s"] * len(data.columns)) sql = "INSERT INTO {} ({}) VALUES ({})".format(table, cols, placeholders) lista = [tuple(row) for row in data.values] try: cursor.executemany(sql, lista) connection.commit() print("Datos copiados correctamente:", data.shape[0]) print("En %s segundos" % (time.time() - start_time2)) except Exception as e: connection.rollback() print("Ocurrió una excepción:", e) finally: connection.close() else: # Si la tabla existe, eliminar los datos existentes y luego insertar los nuevos datos delete_sql = "DELETE FROM {}".format(table) insert_cols = ",".join([str(i) for i in data.columns.tolist()]) placeholders = ",".join(["%s"] * len(data.columns)) insert_sql = "INSERT INTO {} ({}) VALUES ({})".format(table, insert_cols, placeholders) lista = [tuple(row) for row in data.values] try: cursor.execute(delete_sql) cursor.executemany(insert_sql, lista) connection.commit() print("Datos actualizados correctamente:", data.shape[0],"Funcion:",funcion) print("En %s segundos" % (time.time() - start_time2)) except Exception as e: connection.rollback() print("Ocurrió una excepción:", e) finally: connection.close() #--------------------Rendimiento planta--historial-------------------------------- def loadtosqlRendimiento(table, data, funcion): start_time2 = time.time() try: connection = psycopg2.connect(host="198.27.67.220", database="mgmrenso_legola", user="mgmlegola", password="2s6kWSH5CYFG%5KT") cursor = connection.cursor() data.columns = data.columns.str.replace(r'\[|\]', '') # Eliminar corchetes de los nombres de columna cols = ",".join(data.columns) placeholders = ",".join(["%s"] * len(data.columns)) sql = f"INSERT INTO {table} ({cols}) VALUES ({placeholders})" lista = [tuple(row) for row in data.values] cursor.executemany(sql, lista) connection.commit() print("Datos insertados correctamente:", data.shape[0]) print("En %.2f segundos" % (time.time() - start_time2)) except Exception as e: connection.rollback() print("Ocurrió una excepción:", e) finally: cursor.close() connection.close() #---------------------------------------------------------------------------------------------------------- #----------------------------- def Consultar_Periodo(sql, columnas): db = pymysql.connect( host='82.163.176.111', user='mgmrenso_voldemort', password='RHd1&n%=@V2@', db='mgmrenso_wyndham' ) cursor = db.cursor() # Insertar info en DB try: cursor.execute(sql) db.commit() result = cursor.fetchall() column_names = columnas df = pd.DataFrame(result, columns=column_names) return df except Exception as e: db.rollback() print("Exception Ocurred: ", e) traceback.print_exc() finally: db.close() def data_Postgres(sql, columnas): db = psycopg2.connect(host="198.27.67.220", database="mgmrenso_legola", user="mgmlegola", password="2s6kWSH5CYFG%5KT") cursor = db.cursor() # Insertar info en DB try: cursor.execute(sql) db.commit() result = cursor.fetchall() column_names = columnas df = pd.DataFrame(result, columns=column_names) # df["fechahora"] = df["fechahora"].replace({'PM':''}, regex=True) # df["fechahora"] = df["fechahora"].replace({'AM':''}, regex=True) df['fechafull']=df['fechadia']+df['fechahora'] df['fechafull']=pd.to_datetime(df['fechafull'], format='%Y-%m-%d%H:%M:%S') del df['fechadia'] del df['fechahora'] del df['id'] df.reset_index() return df except Exception as e: db.rollback() print("Exception Ocurred: ", e) traceback.print_exc() finally: db.close() #----------------------------- def data(sql, columnas): db = psycopg2.connect(host="198.27.67.220", database="mgmrenso_legola", user="mgmlegola", password="2s6kWSH5CYFG%5KT") cursor = db.cursor() # Insertar info en DB try: cursor.execute(sql) db.commit() result = cursor.fetchall() column_names = columnas df = pd.DataFrame(result, columns=column_names) df["fechahora"] = df["fechahora"].replace({'PM':''}, regex=True) df["fechahora"] = df["fechahora"].replace({'AM':''}, regex=True) # Convertir las columnas de fecha y hora en objetos de fecha y hora df['fechadia'] = pd.to_datetime(df['fechadia']) # Convertir la columna 'fechahora' a formato de hora df['fechahora'] = pd.to_datetime(df['fechahora'], errors='coerce') # Formatear la columna 'fechahora' en formato de hora (HH:MM:SS) df['fechahora'] = df['fechahora'].dt.strftime('%H:%M:%S') # Unir la columna de fecha y hora en una nueva columna df['fechafull'] = pd.to_datetime(df['fechadia'].astype(str) + ' ' + df['fechahora'].astype(str)) del df['fechadia'] del df['fechahora'] del df['id'] df.reset_index() return df except Exception as e: db.rollback() print("Exception Ocurred: ", e) traceback.print_exc() finally: db.close() #Funcion para conectarse a la bd rendimiento planta #----------------------------- def Datos_Rendimiento_PLanta_Acomulado(sql, columnas): db = psycopg2.connect(host="198.27.67.220", database="mgmrenso_legola", user="mgmlegola", password="2s6kWSH5CYFG%5KT") cursor = db.cursor() # Insertar info en DB try: cursor.execute(sql) db.commit() result = cursor.fetchall() df = pd.DataFrame(result, columns=columnas) df.reset_index() return df except Exception as e: db.rollback() print("Exception Ocurred: ", e) traceback.print_exc() finally: db.close() ################################################################################################################################# #FIN-----------------------Funciones con conexion a la base de datos----------------------------------FIN------------------------ ################################################################################################################################# def Tabla_BMS(inicio, fin): # SQL Y DATAFRAME DE LOS DATOS columnas=["id","fechadia","fechahora","variable","valor"]#definimos columnas sql = "SELECT * FROM monitoringwyndham WHERE fechadia BETWEEN '"+str(inicio)+"' AND '"+str(fin)+"';"#sql de los datos #sql = "SELECT * FROM `monitoringwyndham` WHERE `fechadia` BETWEEN '"+str(inicio)+"' AND '"+str(fin)+"';"#sql de los datos df=data(sql,columnas)#llamamos la funcion y le mandamos los pàrametros #inicio kw1 dataframe kw1= df[df["variable"]=="kw1"] kw1.rename(columns={'valor':'CHILLER_DAIKIN_[kWh]'}, inplace=True) kw1.drop(['variable'], axis=1, inplace=True) #fin kw1 datframe #inicio kw2 dataframe kw2= df[df["variable"]=="kw2"] kw2.rename(columns={'valor':'TEMPLIFIER_[kWh]'}, inplace=True) kw2.drop(['variable'], axis=1, inplace=True) #fin kw2 datframe #kw3 datframe inicio kw3=df[df["variable"]=="kw3"] kw3.rename(columns={'valor':'Bombas_AH_[kWh]'}, inplace=True) kw3.drop(['variable'], axis=1, inplace=True) #fin kw3 dataframe #kw4 datframe inicio kw4=df[df["variable"]=="kw4"] kw4.rename(columns={'valor':'BombaTorrre_[kWh]'}, inplace=True) kw4.drop(['variable'], axis=1, inplace=True) #fin kw4 dataframe #kw5 datframe inicio kw5=df[df["variable"]=="kw5"] kw5.rename(columns={'valor':'AbanicoTorre_[kWh]'}, inplace=True) kw5.drop(['variable'], axis=1, inplace=True) #fin kw5 dataframe #kw6 datframe inicio kw6=df[df["variable"]=="kw6"] kw6.rename(columns={'valor':'BOMBA_TEMPLIFIER_[kWh]'}, inplace=True) kw6.drop(['variable'], axis=1, inplace=True) #fin kw6 dataframe #kw7 datframe inicio kw7=df[df["variable"]=="kw7"] kw7.rename(columns={'valor':'BOMBA_AC_[kW]'}, inplace=True) kw7.drop(['variable'], axis=1, inplace=True) #fin kw7 dataframe #tonsac datframe inicio tonsac=df[df["variable"]=="tonsac"] tonsac.rename(columns={'valor':'(Ton_AH)'}, inplace=True) tonsac.drop(['variable'], axis=1, inplace=True) #fin tonsac dataframe #tonsah datframe inicio tonsah=df[df["variable"]=="tonsah"] tonsah.rename(columns={'valor':'(TON_AC)'}, inplace=True) tonsah.drop(['variable'], axis=1, inplace=True) #fin tonsah dataframe #unimos los dataframe procesados pero comparando las fechas unido=pd.merge(kw1, kw2, on='fechafull') unido=pd.merge(unido, kw3, on='fechafull') unido=pd.merge(unido, kw4, on='fechafull') unido=pd.merge(unido, kw5, on='fechafull') unido=pd.merge(unido, kw6, on='fechafull') unido=pd.merge(unido, kw7, on='fechafull') unido=pd.merge(unido, tonsac, on='fechafull') unido=pd.merge(unido, tonsah, on='fechafull') unido = unido.set_index('fechafull') BMS=pd.DataFrame(unido)#Creamos un nuevo dataframe. # Realizar el muestreo a frecuencia horaria df_Hora_A_Hora = BMS.resample('H').mean() #creamos lista de las columnas a sumar lista_Para_Sumar=['CHILLER_DAIKIN_[kWh]','TEMPLIFIER_[kWh]','Bombas_AH_[kWh]','BombaTorrre_[kWh]','AbanicoTorre_[kWh]','BOMBA_TEMPLIFIER_[kWh]','BOMBA_AC_[kW]']#crear lista con las columnas se sumaran. #creamos un nuevo dataframe con el resultado y Le asignamos la lista a nuestro dataframe df_Hora_A_Hora['PRINCIPAL_PLANTA_AH_[KwH]']= df_Hora_A_Hora[lista_Para_Sumar].sum(axis=1) # Imprimir o retornar el nuevo DataFrame #print(df_Hora_A_Hora) #Información de utilidad: """ A continuación, utilizamos resample('H') para realizar el muestreo a una frecuencia horaria. La función mean() se utiliza para calcular el valor promedio de los datos en cada hora. Puedes cambiar mean() a otra función de agregación, como sum() o max(), según tus necesidades. """ #df_Hora_A_Hora=df_Hora_A_Hora.applymap(lambda x: str(x).replace('.', ',')) # Exportar el DataFrame a un archivo Excel # Reemplazar puntos por comas solo en la columna "Columna1" #df_Hora_A_Hora["(Ton_AH)"]= df_Hora_A_Hora["(Ton_AH)"]*100 #df_Hora_A_Hora['(Ton_AH)'] = df_Hora_A_Hora['(Ton_AH)'].str.replace(',', '.').astype(float) #df_Hora_A_Hora=df_Hora_A_Hora["(Ton_AH)"].applymap(lambda x: f"{x:.3f}".replace('.', ',')) #nombre_archivo = 'Tabla_BMS.xlsx' #df_Hora_A_Hora.to_excel(nombre_archivo, index=True) #print(df_Hora_A_Hora) return df_Hora_A_Hora def Tabla_PLC(inicio, fin): # SQL Y DATAFRAME DE LOS DATOS columnas=['id','fechadia', 'fechahora', 'flujo_agua', 'flujo_gas', 'flujo_vapor_entrada_tanque', 'flujo_vapor_salida_caldera', 'medidor_principal_potencia_activa_fase_a', 'medidor_principal_potencia_activa_fase_b', 'medidor_principal_potencia_activa_fase_c', 'medidor_principal_potencia_aparente_fase_a', 'medidor_principal_potencia_aparente_fase_b','medidor_principal_potencia_aparente_fase_c', 'medidor_principal_potencia_reactiva_fase_a', 'medidor_principal_potencia_reactiva_fase_b', 'medidor_principal_potencia_reactiva_fase_c', 'temp_entrada', 'temp_entrada_tanque', 'temp_salida', 'totalizador_agua']#definimos columnas sql = "select * from wyndham where fechadia between '"+str(inicio)+"' and '"+str(fin)+"'"#sql de los datos #sql = "SELECT * FROM `monitoringwyndham` WHERE `fechadia` BETWEEN '"+str(inicio)+"' AND '"+str(fin)+"';"#sql de los datos df=data_Postgres(sql,columnas)#llamamos la funcion y le mandamos los pàrametros #Creacion de dataframe que se necesitan df.rename(columns={'temp_entrada':'Temp_Entrada (°C)'},inplace=True)#Cambiar nombre de la columna df.rename(columns={"temp_salida":"Temp_SALIDA (°C)"},inplace=True)#Cambiar nombre de la columna df.rename(columns={"flujo_gas":"GAS-FLUJO (l/s)"},inplace=True)#Cambiar nombre de la columna df.rename(columns={"flujo_vapor_entrada_tanque":"WHY_PLC 19 - Totalizado de Vapor entrada Tanque"},inplace=True)#Cambiar nombre de la columna df.rename(columns={"flujo_vapor_salida_caldera":"WHY_PLC 17 - Totalizado de Vapor Salida Caldera"},inplace=True)#Cambiar nombre de la columna df.rename(columns={"flujo_agua":"AguaFlujoAC [m3/h]"},inplace=True)#Cambiar nombre de la columna df["PRINCIPAL HOTEL_[kWh]"]=0 df["Máx. de AGUA AC(m3)"]=0 df["Máx. de GAS(l)"]=0 df['fechafull']= pd.to_datetime(df['fechafull'])#convertir a formato de tiempo df.set_index('fechafull', inplace=True)#crear indice # Convertir las columnas de tipo object a int64 o float df['AguaFlujoAC [m3/h]'] = df['AguaFlujoAC [m3/h]'].str.replace(',', '').astype(float) df['Temp_Entrada (°C)'] = df['Temp_Entrada (°C)'].str.replace(',', '').astype(float) df['Temp_SALIDA (°C)'] = df['Temp_SALIDA (°C)'].str.replace(',', '').astype(float) df['GAS-FLUJO (l/s)'] = df['GAS-FLUJO (l/s)'].str.replace(',', '').astype(float) df['WHY_PLC 17 - Totalizado de Vapor Salida Caldera'] = df['WHY_PLC 17 - Totalizado de Vapor Salida Caldera'].str.replace(',', '').astype(float) df['WHY_PLC 19 - Totalizado de Vapor entrada Tanque'] = df['WHY_PLC 19 - Totalizado de Vapor entrada Tanque'].str.replace(',', '').astype(float) df['medidor_principal_potencia_reactiva_fase_c'] = df['medidor_principal_potencia_reactiva_fase_c'].str.replace(',', '').astype(float) df['totalizador_agua'] = df['totalizador_agua'].str.replace(',', '').astype(float) df['temp_entrada_tanque'] = df['temp_entrada_tanque'].str.replace(',', '').astype(float) df['medidor_principal_potencia_reactiva_fase_b'] = df['medidor_principal_potencia_reactiva_fase_b'].str.replace(',', '').astype(float) df['medidor_principal_potencia_reactiva_fase_a'] = df['medidor_principal_potencia_reactiva_fase_a'].str.replace(',', '').astype(float) df['medidor_principal_potencia_aparente_fase_c'] = df['medidor_principal_potencia_aparente_fase_c'].str.replace(',', '').astype(float) df['medidor_principal_potencia_aparente_fase_b'] = df['medidor_principal_potencia_aparente_fase_b'].str.replace(',', '').astype(float) df['medidor_principal_potencia_aparente_fase_a'] = df['medidor_principal_potencia_aparente_fase_a'].str.replace(',', '').astype(float) df['medidor_principal_potencia_activa_fase_c'] = df['medidor_principal_potencia_activa_fase_c'].str.replace(',', '').astype(float) df['medidor_principal_potencia_activa_fase_a'] = df['medidor_principal_potencia_activa_fase_a'].str.replace(',', '').astype(float) df['medidor_principal_potencia_activa_fase_b'] = df['medidor_principal_potencia_activa_fase_b'].str.replace(',', '').astype(float) # Realizar el muestreo a frecuencia horaria df_Hora_A_Hora = df.resample('H').mean() df_Hora_A_Hora=df_Hora_A_Hora.round(2) #df_Hora_A_Hora = df_Hora_A_Hora.applymap(lambda x: str(x).replace('.', ',')) #print(df) #nombre_archivo = 'Tabla_plc.xlsx' #df_Hora_A_Hora.to_excel(nombre_archivo, index=True) return df_Hora_A_Hora def DATOS_PM_BMS(inicio, fin, PM, BMS): DF_PM=PM DF_BMS=BMS#guaradr en variable la tabla del| df_Principal=pd.DataFrame() df_Principal['PRINCIPALPLANTA_AH [KwH]']=DF_BMS['PRINCIPAL_PLANTA_AH_[KwH]']#BMS df_Principal['CHILLERDAIKIN [kWh]']=DF_BMS['CHILLER_DAIKIN_[kWh]']#BMS df_Principal['TEMPLIFIER [kWh]']=DF_BMS['TEMPLIFIER_[kWh]']#BMS df_Principal['BOMBA_AC_[kWh]']=DF_BMS['BOMBA_AC_[kW]']#BMS df_Principal['BOMBATEMPLIFIER [kWh]']=DF_BMS['BOMBA_TEMPLIFIER_[kWh]']#BMS df_Principal['BombasAH [kWh]']=DF_BMS['Bombas_AH_[kWh]']#BMS df_Principal['BombaTorrre [kWh]']=DF_BMS['BombaTorrre_[kWh]']#BMS df_Principal['AbanicoTorre [kWh]']=DF_BMS['AbanicoTorre_[kWh]']#BMS df_Principal['FLUJO_GAS_[L/S]']=DF_PM['GAS-FLUJO (l/s)']#PM df_Principal['GAS_ACUMULADO_[L]']=DF_PM['Máx. de GAS(l)']#PM****** df_Principal['FLUJO_AC_[m3/h]']=DF_PM['AguaFlujoAC [m3/h]']#PM df_Principal['AC_ACUMULADO_[M3]']=DF_PM['Máx. de AGUA AC(m3)']#PM****** df_Principal['TEMPERATURA_ENTRADA_[°c]']=DF_PM['Temp_Entrada (°C)']#PM df_Principal['TEMPERATURA_SALIDA_[°C]']=DF_PM['Temp_SALIDA (°C)']#PM df_Principal['PRINCIPAL_HOTEL_[KwH]']=DF_PM['PRINCIPAL HOTEL_[kWh]']#PM********* #suma de las siguientes columnas Suma_Auxiliares=["BOMBA_AC_[kWh]","BOMBATEMPLIFIER [kWh]","BombasAH [kWh]","BombaTorrre [kWh]","AbanicoTorre [kWh]"] df_Principal['AUXILIARES [KWH]']=df_Principal[Suma_Auxiliares].sum(axis=1)#suma df_Principal['Chiller_Daikin_AH_(Ton_AH)']=DF_BMS['(Ton_AH)']#BMS df_Principal['Chiller_Daikin_AH_(Ton_AH)'] = df_Principal['Chiller_Daikin_AH_(Ton_AH)'].apply(lambda x: round(x * 100, 2)) df_Principal['Chiller_Daikin_AC_(Ton_AC)']=DF_BMS['(TON_AC)']#BMS-------- #Resta de las columnas para sacar el aux df_Principal['AUX CHILLER [kWh]']=df_Principal['PRINCIPALPLANTA_AH [KwH]']-df_Principal["TEMPLIFIER [kWh]"]-df_Principal["CHILLERDAIKIN [kWh]"]-df_Principal["BOMBA_AC_[kWh]"]-df_Principal["BOMBATEMPLIFIER [kWh]"] #division de columnas df_Principal['CHILLER_DAIKIN_FACTOR kWh/TAH']=df_Principal['CHILLERDAIKIN [kWh]']/df_Principal["Chiller_Daikin_AH_(Ton_AH)"]#operación Suma_Chiller_Mas_Aux=["AbanicoTorre [kWh]","BombaTorrre [kWh]","BombasAH [kWh]","CHILLERDAIKIN [kWh]"]#arreglo para sumar #Se suma y luego se divide por las siguientes columnas:----------DATOS PRINCIPAL df_Principal["CHILLER_DAIKIN_+_AUX_FACTOR kWh/TAH"]=df_Principal[Suma_Chiller_Mas_Aux].sum(axis=1)/df_Principal["Chiller_Daikin_AH_(Ton_AH)"]#sumar y dividir #RESTAR ENTRE UNA COLUMNA MENOS EL DATO ANTERIOR----------DATOS PM df_Principal["CONSUMO VAPOR SALIDA CALDERA"]=DF_PM["WHY_PLC 17 - Totalizado de Vapor Salida Caldera"]-DF_PM['WHY_PLC 17 - Totalizado de Vapor Salida Caldera'].shift() #RESTAR ENTRE UNA COLUMNA MENOS EL DATO ANTERIOR--------- DATOS PM df_Principal["CONSUMO VAPOR ENTRADA TANQUE"]=DF_PM["WHY_PLC 19 - Totalizado de Vapor entrada Tanque"]-DF_PM['WHY_PLC 19 - Totalizado de Vapor entrada Tanque'].shift() df_Principal["CONSUMO VAPOR LAVANDERÍA"]=df_Principal["CONSUMO VAPOR SALIDA CALDERA"]-df_Principal["CONSUMO VAPOR ENTRADA TANQUE"]#PRINCIPAL df_Principal["CONSUMO AGUA CALIENTE"]=DF_PM["Máx. de AGUA AC(m3)"]-DF_PM["Máx. de AGUA AC(m3)"].shift()#RESTAR MENOS EL DATO ANTERIOR---PM******** df_Principal["CONSUMO GAS"]=DF_PM["Máx. de GAS(l)"]-DF_PM["Máx. de GAS(l)"].shift()#PM******* #nombre_archivo = 'Tabla_PM_BMS.xlsx' #df_Principal.to_excel(nombre_archivo, index=True) return df_Principal def Consolidado_Diario(inicio, fin, PM, BMS): datos=DATOS_PM_BMS(inicio, fin, PM, BMS) datos=datos.reset_index()#Resetiamos el index datos['fechafull'] = pd.to_datetime(datos['fechafull'])#Convertimos la columna en formato de tiempo datos['Fecha'] = datos['fechafull'].dt.date#creamos columna con solo la fecha datos['hora'] = datos['fechafull'].dt.time#Creamos columna con solo la hora #--------creacion de columnas para luego concatenarlas ----- #Chiller Daikin [kWh/dia] Chiller_Daikin_kwh_dia = datos.groupby('Fecha')['CHILLERDAIKIN [kWh]'].sum().reset_index()#Agrupamos las fechas iguales y lo sumamos. Chiller_Daikin_kwh_dia.rename(columns={'CHILLERDAIKIN [kWh]':'Chiller Daikin [kWh/dia]'}, inplace=True)#Renombramos la columna. #Templifier [kWh/dia] Templifier_KwH_Dia=datos.groupby('Fecha')['TEMPLIFIER [kWh]'].sum().reset_index()#Agrupamos las fechas iguales y lo sumamos. Templifier_KwH_Dia.rename(columns={'TEMPLIFIER [kWh]':'Templifier [kWh/dia]'}, inplace=True)#Renombramos la columna. #Planta_Principal_AH_kWh/dia Planta_Principal_AH_kWh_dia=datos.groupby('Fecha')['PRINCIPALPLANTA_AH [KwH]'].sum().reset_index()#Agrupamos las fechas iguales y lo sumamos. Planta_Principal_AH_kWh_dia.rename(columns={'PRINCIPALPLANTA_AH [KwH]':'Planta Principal AH [kWh/dia]'}, inplace=True)#Renombramos la columna. #Chiller + Auxiliares [kWh/dia]#Sirve para mensual suma_Chiller_Mas_Aux=["CHILLERDAIKIN [kWh]","AUX CHILLER [kWh]"] Suma_Chiller_Mas_Auxiliares_kWh_Dia=datos.groupby('Fecha')[suma_Chiller_Mas_Aux].sum().reset_index() Chiller_Mas_Auxiliares_kWh_Dia=pd.DataFrame() Chiller_Mas_Auxiliares_kWh_Dia["Fecha"]=Suma_Chiller_Mas_Auxiliares_kWh_Dia["Fecha"] Chiller_Mas_Auxiliares_kWh_Dia["Chiller + Auxiliares [kWh/dia]"]=Suma_Chiller_Mas_Auxiliares_kWh_Dia[suma_Chiller_Mas_Aux].sum(axis=1) #Consumo_Agua_caliente_medido_m3_dia Consumo_Agua_caliente_medido_m3_dia=datos.groupby('Fecha')['FLUJO_AC_[m3/h]'].sum().reset_index()#Agrupamos las fechas iguales y lo sumamos. Consumo_Agua_caliente_medido_m3_dia.rename(columns={'FLUJO_AC_[m3/h]':'Consumo Agua caliente medido [m3/dia]'}, inplace=True)#Renombramos la columna. #Consumo_Agua_Caliente_Arreglado_m3_día Consumo_Agua_Caliente_Arreglado_m3_día=datos.groupby('Fecha')['CONSUMO AGUA CALIENTE'].sum().reset_index()#Agrupamos las fechas iguales y lo sumamos. Consumo_Agua_Caliente_Arreglado_m3_día.rename(columns={'CONSUMO AGUA CALIENTE':'Consumo Agua Caliente arreglado [m3/día]'}, inplace=True)#Renombramos la columna. #Consumo Gas LP [l/dia] CONSUMO_GAS=datos.groupby("Fecha")["CONSUMO GAS"].sum().reset_index() CONSUMO_GAS.rename(columns={"CONSUMO GAS":"Consumo Gas LP [l/dia]"}, inplace=True) #Consumo AH [Ton/dia]#columna que sirve para mensual||| Consumo_AH_Ton_dia=datos.groupby("Fecha")["Chiller_Daikin_AH_(Ton_AH)"].sum().reset_index() Consumo_AH_Ton_dia.rename(columns={"Chiller_Daikin_AH_(Ton_AH)":"Consumo AH [Ton/dia]"}, inplace=True) #unir todos los dataframe por fechas df_Principal=pd.merge(Chiller_Daikin_kwh_dia, Templifier_KwH_Dia, on='Fecha')#unir por fechas df_Principal=pd.merge(df_Principal, Planta_Principal_AH_kWh_dia, on='Fecha')#unir por fechas df_Principal=pd.merge(df_Principal, Chiller_Mas_Auxiliares_kWh_Dia, on='Fecha')#unir por fechas df_Principal=pd.merge(df_Principal, Consumo_Agua_caliente_medido_m3_dia, on='Fecha')#unir por fechas df_Principal=pd.merge(df_Principal, Consumo_Agua_Caliente_Arreglado_m3_día, on='Fecha')#unir por fechas df_Principal=pd.merge(df_Principal, CONSUMO_GAS, on='Fecha')#unir por fechas df_Principal=pd.merge(df_Principal, Consumo_AH_Ton_dia, on='Fecha')#unir por fechas #Rendimiento Planta AH [kWh/Ton] Rendimiento_Planta_AH_kWh_Ton=datos.groupby("Fecha")["CHILLER_DAIKIN_+_AUX_FACTOR kWh/TAH"].mean().reset_index() Rendimiento_Planta_AH_kWh_Ton.rename(columns={"CHILLER_DAIKIN_+_AUX_FACTOR kWh/TAH":"Rendimiento Planta AH [kWh/Ton]"}, inplace=True) #Tabla de chillerantiguo #----historial rendimiento----------------------- Rendimiento_Planta_AH_kWh_Ton["Fecha"]=pd.to_datetime(Rendimiento_Planta_AH_kWh_Ton["Fecha"]) sql2="SELECT fecha, totalizador FROM public.wyndhamrendimientoplantaah ORDER BY id DESC LIMIT 1;" columna2= ["fecha","totalizador"] UltimoDatoPlanta= Datos_Rendimiento_PLanta_Acomulado(sql2, columna2) UltimoDatoPlanta.rename(columns={"fecha":"Fecha"}, inplace=True) UltimoDatoPlanta["Fecha"]= pd.to_datetime(UltimoDatoPlanta['Fecha']) #condicion UltimoDatoPlanta=UltimoDatoPlanta.at[0, 'Fecha'] Rendimiento_Planta_AH_kWh_Ton= Rendimiento_Planta_AH_kWh_Ton.fillna(0) Datos_actualizar_rendimiento=[] for index, row in Rendimiento_Planta_AH_kWh_Ton.iterrows(): FechaRendimiento= row["Fecha"] valor=row["Rendimiento Planta AH [kWh/Ton]"] if FechaRendimiento > UltimoDatoPlanta: #----------- Datos_actualizar_rendimiento.append([FechaRendimiento,valor]) print("Hola soy mayor que la fecha del ultimo dato") #---guardar en la bd #Guardar en la base de datos if len(Datos_actualizar_rendimiento)>0: df = pd.DataFrame(Datos_actualizar_rendimiento, columns=['Fecha', 'totalizador']) df.rename(columns={'Fecha': 'fecha'}, inplace=True) #print(df) if df.size > 0 : loadtosqlRendimiento('wyndhamrendimientoplantaah',df,"Historial") sql = "SELECT AVG(CAST(totalizador AS DECIMAL)) AS promedio_totalizador FROM public.wyndhamrendimientoplantaah" columnas = ["totalizador"] Historial_Planta = Datos_Rendimiento_PLanta_Acomulado(sql, columnas) Dato_Promedio_Rendimiento_PLanta=float(Historial_Planta["totalizador"]) else: sql = "SELECT AVG(CAST(totalizador AS DECIMAL)) AS promedio_totalizador FROM public.wyndhamrendimientoplantaah" columnas = ["totalizador"] Historial_Planta = Datos_Rendimiento_PLanta_Acomulado(sql, columnas) Dato_Promedio_Rendimiento_PLanta=float(Historial_Planta["totalizador"]) Dato_Promedio_Rendimiento_PLanta= round(float(Dato_Promedio_Rendimiento_PLanta), 2) print("Dato_Promedio_Rendimiento_PLanta") print(Dato_Promedio_Rendimiento_PLanta) Redimiento_Chiller_Antiguo=2.75 #Ahorro planta AH[kWh/dia]#Esto sirve para mensual Total=Redimiento_Chiller_Antiguo-Dato_Promedio_Rendimiento_PLanta df_Principal["Ahorro Planta AH [kWh/dia]"]=df_Principal['Consumo AH [Ton/dia]']*Total #Producción AC [Ton/dia] Producción_AC_Ton_dia=datos.groupby("Fecha")["Chiller_Daikin_AC_(Ton_AC)"].sum().reset_index() Producción_AC_Ton_dia.rename(columns={"Chiller_Daikin_AC_(Ton_AC)":"Producción AC [Ton/dia]"}, inplace=True) df_Principal=pd.merge(df_Principal, Producción_AC_Ton_dia, on='Fecha')#unir por fechas #Energia termica df_Principal["Energia Termica [kWh/dia]"]=df_Principal["Producción AC [Ton/dia]"]*3.52 #Ahorro gas lp Eficiencia_Global = 0.84 * 0.80 Porder_Calorífico_Gas_LP=(6350*4.18)/3600 df_Principal["Ahorro Gas LP [l/dia]"]=(df_Principal["Energia Termica [kWh/dia]"]/Eficiencia_Global)*(1/Porder_Calorífico_Gas_LP) #print(df_Principal) #nombre_archivo = 'TConsolidado_Diario.xlsx' #df_Principal.to_excel(nombre_archivo, index=True) return df_Principal def Reporte_Mensual(inicio, fin, PM, BMS): Datos_Diario=Consolidado_Diario(inicio, fin, PM, BMS) df_Principal=pd.DataFrame() #Hacer las sumatorias de cada columna ConsumoAH=Datos_Diario.groupby("Fecha")["Consumo AH [Ton/dia]"].sum().reset_index() Chiller_Mas_Aux=Datos_Diario.groupby("Fecha")["Chiller + Auxiliares [kWh/dia]"].sum().reset_index() Ahorro_Planta=Datos_Diario.groupby("Fecha")["Ahorro Planta AH [kWh/dia]"].sum().reset_index() Produccion_AC=Datos_Diario.groupby("Fecha")["Producción AC [Ton/dia]"].sum().reset_index() Templifier=Datos_Diario.groupby("Fecha")["Templifier [kWh/dia]"].sum().reset_index() Ahorro_Gas_Lp=Datos_Diario.groupby("Fecha")["Ahorro Gas LP [l/dia]"].sum().reset_index() df_Principal=pd.merge(ConsumoAH, Chiller_Mas_Aux, on='Fecha')#unir por fechas df_Principal=pd.merge(df_Principal, Ahorro_Planta, on='Fecha')#unir por fechas # Quitar el signo negativo de la columna df_Principal['Ahorro Planta AH [kWh/dia]'] = df_Principal['Ahorro Planta AH [kWh/dia]'].abs() df_Principal['Chiller + Auxiliares [kWh/dia]'] = df_Principal['Chiller + Auxiliares [kWh/dia]'].abs() df_Principal['Consumo AH [Ton/dia]'] = df_Principal['Consumo AH [Ton/dia]'].abs() # Modificar los decimales en la columna df_Principal['Ahorro Planta AH [kWh/dia]'] = df_Principal['Ahorro Planta AH [kWh/dia]'].astype(int) df_Principal['Chiller + Auxiliares [kWh/dia]'] = df_Principal['Chiller + Auxiliares [kWh/dia]'].astype(int) df_Principal['Consumo AH [Ton/dia]'] = df_Principal['Consumo AH [Ton/dia]'].astype(int) # Aplicar formato a la columna df_Principal['Ahorro Planta AH [kWh/dia]'] = df_Principal['Ahorro Planta AH [kWh/dia]'].apply(lambda x: '{0:,}'.format(x).replace(',', '.')) df_Principal['Chiller + Auxiliares [kWh/dia]'] = df_Principal['Chiller + Auxiliares [kWh/dia]'].apply(lambda x: '{0:,}'.format(x).replace(',', '.')) #convertir columnas a tipo numerico. df_Principal['Chiller + Auxiliares [kWh/dia]'] = pd.to_numeric(df_Principal['Chiller + Auxiliares [kWh/dia]'], errors='coerce') df_Principal['Ahorro Planta AH [kWh/dia]'] = pd.to_numeric(df_Principal['Ahorro Planta AH [kWh/dia]'], errors='coerce') #Acumulado Ahorro planta------.--------.----- df_Principal['Acumulado Ahorro Planta AH [kWh/dia]'] = df_Principal['Ahorro Planta AH [kWh/dia]'].cumsum()#se utiliza cumsum() para calcular la suma acumulada de los valores #PRODUCCION AC-------------- df_Principal=pd.merge(df_Principal, Produccion_AC, on='Fecha')#unir por fechas df_Principal['Producción AC [Ton/dia]'] = df_Principal['Producción AC [Ton/dia]'].astype(int)#Quitar decimales df_Principal['Producción AC [Ton/dia]'] = df_Principal['Producción AC [Ton/dia]'].apply(lambda x: '{0:,}'.format(x).replace(',', '.')) #Templifier [kWh/dia] df_Principal=pd.merge(df_Principal, Templifier, on='Fecha')#unir por fechas df_Principal['Templifier [kWh/dia]'] = df_Principal['Templifier [kWh/dia]'].astype(int)#Quitar decimales #Ahorro Gas LP [l/dia] df_Principal=pd.merge(df_Principal, Ahorro_Gas_Lp, on='Fecha')#unir por fechas df_Principal['Ahorro Gas LP [l/dia]'] = df_Principal['Ahorro Gas LP [l/dia]'].astype(int)#Quitar decimales #print(df_Principal['Ahorro Gas LP [l/dia]']) #nombre_archivo = 'Reporte_Mensual.xlsx' #df_Principal.to_excel(nombre_archivo, index=True) return df_Principal #INICIO-----Metodos para graficar-------------INICIO def Datos_Grafica_Consumo_AH(inicio, fin, PM, BMS): datos=Reporte_Mensual(inicio, fin, PM, BMS) df_Principal=pd.DataFrame() df_Principal["Fecha"]=datos["Fecha"] df_Principal["Consumo AH [Ton/dia]"]=datos["Consumo AH [Ton/dia]"] #df_principal['Consumo AH [Ton/dia]'] = df_principal['Consumo AH [Ton/dia]'].apply('{:,.2f}'.format) return df_Principal def Datos_Grafica_Chiller_aux(inicio, fin, PM, BMS): datos=Reporte_Mensual(inicio, fin, PM, BMS) df_Principal=pd.DataFrame() df_Principal["Fecha"]=datos["Fecha"] df_Principal["Consumo Chiller + aux [kWh/dia]"]=datos["Chiller + Auxiliares [kWh/dia]"] #df_principal['Consumo Chiller + aux [kWh/dia]'] = df_principal['Consumo Chiller + aux [kWh/dia]'].apply('{:,.2f}'.format) return df_Principal def Datos_Grafica_Ahorro_PLanta(inicio, fin, PM, BMS): datos=Reporte_Mensual(inicio, fin, PM, BMS) df_Principal=pd.DataFrame() df_Principal["Fecha"]=datos["Fecha"] df_Principal["Ahorro Planta AH [kWh/dia]"]=datos["Ahorro Planta AH [kWh/dia]"] #df_principal['Ahorro Planta AH [kWh/dia]'] = df_principal['Ahorro Planta AH [kWh/dia]'].apply('{:,.2f}'.format) return df_Principal def Datos_Grafica_Produccion_AC(inicio, fin, PM, BMS): datos=Reporte_Mensual(inicio, fin, PM, BMS) df_Principal=pd.DataFrame() df_Principal["Fecha"]=datos["Fecha"] df_Principal["Producción AC [Ton/dia]"]=datos["Producción AC [Ton/dia]"] #df_principal['Producción AC [Ton/dia]'] = df_principal['Producción AC [Ton/dia]'].apply('{:,.2f}'.format) return df_Principal def Datos_Grafica_Templifier(inicio, fin, PM, BMS): datos=Reporte_Mensual(inicio, fin, PM, BMS) df_Principal=pd.DataFrame() df_Principal["Fecha"]=datos["Fecha"] df_Principal["Templifier [kWh/dia]"]=datos["Templifier [kWh/dia]"] #df_principal['Templifier [kWh/dia]'] = df_principal['Templifier [kWh/dia]'].apply('{:,.2f}'.format) return df_Principal #FIN---------Metodos para graficar------------------FIN def Ahorros_Energeticos(inicio, fin, PM, BMS): datos=Reporte_Mensual(inicio, fin, PM, BMS) Planta_de_Agua_Helada=(datos["Ahorro Planta AH [kWh/dia]"].mean())*(datos['Ahorro Planta AH [kWh/dia]'].value_counts().sum()) Consumo_Promedio_Templifier=(datos["Templifier [kWh/dia]"].mean())*(datos["Templifier [kWh/dia]"].value_counts().sum()) Consumo_Promedio_Templifier = "{:,.0f}".format(Consumo_Promedio_Templifier).replace(',', '.') Consumo_Promedio_Templifier=float(Consumo_Promedio_Templifier) Minisplit_Inverter=float(10.057) Iluminación_LED=float(19.694) Ahorro_Promedio_EE=float(Iluminación_LED)+float(Minisplit_Inverter)+float(Planta_de_Agua_Helada)-float(Consumo_Promedio_Templifier) Ahorro_Promedio_EE_Año=Ahorro_Promedio_EE*12 Porcentaje_Ahorro_EE_MES=(Ahorro_Promedio_EE/(float(10.357)*(datos['Ahorro Planta AH [kWh/dia]'].value_counts().sum()))) Porcentaje_Ahorro_EE_MES=Porcentaje_Ahorro_EE_MES*100 Datos_Para_Dataframe=[{"Variable":"Planta de Agua Helada [kWh/mes]", "Valor":Planta_de_Agua_Helada}, {"Variable":"Consumo Promedio Templifier [kWh/mes]","Valor":Consumo_Promedio_Templifier}, {"Variable":"Minisplit Inverter [kWh/mes]","Valor":Minisplit_Inverter}, {"Variable":"Iluminación LED [kWh/mes]","Valor":Iluminación_LED}, {"Variable":"Ahorro Promedio EE [kWh/mes]","Valor":Ahorro_Promedio_EE}, {"Variable":"Ahorro Promedio EE [kWh/año]","Valor":Ahorro_Promedio_EE_Año}, {"Variable":"% Ahorro [EE/mes]","Valor":Porcentaje_Ahorro_EE_MES}] df_principal=pd.DataFrame(Datos_Para_Dataframe) # Organizar la columna 'Valor' con comas df_principal['Valor'] = df_principal['Valor'].apply('{:,.2f}'.format) return df_principal def proyecciones(inicio, fin, PM, BMS): datos=Reporte_Mensual(inicio, fin, PM, BMS) Ahorro_GLP_Mensual=(datos["Ahorro Gas LP [l/dia]"].mean())*(datos["Ahorro Gas LP [l/dia]"].value_counts().sum()) Ahorro_Gas_Mensual_porcentaje= Ahorro_GLP_Mensual/(942*datos["Ahorro Gas LP [l/dia]"].value_counts().sum()) Ahorro_Gas_Mensual_porcentaje= Ahorro_Gas_Mensual_porcentaje*100 Ahorro_GLP_Anual=Ahorro_GLP_Mensual*12 Ahorro_Gas_Anual_Porcentaje=Ahorro_GLP_Mensual*12/294446 Ahorro_Gas_Anual_Porcentaje=Ahorro_Gas_Anual_Porcentaje*100#multiplicar por 100 para sacar el porciento Ahorro_Planta_AH_Anual=(datos["Ahorro Planta AH [kWh/dia]"].mean())*float(0.365) Datos_Para_Dataframe=[{"Variable":"Ahorro GLP Mensual [GLP/mes]", "Valor":Ahorro_GLP_Mensual}, {"Variable":"% Ahorro Gas Mensual","Valor":Ahorro_Gas_Mensual_porcentaje}, {"Variable":"Ahorro GLP Anual [GLP/año]","Valor":Ahorro_GLP_Anual}, {"Variable":"% Ahorro Gas Anual","Valor":Ahorro_Gas_Anual_Porcentaje}, {"Variable":"Ahorro Planta AH Anual [GWh/año]","Valor":Ahorro_Planta_AH_Anual}] df_principal=pd.DataFrame(Datos_Para_Dataframe) #df['col1'] = df['col1'].round().astype(int)#Quitar decimales y redondearlos # Organizar la columna 'Valor' con comas df_principal['Valor'] = df_principal['Valor'].apply('{:,.3f}'.format) #print(df_principal) return df_principal ############# CÓDIGO WSGI APACHE2 UBUNTU ###################################################### def application(environ, start_response): #global inicio, fin, condicion status = '200 OK' response_headers = [('Content-type', 'text/plain')] try: #Hacer consulta del periodo para hacer el resto de metodos columnas_Periodo=["id ","Inicio","Fin"] sql_Periodo="SELECT * FROM `periodo`" Data_Periodo=Consultar_Periodo(sql_Periodo,columnas_Periodo) inicio=Data_Periodo["Inicio"][0] fin=Data_Periodo["Fin"][0] #condicion="Tabla_Reporte_Mensual" #llamar las consulas para agilizar el tiempo de carga PM=Tabla_PLC(inicio, fin) BMS=Tabla_BMS(inicio, fin) #Guardar cada tabla en la base de datos. #-------------------------------------------------------------------- Tabla_Principal_Reporte_Mensual=Reporte_Mensual(inicio, fin, PM, BMS) #Guardar en la base de datos if len(Tabla_Principal_Reporte_Mensual)>0: df=pd.DataFrame(Tabla_Principal_Reporte_Mensual,columns =['Fecha', 'Consumo AH [Ton/dia]', 'Chiller + Auxiliares [kWh/dia]', 'Ahorro Planta AH [kWh/dia]','Acumulado Ahorro Planta AH [kWh/dia]','Producción AC [Ton/dia]','Templifier [kWh/dia]','Ahorro Gas LP [l/dia]']) df.rename(columns={'Fecha': 'fecha','Consumo AH [Ton/dia]': 'consumo_ah','Chiller + Auxiliares [kWh/dia]': 'chiller_auxiliares','Ahorro Planta AH [kWh/dia]': 'ahorro_planta_ah','Acumulado Ahorro Planta AH [kWh/dia]': 'acumulado_ahorro_planta_ah','Producción AC [Ton/dia]': 'produccion_ac','Templifier [kWh/dia]': 'templifier','Ahorro Gas LP [l/dia]': 'ahorro_gas_lp'}, inplace=True) if df.size > 0 : loadtosql('reporte_mensual',df,"Reporte mensual") #-------------------------------------------------------------- Grafica_AH=Datos_Grafica_Consumo_AH(inicio, fin, PM, BMS) #Guardar en la base de datos if len(Grafica_AH)>0: df=pd.DataFrame(Grafica_AH,columns =['Fecha','Consumo AH [Ton/dia]']) df.rename(columns={"Consumo AH [Ton/dia]":"consumo"}, inplace=True) if df.size > 0 : loadtosql('grafica_consumo_ah',df,"Datos_Grafica_Consumo_AH") #--------------------------------------------------------------- Grafica_Chiller=Datos_Grafica_Chiller_aux(inicio, fin, PM, BMS) #Guardar en la base de datos if len(Grafica_Chiller)>0: df=pd.DataFrame(Grafica_Chiller,columns =['Fecha','Consumo Chiller + aux [kWh/dia]']) df.rename(columns={"Consumo Chiller + aux [kWh/dia]":"Consumo", "Fecha":"fecha"}, inplace=True) if df.size > 0 : loadtosql('grafica_chiller_aux',df,"Datos_Grafica_Chiller_aux") #------------------------------------------------------------------ Ahorro_Planta=Datos_Grafica_Ahorro_PLanta(inicio, fin, PM, BMS) #Guardar en la base de datos if len(Ahorro_Planta)>0: df=pd.DataFrame(Ahorro_Planta,columns =['Fecha','Ahorro Planta AH [kWh/dia]']) df.rename(columns={"Ahorro Planta AH [kWh/dia]":"consumo", "Fecha":"fecha"}, inplace=True) if df.size > 0 : loadtosql('grafica_ahorro_planta_ah',df,"Datos_Grafica_Ahorro_PLanta") #------------------------------------------------------------------ Grafica_Producion_AC=Datos_Grafica_Produccion_AC(inicio, fin, PM, BMS) #Guardar en la base de datos if len(Grafica_Producion_AC)>0: df=pd.DataFrame(Grafica_Producion_AC,columns =['Fecha','Producción AC [Ton/dia]']) df.rename(columns={"Producción AC [Ton/dia]":"consumo", "Fecha":"fecha"}, inplace=True) if df.size > 0 : loadtosql('grafica_produccion_ac',df,"Datos_Grafica_Produccion_AC") #------------------------------------------------------------------ Grafica_Templifier=Datos_Grafica_Templifier(inicio, fin, PM, BMS) #Guardar en la base de datos if len(Grafica_Templifier)>0: df=pd.DataFrame(Grafica_Templifier,columns =['Fecha','Templifier [kWh/dia]']) df.rename(columns={"Templifier [kWh/dia]":"consumo", "Fecha":"fecha"}, inplace=True) if df.size > 0 : loadtosql('grafica_templifier',df,"Datos_Grafica_Templifier") #------------------------------------------------------------------ Tabla_Ahorros_Energeticos=Ahorros_Energeticos(inicio, fin, PM, BMS) #Guardar en la base de datos if len(Tabla_Ahorros_Energeticos)>0: df=pd.DataFrame(Tabla_Ahorros_Energeticos,columns =['Variable','Valor']) if df.size > 0 : loadtosql('tabla_ahorros_energeticos',df,"Ahorros_Energeticos") #------------------------------------------------------------------ Tabla_proyecciones=proyecciones(inicio, fin, PM, BMS) #Guardar en la base de datos if len(Tabla_proyecciones)>0: df=pd.DataFrame(Tabla_proyecciones,columns =['Variable','Valor']) if df.size > 0 : loadtosql('tabla_proyecciones',df,"proyecciones") except Exception as e: status = '500 Internal Server Error' output = "Se produjo un error: " + str(e) + "\n" output += "Traceback:\n" + traceback.format_exc() response_headers = [('Content-type', 'text/html')] start_response(status, response_headers) return [output.encode()]