reconstruct 01/06

algorithm.py

+#!E:\Pycharm Projects\Waytous
+# -*- coding: utf-8 -*-
+# @Time : 2022/1/5 14:14
+# @Author : Opfer
+# @Site :
+# @File : algorithm.py    
+# @Software: PyCharm
+
+
+from para_config import *
+
+class ScheduleAlg(WalkManage):
+    """ class for the schedule algorithm.
+
+    Description:
+        根据设备状态计算调度价值
+
+    Attribute:
+        equipment class: truck, excavator, dump, group
+    """
+
+    def __init__(self, dump, excavator, truck, group):
+        self._dump = dump
+        self._excavator = excavator
+        self._truck = truck
+        self._group = group
+        # 获取日志器
+        self.logger = get_logger("zxt.alg")
+
+    def truck_schedule(self, current_truck, alg):
+        """
+        计算矿卡驶往各目的地的调度价值
+        :param truck_id: 待调度矿卡uuid
+        :param alg: 启用的调度算法
+        :return: 调度价值
+        """
+
+        if alg == "congestion":
+
+            transport_value = self.congestion_schedule(current_truck.get_truck_id(), current_truck)
+
+        elif alg == "traffic_plan":
+
+            transport_value = self.traffic_plan_schedule(current_truck)
+
+        elif alg == "saturation":
+
+            transport_value = self.saturation_schedule(current_truck)
+
+        else:
+            return None
+
+        return transport_value
+
+    def congestion_schedule(self, truck_id, current_truck):
+
+        transport_value = None
+
+        group_id = current_truck.get_group_id()
+
+        task = current_truck.get_task()
+
+        trip = current_truck.get_trip()
+
+        dynamic_excavator_num = get_value("dynamic_excavator_num")
+
+        dynamic_dump_num = get_value("dynamic_dump_num")
+
+        if task == -2:
+            ################################################ 矿卡启动 ###############################################
+            try:
+                self.logger.info("矿卡状态：矿卡启动或故障恢复")
+                self.logger.info(f"涉及挖机：{list(self._excavator.excavator_uuid_to_index_dict.keys())}")
+            except Exception as es:
+                self.logger.error(f"矿卡{truck_id}状态不匹配")
+                self.logger.error(es)
+
+            try:
+                transport_value = self._group.group_park_to_excavator[group_id]
+
+            except Exception as es:
+                transport_value = np.zeros(dynamic_excavator_num)
+                self.logger.info(es)
+
+        if task in [0, 1, 2]:
+            ################################################ 矿卡空载 ###############################################
+
+            try:
+                self.logger.info("矿卡状态：矿卡空载")
+                self.logger.info(f"涉及卸载设备：{list(self._dump.dump_uuid_to_index_dict.keys())}")
+            except Exception as es:
+                self.logger.error(f"矿卡{truck_id}状态不匹配")
+                self.logger.error(es)
+
+            excavator_index = int(trip[1])
+            try:
+                transport_value = self._group.group_walk_to_dump_cost[group_id][:, excavator_index]
+            except Exception as es:
+                transport_value = np.zeros(dynamic_dump_num)
+                self.logger.error(es)
+
+        elif task in [3, 4, 5]:
+            ################################################ 矿卡重载 ###############################################
+
+            try:
+                self.logger.info("矿卡状态：矿卡重载")
+                self.logger.info(f"涉及挖机设备：{list(self._excavator.excavator_uuid_to_index_dict.keys())}")
+            except Exception as es:
+                self.logger.error(f"矿卡{truck_id}状态不匹配")
+                self.logger.error(es)
+
+            try:
+                # 正常调度
+                dump_index = int(trip[1])
+                transport_value = self._group.group_walk_to_excavator_cost[group_id][dump_index, :]
+            except Exception as es:
+                transport_value = np.zeros(dynamic_excavator_num)
+                self.logger.info(es)
+
+        return transport_value
+
+    def traffic_plan_schedule(self, current_truck):
+
+        traffic_value = None
+
+        truck_id = current_truck.get_truck_id()
+
+        group_id = current_truck.get_group_id()
+
+        task = current_truck.get_task()
+
+        trip = current_truck.get_trip()
+
+        if task in [0, 1, 2]:
+
+            excavator_index = int(trip[1])
+            excavator_id = self._excavator.excavator_index_to_uuid_dict[excavator_index]
+
+            group_excavator_index = self._group.group_excavator_uuid_to_index_dict[group_id][excavator_id]
+
+            try:
+
+                # 计算 group actual traffic flow
+                group_actual_goto_dump_traffic_flow = self._group.group_actual_goto_dump_traffic_flow[
+                    group_id]
+
+                # 计算 group actual traffic flow
+                group_opt_goto_dump_traffic_flow = self._group.group_opt_goto_dump_traffic_flow[group_id]
+
+                self.logger.info("驶往卸点分组车流")
+                self.logger.info(group_actual_goto_dump_traffic_flow)
+                self.logger.info(group_opt_goto_dump_traffic_flow)
+
+                try:
+                    traffic_value = (group_actual_goto_dump_traffic_flow[group_excavator_index, :] + 0.001) \
+                                    / (group_opt_goto_dump_traffic_flow[group_excavator_index, :] + 0.001)
+                except Exception as es:
+                    self.logger.error("error09")
+                    self.logger.error(es)
+
+            except Exception as es:
+                self.logger.error("error11")
+                self.logger.error(es)
+            self.logger.info("traffic_value")
+            self.logger.info(traffic_value)
+            self.logger.info("dump_material_bind_modify")
+            self.logger.info(self._truck.dump_material_bind_modify[self.truck_uuid_to_index_dict[truck_id]])
+
+        elif task in [3, 4, 5]:
+
+            dump_index = int(trip[1])
+            dump_id = self._dump.dump_uuid_to_index_dict[dump_index]
+
+            group_dump_index = self._group.group_dump_uuid_to_index_dict[group_id][dump_id]
+
+            # 提取group actual traffic flow
+            group_actual_goto_excavator_traffic_flow = self._group.group_actual_goto_excavator_traffic_flow[
+                group_id]
+
+            # 提取group actual traffic flow
+            group_opt_goto_excavator_traffic_flow = self._group.group_opt_goto_excavator_traffic_flow[
+                group_id]
+
+            self.logger.info("驶往挖机分组车流")
+            self.logger.info(group_actual_goto_excavator_traffic_flow)
+            self.logger.info(group_opt_goto_excavator_traffic_flow)
+
+            traffic_value = (group_actual_goto_excavator_traffic_flow[group_dump_index, :] + 0.001) \
+                            / (group_opt_goto_excavator_traffic_flow[group_dump_index, :] + 0.001)
+
+            # transport_value = (self.actual_goto_excavator_traffic_flow[trip[1], :] + 0.001) \
+            #                     / (self.opt_goto_excavator_traffic_flow[trip[1], :] + 0.001)
+            self.logger.info("traffic_value")
+            self.logger.info(traffic_value)
+
+        return traffic_value
+
+    def saturation_schedule(self, current_truck):
+
+        transport_value = None
+
+        group_id = current_truck.get_group_id()
+
+        task = current_truck.get_task()
+
+        trip = current_truck.get_trip()
+
+        if task == -2:
+            self.logger.info("饱和度调度")
+
+            transport_value = self._group.group_park_to_excavator[group_id]
+
+            excavator_hold_truck = self._group.update_excavator_hold_truck(self._truck.excavator_hold_truck_num)[
+                group_id]
+
+            actual_flow_to_excavator = excavator_hold_truck * np.mean(self._truck.payload) / \
+                                       self._group.group_park_to_excavator[group_id].reshape(1, -1).flatten()
+
+            allow_flow_to_excavator = self._group.update_allow_flow_to_excavator()[group_id]
+
+            saturation_value = (1 - (actual_flow_to_excavator + 0.01) / (
+                    allow_flow_to_excavator + 0.01)) / transport_value
+
+            self.logger.info(f'实际车流 {actual_flow_to_excavator}')
+            # self.logger.info(actual_flow_to_excavator)
+
+            self.logger.info(f'最大车流 {allow_flow_to_excavator}')
+            # self.logger.info(allow_flow_to_excavator)
+
+            self.logger.info(f'行驶成本 {transport_value}')
+            # self.logger.info(transport_value)
+
+            self.logger.info(f'饱和度价值 {saturation_value}')
+            # self.logger.info(saturation_value)
+
+            return saturation_value
+
+        if task in [0, 1, 2]:
+            self.logger.info("饱和度调度")
+
+            excavator_index = int(trip[1])
+
+            transport_value = self._group.group_walk_to_dump_cost[group_id][:, excavator_index].reshape(1, -1)
+
+            dump_hold_truck = self._group.update_dump_hold_truck(self._truck.dump_hold_truck_num)[group_id]
+
+            actual_flow_to_dump = dump_hold_truck * self._truck.payload / \
+                                  self._group.group_walk_to_dump_cost[group_id][:, excavator_index].reshape(1, -1)
+            # allow_flow_to_dump = self.dump.dump_strength
+
+            allow_flow_to_dump = self._group.update_allow_flow_to_dump()[group_id]
+
+            saturation_value = (1 - (actual_flow_to_dump + 0.01) / (allow_flow_to_dump + 0.01)) / transport_value
+
+            self.logger.info(f'实际车流 {actual_flow_to_dump}')
+            # self.logger.info(actual_flow_to_excavator)
+
+            self.logger.info(f'最大车流 {allow_flow_to_dump}')
+            # self.logger.info(allow_flow_to_excavator)
+
+            self.logger.info(f'行驶成本 {transport_value}')
+            # self.logger.info(transport_value)
+
+            self.logger.info(f'饱和度价值 {saturation_value}')
+            # self.logger.info(saturation_value)
+
+            return saturation_value
+
+        if task in [3, 4, 5]:
+            self.logger.info("饱和度调度")
+
+            dump_index = int(trip[1])
+
+            transport_value = self._group.group_walk_to_excavator_cost[group_id][dump_index, :].reshape(1, -1)
+
+            excavator_hold_truck = self._group.update_excavator_hold_truck(self._truck.excavator_hold_truck_num)[
+                group_id]
+
+            actual_flow_to_excavator = excavator_hold_truck * self._truck.payload / \
+                                       self._group.group_walk_to_excavator_cost[group_id][dump_index, :].reshape(1, -1)
+
+            allow_flow_to_excavator = self._group.update_allow_flow_to_excavator()[group_id]
+
+            saturation_value = (1 - actual_flow_to_excavator / allow_flow_to_excavator) / transport_value
+
+            self.logger.info(f'实际车流 {actual_flow_to_excavator}')
+            # self.logger.info(actual_flow_to_excavator)
+
+            self.logger.info(f'最大车流 {allow_flow_to_excavator}')
+            # self.logger.info(allow_flow_to_excavator)
+
+            self.logger.info(f'行驶成本 {transport_value}')
+            # self.logger.info(transport_value)
+
+            self.logger.info(f'饱和度价值 {saturation_value}')
+            # self.logger.info(saturation_value)
+
+            return saturation_value
\ No newline at end of file

dispatcher.py

