Merge branch 'master' of github.com:Allvey/integrated-scheduling

path_plan/__init__.py

+#!E:\Pycharm Projects\Waytous
+# -*- coding: utf-8 -*-
+# @Time : 2021/8/3 10:51
+# @Author : Opfer
+# @Site :
+# @File : __init__.py.py    
+# @Software: PyCharm
\ No newline at end of file

path_plannner.py

-#!E:\Pycharm Projects\Waytous
-# -*- coding: utf-8 -*-
-# @Time : 2021/7/26 14:35
-# @Author : Opfer
-# @Site :
-# @File : path_plannner.py    
-# @Software: PyCharm
-
-import numpy
-from settings import *
-from static_data_process import *
-from settings import *
-
-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()
-
-park_uuid_to_index_dict, park_index_to_uuid_dict = build_park_uuid_index_map()
-
-load_area_num, unload_area_num = len(load_area_uuid_to_index_dict), len(unload_area_uuid_to_index_dict)
-
-truck_uuid_to_name_dict, truck_name_to_uuid_dict = build_truck_uuid_name_map()
-
-M = 1000000
-
-
-class PathPlanner:
-    def __init__(self):
-        # 路线行驶成本
-        self.rout_cost = np.array((unload_area_num, load_area_num))
-        # 路段集合
-        self.lane_set = {}
-        # 车辆长度(暂)
-        self.truck_length = 113
-        # 装载区数量
-        self.num_of_load_area = len(set(update_load_area()))
-        # 卸载区数量
-        self.num_of_unload_area = len(set(update_unload_area()))
-        # 备停区数量
-        self.num_of_park_area = len(set(update_park_area()))
-        # 路网信息
-        self.walk_time_to_load_area = np.full((self.num_of_unload_area, self.num_of_load_area), M)
-        self.walk_time_to_unload_area = np.full((self.num_of_unload_area, self.num_of_load_area), M)
-        # 路网信息（备停区）
-        self.walk_time_park = np.full((self.num_of_park_area, self.num_of_load_area), M)
-
-    def path_cost_generate(self, load_area_id, unload_area_id, is_park):
-
-        to_unload_blockage_cost = 0
-        to_load_blockage_cost = 0
-        to_unload_cost = 0
-        to_load_cost = 0
-
-        if is_park:
-            path = session_postgre.query(WalkTimePark).filter_by(park_area_id=unload_area_id,
-                                                                 load_area_id=load_area_id).first()
-
-            for lane_id in path.park_load_lanes:
-                to_load_blockage_cost = to_load_blockage_cost + self.lane_cost_generate(lane_id)
-
-            to_load_cost = to_load_blockage_cost + path.park_load_distance
-        else:
-            path = session_postgre.query(WalkTime).filter_by(load_area_id=load_area_id,
-                                                             unload_area_id=unload_area_id).first()
-
-            for lane_id in path.to_unload_lanes:
-                to_unload_blockage_cost = to_unload_blockage_cost + self.lane_cost_generate(lane_id)
-
-            for lane_id in path.to_load_lanes:
-                to_load_blockage_cost = to_load_blockage_cost + self.lane_cost_generate(lane_id)
-
-            print(to_unload_blockage_cost, to_load_blockage_cost)
-
-            to_unload_cost = to_unload_blockage_cost + path.to_unload_distance
-            to_load_cost = to_load_blockage_cost + path.to_load_distance
-
-        return to_unload_cost, to_load_cost
-
-    def lane_cost_generate(self, lane_id):
-
-        lane = session_postgre.query(Lane).filter_by(Id=lane_id).first()
-
-        # 道路长度
-        lane_length = lane.Length
-        # 车辆自由行驶时的速度
-        clear_speed = lane.MaxSpeed
-
-        # 1. 计算阻塞时车辆密度
-        truck_density = lane_length / self.truck_length
-        # 2. 读取实际车流速度(暂)
-        actual_speed = clear_speed
-        # 3. 计算路段阻塞程度
-        lane_blockage = (1 - actual_speed / clear_speed) * truck_density
-
-        return lane_blockage
-
-    def walk_cost(self):
-        for walk_time in session_postgre.query(WalkTime).all():
-            unload_area_index = unload_area_uuid_to_index_dict[str(walk_time.unload_area_id)]
-            load_area_index = load_area_uuid_to_index_dict[str(walk_time.load_area_id)]
-            self.walk_time_to_load_area[unload_area_index][load_area_index], \
-            self.walk_time_to_unload_area[unload_area_index][load_area_index] = \
-                self.path_cost_generate(walk_time.load_area_id, walk_time.unload_area_id, False)
-
-        for walk_time_park in session_postgre.query(WalkTimePark).all():
-            park_area_index = park_uuid_to_index_dict[str(walk_time_park.park_area_id)]
-            load_area_index = load_area_uuid_to_index_dict[str(walk_time_park.load_area_id)]
-            _, self.walk_time_park[park_area_index][load_area_index] = \
-                self.path_cost_generate(walk_time_park.load_area_id, walk_time_park.park_area_id, True)
-
-        print(self.walk_time_to_unload_area)
-        print(self.walk_time_to_load_area)
-        print(self.walk_time_park)
-
-    def update_truck_speed(self):
-        truck_speed_dict = {}
-        device_name_set = redis2.keys()
-        for item in device_name_set:
-            item = item.decode(encoding='utf-8')
-            json_value = json.loads(redis2.get(item))
-            device_type = json_value.get('type')
-            if device_type == 1:
-                truck_speed = json_value.get('speed')
-                truck_speed_dict[truck_name_to_uuid_dict[item]] = truck_speed
-
-        return truck_speed_dict
-
-
-planner = PathPlanner()
-
-planner.walk_cost()
-
-planner.update_truck_speed()

