Merge remote-tracking branch 'origin/master'

xyc

2024-08-02 a43fd8f15c7da7f4a14ba4ebb79970dad4ce1fae

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

@@ -1,6 +1,10 @@
package com.zt.life.modules.mainPart.taskReliability.service;

import com.alibaba.fastjson.JSONObject;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONArray;
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.UUIDUtil;
@@ -9,6 +13,9 @@
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.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.ProductStatusDto;
import com.zt.life.modules.mainPart.taskReliability.dto.TaskModelCheckResult;
import com.zt.life.modules.mainPart.taskReliability.model.*;
@@ -19,6 +26,11 @@
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;
import com.zt.life.modules.mainPart.taskReliability.model.TimeDiagram;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
@@ -30,7 +42,12 @@
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.util.stream.Collectors;


@@ -76,6 +93,24 @@
    private XhProductModelDao xhProductModelDao;
    @Autowired
    private ParamDataDao paramDataDao;
    @Autowired
    private TaskBinoParamDao taskBinoParamDao;
    @Autowired
    private TaskRepairParamDao taskRepairParamDao;

    @Autowired
    private TimeDiagramDao timeDiagramDao;

    @Value("${data.reliaSimLib.resultHome}")
    private String path;

    private JSONObject dialgramJson;


    String templetStr = "{\"cells\":[]}";
    Map<String, JSONObject> templetsMap = new HashMap<>();
    Map<String, String> templetsStrMap = new HashMap<>();


    /**
     * 分页查询
@@ -108,9 +143,510 @@
        return baseDao.getParams(id, taskModelId);
    }

    public List<ProductStatusDto> getChildren(Long productId, Long taskId) {
    public List<ProductStatusDto> getProduct(Long productId, Long taskId) {
        return baseDao.getChildren(productId, taskId);
    }

    public String getTimeDiagram(Long productId, Long taskId, Long fzId) {
        String filePath = path + "/" + fzId + "/" + "status.json";
        ObjectMapper mapper = new ObjectMapper();
        String jsonStr = null;
        try {
            // 使用 ObjectMapper 的 readValue 方法，将文件中的 JSON 数据转换为一个 Java 对象
            // 这里使用 Object 类作为泛型参数，表示任意类型的对象
            Object obj = mapper.readValue(new File(filePath), Object.class);
            // 使用 ObjectMapper 的 writeValueAsString 方法，将 Java 对象转换为 JSON 字符串
            jsonStr = mapper.writeValueAsString(obj);

        } catch (IOException e) {
            // 处理异常
            e.printStackTrace();
            throw new RenException("文件不存在或者文件打不开");
        }
        dialgramJson = new JSONObject(jsonStr);

        // 阶段模型
        List<SimulatAssessTaskPhaseModel> modelDtoList = baseDao.getModelList(productId, fzId);
        // 所有阶段模型的节点集合 （线条）
        List<ProductStatusDto> list = this.getStatusData(productId, taskId);
        // 每次仿真记录
        SimulatAssess simulatAssess = this.get(fzId);

        JSONObject jsonObject = new JSONObject(templetStr);
        JSONArray jsonArray = jsonObject.getJSONArray("cells");

        this.getPetsInfo();
        double x1 = 0;
        double x2 = 0;
        int y = 0;
        int groupY = 0;
        int spaceHeight = 20;
        int groupHeight = 20;

        double pointNumPerHour = 60.0 / simulatAssess.getSamplPeriod();
        //时序图线
        for (int i = 0; i < list.size(); i++) {
            x1 = 0;
            groupY = groupHeight * i;
            ProductStatusDto dto = list.get(i);
            for (StatusDto status : dto.getStatusList()) {
                switch (status.getStatus()) {
                    case "O":
                        y = groupY;
                        break;
                    case "F":
                        y = groupY;// + spaceHeight;
                        break;
                    case "I":
                    case "S":
                    case "M":
                        y = groupY;// + 2 * spaceHeight;
                        break;
                }
                x2 = x1 + status.getTimes() * pointNumPerHour + 5;
                JSONObject lineJson = new JSONObject(templetsStrMap.get(status.getStatus()));
                setlineXy(lineJson, x1, y, x2, y, "");

                JsonUtils2.setJsonValueByPath(lineJson, "id".split("/"), UUIDUtil.generateId().toString());
                x1 = x2 - 5;
                jsonArray.add(lineJson);
            }
            JSONObject textJson = new JSONObject(templetsStrMap.get("text"));
            JsonUtils2.setJsonValueByPath(textJson, "id".split("/"), UUIDUtil.generateId().toString());
            JsonUtils2.setJsonValueByPath(textJson, "attrs/label/textWrap/text".split("/"), dto.getName());
            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 = -100;
        String[] tlArr = "O,F,I,S,M".split(",");
        for (String s : tlArr) {
            JSONObject f = templetsMap.get(s);
            x1 = x1 + spaceWitdth;
            x2 = x2 + spaceWitdth;
            setlineXy(f, x1, y, x2, y, null);
            jsonArray.add(f);
        }

        //阶段模型及刻度
        x1 = 0;
        x2 = 0;
        double y1 = -60;
        y = -30;
        double y2 = -10;
        JSONObject modelJson = new JSONObject(templetsStrMap.get("model"));

        setlineXy(modelJson, x1, y1, x1, y2, null);
        jsonArray.add(modelJson);
        double totalHours = 0;
        for (int i = 0; i < modelDtoList.size(); i++) {
            JSONObject modelJson2 = new JSONObject(templetsStrMap.get("model"));
            SimulatAssessTaskPhaseModel modelDto = modelDtoList.get(i);
            totalHours = totalHours + modelDto.getGkDuration();
            x2 = x2 + modelDto.getGkDuration() * pointNumPerHour;
            if (i < modelDtoList.size() - 1) {
                setlineXy(modelJson2, x2, y1, x2, y, null);
            } else {
                setlineXy(modelJson2, x2, y1, x2, y2, null);
            }
            jsonArray.add(modelJson2);

            //判断是否有模型
            ModelRbd modelRbd = baseDao.getModelByProductGk(modelDto.getGkId(), productId);
            String modelName = "未用";
            String modelId = "";
            if (modelRbd != null) {
                modelName = modelRbd.getModelName();
                modelId = modelRbd.getId().toString();
            }

            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, "position/x".split("/"), x1 + 30);
            JsonUtils2.setJsonValueByPath(textJson, "position/y".split("/"), y1);
            jsonArray.add(textJson);
            x1 = x2;
        }
        JSONObject modelJson3 = new JSONObject(templetsStrMap.get("model"));
        setlineXy(modelJson3, 0, y, x2, y, null);
        jsonArray.add(modelJson3);

        double curPointHour = 50, periodHour = 50;
        while (curPointHour < totalHours) {
            JSONObject modelJson4 = new JSONObject(templetsStrMap.get("model"));
            double x = curPointHour * pointNumPerHour;
            setlineXy(modelJson4, x, y, x, y, null);
            jsonArray.add(modelJson4);
        }

        return jsonObject.toString();
    }

    public void setlineXy(JSONObject lineJson, double x1, double y1, double x2, double y2, String text) {
        JsonUtils2.setJsonValueByPath(lineJson, "source/x".split("/"), x1);
        JsonUtils2.setJsonValueByPath(lineJson, "source/y".split("/"), y1);
        JsonUtils2.setJsonValueByPath(lineJson, "target/x".split("/"), x2);
        JsonUtils2.setJsonValueByPath(lineJson, "target/y".split("/"), y2);
        if (text != null) {
            JsonUtils2.setArrJsonValueByPath(lineJson, "labels".split("/"), null, "0", "attrs/text/text", "");
        }
    }

    public void getPetsInfo() {
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("projectId", 10000);
        params.put("diagramId", 10000);
        List<TimeDiagram> list_style = baseDao.getTimeDiagram(params);
        if (list_style.size() > 0) {
            String modelStr = list_style.get(0).getContent();
            JSONObject modelJson = new JSONObject(modelStr);
            JSONArray modelJsonArray = modelJson.getJSONArray("cells");
            for (int i = 0; i < modelJsonArray.size(); i++
            ) {
                JSONObject jsonObject = modelJsonArray.getJSONObject(i);
                if (jsonObject.get("shape").equals("edge")) {
                    JSONArray tmpArray = jsonObject.getJSONArray("labels");
                    JSONObject tmpJSONObject = (JSONObject) tmpArray.get(0);
                    Object nodeMarker = JsonUtils2.getJsonValueByPath(tmpJSONObject, "attrs/text/text".split("/"));
                    if ("运行".equals(nodeMarker)) {
                        templetsMap.put("O", jsonObject);
                        templetsStrMap.put("O", jsonObject.toString());
                    }
                    if ("故障".equals(nodeMarker)) {
                        templetsMap.put("F", jsonObject);
                        templetsStrMap.put("F", jsonObject.toString());
                    }
                    if ("空闲".equals(nodeMarker)) {
                        templetsMap.put("I", jsonObject);
                        templetsStrMap.put("I", jsonObject.toString());
                    }
                    if ("备份".equals(nodeMarker)) {
                        templetsMap.put("S", jsonObject);
                        templetsStrMap.put("S", jsonObject.toString());
                    }
                    if ("未用".equals(nodeMarker)) {
                        templetsMap.put("M", jsonObject);
                        templetsStrMap.put("M", jsonObject.toString());
                    }
                    if ("模型".equals(nodeMarker)) {
                        JsonUtils2.setJsonValueByPath(tmpJSONObject, "attrs/text/text".split("/"), "");
                        templetsMap.put("model", jsonObject);
                        templetsStrMap.put("model", jsonObject.toString());
                    }

                } else if (jsonObject.get("shape").equals("custom-rect")) {
                    Object nodeMarker = JsonUtils2.getJsonValueByPath(jsonObject, "attrs/label/textWrap/text".split("/"));
                    if ("文字模板1".equals(nodeMarker)) {
                        templetsMap.put("text", jsonObject);
                        templetsStrMap.put("text", jsonObject.toString());
                    }
                } else if (jsonObject.get("shape").equals("image")) {
                    Object nodeMarker = JsonUtils2.getJsonValueByPath(jsonObject, "data/imagePost".split("/"));
                    if ("center".equals(nodeMarker)) {
                        templetsMap.put("center", jsonObject);
                        templetsStrMap.put("center", jsonObject.toString());
                    }
                    if ("top".equals(nodeMarker)) {
                        templetsMap.put("top", jsonObject);
                        templetsStrMap.put("top", jsonObject.toString());
                    }
                    if ("right".equals(nodeMarker)) {
                        templetsMap.put("right", jsonObject);
                        templetsStrMap.put("right", jsonObject.toString());
                    }
                    if ("bottom".equals(nodeMarker)) {
                        templetsMap.put("bottom", jsonObject);
                        templetsStrMap.put("bottom", jsonObject.toString());
                    }
                    if ("left".equals(nodeMarker)) {
                        templetsMap.put("left", jsonObject);
                        templetsStrMap.put("left", jsonObject.toString());
                    }
                }
            }
        }
    }

    public List<ProductStatusDto> getStatusData(Long productId, Long taskId) {
        List<ProductStatusDto> childList = this.getProduct(productId, taskId);
        for (ProductStatusDto item : childList) {
            JSONArray jsonArray = dialgramJson.getJSONArray(String.valueOf(item.getId()));
            if (jsonArray != null) {
                this.processJSONArray(jsonArray, item, taskId);
            }
        }
        return childList;
    }

    public void processJSONArray(JSONArray jsonArray, ProductStatusDto productStatusDto, Long taskId) {

        List<SimulatAssessTaskPhaseModel> phaseModelList = baseDao.getTaskPhaseModelByTaskId(taskId);
        String status = null;
        Double times = null;
        JSONArray jsonArray2 = jsonArray.getJSONArray(0);
        for (int j = 0; j < jsonArray2.size(); j++) {
            JSONArray jsonArray3 = jsonArray2.getJSONArray(j);
            if (jsonArray3.size() == 0) {
                StatusDto statusDto = new StatusDto();
                statusDto.setTimes(phaseModelList.get(j).getGkDuration());
                statusDto.setStatus("");
                productStatusDto.getStatusList().add(statusDto);
            } else {
                for (int a = 0; a < jsonArray3.size(); a++) {
                    JSONArray jsonArray4 = jsonArray3.getJSONArray(a);
                    for (int b = 0; b < jsonArray4.size(); b++) {
                        Object item = jsonArray4.get(b);
                        if (item instanceof Double) {
                            times = (Double) item;
                        } else {
                            status = String.valueOf(item);
                        }
                    }
                    if (status != null || times != null) {
                        StatusDto statusDto = new StatusDto();
                        statusDto.setTimes(times);
                        statusDto.setStatus(status);
                        productStatusDto.getStatusList().add(statusDto);
                    }
                }
            }
        }
    }

    public TimeDiagram getDiagram(String projectId, String diagramId, String showType, String isShow, String digramParams, String majorId, Integer winWidth, Integer winHeight) {
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("projectId", projectId);
        params.put("diagramId", diagramId);

        TimeDiagram diagram = null;

        List<TimeDiagram> list = baseDao.getTimeDiagram(params);
        if (list.size() > 0) {
            diagram = list.get(0);
        } else {
            diagram = new TimeDiagram();
            diagram.setProjectId(Convert.toLong(projectId));
            diagram.setDiagramId(Convert.toLong(diagramId));
        }


        return diagram;
    }

    public void updateDiagram(TimeDiagram diagram) {
        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) {
@@ -158,7 +694,7 @@
            logger.info("算法库返回结果：" + line);
//            int exitCode = process.waitFor(); // 异步方式，不等待算法库计算完毕，所以要注释掉该行
            if (line != null) {
                ReliaSimLibResult rtn = JSONObject.parseObject(line, ReliaSimLibResult.class);
                ReliaSimLibResult rtn = com.alibaba.fastjson.JSONObject.parseObject(line, ReliaSimLibResult.class);
                if ("0".equals(rtn.getCode())) {
                    logger.info("启动算法库成功。");
                    result = Result.ok();
@@ -194,7 +730,7 @@
    private void setParamToRedis(SimulatAssess simulatAssess) {
        String key = simulatAssess.getId().toString() + RELIA_SIM_TASK_TYPE_SIMULATION;
        logger.info("redis key：" + key);
        JSONObject jsonObject = new JSONObject();
        com.alibaba.fastjson.JSONObject jsonObject = new com.alibaba.fastjson.JSONObject();
        jsonObject.put("xmlfile", simulatAssess.getXml());
        // 仿真次数
        jsonObject.put("simulate_times", simulatAssess.getSimulatFrequency());
@@ -211,6 +747,9 @@
        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);
        // 2. 计算各工况模型的运行时长
@@ -232,6 +771,8 @@
                    productList,
                    paramDataList,
                    taskPhaseModelAll,
                    binoParams,
                    taskRepairParams,
                    root,
                    failureModels, repairModels);
            addFailureModelsTag(failureModels, root);
@@ -371,7 +912,8 @@
            taskPhaseModelAll.add(taskPhaseModel);
        }
        // 把零头补到最后一个工况模型
        taskPhaseModels.get(taskPhaseModels.size()-1).setOperatConditDuration(taskPhase.getPhaseDuration() - sum);
        double duration = taskPhaseModels.get(taskPhaseModels.size()-1).getOperatConditDuration();
        taskPhaseModels.get(taskPhaseModels.size()-1).setOperatConditDuration(duration + taskPhase.getPhaseDuration() - sum);
    }

    private List<TaskPhase> calcTaskPhaseDuration(Task task) {
@@ -384,7 +926,8 @@
            sum += duration;
        }
        // 把零头补到最后一个阶段
        taskPhases.get(taskPhases.size()-1).setPhaseDuration(task.getTaskDuration() - sum);
        double duration = taskPhases.get(taskPhases.size()-1).getPhaseDuration();
        taskPhases.get(taskPhases.size()-1).setPhaseDuration(duration + task.getTaskDuration() - sum);

        return taskPhases;
    }
@@ -393,6 +936,8 @@
                              List<XhProductModel> productList,
                              List<ParamData> paramDataList,
                              List<TaskPhaseModel> taskPhaseModelAll,
                              List<TaskBinoParam> binoParams,
                              List<TaskRepairParam> taskRepairParams,
                              Element root,
                              List<FailureModel> failureModels,
                              List<RepairModel> repairModels) {
@@ -416,6 +961,8 @@
                    gkModelsAssembled,
                    algorithmList,
                    modelNodeAndVnodeList,
                    binoParams,
                    taskRepairParams,
                    computerNode, modelTag,
                    failureModels, repairModels);
        }
@@ -427,6 +974,8 @@
                          List<OperatConditModel> gkModelsAssembled,
                          List<Algorithm> algorithmList,
                          List<ModelNode> modelNodeAndVnodeList,
                          List<TaskBinoParam> binoParams,
                          List<TaskRepairParam> taskRepairParams,
                          ModelNode node,
                          Element parent,
                          List<FailureModel> failureModels,
@@ -435,7 +984,7 @@
            Long dataId = node.getDataId();
            XhProductModel product = productList.stream().filter(item ->
                    dataId.equals(item.getId())).collect(Collectors.toList()).get(0);
            if ("3,4,10".equals(product.getProductType())) {
            if ("3,4,10".contains(product.getProductType())) {
                // 系统、分系统、虚单元
                OperatConditModel gkModel = gkModelsAssembled.stream().filter(item ->
                        dataId.equals(item.getProductId())).collect(Collectors.toList()).get(0);
@@ -450,6 +999,8 @@
                        gkModelsAssembled,
                        algorithmListSub,
                        modelNodeAndVnodeListSub,
                        binoParams,
                        taskRepairParams,
                        computerNode, parent,
                        failureModels, repairModels);
            } else if ("5".equals(product.getProductType())) {
@@ -459,11 +1010,13 @@
                Element nodeTag = parent.addElement("node");
                nodeTag.addAttribute("name", dataId.toString());
                nodeTag.addAttribute("type", "node");

                FailureModel failureModel = new FailureModel();
                failureModel.setId(UUIDUtil.generateId());
                failureModel.setType(FailureModel.TYPE_EXP);
                failureModel.setParam1(1.0 / paramData.getTaskMtbcfRegulate());
                failureModels.add(failureModel);

                Element failureTag = nodeTag.addElement("failure_model");
                failureTag.addAttribute("name", failureModel.getId().toString());
                if (1 == paramData.getRepairable()) {
@@ -496,16 +1049,41 @@
            }
            String[] computerNodeListStr = algo.getComputerList().split(",");
            for (String nodeStr : computerNodeListStr) {
                ModelNode md = modelNodeAndVnodeList.stream().filter(item ->
                ModelNode mn = modelNodeAndVnodeList.stream().filter(item ->
                        nodeStr.equals(item.getId().toString())).collect(Collectors.toList()).get(0);
                node2DOM(productList,
                        paramDataList,
                        gkModelsAssembled,
                        algorithmList,
                        modelNodeAndVnodeList,
                        md, element,
                        binoParams,
                        taskRepairParams,
                        mn, element,
                        failureModels, repairModels);
            }
        }
    }

    private FailureModel createFailureModel(ParamData paramData) {
        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);
                break;
            default:
                break;
        }

        return failureModel;
    }
}