二次调度逻辑优化

core/submit.py

@@ -28,6 +28,7 @@ class DispatchSubmission:
     Attribute:
 
     """
+
     def __init__(self, dump: DumpInfo, excavator: ExcavatorInfo, truck: TruckInfo, topo: Topo):
         self.logger = get_logger("zxt.submission")
         self.dump = dump
@@ -35,7 +36,8 @@ class DispatchSubmission:
         self.truck = truck
         self.topo = topo
 
-    def truck_dispatch_to_redis(self, truck_id: str, truck_info: CurrentTruck, dispatch_seq: List[int], group_mode: int):
+    def truck_dispatch_to_redis(self, truck_id: str, truck_info: CurrentTruck, dispatch_seq: List[int],
+                                group_mode: int):
         """
         将truck_id对应矿卡派车计划写入redis
         :param group_mode: (int)
@@ -123,15 +125,18 @@ class DispatchSubmission:
 
             # TODO: 判断了两次是否拥堵，需要改善
 
-            if self.topo is not None:
-
             # 车辆重载等待，且前方道路阻塞
-                if task == 3 and state == 2 and truck_id in self.truck.get_truck_locate_dict() and \
-                        self.truck.get_truck_locate_dict()[truck_id] in self.topo.cross_bf_lanes:
+            if self.topo is not None \
+                    and task == 3 \
+                    and state == 2 \
+                    and truck_id in self.truck.get_truck_lane_locate_dict() \
+                    and self.truck.get_truck_lane_locate_dict()[truck_id] in self.topo.cross_bf_lanes:
                 # try:
                 # if truck_id in self.truck.truck_is_temp and not self.truck.truck_is_temp[truck_id]:
                 self.logger.info("二次调度前往卸载区")
                 record["isTemp"] = True  # 避免反复修改
+                self.logger.info(f'redis 注入 {record}')
+                redis5.set(truck_id, str(json.dumps(record)))
                 POST(truck_id)
                 # else:
                 #     self.logger.info("车辆已完成二次调度-无需更改派车计划")
@@ -144,7 +149,6 @@ class DispatchSubmission:
             else:
                 self.logger.info("正常调度前往卸载区")
                 record["isTemp"] = False
-
                 self.logger.info(f'redis 注入 {record}')
                 redis5.set(truck_id, str(json.dumps(record)))
 
@@ -184,14 +188,19 @@ class DispatchSubmission:
             if self.topo is not None:
 
                 # 车辆重载等待，且前方道路阻塞
-                if task == 0 and state == 2 and truck_id in self.truck.get_truck_locate_dict() and \
-                        self.truck.get_truck_locate_dict()[truck_id] in self.topo.cross_bf_lanes:
+                if self.topo is not None \
+                        and task == 0 \
+                        and state == 2 \
+                        and truck_id in self.truck.get_truck_lane_locate_dict() \
+                        and self.truck.get_truck_lane_locate_dict()[truck_id] in self.topo.cross_bf_lanes:
                     # 车辆停车等待
                     # try:
                     # if truck_id in self.truck.truck_is_temp and not self.truck.truck_is_temp[truck_id]:
                     self.logger.info("二次调度前往装载区")
                     record["isTemp"] = True  # 避免反复修改
                     POST(truck_id)
+                    self.logger.info(f'redis 注入 {record}')
+                    redis5.set(truck_id, str(json.dumps(record)))
                     # else:
                     #     self.logger.info("车辆已完成二次调度-无需更改派车计划")
                     # except Exception as es:
@@ -203,7 +212,6 @@ class DispatchSubmission:
                 else:
                     self.logger.info("正常调度前往装载区")
                     record["isTemp"] = False
-
                     self.logger.info(f'redis 注入 {record}')
                     redis5.set(truck_id, str(json.dumps(record)))
 
@@ -245,19 +253,22 @@ class DispatchSubmission:
         self.logger.info("dispatch_plan_dict")
         self.logger.info(dispatch_plan_dict)
 
