1）修改bug：可靠性预计参数配置，可靠性分布类型下拉框缺少威布尔分布； 2）细化可靠性仿真评估报错信息。

xyc

2024-10-18 c0e3f24edd2ef47339c676ff3dc6fdc06b3c387e

1）修改bug：可靠性预计参数配置，可靠性分布类型下拉框缺少威布尔分布；
2）细化可靠性仿真评估报错信息。

 modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/dao/ModelRbdDao.java

@@ -19,6 +19,7 @@
public interface ModelRbdDao extends BaseDao<ModelRbd> {

    List<ModelRbd> getList(Map<String, Object> params);
    List<ModelRbd> getListAll();
    ModelRbd getDiagram(Long modelId);
    ModelRbd getDiagramOfXDY(Long productId);
    void deleteByModelId(Long modelId);

 modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/dao/TaskBinoParamDao.java

@@ -19,6 +19,6 @@
public interface TaskBinoParamDao extends BaseDao<TaskBinoParam> {

    List<TaskBinoParam> getList(Map<String, Object> params);
    List<TaskBinoParam> getBinoParams(Long taskModelId);
    List<TaskBinoParam> getBinoParams(Long taskId);

}

 modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/dao/TaskDao.java

@@ -24,7 +24,7 @@

    List<Task> getTaskList(Long productId);

    List<Task> getTaskModels(Long productId, Long taskModelId);
    List<TaskPhase> getTaskModelPhases(Long productId, Long taskModelId);
    List<TaskPhaseModel> getTaskModelPhaseModels(Long productId, Long taskModelId);
    List<Task> getTasks(Long productId, Long taskId);
    List<TaskPhase> getTaskPhases(Long productId, Long taskId);
    List<TaskPhaseModel> getTaskPhaseModels(Long productId, Long taskId);
}

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

@@ -12,10 +12,10 @@
    public final static String CATEGORY_PARAM = "设备参数未配置";
    private String category; // 检查结果分类
    private Long productId; // 产品结构树节点ID（为任务可靠性建模对象节点，一般为总体）
    private Long taskModelId; // 任务模型ID
    private String taskModelName; // 任务模型名称
    private Long taskModelPhaseId; // 任务阶段ID
    private String taskModelPhaseName; // 任务阶段名称
    private Long taskId; // 任务ID
    private String taskName; // 任务名称
    private Long taskPhaseId; // 任务阶段ID
    private String taskPhaseName; // 任务阶段名称
    private Long gkId; // 工况ID
    private String gkName; // 工况名称
    private Long nodeId; // 节点ID
@@ -24,6 +24,5 @@
    private String modelName; // 节点选择的模型名称
    private Long deviceId; // 设备ID
    private String deviceName; // 设备名称
    private Long paramId; // 设备参数ID
    private String paramName; // 设备参数名称
    private String paramName; // 参数名称
}

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

@@ -717,7 +717,7 @@
            try {
                setParamToRedis(assessResult);
            } catch (Exception e) {
                throw new RuntimeException("访问Redis失败。请检查Redis是否已启动。");
                throw new RenException("访问Redis失败。请检查Redis是否已启动。");
            }

            Process process = null;
@@ -730,7 +730,7 @@
            } else if (System.getProperty("os.name").toLowerCase().indexOf("linux") > -1) {
                process = Runtime.getRuntime().exec(new String[]{"/bin/sh", "-c", command});
            } else {
                throw new Exception("暂不支持该操作系统，进行启动算法库计算！");
                throw new RenException("暂不支持该操作系统，进行启动算法库计算！");
            }
            is = process.getInputStream();
            // 以命令行方式调用算法库时，接口约定返回的结果是utf-8编码
@@ -741,11 +741,11 @@
            if (line != null) {
                ReliaSimLibResult rtn = com.alibaba.fastjson.JSONObject.parseObject(line, ReliaSimLibResult.class);
                if ("0".equals(rtn.getCode())) {
                    logger.info("启动算法库成功。");
                    logger.info("启动可靠性评定算法库成功。");
                    result = Result.ok();
                } else {
                    String errorMsg = rtn.getErrorMsg();
                    throw new RuntimeException("启动算法库失败: errorMsg=" + errorMsg);
                    throw new RenException("启动可靠性评定算法库失败: errorMsg=" + errorMsg);
                }
            }