+#!E:\Pycharm Projects\Waytous
+# -*- coding: utf-8 -*-
+# @Time : 2021/12/29 11:36
+# @Author : Opfer
+# @Site :
+# @File : dispatcher.py    
+# @Software: PyCharm
+
+from traffic_flow.traffic_flow_planner import *
+from para_config import *
+from group_control.group_control import Group
+from path_plan.priority_control import PriorityController
+from algorithm import ScheduleAlg
+
+
+class CurrentTruck:
+    def __init__(self, truck_id, group_id, trip, task):
+        self._truck_id = truck_id
+        self._group_id = group_id
+        self._trip = trip
+        self._task = task
+
+    def get_truck_id(self):
+        return self._truck_id
+
+    def get_trip(self):
+        return self._trip
+
+    def get_task(self):
+        return self._task
+
+    def get_group_id(self):
+        return self._group_id
+
+
+class RuleHandle:
+    """ class for the schedule rule handler.
+
+    Description:
+        基于调度规则对调度价值进行修正
+
+    Attribute:
+        equipment class: truck, excavator, dump, group
+
+    """
+
+    def __init__(self, dump, excavator, truck, group):
+        self._dump = dump
+        self._excavator = excavator
+        self._truck = truck
+        self._group = group
+        self._priority_control = PriorityController()
+        self._schedule_alg = ScheduleAlg(dump, excavator, truck, group)
+
+    def filter(self, current_truck):
+        """
+        计算调度规则综合影响调度价值结果
+        :param truck_id: 矿卡uuid
+        :return:
+
+        """
+
+        # 矿卡uuid
+        truck_id = current_truck.get_truck_id()
+
+        # 矿卡序号
+        truck_index = self.truck.truck_uuid_to_index_dict[truck_id]
+
+        # 矿卡行程
+        trip = current_truck.get_trip()
+
+        # 矿卡任务
+        task = current_truck.get_task()
+
+        # 1. 读取路网权重和可通行性
+        walk_to_excavator_weight, walk_to_excavator_weight, park_walk_weight \
+            = self._priority_control.weighted_walk_calc()
+        walk_available = self._priority_control.walk_available_calc()
+
+        # 2. 读取挖机禁止关系
+        # excavator_exclude_truck_factor = self._truck.update_truck_excavator_exclude()
+        #
+        # excavator_exclude_truck_factor[np.where(excavator_exclude_truck_factor > M / 2)] = 1
+        #
+        # excavator_exclude_truck_factor = 1 - excavator_exclude_truck_factor
+
+        excavator_exclude_modify = self._group.group_excavator_exclude_modify[truck_id]
+
+        # 3. 读取调度价值
+        transport_value = self._schedule_alg.truck_schedule(current_truck, "congestion")
+
+        transport_value_norm = np.max(transport_value) / transport_value
+
+        transport_value_norm = transport_value_norm * walk_available
+
+    # def route_modify_factor(self, truck_id):
+    #     """
+    #     规则及权重因子针对某个矿卡的待的各路线的影响
+    #     :param truck_id:
+    #     :return:
+    #     """
+    #     walk_to_excavator_weight, walk_to_excavator_weight, park_walk_weight \
+    #         = self._priority_control.weighted_walk_calc()
+    #     walk_available = self._priority_control.walk_available_calc()
+
+    def truck_walk_weight(self, current_truck):
+        """
+        道路权重性针对某个矿卡到的各目的地的影响
+        :param current_truck:
+        :return:
+        """
+        walk_to_excavator_weight, walk_to_dump_weight, park_walk_weight \
+            = self._priority_control.weighted_walk_calc()
+
+        if current_truck.get_task() == 2:
+            return park_walk_weight
+
+        elif current_truck.get_task() in [0, 1, 2]:
+            end_excavator = int(current_truck.get_trip[1])
+            return walk_to_dump_weight[end_excavator, :]
+
+        elif current_truck.get_trip() in [3, 4, 5]:
+            end_dump = int(current_truck.get_trip[1])
+            return walk_to_excavator_weight[end_dump, :]
+
+    def truck_walk_available(self, current_truck):
+        """
+        道路通行性针对某个矿卡到的各目的地的影响
+        :param current_truck: 当前请调矿卡
+        :return: 矿卡出发地到各目的地道路可通行性
+        """
+        walk_available = self._priority_control.walk_available_calc()
+
+        if current_truck.get_task() == 2:
+            return np.ones(get_value("excavator_num"))
+
+        elif current_truck.get_task() in [0, 1, 2]:
+            end_excavator = int(current_truck.get_trip[1])
+            return walk_available[:, end_excavator].reshape(1, -1)
+
+        elif current_truck.get_trip() in [3, 4, 5]:
+            end_dump = int(current_truck.get_trip[1])
+            return walk_available[end_dump, :].reshape(1, -1)
+
+
+class Dispatcher(WalkManage):
+    """ class for the truck dispatch.
+
+    Description:
+        计算根据矿卡状态计算最佳派车计划
+        将派车计划写入redis
+
+    Attribute:
+        equipment class: truck, excavator, dump
+        schedule start time
+        equipment available time: truck, excavator, dump
+
+    """
+
+    def __init__(self, dump, excavator, truck, predict_schedule):
+
+        # 调度开始时间
+        self.start_time = datetime.now()
+
+        # 路径规划对象
+        self.path = PathPlanner()
+
+        # 车流对象
+        self.traffic_flow = Traffic_flow(dump, excavator, truck)
+
+        # 分组控制对象
+        self.group = Group(dump, excavator, truck, self.traffic_flow)
+
+        # 行程预测对象
+        self.pre_sch = predict_schedule
+
+        # 设备对象
+        self.dump = dump
+        self.excavator = excavator
+        self.truck = truck
+
+        # 调度算法
+        self._schedule_alg = ScheduleAlg(dump, excavator, truck, self.group)
+
+        # 获取日志器
+        self.logger = get_logger("zxt.dispatcher")
+
+    def dispatcher_period_update(self):
+
+        # 装载映射参数及
+        self.period_map_para_load()
+
+        self.period_walk_para_load()
+
+        # 更新卸载设备对象
+        self.dump.para_period_update()
+
+        # 更新挖机对象
+        self.excavator.para_period_update()
+
+        # 更新矿卡对象
+        self.truck.para_period_update(self.dump, self.excavator)
+
+        self.truck.state_period_update()
+
+        # 更新实时车流
+        self.traffic_flow.update_actual_traffic_flow()
+
+        # 获取路网加权行驶成本
+        self.cost_to_excavator, self.cost_to_dump, self.cost_park_to_excavator = self.path.walk_cost()
+
+        # 调度分组更新
+        self.group.period_update()
+
+    def truck_schedule(self, truck_id):
+        # 规则读取
+
+        rule3 = session_mysql.query(DispatchRule).filter_by(id=3).first().disabled
+
+        rule4 = session_mysql.query(DispatchRule).filter_by(id=4).first().disabled
+
+        # 读取优先级设置
+        excavator_priority_coefficient = self.excavator.excavator_priority_coefficient
+
+        excavator_material_priority = self.excavator.excavator_material_priority
+
+        # 矿卡序号
+        truck_index = self.truck.truck_uuid_to_index_dict[truck_id]
+
+        # 矿卡行程
+        trip = self.truck.get_truck_current_trip()[truck_index]
+
+        # 矿卡任务
+        task = self.truck.get_truck_current_task()[self.truck.truck_index_to_uuid_dict[truck_index]]
+
+        # 调度分组
+        group_id = self.group.dispatch_truck_group[truck_id]
+
+        # 记录当前调度车辆信息
+        current_truck = CurrentTruck(truck_id, group_id, trip, task)
+
+        if truck_id not in self.group.dispatch_truck_group:
+            self.logger.error("无该矿卡")
+            return -1
+
+        target = 0
+
+        # # 车流计算
+        # # 驶往卸载设备的实际车流
+        # actual_goto_dump_traffic_flow = self.traffic_flow.actual_goto_dump_traffic_flow
+        #
+        # # 驶往挖机的实际车流
+        # actual_goto_excavator_traffic_flow = self.traffic_flow.actual_goto_excavator_traffic_flow
+        #
+        # # 计算理想车流
+        # opt_goto_dump_traffic_flow, opt_goto_excavator_traffic_flow = traffic_flow_plan(self.truck)
+
+        truck_uuid_to_name_dict = get_value("truck_uuid_to_name_dict")
+        self.logger.info(f"========== 调度矿卡 {truck_id} {truck_index} {truck_uuid_to_name_dict[truck_id]} ==========")
+
+        if task == -2:
+
+            ################################################ 矿卡启动 ###############################################
+
+            try:
+                self.logger.info("矿卡状态：矿卡启动或故障恢复")
+                self.logger.info("矿卡行程：无")
+                self.logger.info(f"涉及挖机：{list(self.excavator.excavator_uuid_to_index_dict.keys())}")
+                if truck_id in self.truck.truck_material_bind:
+                    self.logger.info(f'物料类型 {self.truck.truck_material_bind[truck_id]}')
+                self.logger.info(f'挖机设备优先级 {excavator_priority_coefficient}')
+
+            except Exception as es:
+                self.logger.error(f"矿卡{truck_id}状态不匹配")
+                self.logger.error(es)
+
+            # try:
+            # 1. 绑定调度
+            if truck_id in self.truck.truck_excavator_bind:
+                self.logger.info("绑定调度")
+                target = self.excavator.excavator_uuid_to_index_dict[self.truck.truck_excavator_bind[truck_id]]
+
+            # 2. 正常调度
+            elif rule3 and rule4:
+                self.logger.info("正常调度")
+
+                transport_value = self._schedule_alg.truck_schedule(current_truck, "congestion")
+
+                self.logger.info(f'行驶成本-含拥堵度的路径长度 {transport_value}')
+
+                excavator_exclude_modify = self.group.group_excavator_exclude_modify[truck_id]
+
+                self.logger.info(f'挖机设备禁止因子 {excavator_exclude_modify}')
+
+                target = np.argmin(
+                    transport_value
+                    + excavator_exclude_modify)
+                target = self.excavator.excavator_uuid_to_index_dict[
+                    self.group.group_excavator_index_to_uuid_dict[group_id][target]]
+
+                self.logger.info(f'行驶成本-含拥堵度的路径长度 {self.excavator.excavator_uuid_to_index_dict}')
+
+            # 3. 启用饱和度调度
+            else:
+                self.logger.info("饱和度调度")
+
+                saturation_value = self._schedule_alg.saturation_schedule(current_truck)
+
+                self.logger.info(f'驶往挖机饱和度价值 {saturation_value}')
+
+                target = np.argmax(saturation_value)
+
+                target = self.excavator.excavator_uuid_to_index_dict[
+                    self.group.group_excavator_index_to_uuid_dict[group_id][target]]
+
+            self.logger.info(self.excavator.excavator_uuid_to_index_dict)
+            self.logger.info(self.group.group_excavator_uuid_to_index_dict)
+            excavator_uuid_to_name_dict = get_value("excavator_uuid_to_name_dict")
+            self.logger.info(f"目的地：{excavator_uuid_to_name_dict[self.excavator.excavator_index_to_uuid_dict[target]]}")
+
+        if task in [0, 1, 2]:
+            ################################################ 矿卡空载 ###############################################
+
+            try:
+                self.logger.info("矿卡状态：矿卡空载")
+                self.logger.info(f"涉及卸载设备：{list(self.dump.dump_uuid_to_index_dict.keys())}")
+            except Exception as es:
+                self.logger.error(f"矿卡{truck_id}状态不匹配")
+                self.logger.error(es)
+
+            # 日志记录部分
+            try:
+                self.logger.info(f'挖机id: {self.excavator.excavator_uuid_to_index_dict}')
+                self.logger.info(f'卸点id: {self.dump.dump_uuid_to_index_dict}')
+                self.logger.info(f'空载trip {trip}')
+                if truck_id in self.truck.truck_material_bind:
+                    self.logger.info(f'物料类型 {self.truck.truck_material_bind[truck_id]}')
+                self.logger.info(f'驶往卸点的运输成本 {self.cost_to_dump}')
+                self.logger.info("卸点物料修正")
+                self.logger.info(self.truck.dump_material_bind_modify)
+
+            except Exception as es:
+                self.logger.info("矿卡行程信息异常")
+                self.logger.info(es)
+
+            # 1. 绑定调度
+            if truck_id in self.truck.truck_dump_bind:
+                self.logger.info("矿卡已绑定卸点")
+                unload_area_uuid_to_index_dict = get_value("unload_area_uuid_to_index_dict")
+                bind_unload_area_id = self.truck.truck_dump_bind[truck_id]
+                for key, value in self.dump.dump_index_to_unload_area_index_dict.items():
+                    if value == unload_area_uuid_to_index_dict[bind_unload_area_id]:
+                        target = key
+                        break
+
+            # 2. 正常调度
+            elif rule3 and rule4:
+
+                transport_value = self._schedule_alg.truck_schedule(current_truck, "congestion")
+                self.logger.info(f'行驶成本-含拥堵度的路径长度 {transport_value}')
+
+                dump_material_bind_modify = self.group.group_dump_material_bind_modify[truck_id]
+                self.logger.info(f'卸点物料禁止因子 {dump_material_bind_modify}')
+
+                target = np.argmin(transport_value.T + dump_material_bind_modify)
+
+                target = self.dump.dump_uuid_to_index_dict[
+                    self.group.group_dump_index_to_uuid_dict[group_id][target]]
+
+            # 3. 饱和度调度
+            else:
+
+                self.logger.info("饱和度调度")
+
+                # saturation_value = self._schedule_alg.saturation_schedule(current_truck)
+
+                saturation_value = self._schedule_alg.truck_schedule(current_truck, "saturation")
+
+                self.logger.info(f'驶往卸点饱和度价值 {saturation_value}')
+
+                target = np.argmax(saturation_value)
+
+                target = self.dump.dump_uuid_to_index_dict[
+                    self.group.group_dump_index_to_uuid_dict[group_id][target]]
+
+            dump_uuid_to_name_dict = get_value("dump_uuid_to_name_dict")
+            self.logger.info(f"目的地：{dump_uuid_to_name_dict[self.dump.dump_index_to_uuid_dict[target]]}")
+
+        elif task in [3, 4, 5]:
+            ################################################ 矿卡重载 ###############################################
+
+            try:
+                self.logger.info("矿卡状态：矿卡重载")
+                self.logger.info(f"涉及挖机设备：{list(self.excavator.excavator_uuid_to_index_dict.keys())}")
+            except Exception as es:
+                self.logger.error(f"矿卡{truck_id}状态不匹配")
+                self.logger.error(es)
+
+            try:
+                self.logger.info("挖机id:")
+                self.logger.info(self.excavator.excavator_uuid_to_index_dict)
+                self.logger.info("卸点id:")
+                self.logger.info(self.dump.dump_uuid_to_index_dict)
+                self.logger.info("重载trip")
+                self.logger.info(trip)
+                self.logger.info("物料类型")
+                if truck_id in self.truck.truck_material_bind:
+                    self.logger.info(self.truck.truck_material_bind[truck_id])
+                self.logger.info("驶往挖机的运输成本")
+                self.logger.info(self.cost_to_excavator)
+                self.logger.info("挖机物料修正")
+                self.logger.info(self.truck.excavator_material_bind_modify)
+                self.logger.info("挖机优先级修正")
+                self.logger.info(self.excavator.excavator_priority_coefficient)
+            except Exception as es:
+                self.logger.info("矿卡行程信息异常")
+                self.logger.info(es)
+
+            # 计算目的地
+            try:
+                # 1. 绑定调度
+                if truck_id in self.truck.truck_excavator_bind:
+                    target = self.excavator.excavator_uuid_to_index_dict[self.truck.truck_excavator_bind[truck_id]]
+                    self.logger.info("矿卡已绑定挖机")
+                    self.logger.info("cost_to_excavator")
+                    self.logger.info(self.cost_to_excavator)
+
+                # 2 正常调度
+                elif rule3 and rule4:
+                    self.logger.info("正常调度")
+
+                    transport_value = self._schedule_alg.truck_schedule(current_truck, "congestion")
+                    self.logger.info(f'行驶成本-含拥堵度的路径长度 {transport_value}')
+
+                    excavator_exclude_modify = self.group.group_excavator_exclude_modify[truck_id]
+                    self.logger.info(f'挖机设备禁止因子 {excavator_exclude_modify}')
+
+                    self.logger.info(transport_value)
+                    target = np.argmin(
+                        transport_value.T
+                        + excavator_exclude_modify)
+
+                    target = self.excavator.excavator_uuid_to_index_dict[
+                        self.group.group_excavator_index_to_uuid_dict[group_id][target]]
+
+                # 3. 饱和度调度
+                else:
+                    self.logger.info("饱和度调度")
+
+                    # saturation_value = self._schedule_alg.saturation_schedule(current_truck)
+
+                    saturation_value = self._schedule_alg.truck_schedule(current_truck, "saturation")
+
+                    self.logger.info(f'驶往卸点饱和度价值 {saturation_value}')
+
+                    target = np.argmax(saturation_value)
+
+                    target = self.excavator.excavator_uuid_to_index_dict[
+                        self.group.group_excavator_index_to_uuid_dict[group_id][target]]
+
+            except Exception as es:
+                self.logger.info("trip出错1")
+                self.logger.info(es)
+
+            excavator_uuid_to_name_dict = get_value("excavator_uuid_to_name_dict")
+            self.logger.info(f"目的地：{excavator_uuid_to_name_dict[self.excavator.excavator_index_to_uuid_dict[target]]}")
+
+        self.logger.info("==========================================================")
+
+        print(target)
+        # except Exception as es:
+        #     self.logger.error("truck_schedule,error")
+        #     self.logger.error(es)
+        return target
+
+    def schedule_construct(self):
+
+        global truck
+        global excavator
+        global dump
+
+        # self.reset()
+
+        # try:
+
+        # 读取所需信息
+        dynamic_truck_num = get_value("dynamic_truck_num")
+        truck_current_trip = self.truck.get_truck_current_trip()
+        truck_current_task = self.truck.get_truck_current_task()
+
+        # Seq初始化
+        Seq = [[truck_current_trip[i][1], -1] for i in range(dynamic_truck_num)]
+
+        # 获取矿卡最早可用时间
+        truck_avl_time = self.pre_sch.get_truck_avl_time()
+
+        # 根据矿卡最早可用时间顺序进行规划
+        temp = copy.deepcopy(truck_avl_time) - self.truck.truck_priority
+
+        try:
+            # 没有启动的矿卡加上一个很大的值，降低其优先级
+            for i in range(dynamic_truck_num):
+                task = truck_current_task[self.truck.truck_index_to_uuid_dict[i]]
+                if task == -2:
+                    temp[i] = temp[i] + M
+        except Exception as es:
+            self.logger.error("矿卡排序启动异常")
+            self.logger.error(es)
+
+        index = np.argsort(temp.reshape(1, -1))
+        index = index.flatten()
+
+        # 对于在线矿卡已经赋予新的派车计划，更新其最早可用时间，及相关设备时间参数
+        for truck_index in index:
+            if len(Seq[truck_index]) > 0:
+
+                # try:
+                # 获取矿卡id
+                try:
+                    truck_id = self.truck.truck_index_to_uuid_dict[truck_index]
+                except Exception as es:
+                    self.logger.error('error01')
+                    self.logger.error(es)
+
+                # 判断矿卡是否禁用
+                if truck_id in self.truck.update_truck_disable_list():
+                    continue
+                try:
+                    # 获取矿卡当前任务
+                    task = truck_current_task[self.truck.truck_index_to_uuid_dict[truck_index]]
+                except Exception as es:
+                    self.logger.error('error02')
+                    self.logger.error(es)
+
+                try:
+                    # 矿卡结束当前派车计划后的目的地
+                    end_eq_index = truck_current_trip[truck_index][1]
+                except Exception as es:
+                    self.logger.error('error03')
+                    self.logger.error(es)
+
+                # try:
+                # 调用调度函数，得到最优目的地序号
+                target_eq_index = self.truck_schedule(self.truck.truck_index_to_uuid_dict[truck_index])
+
+                # except Exception as es:
+                #     self.logger.error('error04')
+                #     self.logger.error(es)
+                #     self.logger.error("truck_index,uuid")
+                #     self.logger.error(truck_index)
+                #     self.logger.error(self.truck.truck_index_to_uuid_dict[truck_index])
+
+                # self.logger.("target_eq_index")
+                # self.logger.error(target_eq_index)
+                try:
+                    # 写入Seq序列
+                    Seq[truck_index][1] = target_eq_index
+                except Exception as es:
+                    self.logger.error('error05')
+                    self.logger.error(es)
+                    self.logger.error("target_eq_index")
+                    self.logger.error(target_eq_index)
+                    self.logger.error("target_eq_index,type")
+                    self.logger.error(type(target_eq_index))
+                # except Exception as es:
+                #     self.logger.error("truck,task,end_eq_index,error")
+                #     self.logger.error(es)
+                try:
+                    group_id = self.group.dispatch_truck_group[truck_id]
+                except Exception as es:
+                    self.logger.error("非动态调度矿卡")
+                    self.logger.error(es)
+
+        for i in range(len(Seq)):
+            try:
+                try:
+                    truck_id = self.truck.truck_index_to_uuid_dict[i]
+                    group_id = self.group.dispatch_truck_group[truck_id]
+
+                    record = {"truckId": self.truck.truck_index_to_uuid_dict[i]}
+                    task = self.truck.get_truck_current_task()[self.truck.truck_index_to_uuid_dict[i]]
+                except Exception as es:
+                    self.logger.error("truck_id,group_id,record,task出错")
+                    self.logger.error(es)
+
+                if task in empty_task_set:
+
+                    item = (
+                        session_mysql.query(Dispatch)
+                            .filter_by(dump_id=self.dump.dump_index_to_uuid_dict[Seq[i][1]],
+                                       exactor_id=self.excavator.excavator_index_to_uuid_dict[Seq[i][0]],
+                                       truck_id=truck_id,
+                                       group_id=group_id,
+                                       isauto=1, isdeleted=0, ).first())
+
+                    record["exactorId"] = item.exactor_id
+                    record["dumpId"] = item.dump_id
+                    record["loadAreaId"] = item.load_area_id
+                    record["unloadAreaId"] = item.unload_area_id
+                    record["dispatchId"] = item.id
+                    record["isdeleted"] = False
+                    record["creator"] = item.creator
+                    record["createtime"] = item.createtime.strftime(
+                        "%b %d, %Y %I:%M:%S %p")
+
+                    redis5.set(self.truck.truck_index_to_uuid_dict[i], str(json.dumps(record)))
+                elif task in heavy_task_set:
+                    item = (
+                        session_mysql.query(Dispatch)
+                            .filter_by(exactor_id=self.excavator.excavator_index_to_uuid_dict[Seq[i][1]],
+                                       dump_id=self.dump.dump_index_to_uuid_dict[Seq[i][0]],
+                                       truck_id=truck_id,
+                                       group_id=group_id,
+                                       isauto=1, isdeleted=0, ).first())
+                    record["exactorId"] = self.excavator.excavator_index_to_uuid_dict[Seq[i][1]]
+                    record["dumpId"] = item.dump_id
+                    record["loadAreaId"] = item.load_area_id
+                    record["unloadAreaId"] = item.unload_area_id
+                    record["dispatchId"] = item.id
+                    record["isdeleted"] = False
+                    record["creator"] = item.creator
+                    record["createtime"] = item.createtime.strftime(
+                        "%b %d, %Y %I:%M:%S %p")
+
+                    redis5.set(self.truck.truck_index_to_uuid_dict[i], str(json.dumps(record)))
+                elif task == -2:
+                    try:
+                        try:
+                            item = (
+                                session_mysql.query(Dispatch)
+                                    .filter_by(exactor_id=self.excavator.excavator_index_to_uuid_dict[Seq[i][1]],
+                                               truck_id=truck_id,
+                                               group_id=group_id,
+                                               isauto=1, isdeleted=0).first())
+
+                            print("item")
+                            print(item.id, item.truck_id, item.exactor_id, item.dump_id)
+                        except Exception as es:
+                            self.logger.error("task-2,error01")
+
+                        try:
+                            record["exactorId"] = item.exactor_id
+                            record["dumpId"] = item.dump_id
+                            record["loadAreaId"] = item.load_area_id
+                            record["unloadAreaId"] = item.unload_area_id
+                            record["dispatchId"] = item.id
+                            record["isdeleted"] = False
+                            record["creator"] = item.creator
+                            record["createtime"] = item.createtime.strftime(
+                                "%b %d, %Y %I:%M:%S %p")
+
+                            redis5.set(self.truck.truck_index_to_uuid_dict[i], str(json.dumps(record)))
+
+                        except Exception as es:
+                            self.logger.error("task-2,error02")
+                            self.logger.error(es)
+
+                    except Exception as es:
+                        self.logger.error("task为-2时error")
+                        self.logger.error(es)
+                else:
+                    pass
+
+            except Exception as es:
+                self.logger.error("调度结果写入异常-redis写入异常")
+                self.logger.error(f"调度结果:{Seq}")
+                self.logger.error(es)
+
+        for i in range(dynamic_truck_num):
+            print("dispatch_setting:")
+            print(redis5.get(self.truck.truck_index_to_uuid_dict[i]))
+        # except Exception as es:
+        #     self.logger.error("更新不及时-1")
+        #     self.logger.error(es)
+
+        return Seq
+
+
+class PreSchedule:
+    """ class for the prediction of equipments' trip.
+
+    Description:
+        Calculate and update the prediction item.
+        复杂处理所有预测项的计算与更新
+        基于矿卡最近一次装卸载时间预测其抵达目的地时间
+        根据矿卡请求队列及抵达信息，计算设备最早可用时间
+
+    Attribute:
+        equipment class: truck, excavator, dump
+        schedule start time
+        equipment available time: truck, excavator, dump
+
+    """
+
+    def __init__(self, truck, excavator, dump):
+        # 设备对象域
+        self.truck = truck
+        self.excavator = excavator
+        self.dump = dump
+
+        # 调度开始时间
+        self.start_time = datetime.now()
+
+        # 真实设备可用时间
+        self.truck_reach_dump = np.zeros(self.truck.get_truck_num())
+        self.truck_reach_excavator = np.zeros(self.truck.get_truck_num())
+        self.excavator_avl_time = np.zeros(self.excavator.get_excavator_num())
+        self.dump_avl_time = np.zeros(self.dump.get_dump_num())
+        # 卡车完成装载及卸载时间(矿卡可用时间)
+        self.truck_avl_time = np.zeros(self.truck.get_truck_num())
+
+    def update_truck_reach_time(self):
+        """
+        更新矿卡预计抵达目的地时间
+        :return:
+            excavator_avl_ls: (list) 驶往挖机的各矿卡抵达时间
+            dump_avl_ls: (list) 驶往卸点的各矿卡抵达时间
+        """
+        try:
+            dynamic_excavator_num = self.excavator.get_excavator_num()
+            dumps = self.dump.get_dump_num()
+            trucks = self.truck.get_truck_num()
+
+            truck_current_task = self.truck.get_truck_current_task()
+
+            truck_current_trip = self.truck.get_truck_current_trip()
+
+            truck_reach_excavator = self.truck.get_truck_reach_excavator()
+
+            truck_reach_dump = self.truck.get_truck_reach_dump()
+
+            excavator_avl_ls = [[] for _ in range(dynamic_excavator_num)]
+            dump_avl_ls = [[] for _ in range(dumps)]
+            for i in range(trucks):
+                task = truck_current_task[self.truck.truck_index_to_uuid_dict[i]]
+                end_area_index = truck_current_trip[i][1]
+                if task in [0, 1]:
+                    reach_time = truck_reach_excavator[i]
+                    excavator_avl_ls[end_area_index].append(
+                        [reach_time, i, end_area_index]
+                    )
+                elif task in [3, 4]:
+                    reach_time = truck_reach_dump[i]
+                    dump_avl_ls[end_area_index].append([reach_time, i, end_area_index])
+                elif task == -2:
+                    self.truck_avl_time[i] = (
+                                                     datetime.now() - self.start_time
+                                             ) / timedelta(hours=0, minutes=1, seconds=0)
+
+        except Exception as es:
+            self.logger.error("矿卡预计抵达时间计算异常")
+            self.logger.error(es)
+            return [], []
+
+        return excavator_avl_ls, dump_avl_ls
+
+    def update_excavator_avl_time(self, excavator_avl_ls):
+        """
+        更新挖机预计可用时间
+        :param
+            excavator_avl_ls: (list) 驶往挖机的各矿卡抵达时间
+        :return:
+            excavator_avl_time: (array) 各挖机完成所有已分配矿卡装载的时间
+        """
+
+        # 初始化挖机可用时间
+        self.excavator_avl_time = np.full(
+            get_value("dynamic_excavator_num"),
+            (datetime.now() - self.start_time)
+            / timedelta(hours=0, minutes=1, seconds=0),
+        )
+
+        loading_time = self.excavator.get_loading_time()
+
+        loading_task_time = self.excavator.get_loading_task_time()
+
+        try:
+
+            now = float(
+                (datetime.now() - self.start_time)
+                / timedelta(hours=0, minutes=1, seconds=0)
+            )
+
+            for reach_ls in excavator_avl_ls:
+                if len(reach_ls) != 0:
+                    reach_ls = np.array(reach_ls)
+                    tmp = reach_ls[np.lexsort(reach_ls[:, ::-1].T)]
+                    for i in range(len(tmp)):
+                        excavator_index = int(tmp[i][2])
+                        self.excavator_avl_time[excavator_index] = (
+                                max(tmp[i][0], self.excavator_avl_time[excavator_index])
+                                + loading_task_time[excavator_index]
+                        )
+                        self.truck_avl_time[
+                            int(tmp[i][1])
+                        ] = self.excavator_avl_time[excavator_index]
+
+                        # # 若挖机可用时间严重偏离，进行修正
+                        # if abs(self.excavator_avl_time[excavator_index] - now) > 60:
+                        #     self.truck_avl_time[int(tmp[i][1])] = now
+                        # if abs(self.excavator_avl_time[excavator_index] - now) > 60:
+                        #     self.excavator_avl_time[excavator_index] = now
+        except Exception as es:
+            self.logger.error("挖机可用时间计算异常")
+            self.logger.error(es)
+
+        return self.excavator_avl_time
+
+    def update_dump_avl_time(self, dump_avl_ls):
+        """
+        更新卸载设备预计可用时间
+        :param
+            dump_avl_ls: (list) 驶往卸点的各矿卡抵达时间
+        :return:
+            dump_avl_time: (array) 各卸点完成所有已分配矿卡卸载的时间
+        """
+
+        dynamic_dump_num = self.dump.get_dump_num()
+
+        # 初始化卸载设备可用时间
+        self.dump_avl_time = np.full(
+            dynamic_dump_num,
+            (datetime.now() - self.start_time)
+            / timedelta(hours=0, minutes=1, seconds=0),
+        )
+
+        unloading_time = self.dump.get_unloading_time()
+
+        unloading_task_time = self.dump.get_unloading_task_time()
+
+        try:
+
+            now = float(
+                (datetime.now() - self.start_time)
+                / timedelta(hours=0, minutes=1, seconds=0)
+            )
+
+            for reach_ls in dump_avl_ls:
+                if len(reach_ls) != 0:
+                    reach_ls = np.array(reach_ls)
+                    tmp = reach_ls[np.lexsort(reach_ls[:, ::-1].T)]
+                    for i in range(len(tmp)):
+                        dump_index = int(tmp[i][2])
+                        self.dump_avl_time[dump_index] = (
+                                max(tmp[i][0], self.dump_avl_time[dump_index])
+                                + unloading_task_time[dump_index]
+                        )
+                        self.truck_avl_time[
+                            int(tmp[i][1])
+                        ] = self.dump_avl_time[dump_index]
+
+                        # # 若卸载设备可用时间严重偏离，进行修正
+                        # if abs(self.dump_avl_time[dump_index] - now) > 60:
+                        #     self.dump_avl_time[dump_index] = now
+                        # if abs(self.truck_avl_time[int(tmp[i][1])] - now) > 60:
+                        #     self.truck_avl_time[int(tmp[i][1])] = now
+        except Exception as es:
+            self.logger.error("卸载设备可用时间计算异常")
+            self.logger.error(es)
+
+        return self.dump_avl_time
+
+    def _reset(self):
+        """
+        重置设备可用时间
+        :return:
+        """
+        # 真实设备可用时间
+        self.truck_reach_dump = np.zeros(self.truck.get_truck_num())
+        self.truck_reach_excavator = np.zeros(self.truck.get_truck_num())
+        self.excavator_avl_time = np.zeros(self.excavator.get_excavator_num())
+        self.dump_avl_time = np.zeros(self.dump.get_dump_num())
+        # 卡车完成装载及卸载时间(矿卡可用时间)
+        self.truck_avl_time = np.zeros(self.truck.get_truck_num())
+
+    def get_dump_avl_time(self):
+        """
+        获取卸载点最早可用时间
+        :return:
+            dump_avl_time: (array) 各卸点完成所有已分配矿卡卸载的时间
+        """
+        self._reset()
+        excavator_avl_ls, dump_avl_ls = self.update_truck_reach_time()
+        dump_avl_time = self.update_dump_avl_time(dump_avl_ls)
+        return dump_avl_time
+
+    def get_excavator_avl_time(self):
+        """
+        获取挖机最早可用时间
+        :return:
+            excavator_avl_time: (array) 各挖机完成所有已分配矿卡装载的时间
+        """
+        self._reset()
+        excavator_avl_ls, dump_avl_ls = self.update_truck_reach_time()
+        return self.update_excavator_avl_time(excavator_avl_ls)
+
+    def get_truck_avl_time(self):
+        """
+        获取矿卡最早可用时间
+        :return:
+            truck_avl_time: (array) 各矿卡完成当前装载或卸载任务的时间
+        """
+        self._reset()
+        excavator_avl_ls, dump_avl_ls = self.update_truck_reach_time()
+        self.update_excavator_avl_time(excavator_avl_ls)
+        self.update_dump_avl_time(dump_avl_ls)
+        return self.truck_avl_time

