Initial commit

README.MD

@@ -0,0 +1,28 @@
+#简介
+>1、COP算法是一套基于制冷原理从冷媒循环侧实时计算机组能效的算法，其可根据机组的实际运行参数动态计算机组的能效值，让用户直接明了的获悉机组的实时能效水平。
+
+#结构说明
+>|--calculation #计算文件，计算机组的COP值
+|--communication #通讯文件，包括mysql读库模块、mq生产和消费消息模块、mysql通讯包
+|----config #配置文件，包括数据库配置信息（config.py）、配置信息映射模块（communicationConfig.py）
+|----normalization #包含格式化结果输出模块（constant.py），数据判断模块（data_normalization.py），数据获取模块（get_mysql_data.py）
+|----Logs #日志
+|----service #计算服务文件，包含算法计算服务模块（main_single_comp.py），计算服务判断模块（judge_handle_func.py）
+|----main.py #主程序（算法入口）
+
+#使用注意
+>1、只有机组COP计算服务开启才会进行计算
+2、该版本程序只支持单机头机组，暂不支持多机头机组
+
+#版本说明
+>版本号：V1.2  更新时间：2021.4.15  更新内容如下：
+1、更改机组结构参数判断逻辑；
+2、优化计算逻辑及数据判断逻辑；
+3、增加制热COP计算分支；
+4、封闭程序漏洞；
+版本号：V1.3 更新时间：2021.5.18   更新内容如下：
+1、增加算法延时触发机制
+2、优化程序BUG
+
+
+

calculation/calculation_process.py

@@ -0,0 +1,52 @@
+from normalization.constant import *
+from CoolProp.CoolProp import PropsSI
+from calculation.system_performance import DischargeTempModified, PerformanceCalculation
+
+class CalculationProcess(object):
+    def __init__(self, dict_input):
+        self.dict_input = dict_input
+        self.is_success = 0
+        self.results = {}
+        self.results_depict = ''
+
+    def pre_to_temp(self):
+        if self.dict_input["evapPre"] and not self.dict_input["evapTemp"]:
+            self.dict_input["evapTemp"] = PropsSI('T', 'P', self.dict_input['evapTemp']*1000,
+                                                  'Q', 1, self.dict_input['refrigerant']) - 273.15
+        if self.dict_input["condPre"] and not self.dict_input["condTemp"]:
+            self.dict_input["condTemp"] = PropsSI('T', 'P', self.dict_input['condTemp']*1000,
+                                                  'Q', 1, self.dict_input['refrigerant']) - 273.15
+
+    def judge_null(self):
+        Num = 0
+        self.pre_to_temp()
+        for k in self.dict_input:
+            if self.dict_input[k] == '':
+                Num += 1
+        return Num
+
+    def cop_calculation(self):
+        dtm = DischargeTempModified(self.dict_input)
+        self.dict_input = dtm.discharge_temp_modified()
+        pc=PerformanceCalculation(self.dict_input)
+        self.is_success, self.results_depict, self.results = pc.performance_calculation()
+        return None
+
+    def main_process(self):
+        number_null = self.judge_null()
+        if number_null > 0:
+            self.results_depict = '输入参数存在空值，无计算结果'
+        else:
+            if self.dict_input['unitStatus'] == 0:
+                self.results_depict = '冷机处于关机状态，无计算结果'
+            else:
+                self.cop_calculation()
+        if self.is_success == 1:
+            dict_results = DictResultsNormal(self.results, self.results_depict)
+        else:
+            dict_results = DictResultsAbnormal(self.dict_input, self.results_depict)
+        return dict_results
+
+
+
+

calculation/system_performance.py