settings.py

@@ -28,9 +28,10 @@ logging.basicConfig()
 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("RDlogs/dispatch.log", maxBytes=3 * 1024 * 1024, backupCount=10)
+filehandler = logging.handlers.RotatingFileHandler("./RDlogs/dispatch.log", maxBytes=3 * 1024 * 1024, backupCount=10)
 # 设置后缀名称，跟strftime的格式一样
 filehandler.suffix = "%Y-%m-%d_%H-%M.log"
 

traffic_flow/__init__.py

+#!E:\Pycharm Projects\Waytous
+# -*- coding: utf-8 -*-
+# @Time : 2021/8/3 10:51
+# @Author : Opfer
+# @Site :
+# @File : __init__.py.py    
+# @Software: PyCharm
\ No newline at end of file

traffic_flow/traffic_flow_planner.py

@@ -19,12 +19,12 @@ from traffic_flow.traffic_flow_info import *
 # traffic_programme_para.grade_loading_array[excavator_index] = 100  # 挖机装载物料品位
 # traffic_programme_para.excavator_priority_coefficient[excavator_index] = 1  # 挖机优先级
 # traffic_programme_para.dump_strength[dump_index] = 200  # 卸载设备最大卸载能力，单位吨/小时
-# traffic_programme_para.grade_upper_dump_array[dump_index] = 100  # 卸点品位上限
-# traffic_programme_para.grade_lower_dump_array[dump_index] = 100  # 卸点品位下限
+# traffic_programme_para.grade_upper_dump_array[dump_index] = 100  # 卸载设备品位上限
+# traffic_programme_para.grade_lower_dump_array[dump_index] = 100  # 卸载设备品位下限
 # traffic_programme_para.dump_priority_coefficient[dump_index] = 1  # 卸载设备优先级
 
 
-# 从数据库中读取电铲和卸载点相关参数，并将线性规划所用参数保存在TrafficProgPara类中
+# 从数据库中读取挖机和卸载设备相关参数，并将线性规划所用参数保存在TrafficProgPara类中
 
 
 # 解决线性规划问题，生成每条道路的流量
@@ -33,13 +33,13 @@ def transportation_problem_slove(coefficient, w_ij, s_ij, b_excavator,
                                  max_unload_weigh_alg_flag, truck_total_num,
                                  goto_excavator_dis, goto_dump_dis, min_throughout,
                                  grade_lower_array=None, grade_upper_array=None):
-    row = len(coefficient)  # 代表电铲的个数,第i行代表第i台电铲
-    col = len(coefficient[0])  # 代表卸载点的个数,第j行代表第j个卸载点
+    row = len(coefficient)  # 代表挖机的个数,第i行代表第i台挖机
+    col = len(coefficient[0])  # 代表卸载设备的个数,第j行代表第j个卸载设备
 
     # prob = pulp.LpProblem('Transportation Problem', sense=pulp.LpMaximize)
-    # 卸载道路的流量,单位是吨/小时,i代表起点为第i个电铲,j代表终点为第j个卸载点
+    # 卸载道路的流量,单位是吨/小时,i代表起点为第i个挖机,j代表终点为第j个卸载设备
     var_x = [[pulp.LpVariable('x{0}{1}'.format(i, j), lowBound=0) for j in range(col)] for i in range(row)]
-    # 装载道路的流量,单位是吨/小时,i代表起点为第i个卸载点,j代表终点为第j个电铲
+    # 装载道路的流量,单位是吨/小时,i代表起点为第i个卸载设备,j代表终点为第j个挖机
     var_y = [[pulp.LpVariable('y{0}{1}'.format(i, j), lowBound=0) for j in range(row)] for i in range(col)]
 
     flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x]
@@ -70,16 +70,16 @@ def transportation_problem_slove(coefficient, w_ij, s_ij, b_excavator,
              pulp.lpSum(load_truck_totla_num_array) <= truck_total_num)
 
     # 最大工作强度约束
-    # 约束每个电铲的工作强度
+    # 约束每个挖机的工作强度
     for i in range(row):
         prob += (pulp.lpSum(var_x[i]) <= b_excavator[i])
-    # 约束每个卸载点的工作强度
+    # 约束每个卸载设备的工作强度
     for j in range(col):
         prob += (pulp.lpSum(var_y[j]) <= b_dump[j])
 
     '''
     # 车流基尔霍夫定理约束
-    # 进入电铲和从电铲出去的车辆个数需要相同
+    # 进入挖机和从挖机出去的车辆个数需要相同
     for i in range(row):
         prob += (pulp.lpSum(unload_truck_total_num_array[i]) == pulp.lpSum(load_truck_totla_num_array[:,i]))
     # 从装载点离开和进来的车辆个数需要相同
@@ -87,16 +87,16 @@ def transportation_problem_slove(coefficient, w_ij, s_ij, b_excavator,
         prob += (pulp.lpSum(load_truck_totla_num_array[j]) == pulp.lpSum(unload_truck_total_num_array[:,j]))
     '''
 
-    # 从装载点去往卸载点的流量之和要小于从卸载点到装载点的流量之和
+    # 从装载点去往卸载设备的流量之和要小于从卸载设备到装载点的流量之和
     for i in range(row):
         prob += (pulp.lpSum((np.array(var_x))[i]) <= pulp.lpSum((np.array(var_y))[:, i]))
 
-    # 从卸载点出发去往装载点的流量之和要小于从装载点到本卸载点的流量之和
+    # 从卸载设备出发去往装载点的流量之和要小于从装载点到本卸载设备的流量之和
     for j in range(col):
         prob += (pulp.lpSum((np.array(var_y))[j]) <= pulp.lpSum((np.array(var_x))[:, j]))
 
     # 矿石品位约束卸载
-    # 去往卸载点的流量使用矩阵乘法乘以每个电铲处矿石的品位，得到每个卸载点的矿石品位总和
+    # 去往卸载设备的流量使用矩阵乘法乘以每个挖机处矿石的品位，得到每个卸载设备的矿石品位总和
     grade_array = np.dot(grade_loading_array, var_x)
     for j in range(col):
         sum_traffic_unload = pulp.lpSum((np.array(var_x))[:, j])
@@ -147,7 +147,7 @@ def traffic_flow_plan():
 
     load_area_num = len(load_area_set)
 
-    print("装载区数量:", load_area_num, "卸载区数量:", unload_area_num, "挖机数量:", excavator_num, "卸点数量:", dump_num)
+    print("装载区数量:", load_area_num, "卸载区数量:", unload_area_num, "挖机数量:", excavator_num, "卸载设备数量:", dump_num)
 
     # 初始化参量
     traffic_programme_para = Traffic_para_init(load_area_num, unload_area_num, excavator_num, dump_num)

wato_dispatch.py

@@ -128,7 +128,7 @@ park_index_to_uuid_dict = {}
 
 park_num = 0
 
-for item in session_postgre.query(WalkTimePort).all():
+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