equipment/dump.py

@@ -36,6 +36,9 @@ class DumpInfo(WalkManage):
         self.period_map_para_load()
         self.period_walk_para_load()
 
+        # 日志器
+        self.logger = get_logger("zxt.dump")
+
         # 参数初始化
         self.para_period_update()
 
@@ -83,8 +86,8 @@ class DumpInfo(WalkManage):
             #         ave_unload_time / unload_count
             #     )
             # except Exception as es:
-            #     logger.error(f"卸载设备 {dump_id} 卸载时间信息缺失, 已设为默认值(1min)")
-            #     logger.error(es)
+            #     self.logger.error(f"卸载设备 {dump_id} 卸载时间信息缺失, 已设为默认值(1min)")
+            #     self.logger.error(es)
             self.unloading_time[self.dump_uuid_to_index_dict[dump_id]] = 5.00
         # print("average_unload_time: ", self.unloading_time[self.dump_uuid_to_index_dict[dump_id]])
 
@@ -110,8 +113,8 @@ class DumpInfo(WalkManage):
             #             query.exit_entrance_time / query.exit_entrance_count
             #         )
             # except Exception as es:
-            #     logger.error(f"卸载设备 {dump_id} 出入场时间信息缺失, 已设为默认值(1min)")
-            #     logger.error(es)
+            #     self.logger.error(f"卸载设备 {dump_id} 出入场时间信息缺失, 已设为默认值(1min)")
+            #     self.logger.error(es)
             self.entrance_time[self.dump_uuid_to_index_dict[dump_id]] = 0.50
             self.exit_time[self.dump_uuid_to_index_dict[dump_id]] = 0.50
 
@@ -123,8 +126,8 @@ class DumpInfo(WalkManage):
                 dump_material_id = session_postgre.query(DumpArea).filter_by(Id=unload_area_id).first().Material
                 self.dump_material[dump_id] = dump_material_id
             except Exception as es:
-                logger.error("无动态派车计划可用")
-                logger.error(es)
+                self.logger.error("无动态派车计划可用")
+                self.logger.error(es)
 
     def update_dump_priority(self):
         self.dump_priority_coefficient = np.ones(self.dynamic_dump_num)
@@ -135,14 +138,14 @@ class DumpInfo(WalkManage):
                 item = session_postgre.query(DumpArea).filter_by(Id=unload_area_id).first()
                 self.dump_priority_coefficient[self.dump_uuid_to_index_dict[dump_id]] += item.Priority
             except Exception as es:
-                logger.error("无动态派车计划可用")
-                logger.error(es)
+                self.logger.error("无动态派车计划可用")
+                self.logger.error(es)
 
     def update_unload_ability(self):
         try:
             rule3 = session_mysql.query(DispatchRule).filter_by(id=3).first()
             if not rule3.disabled:
-                for dump_index in range(dynamic_dump_num):
+                for dump_index in range(self.dynamic_dump_num):
                     unload_area_id = unload_area_index_to_uuid_dict[self.dump_index_to_unload_area_index_dict[dump_index]]
 
                     unload_ability = session_postgre.query(DumpArea).filter_by(Id=unload_area_id).first().UnloadAbililty
@@ -154,8 +157,8 @@ class DumpInfo(WalkManage):
                 self.dump_strength = np.full(self.dynamic_dump_num, 5000)
 
         except Exception as es:
-            logger.error(es)
-            logger.error("卸载点卸载信息读取异常")
+            self.logger.error(es)
+            self.logger.error("卸载点卸载信息读取异常")
 
     def reset(self):
         # 卸载设备数量
@@ -181,7 +184,7 @@ class DumpInfo(WalkManage):
 
         # print("Dump update!")
 
-        logger.info("Dump update!")
+        self.logger.info("Dump update!")
 
         # 装载周期参数
         self.period_map_para_load()

equipment/excavator.py

@@ -40,6 +40,9 @@ class ExcavatorInfo(WalkManage):
         self.period_map_para_load()
         self.period_walk_para_load()
 
+        # 日志器
+        self.logger = get_logger("zxt.excavator")
+
         # 参数初始化
         self.para_period_update()
 
@@ -77,12 +80,12 @@ class ExcavatorInfo(WalkManage):
             #         ave_load_time / load_count
             #     )
             # except Exception as es:
-            #     logger.error(f"挖机 {excavator_id} 装载时间信息缺失, 已设为默认值(1min)")
-            #     logger.error(es)
-            logger.info("loading_time")
-            logger.info(self.loading_time)
-            logger.info("excavator_uuid_to_index_dict")
-            logger.info(self.excavator_uuid_to_index_dict)
+            #     self.logger.error(f"挖机 {excavator_id} 装载时间信息缺失, 已设为默认值(1min)")
+            #     self.logger.error(es)
+            self.logger.info("loading_time")
+            self.logger.info(self.loading_time)
+            self.logger.info("excavator_uuid_to_index_dict")
+            self.logger.info(self.excavator_uuid_to_index_dict)
             self.loading_time[self.excavator_uuid_to_index_dict[excavator_id]] = 5.00
 
     # 更新挖机设备出入时间
@@ -108,8 +111,8 @@ class ExcavatorInfo(WalkManage):
             #             self.excavator_uuid_to_index_dict[excavator_id]
             #         ] = float(query.exit_entrance_time / query.exit_entrance_count)
             # except Exception as es:
-            #     logger.error(f"挖机设备 {excavator_id} 出入场时间信息缺失, 已设为默认值(1min)")
-            #     logger.error(es)
+            #     self.logger.error(f"挖机设备 {excavator_id} 出入场时间信息缺失, 已设为默认值(1min)")
+            #     self.logger.error(es)
             self.entrance_time[
                 self.excavator_uuid_to_index_dict[excavator_id]
             ] = 0.50
@@ -128,25 +131,25 @@ class ExcavatorInfo(WalkManage):
         return loading_task_time
 
     def update_excavator_material(self):
-        logger.info("self.dynamic_excavator_set")
-        logger.info(self.dynamic_excavator_set)
+        self.logger.info("self.dynamic_excavator_set")
+        self.logger.info(self.dynamic_excavator_set)
         for excavator_id in self.dynamic_excavator_set:
             try:
                 load_area_id = session_mysql.query(Dispatch).filter_by(exactor_id=excavator_id, isdeleted=0, isauto=1).first().load_area_id
                 excavator_material_id = session_postgre.query(DiggingWorkArea).filter_by(Id=load_area_id).first().Material
                 self.excavator_material[excavator_id] = excavator_material_id
             except Exception as es:
-                logger.warning(es)
+                self.logger.warning(es)
 
     def update_excavator_priority(self):
 
-        logger.info("dynamic_excavator_set")
-        logger.info(self.dynamic_excavator_set)
+        self.logger.info("dynamic_excavator_set")
+        self.logger.info(self.dynamic_excavator_set)
 
         for excavator_id in get_value("dynamic_excavator_set"):
             item = session_mysql.query(Equipment).filter_by(id=excavator_id).first()
-            logger.info("excavator_priority_coefficient")
-            logger.info(self.excavator_priority_coefficient)
+            self.logger.info("excavator_priority_coefficient")
+            self.logger.info(self.excavator_priority_coefficient)
             self.excavator_priority_coefficient[self.excavator_uuid_to_index_dict[excavator_id]] = item.priority + 1
 
             # 物料优先级控制
@@ -180,8 +183,8 @@ class ExcavatorInfo(WalkManage):
                 self.excavator_strength = np.full(self.dynamic_excavator_num, 5000)
 
         except Exception as es:
-            logger.error(es)
-            logger.error("挖机装载信息信息读取异常")
+            self.logger.error(es)
+            self.logger.error("挖机装载信息信息读取异常")
 
     def reset(self):
 
@@ -208,12 +211,12 @@ class ExcavatorInfo(WalkManage):
 
         self.reset()
 
-        logger.info("Excavator update!")
+        self.logger.info("Excavator update!")
 
         rule7 = session_mysql.query(DispatchRule).filter_by(id=7).first().disabled
 
-        logger.info("物料优先级规则")
-        logger.info(rule7)
+        self.logger.info("物料优先级规则")
+        self.logger.info(rule7)
 
         # 装载周期参数
         self.period_map_para_load()

equipment/truck.py

@@ -11,9 +11,7 @@ from equipment.dump import DumpInfo
 from equipment.excavator import ExcavatorInfo
 from typing import List
 
-# 引入对象
-dump = DumpInfo()
-excavator = ExcavatorInfo()
+
 
 
 # 矿卡设备类
@@ -76,6 +74,8 @@ class TruckInfo(WalkManage):
         # 初始化读取映射及路网
         self.period_map_para_load()
         self.period_walk_para_load()
+        # 日志
+        self.logger = get_logger("zxt.truck")
         # 初始化读取参数
         self.para_period_update(dump, excavator)
         # # 矿卡所属group
@@ -151,11 +151,11 @@ class TruckInfo(WalkManage):
                             truck_name_to_uuid_dict[item]
                         ] = currentTask
             except Exception as es:
-                logger.error("读取矿卡任务异常-reids读取异常")
-                logger.error(es)
+                self.logger.error("读取矿卡任务异常-reids读取异常")
+                self.logger.error(es)
 
-        logger.info("矿卡当前任务：")
-        logger.info(self.truck_current_task)
+        self.logger.info("矿卡当前任务：")
+        self.logger.info(self.truck_current_task)
 
         # logger.info("device_name_set，大小")
         # logger.info(len(device_name_set))
@@ -205,19 +205,19 @@ class TruckInfo(WalkManage):
                                 self.last_load_time[item] = datetime.now()
                                 redis2.hsetnx(truck_uuid_to_name_dict[item], str_to_byte("lastLoadTime"),
                                               "\"" + datetime.now().strftime("%Y-%m-%d %H:%M:%S") + "\"")
-                                logger.info("lastLoadTime is Error")
+                                self.logger.info("lastLoadTime is Error")
                         else:
                             self.last_load_time[item] = datetime.now()
                             redis2.hsetnx(truck_uuid_to_name_dict[item], str_to_byte("lastLoadTime"),
                                           "\"" + datetime.now().strftime("%Y-%m-%d %H:%M:%S") + "\"")
-                            logger.info("lastLoadTime is None")
+                            self.logger.info("lastLoadTime is None")
                         self.relative_last_load_time[item] = float(
                             (self.last_load_time[item] - self.start_time)
                             / timedelta(hours=0, minutes=1, seconds=0)
                         )
                         # print("相对last_load_time", self.relative_last_load_time[item])
-                        logger.info("相对last_load_time")
-                        logger.info(self.relative_last_load_time[item])
+                        self.logger.info("相对last_load_time")
+                        self.logger.info(self.relative_last_load_time[item])
                     if task in empty_task_set:
                         if str_to_byte("lastUnloadTime") in key_value_dict.keys():
                             last_unload_time_tmp = eval(key_value_dict[str_to_byte("lastUnloadTime")])
@@ -228,7 +228,7 @@ class TruckInfo(WalkManage):
                                 self.last_unload_time[item] = datetime.now()
                                 redis2.hsetnx(truck_uuid_to_name_dict[item], str_to_byte("lastUnloadTime"),
                                               "\"" + datetime.now().strftime("%Y-%m-%d %H:%M:%S") + "\"")
-                                logger.info("lastUnloadTime is Error")
+                                self.logger.info("lastUnloadTime is Error")
                         else:
                             self.last_unload_time[item] = datetime.now()
                             # key_value_dict[str_to_byte("lastUnloadTime")] = datetime.now().strftime(
@@ -236,14 +236,14 @@ class TruckInfo(WalkManage):
                             # )
                             redis2.hsetnx(truck_uuid_to_name_dict[item], str_to_byte("lastUnloadTime"),
                                           "\"" + datetime.now().strftime("%Y-%m-%d %H:%M:%S") + "\"")
-                            logger.info("lastUnloadTime is None")
+                            self.logger.info("lastUnloadTime is None")
                         self.relative_last_unload_time[item] = float(
                             (self.last_unload_time[item] - self.start_time)
                             / timedelta(hours=0, minutes=1, seconds=0)
                         )
                         # print("相对last_unload_time", self.relative_last_unload_time[item])
-                        logger.info("相对last_unload_time")
-                        logger.info(self.relative_last_unload_time[item])
+                        self.logger.info("相对last_unload_time")
+                        self.logger.info(self.relative_last_unload_time[item])
                     elif task == -2:
                         # print(datetime.now())
                         self.last_unload_time[item] = datetime.now()
@@ -259,8 +259,8 @@ class TruckInfo(WalkManage):
                                           "\"" + datetime.now().strftime("%Y-%m-%d %H:%M:%S") + "\"")
                         # redis2.hsetnx(truck_uuid_to_name_dict[item], str(json.dumps(key_value_dict)))
         except Exception as es:
-            logger.error("读取矿卡可用时间异常-redis读取异常")
-            logger.error(es)
+            self.logger.error("读取矿卡可用时间异常-redis读取异常")
+            self.logger.error(es)
 
     def update_truck_trip(self):
 
@@ -283,8 +283,8 @@ class TruckInfo(WalkManage):
                 if task in empty_task_set + heavy_task_set and item is None:
                     raise Exception(f"矿卡 {truck_id} 配对关系异常")
             except Exception as es:
-                logger.error("配对关系异常")
-                logger.error(es)
+                self.logger.error("配对关系异常")
+                self.logger.error(es)
                 continue
 
             # try:
@@ -356,8 +356,8 @@ class TruckInfo(WalkManage):
                 # self.excavator_hold_truck_num[end_eqp_index] = self.excavator_hold_truck_num[end_eqp_index] + 1
                 pass
             # except Exception as es:
-            #     logger.error("矿卡行程读取异常")
-            #     logger.error(es)
+            #     self.logger.error("矿卡行程读取异常")
+            #     self.logger.error(es)
 
         # print("self.dump_hold_truck_num")
         # print(self.dump_hold_truck_num)
@@ -384,8 +384,8 @@ class TruckInfo(WalkManage):
                 if task in empty_task_set + heavy_task_set and item is None:
                     raise Exception(f"矿卡 {truck_id} 配对关系异常")
             except Exception as es:
-                logger.error("配对关系异常")
-                logger.error(es)
+                self.logger.error("配对关系异常")
+                self.logger.error(es)
                 continue
 
             # try:
@@ -409,8 +409,8 @@ class TruckInfo(WalkManage):
             else:
                 pass
             # except Exception as es:
-            #     logger.error("矿卡行程读取异常")
-            #     logger.error(es)
+            #     self.logger.error("矿卡行程读取异常")
+            #     self.logger.error(es)
 
         print("self.dump_hold_truck_num")
         print(self.dump_hold_truck_num)
@@ -441,8 +441,8 @@ class TruckInfo(WalkManage):
         #                 .capacity
         #         )
         # except Exception as es:
-        #     logger.error("读取矿卡有效载重异常-矿卡型号信息缺失")
-        #     logger.error(es)
+        #     self.logger.error("读取矿卡有效载重异常-矿卡型号信息缺失")
+        #     self.logger.error(es)
 
     def update_truck_priority(self):
         self.truck_priority = np.full(self.dynamic_truck_num, 0)
@@ -473,8 +473,8 @@ class TruckInfo(WalkManage):
                                 dump_area.Id
                             )
         except Exception as es:
-            logger.error("矿卡-卸载区域绑定关系读取异常")
-            logger.error(es)
+            self.logger.error("矿卡-卸载区域绑定关系读取异常")
+            self.logger.error(es)
 
     def update_truck_excavator_bind(self):
         try:
@@ -489,8 +489,8 @@ class TruckInfo(WalkManage):
                                 truck_name_to_uuid_dict[truck_name]
                             ] = excavator_id
         except Exception as es:
-            logger.error("矿卡-挖机绑定关系读取异常")
-            logger.error(es)
+            self.logger.error("矿卡-挖机绑定关系读取异常")
+            self.logger.error(es)
 
     def update_truck_excavator_exclude(self):
 
@@ -519,8 +519,10 @@ class TruckInfo(WalkManage):
                                     self.excavator_uuid_to_index_dict[excavator_id]
                                 ] = 1000000
         except Exception as es:
-            logger.error("矿卡-挖机禁止关系读取异常")
-            logger.error(es)
+            self.logger.error("矿卡-挖机禁止关系读取异常")
+            self.logger.error(es)
+
+        return self.excavator_exclude_modify
 
     def update_truck_dump_exclude(self):
         pass
@@ -570,8 +572,8 @@ class TruckInfo(WalkManage):
                         if dump_material_id != material:
                             self.dump_material_bind_modify[truck_index][dump_index] = 1000000
         except Exception as es:
-            logger.error(es)
-            logger.error("矿卡物料更新异常")
+            self.logger.error(es)
+            self.logger.error("矿卡物料更新异常")
 
     def update_truck_spec(self):
         for truck_id in self.dynamic_truck_set:
@@ -653,7 +655,7 @@ class TruckInfo(WalkManage):
         # 设备优先级启用
         rule6 = session_mysql.query(DispatchRule).filter_by(id=6).first().disabled
 
-        # logger.info("Para truck update!")
+        # self.logger.info("Para truck update!")
         #
         # # 装载周期参数
         # self.period_map_para_load()
@@ -663,20 +665,20 @@ class TruckInfo(WalkManage):
         # # 更新有效载重
         # self.update_truck_payload()
         #
-        # logger.info("距离成本规则")
-        # logger.info(rule1)
+        # self.logger.info("距离成本规则")
+        # self.logger.info(rule1)
         #
-        # logger.info("拥堵成本规则")
-        # logger.info(rule2)
+        # self.logger.info("拥堵成本规则")
+        # self.logger.info(rule2)
         #
-        # logger.info("车流规划规则")
-        # logger.info(rule3 or rule4)
+        # self.logger.info("车流规划规则")
+        # self.logger.info(rule3 or rule4)
         #
-        # logger.info("生产组织规则")
-        # logger.info(rule5)
+        # self.logger.info("生产组织规则")
+        # self.logger.info(rule5)
         #