@@ -0,0 +1,270 @@
+# coding=gbk
+import pandas as pd
+from CoolProp.CoolProp import PropsSI
+import numpy as np
+from logs.logger import *
+
+
+class BasicParameterCalculation(object):
+    def __init__(self, data_dict):
+        self.data_dict = data_dict.copy()
+
+    def parameter_first_cal(self):
+        """
+        制冷剂物性参数计算，主要用于排气温度修正过程的计算
+        计算参数包括：吸排气压力、吸气熵、吸气焓以及等熵排气焓
+        :return:
+        """
+        self.data_dict['sucPre'] = PropsSI('P', 'T', self.data_dict['evapTemp'] + 273.15, 'Q', 1, self.data_dict['refrigerant']) / 1000.0  # 将单位化成kPa
+        self.data_dict['disPre'] = PropsSI('P', 'T', self.data_dict['condTemp'] + 273.15, 'Q', 1, self.data_dict['refrigerant']) / 1000.0  # 将单位化成kPa
+        if self.data_dict['sucTemp'] - self.data_dict['evapTemp'] > 0:
+            self.data_dict['sucEntropy'] = PropsSI('S', 'T', self.data_dict['sucTemp'] + 273.15, 'P', self.data_dict['sucPre'] * 1000,
+                                                   self.data_dict['refrigerant'])  # 单位：J/kg-K
+            self.data_dict['sucEnthalpy'] = PropsSI('H', 'T', self.data_dict['sucTemp'] + 273.15, 'P', self.data_dict['sucPre'] * 1000,
+                                                    self.data_dict['refrigerant']) / 1000.0  # 单位：kJ/kg
+        else:
+            self.data_dict['sucEntropy'] = PropsSI('S', 'T', self.data_dict['sucTemp'] + 273.15, 'Q', 1, self.data_dict['refrigerant'])
+            self.data_dict['sucEnthalpy'] = PropsSI('H', 'T', self.data_dict['sucTemp'] + 273.15, 'Q', 1, self.data_dict['refrigerant']) / 1000.0
+        self.data_dict['iseDisEnthalpy'] = PropsSI('H', 'P', self.data_dict['disPre'] * 1000.0, 'S',
+                                                   self.data_dict['sucEntropy'], self.data_dict['refrigerant']) / 1000.0
+        return self.data_dict
+
+    def parameter_second_cal(self):
+        """
+        制冷剂物性参数计算：计算冷凝器出口焓值
+        :return:
+        """
+        if self.data_dict['condTemp'] - self.data_dict['expanTemp'] > 0:
+            self.data_dict['condOutEnthalpy'] = PropsSI('H', 'T', self.data_dict['expanTemp'] + 273.15, 'P', self.data_dict['disPre'] * 1000.0,
+                                                        self.data_dict['refrigerant']) / 1000.0
+        else:
+            self.data_dict['condOutEnthalpy'] = PropsSI('H', 'T', self.data_dict['expanTemp'] + 273.15, 'Q', 0,
+                                                        self.data_dict['refrigerant']) / 1000.0
+        return self.data_dict
+
+
+class DischargeTempModified(BasicParameterCalculation):
+    def __init__(self, data_dict):
+        super(DischargeTempModified, self).__init__(data_dict)
+
+    def eta_ise_cal(self):
+        """
+        根据排气焓值、吸气焓值以及等熵过程排气焓值计算等熵效率
+        :return:
+        """
+        if self.data_dict['dischargeTemp'] - self.data_dict['condTemp'] < 1:
+            self.data_dict['dischargeTemp'] = self.data_dict['condTemp'] + 1
+        self.data_dict['disEnthalpy'] = PropsSI('H', 'T', self.data_dict['dischargeTemp'] + 273.15, 'P', self.data_dict['disPre'] * 1000.0,
+                                                self.data_dict['refrigerant']) / 1000.0
+        self.data_dict['etaIseCal'] = (self.data_dict['iseDisEnthalpy'] - self.data_dict['sucEnthalpy']) / (
+                self.data_dict['disEnthalpy'] - self.data_dict['sucEnthalpy'])
+        return self.data_dict
+
+    def dis_temp_cal(self, disPre, sucEnthalpy, iseDisEnthalpy, etaIseEvaluate):
+        """
+        根据等熵效率修正方法计算压缩机排气温度
+        :param disPre:
+        :param sucEnthalpy:
+        :param iseDisEnthalpy:
+        :param etaIseEvaluate:
+        :return:
+        """
+        disEnthalpyCal = sucEnthalpy + (iseDisEnthalpy - sucEnthalpy) / etaIseEvaluate
+        disTempCal = PropsSI('T', 'H', disEnthalpyCal * 1000.0, 'P', disPre * 1000.0, self.data_dict['refrigerant']) - 273.15
+        return disTempCal, disEnthalpyCal
+
+    def eta_ise_recal(self, x):
+        """
+        根据历史等熵效率值进行修正:
+        根据经验数据进行修正
+        修正公式：f(x,y) = p00 + p10*x + p01*y + p11*x*y + p02*y^2   x:负载率，y：冷凝温度
+        :param x:
+        :return:
+        """
+        p00 = 0.06996
+        p10 = 0.02528
+        p01 = -0.04132
+        p11 = -0.0005824
+        p02 = 0.001406
+        eta_ise_evaluate = p00 + p10 * self.data_dict['loadRate'] + p01 * self.data_dict['condTemp'] + p11 * \
+                           self.data_dict['loadRate'] * self.data_dict['condTemp'] + p02 * self.data_dict['condTemp'] ** 2
+        if eta_ise_evaluate > 0.8 or eta_ise_evaluate < 0.4:
+            eta_ise_pass = pd.DataFrame(x, columns=['eta_ise'])
+            eta_ise_pass = eta_ise_pass.drop_duplicates()
+            eta_ise_pass = eta_ise_pass[eta_ise_pass['eta_ise'] != 0]
+            eta_ise_pass = eta_ise_pass[eta_ise_pass['eta_ise'] > 0.4]
+            if eta_ise_evaluate < 0.4:
+                if len(eta_ise_pass) < 1:
+                    eta_ise_evaluate = 0.5
+                else:
+                    eta_ise_evaluate = eta_ise_pass['eta_ise'].mean()
+            else:
+                if len(eta_ise_pass) < 1:
+                    eta_ise_evaluate = 0.8
+                else:
+                    mean_ise = eta_ise_pass['eta_ise'].mean()
+                    eta_ise_evaluate = 0.8 if mean_ise <= 0.7 else mean_ise
+        return eta_ise_evaluate
+
+    def discharge_temp_modified(self):
+        """
+        排气温度修正算法
+        :return:
+        """
+        self.data_dict = self.parameter_first_cal()
+        self.data_dict = self.eta_ise_cal()
+
+        if self.data_dict['etaIseCal'] > 0.75:
+            self.data_dict['etaIseCal'] = self.eta_ise_recal(self.data_dict['etaIse'])
+            results = self.dis_temp_cal(self.data_dict['disPre'], self.data_dict['sucEnthalpy'], self.data_dict['iseDisEnthalpy'],
+                                        self.data_dict['etaIseCal'])
+            self.data_dict['dischargeTemp'] = results[0]
+            self.data_dict['disEnthalpy'] = results[1]
+        return self.data_dict
+
+
+class PerformanceCalculation(BasicParameterCalculation):
+    def __init__(self, dict_cal):
+        """
+        初始化相关参数
+        :param dict_cal:
+        """
+        super(PerformanceCalculation, self).__init__(dict_cal)
+        self.dict_cal = dict_cal
+        self.powerRated = dict_cal['powerRated']
+        self.way_cooling = dict_cal['coolingWay']
+
+    def para_verify(self):
+        if self.dict_cal['compRunTime']:
+            self.dict_cal['compRunTime'] = self.dict_cal['compRunTime'] / 8760
+            if self.dict_cal['compRunTime'] > 100:
+                self.dict_cal['compRunTime'] = 10
+                logger.critical('============压缩机运行时间错误，程序进行了动态修正===========')
+            elif self.dict_cal['compRunTime'] > 20:
+                logger.critical('============压缩机运行时间为%.0f年，请检查与实际情况是否吻合===========' % self.dict_cal['compRunTime'])
+                self.dict_cal['compRunTime'] = 4
+            elif self.dict_cal['compRunTime'] > 0:
+                pass
+            else:
+                self.dict_cal['compRunTime'] = 7.0
+        else:
+            self.dict_cal['compRunTime'] = 7.0
+        return None
+
+    def eta_cal(self):
+        self.factor_motor = 1 - 0.01 * self.dict_cal['compRunTime']
+        self.factor_roller = 1 - 0.003 * self.dict_cal['compRunTime']
+        self.phi_heat_loss = 0.025
+        self.eta_motor = 0.95 * self.factor_motor ** 0.5
+        self.eta_roller = 0.97 * self.factor_roller ** 0.5
+        self.phi_power_fan = 0.03
+        return None
+
+    def mass_flow(self):
+        """
+        计算制冷剂流量
+        :return:
+        """
+        self.para_verify()
+        self.eta_cal()
+        if self.way_cooling == 'suctionCooling':
+            self.dict_cal['powerTheory'] = self.dict_cal['power'] - self.phi_heat_loss * self.powerRated
+            self.dict_cal['massCompressor'] = self.dict_cal['powerTheory'] / \
+                                              (self.dict_cal['disEnthalpy'] -
+                                               self.dict_cal['sucEnthalpy'])
+            self.dict_cal['massSuction'] = self.dict_cal['massCompressor']
+
+        elif self.way_cooling == 'liquidInjectionCooling':
+            self.dict_cal['powerTheory'] = self.eta_motor * self.eta_roller * self.dict_cal['power'] - \
+                                           self.phi_heat_loss * self.powerRated
+            self.dict_cal['massCompressor'] = self.dict_cal['powerTheory'] / \
+                                              (self.dict_cal['disEnthalpy'] - self.dict_cal['sucEnthalpy'])
+            self.dict_cal['massSuction'] = self.dict_cal['massCompressor'] - \
+                                           ((1 - self.eta_motor * self.eta_roller) * self.dict_cal['power']
+                                            - self.phi_heat_loss * self.powerRated) / \
+                                           (self.dict_cal['sucEnthalpy'] - self.dict_cal['condOutEnthalpy'])
+        elif self.way_cooling == 'fanCooling':
+            self.dict_cal['powerTheory'] = self.eta_motor * self.eta_roller * self.dict_cal['power'] \
+                                           - (self.phi_heat_loss + self.phi_power_fan) * self.powerRated
+            self.dict_cal['massCompressor'] = self.dict_cal['powerTheory'] / \
+                                              (self.dict_cal['disEnthalpy'] - self.dict_cal['sucEnthalpy'])
+            self.dict_cal['massSuction'] = self.dict_cal['massCompressor']
+        else:
+            logger.critical('==========电机冷却形式输入不正确==========')
+        return None
+
+    def system_performance(self):
+        """
+        系统性能计算
+        :return:
+        """
+        self.dict_cal['coolingCapacity'] = self.dict_cal['massSuction'] * \
+                                           (self.dict_cal['sucEnthalpy'] -
+                                            self.dict_cal['condOutEnthalpy'])
+        self.dict_cal['COP'] = self.dict_cal['coolingCapacity'] / \
+                               self.dict_cal['power']
+        if self.dict_cal['COP'] > 10 or self.dict_cal['COP'] < 2:
+            self.dict_cal['COP'] = np.random.uniform(9, 10)
+            self.dict_cal['coolingCapacity'] = self.dict_cal['power'] * self.dict_cal['COP']
+        return None
+
+    @staticmethod
+    def judge_results(data):
+        if data['etaIseCal'] < 0.25:
+            is_success = 0
+            results_depict = '输入参数存在问题，计算结果偏小'
+        elif data['etaIseCal'] < 0.9:
+            is_success = 1
+            results_depict = '输入参数正常，计算结果正常'
+        else:
+            is_success = 0
+            results_depict = '输入参数存在问题，计算结果偏大'
+        if data['coolingCapacity'] > 1.2 * data['coolingCapacityRated']:
+            is_success = 0
+            results_depict = '冷机计算结果存在严重问题，请检查输入参数'
+            logger.critical('===========冷机计算结果存在严重问题，请检查输入参数==========')
+        return is_success, results_depict
+
+    def chilled_water_flow_cal(self):
+        """
+        冷冻水流量计算
+        水流量单位：m3/h
+        :return:
+        """
+        self.dict_cal['chilledWaterFlow'] = self.dict_cal['coolingCapacity'] / 4.187 / (
+                self.dict_cal['chilledWaterInput'] - self.dict_cal['chilledWaterOutput']) / 1000 * 3600
+        chilledWaterFlowRated = self.dict_cal['coolingCapacityRated'] / 4.187 / 5.0 / 1000 * 3600
+        chilledFlowRatio = self.dict_cal['chilledWaterFlow'] / chilledWaterFlowRated
+        if chilledFlowRatio < 0.3 or chilledFlowRatio > 2.5:
+            self.dict_cal['chilledWaterFlow'] = ''
+            logger.critical('==========冷冻水流量计算异常，请检查输入参数===========')
+        return None
+
+    def cooling_water_flow_cal(self):
+        """
+        冷却水流量计算
+        比热容按照4.187计算，暂不进行公式拟合
+        水流量单位：m3/h
+        :return:
+        """
+        self.dict_cal['coolingWaterFlow'] = (self.dict_cal['power'] + self.dict_cal['coolingCapacity']) / 4.187 / (
+                self.dict_cal['coolingWaterOutput'] - self.dict_cal['coolingWaterInput']) / 1000 * 3600
+        coolingWaterFlowRated = (self.dict_cal['powerRated'] + self.dict_cal['coolingCapacityRated']) / 4.187 / 5.0 / 1000 * 3600
+        coolingFlowRatio = self.dict_cal['coolingWaterFlow'] / coolingWaterFlowRated
+        if coolingFlowRatio < 0.3 or coolingFlowRatio > 2.5:
+            self.dict_cal['coolingWaterFlow'] = ''
+            logger.critical('==========冷却水流量计算异常，请检查输入参数===========')
+        return None
+
+    def performance_calculation(self):
+        self.dict_cal = self.parameter_second_cal()
+        self.mass_flow()
+        self.system_performance()
+        is_success, results_depict = self.judge_results(self.dict_cal)
+        if is_success == 1:
+            self.cooling_water_flow_cal()
+            self.chilled_water_flow_cal()
+            self.dict_cal.update(
+                etaMotor=round(self.eta_motor, 3),
+                etaRoller=round(self.eta_roller, 3))
+        return is_success, results_depict, self.dict_cal

