Skip to content

I
integrated-scheduling
Commit 31e38a6a authored by Allvey's avatar Allvey
Browse files
Options

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

# Conflicts: # realtime_dispatch.py # settings.py # static_data_process.py # tables.py # traffic_flow_planner.py
parent fdff645b
Hide whitespace changes
Inline Side-by-side
Showing with 363 additions and 194 deletions
RDlogs/dispatch.log
View file @ 31e38a6a
This source diff could not be displayed because it is too large. You can view the blob instead.
path_plan/__init__.py 0 → 100644
View file @ 31e38a6a
#!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_plan/path_plannner.py 0 → 100644
View file @ 31e38a6a
#!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)
# 路段类
self.lane = LaneInfo()
self.lane.lane_speed_generate()
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
# 阻塞成本权重
alpha = 500
# 距离成本权重
beta = 1
try:
# 备停区处理
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 + beta * self.lane_cost_generate(lane_id)
# 道路总成本=道路距离成本+道路阻塞成本
to_load_cost = alpha * to_load_blockage_cost + beta * 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)
to_unload_cost = alpha * to_unload_blockage_cost + beta * path.to_unload_distance
to_load_cost = alpha * to_load_blockage_cost + beta * path.to_load_distance
except Exception as es:
logger.error(f'道路{load_area_id-unload_area_id}行驶成本计算异常')
logger.error(es)
return to_unload_cost, to_load_cost
def lane_cost_generate(self, lane_id):
try:
# 读取路段记录
lane_rec = session_postgre.query(Lane).filter_by(Id=lane_id).first()
# 道路长度
lane_length = lane_rec.Length
# 车辆自由行驶时的速度
clear_speed = lane_rec.MaxSpeed
# 1. 计算阻塞时车辆密度=路段长度/车辆长度
truck_density = lane_length / self.truck_length
# 2. 读取实际车流速度
actual_speed = self.lane.lane_speed_dict[lane_id]
# 3. 计算路段阻塞程度=(1-实际路段速度)/路段最高速度
lane_blockage = (1 - actual_speed / clear_speed) * truck_density
except Exception as es:
logger.error('路段拥堵成本计算异常')
logger.error(es)
return lane_blockage
def walk_cost(self):
try:
# 读取路网距离信息
walk_time_load_distance = np.full((self.num_of_unload_area, self.num_of_load_area), M)
walk_time_unload_distance = np.full((self.num_of_unload_area, self.num_of_load_area), M)
# 读取路网成本
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)
walk_time_unload_distance[unload_area_index][load_area_index] = walk_time.to_load_distance
walk_time_load_distance[unload_area_index][load_area_index] = walk_time.to_unload_distance
# 读取备停区路网成本
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)
except Exception as es:
logger.error('路网信息计成本计算异常')
logger.error(es)
print("真实路网距离：装载-卸载")
print(self.walk_time_to_load_area)
print(self.walk_time_to_unload_area)
print("实际路网距离(阻塞)：装载-卸载")
print(walk_time_load_distance)
print(walk_time_unload_distance)
class LaneInfo:
def __init__(self):
self.lane_speed_dict = {}
def update_truck_speed(self):
# 读取矿卡实时速度信息
try:
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
except Exception as es:
logger.error(f'矿卡{item}实时速度读取异常')
logger.error(es)
return truck_speed_dict
def update_truck_loacate(self):
# 读取矿卡所在路段信息
try:
truck_locate_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_locate = json_value.get('laneId')
truck_locate_dict[truck_name_to_uuid_dict[item]] = truck_locate
except Exception as es:
logger.error(f'矿卡{item}所在路段信息读取异常')
return truck_locate_dict
def lane_speed_generate(self):
# truck -> lane
truck_locate_dict = self.update_truck_loacate()
print("truck -> lane")
print(truck_locate_dict)
# truck -> speed
truck_speed_dict = self.update_truck_speed()
print("truck -> speed")
print(truck_speed_dict)
try:
# lane_set, 用到的路段集合
lane_set = []
for walk_time in session_postgre.query(WalkTime).all():
for lane in walk_time.to_load_lanes:
lane_set.append(lane)
for lane in walk_time.to_unload_lanes:
lane_set.append(lane)
for walk_time_park in session_postgre.query(WalkTimePark).all():
for lane in walk_time_park.park_load_lanes:
lane_set.append(lane)
lane_set = set(lane_set)
except Exception as es:
logger.error('所用路网路段集合读取异常')
# lane -> speed, 各路段平均行驶速度
self.lane_speed_dict = {}
# lane -> num, 各路段行驶车辆
lane_trucks_dict = {}
# used lane, 存在行驶矿卡的路段
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
# 对于各路段信息
for truck in truck_locate_dict.keys():
lane_id = truck_locate_dict[truck]
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]
# 该路段矿卡数量加一
lane_trucks_dict[truck_locate_dict[truck]] = lane_trucks_dict[truck_locate_dict[truck]] + 1
# 记录存在行驶矿卡的路段
tmp_lane_set.append(lane_id)
# 存在矿卡的路段
print("存在矿卡的路段:")
print(tmp_lane_set)
# 对不存在的矿卡路段，实时速度设置为最高
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
lane_trucks_dict[str(lane_id)] = 1
# 各路段实时速度取平均
for lane in lane_trucks_dict:
self.lane_speed_dict[lane] = self.lane_speed_dict[lane] / lane_trucks_dict[lane]
except Exception as es:
logger.error("路段实时速度计算异常")
logger.error(es)
return self.lane_speed_dict
path_plannner.py deleted 100644 → 0
View file @ fdff645b
#!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
View file @ 31e38a6a
......@@ -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 0 → 100644
View file @ 31e38a6a
#!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_info.py
View file @ 31e38a6a
......@@ -10,24 +10,25 @@
from static_data_process import *
from settings import *
from path_plan.path_plannner import *
# 车流规划类
class Traffic_para(object):
def __init__(self, num_of_load_area, num_of_unload_area, num_of_excavator, num_of_dump):
self.load_area_uuid_to_ref_id_dict = {} # 用于保存装载点uuid到id的映射
self.load_area_ref_id_to_uuid_dict = {} # 用于保存装载点id到uuid的映射
self.unload_area_uuid_to_ref_id_dict = {} # 用于保存卸载点uuid到id的映射
self.unload_area_ref_id_to_uuid_dict = {} # 用于保存卸载点id到uuid的映射
self.load_area_uuid_to_index_dict = {} # 用于保存装载点uuid到id的映射
self.load_area_index_to_uuid_dict = {} # 用于保存装载点id到uuid的映射
self.unload_area_uuid_to_index_dict = {} # 用于保存卸载点uuid到id的映射
self.unload_area_index_to_uuid_dict = {} # 用于保存卸载点id到uuid的映射
self.excavator_uuid_to_ref_id_dict = {} # 用于保存挖机uuid到id的映射
self.excavator_ref_id_to_uuid_dict = {} # 用于保存挖机id到uuid的映射
self.dump_uuid_to_ref_id_dict = {} # 用于保存卸点uuid到id的映射
self.dump_ref_id_to_uuid_dict = {} # 用于保存卸点id到uuid的映射
self.excavator_uuid_to_index_dict = {} # 用于保存挖机uuid到id的映射
self.excavator_index_to_uuid_dict = {} # 用于保存挖机id到uuid的映射
self.dump_uuid_to_index_dict = {} # 用于保存卸点uuid到id的映射
self.dump_index_to_uuid_dict = {} # 用于保存卸点id到uuid的映射
self.dump_uuid_to_unload_area_uuid_dict = {} # 用于保存卸点与卸载区的绑定关系(uuid)
self.excavator_uuid_to_load_area_uuid_dict = {} # 用于保存挖机与装载区的绑定关系(uuid)
self.dump_ref_id_to_unload_area_ref_id_dict = {} # 用于保存卸点与卸载区的绑定关系(id)
self.excavator_ref_id_to_load_area_ref_id_dict = {} # 用于保存挖机与装载区的绑定关系(id)
self.dump_index_to_unload_area_index_dict = {} # 用于保存卸点与卸载区的绑定关系(id)
self.excavator_index_to_load_area_index_dict = {} # 用于保存挖机与装载区的绑定关系(id)
self.empty_speed = 25 # 空载矿卡平均时速
......@@ -36,7 +37,7 @@ class Traffic_para(object):
self.goto_unload_area_distance = np.zeros((num_of_load_area, num_of_unload_area)) # 重载运输路线距离
# self.avg_goto_excavator_weight = np.zeros((num_of_load_area, num_of_unload_area))
self.avg_goto_excavator_weight = np.full((num_of_load_area, num_of_unload_area), 1)
self.avg_goto_excavator_weight = np.full((num_of_unload_area, num_of_load_area), 1)
# self.avg_goto_dump_weight = np.zeros((num_of_load_area, num_of_unload_area))
self.avg_goto_dump_weight = np.full((num_of_load_area, num_of_unload_area), 1)
......@@ -49,6 +50,9 @@ class Traffic_para(object):
self.excavator_strength = np.zeros(num_of_excavator) # 用于保存电铲的工作强度,单位是t/h
self.dump_strength = np.zeros(num_of_dump) # 卸载点的工作强度，单位是t/h
self.path_planner = PathPlanner()
self.path_planner.walk_cost()
'''
以下参数暂时没用到
'''
......@@ -73,14 +77,14 @@ class Traffic_para(object):
dump_id = dispatch.dump_id
if dump_id not in self.dump_uuid_to_unload_area_uuid_dict:
# dump_uuid <-> dump_id
self.dump_uuid_to_ref_id_dict[dump_id] = dump_index
self.dump_ref_id_to_uuid_dict[dump_index] = dump_id
self.dump_uuid_to_index_dict[dump_id] = dump_index
self.dump_index_to_uuid_dict[dump_index] = dump_id
# dump_uuid -> unload_area_uuid
self.dump_uuid_to_unload_area_uuid_dict[dump_id] = unload_area_id
# dump_id -> unload_area_id
self.dump_ref_id_to_unload_area_ref_id_dict[
self.dump_uuid_to_ref_id_dict[dump_id]] = \
self.unload_area_uuid_to_ref_id_dict[unload_area_id]
self.dump_index_to_unload_area_index_dict[
self.dump_uuid_to_index_dict[dump_id]] = \
self.unload_area_uuid_to_index_dict[unload_area_id]
self.dump_strength[dump_index] = 300 # 卸载设备最大卸载能力，单位吨/小时
self.grade_upper_dump_array[dump_index] = 100 # 卸点品位上限
......@@ -91,25 +95,28 @@ class Traffic_para(object):
# 提取挖机信息并建立映射
def extract_excavator_info(self):
excavator_index = 0
for dispatch in session_mysql.query(Dispatch).filter_by(isdeleted=0, isauto=1).all():
excavator_id = dispatch.exactor_id
load_area_id = dispatch.load_area_id
if excavator_id not in self.excavator_uuid_to_ref_id_dict:
# excavator_uuid <-> excavator_uuid
self.excavator_uuid_to_ref_id_dict[excavator_id] = excavator_index
self.excavator_ref_id_to_uuid_dict[excavator_index] = excavator_id
# excavator_uuid -> load_area_uuid
self.excavator_uuid_to_load_area_uuid_dict[excavator_id] = load_area_id
# excavator_id -> load_area_id
self.excavator_ref_id_to_load_area_ref_id_dict[
self.excavator_uuid_to_ref_id_dict[excavator_id]] = \
self.load_area_uuid_to_ref_id_dict[load_area_id]
self.excavator_strength[excavator_index] = 300 # 挖机最大装载能力，单位吨/小时
self.grade_loading_array[excavator_index] = 100 # 挖机装载物料品位
self.excavator_priority_coefficient[excavator_index] = 1 # 挖机优先级
excavator_index += 1
try:
excavator_index = 0
for dispatch in session_mysql.query(Dispatch).filter_by(isdeleted=0, isauto=1).all():
excavator_id = dispatch.exactor_id
load_area_id = dispatch.load_area_id
if excavator_id not in self.excavator_uuid_to_index_dict:
# excavator_uuid <-> excavator_uuid
self.excavator_uuid_to_index_dict[excavator_id] = excavator_index
self.excavator_index_to_uuid_dict[excavator_index] = excavator_id
# excavator_uuid -> load_area_uuid
self.excavator_uuid_to_load_area_uuid_dict[excavator_id] = load_area_id
# excavator_id -> load_area_id
self.excavator_index_to_load_area_index_dict[
self.excavator_uuid_to_index_dict[excavator_id]] = \
self.load_area_uuid_to_index_dict[load_area_id]
self.excavator_strength[excavator_index] = 300 # 挖机最大装载能力，单位吨/小时
self.grade_loading_array[excavator_index] = 100 # 挖机装载物料品位
self.excavator_priority_coefficient[excavator_index] = 1 # 挖机优先级
excavator_index += 1
except Exception as es:
logger.error("车流规划读取挖机信息异常")
def extract_walk_time_info(self):
# load_area_uuid <-> load_area_id
......@@ -121,13 +128,13 @@ class Traffic_para(object):
load_area_id = str(walk_time.load_area_id)
unload_area_id = str(walk_time.unload_area_id)
if load_area_id not in self.load_area_uuid_to_ref_id_dict:
self.load_area_uuid_to_ref_id_dict[load_area_id] = load_area_index
self.load_area_ref_id_to_uuid_dict[load_area_index] = load_area_id
if load_area_id not in self.load_area_uuid_to_index_dict:
self.load_area_uuid_to_index_dict[load_area_id] = load_area_index
self.load_area_index_to_uuid_dict[load_area_index] = load_area_id
load_area_index += 1
if unload_area_id not in self.unload_area_uuid_to_ref_id_dict:
self.unload_area_uuid_to_ref_id_dict[unload_area_id] = unload_area_index
self.unload_area_ref_id_to_uuid_dict[unload_area_index] = unload_area_id
if unload_area_id not in self.unload_area_uuid_to_index_dict:
self.unload_area_uuid_to_index_dict[unload_area_id] = unload_area_index
self.unload_area_index_to_uuid_dict[unload_area_index] = unload_area_id
unload_area_index += 1
# 路网信息读取
......@@ -135,8 +142,8 @@ class Traffic_para(object):
load_area_id = str(walk_time.load_area_id)
unload_area_id = str(walk_time.unload_area_id)
# 将uuid转为id
load_area_index = self.load_area_uuid_to_ref_id_dict[load_area_id]
unload_area_index = self.unload_area_uuid_to_ref_id_dict[unload_area_id]
load_area_index = self.load_area_uuid_to_index_dict[load_area_id]
unload_area_index = self.unload_area_uuid_to_index_dict[unload_area_id]
# 运输路线距离
self.goto_load_area_distance[unload_area_index][load_area_index] = walk_time.to_load_distance
......@@ -158,7 +165,9 @@ class Traffic_para(object):
(60 / 1000 * walk_time.to_unload_distance / self.heavy_speed) / self.payload
# / self.avg_goto_excavator_weight[unload_area_index][load_area_index]
# 车流规划部分矩阵格式与其余两个模块不同
self.goto_load_area_distance = self.path_planner.walk_time_to_load_area
self.goto_unload_area_distance = self.path_planner.walk_time_to_unload_area.transpose()
# 初始化车流规划类
......@@ -185,8 +194,8 @@ def Traffic_para_init(num_of_load_area, num_of_unload_area, num_of_excavator, nu
for i in range(num_of_excavator):
for j in range(num_of_dump):
# 查找挖机绑定的装载区, 卸载设备绑定的卸载区
load_area_index = tra_para.excavator_ref_id_to_load_area_ref_id_dict[i]
unload_area_index = tra_para.dump_ref_id_to_unload_area_ref_id_dict[j]
load_area_index = tra_para.excavator_index_to_load_area_index_dict[i]
unload_area_index = tra_para.dump_index_to_unload_area_index_dict[j]
# 逻辑道路因子赋值, 来自实际道路因子
tra_para.goto_excavator_factor[j][i] = \
......@@ -203,6 +212,11 @@ def Traffic_para_init(num_of_load_area, num_of_unload_area, num_of_excavator, nu
tra_para.goto_excavator_distance[j][i] = \
tra_para.goto_load_area_distance[unload_area_index][load_area_index]
print(i, j)
print(tra_para.goto_dump_distance)
print(load_area_index, unload_area_index)
print(tra_para.goto_unload_area_distance)
tra_para.goto_dump_distance[i][j] = \
tra_para.goto_unload_area_distance[load_area_index][unload_area_index]
return tra_para
traffic_flow/traffic_flow_planner.py
View file @ 31e38a6a
......@@ -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
View file @ 31e38a6a
......@@ -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
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment