package com.zy.ai.service.impl;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONObject;
|
import com.zy.ai.domain.autotune.AutoTuneHotPathSegmentItem;
|
import com.zy.ai.domain.autotune.AutoTuneRoutePressureSnapshot;
|
import com.zy.ai.domain.autotune.AutoTuneRoutePressureRuleSnapshot;
|
import com.zy.ai.domain.autotune.AutoTuneStationRuntimeItem;
|
import com.zy.ai.domain.autotune.AutoTuneTargetStationRoutePressureItem;
|
import com.zy.ai.domain.autotune.AutoTuneTaskDetailItem;
|
import com.zy.ai.domain.autotune.AutoTuneTaskRouteSampleItem;
|
import com.zy.ai.domain.autotune.AutoTuneTaskSnapshot;
|
import com.zy.ai.service.RoutePressureSnapshotService;
|
import com.zy.asrs.domain.vo.StationTaskTraceVo;
|
import com.zy.asrs.entity.WrkMast;
|
import com.zy.common.model.NavigateNode;
|
import com.zy.common.utils.NavigateUtils;
|
import com.zy.core.enums.WrkIoType;
|
import com.zy.core.enums.WrkStsType;
|
import com.zy.core.trace.StationTaskTraceRegistry;
|
import com.zy.core.utils.station.StationOutboundDecisionSupport;
|
import com.zy.system.service.ConfigService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.HashSet;
|
import java.util.LinkedHashMap;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Set;
|
|
@Service("routePressureSnapshotService")
|
public class RoutePressureSnapshotServiceImpl implements RoutePressureSnapshotService {
|
|
private static final int MAX_ANALYZED_TASK_COUNT = 50;
|
private static final int DEFAULT_SEGMENT_WINDOW_SIZE = 4;
|
private static final int DEFAULT_MEDIUM_PERCENT = 50;
|
private static final int DEFAULT_HIGH_PERCENT = 75;
|
private static final int DEFAULT_PASS_WEIGHT_PERCENT = 35;
|
private static final int DEFAULT_OCCUPIED_WEIGHT_PERCENT = 25;
|
private static final int DEFAULT_BLOCKED_WEIGHT_PERCENT = 20;
|
private static final int DEFAULT_NON_AUTOING_WEIGHT_PERCENT = 10;
|
private static final int DEFAULT_RUN_BLOCK_WEIGHT_PERCENT = 10;
|
private static final int MAX_HOT_PATH_SEGMENT_COUNT = 10;
|
private static final int MAX_TARGET_MAIN_SEGMENT_COUNT = 3;
|
private static final String CONFIG_SEGMENT_WINDOW_SIZE = "aiAutoTuneRoutePressureSegmentWindowSize";
|
private static final String CONFIG_MEDIUM_PERCENT = "aiAutoTuneRoutePressureMediumPercent";
|
private static final String CONFIG_HIGH_PERCENT = "aiAutoTuneRoutePressureHighPercent";
|
private static final String CONFIG_PASS_WEIGHT_PERCENT = "aiAutoTuneRoutePressurePassWeightPercent";
|
private static final String CONFIG_OCCUPIED_WEIGHT_PERCENT = "aiAutoTuneRoutePressureOccupiedWeightPercent";
|
private static final String CONFIG_BLOCKED_WEIGHT_PERCENT = "aiAutoTuneRoutePressureBlockedWeightPercent";
|
private static final String CONFIG_NON_AUTOING_WEIGHT_PERCENT = "aiAutoTuneRoutePressureNonAutoingWeightPercent";
|
private static final String CONFIG_RUN_BLOCK_WEIGHT_PERCENT = "aiAutoTuneRoutePressureRunBlockWeightPercent";
|
private static final String PATH_SOURCE_TRACE_PENDING = "trace_pending";
|
private static final String PATH_SOURCE_TRACE_ISSUED = "trace_issued";
|
private static final String PATH_SOURCE_ESTIMATED = "estimated";
|
private static final String PATH_SOURCE_MISSING = "missing";
|
private static final String PRESSURE_HIGH = "high";
|
private static final String PRESSURE_MEDIUM = "medium";
|
private static final String PRESSURE_LOW = "low";
|
private static final String DIRECTION_INCREASE_CANDIDATE = "increase_candidate";
|
private static final String DIRECTION_OBSERVE = "observe";
|
private static final String DIRECTION_DECREASE_CANDIDATE = "decrease_candidate";
|
private static final String CONFIDENCE_HIGH = "high";
|
private static final String CONFIDENCE_MEDIUM = "medium";
|
private static final String CONFIDENCE_LOW = "low";
|
|
@Autowired
|
private StationTaskTraceRegistry stationTaskTraceRegistry;
|
|
@Autowired
|
private NavigateUtils navigateUtils;
|
|
@Autowired
|
private StationOutboundDecisionSupport stationOutboundDecisionSupport;
|
|
@Autowired
|
private ConfigService configService;
|
|
@Override
|
public AutoTuneRoutePressureSnapshot buildSnapshot(List<WrkMast> activeTasks,
|
AutoTuneTaskSnapshot taskSnapshot,
|
List<AutoTuneStationRuntimeItem> stationRuntimeSnapshot) {
|
AutoTuneRoutePressureSnapshot snapshot = new AutoTuneRoutePressureSnapshot();
|
AutoTuneRoutePressureRuleSnapshot ruleSnapshot = buildRoutePressureRuleSnapshot();
|
List<WrkMast> selectedTasks = selectTasksForAnalysis(activeTasks, taskSnapshot);
|
Map<Integer, StationTaskTraceVo> traceMap = buildTraceMap();
|
Map<String, EstimatedPathResult> estimatedPathCache = new LinkedHashMap<>();
|
List<AutoTuneTaskRouteSampleItem> routeSamples = new ArrayList<>();
|
|
for (WrkMast task : selectedTasks) {
|
AutoTuneTaskRouteSampleItem routeSample = buildRouteSample(task, traceMap, estimatedPathCache);
|
routeSamples.add(routeSample);
|
}
|
|
snapshot.setAnalyzedTaskCount(selectedTasks.size());
|
snapshot.setTracePathCount(countByPathSource(routeSamples, PATH_SOURCE_TRACE_PENDING)
|
+ countByPathSource(routeSamples, PATH_SOURCE_TRACE_ISSUED));
|
snapshot.setEstimatedPathCount(countByPathSource(routeSamples, PATH_SOURCE_ESTIMATED));
|
snapshot.setPathErrorCount(countByPathSource(routeSamples, PATH_SOURCE_MISSING));
|
snapshot.setConfidence(snapshotConfidence(snapshot.getAnalyzedTaskCount(), snapshot.getPathErrorCount()));
|
snapshot.setRoutePressureRuleSnapshot(ruleSnapshot);
|
snapshot.setTaskRouteSamples(routeSamples);
|
Map<Integer, AutoTuneStationRuntimeItem> runtimeMap = buildRuntimeMap(stationRuntimeSnapshot);
|
List<AutoTuneHotPathSegmentItem> allHotPathSegments = buildHotPathSegments(
|
routeSamples,
|
runtimeMap,
|
ruleSnapshot
|
);
|
snapshot.setHotPathSegments(topHotPathSegments(allHotPathSegments));
|
snapshot.setTargetStationRoutePressure(buildTargetStationRoutePressure(
|
routeSamples,
|
allHotPathSegments,
|
taskSnapshot,
|
ruleSnapshot
|
));
|
return snapshot;
|
}
|
|
private AutoTuneRoutePressureRuleSnapshot buildRoutePressureRuleSnapshot() {
|
AutoTuneRoutePressureRuleSnapshot snapshot = new AutoTuneRoutePressureRuleSnapshot();
|
snapshot.setSegmentWindowSize(readIntConfig(
|
CONFIG_SEGMENT_WINDOW_SIZE,
|
DEFAULT_SEGMENT_WINDOW_SIZE,
|
2,
|
20
|
));
|
snapshot.setMediumPercent(readIntConfig(CONFIG_MEDIUM_PERCENT, DEFAULT_MEDIUM_PERCENT, 1, 100));
|
snapshot.setHighPercent(readIntConfig(CONFIG_HIGH_PERCENT, DEFAULT_HIGH_PERCENT, 1, 100));
|
if (snapshot.getMediumPercent() > snapshot.getHighPercent()) {
|
snapshot.setMediumPercent(DEFAULT_MEDIUM_PERCENT);
|
snapshot.setHighPercent(DEFAULT_HIGH_PERCENT);
|
}
|
snapshot.setPassWeightPercent(readIntConfig(CONFIG_PASS_WEIGHT_PERCENT, DEFAULT_PASS_WEIGHT_PERCENT, 0, 100));
|
snapshot.setOccupiedWeightPercent(readIntConfig(
|
CONFIG_OCCUPIED_WEIGHT_PERCENT,
|
DEFAULT_OCCUPIED_WEIGHT_PERCENT,
|
0,
|
100
|
));
|
snapshot.setBlockedWeightPercent(readIntConfig(
|
CONFIG_BLOCKED_WEIGHT_PERCENT,
|
DEFAULT_BLOCKED_WEIGHT_PERCENT,
|
0,
|
100
|
));
|
snapshot.setNonAutoingWeightPercent(readIntConfig(
|
CONFIG_NON_AUTOING_WEIGHT_PERCENT,
|
DEFAULT_NON_AUTOING_WEIGHT_PERCENT,
|
0,
|
100
|
));
|
snapshot.setRunBlockWeightPercent(readIntConfig(
|
CONFIG_RUN_BLOCK_WEIGHT_PERCENT,
|
DEFAULT_RUN_BLOCK_WEIGHT_PERCENT,
|
0,
|
100
|
));
|
return snapshot;
|
}
|
|
private int readIntConfig(String code, int defaultValue, int minValue, int maxValue) {
|
if (configService == null) {
|
return defaultValue;
|
}
|
String value = configService.getConfigValue(code, String.valueOf(defaultValue));
|
try {
|
if (value == null || value.trim().isEmpty()) {
|
return defaultValue;
|
}
|
int parsedValue = Integer.parseInt(value.trim());
|
if (parsedValue < minValue || parsedValue > maxValue) {
|
return defaultValue;
|
}
|
return parsedValue;
|
} catch (Exception e) {
|
return defaultValue;
|
}
|
}
|
|
private List<WrkMast> selectTasksForAnalysis(List<WrkMast> activeTasks,
|
AutoTuneTaskSnapshot taskSnapshot) {
|
List<WrkMast> sortedOutboundTasks = sortedOutboundTasks(activeTasks);
|
Set<Integer> blockedWrkNos = collectBlockedWrkNos(taskSnapshot);
|
LinkedHashMap<Integer, WrkMast> selected = new LinkedHashMap<>();
|
|
for (WrkMast task : sortedOutboundTasks) {
|
Integer wrkNo = task.getWrkNo();
|
if (wrkNo != null && blockedWrkNos.contains(wrkNo)) {
|
selected.put(wrkNo, task);
|
}
|
if (selected.size() >= MAX_ANALYZED_TASK_COUNT) {
|
return new ArrayList<>(selected.values());
|
}
|
}
|
|
for (WrkMast task : sortedOutboundTasks) {
|
Integer wrkNo = task.getWrkNo();
|
if (wrkNo != null) {
|
selected.putIfAbsent(wrkNo, task);
|
}
|
if (selected.size() >= MAX_ANALYZED_TASK_COUNT) {
|
break;
|
}
|
}
|
return new ArrayList<>(selected.values());
|
}
|
|
private Set<Integer> collectBlockedWrkNos(AutoTuneTaskSnapshot taskSnapshot) {
|
Set<Integer> blockedWrkNos = new HashSet<>();
|
if (taskSnapshot == null || taskSnapshot.getStationLimitBlockedTasks() == null) {
|
return blockedWrkNos;
|
}
|
for (AutoTuneTaskDetailItem blockedTask : taskSnapshot.getStationLimitBlockedTasks()) {
|
if (blockedTask != null && blockedTask.getWrkNo() != null) {
|
blockedWrkNos.add(blockedTask.getWrkNo());
|
}
|
}
|
return blockedWrkNos;
|
}
|
|
private List<WrkMast> sortedOutboundTasks(List<WrkMast> activeTasks) {
|
List<WrkMast> sortedTasks = new ArrayList<>();
|
if (activeTasks == null) {
|
return sortedTasks;
|
}
|
for (WrkMast task : activeTasks) {
|
if (task != null && Objects.equals(task.getIoType(), WrkIoType.OUT.id)) {
|
sortedTasks.add(task);
|
}
|
}
|
sortedTasks.sort(Comparator
|
.comparing(WrkMast::getBatch, Comparator.nullsLast(String::compareTo))
|
.thenComparing(WrkMast::getBatchSeq, Comparator.nullsLast(Integer::compareTo))
|
.thenComparing(WrkMast::getWrkNo, Comparator.nullsLast(Integer::compareTo)));
|
return sortedTasks;
|
}
|
|
private Map<Integer, StationTaskTraceVo> buildTraceMap() {
|
Map<Integer, StationTaskTraceVo> traceMap = new LinkedHashMap<>();
|
if (stationTaskTraceRegistry == null) {
|
return traceMap;
|
}
|
List<StationTaskTraceVo> traceSnapshots;
|
try {
|
traceSnapshots = stationTaskTraceRegistry.listPlanningActiveTraceSnapshots();
|
} catch (Exception e) {
|
return traceMap;
|
}
|
if (traceSnapshots == null) {
|
return traceMap;
|
}
|
for (StationTaskTraceVo traceSnapshot : traceSnapshots) {
|
if (traceSnapshot != null && traceSnapshot.getTaskNo() != null) {
|
traceMap.putIfAbsent(traceSnapshot.getTaskNo(), traceSnapshot);
|
}
|
}
|
return traceMap;
|
}
|
|
private AutoTuneTaskRouteSampleItem buildRouteSample(WrkMast task,
|
Map<Integer, StationTaskTraceVo> traceMap,
|
Map<String, EstimatedPathResult> estimatedPathCache) {
|
AutoTuneTaskRouteSampleItem item = baseRouteSample(task);
|
if (!isRunningStationTask(task)) {
|
return buildEstimatedRouteSample(item, task, estimatedPathCache);
|
}
|
|
StationTaskTraceVo trace = task == null || task.getWrkNo() == null ? null : traceMap.get(task.getWrkNo());
|
if (trace == null) {
|
return completeRouteSample(item, PATH_SOURCE_MISSING, Collections.emptyList(),
|
"missing station trace for running station task");
|
}
|
|
List<Integer> remainingPath = traceRemainingPath(trace);
|
if (!remainingPath.isEmpty()) {
|
return completeRouteSample(item, PATH_SOURCE_TRACE_PENDING, remainingPath, null);
|
}
|
|
List<Integer> issuedPath = firstNonEmptyDistinct(
|
trace == null ? null : trace.getLatestIssuedSegmentPath(),
|
trace == null ? null : trace.getIssuedStationIds()
|
);
|
if (!issuedPath.isEmpty()) {
|
return completeRouteSample(item, PATH_SOURCE_TRACE_ISSUED, issuedPath, null);
|
}
|
|
return completeRouteSample(item, PATH_SOURCE_MISSING, Collections.emptyList(),
|
"missing usable station trace path for running station task");
|
}
|
|
private List<Integer> traceRemainingPath(StationTaskTraceVo trace) {
|
if (trace == null) {
|
return Collections.emptyList();
|
}
|
List<Integer> pendingPath = distinctPositive(trace.getPendingStationIds());
|
Integer currentStationId = trace.getCurrentStationId();
|
if (currentStationId == null || currentStationId <= 0) {
|
return pendingPath;
|
}
|
|
List<Integer> remainingPath = new ArrayList<>();
|
remainingPath.add(currentStationId);
|
Integer previousStationId = currentStationId;
|
for (Integer stationId : pendingPath) {
|
if (Objects.equals(stationId, previousStationId)) {
|
continue;
|
}
|
remainingPath.add(stationId);
|
previousStationId = stationId;
|
}
|
return remainingPath;
|
}
|
|
private boolean isRunningStationTask(WrkMast task) {
|
return task != null && Objects.equals(task.getWrkSts(), WrkStsType.STATION_RUN.sts);
|
}
|
|
private AutoTuneTaskRouteSampleItem baseRouteSample(WrkMast task) {
|
AutoTuneTaskRouteSampleItem item = new AutoTuneTaskRouteSampleItem();
|
if (task == null) {
|
return item;
|
}
|
item.setWrkNo(task.getWrkNo());
|
item.setWrkSts(task.getWrkSts());
|
item.setBatch(task.getBatch());
|
item.setBatchSeq(task.getBatchSeq());
|
item.setSourceStaNo(task.getSourceStaNo());
|
item.setTargetStaNo(task.getStaNo());
|
return item;
|
}
|
|
private AutoTuneTaskRouteSampleItem buildEstimatedRouteSample(AutoTuneTaskRouteSampleItem item,
|
WrkMast task,
|
Map<String, EstimatedPathResult> cache) {
|
if (task == null || task.getSourceStaNo() == null || task.getStaNo() == null) {
|
return completeRouteSample(item, PATH_SOURCE_MISSING, Collections.emptyList(),
|
"missing sourceStaNo or staNo");
|
}
|
|
Double pathLenFactor = resolvePathLenFactor(task);
|
String cacheKey = buildEstimatedPathCacheKey(task, pathLenFactor);
|
EstimatedPathResult pathResult = cache.get(cacheKey);
|
if (pathResult == null) {
|
pathResult = estimatePath(task, pathLenFactor);
|
cache.put(cacheKey, pathResult);
|
}
|
if (pathResult.pathStationIds.isEmpty()) {
|
return completeRouteSample(item, PATH_SOURCE_MISSING, Collections.emptyList(), pathResult.pathError);
|
}
|
return completeRouteSample(item, PATH_SOURCE_ESTIMATED, pathResult.pathStationIds, null);
|
}
|
|
private Double resolvePathLenFactor(WrkMast task) {
|
if (stationOutboundDecisionSupport == null) {
|
return 0.0d;
|
}
|
try {
|
Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(task);
|
return pathLenFactor == null ? 0.0d : pathLenFactor;
|
} catch (Exception e) {
|
return 0.0d;
|
}
|
}
|
|
private String buildEstimatedPathCacheKey(WrkMast task, Double pathLenFactor) {
|
return task.getWrkNo() + ":" + task.getSourceStaNo() + "->" + task.getStaNo() + ":" + pathLenFactor;
|
}
|
|
private EstimatedPathResult estimatePath(WrkMast task, Double pathLenFactor) {
|
List<NavigateNode> navigateNodes;
|
try {
|
navigateNodes = navigateUtils.calcOptimalPathByStationId(
|
task.getSourceStaNo(),
|
task.getStaNo(),
|
task.getWrkNo(),
|
pathLenFactor
|
);
|
} catch (Exception e) {
|
return EstimatedPathResult.error("path estimate exception: " + e.getClass().getSimpleName());
|
}
|
List<Integer> pathStationIds = stationIdsFromNavigateNodes(navigateNodes);
|
if (pathStationIds.isEmpty()) {
|
return EstimatedPathResult.error("path estimate failed");
|
}
|
return EstimatedPathResult.success(pathStationIds);
|
}
|
|
private List<Integer> stationIdsFromNavigateNodes(List<NavigateNode> navigateNodes) {
|
List<Integer> stationIds = new ArrayList<>();
|
if (navigateNodes == null) {
|
return stationIds;
|
}
|
for (NavigateNode navigateNode : navigateNodes) {
|
Integer stationId = stationIdFromNavigateNode(navigateNode);
|
if (stationId != null && stationId > 0) {
|
stationIds.add(stationId);
|
}
|
}
|
return stationIds;
|
}
|
|
private Integer stationIdFromNavigateNode(NavigateNode navigateNode) {
|
if (navigateNode == null) {
|
return null;
|
}
|
if (navigateNode.getStationId() != null) {
|
return navigateNode.getStationId();
|
}
|
String nodeValue = navigateNode.getNodeValue();
|
if (nodeValue == null || nodeValue.trim().isEmpty()) {
|
return null;
|
}
|
try {
|
JSONObject value = JSON.parseObject(nodeValue);
|
return value == null ? null : value.getInteger("stationId");
|
} catch (Exception e) {
|
return null;
|
}
|
}
|
|
@SafeVarargs
|
private final List<Integer> firstNonEmptyDistinct(List<Integer>... pathCandidates) {
|
if (pathCandidates == null) {
|
return Collections.emptyList();
|
}
|
for (List<Integer> pathCandidate : pathCandidates) {
|
List<Integer> pathStationIds = distinctPositive(pathCandidate);
|
if (!pathStationIds.isEmpty()) {
|
return pathStationIds;
|
}
|
}
|
return Collections.emptyList();
|
}
|
|
private List<Integer> distinctPositive(List<Integer> source) {
|
List<Integer> result = new ArrayList<>();
|
if (source == null) {
|
return result;
|
}
|
Integer previousStationId = null;
|
for (Integer stationId : source) {
|
if (stationId == null || stationId <= 0 || Objects.equals(stationId, previousStationId)) {
|
continue;
|
}
|
result.add(stationId);
|
previousStationId = stationId;
|
}
|
return result;
|
}
|
|
private AutoTuneTaskRouteSampleItem completeRouteSample(AutoTuneTaskRouteSampleItem item,
|
String pathSource,
|
List<Integer> pathStationIds,
|
String pathError) {
|
List<Integer> safePathStationIds = pathStationIds == null ? Collections.emptyList() : new ArrayList<>(pathStationIds);
|
item.setPathSource(pathSource);
|
item.setPathStationIds(safePathStationIds);
|
item.setPathLength(safePathStationIds.size());
|
item.setPathError(pathError);
|
return item;
|
}
|
|
private int countByPathSource(List<AutoTuneTaskRouteSampleItem> routeSamples, String pathSource) {
|
int count = 0;
|
for (AutoTuneTaskRouteSampleItem routeSample : routeSamples) {
|
if (routeSample != null && pathSource.equals(routeSample.getPathSource())) {
|
count++;
|
}
|
}
|
return count;
|
}
|
|
private Map<Integer, AutoTuneStationRuntimeItem> buildRuntimeMap(List<AutoTuneStationRuntimeItem> stationRuntimeSnapshot) {
|
Map<Integer, AutoTuneStationRuntimeItem> runtimeMap = new LinkedHashMap<>();
|
if (stationRuntimeSnapshot == null) {
|
return runtimeMap;
|
}
|
for (AutoTuneStationRuntimeItem runtimeItem : stationRuntimeSnapshot) {
|
if (runtimeItem != null && runtimeItem.getStationId() != null) {
|
runtimeMap.putIfAbsent(runtimeItem.getStationId(), runtimeItem);
|
}
|
}
|
return runtimeMap;
|
}
|
|
private List<AutoTuneHotPathSegmentItem> buildHotPathSegments(List<AutoTuneTaskRouteSampleItem> routeSamples,
|
Map<Integer, AutoTuneStationRuntimeItem> runtimeMap,
|
AutoTuneRoutePressureRuleSnapshot ruleSnapshot) {
|
LinkedHashMap<String, SegmentAggregate> aggregateMap = new LinkedHashMap<>();
|
if (routeSamples == null) {
|
return Collections.emptyList();
|
}
|
int validRouteSampleCount = 0;
|
for (AutoTuneTaskRouteSampleItem routeSample : routeSamples) {
|
if (!hasValidPath(routeSample)) {
|
continue;
|
}
|
validRouteSampleCount++;
|
Set<String> sampleSegmentKeys = new HashSet<>();
|
List<List<Integer>> routeSegments = splitRouteSegments(routeSample.getPathStationIds(), ruleSnapshot);
|
for (List<Integer> routeSegment : routeSegments) {
|
String segmentKey = buildSegmentKey(routeSegment);
|
if (segmentKey == null || !sampleSegmentKeys.add(segmentKey)) {
|
continue;
|
}
|
SegmentAggregate aggregate = aggregateMap.computeIfAbsent(
|
segmentKey,
|
key -> new SegmentAggregate(key, routeSegment)
|
);
|
aggregate.addRouteSample(routeSample);
|
}
|
}
|
List<AutoTuneHotPathSegmentItem> hotPathSegments = new ArrayList<>();
|
for (SegmentAggregate aggregate : aggregateMap.values()) {
|
hotPathSegments.add(aggregate.toItem(runtimeMap, ruleSnapshot, validRouteSampleCount));
|
}
|
hotPathSegments.sort(this::compareHotPathSegment);
|
return hotPathSegments;
|
}
|
|
private boolean hasValidPath(AutoTuneTaskRouteSampleItem routeSample) {
|
return routeSample != null
|
&& routeSample.getTargetStaNo() != null
|
&& routeSample.getPathStationIds() != null
|
&& routeSample.getPathStationIds().size() >= 2
|
&& !PATH_SOURCE_MISSING.equals(routeSample.getPathSource());
|
}
|
|
private List<List<Integer>> splitRouteSegments(List<Integer> pathStationIds,
|
AutoTuneRoutePressureRuleSnapshot ruleSnapshot) {
|
if (pathStationIds == null || pathStationIds.isEmpty()) {
|
return Collections.emptyList();
|
}
|
List<Integer> safePathStationIds = new ArrayList<>(pathStationIds);
|
int segmentWindowSize = ruleWindowSize(ruleSnapshot);
|
if (safePathStationIds.size() <= segmentWindowSize) {
|
return Collections.singletonList(safePathStationIds);
|
}
|
List<List<Integer>> routeSegments = new ArrayList<>();
|
for (int startIndex = 0; startIndex <= safePathStationIds.size() - segmentWindowSize; startIndex++) {
|
int endIndex = startIndex + segmentWindowSize;
|
routeSegments.add(new ArrayList<>(safePathStationIds.subList(startIndex, endIndex)));
|
}
|
return routeSegments;
|
}
|
|
private int ruleWindowSize(AutoTuneRoutePressureRuleSnapshot ruleSnapshot) {
|
Integer segmentWindowSize = ruleSnapshot == null ? null : ruleSnapshot.getSegmentWindowSize();
|
return segmentWindowSize == null || segmentWindowSize < 2 ? DEFAULT_SEGMENT_WINDOW_SIZE : segmentWindowSize;
|
}
|
|
private String buildSegmentKey(List<Integer> stationIds) {
|
if (stationIds == null || stationIds.isEmpty()) {
|
return null;
|
}
|
StringBuilder segmentKey = new StringBuilder();
|
for (Integer stationId : stationIds) {
|
if (stationId == null) {
|
return null;
|
}
|
if (segmentKey.length() > 0) {
|
segmentKey.append("-");
|
}
|
segmentKey.append(stationId);
|
}
|
return segmentKey.toString();
|
}
|
|
private int compareHotPathSegment(AutoTuneHotPathSegmentItem left, AutoTuneHotPathSegmentItem right) {
|
int pressureCompare = Integer.compare(
|
pressureRank(right.getPressureLevel()),
|
pressureRank(left.getPressureLevel())
|
);
|
if (pressureCompare != 0) {
|
return pressureCompare;
|
}
|
int scoreCompare = Integer.compare(nullSafe(right.getPressureScore()), nullSafe(left.getPressureScore()));
|
if (scoreCompare != 0) {
|
return scoreCompare;
|
}
|
int passCompare = Integer.compare(nullSafe(right.getPassTaskCount()), nullSafe(left.getPassTaskCount()));
|
if (passCompare != 0) {
|
return passCompare;
|
}
|
int runBlockCompare = Integer.compare(nullSafe(right.getRunBlockCount()), nullSafe(left.getRunBlockCount()));
|
if (runBlockCompare != 0) {
|
return runBlockCompare;
|
}
|
int taskHoldingCompare = Integer.compare(
|
nullSafe(right.getTaskHoldingCount()),
|
nullSafe(left.getTaskHoldingCount())
|
);
|
if (taskHoldingCompare != 0) {
|
return taskHoldingCompare;
|
}
|
int loadingCompare = Integer.compare(nullSafe(right.getLoadingCount()), nullSafe(left.getLoadingCount()));
|
if (loadingCompare != 0) {
|
return loadingCompare;
|
}
|
return nullSafeString(left.getSegmentKey()).compareTo(nullSafeString(right.getSegmentKey()));
|
}
|
|
private int pressureRank(String pressureLevel) {
|
if (PRESSURE_HIGH.equals(pressureLevel)) {
|
return 3;
|
}
|
if (PRESSURE_MEDIUM.equals(pressureLevel)) {
|
return 2;
|
}
|
return 1;
|
}
|
|
private int nullSafe(Integer value) {
|
return value == null ? 0 : value;
|
}
|
|
private String nullSafeString(String value) {
|
return value == null ? "" : value;
|
}
|
|
private List<AutoTuneHotPathSegmentItem> topHotPathSegments(List<AutoTuneHotPathSegmentItem> allHotPathSegments) {
|
if (allHotPathSegments == null || allHotPathSegments.isEmpty()) {
|
return Collections.emptyList();
|
}
|
int toIndex = Math.min(MAX_HOT_PATH_SEGMENT_COUNT, allHotPathSegments.size());
|
return new ArrayList<>(allHotPathSegments.subList(0, toIndex));
|
}
|
|
private List<AutoTuneTargetStationRoutePressureItem> buildTargetStationRoutePressure(
|
List<AutoTuneTaskRouteSampleItem> routeSamples,
|
List<AutoTuneHotPathSegmentItem> allHotPathSegments,
|
AutoTuneTaskSnapshot taskSnapshot,
|
AutoTuneRoutePressureRuleSnapshot ruleSnapshot) {
|
LinkedHashMap<Integer, TargetPressureAggregate> targetAggregateMap = new LinkedHashMap<>();
|
Set<Integer> blockedWrkNos = collectBlockedWrkNos(taskSnapshot);
|
|
if (routeSamples != null) {
|
for (AutoTuneTaskRouteSampleItem routeSample : routeSamples) {
|
if (!hasValidPath(routeSample)) {
|
continue;
|
}
|
Integer targetStaNo = routeSample.getTargetStaNo();
|
TargetPressureAggregate aggregate = targetAggregateMap.computeIfAbsent(
|
targetStaNo,
|
TargetPressureAggregate::new
|
);
|
aggregate.routeTaskCount++;
|
if (routeSample.getWrkNo() != null && blockedWrkNos.contains(routeSample.getWrkNo())) {
|
aggregate.blockedTaskCount++;
|
}
|
}
|
}
|
|
if (allHotPathSegments != null) {
|
for (AutoTuneHotPathSegmentItem hotPathSegment : allHotPathSegments) {
|
if (hotPathSegment == null || hotPathSegment.getRelatedTargetStations() == null) {
|
continue;
|
}
|
for (Integer targetStationId : hotPathSegment.getRelatedTargetStations()) {
|
TargetPressureAggregate aggregate = targetAggregateMap.get(targetStationId);
|
if (aggregate != null) {
|
aggregate.relatedHotSegments.add(hotPathSegment);
|
}
|
}
|
}
|
}
|
|
List<AutoTuneTargetStationRoutePressureItem> targetPressureItems = new ArrayList<>();
|
for (TargetPressureAggregate aggregate : targetAggregateMap.values()) {
|
targetPressureItems.add(aggregate.toItem(ruleSnapshot));
|
}
|
targetPressureItems.sort(Comparator.comparing(
|
AutoTuneTargetStationRoutePressureItem::getTargetStationId,
|
Comparator.nullsLast(Integer::compareTo)
|
));
|
return targetPressureItems;
|
}
|
|
private int calculateSegmentPressureScore(int passTaskCount,
|
int taskHoldingCount,
|
int loadingCount,
|
int runBlockCount,
|
int nonAutoingCount,
|
int segmentStationCount,
|
int validRouteSampleCount,
|
AutoTuneRoutePressureRuleSnapshot ruleSnapshot) {
|
double passRatio = ratio(passTaskCount, validRouteSampleCount);
|
double occupiedRatio = ratio(taskHoldingCount + loadingCount, segmentStationCount);
|
double nonAutoingRatio = ratio(nonAutoingCount, segmentStationCount);
|
double runBlockRatio = ratio(runBlockCount, segmentStationCount);
|
double score = passRatio * nullSafe(ruleSnapshot.getPassWeightPercent())
|
+ occupiedRatio * nullSafe(ruleSnapshot.getOccupiedWeightPercent())
|
+ nonAutoingRatio * nullSafe(ruleSnapshot.getNonAutoingWeightPercent())
|
+ runBlockRatio * nullSafe(ruleSnapshot.getRunBlockWeightPercent());
|
return clampPercent((int) Math.round(score));
|
}
|
|
private String calculatePressureLevel(int pressureScore, AutoTuneRoutePressureRuleSnapshot ruleSnapshot) {
|
if (pressureScore >= nullSafe(ruleSnapshot.getHighPercent())) {
|
return PRESSURE_HIGH;
|
}
|
if (pressureScore >= nullSafe(ruleSnapshot.getMediumPercent())) {
|
return PRESSURE_MEDIUM;
|
}
|
return PRESSURE_LOW;
|
}
|
|
private Map<String, Object> segmentPressureFactors(int passTaskCount,
|
int taskHoldingCount,
|
int loadingCount,
|
int runBlockCount,
|
int nonAutoingCount,
|
int segmentStationCount,
|
int validRouteSampleCount) {
|
Map<String, Object> factors = new LinkedHashMap<>();
|
factors.put("passRatio", percentValue(passTaskCount, validRouteSampleCount));
|
factors.put("occupiedRatio", percentValue(taskHoldingCount + loadingCount, segmentStationCount));
|
factors.put("nonAutoingRatio", percentValue(nonAutoingCount, segmentStationCount));
|
factors.put("runBlockRatio", percentValue(runBlockCount, segmentStationCount));
|
return factors;
|
}
|
|
private double ratio(int numerator, int denominator) {
|
if (numerator <= 0 || denominator <= 0) {
|
return 0.0d;
|
}
|
return Math.min(1.0d, (double) numerator / (double) denominator);
|
}
|
|
private Integer percentValue(int numerator, int denominator) {
|
return clampPercent((int) Math.round(ratio(numerator, denominator) * 100.0d));
|
}
|
|
private int clampPercent(int value) {
|
if (value < 0) {
|
return 0;
|
}
|
return Math.min(value, 100);
|
}
|
|
private String snapshotConfidence(int analyzedTaskCount, int pathErrorCount) {
|
if (analyzedTaskCount >= 10 && pathErrorCount == 0) {
|
return CONFIDENCE_HIGH;
|
}
|
if (analyzedTaskCount >= 3 && pathErrorCount < analyzedTaskCount) {
|
return CONFIDENCE_MEDIUM;
|
}
|
return CONFIDENCE_LOW;
|
}
|
|
private String targetConfidence(int routeTaskCount) {
|
if (routeTaskCount >= 10) {
|
return CONFIDENCE_HIGH;
|
}
|
if (routeTaskCount >= 3) {
|
return CONFIDENCE_MEDIUM;
|
}
|
return CONFIDENCE_LOW;
|
}
|
|
private static class EstimatedPathResult {
|
private final List<Integer> pathStationIds;
|
private final String pathError;
|
|
private EstimatedPathResult(List<Integer> pathStationIds, String pathError) {
|
this.pathStationIds = pathStationIds;
|
this.pathError = pathError;
|
}
|
|
private static EstimatedPathResult success(List<Integer> pathStationIds) {
|
return new EstimatedPathResult(new ArrayList<>(pathStationIds), null);
|
}
|
|
private static EstimatedPathResult error(String pathError) {
|
return new EstimatedPathResult(Collections.emptyList(), pathError);
|
}
|
}
|
|
private class SegmentAggregate {
|
private final String segmentKey;
|
private final List<Integer> stationIds;
|
private final Set<Integer> relatedTargetStations = new LinkedHashSet<>();
|
private final Set<Integer> sampleWrkNos = new LinkedHashSet<>();
|
private int passTaskCount;
|
|
private SegmentAggregate(String segmentKey, List<Integer> stationIds) {
|
this.segmentKey = segmentKey;
|
this.stationIds = new ArrayList<>(stationIds);
|
}
|
|
private void addRouteSample(AutoTuneTaskRouteSampleItem routeSample) {
|
passTaskCount++;
|
if (routeSample.getTargetStaNo() != null) {
|
relatedTargetStations.add(routeSample.getTargetStaNo());
|
}
|
if (routeSample.getWrkNo() != null) {
|
sampleWrkNos.add(routeSample.getWrkNo());
|
}
|
}
|
|
private AutoTuneHotPathSegmentItem toItem(Map<Integer, AutoTuneStationRuntimeItem> runtimeMap,
|
AutoTuneRoutePressureRuleSnapshot ruleSnapshot,
|
int validRouteSampleCount) {
|
int loadingCount = 0;
|
int taskHoldingCount = 0;
|
int runBlockCount = 0;
|
int nonAutoingCount = 0;
|
for (Integer stationId : stationIds) {
|
AutoTuneStationRuntimeItem runtimeItem = runtimeMap.get(stationId);
|
if (runtimeItem == null) {
|
continue;
|
}
|
if (Objects.equals(runtimeItem.getLoading(), 1)) {
|
loadingCount++;
|
}
|
if (runtimeItem.getTaskNo() != null && runtimeItem.getTaskNo() > 0) {
|
taskHoldingCount++;
|
}
|
if (Objects.equals(runtimeItem.getRunBlock(), 1)) {
|
runBlockCount++;
|
}
|
if (!Objects.equals(runtimeItem.getAutoing(), 1)) {
|
nonAutoingCount++;
|
}
|
}
|
|
int pressureScore = calculateSegmentPressureScore(
|
passTaskCount,
|
taskHoldingCount,
|
loadingCount,
|
runBlockCount,
|
nonAutoingCount,
|
stationIds.size(),
|
validRouteSampleCount,
|
ruleSnapshot
|
);
|
AutoTuneHotPathSegmentItem item = new AutoTuneHotPathSegmentItem();
|
item.setSegmentKey(segmentKey);
|
item.setStationIds(new ArrayList<>(stationIds));
|
item.setPassTaskCount(passTaskCount);
|
item.setLoadingCount(loadingCount);
|
item.setTaskHoldingCount(taskHoldingCount);
|
item.setRunBlockCount(runBlockCount);
|
item.setNonAutoingCount(nonAutoingCount);
|
item.setPressureScore(pressureScore);
|
item.setPressureLevel(calculatePressureLevel(pressureScore, ruleSnapshot));
|
item.setPressureFactors(segmentPressureFactors(
|
passTaskCount,
|
taskHoldingCount,
|
loadingCount,
|
runBlockCount,
|
nonAutoingCount,
|
stationIds.size(),
|
validRouteSampleCount
|
));
|
item.setRelatedTargetStations(new ArrayList<>(relatedTargetStations));
|
item.setSampleWrkNos(new ArrayList<>(sampleWrkNos));
|
return item;
|
}
|
}
|
|
private class TargetPressureAggregate {
|
private final Integer targetStationId;
|
private final List<AutoTuneHotPathSegmentItem> relatedHotSegments = new ArrayList<>();
|
private int blockedTaskCount;
|
private int routeTaskCount;
|
|
private TargetPressureAggregate(Integer targetStationId) {
|
this.targetStationId = targetStationId;
|
}
|
|
private AutoTuneTargetStationRoutePressureItem toItem(AutoTuneRoutePressureRuleSnapshot ruleSnapshot) {
|
int pressureScore = targetPressureScore(ruleSnapshot);
|
String pressureLevel = calculatePressureLevel(pressureScore, ruleSnapshot);
|
String heuristicDirection = heuristicDirection(pressureLevel);
|
String evidenceText = evidenceText(pressureLevel, pressureScore, heuristicDirection);
|
AutoTuneTargetStationRoutePressureItem item = new AutoTuneTargetStationRoutePressureItem();
|
item.setTargetStationId(targetStationId);
|
item.setBlockedTaskCount(blockedTaskCount);
|
item.setRouteTaskCount(routeTaskCount);
|
item.setMainHotSegments(mainHotSegmentKeys());
|
item.setPressureLevel(pressureLevel);
|
item.setPressureScore(pressureScore);
|
item.setConfidence(targetConfidence(routeTaskCount));
|
item.setPressureFactors(targetPressureFactors(ruleSnapshot));
|
item.setHeuristicDirection(heuristicDirection);
|
item.setRecommendedDirection(heuristicDirection);
|
item.setRecommendedTargets(Collections.singletonList("station/" + targetStationId + "/outTaskLimit"));
|
item.setReason(evidenceText);
|
item.setEvidenceText(evidenceText);
|
return item;
|
}
|
|
private int targetPressureScore(AutoTuneRoutePressureRuleSnapshot ruleSnapshot) {
|
int pressureScore = highestSegmentPressureScore();
|
int blockedScore = (int) Math.round(
|
ratio(blockedTaskCount, routeTaskCount) * nullSafe(ruleSnapshot.getBlockedWeightPercent())
|
);
|
return clampPercent(pressureScore + blockedScore);
|
}
|
|
private int highestSegmentPressureScore() {
|
int pressureScore = 0;
|
for (AutoTuneHotPathSegmentItem hotPathSegment : relatedHotSegments) {
|
pressureScore = Math.max(pressureScore, nullSafe(hotPathSegment.getPressureScore()));
|
}
|
return pressureScore;
|
}
|
|
private Map<String, Object> targetPressureFactors(AutoTuneRoutePressureRuleSnapshot ruleSnapshot) {
|
Map<String, Object> factors = new LinkedHashMap<>();
|
factors.put("blockedRatio", percentValue(blockedTaskCount, routeTaskCount));
|
factors.put("highestSegmentScore", highestSegmentPressureScore());
|
factors.put("blockedScore", (int) Math.round(
|
ratio(blockedTaskCount, routeTaskCount) * nullSafe(ruleSnapshot.getBlockedWeightPercent())
|
));
|
return factors;
|
}
|
|
private List<String> mainHotSegmentKeys() {
|
List<String> segmentKeys = new ArrayList<>();
|
for (AutoTuneHotPathSegmentItem hotPathSegment : relatedHotSegments) {
|
if (hotPathSegment.getSegmentKey() != null) {
|
segmentKeys.add(hotPathSegment.getSegmentKey());
|
}
|
if (segmentKeys.size() >= MAX_TARGET_MAIN_SEGMENT_COUNT) {
|
break;
|
}
|
}
|
return segmentKeys;
|
}
|
|
private String heuristicDirection(String pressureLevel) {
|
if (PRESSURE_HIGH.equals(pressureLevel)) {
|
return DIRECTION_DECREASE_CANDIDATE;
|
}
|
if (blockedTaskCount > 0) {
|
return DIRECTION_INCREASE_CANDIDATE;
|
}
|
return DIRECTION_OBSERVE;
|
}
|
|
private String evidenceText(String pressureLevel, int pressureScore, String heuristicDirection) {
|
return "目标站" + targetStationId
|
+ "路径事实：pressure=" + pressureLevel
|
+ "，score=" + pressureScore
|
+ "，heuristicDirection=" + heuristicDirection
|
+ "，blockedTaskCount=" + blockedTaskCount
|
+ "，routeTaskCount=" + routeTaskCount
|
+ "，mainHotSegments=" + mainHotSegmentKeys()
|
+ "。";
|
}
|
}
|
}
|