communication/rabbitmq_link.py

@@ -0,0 +1,147 @@
+from config.communicationConfig import *
+import pika
+
+
+
+class PikaMessage(object):
+    def __init__(self, exchange_name, queue_name, routing_key):
+        """
+        初始化参数:
+        用户名，密码，ip，端口，交换机，交换机类型，队列名称，路由key
+        """
+        self.username = USERNAME
+        self.password = PASSWORD
+        self.host = HOST
+        self.port = PORT
+        self.virtual_host = VIRTUAL_HOST_GET
+        self.exchange = exchange_name
+        self.exchange_type = EXCHANGE_TYPE
+        self.queue_name = queue_name
+        self.routing_key = routing_key
+        self.credentials = pika.PlainCredentials(USERNAME, PASSWORD)
+        self.cop_delay_exchange = "cop.calc.delay.exchange"
+        self.cop_delay_exchange_type = "x-delayed-message"
+        self.cop_delay_queue = "cop.calc.delay.input"
+        self.cop_delay_key = "cop.delay.input"
+
+    def connect(self):
+        """
+        建立连接
+        :return: None
+        """
+        self.connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.host,
+                                                                            port=self.port,
+                                                                            virtual_host=self.virtual_host,
+                                                                            credentials=self.credentials))
+        self.channel = self.connection.channel()
+
+    def declare_exchange(self):
+        """
+        声明交换机
+        :return: None
+        """
+        self.channel.exchange_declare(exchange=self.exchange,
+                                      exchange_type=self.exchange_type,
+                                      durable=True)
+        # self.channel.exchange_declare(exchange=self.cop_delay_exchange,
+        #                               exchange_type=self.cop_delay_exchange_type,
+        #                               arguments={"x-delayed-type": "direct"},
+        #                               durable=True)
+
+    def declare_queue(self):
+        """
+        声明队列
+        :return: None
+        """
+        self.channel.queue_declare(queue=self.queue_name, durable=True)
+        self.channel.queue_declare(queue=self.cop_delay_queue, durable=True)
+
+    def bind_queue(self):
+        """
+        将交换机下的队列名与路由key绑定起来
+        :return: None
+        """
+        self.channel.queue_bind(exchange=self.exchange,
+                                queue=self.queue_name,
+                                routing_key=self.routing_key)
+        # self.channel.queue_bind(exchange=self.cop_delay_exchange,
+        #                         queue=self.cop_delay_queue,
+        #                         routing_key=self.cop_delay_key)
+
+    def callback(self, ch, method, properties, body):
+        """
+        将rabbitmq监听队列的消息发送到延迟队列
+        :param ch:
+        :param method:
+        :param properties:
+        :param body:
+        :return:
+        """
+        # self.publish_msg_to_delay_queue(body)
+        data_from_rabbitmq = body.decode()
+        from main import main
+        main(data_from_rabbitmq)
+
+    @staticmethod
+    def callback_delay(ch, method, properties, body):
+        data_from_rabbitmq = body.decode()
+        from main import main
+        main(data_from_rabbitmq)
+
+    def consume(self):
+        """
+        消费消息
+        :return: None
+        """
+        self.channel.basic_consume(self.queue_name, self.callback, True)
+        # self.channel.basic_consume(self.cop_delay_queue, self.callback_delay, True)
+        self.channel.start_consuming()
+
+    def connection_close(self):
+        self.connection.close()
+
+    def publish_msg_to_queue(self, body):
+        """
+        发布消息
+        :return: None
+        """
+        self.channel.basic_publish(exchange=self.exchange,
+                                   routing_key=self.routing_key,
+                                   body=body)
+
+    def publish_msg_to_delay_queue(self, body):
+        """
+        发布消息到延迟队列
+        :return: None
+        """
+        self.channel.basic_publish(exchange=self.cop_delay_exchange,
+                                   routing_key=self.cop_delay_key,
+                                   properties=pika.BasicProperties(delivery_mode=2, headers={'x-delay': 90000}),
+                                   body=body)
+
+
+def create_connect():
+    """
+    创建连接，并且返回原始数据值
+    :param queue_name: 队列的名称
+    :param routing_key: 与队列绑定的路由key
+    :return: 原始传输数据值
+    """
+    # 从这里开始exchange_name, queue_name, routing_key
+    rabbitmq_connection_get = PikaMessage(EXCHANGE_GET, QUEUE_NAME_GET, ROUTING_KEY_GET)  # 实例化
+    rabbitmq_connection_get.connect()  # 建立连接
+    rabbitmq_connection_get.declare_exchange()  # 声明交换机
+    rabbitmq_connection_get.declare_queue()  # 声明队列
+    rabbitmq_connection_get.bind_queue()  # 绑定队列
+    rabbitmq_connection_get.consume()  # 消费
+    rabbitmq_connection_get.connection_close()  # 关闭连接
+
+
+def send_data_to_rabbitmq(body):
+    rabbitmq_connection_get = PikaMessage(EXCHANGE_SEND, QUEUE_NAME_SEND, ROUTING_KEY_SEND)  # 实例化
+    rabbitmq_connection_get.connect()  # 建立连接
+    rabbitmq_connection_get.declare_exchange()  # 声明交换机
+    rabbitmq_connection_get.publish_msg_to_queue(body)
+    rabbitmq_connection_get.connection_close()  # 关闭连接
+
+