-        # logger.info("设备优先级规则")
-        # logger.info(rule6)
+        # self.logger.info("设备优先级规则")
+        # self.logger.info(rule6)
         #
         # if not rule5:
         #     # 更新绑定关系
@@ -701,7 +703,7 @@ class TruckInfo(WalkManage):
         # 物料优先级启用
         rule7 = session_mysql.query(DispatchRule).filter_by(id=7).first().disabled
 
-        logger.info("Para truck update!")
+        self.logger.info("Para truck update!")
 
         # 装载周期参数
         self.period_map_para_update()
@@ -712,41 +714,41 @@ class TruckInfo(WalkManage):
         self.update_truck_payload()
 
         if rule1:
-            logger.info("距离成本规则未启用")
+            self.logger.info("距离成本规则未启用")
         else:
-            logger.info("距离成本规则启用")
+            self.logger.info("距离成本规则启用")
 
         if rule2:
-            logger.info("拥堵成本规则未启用")
+            self.logger.info("拥堵成本规则未启用")
         else:
-            logger.info("拥堵成本规则启用")
+            self.logger.info("拥堵成本规则启用")
 
         if rule3 or rule4:
-            logger.info("车流规划规则未启用")
+            self.logger.info("车流规划规则未启用")
         else:
-            logger.info("车流规划规则启用")
+            self.logger.info("车流规划规则启用")
 
         if rule5:
-            logger.info("生产组织规则未启用")
+            self.logger.info("生产组织规则未启用")
         else:
             # 更新绑定关系
             self.update_truck_dump_area_bind()
             self.update_truck_excavator_bind()
             # 更新禁止关系
             self.update_truck_excavator_exclude()
-            logger.info("生产组织规划规则启用")
+            self.logger.info("生产组织规划规则启用")
 
         if rule6:
-            logger.info("设备优先级规则未启用")
+            self.logger.info("设备优先级规则未启用")
         else:
             # 更新矿卡调度优先级
             self.update_truck_priority()
-            logger.info("设备优先级规则启用")
+            self.logger.info("设备优先级规则启用")
 
         if rule7:
-            logger.info("物料优先级规则未启用")
+            self.logger.info("物料优先级规则未启用")
         else:
-            logger.info("物料优先级规则启用")
+            self.logger.info("物料优先级规则启用")
         # 更新矿卡物料类型
         self.update_truck_material()
 

para_config.py

@@ -18,33 +18,14 @@ empty_task_set = [0, 1, 5]
 # 重载任务集合
 heavy_task_set = [2, 3, 4]
 
-# # 空载矿卡速度，单位（km/h）
-# global empty_speed
-#
-# empty_speed = 25
-#
-# # 重载矿卡速度，单位（km/h）
-# global heavy_speed
-#
-# heavy_speed = 22
-#
-# # 卸载设备目标卸载量
-# dump_target_mass = 5000
-#
-# # 挖机目标装载量
-# excavator_target_mass = 5000
-
 # 任务集合
 task_set = [-2, 0, 1, 2, 3, 4, 5]
 
-#
-# truck = TruckInfo()
-# excavator = ExcavatorInfo()
-# dump = DumpInfo()
-
 # Big integer
 M = 100000000
 
