BUG修复12-5

path_plan/path_plannner.py

@@ -265,13 +265,16 @@ class LaneInfo:
                 # json_value = json.loads(redis2.get(item))
                 key_value_dict = redis2.hgetall(item)
                 device_type = key_value_dict[str_to_byte('type')]
-                if device_type == 1 and str_to_byte('speed') in key_value_dict.keys():
-                    truck_speed = key_value_dict[str_to_byte('speed')]
+                if device_type == str_to_byte("1") and str_to_byte('speed') in key_value_dict.keys():
+                    truck_speed = float(key_value_dict[str_to_byte('speed')])
                     truck_speed_dict[truck_name_to_uuid_dict[item]] = truck_speed
         except Exception as es:
             logger.error(f'矿卡{item}实时速度读取异常')
             logger.error(es)
 
+        print("truck_speed_dict")
+        print(truck_speed_dict)
+
         return truck_speed_dict
 
     def update_truck_loacate(self):
@@ -286,13 +289,16 @@ 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 == 1 and str_to_byte('online') in key_set and str_to_byte('laneId') in key_set:
+                if device_type == str_to_byte("1") and str_to_byte('online') in key_set 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]] = truck_locate
+                    truck_locate_dict[truck_name_to_uuid_dict[item]] = eval(truck_locate)
         except Exception as es:
             logger.error(f'矿卡{item}所在路段信息读取异常')
             logger.error(es)
 
+        print("truck_locate_dict")
+        print(truck_locate_dict)
+
         return truck_locate_dict
 
     def lane_speed_generate(self):
@@ -335,15 +341,18 @@ class LaneInfo:
         tmp_lane_set = []
 
         try:
-
             # 初始化
             for lane_id in lane_set:
                 self.lane_speed_dict[str(lane_id)] = 0
                 lane_trucks_dict[str(lane_id)] = 0
 
             # 对于各路段信息
+            print("truck_locate_dict")
+            print(truck_locate_dict.keys())
             for truck in truck_locate_dict.keys():
                 lane_id = truck_locate_dict[truck]
+                logger.info("lane_speed_generate-lane_id")
+                logger.info(lane_id)
                 if lane_id in lane_set:
                     self.lane_speed_dict[truck_locate_dict[truck]] = self.lane_speed_dict[truck_locate_dict[truck]] + \
                                                                 truck_speed_dict[truck]
@@ -353,9 +362,8 @@ class LaneInfo:
                     tmp_lane_set.append(lane_id)
 
             # 存在矿卡的路段
-            # print("存在矿卡的路段:")
-            # print(tmp_lane_set)
-
+            print("存在矿卡的路段:")
+            print(tmp_lane_set)
             logger.info("存在矿卡的路段:")
             logger.info(tmp_lane_set)
 

realtime_dispatch.py

@@ -329,10 +329,11 @@ class Dispatcher(WalkManage):
                     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]
@@ -347,6 +348,7 @@ class Dispatcher(WalkManage):
                             + 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:
                         actual_flow_to_excavator = truck.excavator_hold_truck_num * truck.payload / self.group.group_park_to_excavator[group_id].reshape(1, -1)
 
@@ -414,13 +416,14 @@ class Dispatcher(WalkManage):
                     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])
@@ -429,7 +432,7 @@ class Dispatcher(WalkManage):
                         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
@@ -449,6 +452,7 @@ class Dispatcher(WalkManage):
                                 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:
 
@@ -518,15 +522,18 @@ class Dispatcher(WalkManage):
                     except Exception as es:
                         logger.error("error06")
                         logger.error(es)
+                # 3. 饱和度调度
                 else:
                     excavator_index = int(trip[1])
 
+                    transport_value = self.group.group_walk_to_dump_cost[group_id][:, excavator_index].reshape(1, -1)
+
                     actual_flow_to_dump = truck.dump_hold_truck_num * truck.payload / \
                                           self.group.group_walk_to_dump_cost[group_id][:, excavator_index].reshape(1,
                                                                                                                    -1)
                     allow_flow_to_dump = dump.dump_strength
 
-                    target = np.argmin(actual_flow_to_dump / allow_flow_to_dump)
+                    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]]
@@ -589,19 +596,22 @@ class Dispatcher(WalkManage):
 
                 # 计算目的地
                 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]
@@ -641,16 +651,20 @@ class Dispatcher(WalkManage):
                             # + excavator_material_bind_modify)
 
                         target = excavator.excavator_uuid_to_index_dict[self.group.group_excavator_index_to_uuid_dict[group_id][target]]
+
+                    # 3. 饱和度调度
                     else:
                         dump_index = int(trip[1])
 