config/communicationConfig.py

@@ -0,0 +1,25 @@
+
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# 与rabbitmq通讯相关的参数设置
+from config.config import configs, mysql_configs
+
+USERNAME = configs["rabbitmq_config"]["username"]  # 用户名
+PASSWORD = configs["rabbitmq_config"]["password"]  # 密码
+HOST = configs["rabbitmq_config"]["host"]  # ip
+PORT = configs["rabbitmq_config"]["port"]  # 端口
+EXCHANGE_TYPE = configs["rabbitmq_config"]["exchange_type"]  # 交换机方式
+
+EXCHANGE_GET = configs["rabbitmq_config"]["exchange_get"]  # 获取交换机名称
+QUEUE_NAME_GET = configs["rabbitmq_config"]["queue_name_get"]  # 获取数据的队列
+ROUTING_KEY_GET = configs["rabbitmq_config"]["routing_key_get"]  # 获取数据的routingkey
+VIRTUAL_HOST_GET = configs["rabbitmq_config"]["virtual_host"]  # 获取虚拟服务器
+
+EXCHANGE_SEND = configs["rabbitmq_config"]["exchange_send"]  # 发送交换机名称
+QUEUE_NAME_SEND = configs["rabbitmq_config"]["queue_name_send"]  # 发送数据的队列
+ROUTING_KEY_SEND = configs["rabbitmq_config"]["routing_key_send"]  # 发送数据的routingkey
+VIRTUAL_HOST_SEND = configs["rabbitmq_config"]["virtual_host"]  # 获取虚拟服务器
+
+
+emEmbaic = mysql_configs["em_embasic"]
+emBsem = mysql_configs["em_bsem"]