+logger = get_logger("zxt.para")
+
 # 装载区、卸载区、备停区在调度算法运行器件默认不发生改变，提前计算部分参量
 # (uuid,index(id)映射关系, 装载区数量, 卸载区数量, 备停区数量, 以及初次统计动态调度矿卡)
 (
@@ -64,6 +45,8 @@ park_num = len(park_uuid_to_index_dict)
 
 truck_uuid_to_name_dict, truck_name_to_uuid_dict = build_truck_uuid_name_map()
 
+excavator_uuid_to_name_dict, dump_uuid_to_name_dict = build_equipment_uuid_name_map()
+
 # 矿卡集合
 truck_set = set(update_total_truck())
 
@@ -305,9 +288,7 @@ class WalkManage(DeviceMap):
         self.walk_time_to_unload_area = np.full((unload_area_num, load_area_num), M)
 
         # 路网行驶时间
-        self.distance_to_excavator = np.full(
-            (dynamic_dump_num, dynamic_excavator_num), M
-        )
+        self.distance_to_excavator = np.full((dynamic_dump_num, dynamic_excavator_num), M)
         self.distance_to_dump = np.full((dynamic_dump_num, dynamic_excavator_num), M)
         self.distance_park_to_excavator = np.full((park_num, dynamic_excavator_num), M)
         self.distance_park_to_load_area = np.full((park_num, load_area_num), M)
@@ -394,6 +375,9 @@ class WalkManage(DeviceMap):
             logger.error("备停区设备路网信息异常")
             logger.error(es)
 
+        logger.info("distance_park_to_excavator")
+        logger.info(self.distance_park_to_excavator)
+
     def period_walk_para_load(self):
         # 装载路网信息
         self.distance_to_load_area = walk_manage.distance_to_load_area
@@ -431,6 +415,7 @@ def period_para_update():
     global park_uuid_to_index_dict, park_index_to_uuid_dict
     global truck_uuid_to_name_dict, truck_name_to_uuid_dict
     global dynamic_truck_num, dynamic_excavator_num, dynamic_dump_num
+    global excavator_uuid_to_name_dict, dump_uuid_to_name_dict
 
     # 清空数据库缓存
     session_mysql.commit()
@@ -455,6 +440,8 @@ def period_para_update():
 
     truck_uuid_to_name_dict, truck_name_to_uuid_dict = build_truck_uuid_name_map()
 
+    excavator_uuid_to_name_dict, dump_uuid_to_name_dict = build_equipment_uuid_name_map()
+
     # 矿卡集合
     truck_set = set(update_total_truck())
 
@@ -495,35 +482,555 @@ def period_para_update():
     global_dict["dynamic_dump_set"] = dynamic_dump_set
     global_dict["dynamic_dump_num"] = dynamic_dump_num
     global_dict["park_num"] = park_num
+    global_dict["load_area_num"] = load_area_num
+    global_dict["unload_area_num"] = unload_area_num
 
-    print("walk_manage.distance_to_excavator")
-    print(dynamic_dump_num, dynamic_excavator_num)
-    print(walk_manage.distance_to_excavator)
-
-    print("walk_manage.excavator_dict")
-    print(walk_manage.excavator_uuid_to_index_dict)
-    print("walk_manage.dump_dict")
-    print(walk_manage.dump_uuid_to_index_dict)
+    global_dict["truck_uuid_to_name_dict"] = truck_uuid_to_name_dict
+    global_dict["excavator_uuid_to_name_dict"] = excavator_uuid_to_name_dict
+    global_dict["dump_uuid_to_name_dict"] = dump_uuid_to_name_dict
+    global_dict["unload_area_uuid_to_index_dict"] = unload_area_uuid_to_index_dict
+    global_dict["unload_area_index_to_uuid_dict"] = unload_area_index_to_uuid_dict
+    global_dict["park_uuid_to_index_dict"] = park_uuid_to_index_dict
+    global_dict["park_index_to_uuid_dict"] = park_index_to_uuid_dict
 
     global_dict["distance_to_excavator"] = walk_manage.distance_to_excavator
     global_dict["distance_park_to_excavator"] = walk_manage.distance_park_to_excavator
     global_dict["distance_to_dump"] = walk_manage.distance_to_dump
 
-    logger.info("walk_manage_para")
-    logger.info("distance_to_excavator")
-    logger.info(walk_manage.distance_to_excavator)
-    logger.info("distance_park_to_excavator")
-    logger.info(walk_manage.distance_park_to_excavator)
-    logger.info("distance_to_dump")
-    logger.info(walk_manage.distance_to_dump)
-    logger.info("excavator_uuid_to_index_dict")
-    logger.info(walk_manage.excavator_uuid_to_index_dict)
-    logger.info("dump_uuid_to_index_dict")
-    logger.info(walk_manage.dump_uuid_to_index_dict)
-    logger.info("walk_manage.distance_park_to_excavator")
-    logger.info(walk_manage.distance_park_to_excavator)
-
-    logger.info("walk_manage.truck_index_to_uuid_dict")
-    logger.info(walk_manage.truck_index_to_uuid_dict)
-    logger.info("walk_manage.dynamic_truck_set")
-    logger.info(dynamic_truck_set)
+    # logger.info("walk_manage_para")
+    # logger.info("distance_to_excavator")
+    # logger.info(walk_manage.distance_to_excavator)
+    # logger.info("distance_park_to_excavator")
+    # logger.info(walk_manage.distance_park_to_excavator)
+    # logger.info("distance_to_dump")
+    # logger.info(walk_manage.distance_to_dump)
+    # logger.info("excavator_uuid_to_index_dict")
+    # logger.info(walk_manage.excavator_uuid_to_index_dict)
+    # logger.info("dump_uuid_to_index_dict")
+    # logger.info(walk_manage.dump_uuid_to_index_dict)
+    # logger.info("walk_manage.distance_park_to_excavator")
+    # logger.info(walk_manage.distance_park_to_excavator)
+    #
+    # logger.info("walk_manage.truck_index_to_uuid_dict")
+    # logger.info(walk_manage.truck_index_to_uuid_dict)
+    # logger.info("walk_manage.dynamic_truck_set")
+    # logger.info(dynamic_truck_set)
+
+
+# # 全局参数设定
+#
+# # 空载任务集合
+# empty_task_set = [0, 1, 5]
+#
+# # 重载任务集合
+# heavy_task_set = [2, 3, 4]
+#
+# # # 空载矿卡速度，单位（km/h）
+# # global empty_speed
+# #
+# # empty_speed = 25
+# #
+# # # 重载矿卡速度，单位（km/h）
+# # global heavy_speed
+# #
+# # heavy_speed = 22
+# #
+# # # 卸载设备目标卸载量
+# # dump_target_mass = 5000
+# #
+# # # 挖机目标装载量
+# # excavator_target_mass = 5000
+#
+# # 任务集合
+# task_set = [-2, 0, 1, 2, 3, 4, 5]
+#
+# #
+# # truck = TruckInfo()
+# # excavator = ExcavatorInfo()
+# # dump = DumpInfo()
+#
+# # Big integer
+# M = 100000000
+#
+# # 装载区、卸载区、备停区在调度算法运行器件默认不发生改变，提前计算部分参量
+# # (uuid,index(id)映射关系, 装载区数量, 卸载区数量, 备停区数量, 以及初次统计动态调度矿卡)
+# (
+#     load_area_uuid_to_index_dict,
+#     unload_area_uuid_to_index_dict,
+#     load_area_index_to_uuid_dict,
+#     unload_area_index_to_uuid_dict,
+# ) = build_work_area_uuid_index_map()
+#
+# load_area_num, unload_area_num = len(load_area_uuid_to_index_dict), len(
+#     unload_area_uuid_to_index_dict
+# )
+#
+# park_uuid_to_index_dict, park_index_to_uuid_dict = build_park_uuid_index_map()
+#
+# park_num = len(park_uuid_to_index_dict)
+#
+# truck_uuid_to_name_dict, truck_name_to_uuid_dict = build_truck_uuid_name_map()
+#
+# # 矿卡集合
+# truck_set = set(update_total_truck())
+#
+# # 固定派车矿卡集合
+# fixed_truck_set = set(update_fixdisp_truck())
+#
+# # 动态派车矿卡集合
+# # dynamic_truck_set = truck_set.difference(fixed_truck_set)
+# dynamic_truck_set = update_dynamic_truck()
+#
+# dynamic_truck_num = len(dynamic_truck_set)
+#
+# logger.info("可用于动态派车的矿卡：")
+# logger.info(dynamic_truck_set)
+#
+# # 用于动态调度的挖机及卸载设备
+# dynamic_excavator_set = set(update_autodisp_excavator())
+# dynamic_excavator_num = len(dynamic_excavator_set)
+#
+# dynamic_dump_set = set(update_autodisp_dump())
+# dynamic_dump_num = len(dynamic_dump_set)
+#
+# global global_dict
+#
+# global_dict = {}
+#
+# global_dict["dynamic_truck_set"] = dynamic_truck_set
+# global_dict["dynamic_truck_num"] = dynamic_truck_num
+# global_dict["dynamic_excavator_set"] = dynamic_excavator_set
+# global_dict["dynamic_excavator_num"] = dynamic_excavator_num
+# global_dict["dynamic_dump_set"] = dynamic_dump_set
+# global_dict["dynamic_dump_num"] = dynamic_dump_num
+# global_dict["park_num"] = park_num
+#
+#
+# def get_value(name):
+#     return global_dict[name]
+#
+# # 设备映射类, 存储除工作区以外的映射关系
+# # 其余设备类继承该类
+# class DeviceMap:
+#     def __init__(self):
+#         self.excavator_uuid_to_index_dict = {}
+#         self.dump_uuid_to_index_dict = {}
+#         self.excavator_index_to_uuid_dict = {}
+#         self.dump_index_to_uuid_dict = {}
+#
+#         self.dump_uuid_to_unload_area_uuid_dict = {}
+#         self.excavator_uuid_to_load_area_uuid_dict = {}
+#         self.excavator_index_to_load_area_index_dict = {}
+#         self.dump_index_to_unload_area_index_dict = {}
+#
+#         self.truck_uuid_to_index_dict = {}
+#         self.truck_index_to_uuid_dict = {}
+#
+#     def get_excavator_uuid_to_index_dict(self):
+#         return self.excavator_uuid_to_index_dict
+#
+#     def get_dump_uuid_to_index_dict(self):
+#         return self.dump_uuid_to_index_dict
+#
+#     def get_excavator_index_to_uuid_dict(self):
+#         return self.excavator_index_to_uuid_dict
+#
+#     def get_dump_index_to_uuid_dict(self):
+#         return self.dump_index_to_uuid_dict
+#
+#     def get_dump_uuid_to_unload_area_uuid_dict(self):
+#         return self.dump_uuid_to_unload_area_uuid_dict
+#
+#     def get_excavator_uuid_to_load_area_uuid_dict(self):
+#         return self.excavator_uuid_to_load_area_uuid_dict
+#
+#     def get_excavator_index_to_load_area_index_dict(self):
+#         return self.excavator_index_to_load_area_index_dict
+#
+#     def get_dump_index_to_unload_area_index_dict(self):
+#         return self.dump_index_to_unload_area_index_dict
+#
+#     def get_truck_uuid_to_index_dict(self):
+#         return self.truck_uuid_to_index_dict
+#
+#     def get_truck_index_to_uuid_dict(self):
+#         return self.truck_index_to_uuid_dict
+#
+#     def reset(self):
+#         self.excavator_uuid_to_index_dict = {}
+#         self.dump_uuid_to_index_dict = {}
+#         self.excavator_index_to_uuid_dict = {}
+#         self.dump_index_to_uuid_dict = {}
+#
+#         self.dump_uuid_to_unload_area_uuid_dict = {}
+#         self.excavator_uuid_to_load_area_uuid_dict = {}
+#         self.excavator_index_to_load_area_index_dict = {}
+#         self.dump_index_to_unload_area_index_dict = {}
+#
+#         self.truck_uuid_to_index_dict = {}
+#         self.truck_index_to_uuid_dict = {}
+#
+#     def period_map_para_update(self):
+#
+#         self.reset()
+#
+#         device_map_dict = update_deveices_map(
+#             unload_area_uuid_to_index_dict, load_area_uuid_to_index_dict
+#         )
+#
+#         self.excavator_uuid_to_index_dict = device_map_dict[
+#             "excavator_uuid_to_index_dict"
+#         ]
+#
+#         print("device.dump_uuid_to_index_dict")
+#         print(self.dump_uuid_to_index_dict)
+#
+#         self.dump_uuid_to_index_dict = device_map_dict["dump_uuid_to_index_dict"]
+#         self.excavator_index_to_uuid_dict = device_map_dict[
+#             "excavator_index_to_uuid_dict"
+#         ]
+#         self.dump_index_to_uuid_dict = device_map_dict["dump_index_to_uuid_dict"]
+#
+#         self.dump_uuid_to_unload_area_uuid_dict = device_map_dict[
+#             "dump_uuid_to_unload_area_uuid_dict"
+#         ]
+#         self.excavator_uuid_to_load_area_uuid_dict = device_map_dict[
+#             "excavator_uuid_to_load_area_uuid_dict"
+#         ]
+#         self.excavator_index_to_load_area_index_dict = device_map_dict[
+#             "excavator_index_to_load_area_index_dict"
+#         ]
+#         self.dump_index_to_unload_area_index_dict = device_map_dict[
+#             "dump_index_to_unload_area_index_dict"
+#         ]
+#
+#         truck_map_dict = update_truck_uuid_index_map(get_value("dynamic_truck_set"))
+#
+#         self.truck_uuid_to_index_dict = truck_map_dict["truck_uuid_to_index_dict"]
+#
+#         self.truck_index_to_uuid_dict = truck_map_dict["truck_index_to_uuid_dict"]
+#
+#     def period_map_para_load(self):
+#         # 装载关系映射
+#         self.excavator_uuid_to_index_dict = device_map.excavator_uuid_to_index_dict
+#         self.dump_uuid_to_index_dict = device_map.dump_uuid_to_index_dict
+#         self.excavator_index_to_uuid_dict = device_map.excavator_index_to_uuid_dict
+#         self.dump_index_to_uuid_dict = device_map.dump_index_to_uuid_dict
+#
+#         self.dump_uuid_to_unload_area_uuid_dict = (
+#             device_map.dump_uuid_to_unload_area_uuid_dict
+#         )
+#         self.excavator_uuid_to_load_area_uuid_dict = (
+#             device_map.excavator_uuid_to_load_area_uuid_dict
+#         )
+#         self.excavator_index_to_load_area_index_dict = (
+#             device_map.excavator_index_to_load_area_index_dict
+#         )
+#         self.dump_index_to_unload_area_index_dict = (
+#             device_map.dump_index_to_unload_area_index_dict
+#         )
+#
+#         self.truck_uuid_to_index_dict = device_map.truck_uuid_to_index_dict
+#         self.truck_index_to_uuid_dict = device_map.truck_index_to_uuid_dict
+#
+#
+# # 路网信息类
+# class WalkManage(DeviceMap):
+#     def __init__(self):
+#         # # 工作区和设备不具备一一对应关系, 为方便就计算, 算法维护两套路网: 面向路网和面向设备
+#
+#         # 路网真实距离
+#         self.walk_time_to_excavator = np.full(
+#             (dynamic_dump_num, dynamic_excavator_num), M
+#         )
+#         self.walk_time_to_dump = np.full((dynamic_dump_num, dynamic_excavator_num), M)
+#         self.walk_time_park_to_excavator = np.full((park_num, dynamic_excavator_num), M)
+#         self.walk_time_park_to_load_area = np.full((park_num, load_area_num), M)
+#         self.walk_time_to_load_area = np.full((unload_area_num, load_area_num), M)
+#         self.walk_time_to_unload_area = np.full((unload_area_num, load_area_num), M)
+#
+#         # 路网行驶时间
+#         self.distance_to_excavator = np.full(
+#             (dynamic_dump_num, dynamic_excavator_num), M
+#         )
+#         self.distance_to_dump = np.full((dynamic_dump_num, dynamic_excavator_num), M)
+#         self.distance_park_to_excavator = np.full((park_num, dynamic_excavator_num), M)
+#         self.distance_park_to_load_area = np.full((park_num, load_area_num), M)
+#         self.distance_to_load_area = np.full((unload_area_num, load_area_num), M)
+#         self.distance_to_unload_area = np.full((unload_area_num, load_area_num), M)
+#
+#     def get_walk_time_to_load_area(self):
+#         return self.walk_time_to_load_area
+#
+#     def get_walk_time_to_unload_area(self):
+#         return self.walk_time_to_unload_area
+#
+#     def get_walk_time_to_excavator(self):
+#         return self.walk_time_to_excavator
+#
+#     def get_walk_time_to_dump(self):
+#         return self.walk_time_to_dump
+#
+#     def get_walk_time_park_to_load_area(self):
+#         return self.walk_time_park_to_load_area
+#
+#     def get_walk_time_park_to_excavator(self):
+#         return self.walk_time_park_to_excavator
+#
+#     def get_distance_to_load_area(self):
+#         return self.distance_to_load_area
+#
+#     def get_distance_to_unload_area(self):
+#         return self.distance_to_unload_area
+#
+#     def get_distance_to_excavator(self):
+#         return self.distance_to_excavator
+#
+#     def get_distance_to_dump(self):
+#         return self.distance_to_dump
+#
+#     def get_distance_park_to_load_area(self):
+#         return self.distance_park_to_load_area
+#
+#     def get_distance_park_to_excavator(self):
+#         return self.distance_park_to_excavator
+#
+#     def reset(self):
+#
+#         # dynamic_excavator_num
+#         # dynamic_dump_num
+#         # park_num
+#
+#         # 路网真实距离
+#         self.walk_time_to_excavator = np.full(
+#             (dynamic_dump_num, dynamic_excavator_num), M
+#         )
+#         self.walk_time_to_dump = np.full((dynamic_dump_num, dynamic_excavator_num), M)
+#         self.walk_time_park_to_excavator = np.full((park_num, dynamic_excavator_num), M)
+#         self.walk_time_park_to_load_area = np.full((park_num, load_area_num), M)
+#         self.walk_time_to_load_area = np.full((unload_area_num, load_area_num), M)
+#         self.walk_time_to_unload_area = np.full((unload_area_num, load_area_num), M)
+#
+#         # 路网行驶时间
+#         self.distance_to_excavator = np.full(
+#             (dynamic_dump_num, dynamic_excavator_num), M
+#         )
+#         self.distance_to_dump = np.full((dynamic_dump_num, dynamic_excavator_num), M)
+#         self.distance_park_to_excavator = np.full((park_num, dynamic_excavator_num), M)
+#         self.distance_park_to_load_area = np.full((park_num, load_area_num), M)
+#         self.distance_to_load_area = np.full((unload_area_num, load_area_num), M)
+#         self.distance_to_unload_area = np.full((unload_area_num, load_area_num), M)
+#
+#     def period_walk_para_update(self):
+#
+#         self.reset()
+#
+#         self.period_map_para_update()
+#
+#         # 计算路网距离及行走时间
+#         try:
+#             # 处理距离
+#             for item in session_postgre.query(WalkTime).all():
+#                 load_area = str(item.load_area_id)
+#                 unload_area = str(item.unload_area_id)
+#                 load_area_index = load_area_uuid_to_index_dict[load_area]
+#                 unload_area_index = unload_area_uuid_to_index_dict[unload_area]
+#                 self.distance_to_load_area[unload_area_index][load_area_index] = float(
+#                     item.to_load_distance
+#                 )
+#                 self.walk_time_to_load_area[unload_area_index][load_area_index] = float(
+#                     60 / 1000 * item.to_load_distance / empty_speed
+#                 )
+#                 self.distance_to_unload_area[unload_area_index][
+#                     load_area_index
+#                 ] = float(item.to_unload_distance)
+#                 self.walk_time_to_unload_area[unload_area_index][
+#                     load_area_index
+#                 ] = float(60 / 1000 * item.to_unload_distance / heavy_speed)
+#         except Exception as es:
+#             logger.error("路网信息异常")
+#             logger.error(es)
+#
+#         # 计算设备路网距离及行走时间
+#         try:
+#             for i in range(dynamic_dump_num):
+#                 for j in range(dynamic_excavator_num):
+#                     self.distance_to_excavator[i][j] = self.distance_to_load_area[
+#                         self.dump_index_to_unload_area_index_dict[i]
+#                     ][self.excavator_index_to_load_area_index_dict[j]]
+#                     self.walk_time_to_excavator[i][j] = self.walk_time_to_load_area[
+#                         self.dump_index_to_unload_area_index_dict[i]
+#                     ][self.excavator_index_to_load_area_index_dict[j]]
+#                     self.distance_to_dump[i][j] = self.distance_to_unload_area[
+#                         self.dump_index_to_unload_area_index_dict[i]
+#                     ][self.excavator_index_to_load_area_index_dict[j]]
+#                     self.walk_time_to_dump[i][j] = self.walk_time_to_unload_area[
+#                         self.dump_index_to_unload_area_index_dict[i]
+#                     ][self.excavator_index_to_load_area_index_dict[j]]
+#         except Exception as es:
+#             logger.error("设备路网信息异常异常")
+#             logger.error(es)
+#
+#         try:
+#             for item in session_postgre.query(WalkTimePark).all():
+#                 load_area = str(item.load_area_id)
+#                 park_area = str(item.park_area_id)
+#                 load_area_index = load_area_uuid_to_index_dict[load_area]
+#                 park_index = park_uuid_to_index_dict[park_area]
+#                 self.distance_park_to_load_area[park_index][load_area_index] = float(
+#                     item.park_load_distance
+#                 )
+#                 self.walk_time_park_to_load_area[park_index][load_area_index] = float(
+#                     60 / 1000 * item.park_load_distance / empty_speed
+#                 )
+#         except Exception as es:
+#             logger.error("备停区路网信息异常")
+#             logger.error(es)
+#         try:
+#             for i in range(park_num):
+#                 for j in range(dynamic_excavator_num):
+#                     self.distance_park_to_excavator[i][j] = self.distance_park_to_load_area[
+#                         i
+#                     ][self.excavator_index_to_load_area_index_dict[j]]
+#                     self.walk_time_park_to_excavator[i][
+#                         j
+#                     ] = self.walk_time_park_to_load_area[i][
+#                         self.excavator_index_to_load_area_index_dict[j]
+#                     ]
+#         except Exception as es:
+#             logger.error("备停区设备路网信息异常")
+#             logger.error(es)
+#
+#     def period_walk_para_load(self):
+#         # 装载路网信息
+#         self.distance_to_load_area = walk_manage.distance_to_load_area
+#         self.distance_to_unload_area = walk_manage.distance_to_unload_area
+#         self.distance_park_to_load_area = walk_manage.distance_park_to_load_area
+#
+#         self.distance_to_excavator = walk_manage.distance_to_excavator
+#         self.distance_to_dump = walk_manage.distance_to_dump
+#         self.distance_park_to_excavator = walk_manage.distance_park_to_excavator
+#
+#         self.walk_time_to_excavator = walk_manage.walk_time_to_excavator
+#         self.walk_time_to_dump = walk_manage.walk_time_to_dump
+#         self.walk_time_park_to_excavator = walk_manage.walk_time_park_to_excavator
+#
+#         self.walk_time_to_load_area = walk_manage.walk_time_to_load_area
+#         self.walk_time_to_unload_area = walk_manage.walk_time_to_unload_area
+#         self.walk_time_park_to_load_area = walk_manage.walk_time_park_to_load_area
+#
+#
+# device_map = DeviceMap()
+#
+# walk_manage = WalkManage()
+#
+# device_map.period_map_para_update()
+#
+# walk_manage.period_map_para_load()
+#
+# walk_manage.period_walk_para_update()
+#
+#
+# def period_para_update():
+#     global load_area_uuid_to_index_dict, load_area_index_to_uuid_dict
+#     global unload_area_uuid_to_index_dict, unload_area_index_to_uuid_dict
+#     global load_area_num, unload_area_num, park_num
+#     global park_uuid_to_index_dict, park_index_to_uuid_dict
+#     global truck_uuid_to_name_dict, truck_name_to_uuid_dict
+#     global dynamic_truck_num, dynamic_excavator_num, dynamic_dump_num
+#
+#     # 清空数据库缓存
+#     session_mysql.commit()
+#     session_mysql.flush()
+#
+#     # 装载区、卸载区、备停区在调度算法运行器件默认不发生改变，提前计算部分参量
+#     # (uuid,index(id)映射关系, 装载区数量, 卸载区数量, 备停区数量, 以及初次统计动态调度矿卡)
+#     (
+#         load_area_uuid_to_index_dict,
+#         unload_area_uuid_to_index_dict,
+#         load_area_index_to_uuid_dict,
+#         unload_area_index_to_uuid_dict,
+#     ) = build_work_area_uuid_index_map()
+#
+#     load_area_num, unload_area_num = len(load_area_uuid_to_index_dict), len(
+#         unload_area_uuid_to_index_dict
+#     )
+#
+#     park_uuid_to_index_dict, park_index_to_uuid_dict = build_park_uuid_index_map()
+#
+#     park_num = len(park_uuid_to_index_dict)
+#
+#     truck_uuid_to_name_dict, truck_name_to_uuid_dict = build_truck_uuid_name_map()
+#
+#     # 矿卡集合
+#     truck_set = set(update_total_truck())
+#
+#     logger.info("truck_set")
+#     logger.info(truck_set)
+#
+#     # 固定派车矿卡集合
+#     fixed_truck_set = set(update_fixdisp_truck())
+#
+#     logger.info("fixed_truck_set")
+#     logger.info(fixed_truck_set)
+#
+#     # 动态派车矿卡集合
+#     # dynamic_truck_set = truck_set.difference(fixed_truck_set)
+#     dynamic_truck_set = update_dynamic_truck()
+#
+#     dynamic_truck_num = len(dynamic_truck_set)
+#
+#     logger.info("可用于动态派车的矿卡：")
+#     logger.info(dynamic_truck_num)
+#     logger.info(dynamic_truck_set)
+#
+#     # 用于动态调度的挖机及卸载设备
+#     dynamic_excavator_set = set(update_autodisp_excavator())
+#     dynamic_excavator_num = len(dynamic_excavator_set)
+#
+#     dynamic_dump_set = set(update_autodisp_dump())
+#     dynamic_dump_num = len(dynamic_dump_set)
+#
+#     device_map.period_map_para_update()
+#
+#     walk_manage.period_walk_para_update()
+#
+#     global_dict["dynamic_truck_set"] = dynamic_truck_set
+#     global_dict["dynamic_truck_num"] = dynamic_truck_num
+#     global_dict["dynamic_excavator_set"] = dynamic_excavator_set
+#     global_dict["dynamic_excavator_num"] = dynamic_excavator_num
+#     global_dict["dynamic_dump_set"] = dynamic_dump_set
+#     global_dict["dynamic_dump_num"] = dynamic_dump_num
+#     global_dict["park_num"] = park_num
+#
+#     print("walk_manage.distance_to_excavator")
+#     print(dynamic_dump_num, dynamic_excavator_num)
+#     print(walk_manage.distance_to_excavator)
+#
+#     print("walk_manage.excavator_dict")
+#     print(walk_manage.excavator_uuid_to_index_dict)
+#     print("walk_manage.dump_dict")
+#     print(walk_manage.dump_uuid_to_index_dict)
+#
+#     global_dict["distance_to_excavator"] = walk_manage.distance_to_excavator
+#     global_dict["distance_park_to_excavator"] = walk_manage.distance_park_to_excavator
+#     global_dict["distance_to_dump"] = walk_manage.distance_to_dump
+#
+#     logger.info("walk_manage_para")
+#     logger.info("distance_to_excavator")
+#     logger.info(walk_manage.distance_to_excavator)
+#     logger.info("distance_park_to_excavator")
+#     logger.info(walk_manage.distance_park_to_excavator)
+#     logger.info("distance_to_dump")
+#     logger.info(walk_manage.distance_to_dump)
+#     logger.info("excavator_uuid_to_index_dict")
+#     logger.info(walk_manage.excavator_uuid_to_index_dict)
+#     logger.info("dump_uuid_to_index_dict")
+#     logger.info(walk_manage.dump_uuid_to_index_dict)
+#     logger.info("walk_manage.distance_park_to_excavator")
+#     logger.info(walk_manage.distance_park_to_excavator)
+#
+#     logger.info("walk_manage.truck_index_to_uuid_dict")
+#     logger.info(walk_manage.truck_index_to_uuid_dict)
+#     logger.info("walk_manage.dynamic_truck_set")
+#     logger.info(dynamic_truck_set)

path_plan/path_plannner.py

@@ -7,6 +7,7 @@
 # @Software: PyCharm
 
 from equipment.truck import TruckInfo, DumpInfo, ExcavatorInfo
+# from path_plan.priority_control import PriorityController
 from path_plan.priority_control import PriorityController
 from para_config import *
 from tables import *
@@ -27,7 +28,6 @@ class PathPlanner(WalkManage):
         # 控制类
         self.controller = PriorityController(self.dump, self.excavator, self.truck)
 
-
         # 路线行驶成本
         self.rout_cost = np.array((unload_area_num, load_area_num))
         # 路段集合
@@ -123,7 +123,7 @@ class PathPlanner(WalkManage):
                 # print("拥堵因子-卸点")
                 # print(alpha, cost_to_unload_blockage)
         except Exception as es:
-            logger.error(f'道路{load_area_id + "-" +unload_area_id}行驶成本计算异常')
+            logger.error(f'道路{load_area_id + "-" + unload_area_id}行驶成本计算异常')
             logger.error(es)
 
         return to_load_cost, to_unload_cost
@@ -165,7 +165,7 @@ class PathPlanner(WalkManage):
 
         self.period_map_para_load()
 
-        self.controller.period_update(self.dump, self.excavator, self.truck)
+        # self.controller.period_update(self.dump, self.excavator, self.truck)
 
         # 计算行驶成本前，更新路网速度信息
         self.lane.lane_speed_generate()
@@ -191,8 +191,6 @@ class PathPlanner(WalkManage):
             logger.error(es)
 
         self.cost_to_excavator = np.zeros_like(get_value("distance_to_excavator"))
-        print("distance_to_excavator")
-        print(self.cost_to_excavator)
         self.cost_to_dump = np.zeros_like(get_value("distance_to_dump"))
         self.cost_park_to_excavator = np.zeros_like(get_value("distance_park_to_excavator"))
 
@@ -201,15 +199,17 @@ class PathPlanner(WalkManage):
 
         # try:
         # 路网权重
-        walk_weight, park_walk_weight = self.controller.weighted_walk_cost()
+        walk_to_excavator_weight, walk_to_dump_weight, park_walk_weight = self.controller.weighted_walk_calc()
 
         # 路网禁用关系
-        walk_available = self.controller.available_walk()
+        walk_available = self.controller.walk_available_calc()
 
-        group_walk_available = self.controller.update_group_walk_available()
+        # group_walk_available = self.controller.update_group_walk_available()
 
         logger.info("path_weight")
-        logger.info(walk_weight)
+        logger.info(walk_to_excavator_weight)
+        logger.info(walk_to_dump_weight)
+        logger.info(park_walk_weight)
 
         logger.info("walk_avail")
         logger.info(walk_available)
@@ -223,8 +223,12 @@ class PathPlanner(WalkManage):
                 unload_area_index = self.dump_index_to_unload_area_index_dict[i]
                 logger.info("cost_to_excavator")
                 logger.info(self.cost_to_excavator)
-                self.cost_to_excavator[i][j] = self.cost_to_load_area[unload_area_index][load_area_index] / walk_weight[i][j] + group_walk_available[i][j]
-                self.cost_to_dump[i][j] = self.cost_to_unload_area[unload_area_index][load_area_index] / walk_weight[i][j] + walk_available[i][j] + group_walk_available[i][j]
+                # self.cost_to_excavator[i][j] = self.cost_to_load_area[unload_area_index][load_area_index] / walk_weight[i][j] + group_walk_available[i][j]
+                self.cost_to_excavator[i][j] = self.cost_to_load_area[unload_area_index][load_area_index] / \
+                                               walk_to_excavator_weight[i][j] + walk_available[i][j]
+                # self.cost_to_dump[i][j] = self.cost_to_unload_area[unload_area_index][load_area_index] / walk_weight[i][j] + walk_available[i][j] + group_walk_available[i][j]
+                self.cost_to_dump[i][j] = self.cost_to_unload_area[unload_area_index][load_area_index] / \
+                                          walk_to_dump_weight[j][i] + walk_available[i][j]
 
         for j in range(get_value("dynamic_excavator_num")):
             load_area_index = self.excavator_index_to_load_area_index_dict[j]
@@ -289,7 +293,10 @@ class LaneInfo:
                 device_type = key_value_dict[str_to_byte('type')]
                 is_online = key_value_dict[str_to_byte('online')]
                 key_set = key_value_dict.keys()
-                if (device_type == str_to_byte("1")) and ((str_to_byte('online') in key_set) and bytes.decode(is_online)) and (str_to_byte('laneId') in key_set):
+                if (device_type == str_to_byte("1")) \
+                        and (str_to_byte('online') in key_set) \
+                        and (bytes.decode(is_online) in ["true" or "True"]) \
+                        and (str_to_byte('laneId') in key_set):
                     truck_locate = key_value_dict[str_to_byte('laneId')]
                     truck_locate_dict[truck_name_to_uuid_dict[item]] = eval(truck_locate)
         except Exception as es:
@@ -370,7 +377,8 @@ class LaneInfo:
             # 对不存在的矿卡路段，实时速度设置为最高
             for lane_id in lane_set:
                 if lane_id not in tmp_lane_set:
-                    self.lane_speed_dict[str(lane_id)] = session_postgre.query(Lane).filter_by(Id=lane_id).first().MaxSpeed
+                    self.lane_speed_dict[str(lane_id)] = session_postgre.query(Lane).filter_by(
+                        Id=lane_id).first().MaxSpeed
                     lane_trucks_dict[str(lane_id)] = 1
 
             # 各路段实时速度取平均

path_plan/priority_control.py

@@ -20,18 +20,23 @@ class PriorityController():
         self.excavator = excavator
         self.truck = truck
 
-    def period_update(self, dump, excavator, truck):
-        # 设备类
-        self.dump = dump
-        self.excavator = excavator
-        self.truck = truck
+        # 获取日志器
+        self.logger = get_logger("zxt.prio")
+        
 
-    def weighted_walk_cost(self):
+    def weighted_walk_calc(self):
+        """
+        计算运输路线权重, 权重影响因素：设备优先级, 物料优先级,
+        :return:
+            walk_weight: 卸载-装载区 路网权重
+            park_walk_weight: 备停区-装载区 路网权重
+        """
         dynamic_dump_num = get_value("dynamic_dump_num")
         dynamic_excavator_num = get_value("dynamic_excavator_num")
         dynamic_dump_set = get_value("dynamic_dump_set")
         dynamic_excavator_set = get_value("dynamic_excavator_set")
-        walk_weight = np.ones((dynamic_dump_num, dynamic_excavator_num))
+        walk_to_excavator_weight = np.ones((dynamic_dump_num, dynamic_excavator_num))
+        walk_to_dump_weight = np.ones((dynamic_excavator_num, dynamic_dump_num))
         excavator_priority = self.excavator.excavator_priority_coefficient
         excavator_material_priority = self.excavator.excavator_material_priority
         dump_priority = self.dump.dump_priority_coefficient
@@ -45,8 +50,8 @@ class PriorityController():
                 for excavator_id in dynamic_excavator_set:
                     dump_index = self.dump.dump_uuid_to_index_dict[dump_id]
                     excavator_inedx = self.excavator.excavator_uuid_to_index_dict[excavator_id]
-                    walk_weight[dump_index][excavator_inedx] += dump_priority[dump_index] * \
-                                                                excavator_priority[excavator_inedx]
+                    walk_to_excavator_weight[dump_index][excavator_inedx] += excavator_priority[excavator_inedx]
+                    walk_to_dump_weight[excavator_inedx][dump_index] += dump_priority[dump_index]
             park_walk_weight = park_walk_weight * self.excavator.excavator_priority_coefficient
 
         rule7 = session_mysql.query(DispatchRule).filter_by(id=7).first()
@@ -56,29 +61,67 @@ class PriorityController():
                 for excavator_id in dynamic_excavator_set:
                     dump_index = self.dump.dump_uuid_to_index_dict[dump_id]
                     excavator_inedx = self.excavator.excavator_uuid_to_index_dict[excavator_id]
-                    walk_weight[dump_index][excavator_inedx] += dump_material_priority[dump_index] * \
-                                                                excavator_material_priority[excavator_inedx]
+                    walk_to_excavator_weight[dump_index][excavator_inedx] += excavator_material_priority[excavator_inedx]
+                    walk_to_dump_weight[excavator_inedx][dump_index] += dump_material_priority[dump_index]
             park_walk_weight = park_walk_weight * self.excavator.excavator_material_priority
 
         try:
-            walk_weight = walk_weight - (walk_weight.min() - 1)
+            walk_to_excavator_weight = walk_to_excavator_weight - (walk_to_excavator_weight.min() - 1)
+
+            walk_to_dump_weight = walk_to_dump_weight - (walk_to_dump_weight.min() - 1)
 
             park_walk_weight = park_walk_weight - (park_walk_weight.min() - 1)
         except Exception as es:
-            logger.errro(es)
-            logger.error("数值异常")
+            self.logger.errro(es)
+            self.logger.error("优先级归一化异常")
+
+        return walk_to_excavator_weight, walk_to_dump_weight, park_walk_weight
+
+    def walk_available_calc(self):
+        """
+        计算路网可通行性(物料, 地图, 分组三者综合)
+        :return:
+            walk_available: 路网可通行性(dump_num, excavator_num)
+        """
+
+        map_walk_available = self.update_map_walk_available()
+        group_walk_available = self.update_group_walk_available()
+        material_walk_available = self.update_material_walk_available()
 
-        return walk_weight, park_walk_weight
+        walk_available = map_walk_available * group_walk_available * material_walk_available
 
-    def available_walk(self):
+        return walk_available
+
+    def update_group_walk_available(self):
+        """
+        计算调度分组间的路网可通行性, 不同分组间路网不可通行
+        :return:
+            group_walk_available: 调度分组路网可通行性矩阵(dump_num, excavator_num)
+        """
+        group_walk_available = np.zeros((get_value("dynamic_dump_num"), get_value("dynamic_excavator_num")))
+
+        for dump_id in get_value("dynamic_dump_set"):
+            for excavator_id in get_value("dynamic_excavator_set"):
+                item = session_mysql.query(Dispatch).filter_by(dump_id=dump_id, exactor_id=excavator_id, isauto=1,
+                                                               isdeleted=0).first()
+                if item is not None:
+                    dump_index = self.dump.dump_uuid_to_index_dict[dump_id]
+                    excavator_index = self.excavator.excavator_uuid_to_index_dict[excavator_id]
+                    group_walk_available[dump_index][excavator_index] = 1
+
+        return group_walk_available
+
+    def update_material_walk_available(self):
+        """
+        更新物料兼容性下路网可通行性
+        :return:
+            walk_available: 物料兼容路网可通行性矩阵(dump_num, excavator_num)
+        """
         dynamic_dump_num = get_value("dynamic_dump_num")
         dynamic_excavator_num = get_value("dynamic_excavator_num")
         dynamic_dump_set = get_value("dynamic_dump_set")
         dynamic_excavator_set = get_value("dynamic_excavator_set")
-        walk_weight = np.zeros((dynamic_dump_num, dynamic_excavator_num))
-
-        print("here")
-        print(dynamic_dump_set)
+        walk_available = np.ones((dynamic_dump_num, dynamic_excavator_num))
 
         try:
 
@@ -86,24 +129,30 @@ class PriorityController():
                 for excavator_id in dynamic_excavator_set:
                     dump_index = self.dump.dump_uuid_to_index_dict[dump_id]
                     excavator_inedx = self.excavator.excavator_uuid_to_index_dict[excavator_id]
+                    # 两设备处理物料不同, 相关路网不可通行
                     if self.excavator.excavator_material[excavator_id] != self.dump.dump_material[dump_id]:
-                        walk_weight[dump_index][excavator_inedx] += 1000000
+                        walk_available[dump_index][excavator_inedx] = 0
         except Exception as es:
-            logger.info(es)
-            logger.info("error-12")
+            self.logger.info(es)
+            self.logger.info("error-12")
 
-        return walk_weight
+        return walk_available
 
-    def update_group_walk_available(self):
-        group_walk_available = np.full((get_value("dynamic_dump_num"), get_value("dynamic_excavator_num")), 1000000)
+    def update_map_walk_available(self):
+        """
+        更新物理路网可通行性
+        :return:
+            walk_available: 物理路网可通行性矩阵(dump_num, excavator_num)
+        """
+        dynamic_dump_num = get_value("dynamic_dump_num")
+        dynamic_excavator_num = get_value("dynamic_excavator_num")
+        walk_available = np.ones((dynamic_dump_num, dynamic_excavator_num))
 
-        for dump_id in get_value("dynamic_dump_set"):
-            for excavator_id in get_value("dynamic_excavator_set"):
-                item = session_mysql.query(Dispatch).filter_by(dump_id=dump_id, exactor_id=excavator_id, isauto=1,
-                                                               isdeleted=0).first()
-                if item is not None:
-                    dump_index = self.dump.dump_uuid_to_index_dict[dump_id]
-                    excavator_index = self.excavator.excavator_uuid_to_index_dict[excavator_id]
-                    group_walk_available[dump_index][excavator_index] = 0
+        walk_manage.period_walk_para_update()
 
-        return group_walk_available
+        for dump_index in range(dynamic_dump_num):
+            for excavator_index in range(dynamic_excavator_num):
+                if walk_manage.distance_to_excavator[dump_index][excavator_index] > M / 2:
+                    walk_available[dump_index][excavator_index] = 0
+
+        return walk_available

realtime_dispatch.py

@@ -16,952 +16,9 @@ from equipment.excavator import ExcavatorInfo
 from equipment.dump import DumpInfo
 import sched
 import time
-from group_control.group_control import Group
+from dispatcher import Dispatcher, PreSchedule
 
-dump = DumpInfo()
-excavator = ExcavatorInfo()
-truck = TruckInfo(dump, excavator)
 
-
-# 调度类
-class Dispatcher(WalkManage):
-    def __init__(self):
-
-        # 模拟挖机/卸载设备产量(防止调度修改真实产量)
-        self.sim_dump_real_mass = np.zeros(dump.get_dump_num())
-        self.sim_excavator_real_mass = np.zeros(excavator.get_excavator_num())
-        # 真实设备可用时间
-        self.cur_truck_reach_dump = np.zeros(truck.get_truck_num())
-        self.cur_truck_reach_excavator = np.zeros(truck.get_truck_num())
-        self.cur_excavator_ava_time = np.zeros(excavator.get_excavator_num())
-        self.cur_dump_ava_time = np.zeros(dump.get_dump_num())
-        # 卡车完成装载及卸载时间(矿卡可用时间)
-        self.cur_truck_ava_time = np.zeros(truck.get_truck_num())
-        # 模拟矿卡可用时间
-        self.sim_truck_ava_time = np.zeros(truck.get_truck_num())
-        # 模拟各设备可用时间(防止调度修改真实产量)
-        self.sim_excavator_ava_time = np.zeros(excavator.get_excavator_num())
-        self.sim_dump_ava_time = np.zeros(dump.get_dump_num())
-        # 挖机/卸载设备预计产量(包含正在驶往挖机/卸载设备那部分矿卡的载重)
-        self.pre_dump_real_mass = np.zeros(dump.get_dump_num())
-        self.pre_excavator_real_mass = np.zeros(excavator.get_excavator_num())
-
-        # 维护一个矿卡调度表
-        self.Seq = [[] for _ in range(truck.get_truck_num())]
-        # 调度开始时间
-        self.start_time = datetime.now()
-        # self.relative_now_time = datetime.now() - self.start_time
-
-        self.path = PathPlanner()
-
-        # 读取车流信息
-
-        self.traffic_flow = Traffic_flow(dump, excavator, truck)
-
-        self.group = Group(dump, excavator, truck, self.traffic_flow)
-
-
-    # 更新矿卡预计抵达目的地时间
-    def update_truck_reach_time(self):
-        try:
-            dynamic_excavator_num = excavator.get_excavator_num()
-            dumps = dump.get_dump_num()
-            trucks = truck.get_truck_num()
-
-            truck_current_task = truck.get_truck_current_task()
-
-            truck_current_trip = truck.get_truck_current_trip()
-
-            cur_truck_reach_excavator = truck.get_truck_reach_excavator()
-
-            cur_truck_reach_dump = truck.get_truck_reach_dump()
-
-            excavator_ava_ls = [[] for _ in range(dynamic_excavator_num)]
-            dump_ava_ls = [[] for _ in range(dumps)]
-            for i in range(trucks):
-                task = truck_current_task[truck.truck_index_to_uuid_dict[i]]
-                end_area_index = truck_current_trip[i][1]
-                if task in [0, 1]:
-                    reach_time = cur_truck_reach_excavator[i]
-                    excavator_ava_ls[end_area_index].append(
-                        [reach_time, i, end_area_index]
-                    )
-                elif task in [3, 4]:
-                    reach_time = cur_truck_reach_dump[i]
-                    dump_ava_ls[end_area_index].append([reach_time, i, end_area_index])
-                elif task == -2:
-                    self.cur_truck_ava_time[i] = (
-                        datetime.now() - self.start_time
-                    ) / timedelta(hours=0, minutes=1, seconds=0)
-
-            # print(truck_index_to_uuid_dict)
-            # print(excavator_ava_ls)
-            # print(dump_ava_ls)
-        except Exception as es:
-            logger.error("矿卡预计抵达时间计算异常")
-            logger.error(es)
-
-        return excavator_ava_ls, dump_ava_ls
-
-    # 更新挖机预计可用时间
-    def update_excavator_ava_time(self, excavator_ava_ls):
-
-        # 初始化挖机可用时间
-        self.cur_excavator_ava_time = np.full(
-            get_value("dynamic_excavator_num"),
-            (datetime.now() - self.start_time)
-            / timedelta(hours=0, minutes=1, seconds=0),
-        )
-
-        loading_time = excavator.get_loading_time()
-
-        loading_task_time = excavator.get_loading_task_time()
-
-        try:
-
-            now = float(
-                (datetime.now() - self.start_time)
-                / timedelta(hours=0, minutes=1, seconds=0)
-            )
-
-            for reach_ls in excavator_ava_ls:
-                if len(reach_ls) != 0:
-                    reach_ls = np.array(reach_ls)
-                    tmp = reach_ls[np.lexsort(reach_ls[:, ::-1].T)]
-                    for i in range(len(tmp)):
-                        excavator_index = int(tmp[i][2])
-                        self.cur_excavator_ava_time[excavator_index] = (
-                            max(tmp[i][0], self.cur_excavator_ava_time[excavator_index])
-                            + loading_task_time[excavator_index]
-                        )
-                        self.cur_truck_ava_time[
-                            int(tmp[i][1])
-                       ] = self.cur_excavator_ava_time[excavator_index]
-
-                        # # 若挖机可用时间严重偏离，进行修正
-                        # if abs(self.cur_excavator_ava_time[excavator_index] - now) > 60:
-                        #     self.cur_truck_ava_time[int(tmp[i][1])] = now
-                        # if abs(self.cur_excavator_ava_time[excavator_index] - now) > 60:
-                        #     self.cur_excavator_ava_time[excavator_index] = now
-        except Exception as es:
-            logger.error("挖机可用时间计算异常")
-            logger.error(es)
-
-    # 更新卸载设备预计可用时间
-    def update_dump_ava_time(self, dump_ava_ls):
-
-        dynamic_dump_num = dump.get_dump_num()
-
-        # 初始化卸载设备可用时间
-        self.cur_dump_ava_time = np.full(
-            dynamic_dump_num,
-            (datetime.now() - self.start_time)
-            / timedelta(hours=0, minutes=1, seconds=0),
-        )
-
-        unloading_time = dump.get_unloading_time()
-
-        unloading_task_time = dump.get_unloading_task_time()
-
-        try:
-
-            now = float(
-                (datetime.now() - self.start_time)
-                / timedelta(hours=0, minutes=1, seconds=0)
-            )
-
-            for reach_ls in dump_ava_ls:
-                if len(reach_ls) != 0:
-                    reach_ls = np.array(reach_ls)
-                    tmp = reach_ls[np.lexsort(reach_ls[:, ::-1].T)]
-                    for i in range(len(tmp)):
-                        dump_index = int(tmp[i][2])
-                        self.cur_dump_ava_time[dump_index] = (
-                            max(tmp[i][0], self.cur_dump_ava_time[dump_index])
-                            + unloading_task_time[dump_index]
-                        )
-                        self.cur_truck_ava_time[
-                            int(tmp[i][1])
-                        ] = self.cur_dump_ava_time[dump_index]
-
-                        # # 若卸载设备可用时间严重偏离，进行修正
-                        # if abs(self.cur_dump_ava_time[dump_index] - now) > 60:
-                        #     self.cur_dump_ava_time[dump_index] = now
-                        # if abs(self.cur_truck_ava_time[int(tmp[i][1])] - now) > 60:
-                        #     self.cur_truck_ava_time[int(tmp[i][1])] = now
-        except Exception as es:
-            logger.error("卸载设备可用时间计算异常")
-            logger.error(es)
-
-    def dispatcher_period_update(self):
-
-        # 装载映射参数及
-        self.period_map_para_load()
-
-        self.period_walk_para_load()
-
-        # 更新卸载设备对象
-        dump.para_period_update()
-
-        # 更新挖机对象
-        excavator.para_period_update()
-
-        # 更新矿卡对象
-        truck.para_period_update(dump, excavator)
-
-        truck.state_period_update()
-
-        # 更新实时车流
-        # self.update_actual_traffic_flow()
-        self.traffic_flow.update_actual_traffic_flow()
-
-        # 矿卡抵达时间
-        excavator_reach_list, dump_reach_list = self.update_truck_reach_time()
-
-        # 挖机可用时间
-        self.update_excavator_ava_time(excavator_reach_list)
-
-        # 卸载设备可用时间
-        self.update_dump_ava_time(dump_reach_list)
-
-        self.cost_to_excavator, self.cost_to_dump, self.cost_park_to_excavator = self.path.walk_cost()
-
-        # 调度分组更新
-        self.group.period_update()
-
-    def sim_para_reset(self):
-
-        # 设备可用时间重置
-        self.sim_truck_ava_time = copy.deepcopy(self.cur_truck_ava_time)
-        self.sim_excavator_ava_time = copy.deepcopy(self.cur_excavator_ava_time)
-        self.sim_dump_ava_time = copy.deepcopy(self.cur_dump_ava_time)
-
-    def reset(self):
-        # 模拟挖机/卸载设备产量(防止调度修改真实产量)
-        self.sim_dump_real_mass = np.zeros(dump.get_dump_num())
-        self.sim_excavator_real_mass = np.zeros(excavator.get_excavator_num())
-        # 真实设备可用时间
-        self.cur_truck_reach_dump = np.zeros(truck.get_truck_num())
-        self.cur_truck_reach_excavator = np.zeros(truck.get_truck_num())
-        self.cur_excavator_ava_time = np.zeros(excavator.get_excavator_num())
-        self.cur_dump_ava_time = np.zeros(dump.get_dump_num())
-        # 卡车完成装载及卸载时间(矿卡可用时间)
-        self.cur_truck_ava_time = np.zeros(truck.get_truck_num())
-        # 模拟矿卡可用时间
-        self.sim_truck_ava_time = np.zeros(truck.get_truck_num())
-        # 模拟各设备可用时间(防止调度修改真实产量)
-        self.sim_excavator_ava_time = np.zeros(excavator.get_excavator_num())
-        self.sim_dump_ava_time = np.zeros(dump.get_dump_num())
-        # 挖机/卸载设备预计产量(包含正在驶往挖机/卸载设备那部分矿卡的载重)
-        self.pre_dump_real_mass = np.zeros(dump.get_dump_num())
-        self.pre_excavator_real_mass = np.zeros(excavator.get_excavator_num())
-
-        # 维护一个矿卡调度表
-        self.Seq = [[] for _ in range(truck.get_truck_num())]
-
-    def truck_schedule(self, truck_id):
-
-            # 规则读取
-            global transport_value
-            rule3 = session_mysql.query(DispatchRule).filter_by(id=3).first().disabled
-
-            rule4 = session_mysql.query(DispatchRule).filter_by(id=4).first().disabled
-
-            # 读取优先级设置
-            excavator_priority_coefficient = excavator.excavator_priority_coefficient
-
-            excavator_material_priority = excavator.excavator_material_priority
-
-            # 矿卡对应序号
-            truck_index = truck.truck_uuid_to_index_dict[truck_id]
-
-            # 矿卡行程
-            trip = truck.get_truck_current_trip()[truck_index]
-
-            # 矿卡当前任务
-            task = truck.get_truck_current_task()[truck.truck_index_to_uuid_dict[truck_index]]
-
-            if truck_id not in self.group.dispatch_truck_group:
-                logger.error("无该矿卡")
-                return -1
-
-            # 矿卡调度分组
-            group_id = self.group.dispatch_truck_group[truck_id]
-
-            dynamic_dump_num = dump.get_dump_num()
-
-            dynamic_excavator_num = excavator.get_excavator_num()
-
-            target = 0
-
-            # 是否启用挖机均衡
-            rule_ex = False
-
-            # 车流计算
-            # 驶往卸载设备的实际车流
-            actual_goto_dump_traffic_flow = self.traffic_flow.actual_goto_dump_traffic_flow
-
-            # 驶往挖机的实际车流
-            actual_goto_excavator_traffic_flow = self.traffic_flow.actual_goto_excavator_traffic_flow
-
-            # 计算理想车流
-            opt_goto_dump_traffic_flow, opt_goto_excavator_traffic_flow = traffic_flow_plan(truck)
-
-            logger.info("==========================================================")
-            logger.info(f"调度矿卡 {truck_id} {truck_index} {truck_uuid_to_name_dict[truck_id]}")
-
-            if task == -2:
-                try:
-                    logger.info("矿卡状态：矿卡启动或故障恢复")
-                    logger.info("矿卡行程：无")
-                    logger.info(f"涉及挖机：{list(excavator.excavator_uuid_to_index_dict.keys())}")
-                    logger.info("物料类型")
-                    if truck_id in truck.truck_material_bind:
-                        logger.info(truck.truck_material_bind[truck_id])
-                    logger.info("挖机物料优先级")
-                    logger.info(excavator_material_priority)
-                    logger.info("挖机设备优先级")
-                    logger.info(excavator_priority_coefficient)
-
-                    logger.info("分组车流")
-                    logger.info(self.group.group_actual_goto_dump_traffic_flow[group_id])
-                    logger.info(self.group.group_opt_goto_dump_traffic_flow[group_id])
-
-                except Exception as es:
-                    logger.error(f"矿卡{truck_id}状态不匹配")
-                    logger.error(es)
-
-                try:
-                    # 1. 矿卡是否存在绑定挖机
-                    if truck_id in truck.truck_excavator_bind:
-                        target = excavator.excavator_uuid_to_index_dict[truck.truck_excavator_bind[truck_id]]
-                    # 2. 正常调度
-                    elif not rule_ex:
-
-                        transport_value = self.group.group_park_to_excavator[group_id]
-
-                        excavator_exclude_modify = self.group.group_excavator_exclude_modify[truck_id]
-                        # excavator_material_bind_modify = self.group.group_excavator_material_bind_modify[truck_id]
-
-                        logger.info("transport_value")
-                        logger.info(transport_value)
-                        target = np.argmin(
-                            transport_value
-                            + excavator_exclude_modify)
-                            # + excavator_material_bind_modify)
-                        target = excavator.excavator_uuid_to_index_dict[self.group.group_excavator_index_to_uuid_dict[group_id][target]]
-                    # 3. 启用饱和度调度
-                    else:
-                        logger.info("饱和度调度")
-                        logger.info(truck.excavator_hold_truck_num)
-                        logger.info(np.mean(truck.payload))
-                        logger.info(self.group.update_excavator_hold_truck(truck.excavator_hold_truck_num))
-
-                        excavator_hold_truck = self.group.update_excavator_hold_truck(truck.excavator_hold_truck_num)[group_id]
-
-                        actual_flow_to_excavator = excavator_hold_truck * np.mean(truck.payload) / self.group.group_park_to_excavator[group_id].reshape(1, -1).flatten()
-
-                        # allow_flow_to_excavator = excavator.excavator_strength
-
-                        allow_flow_to_excavator = self.group.update_allow_flow_to_excavator()[group_id]
-
-                        target = np.argmin(actual_flow_to_excavator / allow_flow_to_excavator)
-
-                        target = excavator.excavator_uuid_to_index_dict[self.group.group_excavator_index_to_uuid_dict[group_id][target]]
-
-                    logger.info(excavator.excavator_uuid_to_index_dict)
-                    logger.info(self.group.group_excavator_uuid_to_index_dict)
-                    logger.info(f"目的地：{excavator.excavator_index_to_uuid_dict[target]}")
-                except Exception as es:
-                    logger.error("error07")
-                    logger.error(es)
-            if task in [0, 1, 2]:
-                try:
-                    logger.info("矿卡状态：矿卡空载")
-                    logger.info(f"涉及卸载设备：{list(dump.dump_uuid_to_index_dict.keys())}")
-                except Exception as es:
-                    logger.error(f"矿卡{truck_id}状态不匹配")
-                    logger.error(es)
-
-                try:
-                    assert np.array(actual_goto_dump_traffic_flow).shape == (
-                        dynamic_excavator_num,
-                        dynamic_dump_num,)
-                    assert np.array(opt_goto_dump_traffic_flow).shape == (
-                        dynamic_excavator_num,
-                        dynamic_dump_num,)
-                except Exception as es:
-                    logger.warning(es)
-                    actual_goto_dump_traffic_flow = np.array(
-                        actual_goto_dump_traffic_flow).reshape((dynamic_excavator_num, dynamic_dump_num))
-                    opt_goto_dump_traffic_flow = np.array(
-                        opt_goto_dump_traffic_flow).reshape((dynamic_excavator_num, dynamic_dump_num))
-
-                actual_goto_dump_traffic_flow = np.array(actual_goto_dump_traffic_flow)
-                opt_goto_dump_traffic_flow = np.array(opt_goto_dump_traffic_flow)
-
-                # 日志记录部分
-                try:
-                    logger.info("挖机id:")
-                    logger.info(excavator.excavator_uuid_to_index_dict)
-                    logger.info("卸点id:")
-                    logger.info(dump.dump_uuid_to_index_dict)
-                    logger.info(f"卸载点实际车流:")
-                    logger.info(actual_goto_dump_traffic_flow)
-                    logger.info(f"卸载点理想车流:")
-                    logger.info(opt_goto_dump_traffic_flow)
-
-                    logger.info("卸载点实际车流")
-                    logger.info(actual_goto_dump_traffic_flow[int(trip[1]), :])
-                    logger.info("卸载点理想车流")
-                    logger.info(opt_goto_dump_traffic_flow[int(trip[1]), :])
-                    logger.info("空载trip")
-                    logger.info(trip)
-                    logger.info("物料类型")
-                    if truck_id in truck.truck_material_bind:
-                        logger.info(truck.truck_material_bind[truck_id])
-                    logger.info("驶往卸点的运输成本")
-                    logger.info(self.cost_to_dump)
-                    logger.info("卸点物料修正")
-                    logger.info(truck.dump_material_bind_modify)
-
-                except Exception as es:
-                    logger.info("车流及修正因子")
-                    logger.info(es)
-
-                # 1. 绑定调度
-                if truck_id in truck.truck_dump_bind:
-                    bind_unload_area_id = truck.truck_dump_bind[truck_id]
-                    for key, value in dump.dump_index_to_unload_area_index_dict.items():
-                        if value == unload_area_uuid_to_index_dict[bind_unload_area_id]:
-                            target = key
-                            break
-                # 2. 正常调度
-                elif not rule_ex:
-                    try:
-                        excavator_index = int(trip[1])
-                        excavator_id = excavator.excavator_index_to_uuid_dict[excavator_index]
-
-                        print(self.group.group_excavator_uuid_to_index_dict[group_id])
-
-                        group_excavator_index = self.group.group_excavator_uuid_to_index_dict[group_id][excavator_id]
-                        # 2.1 正常调度
-                        if rule3 and rule4:
-                            try:
-                                # ga changed
-                            # transport_value = self.cost_to_dump[:, int(trip[1])]
-                            #     transport_value = self.group.group_walk_to_dump_cost[group_excavator_index]
-                                transport_value = self.group.group_walk_to_dump_cost[group_id][:, excavator_index]
-                            except Exception as es:
-                                logger.error("error10")
-                                logger.error(es)
-                                logger.error("group_id")
-                                logger.error(group_id)
-                                logger.error('self.group.group_walk_to_dump_cost')
-                                logger.error(self.group.group_walk_to_dump_cost)
-                                logger.error('self.group.group_walk_to_excavator_cost')
-                                logger.error(self.group.group_walk_to_excavator_cost)
-                                logger.error('self.group.group_excavator_uuid_to_index_dict[group_id][excavator_id]')
-                                logger.error(self.group.group_excavator_uuid_to_index_dict[group_id][excavator_id])
-                                logger.error("self.group.group_excavator_uuid_to_index_dict[group_id]")
-                                logger.error(self.group.group_excavator_uuid_to_index_dict[group_id])
-                        # 2.2 车流规划
-                        else:
-                            try:
-
-                                # 计算 group actual traffic flow
-                                group_actual_goto_dump_traffic_flow = self.group.group_actual_goto_dump_traffic_flow[group_id]
-
-                                # 计算 group actual traffic flow
-                                group_opt_goto_dump_traffic_flow = self.group.group_opt_goto_dump_traffic_flow[group_id]
-
-                                logger.info("驶往卸点分组车流")
-                                logger.info(group_actual_goto_dump_traffic_flow)
-                                logger.info(group_opt_goto_dump_traffic_flow)
-
-                                try:
-                                    transport_value = (group_actual_goto_dump_traffic_flow[group_excavator_index, :] + 0.001) \
-                                                    / (group_opt_goto_dump_traffic_flow[group_excavator_index, :] + 0.001)
-                                except Exception as es:
-                                    logger.error("error09")
-                                    logger.error(es)
-
-                            except Exception as es:
-                                logger.error("error11")
-                                logger.error(es)
-                            logger.info("transport_value")
-                            logger.info(transport_value)
-                            logger.info("dump_material_bind_modify")
-                            logger.info(truck.dump_material_bind_modify[truck_index])
-
-                        try:
-                            dump_material_bind_modify = self.group.group_dump_material_bind_modify[truck_id]
-                        except Exception as es:
-                            logger.error("error13")
-                            logger.error(es)
-                            logger.error("self.group.group_dump_material_bind_modify")
-                            logger.error(self.group.group_dump_material_bind_modify)
-
-                        try:
-                            target = np.argmin(transport_value.T + dump_material_bind_modify)
-                            target = dump.dump_uuid_to_index_dict[self.group.group_dump_index_to_uuid_dict[group_id][target]]
-                            logger.info("target")
-                            logger.info(target)
-                        except Exception as es:
-                            logger.error("error12")
-                            logger.error(es)
-                            logger.error("target")
-                            logger.error(target)
-                            logger.error("transport_value")
-                            logger.error(transport_value)
-                            logger.error(type(transport_value))
-                            logger.error(transport_value.T)
-                            logger.error("dump_material_bind_modify")
-                            logger.error(dump_material_bind_modify)
-
-                            logger.error("self.group.group_dump_index_to_uuid_dict")
-                            logger.error(self.group.group_dump_index_to_uuid_dict)
-                            logger.error("self.group.group_dump_index_to_uuid_dict[group_id]")
-                            logger.error(self.group.group_dump_index_to_uuid_dict[group_id])
-
-                        try:
-                            logger.info("车流比:")
-                            logger.info((actual_goto_dump_traffic_flow[int(trip[1]), :] + 0.001) \
-                                        / (opt_goto_dump_traffic_flow[int(trip[1]), :] + 0.001))
-                        except Exception as es:
-                            logger.error("error08")
-                            logger.error(es)
-
-                    except Exception as es:
-                        logger.error("error06")
-                        logger.error(es)
-                # 3. 饱和度调度
-                else:
-
-                    logger.info("和度调度")
-
-                    excavator_index = int(trip[1])
-
-                    transport_value = self.group.group_walk_to_dump_cost[group_id][:, excavator_index].reshape(1, -1)
-
-                    dump_hold_truck = self.group.update_dump_hold_truck(truck.dump_hold_truck_num)[group_id]
-
-                    actual_flow_to_dump = dump_hold_truck * truck.payload / \
-                                          self.group.group_walk_to_dump_cost[group_id][:, excavator_index].reshape(1,
-                                                                                                                   -1)
-                    allow_flow_to_dump = dump.dump_strength
-
-                    allow_flow_to_dump = self.group.update_allow_flow_to_dump()[group_id]
-
-                    target = np.argmax((1 - actual_flow_to_dump / allow_flow_to_dump) / transport_value)
-
-                    target = dump.dump_uuid_to_index_dict[
-                        self.group.group_dump_index_to_uuid_dict[group_id][target]]
-
-                logger.info(f"目的地：{dump.dump_index_to_uuid_dict[target]}")
-
-            elif task in [3, 4, 5]:
-
-                try:
-                    logger.info("矿卡状态：矿卡重载")
-                    logger.info(f"涉及挖机设备：{list(excavator.excavator_uuid_to_index_dict.keys())}")
-                except Exception as es:
-                    logger.error(f"矿卡{truck_id}状态不匹配")
-                    logger.error(es)
-
-                # 读取车流信息
-                try:
-                    assert np.array(actual_goto_excavator_traffic_flow).shape == (
-                        dynamic_dump_num,
-                        dynamic_excavator_num,)
-                    assert np.array(opt_goto_excavator_traffic_flow).shape == (
-                        dynamic_dump_num,
-                        dynamic_excavator_num,)
-
-                except Exception as es:
-                    logger.warning(es)
-                    actual_goto_excavator_traffic_flow = np.array(
-                        actual_goto_excavator_traffic_flow).reshape((dynamic_dump_num, dynamic_excavator_num))
-                    opt_goto_excavator_traffic_flow = np.array(
-                        opt_goto_excavator_traffic_flow).reshape((dynamic_dump_num, dynamic_excavator_num))
-
-
-                # 不知道为什么，偶尔变成了list
-                actual_goto_excavator_traffic_flow = np.array(actual_goto_excavator_traffic_flow)
-                opt_goto_excavator_traffic_flow = np.array(opt_goto_excavator_traffic_flow)
-
-                try:
-                    logger.info("挖机id:")
-                    logger.info(excavator.excavator_uuid_to_index_dict)
-                    logger.info("卸点id:")
-                    logger.info(dump.dump_uuid_to_index_dict)
-                    logger.info(f"挖机实际车流:")
-                    logger.info(actual_goto_excavator_traffic_flow)
-                    logger.info(f"挖机理想车流:")
-                    logger.info(opt_goto_excavator_traffic_flow)
-                    logger.info("重载trip")
-                    logger.info(trip)
-                    logger.info("物料类型")
-                    if truck_id in truck.truck_material_bind:
-                        logger.info(truck.truck_material_bind[truck_id])
-                    logger.info("驶往挖机的运输成本")
-                    logger.info(self.cost_to_excavator)
-                    logger.info("挖机物料修正")
-                    logger.info(truck.excavator_material_bind_modify)
-                    logger.info("挖机优先级修正")
-                    logger.info(excavator.excavator_priority_coefficient)
-                except Exception as es:
-                    logger.info("车流及修正因子")
-                    logger.info(es)
-
-                # 计算目的地
-                try:
-                    # 1. 绑定调度
-                    if truck_id in truck.truck_excavator_bind:
-                        target = excavator.excavator_uuid_to_index_dict[truck.truck_excavator_bind[truck_id]]
-                        logger.info("矿卡已绑定挖机")
-                    # 2. 正常调度
-                    elif not rule_ex:
-                        logger.info("cost_to_excavator")
-                        logger.info(self.cost_to_excavator)
-
-                        dump_index = int(trip[1])
-                        dump_id = dump.dump_uuid_to_index_dict[dump_index]
-                        # 2.1 正常调度
-                        if rule3 and rule4:
-                            # transport_value = self.cost_to_excavator[int(trip[1]), :]
-                            transport_value = self.group.group_walk_to_excavator_cost[group_id][dump_index, :]
-                        # 2.2 车流规划
-                        else:
-
-                            group_dump_index = self.group.group_dump_uuid_to_index_dict[group_id][dump_id]
-
-                            # 提取group actual traffic flow
-                            group_actual_goto_excavator_traffic_flow = self.group.group_actual_goto_excavator_traffic_flow[
-                                group_id]
-
-                            # 提取group actual traffic flow
-                            group_opt_goto_excavator_traffic_flow = self.group.group_opt_goto_excavator_traffic_flow[
-                                group_id]
-
-                            logger.info("驶往挖机分组车流")
-                            logger.info(group_actual_goto_excavator_traffic_flow)
-                            logger.info(group_opt_goto_excavator_traffic_flow)
-
-                            transport_value = (group_actual_goto_excavator_traffic_flow[group_dump_index, :] + 0.001) \
-                                              / (group_opt_goto_excavator_traffic_flow[group_dump_index, :] + 0.001)
-
-
-                            # transport_value = (self.actual_goto_excavator_traffic_flow[trip[1], :] + 0.001) \
-                            #                     / (self.opt_goto_excavator_traffic_flow[trip[1], :] + 0.001)
-                            logger.info("transport_value")
-                            logger.info(transport_value)
-
-                        # target = np.argmin(transport_value
-                        #     + truck.excavator_exclude_modify[truck_index]
-                        #     + truck.excavator_material_bind_modify[truck_index])
-
-                        excavator_exclude_modify = self.group.group_excavator_exclude_modify[truck_id]
-                        excavator_material_bind_modify = self.group.group_excavator_material_bind_modify[truck_id]
-
-                        logger.info(transport_value)
-                        target = np.argmin(
-                            transport_value.T
-                            + excavator_exclude_modify)
-                            # + excavator_material_bind_modify)
-
-                        target = excavator.excavator_uuid_to_index_dict[self.group.group_excavator_index_to_uuid_dict[group_id][target]]
-
-                    # 3. 饱和度调度
-                    else:
-
-                        logger.info("和度调度")
-
-                        dump_index = int(trip[1])
-
-                        transport_value = self.group.group_walk_to_excavator_cost[group_id][dump_index, :].reshape(1, -1)
-
-                        excavator_hold_truck = self.group.update_excavator_hold_truck(truck.excavator_hold_truck_num)[
-                            group_id]
-
-                        actual_flow_to_excavator = excavator_hold_truck * truck.payload / \
-                                                   self.group.group_walk_to_excavator_cost[group_id][dump_index, :].reshape(
-                                                       1, -1)
-
-                        # allow_flow_to_excavator = excavator.excavator_strength
-
-                        allow_flow_to_excavator = self.group.update_allow_flow_to_excavator()[group_id]
-
-                        target = np.argmax((1 - actual_flow_to_excavator / allow_flow_to_excavator) / transport_value)
-
-                        target = excavator.excavator_uuid_to_index_dict[
-                            self.group.group_excavator_index_to_uuid_dict[group_id][target]]
-                except Exception as es:
-                   logger.info("trip出错1")
-                   logger.info(es)
-
-
-                try:
-                   logger.info("车流比:")
-                   logger.info(
-                    (actual_goto_excavator_traffic_flow[trip[1], :] + 0.001)
-                    / (opt_goto_excavator_traffic_flow[trip[1], :] + 0.001))
-                except Exception as es:
-                    logger.info("trip出错2")
-                    logger.info(es)
-
-                logger.info(f"目的地：{excavator.excavator_index_to_uuid_dict[target]}")
-
-            logger.info("==========================================================")
-
-            print(target)
-        # except Exception as es:
-        #     logger.error("truck_schedule,error")
-        #     logger.error(es)
-            return target
-
-    def schedule_construct(self):
-
-        global truck
-        global excavator
-        global dump
-
-        self.reset()
-
-        print("self.cur_truck_ava_time", self.cur_truck_ava_time)
-
-        try:
-
-            # 读取所需信息
-            dynamic_truck_num = get_value("dynamic_truck_num")
-            truck_current_trip = truck.get_truck_current_trip()
-            truck_current_task = truck.get_truck_current_task()
-            payload = truck.get_payload()
-            unloading_time = dump.get_unloading_time()
-            loading_time = excavator.get_loading_time()
-
-            # 出入场时间
-            loading_task_time = excavator.get_loading_task_time()
-            unloading_task_time = dump.get_unloading_task_time()
-
-            walk_time_to_unload_area = walk_manage.get_walk_time_to_unload_area()
-            walk_time_to_load_area = walk_manage.get_walk_time_to_load_area()
-
-            # Seq初始化
-            Seq = [[truck_current_trip[i][1], -1] for i in range(dynamic_truck_num)]
-
-            # 根据矿卡最早可用时间顺序进行规划
-            print(self.cur_truck_ava_time)
-            print(truck.truck_priority)
-            temp = copy.deepcopy(self.cur_truck_ava_time) - truck.truck_priority
-
-            try:
-                # 没有启动的矿卡加上一个很大的值，降低其优先级
-                for i in range(dynamic_truck_num):
-                    task = truck_current_task[truck.truck_index_to_uuid_dict[i]]
-                    if task == -2:
-                        temp[i] = temp[i] + M
-            except Exception as es:
-                logger.error("矿卡排序启动异常")
-                logger.error(es)
-
-            index = np.argsort(temp.reshape(1, -1))
-            index = index.flatten()
-
-            # 对于在线矿卡已经赋予新的派车计划，更新其最早可用时间，及相关设备时间参数
-            for truck_index in index:
-                if len(Seq[truck_index]) > 0:
-
-                    # try:
-                # 获取矿卡id
-                    try:
-                        truck_id = truck.truck_index_to_uuid_dict[truck_index]
-                    except Exception as es:
-                        logger.error('error01')
-                        logger.error(es)
-
-                    # 判断矿卡是否禁用
-                    if truck_id in truck.update_truck_disable_list():
-                        continue
-                    try:
-                    # 获取矿卡当前任务
-                        task = truck_current_task[truck.truck_index_to_uuid_dict[truck_index]]
-                    except Exception as es:
-                        logger.error('error02')
-                        logger.error(es)
-
-                    try:
-                    # 矿卡结束当前派车计划后的目的地
-                        end_eq_index = truck_current_trip[truck_index][1]
-                    except Exception as es:
-                        logger.error('error03')
-                        logger.error(es)
-
-                    try:
-                    # 调用调度函数，得到最优目的地序号
-                        target_eq_index = self.truck_schedule(truck.truck_index_to_uuid_dict[truck_index])
-
-                    except Exception as es:
-                        logger.error('error04')
-                        logger.error(es)
-                        logger.error("truck_index,uuid")
-                        logger.error(truck_index)
-                        logger.error(truck.truck_index_to_uuid_dict[truck_index])
-
-                    # logger.("target_eq_index")
-                    # logger.error(target_eq_index)
-                    try:
-                    # 写入Seq序列
-                        Seq[truck_index][1] = target_eq_index
-                    except Exception as es:
-                        logger.error('error05')
-                        logger.error(es)
-                        logger.error("target_eq_index")
-                        logger.error(target_eq_index)
-                        logger.error("target_eq_index,type")
-                        logger.error(type(target_eq_index))
-                    # except Exception as es:
-                    #     logger.error("truck,task,end_eq_index,error")
-                    #     logger.error(es)
-                    try:
-                        group_id = self.group.dispatch_truck_group[truck_id]
-                    except Exception as es:
-                        logger.error("非动态调度矿卡")
-                        logger.error(es)
-
-                    # except Exception as es:
-                    #     # logger.error(f'矿卡 {truck_uuid_to_name_dict[self.truck_index_to_uuid_dict[truck_index]]} 派车计划计算异常')
-                    #     logger.error(f'矿卡派车计划计算异常')
-                    #     logger.error(es)
-
-                    try:
-
-                        if task in empty_task_set:
-                            target_area_index = dump.dump_index_to_unload_area_index_dict[target_eq_index]
-                            end_area_index = excavator.excavator_index_to_load_area_index_dict[end_eq_index]
-                            # 更新变量，预计产量更新
-                            self.sim_dump_real_mass[target_eq_index] = \
-                                (self.sim_dump_real_mass[target_eq_index] + payload[truck_index])
-                            # 预计卸载设备可用时间更新
-                            self.sim_dump_ava_time[target_eq_index] = (
-                                max(
-                                    self.sim_dump_ava_time[target_eq_index],
-                                    self.sim_truck_ava_time[truck_index] + \
-                                    walk_time_to_unload_area[target_area_index][end_area_index],)
-                                + unloading_task_time[target_eq_index]
-                            )
-                        elif task in heavy_task_set:
-                            target_area_index = (excavator.excavator_index_to_load_area_index_dict[target_eq_index])
-                            end_area_index = dump.dump_index_to_unload_area_index_dict[end_eq_index]
-                        else:
-                            pass
-                    except Exception as es:
-                        logger.error( f"矿卡 {truck_uuid_to_name_dict[truck.truck_index_to_uuid_dict[truck_index]]} 调度状态更新异常")
-                        logger.error(es)
-
-            for i in range(len(Seq)):
-                try:
-                    try:
-                        truck_id = truck.truck_index_to_uuid_dict[i]
-                        group_id = self.group.dispatch_truck_group[truck_id]
-
-                        record = {"truckId": truck.truck_index_to_uuid_dict[i]}
-                        task = truck.get_truck_current_task()[truck.truck_index_to_uuid_dict[i]]
-                    except Exception as es:
-                        logger.error("truck_id,group_id,record,task出错")
-                        logger.error(es)
-
-                    if task in empty_task_set:
-                        item = (
-                            session_mysql.query(Dispatch)
-                            .filter_by(dump_id=dump.dump_index_to_uuid_dict[Seq[i][1]],
-                                       exactor_id=excavator.excavator_index_to_uuid_dict[Seq[i][0]],
-                                       truck_id=truck_id,
-                                       group_id=group_id,
-                                       isauto=1, isdeleted=0,).first())
-                        record["exactorId"] = item.exactor_id
-                        record["dumpId"] = item.dump_id
-                        record["loadAreaId"] = item.load_area_id
-                        record["unloadAreaId"] = item.unload_area_id
-                        record["dispatchId"] = item.id
-                        record["isdeleted"] = False
-                        record["creator"] = item.creator
-                        record["createtime"] = item.createtime.strftime(
-                            "%b %d, %Y %I:%M:%S %p")
-                    elif task in heavy_task_set:
-                        item = (
-                            session_mysql.query(Dispatch)
-                            .filter_by(exactor_id=excavator.excavator_index_to_uuid_dict[Seq[i][1]],
-                                       dump_id=dump.dump_index_to_uuid_dict[Seq[i][0]],
-                                       truck_id=truck_id,
-                                       group_id=group_id,
-                                       isauto=1, isdeleted=0,).first())
-                        record["exactorId"] = excavator.excavator_index_to_uuid_dict[Seq[i][1]]
-                        record["dumpId"] = item.dump_id
-                        record["loadAreaId"] = item.load_area_id
-                        record["unloadAreaId"] = item.unload_area_id
-                        record["dispatchId"] = item.id
-                        record["isdeleted"] = False
-                        record["creator"] = item.creator
-                        record["createtime"] = item.createtime.strftime(
-                            "%b %d, %Y %I:%M:%S %p")
-                    elif task == -2:
-                        try:
-                            try:
-                                item = (
-                                    session_mysql.query(Dispatch)
-                                        .filter_by(exactor_id=excavator.excavator_index_to_uuid_dict[Seq[i][1]],
-                                                   # truck_id=truck_id,
-                                                   group_id=group_id,
-                                                   isauto=1, isdeleted=0, ).first())
-                            except Exception as es:
-                                logger.error("task-2,error01")
-                                logger.error(es)
-                                logger.error('excavator.excavator_index_to_uuid_dict[Seq[i][1]]')
-                                logger.error(excavator.excavator_index_to_uuid_dict)
-                                logger.error("seq[i]")
-                                logger.error(Seq[i])
-                                logger.error("group_id")
-                                logger.error(group_id)
-
-                            try:
-                                record["exactorId"] = item.exactor_id
-                                record["dumpId"] = item.dump_id
-                                record["loadAreaId"] = item.load_area_id
-                                record["unloadAreaId"] = item.unload_area_id
-                                record["dispatchId"] = item.id
-                                record["isdeleted"] = False
-                                record["creator"] = item.creator
-                                record["createtime"] = item.createtime.strftime(
-                                    "%b %d, %Y %I:%M:%S %p")
-
-                            except Exception as es:
-                                logger.error("task-2,error02")
-                                logger.error(es)
-
-                        except Exception as es :
-                            logger.error("task为-2时error")
-                            logger.error(es)
-                    else:
-                        pass
-
-                    redis5.set(truck.truck_index_to_uuid_dict[i], str(json.dumps(record)))
-
-                except Exception as es:
-                    logger.error("调度结果写入异常-redis写入异常")
-                    logger.error(f"调度结果:{Seq}")
-                    logger.error(es)
-
-            for i in range(dynamic_truck_num):
-                print("dispatch_setting:")
-                print(redis5.get(truck.truck_index_to_uuid_dict[i]))
-        except Exception as es:
-            logger.error("更新不及时-1")
-            logger.error(es)
-
-        return Seq
-
-# 下面三个函数保证程序定期执行，不用管他
 def process(dispatcher):
 
     try:
@@ -975,9 +32,6 @@ def process(dispatcher):
         if get_value("dynamic_truck_num") == 0:
             raise Exception("无动态派车可用矿卡")
             return
-        # para_process(dispatcher)
-        #
-        # state_process(dispatcher)
 
         # 清空数据库缓存
         session_mysql.commit()
@@ -986,16 +40,10 @@ def process(dispatcher):
         # 清空数据库缓存
         session_postgre.commit()
         session_postgre.flush()
-        #
-        # # 周期更新
-        # dispatcher.para_period_update()
 
         # 周期更新
         dispatcher.dispatcher_period_update()
 
-        # 参数重置
-        dispatcher.sim_para_reset()
-
         # try:
 
         # 调度计算
@@ -1011,25 +59,54 @@ def process(dispatcher):
         logger.error("最外层异常捕获")
         logger.error(es)
 
-period_para_update()
-scheduler = sched.scheduler(time.time, time.sleep)
-dispatcher = Dispatcher()
-
 
 def perform(inc, dispatcher):
+    """
+    控制程序循环执行
+    :param inc: (int) 循环周期, 单位, 秒
+    :param dispatcher:  (Dispatch Class) 矿卡调度类对象
+    :return: None
+    """
     scheduler.enter(inc, 0, perform, (inc, dispatcher))
     process(dispatcher)
 
 
 def main(inc, dispatcher):
+    """
+    程序循环入口函数
+    :param inc:  (int) 循环周期, 单位, 秒
+    :param dispatcher:  (Dispatch Class) 矿卡调度类对象
+    :return: None
+    """
     scheduler.enter(0, 0, perform, (inc, dispatcher))
     scheduler.run()
 
 
 if __name__ == "__main__":
+
+    # 初始化日志
+    set_log()
+    # 获取日志器
+    logger = get_logger("zxt.main")
+
+    # 全局参数更新
+    period_para_update()
+
+    # 实例化设备对象
+    dump = DumpInfo()
+    excavator = ExcavatorInfo()
+    truck = TruckInfo(dump, excavator)
+
+    # 实例化程序调度器
+    scheduler = sched.scheduler(time.time, time.sleep)
+
+    # 实例化调度预测器
+    pre_sch = PreSchedule(truck, excavator, dump)
+
+    # 实例化矿卡调度器
+    dispatcher = Dispatcher(dump, excavator, truck, pre_sch)
+
     logger.info(" ")
     logger.info("调度系统启动")
 
-    # dispatcher = Dispatcher()
-
     main(10, dispatcher)

settings.py

@@ -48,32 +48,38 @@ dump_target_mass = para_config["dump_target_mass"]
 excavator_target_mass = para_config["excavator_target_mass"]
 
 
-# 创建日志
-########################################################################################################################
-# 日志存储地址
-log_path = para_config["log_path"]
+def set_log():
+
+    # 创建日志
+    ########################################################################################################################
+    # 日志存储地址
+    log_path = para_config["log_path"]
 
-# 创建日志目录
+    # 创建日志目录
 
-if not os.path.exists(log_path):
+    if not os.path.exists(log_path):
         os.mkdir(log_path)
-# logging初始化工作
-logging.basicConfig()
+    # logging初始化工作
+    logging.basicConfig()
+
+    logger = logging.getLogger("zxt")
+    logger.setLevel(logging.INFO)
 
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.INFO)
 
