ReliabilitySimulation.git

			@@ -6,7 +6,7 @@
			import com.zt.life.modules.mainPart.basicInfo.model.ParamData;
			import com.zt.life.modules.mainPart.basicInfo.model.XhProductModel;
			import com.zt.life.modules.mainPart.taskReliability.dao.*;
			import com.zt.life.modules.mainPart.taskReliability.dto.TaskModelCheckResult;
			import com.zt.life.modules.mainPart.taskReliability.dto.TaskModelCheckResultDto;
			import com.zt.life.modules.mainPart.taskReliability.model.*;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.stereotype.Service;
			@@ -22,11 +22,11 @@
			/**
			* task
			*
			* @author zt generator
			* @author zt generator
			* @since 1.0.0 2024-03-15
			*/
			@Service
			public class TaskService extends BaseService<TaskDao, Task> {
			public class TaskService extends BaseService<TaskDao, Task> {

			@Autowired
			private OperatConditModelDao operatConditModelDao;
			@@ -35,11 +35,15 @@
			@Autowired
			private ModelRbdDao modelRbdDao;
			@Autowired
			private AlgorithmDao algorithmDao;
			@Autowired
			private XhProductModelDao xhProductModelDao;
			@Autowired
			private ParamDataDao paramDataDao;
			@Autowired
			private TaskBinoParamDao taskBinoParamDao;
			@Autowired
			private ReliabilityAssessDao reliabilityAssessDao;

			/**
			* 分页查询
			@@ -61,109 +65,235 @@
			}

			public List<Task> getTaskList(Long productId) {
			return baseDao.getTaskList(productId);
			return baseDao.getTaskList(productId);
			}

			/**
			* 对任务可靠性模型及其参数配置进行完整性检查，并指出以下5类错误：
			* 0）任务总时长未配置
			* 1）阶段时长未配置
			* 2）工况时长未配置
			* 3）工况模型树不完整
			* 4）建模未完成
			* 5）设备参数未配置
			* 可靠性仿真评估：对任务可靠性模型及其参数配置进行完整性检查，并指出以下6类错误：
			* 1）任务总时长未配置
			* 2）阶段时长未配置
			* 3）工况时长未配置
			* 4）工况模型树不完整
			* 5）建模未完成
			* 6）设备参数未配置
			* 可以对所有任务模型进行检查，也可以只检查入参指定的产品节点下的任务模型；前者适合在页面列表显示全体建模状态，后者适合对某任务进行仿真时的检查。
			*
			* @param productId 产品节点ID（一般为总体）
			* @return 检查出的错误的List，长度为0表示没有错误，不会返回null
			*/
			public List<TaskModelCheckResult> checkTaskModel(Long productId, Long taskModelId) {
			List<TaskModelCheckResult> checkResult = new ArrayList<>();
			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,
			TaskModelCheckResult.CATEGORY_TASK_TIME, checkResult);
			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,
			TaskModelCheckResult.CATEGORY_PHASE_TIME, checkResult);
			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,
			TaskModelCheckResult.CATEGORY_GK_TIME, checkResult);
			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,
			TaskModelCheckResult.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) {
			// 无工况模型树根节点，即意味着无工况模型树
			// 有工况被选用，检查选用的工况
			for (TaskPhaseModel taskPhaseModel : phaseModels) {
			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 ->
			task.getProductId().equals(item.getId())).collect(Collectors.toList()).get(0);
			setTaskModelCheckResult(task, phase, taskPhaseModel,
			node, null, null, null,
			TaskModelCheckResultDto.CATEGORY_GK_MODEL, checkResult);
			} else {
			// 有工况模型树，检查其完整性
			for (OperatConditModel gkModel : gkModelTree) {
			XhProductModel node = (XhProductModel) productTreeList.stream().filter(item ->
			taskModel.getProductId().equals(item.getId())).collect(Collectors.toList()).get(0);
			setTaskModelCheckResult(taskModel,
			phase,
			taskPhaseModel,
			null,
			node,
			TaskModelCheckResult.CATEGORY_GK_MODEL, checkResult);
			} else {
			// 有工况模型树，检查其完整性
			// checkGkModel(taskModel, phase, taskPhaseModel, gkModelTops.get(0),
			// deviceUsedList, checkResult);
			gkModel.getProductId().equals(item.getId())).collect(Collectors.toList()).get(0);
			if (isNodeInRbdOfParent(node, gkModelTree, rbdNodeList)) {
			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 (param.getRepairable() == null) {
			setTaskModelCheckResult(task, phase, taskPhaseModel,
			node, modelRbds.get(0), device, "是否可维修",
			TaskModelCheckResultDto.CATEGORY_PARAM, checkResult);
			} else {
			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 +306,278 @@

			}

			// 递归函数
			private void checkGkModel(Task taskModel,
			TaskPhase phase,
			TaskPhaseModel taskPhaseModel,
			OperatConditModel gkModelTreeTop,
			List<OperatConditModel> gkModelList,
			List<ModelNodeAlgorithm> rbdNodeList,
			List<XhProductModel> productTreeList,
			List<XhProductModel> deviceUsedList,
			List<TaskModelCheckResult> 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,
			TaskModelCheckResult.CATEGORY_GK_MODEL, checkResult);
			private boolean isNodeInRbdOfParent(XhProductModel node,
			List<OperatConditModel> gkModelTree,
			List<ModelNodeAlgorithm> rbdNodeList) {
			boolean result = false;
			List<OperatConditModel> parents = gkModelTree.stream().filter(item ->
			item.getProductId().equals(node.getPid())).collect(Collectors.toList());
			if (parents.size() > 0) {
			OperatConditModel parent = parents.get(0);
			if (parent.getModelId() != null) {
			List<ModelNodeAlgorithm> nodes = rbdNodeList.stream().filter(item ->
			item.getModelId().equals(parent.getModelId()) && item.getDataId().equals(node.getId())).collect(Collectors.toList());
			if (nodes.size() > 0) {
			result = true;
			}
			}
			}

			return result;
			}

			private void setTaskModelCheckResult(Task taskModel,
			TaskPhase taskModelPhase,
			TaskPhaseModel taskModelPhaseModel,
			OperatConditModel gkModel,
			XhProductModel node,
			String category,
			List<TaskModelCheckResult> checkResult) {
			TaskModelCheckResult result = new TaskModelCheckResult();
			result.setCategory(category);
			result.setProductId(taskModel.getProductId());
			result.setTaskModelId(taskModel.getId());
			result.setTaskModelName(taskModel.getTaskName());
			switch(category) {
			case TaskModelCheckResult.CATEGORY_TASK_TIME:
			break;
			case TaskModelCheckResult.CATEGORY_PHASE_TIME:
			result.setTaskModelPhaseId(taskModelPhase.getId());
			result.setTaskModelPhaseName(taskModelPhase.getPhaseName());
			break;
			case TaskModelCheckResult.CATEGORY_GK_TIME:
			result.setTaskModelPhaseId(taskModelPhase.getId());
			result.setTaskModelPhaseName(taskModelPhase.getPhaseName());
			if (null != taskModelPhaseModel) {
			result.setGkId(taskModelPhaseModel.getOperatConditId());
			result.setGkName(taskModelPhaseModel.getOperatConditName());
			/**
			* 可靠性评定：对任务可靠性模型、参数配置、可靠性评定数据进行完整性检查，并指出以下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, Long itemId) {
			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<ReliabilityAssess> assessDataList = reliabilityAssessDao.getProductList(productId, itemId);

			// 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);
			}
			break;
			case TaskModelCheckResult.CATEGORY_GK_MODEL:
			result.setTaskModelPhaseId(taskModelPhase.getId());
			result.setTaskModelPhaseName(taskModelPhase.getPhaseName());
			result.setGkId(taskModelPhaseModel.getOperatConditId());
			result.setGkName(taskModelPhaseModel.getOperatConditName());
			result.setNodeId(node.getId());
			result.setNodeName(node.getName());
			break;
			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 (isNodeInRbdOfParent(node, gkModelTree, rbdNodeList)) {
			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) {
			// 2.9 设备参数未配置
			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 && param.getReliabDistribType() != 3) {
			// 2.10 目前不支持二项分布和指数分布以外的分布类型
			setTaskModelCheckResult(task, phase, taskPhaseModel,
			node, modelRbds.get(0), device, "可靠性分布类型",
			TaskModelCheckResultDto.CATEGORY_DISTRIBUTION_NOT_SUPPORT, checkResult);
			} else {
			List<ReliabilityAssess> assessDatas = assessDataList.stream().filter(item ->
			item.getId().equals(device.getId())).collect(Collectors.toList());
			if (assessDatas.size() ==0) {
			// 2.11 评定数据未录入
			setTaskModelCheckResult(task, phase, taskPhaseModel,
			node, modelRbds.get(0), device, null,
			TaskModelCheckResultDto.CATEGORY_NO_ASSESS_DATA, checkResult);
			} else {
			ReliabilityAssess assessData = assessDatas.get(0);
			if (assessData.getFailNum() == null \|\| assessData.getFailNum() == 0) {
			// 2.11 评定数据未录入
			setTaskModelCheckResult(task, phase, taskPhaseModel,
			node, modelRbds.get(0), device, "故障次数",
			TaskModelCheckResultDto.CATEGORY_NO_ASSESS_DATA, checkResult);
			}
			if (param.getReliabDistribType() == 1 &&
			(assessData.getRunTimes() == null \|\| assessData.getRunTimes() == 0.0)) {
			// 2.11 评定数据未录入
			setTaskModelCheckResult(task, phase, taskPhaseModel,
			node, modelRbds.get(0), device, "试验时间",
			TaskModelCheckResultDto.CATEGORY_NO_ASSESS_DATA, checkResult);
			}
			if (param.getReliabDistribType() == 3 &&
			(assessData.getRunNum() == null \|\| assessData.getRunNum() == 0.0)) {
			// 2.11 评定数据未录入
			setTaskModelCheckResult(task, phase, taskPhaseModel,
			node, modelRbds.get(0), device, "试验次数",
			TaskModelCheckResultDto.CATEGORY_NO_ASSESS_DATA, 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,
			XhProductModel node,
			ModelRbd model,
			XhProductModel device,
			String paramName,
			String category,
			List<TaskModelCheckResultDto> checkResult) {
			TaskModelCheckResultDto result = new TaskModelCheckResultDto();
			result.setCategory(category);
			result.setProductId(task.getProductId());
			result.setTaskId(task.getId());
			result.setTaskName(task.getTaskName());
			if (taskPhase != null) {
			result.setTaskPhaseId(taskPhase.getId());
			result.setTaskPhaseName(taskPhase.getPhaseName());
			}
			if (taskPhaseModel != null) {
			result.setGkId(taskPhaseModel.getOperatConditId());
			result.setGkName(taskPhaseModel.getOperatConditName());
			}
			if (node != null) {
			result.setNodeId(node.getId());
			result.setNodeName(node.getName());
			}
			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);
			}
			}