@@ -753,7 +753,7 @@
        } catch (Exception e) {
            logger.error("启动可靠性评定算法库时发生Exception：", e);
            e.printStackTrace();
            result = Result.error(e.getMessage());
            throw new RenException("启动可靠性评定算法库失败: errorMsg=" + e.getMessage());
        } finally {
            if (is != null) {
                try {

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

@@ -612,8 +612,7 @@
        List<TaskModelCheckResultDto> chkResult = taskService.checkTaskModel(simulatAssess.getProductId(),
                simulatAssess.getTaskModelId());
        if (chkResult.size() > 0) {
            result = Result.error("模型不完整，请检查模型定义及参数配置。");
//            result = Result.ok(chkResult);
            result = Result.ok(chkResult);
            return result;
        }

@@ -634,7 +633,7 @@
            try {
                setParamToRedis(simulatAssess);
            } catch (Exception e) {
                throw new RuntimeException("访问Redis失败。请检查Redis是否已启动。");
                throw new RenException("访问Redis失败。请检查Redis是否已启动。");
            }

            Process process = null;
@@ -647,7 +646,7 @@
            } else if (System.getProperty("os.name").toLowerCase().indexOf("linux") > -1) {
                process = Runtime.getRuntime().exec(new String[]{"/bin/sh", "-c", command});
            } else {
                throw new Exception("暂不支持该操作系统，进行启动算法库计算！");
                throw new RenException("暂不支持该操作系统，进行启动算法库计算！");
            }
            is = process.getInputStream();
            // 以命令行方式调用算法库时，接口约定返回的结果是utf-8编码
@@ -658,17 +657,17 @@
            if (line != null) {
                ReliaSimLibResult rtn = com.alibaba.fastjson.JSONObject.parseObject(line, ReliaSimLibResult.class);
                if ("0".equals(rtn.getCode())) {
                    logger.info("启动算法库成功。");
                    logger.info("启动可靠性仿真评估算法库成功。");
                    result = Result.ok();
                } else {
                    String errorMsg = rtn.getErrorMsg();
                    throw new RuntimeException("启动算法库失败: errorMsg=" + errorMsg);
                    throw new RenException("启动可靠性仿真评估算法库失败: errorMsg=" + errorMsg);
                }
            }
        } catch (Exception e) {
            logger.error("启动算法库仿真时发生Exception：", e);
        } catch (IOException e) {
            logger.error("启动可靠性仿真评估算法库仿真时发生Exception：", e);
            e.printStackTrace();
            result = Result.error(e.getMessage());
            throw new RenException("启动可靠性仿真评估算法库失败: errorMsg=" + e.getMessage());
        } finally {
            if (is != null) {
                try {
@@ -773,7 +772,7 @@
            insert(simulatAssess);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("组装算法库仿真计算用模型XML失败: " + e.getMessage());
            throw new RenException("组装算法库仿真计算用模型XML失败: " + e.getMessage());
        }
    }

@@ -1113,7 +1112,8 @@
                break;
            case 3:
                // 二项分布
                if (taskBinoParam.getSimulatTimes().intValue() == taskBinoParam.getSuccessTimes().intValue()) {
                if ((taskBinoParam.getSimulatTimes() == null && taskBinoParam.getSuccessTimes() == null) ||
                        (taskBinoParam.getSimulatTimes().intValue() == taskBinoParam.getSuccessTimes().intValue())) {
                    // 相等则为成败型
                    failureModel.setType(FailureModel.TYPE_FIX);
                    failureModel.setParam1(taskBinoParam.getSuccessRate());

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

@@ -35,6 +35,8 @@
    @Autowired
    private ModelRbdDao modelRbdDao;
    @Autowired
    private AlgorithmDao algorithmDao;
    @Autowired
    private XhProductModelDao xhProductModelDao;
    @Autowired
    private ParamDataDao paramDataDao;
@@ -73,97 +75,215 @@
     * 4）建模未完成
     * 5）设备参数未配置
     * 可以对所有任务模型进行检查，也可以只检查入参指定的产品节点下的任务模型；前者适合在页面列表显示全体建模状态，后者适合对某任务进行仿真时的检查。
     *
     * @param productId 产品节点ID（一般为总体）
     * @return 检查出的错误的List，长度为0表示没有错误，不会返回null
     */
    public List<TaskModelCheckResultDto> checkTaskModel(Long productId, Long taskModelId) {
    public List<TaskModelCheckResultDto> checkTaskModel(Long productId, Long taskId) {
        List<TaskModelCheckResultDto> checkResult = new ArrayList<>();
        List<XhProductModel> deviceUsedList = new ArrayList<>();    // 检查对象模型中使用到的所有设备

        // 1. 获取数据
        // 1.1 获取所有任务模型数据List
        List<Task> taskModelList = baseDao.getTaskModels(productId, taskModelId);
        // 1.2 获取所有任务模型阶段数据List
        List<TaskPhase> taskModelPhaseList = baseDao.getTaskModelPhases(productId, taskModelId);
        // 1.3 获取所有任务模型工况数据List
        List<TaskPhaseModel> taskModelPhaseModelList = baseDao.getTaskModelPhaseModels(productId, taskModelId);
        // 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<ModelNodeAlgorithm> rbdNodeList = modelNodeAlgorithmDao.getRbdNodes();
        // 1.6 获取所有工况模型树数据List
        // 1.5 获取所有工况模型树数据List
        List<OperatConditModel> gkModelList = operatConditModelDao.getGKModelTrees(productId);
        // 1.7 获取所有RBD数据List
        Map<String, Object> mapFilter = new HashMap<>();
        mapFilter.put("productId", productId);
        List<ModelRbd> modelRbdList = modelRbdDao.getList(mapFilter);
        // 1.8 获取所有设备参数（含任务模型的二项分布参数）List
        // 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);
        List<TaskBinoParam> binoParamList = taskBinoParamDao.getBinoParams(taskModelId);
        // 1.8 获取该任务的二项分布参数）List
        List<TaskBinoParam> binoParamList = taskBinoParamDao.getBinoParams(taskId);

        // 2. 检查每个任务模型的数据完整性（递归）
        for (Task taskModel : taskModelList) {
            if (null == taskModel.getTaskDuration() || 0.0 == taskModel.getTaskDuration()) {
        // 2. 检查每个任务模型的数据完整性
        for (Task task : taskList) {
            if (null == task.getTaskDuration() || 0.0 == task.getTaskDuration()) {
                // 2.1 任务总时长未配置
                setTaskModelCheckResult(taskModel,
                        null,
                        null, null, null,
                setTaskModelCheckResult(task, null, null,
                        null, null, null, null,
                        TaskModelCheckResultDto.CATEGORY_TASK_TIME, checkResult);
            }
            List<TaskPhase> phases = taskModelPhaseList.stream().filter(item ->
                    taskModel.getId().equals(item.getTaskId())).collect(Collectors.toList());
            List<TaskPhase> phases = taskPhaseList.stream().filter(item ->
                    task.getId().equals(item.getTaskId())).collect(Collectors.toList());
            for (TaskPhase phase : phases) {
                if (null == phase.getPhaseDurationRate() || 0.0 == phase.getPhaseDurationRate()) {
                    // 2.2 阶段时长未配置
                    setTaskModelCheckResult(taskModel,
                            phase,
                            null, null, null,
                    setTaskModelCheckResult(task, phase, null,
                            null, null, null, null,
                            TaskModelCheckResultDto.CATEGORY_PHASE_TIME, checkResult);
                }
                List<TaskPhaseModel> phaseModels = taskModelPhaseModelList.stream().filter(item ->
                        phase.getId().equals(item.getPhaseId())).collect(Collectors.toList());
                List<TaskPhaseModel> phaseModels = taskPhaseModelList.stream().filter(item ->
                        phase.getId().equals(item.getPhaseId()) && 0.0 != item.getOperatConditDurationRate()).
                        collect(Collectors.toList());
                if (phaseModels.size() <= 0) {
                    // 无工况模型数据
                    // 2.3 工况时长未配置
                    setTaskModelCheckResult(taskModel,
                            phase,
                            null, null, null,
                    setTaskModelCheckResult(task, phase, null,
                            null, null, null, null,
                            TaskModelCheckResultDto.CATEGORY_GK_TIME, checkResult);
                } else {
                    // 有工况模型数据
                    List<TaskPhaseModel> phaseModelWithDurations = taskModelPhaseModelList.stream().filter(item ->
                            0.0 != item.getOperatConditDurationRate()).collect(Collectors.toList());
                    if (phaseModelWithDurations.size() <= 0) {
                        // 无工况模型被选用
                        // 2.3 工况时长未配置
                    // 有工况被选用，检查选用的工况
                        for (TaskPhaseModel taskPhaseModel : phaseModels) {
                            setTaskModelCheckResult(taskModel,
                                    phase,
                                    taskPhaseModel,
                                    null, null,
                                    TaskModelCheckResultDto.CATEGORY_GK_TIME, checkResult);
                        }
                    } else {
                        // 有工况模型被选用，检查选用的工况模型
                        for (TaskPhaseModel taskPhaseModel : phaseModelWithDurations) {
                            // 首先找到顶层模型
                            List<OperatConditModel> gkModelTops = gkModelList.stream().filter(item ->
                                    taskPhaseModel.getOperatConditId().equals(item.getOperatConditId())
                                            && taskModel.getProductId().equals(item.getProductId())).collect(Collectors.toList());
                            if (gkModelTops.size() <= 0) {
                                // 无工况模型树根节点，即意味着无工况模型树
                        List<OperatConditModel> gkModelTree = gkModelList.stream().filter(item ->
                                taskPhaseModel.getOperatConditId().equals(item.getOperatConditId())).collect(Collectors.toList());
                        if (gkModelTree.size() <= 0) {
                            // 无工况模型树
                                XhProductModel node = (XhProductModel) productTreeList.stream().filter(item ->
                                        taskModel.getProductId().equals(item.getId())).collect(Collectors.toList()).get(0);
                                setTaskModelCheckResult(taskModel,
                                        phase,
                                        taskPhaseModel,
                                        null,
                                        node,
                                    task.getProductId().equals(item.getId())).collect(Collectors.toList()).get(0);
                            setTaskModelCheckResult(task, phase, taskPhaseModel,
                                    node, null, null, null,
                                        TaskModelCheckResultDto.CATEGORY_GK_MODEL, checkResult);
                            } else {
                                // 有工况模型树，检查其完整性
//                                checkGkModel(taskModel, phase, taskPhaseModel, gkModelTops.get(0),
//                                        deviceUsedList, checkResult);
                            for (OperatConditModel gkModel : gkModelTree) {
                                XhProductModel node = (XhProductModel) productTreeList.stream().filter(item ->
                                        gkModel.getProductId().equals(item.getId())).collect(Collectors.toList()).get(0);
                                if (null == gkModel.getModelId()) {
                                    // 工况模型树不完整
                                    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) {
                                        // 建模未完成
                                        setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                node, null, null, null,
                                                TaskModelCheckResultDto.CATEGORY_MODEL, checkResult);
                                    } else {
                                        if (!"已完成".equals(modelRbds.get(0).getModelState())) {
                                            // 建模未完成
                                            setTaskModelCheckResult(task, phase, taskPhaseModel,
                                                    node, modelRbds.get(0), null, null,
                                                    TaskModelCheckResultDto.CATEGORY_MODEL, 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);
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
@@ -176,69 +296,41 @@

    }

    // 递归函数
    private void checkGkModel(Task taskModel,
                              TaskPhase phase,
    private void setTaskModelCheckResult(Task task,
                                         TaskPhase taskPhase,
                              TaskPhaseModel taskPhaseModel,
                              OperatConditModel gkModelTreeTop,
                              List<OperatConditModel> gkModelList,
                              List<ModelNodeAlgorithm> rbdNodeList,
                              List<XhProductModel> productTreeList,
                              List<XhProductModel> deviceUsedList,
                              List<TaskModelCheckResultDto> checkResult) {
        // 首先找到顶层模型
        List<OperatConditModel> gkModelTops = gkModelList.stream().filter(item ->
                taskPhaseModel.getOperatConditId().equals(item.getOperatConditId())
                        && taskModel.getProductId().equals(item.getProductId())).collect(Collectors.toList());
        if (gkModelTops.size() <= 0) {
            // 工况模型树不完整（顶层节点未配置模型）
            XhProductModel node = (XhProductModel) productTreeList.stream().filter(item ->
                    taskModel.getProductId().equals(item.getId())).collect(Collectors.toList()).get(0);
            setTaskModelCheckResult(taskModel,
                    phase,
                    taskPhaseModel,
                    null,
                    node,
                    TaskModelCheckResultDto.CATEGORY_GK_MODEL, checkResult);
        }
    }

    private void setTaskModelCheckResult(Task taskModel,
                                         TaskPhase taskModelPhase,
                                         TaskPhaseModel taskModelPhaseModel,
                                         OperatConditModel gkModel,
                                         XhProductModel node,
                                         ModelRbd model,
                                         XhProductModel device,
                                         String paramName,
                                         String category,
                                         List<TaskModelCheckResultDto> checkResult) {
        TaskModelCheckResultDto result = new TaskModelCheckResultDto();
        result.setCategory(category);
        result.setProductId(taskModel.getProductId());
        result.setTaskModelId(taskModel.getId());
        result.setTaskModelName(taskModel.getTaskName());
        switch(category) {
            case TaskModelCheckResultDto.CATEGORY_TASK_TIME:
                break;
            case TaskModelCheckResultDto.CATEGORY_PHASE_TIME:
                result.setTaskModelPhaseId(taskModelPhase.getId());
                result.setTaskModelPhaseName(taskModelPhase.getPhaseName());
                break;
            case TaskModelCheckResultDto.CATEGORY_GK_TIME:
                result.setTaskModelPhaseId(taskModelPhase.getId());
                result.setTaskModelPhaseName(taskModelPhase.getPhaseName());
                if (null != taskModelPhaseModel) {
                    result.setGkId(taskModelPhaseModel.getOperatConditId());
                    result.setGkName(taskModelPhaseModel.getOperatConditName());
        result.setProductId(task.getProductId());
        result.setTaskId(task.getId());
        result.setTaskName(task.getTaskName());
        if (taskPhase != null) {
            result.setTaskPhaseId(taskPhase.getId());
            result.setTaskPhaseName(taskPhase.getPhaseName());
                }
                break;
            case TaskModelCheckResultDto.CATEGORY_GK_MODEL:
                result.setTaskModelPhaseId(taskModelPhase.getId());
                result.setTaskModelPhaseName(taskModelPhase.getPhaseName());
                result.setGkId(taskModelPhaseModel.getOperatConditId());
                result.setGkName(taskModelPhaseModel.getOperatConditName());
        if (taskPhaseModel != null) {
            result.setGkId(taskPhaseModel.getOperatConditId());
            result.setGkName(taskPhaseModel.getOperatConditName());
        }
        if (node != null) {
                result.setNodeId(node.getId());
                result.setNodeName(node.getName());
                break;
        }
        if (model != null) {
            result.setModelId(model.getId());
            result.setModelName(model.getModelName());
        }
        if (device != null) {
            result.setDeviceId(device.getId());
            result.setDeviceName(device.getName());
        }
        result.setParamName(paramName);
        checkResult.add(result);
    }
}

 modules/mainPart/src/main/resources/mapper/taskReliability/ModelRbdDao.xml

@@ -43,6 +43,16 @@
        </where>
        limit 1
    </select>
    <select id="getListAll" resultType="com.zt.life.modules.mainPart.taskReliability.model.ModelRbd">
        select a.*,
        CASE
        WHEN b.end =1 THEN '已完成'
        ELSE '未完成' END AS modelState
        from model_rbd a
        left join (select model_id,1 as end from algorithm where model_type = 'end' and is_delete=0 ) b on b.model_id = a.id
        where
            a.is_delete = 0
    </select>

    <update id="deleteByModelId">
        delete

 modules/mainPart/src/main/resources/mapper/taskReliability/TaskBinoParamDao.xml

@@ -68,8 +68,6 @@
            task_bino_param a
        where
            a.IS_DELETE=0
        <if test="shipId!=null">
            and a.task_id = #{taskModelId}
        </if>
            and a.task_id = #{taskId}
    </select>
</mapper>

 modules/mainPart/src/main/resources/mapper/taskReliability/TaskDao.xml

@@ -26,7 +26,7 @@
        and a.product_id=${productId}
    </select>

    <select id="getTaskModels" resultType="com.zt.life.modules.mainPart.taskReliability.model.Task">
    <select id="getTasks" resultType="com.zt.life.modules.mainPart.taskReliability.model.Task">
        select
            a.*
        FROM
@@ -36,12 +36,12 @@
        <if test="productId!=null">
            and a.product_id=${productId}
        </if>
        <if test="taskModelId!=null">
            and a.id=${taskModelId}
        <if test="taskId!=null">
            and a.id=${taskId}
        </if>
        ORDER BY a.task_sort
    </select>
    <select id="getTaskModelPhases" resultType="com.zt.life.modules.mainPart.taskReliability.model.TaskPhase">
    <select id="getTaskPhases" resultType="com.zt.life.modules.mainPart.taskReliability.model.TaskPhase">
        select
            b.*
        FROM
@@ -53,12 +53,12 @@
        <if test="productId!=null">
            and a.product_id=${productId}
        </if>
        <if test="taskModelId!=null">
            and a.id=${taskModelId}
        <if test="taskId!=null">
            and a.id=${taskId}
        </if>
        ORDER BY a.task_sort, b.phase_sort
    </select>
    <select id="getTaskModelPhaseModels" resultType="com.zt.life.modules.mainPart.taskReliability.model.TaskPhaseModel">
    <select id="getTaskPhaseModels" resultType="com.zt.life.modules.mainPart.taskReliability.model.TaskPhaseModel">
        select
            c.*
        FROM
@@ -75,8 +75,8 @@
            and a.product_id=${productId}
            and d.product_id=${productId}
        </if>
        <if test="taskModelId!=null">
            and a.id=${taskModelId}
        <if test="taskId!=null">
            and a.id=${taskId}
        </if>
        ORDER BY a.task_sort, b.phase_sort
    </select>

 web/src/views/modules/basicInfo/ParamData.vue

@@ -335,7 +335,12 @@
          {
            value: 1,
            label: '指数分布'
          }, {
          },
          {
            value: 2,
            label: '威布尔分布'
          },
          {
            value: 3,
            label: '二项分布'
          }

 web/src/views/modules/taskReliability/ReliabilityAssess.vue

@@ -143,6 +143,7 @@
      async assess() {
        if (!this.dataForm.productId || !this.dataForm.taskId || !this.dataForm.itemId || !this.dataForm.confidence) {
          this.$tip.alert("有未填写的数据")
          return
        }
        let res = await this.$http.post('/taskReliability/ReliabilityAssess/assess', this.dataForm)
        console.log(res.data)

 web/src/views/modules/taskReliability/SimulatAssess.vue

@@ -35,6 +35,23 @@
            </div>
          </el-col>
    </el-row>
    <el-dialog :close-on-click-modal="false" :visible.sync="dialogVisible" title="模型检查" width="60%" @close="dialogVisible = false">
      <el-tag type="danger">模型定义/参数配置里存在以下问题：</el-tag>
      <el-table :data="modelCheckResult" height="100px" v-adaptive="{bottomOffset:30}"
                :header-cell-style="{'text-align':'center'}">
        <el-table-column prop="category" label="检查结果" align="center" width="150"/>
        <el-table-column prop="taskName" label="任务名称" align="center"/>
        <el-table-column prop="taskPhaseName" label="任务阶段名称" align="center"/>
        <el-table-column prop="gkName" label="工况名称" align="center"/>
        <el-table-column prop="nodeName" label="节点名称" align="center"/>
        <el-table-column prop="modelName" label="模型名称" align="center"/>
        <el-table-column prop="deviceName" label="设备名称" align="center"/>
        <el-table-column prop="paramName" label="参数名称" align="center"/>
      </el-table>
      <div slot="footer" class="dialog-footer">
        <el-button type="primary" @click="dialogVisible = false">关 闭</el-button>
      </div>
    </el-dialog>
  </div>
</template>

@@ -63,8 +80,10 @@
          dataType: 'fz',
          samplPeriod: '10',
          simulatFrequency: 500,
          simulatTime: ''
        }
          simulatTime: '',
        },
        dialogVisible: false,
        modelCheckResult: [],
      }
    },
    mounted() {
@@ -132,16 +151,20 @@
        }
      },
      async analyze() {
        this.dialogVisible = false
        this.modelCheckResult = []
        this.isShow = true
        let result = await this.$http.get(`/basicInfo/TyProductModel/getUuid`)
        this.dataForm.id = result.data
        let res = await this.$http.post('/taskReliability/SimulatAssess/analyze', this.dataForm)
        if (res.success) {
          // let chkResult = res.data
          // console.log(chkResult)
          // if (chkResult.length == 0) {
          console.log(res.data)
          if (res.data != null && res.data.length > 0) {
            this.modelCheckResult = res.data
            this.dialogVisible = true
          } else {
            this.timers = window.setInterval(this.getStroke, 1000)
          // }
          }
        }
      }
    }