+    # timefilehandler = logging.handlers.TimedRotatingFileHandler(log_path + "/dispatch.log", when='M', interval=1, backupCount=60)
+    filehandler = logging.handlers.RotatingFileHandler(log_path + "/dispatch.log", maxBytes=3*1024*1024, backupCount=10)
+    # filehandler = logging.handlers.RotatingFileHandler("./Logs/dispatch.log", maxBytes=3 * 1024 * 1024, backupCount=10)
+    # 设置后缀名称，跟strftime的格式一样
+    filehandler.suffix = "%Y-%m-%d_%H-%M.log"
 
-# timefilehandler = logging.handlers.TimedRotatingFileHandler(log_path + "/dispatch.log", when='M', interval=1, backupCount=60)
+    formatter = logging.Formatter("%(asctime)s - %(name)s: %(levelname)s %(filename)s %(message)s")
+    filehandler.setFormatter(formatter)
+    logger.addHandler(filehandler)
 
-filehandler = logging.handlers.RotatingFileHandler(log_path + "/dispatch.log", maxBytes=3*1024*1024, backupCount=10)
-# filehandler = logging.handlers.RotatingFileHandler("./Logs/dispatch.log", maxBytes=3 * 1024 * 1024, backupCount=10)
-# 设置后缀名称，跟strftime的格式一样
-filehandler.suffix = "%Y-%m-%d_%H-%M.log"
 
