优化串联、并联的识别

xyc

2024-03-13 6d6ff1f12e35d2310be581b91a343967e247d4e4

优化串联、并联的识别

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

New file
@@ -0,0 +1,23 @@
package com.zt.life.modules.taskReliability.dao;

import com.zt.common.dao.BaseDao;
import com.zt.life.modules.taskReliability.model.ModelNodeAlgorithm;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;
import java.util.Map;


/**
 * model_line
 *
 * @author zt generator 
 * @since 1.0.0 2024-02-28
 */
@Mapper
public interface ModelNodeAlgorithmDao extends BaseDao<ModelNodeAlgorithm> {

    List<ModelNodeAlgorithm> getList(Map<String, Object> params);
    void deleteByModelId(Long modelId);

}

 modules/mainPart/src/main/java/com/zt/life/modules/taskReliability/model/ModelNodeAlgorithm.java

New file
@@ -0,0 +1,33 @@
package com.zt.life.modules.taskReliability.model;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import com.zt.common.entity.BusiEntity;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * model_line
 *
 * @author zt generator 
 * @since 1.0.0 2024-02-28
 */
@Data
@EqualsAndHashCode(callSuper=false)
@TableName("model_node_algorithm")
public class ModelNodeAlgorithm extends ModelNode {

    public static ModelNodeAlgorithm from(ModelNode node) {
        ModelNodeAlgorithm modelNodeAlgorithm = new ModelNodeAlgorithm();
        modelNodeAlgorithm.setId(node.getId());
        modelNodeAlgorithm.setPicId(node.getPicId());
        modelNodeAlgorithm.setModelId(node.getModelId());
        modelNodeAlgorithm.setDataId(node.getDataId());
        modelNodeAlgorithm.setNodeType(node.getNodeType());
        modelNodeAlgorithm.setNodeTypeExt(node.getNodeTypeExt());
        modelNodeAlgorithm.setName(node.getName());
        modelNodeAlgorithm.setRemark(node.getRemark());
        return modelNodeAlgorithm;
    }
}

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