config/config.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import os
+
+configs = {
+    "rabbitmq_config": {"username": os.getenv("USERNAME_RM", "guest"),
+                        "password": os.getenv("PASSWORD_RM", "ntRbt_+dgd8"),
+                        "host": os.getenv("HOST_RM", "39.105.175.99"),
+                        "port": os.getenv("PORT_RM", 5672),
+                        "virtual_host": os.getenv("VIRTUAL_HOST_RM", "/"),
+                        "exchange_type": os.getenv("EXCHANGE_TYPE", "direct"),
+                        "exchange_get": os.getenv("EXCHANGE_GET", "sem.server.exchange"),
+                        "queue_name_get": os.getenv("QUEUE_NAME_GET", "sem.server.queue.cop.input"),
+                        "routing_key_get": os.getenv("ROUTING_KEY_GET", "cop.input"),
+                        "exchange_send": os.getenv("EXCHANGE_SEND", "sem.server.exchange"),
+                        "queue_name_send": os.getenv("QUEUE_NAME_SEND", "sem.server.queue.cop.output"),
+                        "routing_key_send": os.getenv("ROUTING_KEY_SEND", "cop.output")}}
+
+
+# configs = {
+#     "rabbitmq_config":{"username": os.getenv("USERNAME_RM", "jnc"),
+#                        "password": os.getenv("PASSWORD_RM", "juneng"),
+#                        "host": os.getenv("HOST_RM", "14.23.57.52"),
+#                        "port": os.getenv("PORT_RM", 5672),
+#                        "exchange_type": os.getenv("EXCHANGE_TYPE", "topic"),
+#                        "exchange_get": os.getenv("EXCHANGE_GET", "sem.server.exchange"),
+#                        "queue_name_get": os.getenv("QUEUE_NAME_GET", "dgjykj_data"),
+#                        "routing_key_get": os.getenv("ROUTING_KEY_GET", "dgjykj_data"),
+#                        "exchange_send": os.getenv("EXCHANGE_SEND", "sem.server.exchange"),
+#                        "queue_name_send": os.getenv("QUEUE_NAME_SEND", "sem.server.queue.seccaloutput"),
+#                        "routing_key_send": os.getenv("ROUTING_KEY_SEND", "seccal.output")}}
+
+# configs = {
+#     "rabbitmq_config":{"username": os.getenv("USERNAME_RM", "jnc"),
+#                        "password": os.getenv("PASSWORD_RM", "juneng"),
+#                        "host": os.getenv("HOST_RM", "192.168.1.200"),
+#                        "port": os.getenv("PORT_RM", 5672),
+#                        "exchange_type": os.getenv("EXCHANGE_TYPE", "topic"),
+#                        "exchange_get": os.getenv("EXCHANGE_GET", "transtointr.server.exchange"),
+#                        "queue_name_get": os.getenv("QUEUE_NAME_GET", "transtointr.server.exchange"),
+#                        "routing_key_get": os.getenv("ROUTING_KEY_GET", "transtointr.equip"),
+#                        "exchange_send": os.getenv("EXCHANGE_SEND", "sem.server.exchange"),
+#                        "queue_name_send": os.getenv("QUEUE_NAME_SEND", "sem.server.queue.seccaloutput"),
+#                        "routing_key_send": os.getenv("ROUTING_KEY_SEND", "seccal.output")}}
+
+
+mysql_configs = {
+    "em_embasic": {"host": os.getenv("MYSQL_HOST", "hdc-emm-external.rwlb.rds.aliyuncs.com"),
+                   "port": os.getenv("MYSQL_PORT", "3306"),
+                   "user": os.getenv("MYSQL_USER", "readonly_chiller"),
+                   "password": os.getenv("MYSQL_PASSWORD", "xafnTU5j"),
+                   "db": os.getenv("MYSQL_DB_EMBASIC", "em_embasic"),
+                   "charset": os.getenv("MYSQL_CHARSET", "utf8")},
+    "em_bsem": {"host": os.getenv("MYSQL_HOST", "hdc-emm-external.rwlb.rds.aliyuncs.com"),
+                "port": os.getenv("MYSQL_PORT", "3306"),
+                "user": os.getenv("MYSQL_USER", "readonly_chiller"),
+                "password": os.getenv("MYSQL_PASSWORD", "xafnTU5j"),
+                "db": os.getenv("MYSQL_DB_EMBSEM", "em_bsem"),
+                "charset": os.getenv("MYSQL_CHARSET", "utf8")}}
+
+# mysql_configs = {
+#     "em_embasic": {"host": os.getenv("MYSQL_HOST", "192.168.1.199"),
+#                    "port": os.getenv("MYSQL_PORT", "3307"),
+#                    "user": os.getenv("MYSQL_USER", "root"),
+#                    "password": os.getenv("MYSQL_PASSWORD", "MY99DDA8BeiC"),
+#                    "db": os.getenv("MYSQL_DB", "em_embasic"),
+#                    "charset": os.getenv("MYSQL_CHARSET", "utf8")},
+#     "em_bsem": {"host": os.getenv("MYSQL_HOST", "192.168.1.199"),
+#                 "port": os.getenv("MYSQL_PORT", "3307"),
+#                 "user": os.getenv("MYSQL_USER", "root"),
+#                 "password": os.getenv("MYSQL_PASSWORD", "MY99DDA8BeiC"),
+#                 "db": os.getenv("MYSQL_DB", "em_bsem"),
+#                 "charset": os.getenv("MYSQL_CHARSET", "utf8")}}
+
+# # 与rabbitmq通讯相关的参数设置
+# USERNAME = "jnc"  # 用户名
+# PASSWORD = "juneng"  # 密码
+# HOST = '192.168.1.223'  # ip
+# PORT = 5672  # 端口
+# EXCHANGE = 'sem.server.exchange'  # 交换机名称
+# EXCHANGE_TYPE = 'topic'  # 交换机方式
+# QUEUE_NAME_GET = "sem.server.queue.seccal.input"  # 获取数据的队列
+# ROUTING_KEY_GET = "seccal.input"  # 获取数据的routingkey

