增加可靠性评定时模型及参数检查

xyc

2024-11-04 b03320ae317b7ff09ea1450c0f831f24fe7018e1

增加可靠性评定时模型及参数检查

 modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/dto/TaskModelCheckResultDto.java

@@ -4,12 +4,19 @@

@Data
public class TaskModelCheckResultDto {
    // 可靠性仿真评估
    public final static String CATEGORY_TASK_TIME = "任务总时长未配置";
    public final static String CATEGORY_PHASE_TIME = "阶段时长未配置";
    public final static String CATEGORY_GK_TIME = "工况时长未配置";
    public final static String CATEGORY_GK_MODEL = "工况模型树不完整";
    public final static String CATEGORY_MODEL = "建模未完成";
    public final static String CATEGORY_PARAM = "设备参数未配置";
    // 可靠性评定
    public final static String CATEGORY_MULTI_PHASE = "目前不支持多阶段";
    public final static String CATEGORY_MULTI_GK = "目前不支持多工况";
    public final static String CATEGORY_MODEL_NOT_SUPPORT = "目前不支持串联、并联和表决以外的模型";
    public final static String CATEGORY_DISTRIBUTION_NOT_SUPPORT = "目前不支持二项分布和指数分布以外的分布类型";
    public final static String CATEGORY_NO_ASSESS_DATA = "评定数据未录入";
    private String category; // 检查结果分类
    private Long productId; // 产品结构树节点ID（为任务可靠性建模对象节点，一般为总体）
    private Long taskId; // 任务ID

 modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/service/TaskService.java

@@ -67,13 +67,13 @@
    }

    /**
     * 对任务可靠性模型及其参数配置进行完整性检查，并指出以下5类错误：
     * 0）任务总时长未配置
     * 1）阶段时长未配置
     * 2）工况时长未配置
     * 3）工况模型树不完整
     * 4）建模未完成
     * 5）设备参数未配置
     * 可靠性仿真评估：对任务可靠性模型及其参数配置进行完整性检查，并指出以下6类错误：
     * 1）任务总时长未配置
     * 2）阶段时长未配置
     * 3）工况时长未配置
     * 4）工况模型树不完整
     * 5）建模未完成
     * 6）设备参数未配置
     * 可以对所有任务模型进行检查，也可以只检查入参指定的产品节点下的任务模型；前者适合在页面列表显示全体建模状态，后者适合对某任务进行仿真时的检查。
     *
     * @param productId 产品节点ID（一般为总体）
@@ -296,6 +296,276 @@

    }

    /**
     * 可靠性评定：对任务可靠性模型、参数配置、可靠性评定数据进行完整性检查，并指出以下11类错误：
     * 1）任务总时长未配置
     * 2）目前不支持多阶段
     * 3）阶段时长未配置
     * 4）目前不支持多工况
     * 5）工况时长未配置
     * 6）工况模型树不完整
     * 7）建模未完成
     * 8）目前不支持串联、并联和表决以外的模型
     * 9）设备参数未配置
     * 10）目前不支持二项分布和指数分布以外的分布类型
     * 11）评定数据未录入
     * 可以对所有任务模型进行检查，也可以只检查入参指定的产品节点下的任务模型；前者适合在页面列表显示全体建模状态，后者适合对某任务进行仿真时的检查。
     *
     * @param productId 产品节点ID（一般为总体）
     * @return 检查出的错误的List，长度为0表示没有错误，不会返回null
     */
    public List<TaskModelCheckResultDto> checkTaskModelAssess(Long productId, Long taskId) {
        List<TaskModelCheckResultDto> checkResult = new ArrayList<>();
        List<XhProductModel> deviceUsedList = new ArrayList<>();    // 检查对象模型中使用到的所有设备

        // 1. 获取数据
        // 1.1 获取所有任务数据List
        List<Task> taskList = baseDao.getTasks(productId, taskId);
        // 1.2 获取所有任务阶段数据List
        List<TaskPhase> taskPhaseList = baseDao.getTaskPhases(productId, taskId);
        // 1.3 获取所有任务工况数据List
        List<TaskPhaseModel> taskPhaseModelList = baseDao.getTaskPhaseModels(productId, taskId);
        // 1.4 获取产品结构树结构数据
        List<XhProductModel> productTreeList = xhProductModelDao.getProductTree(productId);
        // 1.5 获取所有工况模型树数据List
        List<OperatConditModel> gkModelList = operatConditModelDao.getGKModelTrees(productId);
        // 1.6 获取所有RBD数据List
        List<ModelRbd> modelRbdList = modelRbdDao.getListAll();
        // 1.7 获取所有模型包含的节点数据
        List<ModelNodeAlgorithm> rbdNodeList = modelNodeAlgorithmDao.getRbdNodes();
        // 1.8 获取该船的所有设备参数List
        List<ParamData> paramDataList = paramDataDao.getDeviceParams(productId);
        // 1.8 获取该任务的二项分布参数）List
        List<TaskBinoParam> binoParamList = taskBinoParamDao.getBinoParams(taskId);

        // 2. 检查每个任务模型的数据完整性
        for (Task task : taskList) {
            if (null == task.getTaskDuration() || 0.0 == task.getTaskDuration()) {
                // 2.1 任务总时长未配置
                setTaskModelCheckResult(task, null, null,
                        null, null, null, null,
                        TaskModelCheckResultDto.CATEGORY_TASK_TIME, checkResult);
            }
            List<TaskPhase> phases = taskPhaseList.stream().filter(item ->
                    task.getId().equals(item.getTaskId())).collect(Collectors.toList());
            if (phases.size() > 1) {
                // 2.2 目前不支持多阶段
                setTaskModelCheckResult(task, null, null,
                        null, null, null, null,
                        TaskModelCheckResultDto.CATEGORY_MULTI_PHASE, checkResult);
            } else if (phases.size() <= 0){
                // 2.3 阶段时长未配置
                setTaskModelCheckResult(task, null, null,
                        null, null, null, null,
                        TaskModelCheckResultDto.CATEGORY_PHASE_TIME, checkResult);
            } else {
                TaskPhase phase = phases.get(0);
                if (null == phase.getPhaseDurationRate() || 0.0 == phase.getPhaseDurationRate()) {
                    // 2.3 阶段时长未配置
                    setTaskModelCheckResult(task, phase, null,
                            null, null, null, null,
                            TaskModelCheckResultDto.CATEGORY_PHASE_TIME, checkResult);
                }
                List<TaskPhaseModel> phaseModels = taskPhaseModelList.stream().filter(item ->
                        phase.getId().equals(item.getPhaseId()) && 0.0 != item.getOperatConditDurationRate()).
                        collect(Collectors.toList());
                if (phaseModels.size() > 1) {
                    // 2.4 目前不支持多工况
                    setTaskModelCheckResult(task, phase, null,
                            null, null, null, null,
                            TaskModelCheckResultDto.CATEGORY_MULTI_GK, checkResult);
                } else if (phaseModels.size() <= 0) {
                    // 2.5 工况时长未配置
                    setTaskModelCheckResult(task, phase, null,
                            null, null, null, null,
                            TaskModelCheckResultDto.CATEGORY_GK_TIME, checkResult);
                } else {
                    // 有工况被选用，检查选用的工况
                    TaskPhaseModel taskPhaseModel = phaseModels.get(0);
                    List<OperatConditModel> gkModelTree = gkModelList.stream().filter(item ->
                            taskPhaseModel.getOperatConditId().equals(item.getOperatConditId())).collect(Collectors.toList());
                    if (gkModelTree.size() <= 0) {
                        // 无工况模型树
                        XhProductModel node = productTreeList.stream().filter(item ->
                                task.getProductId().equals(item.getId())).collect(Collectors.toList()).get(0);
                        // 2.6 工况模型树不完整
                        setTaskModelCheckResult(task, phase, taskPhaseModel,
                                node, null, null, null,
                                TaskModelCheckResultDto.CATEGORY_GK_MODEL, checkResult);
                    } else {
                        // 有工况模型树，检查其完整性
                        for (OperatConditModel gkModel : gkModelTree) {
                            XhProductModel node = productTreeList.stream().filter(item ->
                                    gkModel.getProductId().equals(item.getId())).collect(Collectors.toList()).get(0);
                            if (null == gkModel.getModelId()) {
                                // 2.6 工况模型树不完整
                                setTaskModelCheckResult(task, phase, taskPhaseModel,
                                        node, null, null, null,
                                        TaskModelCheckResultDto.CATEGORY_GK_MODEL, checkResult);
                            } else {
                                List<ModelRbd> modelRbds = modelRbdList.stream().filter(item ->
                                        gkModel.getModelId().equals(item.getId())).collect(Collectors.toList());
                                if (modelRbds.size() == 0) {
                                    // 2.7 建模未完成
                                    setTaskModelCheckResult(task, phase, taskPhaseModel,
                                            node, null, null, null,
                                            TaskModelCheckResultDto.CATEGORY_MODEL, checkResult);
                                } else {
                                    if (!"已完成".equals(modelRbds.get(0).getModelState())) {
                                        // 2.7 建模未完成
                                        setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                node, modelRbds.get(0), null, null,
                                                TaskModelCheckResultDto.CATEGORY_MODEL, checkResult);
                                    } else {
                                        List<Algorithm> algorithmList = algorithmDao.getListByModelId(gkModel.getModelId());
                                        if (hasNotSupportModel(algorithmList)) {
                                            // 2.8 目前不支持串联、并联和表决以外的模型
                                            setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                    node, modelRbds.get(0), null, null,
                                                    TaskModelCheckResultDto.CATEGORY_MODEL_NOT_SUPPORT, checkResult);
                                        } else {
                                            List<ModelNodeAlgorithm> deviceNodes = rbdNodeList.stream().filter(item ->
                                                    gkModel.getModelId().equals(item.getModelId())).collect(Collectors.toList());
                                            for (ModelNodeAlgorithm deviceNode : deviceNodes) {
                                                XhProductModel device = (XhProductModel) productTreeList.stream().filter(item ->
                                                        deviceNode.getDataId().equals(item.getId())).collect(Collectors.toList()).get(0);
                                                if ("5".equals(device.getProductType())) {
                                                    // 设备
                                                    List<ParamData> params = paramDataList.stream().filter(item ->
                                                            deviceNode.getDataId().equals(item.getProductId())).collect(Collectors.toList());
                                                    if (params.size() == 0) {
                                                        // 设备参数未配置
                                                        setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                                node, modelRbds.get(0), device, null,
                                                                TaskModelCheckResultDto.CATEGORY_PARAM, checkResult);
                                                    } else {
                                                        ParamData param = params.get(0);
                                                        if (param.getReliabDistribType() == null) {
                                                            setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                                    node, modelRbds.get(0), device, "可靠性分布类型",
                                                                    TaskModelCheckResultDto.CATEGORY_PARAM, checkResult);
                                                        } else {
                                                            if (param.getReliabDistribType() == 1) {
                                                                // 指数分布
                                                                if (param.getTaskMtbcfRegulate() == null) {
                                                                    setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                                            node, modelRbds.get(0), device, "MTBCF",
                                                                            TaskModelCheckResultDto.CATEGORY_PARAM, checkResult);
                                                                }
                                                            }
                                                            if (param.getReliabDistribType() == 2) {
                                                                // 威布尔分布
                                                                if (param.getTaskMtbcfRegulate() == null) {
                                                                    setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                                            node, modelRbds.get(0), device, "MTBCF",
                                                                            TaskModelCheckResultDto.CATEGORY_PARAM, checkResult);
                                                                }
                                                                if (param.getTaskMtbcfOtherParams2() == null) {
                                                                    setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                                            node, modelRbds.get(0), device, "MTBCF参数2",
                                                                            TaskModelCheckResultDto.CATEGORY_PARAM, checkResult);
                                                                }
                                                                if (param.getTaskMtbcfOtherParams3() == null) {
                                                                    setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                                            node, modelRbds.get(0), device, "MTBCF参数3",
                                                                            TaskModelCheckResultDto.CATEGORY_PARAM, checkResult);
                                                                }
                                                            }
                                                            if (param.getReliabDistribType() == 3) {
                                                                // 二项分布
                                                                List<TaskBinoParam> binoParams = binoParamList.stream().filter(item ->
                                                                        phase.getId().equals(item.getPhaseId()) &&
                                                                                taskPhaseModel.getOperatConditId().equals(item.getOperatConditId()) &&
                                                                                modelRbds.get(0).getId().equals(item.getModelId()) &&
                                                                                device.getId().equals(item.getProductId())).collect(Collectors.toList());
                                                                if (binoParams.size() == 0) {
                                                                    setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                                            node, modelRbds.get(0), device, "二项分布参数",
                                                                            TaskModelCheckResultDto.CATEGORY_PARAM, checkResult);
                                                                } else {
                                                                    TaskBinoParam binoParam = binoParams.get(0);
                                                                    if (binoParam.getSuccessRate() == null) {
                                                                        setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                                                node, modelRbds.get(0), device, "成功率",
                                                                                TaskModelCheckResultDto.CATEGORY_PARAM, checkResult);
                                                                    } else {
                                                                        if (binoParam.getSuccessTimes() != null && binoParam.getSimulatTimes() == null) {
                                                                            setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                                                    node, modelRbds.get(0), device, "总次数",
                                                                                    TaskModelCheckResultDto.CATEGORY_PARAM, checkResult);
                                                                        }
                                                                        if (binoParam.getSuccessTimes() == null && binoParam.getSimulatTimes() != null) {
                                                                            setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                                                    node, modelRbds.get(0), device, "成功次数",
                                                                                    TaskModelCheckResultDto.CATEGORY_PARAM, checkResult);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            if (1 == param.getRepairable()) {
                                                                // 可维修
                                                                if (param.getRepairDistribType() == null) {
                                                                    setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                                            node, modelRbds.get(0), device, "维修分布类型",
                                                                            TaskModelCheckResultDto.CATEGORY_PARAM, checkResult);
                                                                }
                                                                if (param.getRepairDistribType() == 1) {
                                                                    // 指数分布
                                                                    if (param.getRepairMttcr() == null) {
                                                                        setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                                                node, modelRbds.get(0), device, "MTTCR",
                                                                                TaskModelCheckResultDto.CATEGORY_PARAM, checkResult);
                                                                    }
                                                                }
                                                                if (param.getRepairDistribType() == 2) {
                                                                    // 威布尔分布
                                                                    if (param.getRepairMttcr() == null) {
                                                                        setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                                                node, modelRbds.get(0), device, "MTTCR",
                                                                                TaskModelCheckResultDto.CATEGORY_PARAM, checkResult);
                                                                    }
                                                                    if (param.getRepairMttcrOtherParams2() == null) {
                                                                        setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                                                node, modelRbds.get(0), device, "MTTCR参数2",
                                                                                TaskModelCheckResultDto.CATEGORY_PARAM, checkResult);
                                                                    }
                                                                    if (param.getRepairMttcrOtherParams3() == null) {
                                                                        setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                                                node, modelRbds.get(0), device, "MTTCR参数3",
                                                                                TaskModelCheckResultDto.CATEGORY_PARAM, checkResult);
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

            }
        }
        // 3. 返回检查结果
        return checkResult;

    }

    private boolean hasNotSupportModel(List<Algorithm> algorithmList) {
        boolean result = false;
        for (Algorithm algorithm : algorithmList) {
            if ("switch,bridge".contains(algorithm.getAlgorithmType())) {
                result = true;
                break;
            }
        }
        return result;
    }

    private void setTaskModelCheckResult(Task task,
                                         TaskPhase taskPhase,
                                         TaskPhaseModel taskPhaseModel,