@@ -5,15 +5,9 @@
import com.zt.common.service.BaseService;
import com.zt.common.utils.JsonUtils2;
import com.zt.common.utils.UUIDUtil;
import com.zt.life.modules.taskReliability.dao.AlgorithmDao;
import com.zt.life.modules.taskReliability.dao.ModelLineDao;
import com.zt.life.modules.taskReliability.dao.ModelNodeDao;
import com.zt.life.modules.taskReliability.dao.ModelRbdDao;
import com.zt.life.modules.taskReliability.dao.*;
import com.zt.life.modules.taskReliability.dto.ModelLinePair;
import com.zt.life.modules.taskReliability.model.Algorithm;
import com.zt.life.modules.taskReliability.model.ModelLine;
import com.zt.life.modules.taskReliability.model.ModelNode;
import com.zt.life.modules.taskReliability.model.ModelRbd;
import com.zt.life.modules.taskReliability.model.*;
import org.apache.commons.lang3.StringUtils;
import org.checkerframework.checker.units.qual.C;
import org.springframework.beans.factory.annotation.Autowired;
@@ -41,6 +35,8 @@
    private ModelRbdDao modelRbdDao;
    @Autowired
    private AlgorithmDao algorithmDao;
    @Autowired
    private ModelNodeAlgorithmDao modelNodeAlgorithmDao;

    /**
     * 分页查询
@@ -123,7 +119,7 @@
        result = getAlgorithmFromRbd(modelId, modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList);

        // 5. 保存模型
        if (saveFlag) saveModel(modelId, modelNodeList, modelLineList, algorithmList);
        if (saveFlag) saveModel(modelId, modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList);

        return result;
    }
@@ -152,15 +148,11 @@
            hasSimplified = false;
            hasSimplified = simplifySeries(modelId, modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList, hasSimplified);
            hasSimplified = simplifyParallel(modelId, modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList, hasSimplified);
            hasSimplified = simplifyOperator("switch", modelId, modelNodeList, modelLineList, algorithmList, hasSimplified);
            hasSimplified = simplifyOperator("vote", modelId, modelNodeList, modelLineList, algorithmList, hasSimplified);
            hasSimplified = simplifyOperator("switch", modelId, modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList, hasSimplified);
            hasSimplified = simplifyOperator("vote", modelId, modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList, hasSimplified);
            hasSimplified = simplifyBridge(modelId, modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList, hasSimplified);
            isEnd = simplifyEnd(modelId, modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList);
        } while (!isEnd && hasSimplified);

        // 合并碎片化了的串联

        // 合并碎片化了的并联

        return isEnd;
    }
@@ -204,7 +196,7 @@
        algorithm.setAlgorithmType(endNode.getNodeType());
        algorithm.setComputerList(node.getId().toString());
        algorithm.setObjectList(node.getName());
        algorithm.setStep(algorithmList.size());
        algorithm.setStep(algorithmList.size()==0 ? 0 : algorithmList.get(algorithmList.size()-1).getStep()+1);
        algorithmList.add(algorithm);

        // 新增结束的虚节点
@@ -241,17 +233,100 @@
            if ("start,switch,vote".contains(endNode.getNodeType()) || endNode.getOutLineNum()!=1) {
                result.remove(endNode);
            }
            List<ModelNode> seriesNodes = result.stream().filter(item ->
            List<ModelNode> realSeriesNodes = result.stream().filter(item ->
                    !"connect".equals(item.getNodeType())).collect(Collectors.toList());
            if (seriesNodes.size()<2) continue;

            // 替换成虚节点
            if (realSeriesNodes.size()<1) {
                if (result.size() < 2) continue;
                // 替换成连线
                replaceToLineSeries(modelNodeList, modelLineList, result);
            } else if (realSeriesNodes.size()==1) {
                if (result.size() < 2) continue;   // path上只有该产品节点（node/vnode）自己，无需做什么
                // 将path替换成该节点
                replaceToTheNodeSeries(modelNodeList, modelLineList,
                        result, realSeriesNodes.get(0));
            } else {
                // 将path替换成虚节点
            replaceToVnodeSeries(modelId, modelNodeList, modelLineList,
                    algorithmList, modelNodeAndVnodeList, result, seriesNodes);
                        algorithmList, modelNodeAndVnodeList, result, realSeriesNodes);
            }
            hasSimplified = true;
        }

        return hasSimplified;
    }

    private void replaceToLineSeries(List<ModelNode> modelNodeList,
                                     List<ModelLine> modelLineList,
                                     List<ModelNode> path) {
        // 获取path的起点的出口线
        ModelNode finalNodeStart = path.get(0);
        ModelNode finalNodeEnd = path.get(path.size()-1);
        List<ModelLine> outLines = modelLineList.stream().filter(item ->
                item.getBeginCell().equals(finalNodeStart.getPicId())).collect(Collectors.toList());

        // 删除path上的所有中间连线及path的结束点以外的节点
        for (int i=0; i<path.size(); i++) {
            ModelNode finalNode = path.get(i);
            if (i < path.size() - 1) {
                // 将入口线删除
                List<ModelLine> lines = modelLineList.stream().filter(item ->
                        item.getEndCell().equals(finalNode.getPicId())).collect(Collectors.toList());
                modelLineList.removeAll(lines);
                // 删除节点
                modelNodeList.remove(finalNode);
                calcInOutLineNum(finalNode, modelLineList);
            }
        }

        // 将path的起点的出口线改为连接到path的结束点
        for (ModelLine line : outLines) {
            line.setBeginCell(finalNodeEnd.getPicId());
        }

        calcInOutLineNum(finalNodeStart, modelLineList);
        calcInOutLineNum(finalNodeEnd, modelLineList);
    }

    private void replaceToTheNodeSeries(List<ModelNode> modelNodeList,
                                      List<ModelLine> modelLineList,
                                      List<ModelNode> path,
                                      ModelNode theNode) {
        // 获取path的起点的出口线
        ModelNode finalNodeStart = path.get(0);
        List<ModelLine> outLines = modelLineList.stream().filter(item ->
                item.getBeginCell().equals(finalNodeStart.getPicId())).collect(Collectors.toList());
        // 获取path的结束点的入口线
        ModelNode finalNodeEnd = path.get(path.size()-1);
        List<ModelLine> inLines = modelLineList.stream().filter(item ->
                item.getEndCell().equals(finalNodeEnd.getPicId())).collect(Collectors.toList());

        // 删除path上的所有中间连线及theNode以外的节点
        for (int i=0; i<path.size(); i++) {
            ModelNode finalNode = path.get(i);
            if (i < path.size() - 1) {
                // 将入口线删除
                List<ModelLine> lines = modelLineList.stream().filter(item ->
                        item.getEndCell().equals(finalNode.getPicId())).collect(Collectors.toList());
                modelLineList.removeAll(lines);
            }
            if (!finalNode.getId().equals(theNode.getId())) {
                modelNodeList.remove(finalNode);
                calcInOutLineNum(finalNode, modelLineList);
            }
        }

        // 将path的起点的出口线改为连接到theNode
        for (ModelLine line : outLines) {
            line.setBeginCell(theNode.getPicId());
        }
        // 将path的结束点的入口线改为连接到theNode
        for (ModelLine line : inLines) {
            line.setEndCell(theNode.getPicId());
        }

        calcInOutLineNum(finalNodeStart, modelLineList);
        calcInOutLineNum(finalNodeEnd, modelLineList);
        calcInOutLineNum(theNode, modelLineList);
    }

    private void replaceToVnodeSeries(Long modelId,
@@ -262,6 +337,7 @@
                                      List<ModelNode> path,
                                      List<ModelNode> seriesNodes) {
        // 新增algorithm
        List<String> computerList = createVnodeComputerList("series", algorithmList, modelNodeAndVnodeList, seriesNodes);
        Algorithm algorithm = new Algorithm();
        Long id = UUIDUtil.generateId();
        algorithm.setId(id);
@@ -269,9 +345,9 @@
        algorithm.setComputerId(id);
        algorithm.setModelType("series");
        algorithm.setAlgorithmType("series");
        algorithm.setComputerList(joinNodeId(seriesNodes, ","));
        algorithm.setObjectList(joinNodeName(seriesNodes, ","));
        algorithm.setStep(algorithmList.size());
        algorithm.setComputerList(computerList.get(0));
        algorithm.setObjectList(computerList.get(1));
        algorithm.setStep(algorithmList.size()==0 ? 0 : algorithmList.get(algorithmList.size()-1).getStep()+1);
        algorithmList.add(algorithm);

        // 新增虚节点
@@ -322,6 +398,39 @@
        }

        calcInOutLineNum(vnode, modelLineList);
    }

    private List<String> createVnodeComputerList(String type,
                                                 List<Algorithm> algorithmList,
                                                 List<ModelNode> modelNodeAndVnodeList,
                                                 List<ModelNode> nodes) {
        String computerIdList = "";
        String objectList = "";
        for (int i=nodes.size()-1; i>=0; i--) {
            ModelNode node = nodes.get(i);
            if ("node".equals(node.getNodeType())) {
                objectList += "".equals(objectList) ? node.getName() : "," + node.getName();
                computerIdList += "".equals(computerIdList) ? node.getId().toString() : "," + node.getId().toString();
            } else {
                // vnode
                Algorithm algorithm = algorithmList.stream().filter(item ->
                        item.getId().equals(node.getId())).collect(Collectors.toList()).get(0);
                if ("series,parallel".contains(type) && type.equals(algorithm.getAlgorithmType())) {
                    objectList += "".equals(objectList) ? algorithm.getObjectList() : "," + algorithm.getObjectList();
                    computerIdList += "".equals(computerIdList) ? algorithm.getComputerList() : "," + algorithm.getComputerList();
                    algorithmList.remove(algorithm);
                    modelNodeAndVnodeList.remove(node);
                } else {
                    objectList += "".equals(objectList) ? node.getName() : "," + node.getName();
                    computerIdList += "".equals(computerIdList) ? node.getId().toString() : "," + node.getId().toString();
                }
            }
        }

        List<String> result = new ArrayList<>();
        result.add(computerIdList);
        result.add(objectList);
        return result;
    }

    private void seekPathSeries(List<ModelNode> modelNodeList,
@@ -385,7 +494,7 @@
                if ("connect".equals(startNode.getNodeType()) && pathOneGroup.size()==lines.size()) {
                    // 替换成虚节点
                    replaceToVnode("parallel", modelId, modelNodeList, modelLineList,
                            algorithmList, startNode, endNode, branchNodeList);
                            algorithmList, modelNodeAndVnodeList, startNode, endNode, branchNodeList);
                } else {
                    // 新增虚节点
                    ModelNode vnode = new ModelNode();
@@ -405,7 +514,7 @@
                    modelLineNew.setEndCell(startNode.getPicId());
                    modelLineList.add(modelLineNew);
                    replaceToVnode("parallel", modelId, modelNodeList, modelLineList,
                            algorithmList, vnode, endNode, branchNodeList);
                            algorithmList, modelNodeAndVnodeList, vnode, endNode, branchNodeList);
                    calcInOutLineNum(startNode, modelLineList);
                }
                hasSimplified = true;
@@ -575,7 +684,7 @@
        if ("connect".contains(startNode.getNodeType()) && startNode.getInLineNum()==2) {
            // 替换成虚节点
            replaceToVnode("bridge", modelId, modelNodeList, modelLineList,
                    algorithmList, startNode, endNode, branchNodeList);
                    algorithmList, modelNodeAndVnodeList, startNode, endNode, branchNodeList);
        } else {
            // 新增虚节点
            ModelNode vnode = new ModelNode();
@@ -595,7 +704,7 @@
            modelLineNew.setEndCell(startNode.getPicId());
            modelLineList.add(modelLineNew);
            replaceToVnode("bridge", modelId, modelNodeList, modelLineList,
                    algorithmList, vnode, endNode, branchNodeList);
                    algorithmList, modelNodeAndVnodeList, vnode, endNode, branchNodeList);
            calcInOutLineNum(startNode, modelLineList);
        }

@@ -636,6 +745,7 @@
                                     List<ModelNode> modelNodeList,
                                     List<ModelLine> modelLineList,
                                     List<Algorithm> algorithmList,
                                     List<ModelNode> modelNodeAndVnodeList,
                                     boolean hasSimplified) {
        List<ModelNode> opNodes = modelNodeList.stream().filter(item ->
                operator.equals(item.getNodeType())).collect(Collectors.toList());
@@ -664,7 +774,7 @@
            }
            if (thisNodeSuccess) {
                replaceToVnode(opNode.getNodeType(), modelId, modelNodeList, modelLineList,
                        algorithmList, opNode, endNode, branchNodeList);
                        algorithmList, modelNodeAndVnodeList, opNode, endNode, branchNodeList);
                hasSimplified = true;
            }
        }
@@ -677,10 +787,12 @@
                                List<ModelNode> modelNodeList,
                                List<ModelLine> modelLineList,
                                List<Algorithm> algorithmList,
                                List<ModelNode> modelNodeAndVnodeList,
                                ModelNode startNode,
                                ModelNode endNode,
                                List<ModelNode> branchNodeList) {
        // 新增algorithm
        List<String> computerList = createVnodeComputerList(type, algorithmList, modelNodeAndVnodeList, branchNodeList);
        Algorithm algorithm = new Algorithm();
        Long id = UUIDUtil.generateId();
        algorithm.setId(id);
@@ -688,9 +800,9 @@
        algorithm.setComputerId(id);
        algorithm.setModelType(type);
        algorithm.setAlgorithmType(type);
        algorithm.setComputerList(joinNodeId(branchNodeList, ","));
        algorithm.setObjectList(joinNodeName(branchNodeList, ","));
        algorithm.setStep(algorithmList.size());
        algorithm.setComputerList(computerList.get(0));
        algorithm.setObjectList(computerList.get(1));
        algorithm.setStep(algorithmList.size()==0 ? 0 : algorithmList.get(algorithmList.size()-1).getStep()+1);
        algorithmList.add(algorithm);

        // 替换为虚节点
@@ -763,7 +875,7 @@
                if ("node".equals(modelNode.getNodeType())) {
                    modelNode.setDataId(Long.valueOf(JsonUtils2.getJsonValueByPath(jsonObject, "data/dataId".split("/")).toString()));
//                    modelNode.setNodeTypeExt(JsonUtils2.getJsonValueByPath(jsonObject, "data/nodeTypeExt".split("/")).toString());
                    Object label = JsonUtils2.getJsonValueByPath(jsonObject, "attrs/label/textWrap/text".split("/"));
                    Object label = JsonUtils2.getJsonValueByPath(jsonObject, "attrs/text/text".split("/"));
                    modelNode.setName(label==null ? "" : label.toString());
                }
                modelNodeList.add(modelNode);
@@ -890,7 +1002,7 @@
            } // end for
        } while (hasLeastOne);

        if (saveFlag) saveModel(modelId, modelNodeList, modelLineList, algoList);
//        if (saveFlag) saveModel(modelId, modelNodeList, modelLineList, algoList);
    }

    private void handleOneLine(List<ModelLine> modelLineList,
@@ -1010,11 +1122,13 @@
    private void saveModel(Long modelId,
                           List<ModelNode> modelNodeList,
                           List<ModelLine> modelLineList,
                           List<Algorithm> algoList) {
                           List<Algorithm> algoList,
                           List<ModelNode> modelNodeAndVnodeList) {
        // 删除既有数据
        modelNodeDao.deleteByModelId(modelId);
        modelLineDao.deleteByModelId(modelId);
        algorithmDao.deleteByModelId(modelId);
        modelNodeAlgorithmDao.deleteByModelId(modelId);

        // 插入数据
        for (ModelNode modelNode : modelNodeList) {
@@ -1026,6 +1140,9 @@
        for (Algorithm algorithm : algoList) {
            algorithmDao.insert(algorithm);
        }
        for (ModelNode modelNode : modelNodeAndVnodeList) {
            modelNodeAlgorithmDao.insert(ModelNodeAlgorithm.from(modelNode));
        }
    }

}

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

New file
@@ -0,0 +1,24 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.zt.life.modules.taskReliability.dao.ModelNodeAlgorithmDao">

    <select id="getList" resultType="com.zt.life.modules.taskReliability.model.ModelNodeAlgorithm">
        select a.*
        from model_node_algorithm a
        <where>
            a.is_delete = 0
            <if test="whereSql!=null">
                and ${whereSql}
            </if>
        </where>
        <if test="orderBySql!=null">
            ORDER BY ${orderBySql}
        </if>
    </select>

    <update id="deleteByModelId">
        delete from model_node_algorithm where model_id=#{modelId}
    </update>

</mapper>

 web/public/modelImg/switchRight.png