# Importación de librerias from datetime import date, datetime, timedelta import pandas as pd from random import randint import numpy as np import psycopg2 import psycopg2.extras as extras from sys import argv #recibir parametros import traceback ###################################################################################################################### # NOTA. En CRONTAB -E (script.sh) se está ejecutando cada minuto el reinicio del apache2: sudo service apache2 restart ###################################################################################################################### ################################################################################################################################# #Inicio-----------------------Funciones con conexion a la base de datos----------------------------------INICIO------------------ ################################################################################################################################# 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() ####### OBTENER VARIABLES GLOBALES ########################### def obtener_datos_fechareportewyndham(): # Establecer la conexión a la base de datos db = psycopg2.connect(host="198.27.67.220", database="mgmrenso_legola", user="mgmlegola", password="2s6kWSH5CYFG%5KT") cursor = db.cursor() # Ejecutar la consulta SELECT consulta = "SELECT id, fechainicio, fechafin, condicion FROM public.fechareportes WHERE id=1 AND nombrereporte='reporteWyndham'" #id cursor.execute(consulta) # Obtener los resultados de la consulta resultados = cursor.fetchall() # Visualizar los datos obtenidos for fila in resultados: id = fila[0] fechainicio = fila[1] fechafin = fila[2] condicion = fila[3] print(f"ID: {id}, Fecha inicio: {fechainicio}, Fecha fin: {fechafin}, Condición: {condicion}") # Devolver los resultados obtenidos return resultados datos = obtener_datos_fechareportewyndham() if datos is not None and len(datos) > 0: _, inicio, fin, condicion = datos[0] print("Inicio:", inicio) print("Fin:", fin) print("Condición:", condicion) else: # Manejo de caso cuando no se obtienen datos print("No se encontraron datos en la tabla.") ####### OBTENER VARIABLES GLOBALES ########################### #inicio = date(2022, 1, 1) # Inicializar con fecha "2022-01-04" #fin = date.today() # Asignar la fecha actual a la variable "fin" #condicion="Tabla_Reporte_Mensual" ############# CÓDIGO WSGI APACHE2 UBUNTU ###################################################### def application(environ, start_response): #global inicio, fin, condicion status = '200 OK' response_headers = [('Content-type', 'text/plain')] try: #condicion="Tabla_Reporte_Mensual" #df_Hora_A_Hora = Tabla_BMS(inicio, fin) df_BMS = Tabla_BMS(inicio, fin) df_PLC = Tabla_PLC(inicio, fin) df_DATOS_PM_BMS = DATOS_PM_BMS(inicio, fin, PM, BMS) df_Consolidado_Diario = Consolidado_Diario(inicio, fin, PM, BMS) df_Reporte_Mensual = Reporte_Mensual(inicio, fin, PM, BMS) df_combined = pd.concat([df_BMS, df_PLC, df_DATOS_PM_BMS, df_Consolidado_Diario, df_Reporte_Mensual], axis=1) # Combinar todos los DataFrames #df_Principal = Tabla_PLC(inicio, fin) #output = str(df_Hora_A_Hora) #output = df_Hora_A_Hora.to_string() #output = df_Hora_A_Hora.to_html() #output = df_Principal.to_html() output = df_combined.to_html() 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.append(('Content-Length', str(len(output)))) start_response(status, response_headers) return [output.encode()] ################################################################################################################################# #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. """ # Exportar el DataFrame a un archivo Excel #nombre_archivo = 'Tabla_BMS.xlsx' #df_Hora_A_Hora.to_excel(nombre_archivo, index=True) 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() #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_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******* 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 Dato_Promedio_Rendimiento_PLanta=Rendimiento_Planta_AH_kWh_Ton["Rendimiento Planta AH [kWh/Ton]"].mean() Redimiento_Chiller_Antiguo=2.26+0.8 #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) 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]']) 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()) Minisplit_Inverter=10057 Iluminación_LED=19694 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/(10357*(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_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())*0.365 Ahorro_Planta_AH_Anual=Ahorro_Planta_AH_Anual*100 Ahorro_Planta_AH_Anual=int(Ahorro_Planta_AH_Anual) 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('{:,.2f}'.format) #print(df_principal) return df_principal def Conteo(inicio, fin, PM, BMS): datos=Reporte_Mensual(inicio, fin, PM, BMS) Conteo=datos["Fecha"].value_counts().sum() return Conteo #Llamar las consulas para agilizar el tiempo de carga PM=Tabla_PLC(inicio, fin) BMS=Tabla_BMS(inicio, fin) #EJECUTAR FUNCIONES DE ACUERDO A LA NECESIDAD QUE TENGA #Mensual if condicion=="Tabla_Reporte_Mensual": resul=Reporte_Mensual(inicio, fin, PM, BMS) lista=resul.to_numpy() #Imprimir la data para php for i in lista: print("|".join(map(str, i))+str("|")) #Consumo ah grafica if condicion=="Grafica_Consumo_AH": resul=Datos_Grafica_Consumo_AH(inicio, fin, PM, BMS) lista=resul.to_numpy() #Imprimir la data para php for i in lista: print("|".join(map(str, i))+str("|")) # if condicion=="Grafica_Chiller_Aux": resul=Datos_Grafica_Chiller_aux(inicio, fin, PM, BMS) lista=resul.to_numpy() #Imprimir la data para php for i in lista: print("|".join(map(str, i))+str("|")) if condicion=="Grafica_Ahorro_Planta_AH": resul=Datos_Grafica_Ahorro_PLanta(inicio, fin, PM, BMS) lista=resul.to_numpy() #Imprimir la data para php for i in lista: print("|".join(map(str, i))+str("|")) #--------Grafica--------- Produccion AC----------- if condicion=="Grafica_Produccion_AC": resul=Datos_Grafica_Produccion_AC(inicio, fin, PM, BMS) lista=resul.to_numpy() #Imprimir la data para php for i in lista: print("|".join(map(str, i))+str("|")) #--------Grafica--------- Datos_Grafica_Templifier----------- if condicion=="Grafica_Templifier": resul=Datos_Grafica_Templifier(inicio, fin, PM, BMS) lista=resul.to_numpy() #Imprimir la data para php for i in lista: print("|".join(map(str, i))+str("|")) #--------Tabla ahorros energeticos----------- if condicion=="Tabla_Ahorros_Energeticos": resul=Ahorros_Energeticos(inicio, fin, PM, BMS) lista=resul.to_numpy() #Imprimir la data para php for i in lista: print("|".join(map(str, i))+str("|")) #--------Tabla Proyecciones----------- if condicion=="Tabla_Proyecciones": resul=proyecciones(inicio, fin, PM, BMS) lista=resul.to_numpy() #Imprimir la data para php for i in lista: print("|".join(map(str, i))+str("|")) #--------Conteo----------- if condicion=="Conteo": resul=Conteo(inicio, fin, PM, BMS) print(resul)