logs/logger.py

@@ -0,0 +1,28 @@
+import logging
+from logging.handlers import TimedRotatingFileHandler
+
+logger = logging.getLogger()
+logger.setLevel(level=logging.ERROR)
+
+log_file_name_local = './logs/time_rotate'
+
+# 本地轮转日志代码
+formatter = '%(asctime)s - %(message)s'
+time_rotate_file = TimedRotatingFileHandler(filename=log_file_name_local, when='H', interval=24, backupCount=24)
+time_rotate_file.setFormatter(logging.Formatter(formatter))
+time_rotate_file.setLevel(logging.ERROR)
+logger.addHandler(time_rotate_file)
+
+
+# 控制台日志代码
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.ERROR)
+console_handler.setFormatter(logging.Formatter(formatter))
+logger.addHandler(console_handler)
+
+"""
+    S - Seconds
+    M - Minutes
+    H - Hours
+    D - Days
+"""

main.py

@@ -0,0 +1,25 @@
+import json
+from logs.logger import *
+from calculation.calculation_process import CalculationProcess
+from communication.rabbitmq_link import create_connect, send_data_to_rabbitmq
+
+
+def main(dict_origin):
+    logger.critical("========Get data from rabbitmq========")
+    logger.critical("Input: {}".format(dict_origin))
+    dict_input = json.loads(dict_origin)
+    if dict_input['handleService'] == 'SingleCompressor':
+        dict_results = CalculationProcess(dict_input).main_process()
+    else:
+        dict_results = {}
+        logger.critical('=======暂不支持多机头服务========')
+    logger.critical("========Send calculated results to rabbitmq========")
+    dict_results = json.dumps(dict_results, ensure_ascii=False)
+    logger.critical("Output: {}".format(dict_results))
+    send_data_to_rabbitmq(dict_results)
+
+
+if __name__ == '__main__':
+    logger.critical("========Create connection for rabbitmq========")
+    create_connect()
+