-
         for truck_id, dispatch_plan in dispatch_plan_dict.items():
             try:
-                self.logger.info(f'======================================= 调度车辆 =======================================')
+                if truck_id in group.truck_info_list:
+                    self.logger.info(
+                        f'======================================= 派车计划写入 =======================================')
                     self.truck_dispatch_to_redis(truck_id, group.truck_info_list[truck_id], dispatch_plan, group.group_mode)
-                self.logger.info("======================================== 完成写入 =======================================")
+                    self.logger.info(
+                        "======================================== 计划完成写入 =======================================")
+                else:
+                    raise Exception("车辆对象信息不存在 group.truck_info_list")
             except Exception as es:
-                self.logger.error("group_dispatch_to_redis_error")
+                # self.logger.error("group_dispatch_to_redis_error")
                 self.logger.error(es)
                 truck_direct2redis(truck_id)
 
 
-
 def redis_format(truck_id, group_id, dispatch_id, item):
     record = {"truckId": truck_id, "dispatchId": dispatch_id, "exactorId": item.exactor_id, "dumpId": item.dump_id,
               "loadAreaId": item.load_area_id, "unloadAreaId": item.unload_area_id, "groupId": item.group_id,

data/para_config.py

@@ -11,7 +11,9 @@ from settings import *
 from tables import *
 import numpy as np
 
-# 全局参数设定
+'''
+全局参数设定
+'''
 
 # 空载任务集合
 empty_task_set = [0, 1, 5]
@@ -27,69 +29,17 @@ M = 100000000
 
 logger = get_logger("zxt.para")
 
-# # 装载区、卸载区、备停区在调度算法运行器件默认不发生改变，提前计算部分参量
-# # (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()
-#
-# excavator_uuid_to_name_dict, dump_uuid_to_name_dict = build_equipment_uuid_name_map()
-#
-# # 矿卡集合
-# group_trucks = set(update_total_truck())
-#
-# # 固定派车矿卡集合
-# fixed_truck_set = set(update_fixdisp_truck())
-#
-# # 动态派车矿卡集合
-# # dynamic_truck_set = group_trucks.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:
+    """
+    设备映射类, 存储除工作区以外的映射关系, 其余设备类继承该类
+    """
     excavator_uuid_to_index_dict = {}
     dump_uuid_to_index_dict = {}
     excavator_index_to_uuid_dict = {}
@@ -103,50 +53,6 @@ class DeviceMap:
     truck_uuid_to_index_dict = {}
     truck_index_to_uuid_dict = {}
 
-    # def __init__(cls):
-    #     cls.excavator_uuid_to_index_dict = {}
-    #     cls.dump_uuid_to_index_dict = {}
-    #     cls.excavator_index_to_uuid_dict = {}
-    #     cls.dump_index_to_uuid_dict = {}
-    #
-    #     cls.dump_uuid_to_unload_area_uuid_dict = {}
-    #     cls.excavator_uuid_to_load_area_uuid_dict = {}
-    #     cls.excavator_index_to_load_area_index_dict = {}
-    #     cls.dump_index_to_unload_area_index_dict = {}
-    #
-    #     cls.truck_uuid_to_index_dict = {}
-    #     cls.truck_index_to_uuid_dict = {}
-
-    # def get_excavator_uuid_to_index_dict(cls):
-    #     return cls.excavator_uuid_to_index_dict
-    #
-    # def get_dump_uuid_to_index_dict(cls):
-    #     return cls.dump_uuid_to_index_dict
-    #
-    # def get_excavator_index_to_uuid_dict(cls):
-    #     return cls.excavator_index_to_uuid_dict
-    #
-    # def get_dump_index_to_uuid_dict(cls):
-    #     return cls.dump_index_to_uuid_dict
-    #
-    # def get_dump_uuid_to_unload_area_uuid_dict(cls):
-    #     return cls.dump_uuid_to_unload_area_uuid_dict
-    #
-    # def get_excavator_uuid_to_load_area_uuid_dict(cls):
-    #     return cls.excavator_uuid_to_load_area_uuid_dict
-    #
-    # def get_excavator_index_to_load_area_index_dict(cls):
-    #     return cls.excavator_index_to_load_area_index_dict
-    #
-    # def get_dump_index_to_unload_area_index_dict(cls):
-    #     return cls.dump_index_to_unload_area_index_dict
-    #
-    # def get_truck_uuid_to_index_dict(cls):
-    #     return cls.truck_uuid_to_index_dict
-    #
-    # def get_truck_index_to_uuid_dict(cls):
-    #     return cls.truck_index_to_uuid_dict
-
     @classmethod
     def reset(cls):
         cls.excavator_uuid_to_index_dict = {}
@@ -193,58 +99,19 @@ class DeviceMap:
             "dump_index_to_unload_area_index_dict"
         ]
 