-formatter = logging.Formatter("%(asctime)s - %(name)s: %(levelname)s %(filename)s %(message)s")
-filehandler.setFormatter(formatter)
-logger.addHandler(filehandler)
+def get_logger(module_name):
+    logger = logging.getLogger(module_name)
+    return logger
 
 
 # 连接reids

static_data_process.py

@@ -11,6 +11,7 @@
 
 from settings import *
 
+logger = get_logger("zxt.static_data_process")
 
 def build_work_area_uuid_index_map():
     # load_area_id <-> load_area_index
@@ -20,6 +21,8 @@ def build_work_area_uuid_index_map():
     load_area_index_to_uuid_dict = {}
     unload_area_index_to_uuid_dict = {}
 
+    logger = logging.getLogger("build_work_area_uuid_index_map")
+
     unload_area_num = 0
     load_area_num = 0
 
@@ -90,7 +93,41 @@ def build_truck_uuid_name_map():
     return truck_uuid_to_name_dict, truck_name_to_uuid_dict
 
 
+def build_equipment_uuid_name_map():
+    # excavator_id <-> excavator_name
+    # dump_id <-> dump_name
+    excavator_uuid_to_name_dict = {}
+    dump_uuid_to_name_dict = {}
+
+    try:
+        for item in session_mysql.query(Equipment).filter_by(device_type=2).all():
+            truck_id = item.id
+            truck_name = item.equipment_id
+
+            excavator_uuid_to_name_dict[truck_id] = truck_name
+        if len(excavator_uuid_to_name_dict) < 1:
+            raise Exception("无挖机设备可用")
+    except Exception as es:
+        logger.warning(es)
+
+
+    try:
+        for item in session_mysql.query(Equipment).filter_by(device_type=3).all():
+            truck_id = item.id
+            truck_name = item.equipment_id
+
+            dump_uuid_to_name_dict[truck_id] = truck_name
+        if len(dump_uuid_to_name_dict) < 1 :
+            raise Exception("无卸载设备可用")
+    except Exception as es:
+        logger.warning(es)
+    return excavator_uuid_to_name_dict,dump_uuid_to_name_dict
+
+
 def update_deveices_map(unload_area_uuid_to_index_dict, load_area_uuid_to_index_dict):
