790 lines
28 KiB
Python
790 lines
28 KiB
Python
from __future__ import annotations
|
||
|
||
from collections import Counter, defaultdict
|
||
from copy import deepcopy
|
||
from datetime import date, datetime, timedelta
|
||
from statistics import pstdev
|
||
from typing import Any
|
||
|
||
from .config import GeneratorConfig
|
||
from .constraints import validate_schedule_constraints
|
||
from .models import DatasetBundle, stable_id
|
||
|
||
ALTERNATIVE_MODES = (
|
||
(
|
||
"DELIVERY_FIRST",
|
||
"Delivery First",
|
||
{
|
||
"delivery": 0.45,
|
||
"resource": 0.15,
|
||
"cost": 0.10,
|
||
"overtime": 0.10,
|
||
"dock": 0.10,
|
||
"risk": 0.10,
|
||
},
|
||
),
|
||
(
|
||
"RESOURCE_BALANCED",
|
||
"Resource Balanced",
|
||
{
|
||
"delivery": 0.20,
|
||
"resource": 0.40,
|
||
"cost": 0.10,
|
||
"overtime": 0.10,
|
||
"dock": 0.10,
|
||
"risk": 0.10,
|
||
},
|
||
),
|
||
(
|
||
"COST_FIRST",
|
||
"Cost First",
|
||
{
|
||
"delivery": 0.15,
|
||
"resource": 0.10,
|
||
"cost": 0.45,
|
||
"overtime": 0.10,
|
||
"dock": 0.10,
|
||
"risk": 0.10,
|
||
},
|
||
),
|
||
(
|
||
"MIN_OVERTIME",
|
||
"Minimum Overtime",
|
||
{
|
||
"delivery": 0.15,
|
||
"resource": 0.15,
|
||
"cost": 0.10,
|
||
"overtime": 0.40,
|
||
"dock": 0.10,
|
||
"risk": 0.10,
|
||
},
|
||
),
|
||
(
|
||
"DOCK_UTILIZATION",
|
||
"Dock Utilization First",
|
||
{
|
||
"delivery": 0.15,
|
||
"resource": 0.10,
|
||
"cost": 0.10,
|
||
"overtime": 0.10,
|
||
"dock": 0.45,
|
||
"risk": 0.10,
|
||
},
|
||
),
|
||
(
|
||
"MIN_RISK",
|
||
"Minimum Risk",
|
||
{
|
||
"delivery": 0.15,
|
||
"resource": 0.10,
|
||
"cost": 0.10,
|
||
"overtime": 0.10,
|
||
"dock": 0.10,
|
||
"risk": 0.45,
|
||
},
|
||
),
|
||
(
|
||
"RECOMMENDED",
|
||
"Recommended",
|
||
{
|
||
"delivery": 0.25,
|
||
"resource": 0.15,
|
||
"cost": 0.15,
|
||
"overtime": 0.10,
|
||
"dock": 0.15,
|
||
"risk": 0.20,
|
||
},
|
||
),
|
||
)
|
||
|
||
_COMPARE_FIELDS = ("start", "end", "resourceId", "teamId")
|
||
_SLOT_VIEW_FIELDS = (
|
||
"scheduleSlotId",
|
||
"scheduleVersionId",
|
||
"scenarioId",
|
||
"operationId",
|
||
"workOrderId",
|
||
"productionOrderId",
|
||
"projectId",
|
||
"wbsId",
|
||
"resourceId",
|
||
"teamId",
|
||
"start",
|
||
"end",
|
||
"durationHours",
|
||
"timeFence",
|
||
"baselineStart",
|
||
)
|
||
|
||
|
||
def _as_datetime(value: Any) -> datetime:
|
||
return datetime.fromisoformat(str(value))
|
||
|
||
|
||
def _as_date(value: Any) -> date:
|
||
text = str(value)
|
||
return datetime.fromisoformat(text).date() if "T" in text else date.fromisoformat(text)
|
||
|
||
|
||
def _slot_view(slot: dict[str, Any]) -> dict[str, Any]:
|
||
return {field: slot.get(field) for field in _SLOT_VIEW_FIELDS}
|
||
|
||
|
||
def _slot_deltas(
|
||
baseline_slots: list[dict[str, Any]],
|
||
candidate_slots: list[dict[str, Any]],
|
||
) -> list[dict[str, Any]]:
|
||
baseline_by_operation = {
|
||
str(row["operationId"]): row for row in baseline_slots
|
||
}
|
||
deltas: list[dict[str, Any]] = []
|
||
for candidate in candidate_slots:
|
||
operation_id = str(candidate["operationId"])
|
||
baseline = baseline_by_operation[operation_id]
|
||
changed_fields = [
|
||
field
|
||
for field in _COMPARE_FIELDS
|
||
if baseline.get(field) != candidate.get(field)
|
||
]
|
||
if not changed_fields:
|
||
continue
|
||
deltas.append(
|
||
{
|
||
"operationId": operation_id,
|
||
"baselineScheduleSlotId": baseline.get("scheduleSlotId"),
|
||
"alternativeScheduleSlotId": candidate.get("scheduleSlotId"),
|
||
"changedFields": changed_fields,
|
||
"before": _slot_view(baseline),
|
||
"after": _slot_view(candidate),
|
||
}
|
||
)
|
||
return sorted(deltas, key=lambda row: row["operationId"])
|
||
|
||
|
||
def _eligible_order_ids(
|
||
bundle: DatasetBundle,
|
||
config: GeneratorConfig,
|
||
) -> list[str]:
|
||
slots_by_operation = {
|
||
str(row["operationId"]): row for row in bundle.rows("schedule-slots")
|
||
}
|
||
operations_by_order: dict[str, list[dict[str, Any]]] = defaultdict(list)
|
||
for operation in bundle.rows("operations"):
|
||
if operation.get("active", True):
|
||
operations_by_order[str(operation["productionOrderId"])].append(operation)
|
||
|
||
latest_safe_end = datetime.combine(
|
||
config.planning_horizon_end - timedelta(days=2),
|
||
datetime.min.time(),
|
||
tzinfo=_as_datetime(bundle.rows("schedule-slots")[0]["start"]).tzinfo,
|
||
)
|
||
candidates: list[tuple[datetime, str]] = []
|
||
for order_id, operations in operations_by_order.items():
|
||
order_slots = [
|
||
slots_by_operation[str(operation["operationId"])]
|
||
for operation in operations
|
||
]
|
||
if any(slot.get("timeFence") == "FROZEN" for slot in order_slots):
|
||
continue
|
||
order_end = max(_as_datetime(slot["end"]) for slot in order_slots)
|
||
if order_end >= latest_safe_end:
|
||
continue
|
||
candidates.append((order_end, order_id))
|
||
return [order_id for _, order_id in sorted(candidates)]
|
||
|
||
|
||
def _has_overlap(
|
||
slots: list[dict[str, Any]],
|
||
owner_field: str,
|
||
owner_id: str,
|
||
start: datetime,
|
||
end: datetime,
|
||
ignored_operation_id: str,
|
||
) -> bool:
|
||
for row in slots:
|
||
if str(row.get(owner_field)) != owner_id:
|
||
continue
|
||
if str(row.get("operationId")) == ignored_operation_id:
|
||
continue
|
||
other_start = _as_datetime(row["start"])
|
||
other_end = _as_datetime(row["end"])
|
||
if start < other_end and other_start < end:
|
||
return True
|
||
return False
|
||
|
||
|
||
def _apply_safe_assignment_variation(
|
||
bundle: DatasetBundle,
|
||
slots: list[dict[str, Any]],
|
||
variant_index: int,
|
||
excluded_operation_ids: set[str] | None = None,
|
||
) -> dict[str, Any]:
|
||
"""Apply one deterministic, capacity-safe owner change at unchanged dates."""
|
||
operations = {
|
||
str(row["operationId"]): row for row in bundle.rows("operations")
|
||
}
|
||
resources = {
|
||
str(row["resourceId"]): row for row in bundle.rows("resources")
|
||
}
|
||
teams = {str(row["teamId"]): row for row in bundle.rows("teams")}
|
||
employees_by_team: dict[str, list[dict[str, Any]]] = defaultdict(list)
|
||
for employee in bundle.rows("employees"):
|
||
employees_by_team[str(employee.get("teamId") or "")].append(employee)
|
||
|
||
resource_intervals: dict[str, list[tuple[datetime, datetime]]] = defaultdict(list)
|
||
team_intervals: dict[str, list[tuple[datetime, datetime]]] = defaultdict(list)
|
||
for row in slots:
|
||
interval = (_as_datetime(row["start"]), _as_datetime(row["end"]))
|
||
resource_intervals[str(row.get("resourceId"))].append(interval)
|
||
team_intervals[str(row.get("teamId"))].append(interval)
|
||
for timeline in resource_intervals.values():
|
||
timeline.sort()
|
||
for timeline in team_intervals.values():
|
||
timeline.sort()
|
||
|
||
def owner_is_free(
|
||
timeline: list[tuple[datetime, datetime]],
|
||
start: datetime,
|
||
end: datetime,
|
||
) -> bool:
|
||
for other_start, other_end in timeline:
|
||
if other_start >= end:
|
||
break
|
||
if start < other_end and other_start < end:
|
||
return False
|
||
return True
|
||
|
||
def valid_qualifications(team_id: str, at: date) -> set[str]:
|
||
values: set[str] = set()
|
||
for employee in employees_by_team.get(team_id, []):
|
||
qualification = employee.get("qualificationCode")
|
||
if not qualification:
|
||
continue
|
||
valid_to = employee.get("qualificationValidTo")
|
||
if valid_to and _as_date(valid_to) < at:
|
||
continue
|
||
values.add(str(qualification))
|
||
return values
|
||
|
||
def resource_limit(resource: dict[str, Any], *keys: str) -> float | None:
|
||
for key in keys:
|
||
value = resource.get(key)
|
||
if value not in (None, ""):
|
||
return float(value)
|
||
return None
|
||
|
||
def resource_supports(
|
||
resource: dict[str, Any],
|
||
operation: dict[str, Any],
|
||
original: dict[str, Any],
|
||
start: datetime,
|
||
end: datetime,
|
||
) -> bool:
|
||
required_type = str(operation.get("requiredResourceType") or "")
|
||
if str(resource.get("resourceType") or "") != required_type:
|
||
return False
|
||
if resource.get("status", "ACTIVE") != "ACTIVE":
|
||
return False
|
||
if resource.get("shiftCalendarId") != original.get("shiftCalendarId"):
|
||
return False
|
||
required_group = operation.get("requiredResourceGroup")
|
||
if required_group and str(resource.get("resourceGroupId") or "") != str(required_group):
|
||
return False
|
||
if operation.get("transportWindowStatus") == "OPEN" and str(
|
||
resource.get("transportZone") or ""
|
||
) != str(operation.get("transportZone") or ""):
|
||
return False
|
||
required_tags = {
|
||
str(value) for value in operation.get("requiredCapabilityTags") or []
|
||
}
|
||
resource_tags = {
|
||
str(value) for value in resource.get("capabilityTags") or []
|
||
} | {required_type, "FINITE_CAPACITY"}
|
||
if not required_tags.issubset(resource_tags):
|
||
return False
|
||
dimension_checks = (
|
||
("requiredWeightT", ("maximumWeight", "maximumWeightT")),
|
||
("requiredLengthM", ("maximumLength", "maximumLengthM")),
|
||
("requiredWidthM", ("maximumWidth", "maximumWidthM")),
|
||
("requiredHeightM", ("maximumHeight", "maximumHeightM")),
|
||
("requiredLiftRadiusM", ("maximumLiftRadiusM", "maximumLiftRadius")),
|
||
)
|
||
for requirement_key, limit_keys in dimension_checks:
|
||
required_value = operation.get(requirement_key)
|
||
if required_value in (None, ""):
|
||
continue
|
||
limit = resource_limit(resource, *limit_keys)
|
||
if limit is None or float(required_value) > limit + 1e-9:
|
||
return False
|
||
blackouts = {
|
||
str(value)[:10] for value in resource.get("maintenanceBlackoutDates") or []
|
||
}
|
||
cursor = start.date()
|
||
while cursor <= end.date():
|
||
if cursor.isoformat() in blackouts:
|
||
return False
|
||
cursor += timedelta(days=1)
|
||
return True
|
||
|
||
excluded = excluded_operation_ids or set()
|
||
eligible_slots = sorted(
|
||
(
|
||
row
|
||
for row in slots
|
||
if row.get("timeFence") in {"FREE", "STRATEGIC"}
|
||
and str(row.get("operationId")) not in excluded
|
||
),
|
||
key=lambda row: (str(row.get("start")), str(row.get("operationId"))),
|
||
)
|
||
if not eligible_slots:
|
||
raise RuntimeError("no FREE or STRATEGIC slot is available for assignment repair")
|
||
|
||
start_offset = (variant_index * 104729) % len(eligible_slots)
|
||
for scan_index in range(len(eligible_slots)):
|
||
slot = eligible_slots[(start_offset + scan_index) % len(eligible_slots)]
|
||
operation_id = str(slot["operationId"])
|
||
operation = operations[operation_id]
|
||
start = _as_datetime(slot["start"])
|
||
end = _as_datetime(slot["end"])
|
||
original_resource_id = str(slot.get("resourceId"))
|
||
original_team_id = str(slot.get("teamId"))
|
||
original_resource = resources[original_resource_id]
|
||
original_team = teams[original_team_id]
|
||
|
||
changed_fields: list[str] = []
|
||
resource_candidates = [
|
||
row
|
||
for resource_id, row in resources.items()
|
||
if resource_id != original_resource_id
|
||
and resource_supports(row, operation, original_resource, start, end)
|
||
and owner_is_free(resource_intervals.get(resource_id, []), start, end)
|
||
]
|
||
resource_candidates.sort(key=lambda row: str(row["resourceId"]))
|
||
if resource_candidates:
|
||
selected = resource_candidates[
|
||
(variant_index + scan_index) % len(resource_candidates)
|
||
]
|
||
slot["resourceId"] = str(selected["resourceId"])
|
||
changed_fields.append("resourceId")
|
||
|
||
required_skills = {
|
||
str(value) for value in operation.get("requiredSkillCodes") or []
|
||
}
|
||
required_qualifications = {
|
||
str(value)
|
||
for value in operation.get("requiredQualificationCodes") or []
|
||
}
|
||
team_candidates = [
|
||
row
|
||
for team_id, row in teams.items()
|
||
if team_id != original_team_id
|
||
and row.get("status", "ACTIVE") == "ACTIVE"
|
||
and row.get("shiftCalendarId") == original_team.get("shiftCalendarId")
|
||
and required_skills.issubset(
|
||
{str(value) for value in row.get("skillCodes") or []}
|
||
)
|
||
and int(row.get("crewSize") or 0)
|
||
>= int(operation.get("crewSize") or 1)
|
||
and required_qualifications.issubset(
|
||
valid_qualifications(team_id, start.date())
|
||
)
|
||
and owner_is_free(team_intervals.get(team_id, []), start, end)
|
||
]
|
||
team_candidates.sort(key=lambda row: str(row["teamId"]))
|
||
if team_candidates:
|
||
selected = team_candidates[
|
||
(variant_index * 3 + scan_index) % len(team_candidates)
|
||
]
|
||
slot["teamId"] = str(selected["teamId"])
|
||
changed_fields.append("teamId")
|
||
|
||
if not changed_fields:
|
||
continue
|
||
slot["explanation"] = (
|
||
f"方案局部修复在{slot.get('timeFence')}区保持开始/结束时间不变，"
|
||
f"将资源从{original_resource_id}调整为{slot.get('resourceId')}，"
|
||
f"将班组从{original_team_id}调整为{slot.get('teamId')}。"
|
||
)
|
||
slot["evidenceRefs"] = [
|
||
f"operation:{operation_id}",
|
||
f"resource:{slot.get('resourceId')}",
|
||
f"team:{slot.get('teamId')}",
|
||
f"baseline-slot:{slot.get('scheduleSlotId')}",
|
||
]
|
||
return {
|
||
"operationId": operation_id,
|
||
"productionOrderId": slot.get("productionOrderId"),
|
||
"timeFence": slot.get("timeFence"),
|
||
"changedFields": changed_fields,
|
||
"originalResourceId": original_resource_id,
|
||
"resourceId": slot.get("resourceId"),
|
||
"originalTeamId": original_team_id,
|
||
"teamId": slot.get("teamId"),
|
||
}
|
||
raise RuntimeError("no compatible free resource or team assignment was found")
|
||
|
||
|
||
def _normalise_variant_slots(
|
||
bundle: DatasetBundle,
|
||
generated_slots: list[dict[str, Any]],
|
||
schedule_version_id: str,
|
||
scenario_id: str,
|
||
) -> list[dict[str, Any]]:
|
||
baseline_by_operation = {
|
||
str(row["operationId"]): row for row in bundle.rows("schedule-slots")
|
||
}
|
||
normalized: list[dict[str, Any]] = []
|
||
for generated in generated_slots:
|
||
row = deepcopy(generated)
|
||
operation_id = str(row["operationId"])
|
||
baseline = baseline_by_operation[operation_id]
|
||
row["scheduleVersionId"] = schedule_version_id
|
||
row["scenarioId"] = scenario_id
|
||
row["scheduleSlotId"] = stable_id(
|
||
"schedule-slot",
|
||
schedule_version_id,
|
||
operation_id,
|
||
prefix="SLOT",
|
||
)
|
||
row["baselineStart"] = baseline.get("start")
|
||
row["changeAuthorized"] = False
|
||
row["materialReadyAt"] = baseline.get("materialReadyAt")
|
||
row["holdReleaseAt"] = baseline.get("holdReleaseAt")
|
||
row["explanation"] = (
|
||
f"Alternative {scenario_id} keeps valid precedence and time windows, "
|
||
f"using resource {row.get('resourceId')} and team {row.get('teamId')}. "
|
||
"The change passed finite-capacity, skill, maintenance, transport and freeze checks."
|
||
)
|
||
row["evidenceRefs"] = [
|
||
f"operation:{operation_id}",
|
||
f"resource:{row.get('resourceId')}",
|
||
f"team:{row.get('teamId')}",
|
||
f"baseline-slot:{baseline.get('scheduleSlotId')}",
|
||
]
|
||
normalized.append(row)
|
||
return normalized
|
||
|
||
|
||
def _calculate_kpis(
|
||
bundle: DatasetBundle,
|
||
candidate_slots: list[dict[str, Any]],
|
||
deltas: list[dict[str, Any]],
|
||
) -> dict[str, float]:
|
||
operations = {
|
||
str(row["operationId"]): row for row in bundle.rows("operations")
|
||
}
|
||
resources = {
|
||
str(row["resourceId"]): row for row in bundle.rows("resources")
|
||
}
|
||
on_time = 0
|
||
resource_loads: dict[str, float] = defaultdict(float)
|
||
overtime_hours = 0.0
|
||
dock_slots: list[dict[str, Any]] = []
|
||
for slot in candidate_slots:
|
||
operation = operations[str(slot["operationId"])]
|
||
end = _as_datetime(slot["end"])
|
||
need_date = date.fromisoformat(str(operation.get("needDate")))
|
||
on_time += end.date() <= need_date
|
||
duration = float(slot.get("durationHours") or 0.0)
|
||
resource_id = str(slot.get("resourceId"))
|
||
resource_loads[resource_id] += duration
|
||
start = _as_datetime(slot["start"])
|
||
if start.hour < 6 or end.hour > 22:
|
||
overtime_hours += duration
|
||
if str(resources.get(resource_id, {}).get("resourceType")) == "DOCK":
|
||
dock_slots.append(slot)
|
||
|
||
loads = list(resource_loads.values())
|
||
mean_load = sum(loads) / max(1, len(loads))
|
||
dispersion = pstdev(loads) / mean_load if len(loads) > 1 and mean_load else 0.0
|
||
resource_score = max(0.0, 100.0 * (1.0 - min(1.0, dispersion)))
|
||
total_hours = sum(loads)
|
||
changed_ratio = len(deltas) / max(1, len(candidate_slots))
|
||
shift_hours = sum(
|
||
abs(
|
||
(
|
||
_as_datetime(delta["after"]["start"])
|
||
- _as_datetime(delta["before"]["start"])
|
||
).total_seconds()
|
||
)
|
||
/ 3600
|
||
for delta in deltas
|
||
)
|
||
cost_score = max(
|
||
0.0,
|
||
100.0
|
||
- changed_ratio * 35.0
|
||
- min(25.0, shift_hours / max(1.0, total_hours) * 100.0),
|
||
)
|
||
overtime_score = max(
|
||
0.0,
|
||
100.0 - overtime_hours / max(1.0, total_hours) * 100.0,
|
||
)
|
||
if dock_slots:
|
||
dock_start = min(_as_datetime(row["start"]) for row in dock_slots)
|
||
dock_end = max(_as_datetime(row["end"]) for row in dock_slots)
|
||
dock_used = sum(float(row.get("durationHours") or 0.0) for row in dock_slots)
|
||
dock_span = max(1.0, (dock_end - dock_start).total_seconds() / 3600)
|
||
dock_score = min(100.0, dock_used / dock_span * 100.0)
|
||
else:
|
||
dock_score = 100.0
|
||
high_risk = sum(
|
||
row.get("severity") in {"HIGH", "CRITICAL"}
|
||
for row in bundle.rows("conflicts")
|
||
)
|
||
risk_score = max(
|
||
0.0,
|
||
100.0 - high_risk / max(1, len(bundle.rows("conflicts"))) * 100.0,
|
||
)
|
||
return {
|
||
"delivery": round(on_time / max(1, len(candidate_slots)) * 100.0, 4),
|
||
"resource": round(resource_score, 4),
|
||
"cost": round(cost_score, 4),
|
||
"overtime": round(overtime_score, 4),
|
||
"dock": round(dock_score, 4),
|
||
"risk": round(risk_score, 4),
|
||
}
|
||
|
||
|
||
def _build_schedule_variant(
|
||
bundle: DatasetBundle,
|
||
config: GeneratorConfig,
|
||
variant_key: str,
|
||
variant_index: int,
|
||
excluded_operation_ids: set[str] | None = None,
|
||
) -> dict[str, Any]:
|
||
"""Build one deterministic O(n) schedule patch with a local safety proof."""
|
||
baseline_slots = bundle.rows("schedule-slots")
|
||
schedule_version_id = stable_id(
|
||
"schedule-version",
|
||
"variant",
|
||
variant_key,
|
||
config.seed,
|
||
config.scale,
|
||
prefix="SCHV",
|
||
)
|
||
candidate_slots = _normalise_variant_slots(
|
||
bundle,
|
||
baseline_slots,
|
||
schedule_version_id,
|
||
variant_key,
|
||
)
|
||
assignment = _apply_safe_assignment_variation(
|
||
bundle,
|
||
candidate_slots,
|
||
variant_index,
|
||
excluded_operation_ids,
|
||
)
|
||
deltas = _slot_deltas(baseline_slots, candidate_slots)
|
||
if len(deltas) != 1:
|
||
raise RuntimeError(
|
||
f"variant {variant_key} must change exactly one slot, found {len(deltas)}"
|
||
)
|
||
if deltas[0]["before"].get("timeFence") not in {"FREE", "STRATEGIC"}:
|
||
raise RuntimeError(
|
||
f"variant {variant_key} touched a protected time fence"
|
||
)
|
||
changed_field_counts = Counter(deltas[0]["changedFields"])
|
||
local_validation = {
|
||
"valid": True,
|
||
"solveStatus": "FEASIBLE",
|
||
"validationMode": "DELTA_SAFETY_PROOF",
|
||
"checkCount": 1,
|
||
"hardViolationCount": 0,
|
||
"unmarkedHardViolationCount": 0,
|
||
"blockingIssues": [],
|
||
"checks": {
|
||
"changedSlotCount": 1,
|
||
"timeUnchanged": True,
|
||
"precedenceUnchanged": True,
|
||
"materialReadinessUnchanged": True,
|
||
"qualityAndWeatherWindowsUnchanged": True,
|
||
"compatibleResourceOrTeam": True,
|
||
"targetOwnerFreeAtInterval": True,
|
||
"timeFence": assignment["timeFence"],
|
||
},
|
||
}
|
||
return {
|
||
"scheduleVersionId": schedule_version_id,
|
||
"scenarioId": variant_key,
|
||
"solveStatus": "FEASIBLE",
|
||
"targetProductionOrderId": assignment["productionOrderId"],
|
||
"targetOperationId": assignment["operationId"],
|
||
"delayedOperationIds": [],
|
||
"planningAdjustment": {
|
||
"type": "COMPATIBLE_OWNER_SWAP",
|
||
"days": 0,
|
||
"reason": (
|
||
"在FREE或STRATEGIC区保持工序时间不变，仅替换空闲且兼容的"
|
||
"有限资源和/或班组，避免全量重排。"
|
||
),
|
||
"assignment": assignment,
|
||
},
|
||
"scheduleSlots": candidate_slots,
|
||
"slotDeltas": deltas,
|
||
"changedSlotCount": 1,
|
||
"changedFields": sorted(changed_field_counts),
|
||
"changedFieldCounts": dict(sorted(changed_field_counts.items())),
|
||
"constraintValidation": local_validation,
|
||
"normalizedKpis": _calculate_kpis(bundle, candidate_slots, deltas),
|
||
}
|
||
|
||
|
||
def generate_alternatives(
|
||
bundle: DatasetBundle,
|
||
config: GeneratorConfig,
|
||
) -> DatasetBundle:
|
||
baseline_version = (bundle.rows("schedule-versions") or [{}])[0]
|
||
baseline_slots = bundle.rows("schedule-slots")
|
||
alternatives: list[dict[str, Any]] = []
|
||
used_operation_ids: set[str] = set()
|
||
for index, (mode, name, weights) in enumerate(ALTERNATIVE_MODES, 1):
|
||
variant = _build_schedule_variant(
|
||
bundle,
|
||
config,
|
||
mode,
|
||
index,
|
||
used_operation_ids,
|
||
)
|
||
used_operation_ids.add(str(variant["targetOperationId"]))
|
||
normalized = variant["normalizedKpis"]
|
||
score = round(
|
||
sum(normalized[key] * weight for key, weight in weights.items()),
|
||
4,
|
||
)
|
||
validation = variant["constraintValidation"]
|
||
alternatives.append(
|
||
{
|
||
"alternativeId": stable_id(
|
||
"alternative",
|
||
mode,
|
||
config.seed,
|
||
prefix="ALT",
|
||
),
|
||
"mode": mode,
|
||
"name": name,
|
||
"baseScheduleVersionId": baseline_version.get("scheduleVersionId"),
|
||
"scheduleVersionId": variant["scheduleVersionId"],
|
||
"scheduleVersion": {
|
||
"scheduleVersionId": variant["scheduleVersionId"],
|
||
"baseScheduleVersionId": baseline_version.get(
|
||
"scheduleVersionId"
|
||
),
|
||
"versionNo": f"ALT-{index:03d}",
|
||
"scenarioId": mode,
|
||
"immutable": True,
|
||
"slotInheritance": "PATCH_OVER_BASELINE",
|
||
},
|
||
"algorithm": "DETERMINISTIC_COMPATIBLE_OWNER_SWAP",
|
||
"algorithmVersion": "3.0.0",
|
||
"solveStatus": validation["solveStatus"],
|
||
"optimalityGap": None,
|
||
"gapType": "NOT_APPLICABLE",
|
||
"normalization": {
|
||
"range": [0, 100],
|
||
"higherIsBetter": True,
|
||
"source": "ACTUAL_REPAIRED_SCHEDULE",
|
||
},
|
||
"weights": weights,
|
||
"normalizedKpis": normalized,
|
||
"score": score,
|
||
"hardConstraintViolations": 0,
|
||
"unmarkedHardViolationCount": 0,
|
||
"constraintCheckCount": validation["checkCount"],
|
||
"softConstraintCost": round(100 - score, 4),
|
||
"fallbackReason": None,
|
||
"targetProductionOrderId": variant[
|
||
"targetProductionOrderId"
|
||
],
|
||
"targetOperationId": variant["targetOperationId"],
|
||
"planningAdjustment": variant["planningAdjustment"],
|
||
"changedSlotCount": 1,
|
||
"unchangedSlotCount": len(baseline_slots) - 1,
|
||
"changedFields": variant["changedFields"],
|
||
"changedFieldCounts": variant["changedFieldCounts"],
|
||
"slotDeltas": variant["slotDeltas"],
|
||
"alternativeSlots": [variant["slotDeltas"][0]["after"]],
|
||
"constraintValidation": validation,
|
||
"evidenceRefs": [
|
||
"skill:ship-scenario-simulation",
|
||
"KNO-SYN-19-001",
|
||
],
|
||
}
|
||
)
|
||
|
||
combined_version_id = stable_id(
|
||
"schedule-version",
|
||
"alternative-batch-proof",
|
||
config.seed,
|
||
config.scale,
|
||
prefix="SCHV",
|
||
)
|
||
combined_slots = _normalise_variant_slots(
|
||
bundle,
|
||
baseline_slots,
|
||
combined_version_id,
|
||
"ALTERNATIVE_BATCH_PROOF",
|
||
)
|
||
combined_by_operation = {
|
||
str(row["operationId"]): row for row in combined_slots
|
||
}
|
||
for alternative in alternatives:
|
||
delta = alternative["slotDeltas"][0]
|
||
target = combined_by_operation[str(delta["operationId"])]
|
||
for field in _COMPARE_FIELDS:
|
||
target[field] = delta["after"].get(field)
|
||
check_tables = dict(bundle.tables)
|
||
check_tables["schedule-slots"] = combined_slots
|
||
check_bundle = DatasetBundle(
|
||
metadata=bundle.metadata,
|
||
tables=check_tables,
|
||
artifacts=bundle.artifacts,
|
||
diagnostics=bundle.diagnostics,
|
||
)
|
||
batch_validation = validate_schedule_constraints(check_bundle, config)
|
||
if not batch_validation["valid"]:
|
||
raise RuntimeError(
|
||
"seven-alternative combined safety proof failed: "
|
||
+ "; ".join(batch_validation["blockingIssues"][:5])
|
||
)
|
||
batch_proof = {
|
||
"valid": True,
|
||
"solveStatus": "FEASIBLE",
|
||
"validationMode": "DELTA_PROOF_PLUS_SINGLE_BATCH_FULL_VALIDATION",
|
||
"checkCount": batch_validation["checkCount"],
|
||
"hardViolationCount": 0,
|
||
"unmarkedHardViolationCount": 0,
|
||
"blockingIssues": [],
|
||
"combinedProofScheduleVersionId": combined_version_id,
|
||
"combinedChangedSlotCount": len(alternatives),
|
||
}
|
||
for alternative in alternatives:
|
||
alternative["constraintValidation"] = deepcopy(batch_proof)
|
||
alternative["constraintCheckCount"] = batch_validation["checkCount"]
|
||
|
||
recommended = next(
|
||
row for row in alternatives if row["mode"] == "RECOMMENDED"
|
||
)
|
||
best = max(alternatives, key=lambda row: (row["score"], row["mode"]))
|
||
recommended["recommended"] = True
|
||
recommended["recommendationRationale"] = (
|
||
"七个独立版本均采用FREE或STRATEGIC区单槽兼容资源/班组替换；"
|
||
"全部差异合并后仅执行一次完整硬约束校验，兼顾真实性与性能。"
|
||
)
|
||
bundle.artifacts["schedule-alternatives"] = {
|
||
"baselineScheduleVersionId": baseline_version.get("scheduleVersionId"),
|
||
"alternativeCount": len(alternatives),
|
||
"independentScheduleVersionCount": len(
|
||
{row["scheduleVersionId"] for row in alternatives}
|
||
),
|
||
"alternatives": alternatives,
|
||
"recommendedAlternativeId": recommended["alternativeId"],
|
||
"highestScoreAlternativeId": best["alternativeId"],
|
||
"allAlternativesRevalidated": True,
|
||
"validationStrategy": "ONE_COMBINED_FULL_VALIDATION",
|
||
"combinedConstraintValidation": batch_proof,
|
||
"totalChangedSlotCount": len(alternatives),
|
||
"maximumAlternativeDelayDays": 0,
|
||
}
|
||
return bundle
|