-        truck_map_dict = update_truck_uuid_index_map(get_value("dynamic_truck_set"))
+        truck_map_dict = build_truck_uuid_index_map(get_value("dynamic_truck_set"))
 
         cls.truck_uuid_to_index_dict = truck_map_dict["truck_uuid_to_index_dict"]
 
         cls.truck_index_to_uuid_dict = truck_map_dict["truck_index_to_uuid_dict"]
 
-    # def period_map_para_load(cls):
-    #     # 装载关系映射
-    #     cls.excavator_uuid_to_index_dict = device_map.excavator_uuid_to_index_dict
-    #     cls.dump_uuid_to_index_dict = device_map.dump_uuid_to_index_dict
-    #     cls.excavator_index_to_uuid_dict = device_map.excavator_index_to_uuid_dict
-    #     cls.dump_index_to_uuid_dict = device_map.dump_index_to_uuid_dict
-    #
-    #     cls.dump_uuid_to_unload_area_uuid_dict = (
-    #         device_map.dump_uuid_to_unload_area_uuid_dict
-    #     )
-    #     cls.excavator_uuid_to_load_area_uuid_dict = (
-    #         device_map.excavator_uuid_to_load_area_uuid_dict
-    #     )
-    #     cls.excavator_index_to_load_area_index_dict = (
-    #         device_map.excavator_index_to_load_area_index_dict
-    #     )
-    #     cls.dump_index_to_unload_area_index_dict = (
-    #         device_map.dump_index_to_unload_area_index_dict
-    #     )
-    #
-    #     cls.truck_uuid_to_index_dict = device_map.truck_uuid_to_index_dict
-    #     cls.truck_index_to_uuid_dict = device_map.truck_index_to_uuid_dict
-
 
-# 路网信息类
+#
 class WalkManage(DeviceMap):
-    # def __init__(cls):
-    #     # # 工作区和设备不具备一一对应关系, 为方便就计算, 算法维护两套路网: 面向路网和面向设备
-    #
-    #     # 路网真实距离
-    #     cls.walk_time_to_excavator = np.full((dynamic_dump_num, dynamic_excavator_num), M, dtype=float)
-    #     cls.walk_time_to_dump = np.full((dynamic_dump_num, dynamic_excavator_num), M, dtype=float)
-    #     cls.walk_time_park_to_excavator = np.full((park_num, dynamic_excavator_num), M, dtype=float)
-    #     cls.walk_time_park_to_load_area = np.full((park_num, load_area_num), M, dtype=float)
-    #     cls.walk_time_to_load_area = np.full((unload_area_num, load_area_num), M, dtype=float)
-    #     cls.walk_time_to_unload_area = np.full((unload_area_num, load_area_num), M, dtype=float)
-    #
-    #     # 路网行驶时间
-    #     cls.distance_to_excavator = np.full((dynamic_dump_num, dynamic_excavator_num), M, dtype=float)
-    #     cls.distance_to_dump = np.full((dynamic_dump_num, dynamic_excavator_num), M, dtype=float)
-    #     cls.distance_park_to_excavator = np.full((park_num, dynamic_excavator_num), M, dtype=float)
-    #     cls.distance_park_to_load_area = np.full((park_num, load_area_num), M, dtype=float)
-    #     cls.distance_to_load_area = np.full((unload_area_num, load_area_num), M, dtype=float)
-    #     cls.distance_to_unload_area = np.full((unload_area_num, load_area_num), M, dtype=float)
-
-    # # 工作区和设备不具备一一对应关系, 为方便就计算, 算法维护两套路网: 面向路网和面向设备
+    """
+    路网信息类
+    """
+    # 工作区和设备不具备一一对应关系, 为方便就计算, 算法维护两套路网: 面向路网和面向设备
 
     # 路网真实距离
     walk_time_to_excavator = None
@@ -262,49 +129,9 @@ class WalkManage(DeviceMap):
     distance_to_load_area = None
     distance_to_unload_area = None
 
-    # def get_walk_time_to_load_area(cls):
-    #     return cls.walk_time_to_load_area
-    #
-    # def get_walk_time_to_unload_area(cls):
-    #     return cls.walk_time_to_unload_area
-    #
-    # def get_walk_time_to_excavator(cls):
-    #     return cls.walk_time_to_excavator
-    #
-    # def get_walk_time_to_dump(cls):
-    #     return cls.walk_time_to_dump
-    #
-    # def get_walk_time_park_to_load_area(cls):
-    #     return cls.walk_time_park_to_load_area
-    #
-    # def get_walk_time_park_to_excavator(cls):
-    #     return cls.walk_time_park_to_excavator
-    #
-    # def get_distance_to_load_area(cls):
-    #     return cls.distance_to_load_area
-    #
-    # def get_distance_to_unload_area(cls):
-    #     return cls.distance_to_unload_area
-    #
-    # def get_distance_to_excavator(cls):
-    #     return cls.distance_to_excavator
-    #
-    # def get_distance_to_dump(cls):
-    #     return cls.distance_to_dump
-    #
-    # def get_distance_park_to_load_area(cls):
-    #     return cls.distance_park_to_load_area
-    #
-    # def get_distance_park_to_excavator(cls):
-    #     return cls.distance_park_to_excavator
-
     @classmethod
     def reset(cls):
 