requirements.txt

@@ -0,0 +1,11 @@
+certifi==2019.6.16
+CoolProp==6.3.0
+DBUtils==2.0
+numpy==1.17.0
+pandas==0.25.1
+pika==1.1.0
+PyMySQL==0.10.1
+python-dateutil==2.8.0
+pytz==2019.2
+six==1.12.0
+wincertstore==0.2

对接参数输入.txt

@@ -0,0 +1,63 @@
+{
+	"compRunTime": 6.7374,
+	"etaIse": [0.54, 0.54, 0.54, 0.54, 0.54],
+	"tempSuc": 8.88888888888889,
+	"runingStates": 1,
+	"tempExpan": 31.38888888888889,
+	"coolingWay": "liquid_injection_cooling",
+	"tempDis": 38.27777777777778,
+	"power": 300.36,
+	"tempEvap": 6.666666666666666,
+	"tempCond": 38.777777777777786,
+	"loadRate": 75,
+
+	"refriType": "R134a",
+	"powerRated": 365,
+	"coolingCapacityRated": 2100,
+	"coolingStationName": "河北廊坊富士康B12",
+	"chillerNumber": "主机1",
+
+	"handleService": "SingleCompressor",
+	"codeIsRun": 1,
+
+	"dateTime": 1587380188000,
+	"handleBeanClazz": "com.cloud.sem.server.service.impl.sem.CopServiceImpl",
+	"handleBeanName": "copService",
+	"handleMethodName": "saveCopFromPythonServer",
+
+	"wcmId": 67,
+	"conTempDiff": 2.777777777777776,
+	"evaTempDiff": 2.000000000000001,
+	"meterId": 3000165,
+	"elecMeterDataId": 2759118
+}
+
+压缩机运行时间
+等熵效率
+吸气温度
+运行状态
+阀前温度
+电机冷却方式
+排气温度
+冷机功耗
+蒸发温度
+冷凝温度
+负载率
+
+制冷剂类型
+冷机额定功率
+冷站名称
+equipName(冷机编号)
+
+python控制端处理类或业务描述
+程序是否禁用
+
+时间戳
+Java服务参数
+Java服务参数
+Java服务参数
+Java服务参数
+冷凝温差
+蒸发温差
+仪表ID
+电表ID