+                        transport_value = self.group.group_walk_to_excavator_cost[group_id][dump_index, :].reshape(1, -1)
+
                         actual_flow_to_excavator = truck.excavator_hold_truck_num * truck.payload / \
                                                    self.group.group_walk_to_excavator_cost[group_id][dump_index, :].reshape(
                                                        1, -1)
 
                         allow_flow_to_excavator = excavator.excavator_strength
 
-                        target = np.argmin(actual_flow_to_excavator / allow_flow_to_excavator)
+                        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]]

settings.py

@@ -55,8 +55,8 @@ log_path = para_config["log_path"]
 
 # 创建日志目录
 
-if not os.path.exists(log_path):
-    os.mkdir(log_path)
+# if not os.path.exists(log_path):
+#     os.mkdir(log_path)
 # logging初始化工作
 logging.basicConfig()
 
@@ -65,8 +65,8 @@ 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)
+# 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"
 

traffic_flow/traffic_flow_info.py

@@ -82,12 +82,6 @@ class Traffic_flow(WalkManage):
         logger.info("dynamic_truck_num")
         logger.info(dynamic_truck_num)
 
-        print("truck.truck_index_to_uuid_dict")
-        print(self.truck.truck_index_to_uuid_dict)
-
-        print("truck_current_task")
-        print(truck_current_task)
-
         for i in range(dynamic_truck_num):
             task = truck_current_task[self.truck.truck_index_to_uuid_dict[i]]
             end_area_index = truck_current_trip[i][1]
@@ -193,7 +187,7 @@ class Traffic_para(WalkManage):
             logger.warning("矿卡速度设置为默认值")
             logger.warning(es)
 
-        self.min_throughout = 1000  # 最小产量约束
+        self.min_throughout = np.full((1, num_of_dump), 100)  # 最小产量约束
         self.truck_total_num = 0
 
         self.excavator_strength = np.zeros(num_of_excavator)  # 用于保存电铲的工作强度,单位是t/h
@@ -306,13 +300,13 @@ class Traffic_para(WalkManage):
 
         try:
             # 车流规划部分矩阵格式与其余两个模块不同
-            cost_to_dump = self.path_planner.cost_to_dump
-            cost_to_excavator = self.path_planner.cost_to_excavator
+            self.cost_to_dump = self.path_planner.cost_to_dump
+            self.cost_to_excavator = self.path_planner.cost_to_excavator
 
             logger.info("cost_to_dump")
-            logger.info(cost_to_dump)
+            logger.info(self.cost_to_dump)
             logger.info("cost_to_excavator")
-            logger.info(cost_to_excavator)
+            logger.info(self.cost_to_excavator)
             logger.info("self.goto_excavator_factor")
             logger.info(self.goto_excavator_factor)
             logger.info("self.goto_dump_factor")
@@ -323,13 +317,13 @@ class Traffic_para(WalkManage):
             logger.info(get_value("dynamic_excavator_num"))
             # ga
             # 路网信息读取
-            for dump_index in range(get_value("dynamic_dump_num")-1):
-                for excavator_index in range(get_value("dynamic_excavator_num")-1):
+            for dump_index in range(get_value("dynamic_dump_num")):
+                for excavator_index in range(get_value("dynamic_excavator_num")):
                     self.goto_excavator_factor[dump_index][excavator_index] = \
-                        (cost_to_excavator[dump_index][excavator_index] / (empty_speed * 1000)) / self.payload
+                        (self.cost_to_excavator[dump_index][excavator_index] / (empty_speed * 1000)) / self.payload
 
                     self.goto_dump_factor[excavator_index][dump_index] = \
-                        (cost_to_dump[excavator_index][dump_index] / (heavy_speed * 1000)) / self.payload
+                        (self.cost_to_dump[dump_index][excavator_index] / (heavy_speed * 1000)) / self.payload
 
             # logger.info("self.goto_dump_factor")
             # logger.info(self.goto_dump_factor)

traffic_flow/traffic_flow_planner.py

