修改

jinlin

2024-09-20 275125ec506507e7a644ab3b3079f618c64d1fea

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

@@ -2,24 +2,30 @@

import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONArray;
import cn.hutool.json.XML;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.spire.pdf.tables.table.convert.Convert;
import com.zt.common.exception.RenException;
import com.zt.common.service.BaseService;
import com.zt.common.servlet.Result;
import com.zt.common.utils.TreeUtils;
import com.zt.common.utils.UUIDUtil;
import com.zt.life.modules.mainPart.basicInfo.dao.ParamDataDao;
import com.zt.life.modules.mainPart.basicInfo.dao.XhProductModelDao;
import com.zt.life.modules.mainPart.basicInfo.model.ParamData;
import com.zt.life.modules.mainPart.basicInfo.model.XhProductModel;
import com.zt.life.modules.mainPart.basicInfo.service.XhProductModelService;
import com.zt.life.modules.mainPart.taskReliability.dao.*;
import com.zt.common.utils.JsonUtils2;
import com.zt.life.modules.mainPart.taskReliability.dao.SimulatAssessDao;
import com.zt.life.modules.mainPart.taskReliability.dao.TimeDiagramDao;
import com.zt.life.modules.mainPart.taskReliability.dto.*;
import com.zt.life.modules.mainPart.taskReliability.dto.ProductStatusDto;
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.dto.TaskPhaseConstraintDto;
import com.zt.life.modules.mainPart.taskReliability.model.*;
import com.zt.life.modules.mainPart.utils.GetStringSpace;
import org.apache.commons.io.IOUtils;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
@@ -27,7 +33,6 @@
import org.dom4j.io.XMLWriter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.zt.life.modules.mainPart.taskReliability.dto.StatusDto;
import com.zt.life.modules.mainPart.taskReliability.model.ModelRbd;
import com.zt.life.modules.mainPart.taskReliability.model.SimulatAssess;
import com.zt.life.modules.mainPart.taskReliability.model.SimulatAssessTaskPhaseModel;
@@ -38,18 +43,8 @@
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.awt.*;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringWriter;
import java.util.ArrayList;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.io.*;
import java.util.*;
import java.util.stream.Collectors;


@@ -62,7 +57,8 @@
@Service
public class SimulatAssessService extends BaseService<SimulatAssessDao, SimulatAssess> {
    private static final Logger logger = LoggerFactory.getLogger(SimulatAssessService.class);
    private static final String RELIA_SIM_TASK_TYPE_SIMULATION = "calcreq";
    public static final String RELIA_SIM_TASK_TYPE_SIMULATION = "calcreq";
    public static final String RELIA_SIM_TASK_TYPE_PROGRESS = "calcprog";

    @Value("${spring.redis.host}")
    private String redisHost;
@@ -72,13 +68,13 @@
    private String reliaSimMain;
    @Value("${data.reliaSimLib.resultHome}")
    private String resultHome;
    @Value("${data.reliaSimLib.fixedRandomSeed}")
    private String fixedRandomSeed;

    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private TaskService taskService;
    @Autowired
    private TaskPhaseService taskPhaseService;
    @Autowired
    private SimulatAssessTaskPhaseModelService simulatAssessTaskPhaseModelService;
    @Autowired
@@ -113,6 +109,8 @@
    Map<String, JSONObject> templetsMap = new HashMap<>();
    Map<String, String> templetsStrMap = new HashMap<>();

    private JSONObject xmlJSONObj;