+
+    logger = get_logger("zxt.update_deveices_map")
+
     excavator_uuid_to_index_dict = {}  # 用于将Excavator表中的area_id映射到index
     dump_uuid_to_index_dict = {}  # 用于将Dump表中的area_id映射到index
     excavator_index_to_uuid_dict = {}  # 用于将index映射到Excavator表中的area_id
@@ -288,8 +325,6 @@ def update_autodisp_dump():
     except Exception as es:
         logger.warning(es)
 
-    print("here1")
-    print(set(dynamic_dump_list))
     return set(dynamic_dump_list)
 
 
@@ -313,3 +348,305 @@ def update_park_area():
     for walk_time_park in session_postgre.query(WalkTimePark).all():
         park_area_list.append(walk_time_park.park_area_id)
     return park_area_list
+
+# def build_work_area_uuid_index_map():
+#     # load_area_id <-> load_area_index
+#     # unload_area_id <-> unload_area_index
+#     load_area_uuid_to_index_dict = {}
+#     unload_area_uuid_to_index_dict = {}
+#     load_area_index_to_uuid_dict = {}
+#     unload_area_index_to_uuid_dict = {}
+#
+#     unload_area_num = 0
+#     load_area_num = 0
+#
+#     try:
+#         for item in session_postgre.query(WalkTime).all():
+#             load_area = str(item.load_area_id)
+#             unload_area = str(item.unload_area_id)
+#             if load_area not in load_area_uuid_to_index_dict:
+#                 load_area_uuid_to_index_dict[load_area] = load_area_num
+#                 load_area_index_to_uuid_dict[load_area_num] = load_area
+#                 load_area_num = load_area_num + 1
+#             if unload_area not in unload_area_uuid_to_index_dict:
+#                 unload_area_uuid_to_index_dict[unload_area] = unload_area_num
+#                 unload_area_index_to_uuid_dict[unload_area_num] = unload_area
+#                 unload_area_num = unload_area_num + 1
+#         if unload_area_num < 1 or load_area_num < 1:
+#             raise Exception("无路网信息")
+#     except Exception as es:
+#         logger.error("路网读取")
+#         logger.error(es)
+#     return (
+#         load_area_uuid_to_index_dict,
+#         unload_area_uuid_to_index_dict,
+#         load_area_index_to_uuid_dict,
+#         unload_area_index_to_uuid_dict,
+#     )
+#
+#
+# def build_park_uuid_index_map():
+#     # park_id <-> park_index
+#     park_uuid_to_index_dict = {}
+#     park_index_to_uuid_dict = {}
+#
+#     park_num = 0
+#
+#     try:
+#         for item in session_postgre.query(WalkTimePark).all():
+#             park = str(item.park_area_id)
+#             if park not in park_uuid_to_index_dict:
+#                 park_uuid_to_index_dict[park] = park_num
+#                 park_index_to_uuid_dict[park_num] = park
+#                 park_num = park_num + 1
+#         if park_num < 1:
+#             raise Exception("无备停区路网信息")
+#     except Exception as es:
+#         logger.info("备停区路网读取")
+#         logger.error(es)
+#
+#     return park_uuid_to_index_dict, park_index_to_uuid_dict
+#
+#
+# def build_truck_uuid_name_map():
+#     # truck_id <-> truck_name
+#     truck_uuid_to_name_dict = {}
+#     truck_name_to_uuid_dict = {}
+#
+#     try:
+#         for item in session_mysql.query(Equipment).filter_by(device_type=1).all():
+#             truck_id = item.id
+#             truck_name = item.equipment_id
+#
+#             truck_name_to_uuid_dict[truck_name] = truck_id
+#             truck_uuid_to_name_dict[truck_id] = truck_name
+#         if len(truck_uuid_to_name_dict) < 1 or len(truck_name_to_uuid_dict) < 1:
+#             raise Exception("无矿卡设备可用-矿卡设备映射异常")
+#     except Exception as es:
+#         logger.warning(es)
+#     return truck_uuid_to_name_dict, truck_name_to_uuid_dict
+#
+#
+# def update_deveices_map(unload_area_uuid_to_index_dict, load_area_uuid_to_index_dict):
+#     excavator_uuid_to_index_dict = {}  # 用于将Excavator表中的area_id映射到index
+#     dump_uuid_to_index_dict = {}  # 用于将Dump表中的area_id映射到index
+#     excavator_index_to_uuid_dict = {}  # 用于将index映射到Excavator表中的area_id
+#     dump_index_to_uuid_dict = {}  # 用于将index映射到Dump表中的area_id
+#
+#     dump_uuid_to_unload_area_uuid_dict = {}
+#     excavator_uuid_to_load_area_uuid_dict = {}
+#     excavator_index_to_load_area_index_dict = {}
+#     dump_index_to_unload_area_index_dict = {}
+#
+#     try:
+#         excavator_num = 0
+#         dump_num = 0
+#         for item in (
+#             session_mysql.query(Dispatch).filter_by(isdeleted=0, isauto=1).all()
+#         ):
+#             # excavator_id <-> excavator_index
+#             # dump_id <-> dump_index
+#             # excavator_id <-> load_area_id
+#             # dump_id <-> unload_area_id
+#             # excavator_index <-> load_area_index
+#             # dump_index <-> unload_area_index
+#             excavator_id = item.exactor_id
+#             load_area_id = item.load_area_id
+#             unload_area_id = item.unload_area_id
+#             dump_id = item.dump_id
+#             if dump_id not in dump_uuid_to_unload_area_uuid_dict:
+#                 dump_uuid_to_index_dict[dump_id] = dump_num
+#                 dump_index_to_uuid_dict[dump_num] = dump_id
+#                 dump_uuid_to_unload_area_uuid_dict[dump_id] = unload_area_id
+#                 dump_index_to_unload_area_index_dict[
+#                     dump_uuid_to_index_dict[dump_id]
+#                 ] = unload_area_uuid_to_index_dict[unload_area_id]
+#                 dump_num = dump_num + 1
+#             if excavator_id not in excavator_uuid_to_index_dict:
+#                 excavator_uuid_to_index_dict[excavator_id] = excavator_num
+#                 excavator_index_to_uuid_dict[excavator_num] = excavator_id
+#                 excavator_uuid_to_load_area_uuid_dict[excavator_id] = load_area_id
+#                 excavator_index_to_load_area_index_dict[
+#                     excavator_uuid_to_index_dict[excavator_id]
+#                 ] = load_area_uuid_to_index_dict[load_area_id]
+#                 excavator_num = excavator_num + 1
+#         if excavator_num < 1 or dump_num < 1:
+#             raise Exception("无动态派车计划可用-动态派车挖机/卸载设备映射失败")
+#     except Exception as es:
+#         logger.error("卸载区信息异常")
+#         logger.error(es)
+#
+#     logger.info("excavator_index_to_load_area_index_dict")
+#     logger.info(excavator_index_to_load_area_index_dict)
+#
+#     logger.info("load_area_uuid_to_index_dict")
+#     logger.info(load_area_uuid_to_index_dict)
+#     logger.info("static_excavator_uuid_to_index_dict")
+#     logger.info(excavator_uuid_to_index_dict)
+#
+#     return {
+#         "excavator_uuid_to_index_dict": excavator_uuid_to_index_dict,
+#         "dump_uuid_to_index_dict": dump_uuid_to_index_dict,
+#         "excavator_index_to_uuid_dict": excavator_index_to_uuid_dict,
+#         "dump_index_to_uuid_dict": dump_index_to_uuid_dict,
+#         "dump_uuid_to_unload_area_uuid_dict": dump_uuid_to_unload_area_uuid_dict,
+#         "excavator_uuid_to_load_area_uuid_dict": excavator_uuid_to_load_area_uuid_dict,
+#         "excavator_index_to_load_area_index_dict": excavator_index_to_load_area_index_dict,
+#         "dump_index_to_unload_area_index_dict": dump_index_to_unload_area_index_dict,
+#     }
+#
+#
+# def update_truck_uuid_index_map(dynamic_truck_set):
+#     truck_uuid_to_index_dict = {}
+#     truck_index_to_uuid_dict = {}
+#
+#     # truck_id <-> truck_index
+#     truck_num = 0
+#     for truck_id in dynamic_truck_set:
+#         truck_uuid_to_index_dict[truck_id] = truck_num
+#         truck_index_to_uuid_dict[truck_num] = truck_id
+#         truck_num = truck_num + 1
+#
+#     logger.info("static_data_process.py-truck_uuid_to_index_dict")
+#     logger.info(truck_uuid_to_index_dict)
+#
+#     return {
+#         "truck_uuid_to_index_dict": truck_uuid_to_index_dict,
+#         "truck_index_to_uuid_dict": truck_index_to_uuid_dict,
+#     }
+#
+#
+# def update_total_truck():
+#     # 矿卡集合
+#     truck_list = []
+#
+#     try:
+#         query = np.array(
+#             session_mysql.query(Equipment)
+#             .filter_by(device_type=1, isdeleted=0)
+#             .all()
+#         )
+#
+#         # for item in query:
+#         #     json_value = json.loads(redis2.get(item.equipment_id))
+#         #     is_online = json_value.get('isOnline')
+#         #     if is_online:
+#         #         truck_list.append(item.id)
+#
+#         for item in query:
+#             truck_list.append(item.id)
+#
+#         if len(truck_list) < 1:
+#             raise Exception("无矿卡设备可用-矿卡集合读取异常")
+#     except Exception as es:
+#         logger.info("矿卡读取")
+#         logger.error(es)
+#
+#     return truck_list
+#
+#
+# def update_dynamic_truck():
+#     dynamic_truck_list = []
+#
+#     try:
+#         query = np.array(
+#             session_mysql.query(Dispatch).filter_by(isauto=1, isdeleted=0).all()
+#         )
+#
+#         for item in query:
+#             if item.truck_id is not None:
+#                 dynamic_truck_list.append(item.truck_id)
+#
+#     except Exception as es:
+#         logger.error(es)
+#         logger.error("动态调度矿卡读取异常")
+#
+#     return set(dynamic_truck_list)
+#
+#
+# def update_fixdisp_truck():
+#     # 固定派车矿卡集合
+#     fixed_truck_list = []
+#
+#     try:
+#         query = np.array(
+#             session_mysql.query(Dispatch).filter_by(isauto=0, isdeleted=0).all()
+#         )
+#
+#         for item in query:
+#             fixed_truck_list.append(item.truck_id)
+#
+#         rule5 = session_mysql.query(DispatchRule).filter_by(id=5).first().disabled
+#
+#         if not rule5:
+#             query = np.array(
+#                 session_mysql.query(Equipment)
+#                 .filter_by(device_type=1, isdeleted=0, disabled=1)
+#                 .all()
+#             )
+#
+#             for item in query:
+#                 fixed_truck_list.append(item.id)
+#
+#         if len(fixed_truck_list) < 1:
+#             raise Exception("无固定派车计划可用-固定派车矿卡集合读取异常")
+#     except Exception as es:
+#         logger.info("派车计划读取")
+#         logger.error(es)
+#     return set(fixed_truck_list)
+#
+#
+# def update_autodisp_excavator():
+#     # 用于动态派车的挖机集合
+#     dynamic_excavator_list = []
+#     try:
+#         for item in (
+#             session_mysql.query(Dispatch).filter_by(isdeleted=0, isauto=1).all()
+#         ):
+#             dynamic_excavator_list.append(item.exactor_id)
+#         if len(dynamic_excavator_list) < 1:
+#             raise Exception("无动态派车计划可用-动态派车挖机/卸载设备集合读取异常")
+#     except Exception as es:
+#         logger.warning(es)
+#
+#     return set(dynamic_excavator_list)
+#
+#
+# def update_autodisp_dump():
+#     # 用于动态调度的卸载点集合
+#     dynamic_dump_list = []
+#     try:
+#         for item in (
+#             session_mysql.query(Dispatch).filter_by(isdeleted=0, isauto=1).all()
+#         ):
+#             dynamic_dump_list.append(item.dump_id)
+#         if len(dynamic_dump_list) < 1:
+#             raise Exception("无动态派车计划可用-动态派车挖机/卸载设备集合读取异常")
+#     except Exception as es:
+#         logger.warning(es)
+#
+#     print("here1")
+#     print(set(dynamic_dump_list))
+#     return set(dynamic_dump_list)
+#
+#
+# def update_load_area():
+#     load_area_list = []
+#     for walk_time in session_postgre.query(WalkTime).all():
+#         load_area_list.append(walk_time.load_area_id)
+#
+#     return load_area_list
+#
+#
+# def update_unload_area():
+#     unload_area_list = []
+#     for walk_time in session_postgre.query(WalkTime).all():
+#         unload_area_list.append(walk_time.unload_area_id)
+#     return unload_area_list
+#
+#
+# def update_park_area():
+#     park_area_list = []
+#     for walk_time_park in session_postgre.query(WalkTimePark).all():
+#         park_area_list.append(walk_time_park.park_area_id)
+#     return park_area_list