380 lines
15 KiB
Python
380 lines
15 KiB
Python
from __future__ import annotations
|
|
import model
|
|
from datetime import datetime, timedelta
|
|
from typing import List, Dict, Optional
|
|
import math
|
|
|
|
|
|
class RuntimeProduct:
|
|
|
|
def __init__(self, product: model.Product, amount: int, order: model.Order):
|
|
self.ddl: datetime = datetime.today()
|
|
self.start: datetime = datetime.today()
|
|
self.delay = datetime.today()
|
|
self.product: model.Product = product
|
|
self.amount: int = amount
|
|
self.order: model.Order = order
|
|
self.father_product: Optional[model.Product] = None
|
|
|
|
def set_father_product(self, father_product: model.Product):
|
|
self.father_product = father_product
|
|
|
|
def set_ddl_start(self, ddl: datetime, start: datetime):
|
|
self.ddl = ddl
|
|
self.start = start
|
|
|
|
def set_delay(self, processes_pdt_times):
|
|
self.delay = self.ddl - timedelta(minutes=processes_pdt_times)
|
|
|
|
|
|
class ProductLine:
|
|
|
|
def __init__(self, product: model.Product):
|
|
self.product: product = product
|
|
self.runtime_products: List[RuntimeProduct] = []
|
|
|
|
def add_runtime_product(self, runtime_product: RuntimeProduct):
|
|
self.runtime_products.append(runtime_product)
|
|
|
|
|
|
class RuntimeProductLines:
|
|
|
|
def __init__(self):
|
|
self.product_lines: Dict[str, ProductLine] = {}
|
|
self.product_lines_list: List[ProductLine] = []
|
|
|
|
def add_runtime_product(self, runtime_product: RuntimeProduct):
|
|
|
|
if runtime_product.product.product_id not in self.product_lines.keys():
|
|
self.product_lines[runtime_product.product.product_id] = ProductLine(runtime_product.product)
|
|
self.product_lines_list = list(self.product_lines.values())
|
|
|
|
self.product_lines[runtime_product.product.product_id].add_runtime_product(runtime_product)
|
|
|
|
def pop_runtime_product(self):
|
|
if self.product_lines_list is None:
|
|
return None
|
|
|
|
earliest_end_time_runtime_product_line = self.product_lines_list[0]
|
|
|
|
earliest_end_time_runtime_product = None
|
|
if len(earliest_end_time_runtime_product_line.runtime_products) > 0:
|
|
earliest_end_time_runtime_product = earliest_end_time_runtime_product_line.runtime_products[0]
|
|
|
|
for product_line in self.product_lines_list:
|
|
if len(product_line.runtime_products) > 0:
|
|
runtime_product = product_line.runtime_products[0]
|
|
if earliest_end_time_runtime_product is None \
|
|
or runtime_product.ddl < earliest_end_time_runtime_product.ddl:
|
|
earliest_end_time_runtime_product = runtime_product
|
|
earliest_end_time_runtime_product_line = product_line
|
|
|
|
if len(earliest_end_time_runtime_product_line.runtime_products) > 0:
|
|
earliest_end_time_runtime_product_line.runtime_products.pop(0)
|
|
|
|
return earliest_end_time_runtime_product
|
|
|
|
def reset(self):
|
|
self.product_lines_list = list(self.product_lines)
|
|
|
|
|
|
# 运行时工序
|
|
class RuntimeProcess:
|
|
|
|
def __init__(self, runtime_product: RuntimeProduct, process: model.Process, order: model.Order):
|
|
self.runtime_product = runtime_product
|
|
self.process = process
|
|
self.ddl = runtime_product.ddl
|
|
self.delay = self.runtime_product.ddl - timedelta(minutes=process.pdt_time)
|
|
self.order: model.Order = order
|
|
|
|
|
|
# 运行时资源需求
|
|
class RuntimeResourceNeed:
|
|
|
|
def __init__(self, runtime_process: RuntimeProcess, resource_attr: str, workspace: str,
|
|
start: datetime, end: datetime):
|
|
if start > end:
|
|
raise RuntimeError("the start time must before the end time")
|
|
|
|
self.process: model.Process = runtime_process.process
|
|
self.order: model.Order = runtime_process.order
|
|
self.resource_attr: str = resource_attr
|
|
self.workspace: str = workspace
|
|
self.start: datetime = start
|
|
self.end: datetime = end
|
|
self.plan_alloc_resources_id: List[str] = []
|
|
self.could_alloc: bool = False
|
|
self.ddl: datetime = runtime_process.ddl
|
|
self.father_product: model.Product = runtime_process.runtime_product.father_product
|
|
self.product: model.Product = runtime_process.runtime_product.product
|
|
self.duration: timedelta = self.end - self.start
|
|
|
|
def add_plan_alloc_resource(self, runtime_resource_id: str):
|
|
self.plan_alloc_resources_id.append(runtime_resource_id)
|
|
|
|
|
|
# 运行时资源
|
|
class RuntimeResource:
|
|
|
|
def __init__(self, resource: model.Resource, start_time: datetime):
|
|
self.resource: model.Resource = resource
|
|
self.workspace: str = self.resource.workspace
|
|
self.basic_attr = self.resource.basic_attr
|
|
self.resource_attrs = self.resource.attrs
|
|
self.schedules: List[RuntimeResourceNeed] = []
|
|
self.start_time: datetime = start_time
|
|
self.durations_cache: Dict[int, int] = {}
|
|
|
|
def add_schedule(self, schedule: RuntimeResourceNeed, do: bool) -> bool:
|
|
|
|
pre_need: Optional[RuntimeResourceNeed] = None
|
|
back_need: Optional[RuntimeResourceNeed] = None
|
|
|
|
if schedule.ddl < self.start_time:
|
|
return False
|
|
|
|
# 统计开始前24小时工作时间
|
|
work_time_statistical_start = schedule.start - timedelta(hours=24)
|
|
work_time_statistical: int = 0
|
|
|
|
cache_index: int = 0
|
|
|
|
# 检查冲突
|
|
for resource_need in self.schedules:
|
|
|
|
if resource_need.end > schedule.end \
|
|
and resource_need.start > schedule.end:
|
|
break
|
|
|
|
# 工作开始前24小时加上该计划后已经累计工作超过8小时
|
|
if work_time_statistical + schedule.duration.total_seconds() > 8 * 3600:
|
|
return False
|
|
|
|
# 优化
|
|
if schedule.end < resource_need.start:
|
|
if resource_need.start > work_time_statistical_start \
|
|
and resource_need.end < schedule.start:
|
|
# 记录工作时间
|
|
work_time_statistical += resource_need.duration.total_seconds()
|
|
|
|
continue
|
|
|
|
if schedule.start < resource_need.end < schedule.end:
|
|
pre_need = resource_need
|
|
break
|
|
|
|
if resource_need.start < schedule.end < resource_need.end:
|
|
pre_need = resource_need
|
|
break
|
|
|
|
if schedule.start < resource_need.start < schedule.end:
|
|
back_need = resource_need
|
|
break
|
|
|
|
if resource_need.start < schedule.start < resource_need.end:
|
|
back_need = resource_need
|
|
break
|
|
|
|
if schedule.start == resource_need.start and schedule.end == resource_need.end:
|
|
pre_need = resource_need
|
|
back_need = resource_need
|
|
break
|
|
|
|
if resource_need.start < schedule.start \
|
|
and resource_need.end < schedule.start:
|
|
cache_index += 1
|
|
|
|
if pre_need is not None or back_need is not None:
|
|
return False
|
|
else:
|
|
if do is True:
|
|
self.schedules.append(schedule)
|
|
self.schedules = sorted(self.schedules, key=lambda need: need.start)
|
|
self.durations_cache[int(schedule.duration.total_seconds())] = cache_index
|
|
return True
|
|
|
|
def get_earliest_available_free_times(self, duration: timedelta) -> datetime:
|
|
|
|
# 没有已分配任务
|
|
if len(self.schedules) == 0:
|
|
return self.start_time
|
|
|
|
# 只有一个已分配任务
|
|
if len(self.schedules) == 1:
|
|
target_schedule = self.schedules[0]
|
|
if self.start_time < target_schedule.start:
|
|
if target_schedule.start - self.start_time > duration:
|
|
# 如果工作时间加起来小于8小时
|
|
if (target_schedule.duration + duration).total_seconds() < 8 * 3600:
|
|
return target_schedule.start - duration
|
|
else:
|
|
# 延后16小时
|
|
return target_schedule.end + timedelta(hours=16)
|
|
|
|
else:
|
|
if (target_schedule.duration + duration).total_seconds() < 8 * 3600:
|
|
return target_schedule.end
|
|
else:
|
|
# 延后16小时
|
|
return target_schedule.end + timedelta(hours=16)
|
|
|
|
cache_index: int = 0
|
|
if int(duration.total_seconds()) in self.durations_cache.keys():
|
|
cache_index = self.durations_cache[int(duration.total_seconds())]
|
|
# print("CACHE HIT:", cache_index,
|
|
# "DURATION:", int(duration.total_seconds()))
|
|
|
|
# 正常执行
|
|
for i in range(cache_index, len(self.schedules) - 2):
|
|
pre_schedule = self.schedules[i]
|
|
back_schedule = self.schedules[i + 1]
|
|
|
|
if back_schedule.start - pre_schedule.end > duration:
|
|
|
|
# 统计开始前24小时工作时间
|
|
work_time_statistical_start = pre_schedule.end - timedelta(hours=24)
|
|
work_time_statistical: int = 0
|
|
|
|
for schedule in self.schedules:
|
|
|
|
if schedule.start < work_time_statistical_start:
|
|
continue
|
|
|
|
if schedule.start > pre_schedule.end:
|
|
break
|
|
|
|
if schedule.start > work_time_statistical_start \
|
|
and schedule.end <= pre_schedule.end:
|
|
work_time_statistical += schedule.duration.total_seconds()
|
|
|
|
if work_time_statistical + duration.total_seconds() < 8 * 3600:
|
|
return pre_schedule.end
|
|
else:
|
|
continue
|
|
|
|
# 统计开始前24小时工作时间
|
|
work_time_statistical_start = self.schedules[-1].end - timedelta(hours=24)
|
|
work_time_statistical: int = 0
|
|
|
|
for schedule in self.schedules:
|
|
|
|
if schedule.start < work_time_statistical_start:
|
|
continue
|
|
|
|
if schedule.start > self.schedules[-1].end:
|
|
break
|
|
|
|
if schedule.start > work_time_statistical_start:
|
|
work_time_statistical += schedule.duration.total_seconds()
|
|
if work_time_statistical + duration.total_seconds() < 8 * 3600:
|
|
return self.schedules[-1].end
|
|
else:
|
|
return self.schedules[-1].end + timedelta(hours=16)
|
|
|
|
|
|
class RuntimeResourcePool:
|
|
|
|
def __init__(self, resources: List[model.Resource], start_time: datetime):
|
|
self.pools: Dict[int, Dict[str, RuntimeResource]] = {}
|
|
self.start_time: datetime = start_time
|
|
|
|
for resource in resources:
|
|
runtime_resource = RuntimeResource(resource, self.start_time)
|
|
if hash(runtime_resource.workspace) not in self.pools.keys():
|
|
self.pools[hash(runtime_resource.workspace)] = {}
|
|
self.pools[hash(runtime_resource.workspace)][runtime_resource.resource.rsc_id] = runtime_resource
|
|
|
|
def try_alloc_resource(self, resource_needs: List[RuntimeResourceNeed]) -> bool:
|
|
|
|
# 已经满足的需求
|
|
fulfilled_needs = []
|
|
|
|
if_all_alloc = True
|
|
|
|
for resource_need in resource_needs:
|
|
|
|
if resource_need.could_alloc is True:
|
|
continue
|
|
|
|
# 查找相同车间的资源
|
|
temp_pool = list(self.pools[hash(resource_need.workspace)].values())
|
|
|
|
# 精确搜索
|
|
for runtime_resource in temp_pool:
|
|
if runtime_resource.basic_attr == resource_need.resource_attr:
|
|
if runtime_resource.add_schedule(resource_need, True) is True:
|
|
resource_need.add_plan_alloc_resource(runtime_resource.resource.rsc_id)
|
|
fulfilled_needs.append(resource_need)
|
|
resource_need.could_alloc = True
|
|
break
|
|
|
|
# 是否已经分配完成
|
|
if resource_need.could_alloc is False:
|
|
# 放宽条件搜索
|
|
for runtime_resource in temp_pool:
|
|
# 排除不同车间
|
|
if runtime_resource.workspace != resource_need.workspace:
|
|
continue
|
|
if resource_need.resource_attr in runtime_resource.resource_attrs:
|
|
if runtime_resource.add_schedule(resource_need, True) is True:
|
|
resource_need.add_plan_alloc_resource(runtime_resource.resource.rsc_id)
|
|
fulfilled_needs.append(resource_need)
|
|
resource_need.could_alloc = True
|
|
break
|
|
|
|
if resource_need not in fulfilled_needs:
|
|
if_all_alloc = False
|
|
|
|
return if_all_alloc
|
|
|
|
def reset_earliest_free_start_time(self, resource_needs: List[RuntimeResourceNeed]) -> bool:
|
|
|
|
if_found = False
|
|
|
|
for resource_need in resource_needs:
|
|
|
|
if resource_need.could_alloc is True:
|
|
continue
|
|
|
|
earliest_time: Optional[datetime] = None
|
|
|
|
duration = resource_need.end - resource_need.start
|
|
|
|
# 查找相同车间的资源
|
|
temp_pool = list(self.pools[hash(resource_need.workspace)].values())
|
|
|
|
# 精确搜索
|
|
for runtime_resource in temp_pool:
|
|
if runtime_resource.basic_attr == resource_need.resource_attr:
|
|
temp_earliest_time = runtime_resource.get_earliest_available_free_times(duration)
|
|
# 时间不能超过DDL
|
|
if temp_earliest_time > resource_need.ddl - duration:
|
|
continue
|
|
if earliest_time is None or earliest_time > temp_earliest_time:
|
|
earliest_time = temp_earliest_time
|
|
|
|
# 优先利用对口资源
|
|
if earliest_time is not None:
|
|
resource_need.start = earliest_time
|
|
# 放宽条件搜索
|
|
else:
|
|
for runtime_resource in temp_pool:
|
|
|
|
if resource_need.resource_attr in runtime_resource.resource_attrs:
|
|
temp_earliest_time = runtime_resource.get_earliest_available_free_times(duration)
|
|
# 时间不能超过DDL
|
|
if temp_earliest_time > resource_need.ddl - duration:
|
|
continue
|
|
if earliest_time is None or earliest_time > temp_earliest_time:
|
|
earliest_time = temp_earliest_time
|
|
|
|
if earliest_time is None:
|
|
if_found = False
|
|
else:
|
|
resource_need.start = earliest_time
|
|
resource_need.end = earliest_time + duration
|
|
if_found = True
|
|
|
|
return if_found
|