Skip to content

I
integrated-scheduling-v3
Commit a274a624 authored by 张晓彤's avatar 张晓彤
Browse files
Options

二次调度逻辑优化

parent 77024ac7
Show whitespace changes
Inline Side-by-side
Showing with 259 additions and 538 deletions
core/group.py
View file @ a274a624
......@@ -349,8 +349,15 @@ class GroupDispatcher:
"""
self.logger = logging.getLogger("zxt.GroupDispatcher")
self.group = group
self.gothrough_active = False
if self.group.topo is not None:
self.redispatcher = ReDispatcher(self.group)
with open(json_file, encoding='UTF-8') as f:
load_value = json.load(f)
if "gothrough" in load_value:
self.gothrough_active = True
self.gothroghdispatcher = GoThroughDispatcher(self.group)
def group_dispatch(self, Solver) -> Mapping[str, List[str]]:
......@@ -374,8 +381,6 @@ class GroupDispatcher:
for truck_id in list(self.group.group_trucks):
self.logger.info(f'调度车辆 {truck_id}')
# try:
# get truck index from mapping
if truck_id not in self.group.truck.truck_uuid_to_index_dict:
......@@ -402,6 +407,53 @@ class GroupDispatcher:
else:
truck_task = truck_task_list[truck_id]
# get truck lane_id from truck obj.
truck_lane_locate_dict = self.group.truck.get_truck_lane_locate_dict()
if truck_id not in truck_lane_locate_dict:
self.logger.warning(f'truck.truck lane dict 中不存在矿卡 {truck_id}')
# continue
truck_lane_locate = None
else:
truck_lane_locate = truck_lane_locate_dict[truck_id]
# get truck name form dict.
truck_uuid_to_name_dict = get_value("truck_uuid_to_name_dict")
# 获取请调车辆名
if truck_id not in truck_uuid_to_name_dict:
# raise CoreException(102, f'truck_uuid_to_name_dict 缺失车辆 {truck_id} 信息')
self.logger.error(f'truck_uuid_to_name_dict 缺失车辆 {truck_id} 信息')
truck_name = truck_uuid_to_name_dict[truck_id]
# 获取车辆当前派车计划
if truck_task in [0, 1, 5]:
excavator_index = int(truck_trip[1])
dump_index = int(truck_trip[0])
else:
dump_index = int(truck_trip[1])
excavator_index = int(truck_trip[0])
if excavator_index == -1:
current_truck_goto_excavator_id = None
current_load_area_id = None
else:
# if excavator_index not in self.group.excavator_info.excavator_index_to_uuid_dict:
# # raise CoreException(111, f'excavator_index_to_uuid_dict 缺失 {excavator_index} 号挖机信息')
# self.logger.error(f'excavator_index_to_uuid_dict 缺失 {excavator_index} 号挖机信息')
current_truck_goto_excavator_id = self.group.excavator_info.excavator_index_to_uuid_dict[
excavator_index]
current_load_area_id = DispatchInfo.excavator_load_dict[current_truck_goto_excavator_id]
if dump_index == -1:
current_truck_goto_dump_id = None
current_unload_area_id = None
else:
# if dump_index not in self.group.dump_info.dump_index_to_uuid_dict:
# # raise CoreException(111, f'dump_index_to_uuid_dict 缺失 {dump_index} 号卸点信息')
# self.logger.error(f'dump_index_to_uuid_dict 缺失 {dump_index} 号卸点信息')
current_truck_goto_dump_id = self.group.dump_info.dump_index_to_uuid_dict[dump_index]
current_unload_area_id = DispatchInfo.dump_unload_area_dict[current_truck_goto_dump_id]
# Construct a truck obj. and add it to group truck dictionary.
truck_info = CurrentTruck(truck_id, self.group.group_id, truck_trip, truck_task,
self.group.truck.get_truck_current_state()[truck_id])
......@@ -419,19 +471,21 @@ class GroupDispatcher:
# self.logger.error("车辆调度信息读取异常")
# self.logger.error(es)
try:
self.logger.info(f'======================= 开始处理调度车辆 {truck_name} =======================')
# try:
# 全智能模式
if self.group.group_mode == 1:
self.logger.info("全智能模式调度")
self.logger.info("调度模式：全智能模式调度")
self.full_dynamic_mode(truck_id, solver, truck_dispatch, truck_info, truck_task, truck_trip)
# 空车智能模式
elif self.group.group_mode == 2:
self.logger.info("空车智能模式调度")
self.logger.info("调度模式：空车智能模式调度")
self.semi_dynamic_mode(truck_id, solver, truck_dispatch, truck_info, truck_task, truck_trip)
# 定铲派车
elif self.group.group_mode == 3:
self.logger.info("固定模式调度")
self.logger.info("调度模式：固定模式调度")
try:
truck_dispatch[truck_id] = DispatchInfo.get_truck_match(truck_id)
except Exception as es:
......@@ -440,14 +494,15 @@ class GroupDispatcher:
# 分流配比模式
elif self.group.group_mode == 4:
self.logger.info("分流配比模式调度")
self.logger.info("调度模式：分流配比模式调度")
self.ratio_mode(truck_id, truck_dispatch, truck_task)
except Exception as es:
self.logger.error("调度调用异常")
self.logger.error(es)
# except Exception as es:
# self.logger.error("调度调用异常")
# self.logger.error(es)
self.logger.info(f'======================= 派车计划计算结束 {truck_name} =======================')
# return dispatch plan
return truck_dispatch
def ratio_mode(self, i, truck_dispatch, truck_task):
......@@ -526,36 +581,62 @@ class GroupDispatcher:
def full_dynamic_mode(self, i: str, s: AlgorithmBase, truck_dispatch: Mapping[str, List[str]],
truck_info: CurrentTruck, truck_task: int, truck_trip: List[int]):
# 车辆停止或者车辆位于卸载区内, 调度车辆前往装载区
if truck_task in [-2, 3, 4, 5]:
# if truck_task == 3 and self.group.truck.truck_current_state[i] == 2:
if truck_task == 3:
if self.group.topo is not None:
# 获取车辆任务信息
try:
truck_locate = self.group.truck.get_truck_locate_dict()[i]
truck_task = truck_info.get_task()
if truck_task is None:
raise Exception("车辆任务信息丢失")
except Exception as es:
self.logger.error("车辆位置信息丢失")
self.logger.error(es)
truck_dispatch[i] = [None, None]
return
# 获取车辆位置信息
try:
truck_locate = self.group.truck.get_truck_lane_locate_dict()[i]
except Exception as es:
self.logger.error(f'车辆位置信息丢失 {es}')
truck_locate = None
# 获取车辆临时字段
try:
truck_is_temp = self.group.truck.truck_is_temp[i]
except Exception as es:
truck_is_temp = False
self.logger.error("车辆临时字段异常")
self.logger.error(es)
self.logger.error(f'车辆临时字段异常 {es}')
# 车辆停止或者车辆位于卸载区内, 调度车辆前往装载区
if truck_task in [-2, 3, 4, 5]:
# if truck_task == 3 and self.group.truck.truck_current_state[i] == 2:
if truck_task == 3:
if self.group.topo is not None and truck_locate is not None:
self.logger.info("潜在二次调度车辆状态")
self.logger.info(f'车辆位置 {truck_locate}')
self.logger.info(f'车辆状态 {self.group.truck.truck_current_state[i]}')
self.logger.info(f'车辆临时 {truck_is_temp} {type(truck_is_temp)}')
self.logger.info(f'车辆任务 {truck_task}')
self.logger.info(f'车辆临时 {truck_is_temp}')
self.logger.info(self.group.topo.cross_bf_lanes)
self.logger.info(self.group.truck.truck_current_state)
# 车辆当前位于交叉路口前，且排队等待
if (truck_locate in self.group.topo.cross_bf_lanes) and (not truck_is_temp):
self.logger.info("触发二次调度")
# self.redispatch_to_dump(i, truck_dispatch, truck_locate, truck_trip)
try:
self.redispatcher.redispatch_to_dump(i, truck_dispatch, truck_locate, truck_trip)
except Exception as es:
self.logger.error("二次调度至卸载点失败")
self.logger.error(es)
else:
pass
self.logger.info("未触发二次调度")
else:
self.logger.info("正常重载行驶无需调度")
else:
try:
if i in self.group.truck.truck_excavator_bind:
self.logger.info("车辆存在绑定关系")
try:
if i not in self.group.truck.truck_excavator_bind:
raise CoreException(102, f'truck.group_excavators bind 中不存在 {i}')
......@@ -565,6 +646,7 @@ class GroupDispatcher:
return
next_excavator_id = self.group.truck.truck_excavator_bind[i]
else:
self.logger.info("触发调度算法逻辑")
next_excavator_value = s.solve(truck_info)
self.logger.info(f'车辆排斥修正 {i}, {self.group.truck_excavator_exclude_modify[i]}')
min_index = np.argmin(next_excavator_value + self.group.truck_excavator_exclude_modify[i])
......@@ -580,76 +662,58 @@ class GroupDispatcher:
next_unload_area_id = get_value("dump_uuid_to_unload_area_uuid_dict")[dump_id]
truck_dispatch[i] = [next_excavator_id, next_unload_area_id]
self.logger.info(f'调度结果 next_excavator_id: '
f'{next_excavator_id} next_unload_area_id: {next_unload_area_id}')
except Exception as es:
self.logger.error("重载车辆全智能模式-计算异常")
self.logger.error(es)
# 车辆位于装载区内, 调度车辆前往卸载区
elif truck_task in [0, 1, 2]:
# if truck_task == 0 and self.group.truck.truck_current_state[i] == 2:
if truck_task == 0:
if self.group.topo is not None:
if i in self.group.truck.get_truck_locate_dict():
truck_locate = self.group.truck.get_truck_locate_dict()[i]
else:
self.logger.error(f'车辆 {i} 位置信息丢失')
truck_dispatch[i] = [None, None]
return
if self.group.topo is not None and truck_locate is not None:
self.logger.info("潜在二次调度车辆状态")
self.logger.info(self.group.truck.truck_is_temp)
try:
truck_is_temp = self.group.truck.truck_is_temp[i]
except Exception as es:
truck_is_temp = False
self.logger.error("车辆临时字段异常")
self.logger.error(es)
# 车辆当前位于交叉路口前，且排队等待
self.logger.info("潜在二次调度车辆状态")
self.logger.info(f'车辆 {i}')
self.logger.info(f'车辆位置 {truck_locate}')
self.logger.info(f'车辆状态 {self.group.truck.truck_current_state[i]}')
self.logger.info(f'车辆临时 {truck_is_temp} {type(truck_is_temp)}')
self.logger.info(f'车辆临时 {truck_is_temp}')
self.logger.info(self.group.topo.cross_bf_lanes)
self.logger.info(self.group.truck.truck_current_state)
self.logger.info(truck_is_temp)
# if (truck_locate in self.topo.cross_bf_lanes) and (self.truck.truck_current_state[truck_id] == 2) \
# and (not truck_is_temp):
# if (truck_locate in self.group.topo.cross_bf_lanes) and (
# self.group.truck.truck_current_state[i] == 2):
if (truck_locate in self.group.topo.cross_bf_lanes) and (not truck_is_temp):
self.logger.info("触发二次调度")
# self.redispatch_to_excavator(i, truck_dispatch, truck_locate)
try:
self.redispatcher.redispatch_to_excavator(i, truck_dispatch, truck_locate)
except Exception as es:
self.logger.error("二次调度至装载点失败")
self.logger.error(es)
else:
self.logger.info("未触发二次调度")
# 穿越装载区判断
if self.gothrough_active:
self.gothroghdispatcher.update_lanes_info()
self.gothroghdispatcher.redispatch_request(request_truck_id=i, truck=self.group.truck)
else:
pass
self.logger.info("正常空载行驶无需调度")
else:
try:
next_excavator_id = get_value("excavator_index_to_uuid_dict")[truck_trip[-1]]
next_unload_area_value = s.solve(truck_info)
# self.logger.info(f'车辆 {truck_id}')
# self.logger.info(f'group distance {self.to_unload_area_distance}')
# self.logger.info(f'walk available {self.group_walk_available}')
#
# self.logger.info(self.unload_area_uuid_index_dict)
# self.logger.info(self.excavator_uuid_index_dict)
if i in self.group.truck.truck_dump_bind:
self.logger.info("车辆存在绑定关系")
dump_uuid_to_unload_area_uuid_dict = get_value("dump_uuid_to_unload_area_uuid_dict")
next_unload_area_id = dump_uuid_to_unload_area_uuid_dict[self.group.truck.truck_dump_bind[i]]
else:
tmp = self.group.group_walk_available[
self.group.excavator_uuid_index_dict[next_excavator_id], :].flatten()
# self.logger.info(f'group_walk_available_pick {tmp}')
# self.logger.info(f'next_excavator_id {next_excavator_id}')
# self.logger.info(next_unload_area_value)
self.logger.info("触发调度算法逻辑")
next_unload_area_value *= self.group.group_walk_available[
self.group.excavator_uuid_index_dict[next_excavator_id], :].flatten()
# self.logger.info(next_unload_area_value)
min_index = np.argmin(next_unload_area_value)
next_unload_area_id = self.group.unload_area_uuid_index_dict.inverse[min_index]
......@@ -658,6 +722,9 @@ class GroupDispatcher:
truck_dispatch[i] = [next_excavator_id, next_unload_area_id]
self.logger.info(f'调度结果 next_excavator_id: '
f'{next_excavator_id} next_unload_area_id: {next_unload_area_id}')
except Exception as es:
self.logger.error("空载车辆全智能模式-计算异常")
self.logger.error(es.__traceback__.tb_lineno)
......@@ -998,7 +1065,7 @@ class ReDispatcher:
def get_congestion_lanes(self):
# 存在车辆拥堵的路段
truck_locate_dict = self.group.truck.get_truck_locate_dict()
truck_locate_dict = self.group.truck.get_truck_lane_locate_dict()
congestion_lane_list = []
for key, value in truck_locate_dict.items():
if self.group.truck.truck_current_state[key] == 2:
......
core/submit.py
View file @ a274a624
......@@ -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/dispatchInfo.py
View file @ a274a624
......@@ -4,13 +4,12 @@
# @Site :
# @File : dispatchInfo.py
# @Software: PyCharm
import numpy as np
from settings import *
from tables import *
import pandas as pd
from tables import DispatchMatch, DispatchEquipment
# 分组数据处理
from data.para_config import *
from bidict import bidict
from settings import get_logger
logger = get_logger("zxt.dispatchInfo")
......@@ -123,18 +122,6 @@ class DispatchInfo:
cls.load_area_uuid_to_index_dict = {}
cls.unload_area_uuid_to_index_dict = {}
# cls.group_unload_area_dict = {} # cls.group_unload_area_dict.keys() 相当于所有的team_id
# cls.unload_area_group_dict = {} # cls.unload_area_group_dict.keys() 相当于所有的卸载区 unload_area_id
# cls.group_excavator_dict = {}
# cls.excavator_group_dict = {}
# cls.load_excavator_dict = {} # cls.load_excavator_dict.keys() 相当于所有的装载区 load_area_id
# cls.excavator_load_dict = {}
# cls.group_truck_dict = {}
# cls.truck_group_dict = {}
# cls.group_mode = {}
# cls.load_distance = {} # to_load_diatance-->>空车模式
# cls.unload_distance = {} # to_unload_distance-->>重车模式
@classmethod
def update_device_group_structure(cls):
"""
......@@ -347,16 +334,6 @@ class DispatchInfo:
group_unload_area_uuid_to_index = {}
try:
# # unload->load distance
# unload_load_distance = np.zeros((len(unload_areas), len(load_areas)))
# for truck_id in range(len(unload_areas)):
# for j in range(len(load_areas)):
# distance = int(session_postgre.query(WalkTime).filter_by(unload_area_id=unload_areas[truck_id], load_area_id=load_areas[j]).first().to_load_distance)
# unload_load_distance[truck_id][j] = distance
# cls.load_distance[item] = unload_load_distance
group_excavator_count = 0
group_dump_count = 0
group_load_area_count = 0
......@@ -375,9 +352,9 @@ class DispatchInfo:
load_area_id=load_area_id).first()
if distance is not None:
logger.warning(f'装载区 {load_area_id} 与 卸载区 {unload_area_id} 间路网不通')
unload_load_distance[group_dump_count][group_excavator_count] = float(distance.to_load_distance)
else:
logger.warning(f'装载区 {load_area_id} 与 卸载区 {unload_area_id} 间路网不通')
unload_load_distance[group_dump_count][group_excavator_count] = 1000000
if excavator_id not in group_excavator_uuid_to_index:
......@@ -440,39 +417,6 @@ class DispatchInfo:
logger.error("路网距离更新异常-调度部分和路网部分不一致")
logger.error(es)
# @classmethod
# def update_device_dict(cls):
# cls.excavator_uuid_index_dict = {}
# cls.unload_area_uuid_index_dict = {}
# cls.truck_uuid_index_dict = {}
# cls.dump_uuid_index_dict = {}
# for group_id in cls.group_set:
# cls.excavator_uuid_index_dict = {}
# cls.unload_area_uuid_index_dict = {}
# cls.truck_uuid_index_dict = {}
# cls.dump_uuid_index_dict = {}
#
# for truck_id in range(len(cls.group_excavator_dict[group_id])):
# cls.excavator_uuid_index_dict[group_id][list(cls.group_excavator_dict[group_id])[truck_id]] = truck_id
#
# for truck_id in range(len(cls.group_unload_area_dict[group_id])):
# cls.unload_area_uuid_index_dict[group_id][list(cls.group_unload_area_dict[group_id])[truck_id]] = truck_id
#
# for truck_id in range(len(cls.group_dump_dict[group_id])):
# cls.dump_uuid_index_dict[group_id][list(cls.group_dump_dict[group_id])[truck_id]] = truck_id
#
# for truck_id in range(len(cls.group_truck_dict[group_id])):
# cls.truck_uuid_index_dict[group_id][list(cls.group_truck_dict[group_id])[truck_id]] = truck_id
#
# # self.excavator_uuid_index_dict = bidict(DispatchInfo.excavator_uuid_to_index_dict[self.group_id])
# # self.unload_area_uuid_index_dict = bidict(DispatchInfo.unload_area_uuid_to_index_dict[self.group_id])
# # self.dump_uuid_index_dict = bidict(DispatchInfo.dump_uuid_to_index_dict[self.group_id])
#
# cls.excavator_uuid_index_dict = bidict(cls.excavator_uuid_index_dict)
# cls.unload_area_uuid_index_dict = bidict(cls.unload_area_uuid_index_dict)
# cls.truck_uuid_index_dict = bidict(cls.truck_uuid_index_dict)
# cls.dump_uuid_index_dict = bidict(cls.dump_uuid_index_dict)
@classmethod
def get_group_excavator_dict(cls, group_id):
return cls.excavator_uuid_to_index_dict[group_id]
......@@ -531,18 +475,19 @@ class DispatchInfo:
@classmethod
def get_park_to_excavator_distance(cls, group_id):
excavators = cls.group_excavator_dict[group_id]
park_matrix = np.ones((1, len(excavators)))
park_area_set = get_value("park_uuid_to_index_dict").keys()
park_matrix = np.ones((len(park_area_set), len(excavators)))
try:
b = excavators
for i in range(len(excavators)):
load_area_id = cls.excavator_load_dict[excavators[i]]
for park_idx in range(len(park_area_set)):
try:
distance = session_postgre.query(WalkTimePark).filter_by(load_area_id=load_area_id).first().park_load_distance
park_matrix[0][i] = distance
park_matrix[park_idx][i] = distance
except Exception as es:
logger.warning("查询不到距离，设置为100000000")
logger.warning(es)
park_matrix[0][i] = 100000000 # 设置为一个很大的数字
park_matrix[park_idx][i] = 100000000 # 设置为一个很大的数字
except Exception as es:
logger.error("park->load距离更新异常, 存在备停区不可达的装载区")
logger.error(es)
......@@ -551,6 +496,13 @@ class DispatchInfo:
return park_matrix
@classmethod
def get_park_set(cls):
park_areas_set = set()
for item in session_postgre.query(WalkTimePark).all():
park_areas_set.add(item.park_area_id)
return park_areas_set
@classmethod
def get_truck_exactor(cls, truck_id):
return cls.truck_exactor_dict[truck_id]
......@@ -563,161 +515,4 @@ class DispatchInfo:
return cls.exactor_unload_dict[exactor_id]
# #!E:\Pycharm Projects\Waytous
# # -*- coding: utf-8 -*-
# # @Time : 2022/5/30 14:45
# # @Author : Opfer
# # @Site :
# # @File : dispatchInfo.py
# # @Software: PyCharm
# from settings import *
#
# logger = get_logger("mqc.dispatchInfo")
#
#
# class DispatchInfo:
# """
# class for dispatch group info.
# """
#
# # dispatch groups
# group_set = set()
#
# # device group structure
# group_unload_area_dict = {} # team_id -> dict {unload_area_id, unload_area_id, ...}
# # {group_id:unload_area_id,...}
# group_excavator_dict = {} # team_id -> dict {[excavator_id, load_area_id], ...}
# # {group_id: [excavator_id, unload_area_id], ...}
# group_truck_dict = {} # team_id -> dict {truck_id, ...}
# # {group_id:[truck_id,truck_id],...}
#
# unload_area_group_dict = {} # unload_area_id -> team_id
# excavator_group_dict = {} # excavator_id -> team_id
# truck_group_dict = {} # truck_id -> team_id
#
# # group feature
# group_mode = {} # 四种模式：全智能、空车智能、定铲定铲和分流配比模式
# # {mode_name:mode_code}
#
# # route_distance（路网距离）
# load_excavator_distance = {} # 装载区-挖机（电铲）的距离 数据格式 -->> {load_area_id:[excavator_uuid, to_load_distance],}
# unload_excavator_distance = {} # 卸载区-挖机（电铲）的距离 数据格式 -->> {unload_area_id:[excavator_uuid, to_unload_distance],}
#
# @classmethod
# def renew_set(cls):
# """
# @date：2022/6/2 19:50
# @author：maqc
# @desc：实例化对象，可直接访问
# """
# cls.group_unload_area_dict = {}
# cls.unload_area_group_dict = {}
#
# cls.group_excavator_dict = {}
# cls.excavator_group_dict = {}
#
# cls.group_truck_dict = {}
# cls.truck_group_dict = {}
#
# cls.group_mode = {}
# cls.load_excavator_distance = {}
# cls.unload_excavator_distance = {}
#
# @classmethod
# def update_device_group_structure(cls):
# """
# @date：2022/6/2 19:49
# @author：maqc
# @desc：分组与卸载区、挖机、矿卡的映射和反映射
# """
# logger = get_logger("mqc.update_device_group_structure")
# try:
# # group_unload_area_dict = {} -->> {group_id:unload_area_id,...}
# # unload_area_group_dict = {} # unload_area_id -> team_id
# group_code_dict = {} # group_code-->>team_id的映射
# for valve in session_mysql.query(DispatchMatch).filter_by(group_type=1).all():
# group_code_dict[valve.group_code] = valve.team_id
# if valve.team_id not in cls.group_unload_area_dict:
# cls.group_unload_area_dict[valve.team_id] = [valve.unload_area_id] # 注意：一个team_id可能对应多个unload_area_id
# else:
# cls.group_unload_area_dict[valve.team_id].append(valve.unload_area_id)
# cls.unload_area_group_dict[valve.unload_area_id] = valve.team_id # 一个unload_area_id只对应一个team_id
# # group_excavator_dict = {} -->> {group_id: [excavator_id, unload_area_id], ...} # 一个team_id对应一组excavator_id, unload_area_id
# # excavator_group_dict = {} -->> excavator_id -> team_id 一个excavator_id只对应一个team_id
# for item in session_mysql.query(DispatchMatch).filter_by(group_type=1).all():
# # cls.group_excavator_dict[item.team_id] = [item.excavator_id, item.unload_area_id]
# cls.group_excavator_dict[item.team_id] = item.excavator_id
# cls.excavator_group_dict[item.excavator_id] = item.team_id
# # group_truck_dict = {} -->> {group_id:[truck_id,truck_id],...}
# # truck_group_dict = {} -->> truck_id -> team_id
# for key in session_mysql.query(DispatchEquipment).filter_by(group_type=1).all():
# if key.group_code in group_code_dict:
# if key.group_code not in cls.group_truck_dict:
# cls.group_truck_dict[key.group_code] = [key.equipment_id]
# else:
# cls.group_truck_dict[key.group_code].append(key.equipment_id)
# cls.truck_group_dict[key.equipment_id] = group_code_dict[key.group_code]
# except Exception as es:
# logger.error("分组到卸载区的数据更新异常")
# logger.error(es)
#
# @classmethod
# def update_group_mode(cls):
# """
# @date：2022/6/2 19:49
# @author：maqc
# @desc：处理其它类型的数据
# """
# logger = get_logger("mqc.update_group_mode")
# try:
# for value in session_mysql.query(DispatchMode).all():
# cls.group_mode[value.mode_name] = value.mode_code
# except Exception as es:
# logger.error("派车模式数据更新异常")
# logger.error(es)
#
# @classmethod
# def dispatch_group_init(cls):
# """
# update basic paras (group_set, dict, num ...)
# :return:
# """
# pass
#
#
# @classmethod
# def get_group_road_info(cls,group_id, truck_info):
# if truck_info == 1:
# for truck_id in group_excavator():
# pass
# for j in group_unload_area():
# pass
# if truck_info == 2:
# pass
# @classmethod
# # 距离-->>数据格式：矩阵-->>to_load_distance
# def update_route_distance(cls):
# """
# @date：2022/6/2 19:50
# @author：maqc
# @desc：更新路网距离，返回矩阵格式数据
# """
# load_excavator_dict = {} # 装载区id-->>电铲编号的映射
# logger = get_logger("mqc.update_route_distance")
# try:
# for value in session_postgre.query(DiggingWorkArea).all():
# load_excavator_dict[value.Id] = value.Exactorld
# for value in session_postgre.query(WalkTime).all():
# if value.load_area_id in load_excavator_dict:
# cls.load_excavator_distance[value.load_area_id] = [load_excavator_dict[value.load_area_id],
# value.to_load_distance]
# cls.unload_excavator_distance[value.unload_area_id] = [load_excavator_dict[value.load_area_id],
# value.to_unload_distance]
# except Exception as es:
# logger.error("路网数据更新异常")
# logger.error(es)
#
#
data/para_config.py
View file @ a274a624
......@@ -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
View file @ a274a624
......@@ -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
View file @ a274a624
......@@ -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
View file @ a274a624
......@@ -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
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