@@ -37,7 +37,10 @@ def transportation_problem_slove(coefficient_goto_dump, coefficient_goto_excavat
     if max_unload_weigh_alg_flag == True:
         prob = pulp.LpProblem('Transportation Problem', sense=pulp.LpMaximize)
         # 得到目标函数，目标函数是使得系统的运输量最大
-        prob += (pulp.lpDot(flatten(var_x), coefficient_goto_dump.flatten()))
+        # prob += (pulp.lpDot(flatten(var_x), coefficient_goto_dump.flatten()))
+
+        prob += (pulp.lpDot(flatten(var_x), coefficient_goto_dump.flatten()) + pulp.lpDot(flatten(var_y),
+                                                                                          coefficient_goto_excavator.flatten()))
     else:
         prob = pulp.LpProblem('Transportation Problem', sense=pulp.LpMinimize)
         goto_excavator_cost = var_y * walk_time_to_excavator
@@ -47,8 +50,8 @@ def transportation_problem_slove(coefficient_goto_dump, coefficient_goto_excavat
     # 定义约束条件
     # 最小产量约束，仅在最小化成本模式下成立
     if max_unload_weigh_alg_flag == False:
-        for i in range(col):
-            prob += pulp.lpSum(var_y[i]) >= min_throughout[i]
+        for j in range(col):
+            prob += pulp.lpSum(var_y[j]) >= min_throughout[j]
 
     logger.info("road_factor")
     logger.info(w_ij)
@@ -60,8 +63,12 @@ def transportation_problem_slove(coefficient_goto_dump, coefficient_goto_excavat
     # 通过矩阵按元素相乘得到每条装载道路上的车辆个数
     load_truck_totla_num_array = s_ij * var_y
     # 装载的矿卡数和卸载的矿卡数需要小于矿卡总数
-    prob += (pulp.lpSum(unload_truck_total_num_array) +
-             pulp.lpSum(load_truck_totla_num_array) <= truck_total_num)
+    # prob += (pulp.lpSum(unload_truck_total_num_array) +
+    #          pulp.lpSum(load_truck_totla_num_array) <= truck_total_num)
+
+    prob += (pulp.lpSum(unload_truck_total_num_array) <= truck_total_num)
+
+    prob += (pulp.lpSum(load_truck_totla_num_array) <= truck_total_num)
 
     # 约束一:最大工作强度约束
     # 约束每个挖机的工作强度
@@ -111,12 +118,12 @@ def transportation_problem_slove(coefficient_goto_dump, coefficient_goto_excavat
     for i in range(row):
         print("excavator_hold_truck_num")
         print(excavator_hold_truck_num, i)
-        prob += (pulp.lpSum((np.array(var_x))[i]) <= excavator_hold_truck_num[i] * 220 + 0.001)
+        prob += (pulp.lpSum((np.array(var_x))[i]) <= excavator_hold_truck_num[i] * 10000 + 0.001)
 
     for j in range(col):
         print(dump_hold_truck_num)
         print(dump_hold_truck_num, j)
-        prob += (pulp.lpSum((np.array(var_y))[j]) <= dump_hold_truck_num[j] * 220 + 0.001)
+        prob += (pulp.lpSum((np.array(var_y))[j]) <= dump_hold_truck_num[j] * 10000 + 0.001)
 
 
     # 约束五:非负约束
@@ -165,8 +172,6 @@ def traffic_flow_plan(truck):
 
     dump_num = get_value("dynamic_dump_num")
 
-    print("here5")
-    print(dump_num)
 
     excavator_num = get_value("dynamic_excavator_num")
 
@@ -188,8 +193,8 @@ def traffic_flow_plan(truck):
 
     coefficient_goto_dump = traffic_programme_para.priority_coefficient_goto_dump
     coefficient_goto_excavator = traffic_programme_para.priority_coefficient_goto_excavator
-    w_ij = traffic_programme_para.goto_dump_factor
-    s_ij = traffic_programme_para.goto_excavator_factor
+    w_ij = traffic_programme_para.goto_dump_factor * 100
+    s_ij = traffic_programme_para.goto_excavator_factor * 100
     b_excavator = traffic_programme_para.excavator_strength
     b_dump = traffic_programme_para.dump_strength
     grade_loading_array = traffic_programme_para.grade_loading_array
@@ -199,17 +204,18 @@ def traffic_flow_plan(truck):
     walk_time_to_excavator = traffic_programme_para.walk_time_to_excavator
     walk_time_to_dump = traffic_programme_para.walk_time_to_dump
     truck_total_num = traffic_programme_para.truck_total_num
-    print("here1212")
-    print(traffic_programme_para.dump_hold_truck_num)
-    print(traffic_programme_para.excavator_hold_truck_num)
     dump_hold_truck_num = traffic_programme_para.dump_hold_truck_num
     excavator_hold_truck_num = traffic_programme_para.excavator_hold_truck_num
 
-    print(w_ij, s_ij, b_excavator, b_dump)
+    cost_to_excavator = traffic_programme_para.cost_to_excavator
+    cost_to_dump = traffic_programme_para.cost_to_dump
+
+    logger.info("车流规划参数")
+    logger.info(" ")
 
     res = transportation_problem_slove(coefficient_goto_dump, coefficient_goto_excavator, w_ij, s_ij, b_excavator, b_dump,
                                        grade_loading_array, max_unload_weigh_alg_flag, truck_total_num,
-                                       walk_time_to_excavator, walk_time_to_dump, min_throughout,
+                                       cost_to_excavator, cost_to_dump, min_throughout,
                                        grade_upper_dump_array, grade_lower_dump_array,
                                        dump_hold_truck_num, excavator_hold_truck_num)