-        # dynamic_excavator_num
-        # dynamic_dump_num
-        # park_num
-
         # 路网真实距离
         cls.walk_time_to_excavator = np.full(
             (dynamic_dump_num, dynamic_excavator_num), M
@@ -450,7 +277,8 @@ def global_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()
+    excavator_uuid_to_name_dict = build_excavator_uuid_name_map()
+    dump_uuid_to_name_dict = build_dump_uuid_name_map()
 
     global_dict = {"park_num": park_num, "load_area_num": load_area_num, "unload_area_num": unload_area_num,
                    "truck_uuid_to_name_dict": truck_uuid_to_name_dict,

data/static_data_process.py

@@ -14,6 +14,11 @@ from tables import *
 
 logger = get_logger("zxt.static_data_process")
 
+'''
+area uuid index map building
+'''
+
+
 def build_work_area_uuid_index_map():
     # load_area_id <-> load_area_index
     # unload_area_id <-> unload_area_index
@@ -71,7 +76,7 @@ def build_park_uuid_index_map():
         if park_num < 1:
             raise Exception("无备停区路网信息")
     except Exception as es:
-        logger.info("备停区路网读取")
+        logger.error("备停区路网读取")
         logger.error(es)
         session_postgre.rollback()
         session_mysql.rollback()
@@ -79,6 +84,11 @@ def build_park_uuid_index_map():
     return park_uuid_to_index_dict, park_index_to_uuid_dict
 
 
+'''
+equipment uuid name map building
+'''
+
+
 def build_truck_uuid_name_map():
     # truck_id <-> truck_name
     truck_uuid_to_name_dict = {}
@@ -100,11 +110,9 @@ def build_truck_uuid_name_map():
     return truck_uuid_to_name_dict, truck_name_to_uuid_dict
 
 
-def build_equipment_uuid_name_map():
+def build_excavator_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():
@@ -118,8 +126,13 @@ def build_equipment_uuid_name_map():
         logger.warning(es)
         session_postgre.rollback()
         session_mysql.rollback()
+    return excavator_uuid_to_name_dict
 
 
+def build_dump_uuid_name_map():
+    # dump_id <-> dump_name
+    dump_uuid_to_name_dict = {}
+
     try:
         for item in session_mysql.query(Equipment).filter_by(device_type=3).all():
             truck_id = item.id
@@ -132,7 +145,7 @@ def build_equipment_uuid_name_map():
         logger.warning(es)
         session_postgre.rollback()
         session_mysql.rollback()
-    return excavator_uuid_to_name_dict, dump_uuid_to_name_dict
+    return dump_uuid_to_name_dict
 
 
 def update_deveices_map(unload_area_uuid_to_index_dict, load_area_uuid_to_index_dict):
@@ -210,7 +223,7 @@ def update_deveices_map(unload_area_uuid_to_index_dict, load_area_uuid_to_index_
     }
 
 
-def update_truck_uuid_index_map(dynamic_truck_set):
+def build_truck_uuid_index_map(dynamic_truck_set):
     truck_uuid_to_index_dict = {}
     truck_index_to_uuid_dict = {}
 
@@ -229,6 +242,7 @@ def update_truck_uuid_index_map(dynamic_truck_set):
         "truck_index_to_uuid_dict": truck_index_to_uuid_dict,
     }
 
+
 def update_total_truck():
     # 矿卡集合
     truck_list = []

equipment/truck.py

@@ -85,8 +85,8 @@ class TruckInfo(WalkManage):
         # 对象域
         self._dump = dump
         self._excavator = excavator
-        # 车辆位置信息
-        self.truck_locate_dict = {}
+        # 车辆车道位置信息
+        self.truck_lane_locate_dict = {}
         # 车辆临时调度
         self.truck_is_temp = {}
 
@@ -132,8 +132,8 @@ class TruckInfo(WalkManage):
     def get_excavator_hold_truck_num(self):
         return self.excavator_hold_truck_num
 
-    def get_truck_locate_dict(self):
-        return self.truck_locate_dict
+    def get_truck_lane_locate_dict(self):
+        return self.truck_lane_locate_dict
 
     ################################################ short term update ################################################
 
@@ -219,18 +219,20 @@ class TruckInfo(WalkManage):
                 key_value_dict = redis5.get(truck_name_to_uuid_dict[item])  # reids str可以自动转为bytes
 
                 if key_value_dict is None:
-                    raise CoreException(108, f'车辆{item}不存在于redis5')
-
+                    # raise CoreException(108, f'车辆{item}不存在于redis5')
+                    self.logger.warning(f'车辆{item}不存在于redis5')
+                    isTemp = True
+                else:
                     key_value_dict = json.loads(byte_to_str(key_value_dict))
 
-                if truck_name_to_uuid_dict[item] in self.dynamic_truck_set:
-                    try:
+                    if "isTemp" in key_value_dict:
                         isTemp = key_value_dict["isTemp"]
+                    else:
+                        isTemp = True
+                if truck_name_to_uuid_dict[item] in self.dynamic_truck_set:
                     self.truck_is_temp[truck_name_to_uuid_dict[item]] = bool(isTemp)
-                    except Exception as es:
-                        self.logger.error(item)
-                        self.logger.error(es)
-                        self.truck_is_temp[truck_name_to_uuid_dict[item]] = True
+                else:
+                    continue
 
                     # print(f'here3 {item} {bool(isTemp)}')
             except Exception as es:
@@ -525,15 +527,15 @@ class TruckInfo(WalkManage):
         print("self.excavator_hold_truck_num")
         print(self.excavator_hold_truck_num)
 
-    def update_trucks_locate(self):
+    def update_trucks_lane_locate(self):
         """
         get trucks locates.
-        :return: truck_locate_dict
+        :return: truck_lane_locate_dict
         """
 
         truck_uuid_to_name_dict = get_value("truck_uuid_to_name_dict")
 
-        self.truck_locate_dict = {}
+        self.truck_lane_locate_dict = {}
         for truck_id in self.dynamic_truck_set:
             try:
                 # item = item.decode(encoding='utf-8')
@@ -548,7 +550,7 @@ class TruckInfo(WalkManage):
                         and (str_to_byte('laneId') in key_set):
                     truck_locate = key_value_dict[str_to_byte('laneId')]
                     if eval(truck_locate) is not '':
-                        self.truck_locate_dict[truck_id] = eval(truck_locate)
+                        self.truck_lane_locate_dict[truck_id] = eval(truck_locate)
             except Exception as es:
                 self.logger.error(es)
                 self.logger.error(f'车辆 {truck_id} 位置信息丢失')
@@ -638,6 +640,9 @@ class TruckInfo(WalkManage):
                     item = session_mysql.query(Equipment).filter_by(id=excavator_id).first()
                     if item.bind_list is not None:
                         for truck_name in json.loads(item.bind_list):
+                            if truck_name not in truck_name_to_uuid_dict:
+                                self.logger.error(f'truck_name_to_uuid_dict 不存在 {truck_name}')
+                                continue
                             self.truck_excavator_bind[
                                 truck_name_to_uuid_dict[truck_name]
                             ] = excavator_id
@@ -953,4 +958,4 @@ class TruckInfo(WalkManage):
         self.update_truck_speed()
 
         # 矿卡位置更新
-        self.update_trucks_locate()
+        self.update_trucks_lane_locate()

graph/topo_graph.py

@@ -154,21 +154,21 @@ class Topo():
             if Entrancenode_for_dump not in self.unload_G_all_nodes:
                 self.unload_G_all_nodes.append(Entrancenode_for_dump)
                 self.unload_G_dump_nodes.append(Entrancenode_for_dump)
-
             try:
                 unload_saved_lane = []
-                for i in item[1]:  # for each lane in a to_unload route
-                    i_startpoint = str(session_postgre.query(Lane).filter_by(Id=i).first().StartNodeId)
-                    i_endpoint = str(session_postgre.query(Lane).filter_by(Id=i).first().EndNodeId)
+                for lane_id in item[1]:  # for each lane in a to_unload route
+                    lane_startpoint = str(session_postgre.query(Lane).filter_by(Id=lane_id).first().StartNodeId)
+                    lane_endpoint = str(session_postgre.query(Lane).filter_by(Id=lane_id).first().EndNodeId)
 
                     # add [start_point, end_point, length, lane_id] to unload_saved_lane
-                    unload_saved_lane.append([str(i_startpoint), str(i_endpoint),
-                                              float(session_postgre.query(Lane).filter_by(Id=i).first().Length), i])
-                    # son_lane_num = sum(1 for truck_id in session_postgre.query(Lane).filter_by(StartNodeId = i_endpoint).all())
-                    son_lane_num = len(session_postgre.query(Lane).filter_by(StartNodeId=i_endpoint).all())
+                    unload_saved_lane.append([str(lane_startpoint), str(lane_endpoint),
+                                              float(session_postgre.query(Lane).filter_by(Id=lane_id).first().Length),
+                                              lane_id])
+                    # son_lane_num = sum(1 for truck_id in session_postgre.query(Lane).filter_by(StartNodeId = lane_endpoint).all())
+                    son_lane_num = len(session_postgre.query(Lane).filter_by(StartNodeId=lane_endpoint).all())
 
                     # 可以添加的节点：分叉口或终点
-                    if son_lane_num > 1 or i_endpoint in self.unload_G_dump_nodes:
+                    if son_lane_num > 1 or lane_endpoint in self.unload_G_dump_nodes:
                         # print("item",item[0])
                         # print(unload_saved_lane)
                         # print("\n")
@@ -188,17 +188,17 @@ class Topo():
                         # if [unload_saved_lane[0][0], unload_saved_lane[-1][1]] not in self.unload_G_edges:
                         #     self.unload_G_edges.append([unload_saved_lane[0][0], unload_saved_lane[-1][1]])
                         unload_saved_lane = []
-                        if i_startpoint not in self.unload_G_all_nodes:
-                            self.unload_G_all_nodes.append(i_startpoint)
-                        if i_endpoint not in self.unload_G_all_nodes:
-                            self.unload_G_all_nodes.append(i_endpoint)
+                        if lane_startpoint not in self.unload_G_all_nodes:
+                            self.unload_G_all_nodes.append(lane_startpoint)
+                        if lane_endpoint not in self.unload_G_all_nodes:
+                            self.unload_G_all_nodes.append(lane_endpoint)
             except Exception as es:
                 self.logger.error(es)
                 self.logger.error("去卸载区拓扑图出错")
                 session_mysql.rollback()
                 session_postgre.rollback()
                 # path_node_for_trip.append(Exitnode_for_digging)  # add node for trip
-                # if i_endpoint in self.unload_G_dump_nodes:
+                # if lane_endpoint in self.unload_G_dump_nodes:
 
             # load_G
             Entrancenode_for_digging = str(
@@ -216,24 +216,26 @@ class Topo():
                 self.load_G_all_nodes.append(Entrancenode_for_digging)
                 self.load_G_digging_nodes.append(Entrancenode_for_digging)
 
-            self.load_G.add_node(Exitnode_for_dump, name='group_dumps', type=digging_name)
-            self.load_G.add_node(Entrancenode_for_digging, name='digging', type=dump_name)
+            self.load_G.add_node(Exitnode_for_dump, name='group_dumps', type=dump_name)
+            self.load_G.add_node(Entrancenode_for_digging, name='digging', type=digging_name)
 
             try:
                 load_saved_lane = []
 
-                for i in item[2]: # [[str(item.load_area_id), str(item.unload_area_id)], item.to_unload_lanes, item.to_load_lanes]
-                    load_i_startpoint = str(session_postgre.query(Lane).filter_by(Id=i).first().StartNodeId)
-                    load_i_endpoint = str(session_postgre.query(Lane).filter_by(Id=i).first().EndNodeId)
+                for lane_id in item[
+                    2]:  # [[str(item.load_area_id), str(item.unload_area_id)], item.to_unload_lanes, item.to_load_lanes]
+                    lane_startpoint = str(session_postgre.query(Lane).filter_by(Id=lane_id).first().StartNodeId)
+                    lane_endpoint = str(session_postgre.query(Lane).filter_by(Id=lane_id).first().EndNodeId)
 
-                    load_saved_lane.append([str(load_i_startpoint), str(load_i_endpoint),
-                                            float(session_postgre.query(Lane).filter_by(Id=i).first().Length), i])
-                    # son_lane_num = sum(1 for truck_id in session_postgre.query(Lane).filter_by(StartNodeId = load_i_endpoint).all())
-                    son_lane_num = len(session_postgre.query(Lane).filter_by(StartNodeId=load_i_endpoint).all())
+                    load_saved_lane.append([str(lane_startpoint), str(lane_endpoint),
+                                            float(session_postgre.query(Lane).filter_by(Id=lane_id).first().Length),
+                                            lane_id])
+                    # son_lane_num = sum(1 for truck_id in session_postgre.query(Lane).filter_by(StartNodeId = lane_endpoint).all())
+                    son_lane_num = len(session_postgre.query(Lane).filter_by(StartNodeId=lane_endpoint).all())
 
                     nodes = list(self.load_G.nodes)
                     # 可以添加的节点：分叉口或终点
-                    if son_lane_num > 1 or load_i_endpoint in self.load_G_digging_nodes or load_i_endpoint in nodes:
+                    if son_lane_num > 1 or lane_endpoint in self.load_G_digging_nodes or lane_endpoint in nodes:
                         # print("item",item[0])
                         # print(load_saved_lane)
                         # print("\n")
@@ -252,19 +254,19 @@ class Topo():
                         # if [load_saved_lane[0][0], load_saved_lane[-1][1]] not in self.load_G_edges:
                         #     self.load_G_edges.append([load_saved_lane[0][0], load_saved_lane[-1][1]])
                         load_saved_lane = []
-                        if load_i_startpoint not in self.load_G_all_nodes:
-                            self.load_G_all_nodes.append(load_i_startpoint)
-                        if load_i_endpoint not in self.load_G_all_nodes:
-                            self.load_G_all_nodes.append(load_i_endpoint)
+                        if lane_startpoint not in self.load_G_all_nodes:
+                            self.load_G_all_nodes.append(lane_startpoint)
+                        if lane_endpoint not in self.load_G_all_nodes:
+                            self.load_G_all_nodes.append(lane_endpoint)
             except Exception as es:
                 self.logger.error(es)
                 self.logger.error("去装载区拓扑图生成失败")
                 session_mysql.rollback()
                 session_postgre.rollback()
 
-
         print(self.load_G.nodes.data())
 
+        # park_to_load_G
 
 
         for k in park_trip:
@@ -354,10 +356,11 @@ class Topo():
                 distance, path = nx.single_source_dijkstra(self.unload_G, source=source_node, target=i,
                                                            weight="real_distance")
 
-                unload_area_id = session_postgre.query(DumpArea).filter_by(Id=unload_area_id).first(EntranceNodeId=i).first().Id
+                unload_area_id = session_postgre.query(DumpArea).filter_by(Id=unload_area_id).first(
+                    EntranceNodeId=i).first().Id
                 unload_area_lane_dict[str(unload_area_id)] = []
                 for j in range(len(path) - 1):
-                    unload_area_lane_dict[str(unload_area_id)] += self.load_G[path[j]][path[j+1]]['lane']
+                    unload_area_lane_dict[str(unload_area_id)] += self.load_G[path[j]][path[j + 1]]['lane']
 
                 path_length_map[distance] = path
                 # print(path)
@@ -402,7 +405,6 @@ class Topo():
                 data[u] = [v[0], v[0]]
             self.load_G[path[i]][path[i + 1]]['locked_distance'] = sum(i[-1] for i in list(data.values()))
 
-
     """
     return relative distance between node and lane (graph_type: 0=load, 1=unload)
     """
@@ -455,7 +457,6 @@ class Topo():
         if not len(target_list):
             self.logger.error("当前无可去装载区！")
 
-
         load_area_lane_dict = {}
 
         # print(target_list)
@@ -469,7 +470,7 @@ class Topo():
                 load_area_id = session_postgre.query(DiggingWorkArea).filter_by(EntranceNodeId=i).first().Id
                 load_area_lane_dict[str(load_area_id)] = []
                 for j in range(len(path) - 1):
-                    load_area_lane_dict[str(load_area_id)] += self.load_G[path[j]][path[j+1]]['lane']
+                    load_area_lane_dict[str(load_area_id)] += self.load_G[path[j]][path[j + 1]]['lane']
 
                 path_length_map[distance] = path
                 # print(path)
@@ -511,6 +512,6 @@ class Topo():
                 lanes = session_postgre.query(Lane).filter_by(EndNodeId=node_id).first()
                 if lanes is not None:
                     self.cross_bf_lanes.append(str(lanes.Id))
+
     def get_cross_nodes(self):
         return self.cross_nodes
-