    /**
     * 分页查询
@@ -137,8 +135,12 @@
        return baseDao.getNumById(productId, taskModelId);
    }

    public List<SimulatAssess> getList(Long productId, Long taskModelId) {
        return baseDao.getList(productId, taskModelId);
    public List<SimulatAssess> getList(Long taskModelId) {
        return baseDao.getList(taskModelId);
    }

    public SimulatAssess getByTaskId(Long taskModelId) {
        return baseDao.getByTaskId(taskModelId);
    }

    public SimulatAssess getParams(Long id, Long taskModelId) {
@@ -180,7 +182,7 @@
        this.getPetsInfo();
        double x1 = 0;
        double x2 = 0;
        int y = 0;
        int y = -10;
        int groupY = 0;
        int spaceHeight = 20;
        int groupHeight = 20;
@@ -208,9 +210,9 @@
                x2 = x1 + status.getTimes() * pointNumPerHour + 5;
                JSONObject lineJson = new JSONObject(templetsStrMap.get(status.getStatus()));
                setlineXy(lineJson, x1, y, x2, y, "");
                JsonUtils2.setJsonValueByPath(lineJson,"data/status".split("/"),status.getStatus());
                JsonUtils2.setJsonValueByPath(lineJson,"data/startTimes".split("/"),String.format("%.4f", x1));
                JsonUtils2.setJsonValueByPath(lineJson,"data/endTimes".split("/"),String.format("%.4f", x1 + status.getTimes()));
                JsonUtils2.setJsonValueByPath(lineJson, "data/status".split("/"), status.getStatus());
                JsonUtils2.setJsonValueByPath(lineJson, "data/startTimes".split("/"), String.format("%.4f", x1));
                JsonUtils2.setJsonValueByPath(lineJson, "data/endTimes".split("/"), String.format("%.4f", x1 + status.getTimes()));
                JsonUtils2.setJsonValueByPath(lineJson, "id".split("/"), UUIDUtil.generateId().toString());
                x1 = x2 - 5;
                jsonArray.add(lineJson);
@@ -221,14 +223,13 @@
            JsonUtils2.setJsonValueByPath(textJson, "position/x".split("/"), 20);
            JsonUtils2.setJsonValueByPath(textJson, "position/y".split("/"), y - 15);
            jsonArray.add(textJson);

        }

        //图例
        int spaceWitdth = 80;
        x1 = -spaceWitdth;
        x2 = -11;
        y = -130;
        y = -110;
        String[] tlArr = "O,F,I,S,M".split(",");
        for (String s : tlArr) {
            JSONObject f = templetsMap.get(s);
@@ -241,12 +242,12 @@
        //阶段模型及刻度
        x1 = 0;
        x2 = 0;
        double y1 = -100;
        y = -70;
        double y1 = -80;
        y = -60;
        double y2 = -50;

        JSONObject modelJson = new JSONObject(templetsStrMap.get("model"));
        setlineXy(modelJson, 2, y1, 2, y2, null);
        setlineXy(modelJson, 1, y1, 1, y2, null);
        jsonArray.add(modelJson);
        double totalHours = 0;
        for (int i = 0; i < modelDtoList.size(); i++) {
@@ -270,17 +271,18 @@
                modelName = modelRbd.getModelName();
                modelId = modelRbd.getId().toString();
            }
            Map<String, Integer> mapSpace = GetStringSpace.getStringSpaceSize(modelName, null, 18);
            Map<String, Integer> mapSpace = GetStringSpace.getStringSpaceSize(modelName, null, 12);
            JSONObject textJson = new JSONObject(templetsStrMap.get("text"));
            JsonUtils2.setJsonValueByPath(textJson, "data/dataId".split("/"), modelId);
            JsonUtils2.setJsonValueByPath(textJson, "id".split("/"), UUIDUtil.generateId().toString());
            JsonUtils2.setJsonValueByPath(textJson, "attrs/label/textWrap/text".split("/"), modelName);
            JsonUtils2.setJsonValueByPath(textJson, "attrs/label/textWrap/text".split("/"), "模型"+(i+1));
            JsonUtils2.setJsonValueByPath(textJson, "attrs/label/textWrap/modelName".split("/"), modelName);

            JsonUtils2.setJsonValueByPath(textJson, "size/width".split("/"), mapSpace.get("width") + 20);
            JsonUtils2.setJsonValueByPath(textJson, "size/width".split("/"), mapSpace.get("width")+10);

            double x11 = x1 + ((gkPoint - mapSpace.get("width") - 20) / 2);
            double x11 = x1 + ((gkPoint - mapSpace.get("width")+12) / 2);
            JsonUtils2.setJsonValueByPath(textJson, "position/x".split("/"), x11);
            JsonUtils2.setJsonValueByPath(textJson, "position/y".split("/"), y1);
            JsonUtils2.setJsonValueByPath(textJson, "position/y".split("/"), y1-10);
            jsonArray.add(textJson);
            x1 = x2;
        }
@@ -288,7 +290,8 @@
        setlineXy(modelJson3, 0, y, x2, y, null);
        jsonArray.add(modelJson3);

        Integer curPointHour = 50, periodHour = 50;
        //刻度
        Integer curPointHour = 100, periodHour = 100;
        while (curPointHour < totalHours) {
            JSONObject modelJson4 = new JSONObject(templetsStrMap.get("model"));
            double x = curPointHour * pointNumPerHour;
@@ -304,7 +307,7 @@

            double x11 = x - mapSpace.get("width") / 2 - 5;
            JsonUtils2.setJsonValueByPath(textJson, "position/x".split("/"), x11);
            JsonUtils2.setJsonValueByPath(textJson, "position/y".split("/"), y2);
            JsonUtils2.setJsonValueByPath(textJson, "position/y".split("/"), y2-10);
            jsonArray.add(textJson);

            curPointHour += periodHour;
@@ -470,214 +473,11 @@
        timeDiagramDao.updateById(diagram);
    }

/*    public void combineDiagram(TimeDiagram networkDiagram) {

        if (!networkDiagram.getDiagramId().equals(1L) && !networkDiagram.getDiagramId().equals(2L))
            return null;
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("projectId", networkDiagram.getProjectId());

        ProjectNetworkDiagram combineDiagram = null;
        params.put("diagramId", 100);
        List<ProjectNetworkDiagram> list = baseDao.getList(params);
        if (list.size() > 0) {
            combineDiagram = list.get(0);
        }

        ProjectNetworkDiagram phaseDiagram = null;
        params.put("diagramId", 1);
        List<ProjectNetworkDiagram> list1 = baseDao.getList(params);
        if (list1.size() > 0) {
            phaseDiagram = list1.get(0);
        }

        ProjectNetworkDiagram inspectDiagram = null;
        params.put("diagramId", 2);
        List<ProjectNetworkDiagram> list2 = baseDao.getList(params);
        if (list2.size() > 0) {
            inspectDiagram = list2.get(0);
        }

        String jsonStr = "";
        Map<String, Map<String, String>> leftMap = new Hashtable<>();
        Map<String, Map<String, String>> rightMap = new Hashtable<>();
        if (phaseDiagram != null && inspectDiagram != null) {
            String inspectJsonStr = inspectDiagram.getContent();
            JSONObject inspectJsonObj = new JSONObject(inspectJsonStr);
            JSONArray inspectJsonArray = inspectJsonObj.getJSONArray("cells");

            String phaseJsonStr = phaseDiagram.getContent();
            JSONObject phaseJsonObj = new JSONObject(phaseJsonStr);
            JSONArray phaseJsonArray = phaseJsonObj.getJSONArray("cells");

            JSONArray leftArray = inspectJsonArray.stream().filter(iter -> "edge".equals(((JSONObject) iter).get("shape"))
                    && "left".equals(((JSONObject) iter).get("phaseType"))).collect(Collectors.toCollection(JSONArray::new));
            int leftPhaseMaxX = 0;
            int phaseY = 0;
            String leftPhaseMaxId = "";
            for (int i = 0; i < leftArray.size(); i++) {
                Map<String, String> tmpMap = new Hashtable<>();

                JSONObject lineObject = (JSONObject) leftArray.get(i);
                String phaseId = lineObject.getStr("phaseId");
                JSONArray phaseArray = phaseJsonArray.stream().filter(iter -> "custom-circle".equals(((JSONObject) iter).get("shape"))
                        && phaseId.equals(((JSONObject) iter).get("id"))).collect(Collectors.toCollection(JSONArray::new));

                tmpMap.put("lineId", lineObject.getStr("id"));
                tmpMap.put("phaseId", phaseId);
                String portId = "";
                if (phaseArray.size() > 0) {
                    JSONObject phaseObject = (JSONObject) phaseArray.get(0);
                    Object portIdObject = JsonUtils2.getArrJsonValueByPath(phaseObject, "ports/items/".split("/"), "group", "right", "id");
                    //portId = portIdObject == null ? "" : portIdObject.toString();
                    Object xObject = JsonUtils2.getJsonValueByPath(phaseObject, "position/x".split("/"));
                    int x = xObject == null ? 0 : Convert.toInt(xObject.toString());
                    if (x > leftPhaseMaxX) {
                        leftPhaseMaxX = x;
                        leftPhaseMaxId = phaseObject.getStr("id");
                    }
                    if (phaseY == 0) {
                        Object yObject = JsonUtils2.getJsonValueByPath(phaseObject, "position/y".split("/"));
                        phaseY = yObject == null ? 0 : Convert.toInt(yObject.toString());
                    }
                }
                tmpMap.put("portId", portId);
                leftMap.put(lineObject.getStr("id"), tmpMap);
            }

            JSONArray rightArray = inspectJsonArray.stream().filter(iter -> "edge".equals(((JSONObject) iter).get("shape"))
                    && "right".equals(((JSONObject) iter).get("phaseType"))).collect(Collectors.toCollection(JSONArray::new));
            int rightPhaseMinX = 10000000;
            String rightPhaseMinId = "";
            for (int i = 0; i < rightArray.size(); i++) {
                Map<String, String> tmpMap = new Hashtable<>();

                JSONObject lineObject = (JSONObject) rightArray.get(i);
                String phaseId = lineObject.getStr("phaseId");
                JSONArray phaseArray = phaseJsonArray.stream().filter(iter -> "custom-circle".equals(((JSONObject) iter).get("shape"))
                        && phaseId.equals(((JSONObject) iter).get("id"))).collect(Collectors.toCollection(JSONArray::new));

                tmpMap.put("lineId", lineObject.getStr("id"));
                tmpMap.put("phaseId", phaseId);
                String portId = "";
                if (phaseArray.size() > 0) {
                    JSONObject phaseObject = (JSONObject) phaseArray.get(0);
                    Object portIdObject = JsonUtils2.getArrJsonValueByPath(phaseObject, "ports/items/".split("/"), "group", "left", "id");
                    //portId = portIdObject == null ? "" : portIdObject.toString();
                    Object xObject = JsonUtils2.getJsonValueByPath(phaseObject, "position/x".split("/"));
                    int x = xObject == null ? 100000000 : Convert.toInt(xObject.toString());
                    if (x < rightPhaseMinX) {
                        rightPhaseMinX = x;
                        rightPhaseMinId = phaseObject.getStr("id");
                    }
                }
                tmpMap.put("portId", portId);
                rightMap.put(lineObject.getStr("id"), tmpMap);
            }


            JSONArray startArray = inspectJsonArray.stream().filter(iter -> "custom-circle".equals(((JSONObject) iter).get("shape"))
                    && "10000".equals(((JSONObject) iter).get("id"))).collect(Collectors.toCollection(JSONArray::new));
            int inspectBeginX = 0;
            int inspectY = 0;
            if (startArray.size() > 0) {
                JSONObject inspectObject = (JSONObject) startArray.get(0);
                Object xObject = JsonUtils2.getJsonValueByPath(inspectObject, "position/x".split("/"));
                inspectBeginX = xObject == null ? 0 : Convert.toInt(xObject.toString());
                Object yObject = JsonUtils2.getJsonValueByPath(inspectObject, "position/y".split("/"));
                inspectY = yObject == null ? 0 : Convert.toInt(yObject.toString());
            }

            JSONArray endArray = inspectJsonArray.stream().filter(iter -> "custom-circle".equals(((JSONObject) iter).get("shape"))
                    && "20000".equals(((JSONObject) iter).get("id"))).collect(Collectors.toCollection(JSONArray::new));
            int inspectEndX = 10000000;
            if (endArray.size() > 0) {
                JSONObject inspectObject = (JSONObject) endArray.get(0);
                Object xObject = JsonUtils2.getJsonValueByPath(inspectObject, "position/x".split("/"));
                inspectEndX = xObject == null ? 100000000 : Convert.toInt(xObject.toString());
            }

            JSONObject beginObject = null;
            JSONObject endObject = null;
            for (int i = 0; i < inspectJsonArray.size(); i++) {
                JSONObject inspectObject = (JSONObject) inspectJsonArray.get(i);
                String inspectObjectId = inspectObject.getStr("id");
                if (leftMap.get(inspectObjectId) != null) {
                    JsonUtils2.setJsonValueByPath(inspectObject, "target/cell".split("/"), leftMap.get(inspectObjectId).get("phaseId"));
                    JsonUtils2.setJsonValueByPath(inspectObject, "target/port".split("/"), leftMap.get(inspectObjectId).get("portId"));
                }
                if (rightMap.get(inspectObjectId) != null) {
                    JsonUtils2.setJsonValueByPath(inspectObject, "target/cell".split("/"), rightMap.get(inspectObjectId).get("phaseId"));
                    JsonUtils2.setJsonValueByPath(inspectObject, "target/port".split("/"), rightMap.get(inspectObjectId).get("portId"));
                }
                if ("10000".equals(inspectObjectId)) {
                    //inspectJsonArray.remove(inspectObject);
                    beginObject = inspectObject;
                }
                if ("20000".equals(inspectObjectId)) {
                    //inspectJsonArray.remove(inspectObject);
                    endObject = inspectObject;
                }
            }

            if (endObject != null)
                inspectJsonArray.remove(endObject);
            if (beginObject != null)
                inspectJsonArray.remove(beginObject);

            for (int i = 0; i < phaseJsonArray.size(); i++) {
                JSONObject phaseObject = (JSONObject) phaseJsonArray.get(i);
                if ("custom-circle".equals(phaseObject.getStr("shape"))) {
                    Object xObject = JsonUtils2.getJsonValueByPath(phaseObject, "position/x".split("/"));
                    Object yObject = JsonUtils2.getJsonValueByPath(phaseObject, "position/y".split("/"));
                    int x = Convert.toInt(xObject.toString());
                    int y = Convert.toInt(yObject.toString());
                    if (x <= leftPhaseMaxX)
                        x = x + (inspectBeginX - leftPhaseMaxX);
                    else if (x >= rightPhaseMinX)
                        x = x + (inspectEndX - rightPhaseMinX);
                    y = y + (inspectY - phaseY);
                    JsonUtils2.setJsonValueByPath(phaseObject, "position/x".split("/"), x);
                    JsonUtils2.setJsonValueByPath(phaseObject, "position/y".split("/"), y);
                }
            }

            for (int i = 0; i < phaseJsonArray.size(); i++) {
                JSONObject phaseObject = (JSONObject) phaseJsonArray.get(i);
                if ("edge".equals(phaseObject.getStr("shape"))) {
                    Object sourceId = JsonUtils2.getJsonValueByPath(phaseObject, "source/cell".split("/"));
                    Object targetId = JsonUtils2.getJsonValueByPath(phaseObject, "target/cell".split("/"));
                    if (leftPhaseMaxId.equals(sourceId) && rightPhaseMinId.equals(targetId)) {
                        phaseJsonArray.remove(phaseObject);
                    }
                }
            }
            inspectJsonArray.addAll(phaseJsonArray);
            jsonStr = inspectJsonObj.toString();
        } else if (phaseDiagram != null) {
            jsonStr = phaseDiagram.getContent();
        } else if (inspectDiagram != null) {
            jsonStr = inspectDiagram.getContent();
        }

        if (combineDiagram != null) {
            combineDiagram.setContent(jsonStr);
            baseDao.updateById(combineDiagram);
        } else {
            combineDiagram = new ProjectNetworkDiagram();
            combineDiagram.setProjectId(networkDiagram.getProjectId());
            combineDiagram.setDiagramId(100L);
            combineDiagram.setContent(jsonStr);
            baseDao.insert(combineDiagram);
        }
        return combineDiagram;
    }*/

    @Transactional(rollbackFor = Exception.class)
    public Result simulate(SimulatAssess simulatAssess) {
        Result result = null;
        // 1. 检查模型完整性
        List<TaskModelCheckResult> chkResult = taskService.checkTaskModel(simulatAssess.getProductId(),
        List<TaskModelCheckResultDto> chkResult = taskService.checkTaskModel(simulatAssess.getProductId(),
                simulatAssess.getTaskModelId());
        if (chkResult.size() > 0) {
            result = Result.error("模型不完整，请检查模型定义及参数配置。");
@@ -762,18 +562,29 @@
        // 采样周期
        jsonObject.put("timeslice", simulatAssess.getSamplPeriod() / 60.0);   // 单位统一换算为小时
        jsonObject.put("result_home", resultHome);
        jsonObject.put("seed", 1000);
        if (null != fixedRandomSeed && "1".equals(fixedRandomSeed)) {
            // 固定种子
            jsonObject.put("seed", 1000);
        } else {
            // 随机种子
            jsonObject.put("seed", new Random().nextInt(1000));
        }
        redisTemplate.opsForValue().set(key, jsonObject.toJSONString());
    }

    public void deleteSimInfoInRedis(Long simId) {
        redisTemplate.delete(simId.toString() + RELIA_SIM_TASK_TYPE_SIMULATION);
        redisTemplate.delete(simId.toString() + RELIA_SIM_TASK_TYPE_PROGRESS);
    }

    private void assembleModelXml(SimulatAssess simulatAssess) {
        Long productId = simulatAssess.getProductId();
        XhProductModel product = xhProductModelDao.getById(productId);
        List<XhProductModel> productList = xhProductModelDao.getByShipId(productId);
        List<ParamData> paramDataList = paramDataDao.getDeviceParams(productId);
        Long taskId = simulatAssess.getTaskModelId();
        Task task = taskService.get(taskId);
        List<TaskBinoParam> binoParams = taskBinoParamDao.getBinoParams(taskId);
        List<TaskRepairParam> taskRepairParams = taskRepairParamDao.getTaskRepairParams(taskId);

        // 1. 计算各任务阶段的运行时长
        List<TaskPhase> taskPhases = calcTaskPhaseDuration(task);
@@ -792,12 +603,14 @@
            Element root = document.addElement("des");
            root.addAttribute("name", "General system");
            addTasksTag(taskPhaseModelAll, root);
            addModelsTag(productId,
            addModelsTag(taskId,
                    productId,
                    product.getName(),
                    product.getNamePath(),
                    productList,
                    paramDataList,
                    taskPhaseModelAll,
                    binoParams,
                    taskRepairParams,
                    root,
                    failureModels, repairModels);
            addFailureModelsTag(failureModels, root);
@@ -819,6 +632,8 @@
            } finally {
                if (xmlWriter != null) xmlWriter.close();
            }
            // XML存盘
            insert(simulatAssess);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("组装算法库仿真计算用模型XML失败: " + e.getMessage());
@@ -843,7 +658,8 @@
            satpm.setPhaseName(phase.getPhaseName());
            satpm.setPhaseDurationRate(phase.getPhaseDurationRate());
            satpm.setPhaseDuration(phase.getPhaseDuration());
            satpm.setPhaseConstraint(null); // TODO
            satpm.setPhaseConstraint(tpm.getPhaseConstraints().stream().map(item ->
                    item.getProductId().toString()).collect(Collectors.joining(",")));
            satpm.setGkId(tpm.getOperatConditId());
            satpm.setGkName(tpm.getOperatConditName());
            satpm.setGkDurationRate(tpm.getOperatConditDurationRate());
@@ -860,6 +676,11 @@
            Element taskTag = tasksTag.addElement("task");
            taskTag.addAttribute("duration", String.valueOf(taskPhaseModel.getOperatConditDuration()));
            taskTag.addAttribute("model", taskPhaseModel.getOperatConditId().toString());
            if (null != taskPhaseModel.getPhaseConstraints() && taskPhaseModel.getPhaseConstraints().size() > 0) {
                taskTag.addAttribute("NAM",
                        taskPhaseModel.getPhaseConstraints().stream().map(item ->
                                item.getProductId().toString()).collect(Collectors.joining(",")));
            }
        }
    }

@@ -891,7 +712,7 @@
                    ele.addAttribute("value", String.valueOf(failureModel.getParam3()));
                    break;
                case FailureModel.TYPE_FIX:
                    ele = failureModelTag.addElement("unreliability");
                    ele = failureModelTag.addElement("reliability");
                    ele.addAttribute("value", String.valueOf(failureModel.getParam1()));
                    break;
                default:
@@ -934,6 +755,10 @@
            double duration = taskPhase.getPhaseDuration() * taskPhaseModel.getOperatConditDurationRate() / totalRate;
            taskPhaseModel.setOperatConditDuration(duration);
            sum += duration;

            List<TaskPhaseConstraintDto> taskRepairConstraints = taskRepairParamDao.getTaskRepairConstraints(taskPhase.getTaskId(),
                    taskPhaseModel.getPhaseId(), taskPhaseModel.getOperatConditId());
            taskPhaseModel.setPhaseConstraints(taskRepairConstraints);
            taskPhaseModelAll.add(taskPhaseModel);
        }
        // 把零头补到最后一个工况模型
@@ -957,12 +782,14 @@
        return taskPhases;
    }

    private void addModelsTag(Long productId,
    private void addModelsTag(Long taskId,
                              Long productId,
                              String productName,
                              String productNamePath,
                              List<XhProductModel> productList,
                              List<ParamData> paramDataList,
                              List<TaskPhaseModel> taskPhaseModelAll,
                              List<TaskBinoParam> binoParams,
                              List<TaskRepairParam> taskRepairParams,
                              Element root,
                              List<FailureModel> failureModels,
                              List<RepairModel> repairModels) {
@@ -981,28 +808,36 @@
                    "end".equals(item.getAlgorithmType())).collect(Collectors.toList()).get(0);
            ModelNode computerNode = modelNodeAndVnodeList.stream().filter(item ->
                    endAlgo.getComputerList().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
            node2DOM(productId,
            node2DOM(taskId,
                    taskPhaseModel,
                    gkModelTop.getModelId(),
                    productId,
                    productName,
                    productNamePath,
                    productList,
                    paramDataList,
                    gkModelsAssembled,
                    algorithmList,
                    modelNodeAndVnodeList,
                    binoParams,
                    taskRepairParams,
                    computerNode, modelTag,
                    failureModels, repairModels);
        }
    }

    // 递归函数
    private void node2DOM(Long productId,
    private void node2DOM(Long taskId,
                          TaskPhaseModel taskPhaseModel,
                          Long modelId,
                          Long productId,
                          String productName,
                          String productNamePath,
                          List<XhProductModel> productList,
                          List<ParamData> paramDataList,
                          List<OperatConditModel> gkModelsAssembled,
                          List<Algorithm> algorithmList,
                          List<ModelNode> modelNodeAndVnodeList,
                          List<TaskBinoParam> binoParams,
                          List<TaskRepairParam> taskRepairParams,
                          ModelNode node,
                          Element parent,
                          List<FailureModel> failureModels,
@@ -1021,37 +856,57 @@
                        "end".equals(item.getAlgorithmType())).collect(Collectors.toList()).get(0);
                ModelNode computerNode = modelNodeAndVnodeListSub.stream().filter(item ->
                        endAlgo.getComputerList().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
                node2DOM(product.getId(),
                node2DOM(taskId,
                        taskPhaseModel,
                        gkModel.getModelId(),
                        product.getId(),
                        product.getName(),
                        product.getNamePath(),
                        productList,
                        paramDataList,
                        gkModelsAssembled,
                        algorithmListSub,
                        modelNodeAndVnodeListSub,
                        binoParams,
                        taskRepairParams,
                        computerNode, parent,
                        failureModels, repairModels);
            } else if ("5".equals(product.getProductType())) {
                // 设备
                ParamData paramData = paramDataList.stream().filter(item ->
                        dataId.equals(item.getProductId())).collect(Collectors.toList()).get(0);
                Element nodeTag = parent.addElement("node");
                nodeTag.addAttribute("name", dataId.toString());
                nodeTag.addAttribute("real_name", product.getName());
                nodeTag.addAttribute("name_path", product.getNamePath());
                nodeTag.addAttribute("type", "node");

                FailureModel failureModel = new FailureModel();
                failureModel.setId(UUIDUtil.generateId());
                failureModel.setType(FailureModel.TYPE_EXP);
                failureModel.setParam1(1.0 / paramData.getTaskMtbcfRegulate());
                ParamData paramData = paramDataList.stream().filter(item ->
                        dataId.equals(item.getProductId())).collect(Collectors.toList()).get(0);
                Double ratio = paramData.getTaskMtbcfOperatingRatio();
                if (null != ratio && ratio > 0) {
                    // 间断型设备的处理
                    double cycon = taskPhaseModel.getOperatConditDuration() * ratio;
                    double cycdown = taskPhaseModel.getOperatConditDuration() - cycon;
                    nodeTag.addAttribute("cycon", String.valueOf(cycon));
                    nodeTag.addAttribute("cycdown", String.valueOf(cycdown));
                }
                TaskBinoParam taskBinoParam = null;
                if (3 == paramData.getReliabDistribType()) {
                    // 二项分布处理
                    taskBinoParam = binoParams.stream()
                            .filter(item -> taskId.equals(item.getTaskId()))
                            .filter(item -> taskPhaseModel.getPhaseId().equals(item.getPhaseId()))
                            .filter(item -> taskPhaseModel.getOperatConditId().equals(item.getOperatConditId()))
                            .filter(item -> modelId.equals(item.getModelId()))
                            .filter(item -> dataId.equals(item.getProductId()))
                            .collect(Collectors.toList()).get(0);
                }
                FailureModel failureModel = createFailureModel(paramData, taskBinoParam);
                failureModels.add(failureModel);

                Element failureTag = nodeTag.addElement("failure_model");
                failureTag.addAttribute("name", failureModel.getId().toString());

                if (1 == paramData.getRepairable()) {
                    RepairModel repairModel = new RepairModel();
                    repairModel.setId(UUIDUtil.generateId());
                    repairModel.setType(RepairModel.TYPE_EXP);
                    repairModel.setParam1(1.0 / paramData.getRepairMttcr());
                    // 可维修
                    RepairModel repairModel = createRepairModel(paramData);
                    repairModels.add(repairModel);
                    Element repairTag = nodeTag.addElement("repair_model");
                    repairTag.addAttribute("name", repairModel.getId().toString());
@@ -1066,6 +921,8 @@
                element.addAttribute("name", algo.getId().toString());
            } else {
                element.addAttribute("name", productId.toString());
                element.addAttribute("real_name", productName);
                element.addAttribute("name_path", productNamePath);
            }
            if ("series".equals(algo.getAlgorithmType())) {
                element.addAttribute("type", "series");
@@ -1083,35 +940,52 @@
            for (String nodeStr : computerNodeListStr) {
                ModelNode mn = modelNodeAndVnodeList.stream().filter(item ->
                        nodeStr.equals(item.getId().toString())).collect(Collectors.toList()).get(0);
                node2DOM(null,
                node2DOM(taskId,
                        taskPhaseModel,
                        modelId,
                        null,
                        null,
                        null,
                        productList,
                        paramDataList,
                        gkModelsAssembled,
                        algorithmList,
                        modelNodeAndVnodeList,
                        binoParams,
                        taskRepairParams,
                        mn, element,
                        failureModels, repairModels);
            }
        }
    }

    private FailureModel createFailureModel(ParamData paramData) {
    private FailureModel createFailureModel(ParamData paramData, TaskBinoParam taskBinoParam) {
        FailureModel failureModel = new FailureModel();
        failureModel.setId(UUIDUtil.generateId());
        switch (paramData.getReliabDistribType()) {
            case 1:
                // 指数分布
                failureModel.setType(FailureModel.TYPE_EXP);
                failureModel.setParam1(1.0 / paramData.getTaskMtbcfRegulate());
                break;
            case 2:
                // 威布尔分布
                failureModel.setType(FailureModel.TYPE_WBL);
                failureModel.setParam2(paramData.getTaskMtbcfOtherParams2());
                failureModel.setParam3(paramData.getTaskMtbcfOtherParams3());
                break;
            case 3:
                failureModel.setType(FailureModel.TYPE_BIN);
                // 二项分布
                if (taskBinoParam.getSimulatTimes().intValue() == taskBinoParam.getSuccessTimes().intValue()) {
                    // 相等则为成败型
                    failureModel.setType(FailureModel.TYPE_FIX);
                    failureModel.setParam1(taskBinoParam.getSuccessRate());
                } else {
                    // 二项分布
                    failureModel.setType(FailureModel.TYPE_BIN);
                    failureModel.setParam1(taskBinoParam.getSuccessRate());
                    failureModel.setParam2(taskBinoParam.getSimulatTimes());
                    failureModel.setParam3(taskBinoParam.getSuccessTimes());
                }
                break;
            default:
                break;
@@ -1119,4 +993,237 @@

        return failureModel;
    }

    private RepairModel createRepairModel(ParamData paramData) {
        RepairModel repairModel = new RepairModel();
        repairModel.setId(UUIDUtil.generateId());
        switch (paramData.getRepairDistribType()) {
            case 1:
                // 指数分布
                repairModel.setType(FailureModel.TYPE_EXP);
                repairModel.setParam1(1.0 / paramData.getRepairMttcr());
                break;
            case 2:
                // 威布尔分布
                repairModel.setType(FailureModel.TYPE_WBL);
                repairModel.setParam2(paramData.getRepairMttcrOtherParams2());
                repairModel.setParam3(paramData.getRepairMttcrOtherParams3());
                break;
            case 3:
                // 二项分布（维修没有）
                break;
            default:
                break;
        }

        return repairModel;
    }

    public List<WeakDto> getReliabilityWeakness(Long fzId, Long taskId, Long productId) {
        String filePath = path + "/" + fzId + "/" + "result.xml";
        List<WeakDto> list = new ArrayList<>();
        Map<Long, WeakDto> map = new HashMap<>();
        String xml;
        InputStream in = null;
        try {
            in = new FileInputStream(filePath);
            xml = IOUtils.toString(in);
        } catch (IOException e) {
            e.printStackTrace();
            throw new RenException("文件不存在或者文件打不开");
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        List<WeakDto> productList = baseDao.getProductList(taskId, productId);
        for (WeakDto dto : productList) {
            map.put(dto.getId(), dto);
        }
        JSONObject xmlJSONObj = XML.toJSONObject(xml);
        JSONArray jsonArray = xmlJSONObj.getJSONObject("ResultNodes").getJSONArray("ResultNode");
        for (int i = 0; i < jsonArray.size(); i++) {
            WeakDto data = new WeakDto();
            Long productId1;
            Object nameValue = jsonArray.getJSONObject(i).get("name");
            if (nameValue instanceof Long) {
                productId1 = (Long) nameValue;
                WeakDto weakDto = map.get(productId1);
                Double mtbfTime = null;

                Double mtbf = (Double) jsonArray.getJSONObject(i).get("mttf");
                Double mttr = (Double) jsonArray.getJSONObject(i).get("mttr");
                Double msr = (Double) jsonArray.getJSONObject(i).get("msr");

                data.setMtbf(mtbf);
                data.setMttr(mttr);
                data.setMsr(msr);

                if (weakDto != null) {
                    data.setId(weakDto.getId());
                    data.setSort(weakDto.getSort());
                    data.setPid(weakDto.getPid());
                    data.setName(weakDto.getName());
                    data.setProductType(weakDto.getProductType());
                    data.setTimeRate(weakDto.getTimeRate());
                    mtbfTime = mtbf / weakDto.getTimeRate();
                }

                data.setMtbfTime(mtbfTime);
                data.setIsWeak(0);

                list.add(data);
            }
        }
        List<WeakDto> treeList = TreeUtils.build(list);
        this.getIsweak(treeList.get(0).getChildren());
        return treeList;
    }

    private void getIsweak(List<WeakDto> treeList) {
        WeakDto minDto = null;
        for (WeakDto dto : treeList) {
            if (dto.getProductType() == 10)
                continue;
            if (minDto == null) {
                minDto = dto;
            }
            if (dto.getMtbfTime() < minDto.getMtbfTime()) {
                minDto = dto;
            }
        }
        minDto.setIsWeak(1);
        if (minDto.getChildren().size() > 0) {
            this.getIsweak(minDto.getChildren());
        }
    }

    public SchemeComparDto SchemeCompar(String[] taskList, Long showProductId) {
        SchemeComparDto dto = new SchemeComparDto();
        List<SimulaDataDto> dataDtoList = new ArrayList<>();
        List<SchemeComparCurve> curveList = new ArrayList<>();
        List<Double> xData = new ArrayList<>();
        SimulatAssess simulatAssess;
        SimulaDataDto data;

        Task task;
        for (String taskId : taskList) {
            Long taskModelId = Long.parseLong(taskId);
            task = taskService.get(taskModelId);
            simulatAssess = this.getByTaskId(taskModelId);
            SimulaDataDto resultData;
            if (showProductId!=null){
                simulatAssess.setProductId(showProductId);
                resultData =this.getResultXML(simulatAssess);
            }else{
                resultData = this.getResultXML(simulatAssess);
            }

            data = resultData;
            data.setName(task.getTaskName());
            dataDtoList.add(data);
            xData = resultData.getCurveParam().getXData();

            SchemeComparCurve curve = new SchemeComparCurve();
            curve.setName(task.getTaskName());
            curve.setSmooth(true);
            curve.setType("line");
            curve.setData(resultData.getCurveParam().getYData());
            curveList.add(curve);
        }
        dto.setXDataList(xData);
        dto.setDataList(dataDtoList);
        dto.setCurveList(curveList);
        return dto;
    }

    public SimulaDataDto getResultXML(SimulatAssess simulatAssess) {
        if (simulatAssess.getDataType() != null && simulatAssess.getDataType().equals("fz")) {
            Integer num = this.getNumById(simulatAssess.getProductId(), simulatAssess.getTaskModelId());
            simulatAssess.setName("仿真记录" + (num + 1));
            this.update(simulatAssess);
        }
        String filePath = path + "/" + simulatAssess.getId() + "/" + "result.xml";
        String xml;
        InputStream in = null;

        try {
            in = new FileInputStream(filePath);
            xml = IOUtils.toString(in);
        } catch (IOException e) {
            e.printStackTrace();
            throw new RenException("文件不存在或者文件打不开");
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        xmlJSONObj = XML.toJSONObject(xml);
        simulatAssess.setShowProductId(simulatAssess.getProductId());
        SimulaDataDto data = this.getResultData(simulatAssess);
        return data;
    }

    public SimulaDataDto getResultData(SimulatAssess simulatAssess) {
        SimulaDataDto data = new SimulaDataDto();
        CurveParam param = new CurveParam();
        Double samplPeriod = Double.valueOf(simulatAssess.getSamplPeriod());
        samplPeriod = samplPeriod / 60;
        JSONArray jsonArray = xmlJSONObj.getJSONObject("ResultNodes").getJSONArray("ResultNode");
        for (int i = 0; i < jsonArray.size(); i++) {
            Long productId = null;
            Object nameValue = jsonArray.getJSONObject(i).get("name");
            if (nameValue instanceof Long) {
                productId = (Long) nameValue;
                if (productId.equals(simulatAssess.getShowProductId())) {
                    Object object = jsonArray.getJSONObject(i).get("phase");
                    List<Double> doubleArray = new ArrayList<>();
                    List<Double> xList = new ArrayList<>();
                    String availability = null;
                    if (object instanceof JSONArray) {
                        JSONArray jsonArray2 = jsonArray.getJSONObject(i).getJSONArray("phase");
                        for (int j = 0; j < jsonArray2.size(); j++) {
                            if (availability != null) {
                                availability = availability + " " + jsonArray2.getJSONObject(j).get("availability");
                            } else {
                                availability = (String) jsonArray2.getJSONObject(j).get("availability");
                            }
                        }
                    } else {
                        JSONObject jsonObject2 = jsonArray.getJSONObject(i).getJSONObject("phase");
                        availability = (String) jsonObject2.get("availability");
                    }

                    String[] arr = availability.split(" ");
                    // 遍历子字符串数组，将每个元素转换为double并存储到double数组中
                    Double j = 0.0;
                    for (int a = 0; a < arr.length; a++) {
                        j = samplPeriod + j;
                        doubleArray.add(Double.parseDouble(arr[a]));
                        xList.add(j);
                    }

                    param.setXData(xList);
                    param.setYData(doubleArray);
                    Double mtbf = (Double) jsonArray.getJSONObject(i).get("mttf");
                    Double mttr = (Double) jsonArray.getJSONObject(i).get("mttr");
                    Double msr = (Double) jsonArray.getJSONObject(i).get("msr");
                    data.setMtbf(mtbf);
                    data.setMttr(mttr);
                    data.setMsr(msr);
                }
                data.setCurveParam(param);
            }
        }
        return data;
    }
}