新增可忽略的维修时间

xyc

2025-02-21 664db98c9e8595ce4dd636a27f480e3a08b81ff5

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

@@ -8,7 +8,7 @@
import com.zt.common.db.query.QueryFilter;
import com.zt.common.exception.RenException;
import com.zt.common.service.BaseService;
import com.zt.common.servlet.Result;
import com.zt.common.utils.CommonUtils;
import com.zt.common.utils.TreeUtils;
import com.zt.common.utils.UUIDUtil;
import com.zt.life.export.service.DownloadService;
@@ -27,7 +27,7 @@
import com.zt.life.modules.mainPart.taskReliability.model.*;
import com.zt.life.modules.mainPart.utils.GetStringSpace;
import com.zt.life.modules.mainPart.utils.OSUtils.ProcessUtils;
import io.swagger.models.auth.In;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.dom4j.Document;
@@ -51,10 +51,7 @@
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.nio.file.FileAlreadyExistsException;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;


@@ -1127,6 +1124,10 @@
                failureTag.addAttribute("name", failureModel.getId().toString());

                if (1 == paramData.getRepairable()) {
                    // 可忽略的维修时间
                    if (paramData.getNegligibleRepairTime() != null && paramData.getNegligibleRepairTime().doubleValue() > 0) {
                        nodeTag.addAttribute("negligible_repair_time", String.valueOf(paramData.getNegligibleRepairTime()));
                    }
                    // 可维修
                    RepairModel repairModel = null;
                    if (isRepairDirac(simulatAssess.getRepairDiracFlag(), taskPhaseModel, product.getId())) {
@@ -1757,4 +1758,535 @@
            }
        }
    }
/*
    public Boolean mySimulate(SimulatAssess simulatAssess) {
        logger.info("仿真评估开始");
        // 1. 仿真初始化
        SimulateStaticDataDto simulateStaticDataDto = new SimulateStaticDataDto();
        SimulateDynamicDataDto simulateDynamicDataDto = new SimulateDynamicDataDto();
        initSimulate(simulatAssess, simulateStaticDataDto, simulateDynamicDataDto);
        logger.info("仿真评估初始化完成");

        // 2. 仿真处理
        for (int i = 0; i < simulatAssess.getSimulatFrequency(); i++) {
            doSimulate(i, simulatAssess, simulateStaticDataDto, simulateDynamicDataDto);
        }
        logger.info("仿真评估仿真处理完成");

        return true;
    }

    private void initSimulate(SimulatAssess simulatAssess,
                              SimulateStaticDataDto simulateStaticDataDto,
                              SimulateDynamicDataDto simulateDynamicDataDto) {
        Date beginDate = new Date();
        XhProductModel product = xhProductModelDao.getById(simulatAssess.getProductId());
        List<XhProductModel> productList = xhProductModelDao.getByShipId(product.getId());
        List<ParamData> paramDataList = paramDataDao.getDeviceParams(product.getId());
        Task task = taskService.get(simulatAssess.getTaskModelId());
        if (simulatAssess.getTaskDuration() != null) {
            task.setTaskDuration(simulatAssess.getTaskDuration());
        }
        List<TaskBinoParam> binoParams = taskBinoParamDao.getBinoParams(task.getId());

        // 1. 计算各任务阶段的运行时长
        List<TaskPhase> taskPhases = calcTaskPhaseDuration(task);
        // 2. 计算各工况模型的运行时长
        List<TaskPhaseModel> taskPhaseModelAll = new ArrayList<>();
        for (TaskPhase taskPhase : taskPhases) {
            calcTaskPhaseModelDuration(taskPhase, taskPhaseModelAll);
        }
        Date date1 = new Date();
        logger.info("数据准备时间：" + CommonUtils.getDatePoor(date1, beginDate));
        // 3. 将各工况模型递归拆解为完整的可供仿真计算的阶段工况模型数据
        createAllModelData(simulatAssess.getRepairDiracFlag(),
                task.getId(),
                product.getId(),
                product.getName(),
                product.getNamePath(),
                productList,
                paramDataList,
                taskPhaseModelAll,
                binoParams,
                simulateStaticDataDto);
        Date date2 = new Date();
        logger.info("生成阶段工况模型数据时间：" + CommonUtils.getDatePoor(date2, date1));
        // 4. 生成静态事件列表
        createStaticEventList(simulateStaticDataDto, task.getTaskDuration());
        Date date3 = new Date();
        logger.info("生成静态事件列表时间：" + CommonUtils.getDatePoor(date3, date2));
        // 5. 生成动态仿真数据
        createDynamicSimulateData(simulatAssess, simulateStaticDataDto, simulateDynamicDataDto);
        Date date4 = new Date();
        logger.info("生成动态仿真数据时间：" + CommonUtils.getDatePoor(date4, date3));
        // 6. 存盘
        saveSimulatAssessTaskPhaseModel(simulatAssess,
                task,
                taskPhases,
                taskPhaseModelAll);
    }

    private void createDynamicSimulateData(SimulatAssess simulatAssess,
                              SimulateStaticDataDto simulateStaticDataDto,
                              SimulateDynamicDataDto simulateDynamicDataDto) {
        List<SimulateNode> nodeList = simulateDynamicDataDto.getNodeList();
        Map<Long, SimulateModelData> modelDataMap = simulateStaticDataDto.getModelDataMap();
        for (Long key : modelDataMap.keySet()) {
            for (SimulateNode node : modelDataMap.get(key).getActualNodeList()) {
                List<SimulateNode> nodes = nodeList.stream().filter(item ->
                        node.getId().equals(item.getId())).collect(Collectors.toList());
                if (nodes.size() == 0) {
                    nodeList.add(node.clone());
                }
            }
        }
        simulateDynamicDataDto.setStaticNodeNum(nodeList.size());

        for (SimulateNode node : nodeList) {
            List<List<SimulateStatus>> statusData = new ArrayList<>();
            node.setStatusData(statusData);
            for (int i = 0; i < simulatAssess.getSimulatFrequency(); i++) {
                List<SimulateStatus> statusList = new ArrayList<>();
                statusData.add(statusList);
            }
        }
    }

    private void createStaticEventList(SimulateStaticDataDto simulateStaticDataDto, double taskDuration) {
        Map<Long, SimulateModelData> modelDataMap = simulateStaticDataDto.getModelDataMap();
        Map<Long, SimulatePhaseModel> modelStartTimeMap = simulateStaticDataDto.getModelStartTimeMap();
        for (Long key : modelStartTimeMap.keySet()) {
            // 1. 阶段工况模型切换事件
            double startTime = modelStartTimeMap.get(key).getStartTime();
            SimulateEvent event = new SimulateEvent();
            event.setId(UUIDUtil.generateId());
            event.setType(SimulateEvent.TYPE_MODEL_CHG);
            event.setTime(startTime);
            event.setNodeId(key.toString());
            simulateStaticDataDto.getStaticEventList().add(event);

            // 2. 有运行比的设备节点的cycon/cycoff事件
            List<SimulateNode> nodes = modelDataMap.get(key).getActualNodeList().stream().filter(item ->
                    item.getIsLeafNode() && item.getCycOffDuration() != null).collect(Collectors.toList());
            if (nodes.size() > 0) {
                List<SimulateEvent> cycEventList = new ArrayList<>();
                simulateStaticDataDto.getCycEventMap().put(key, cycEventList);
                for (SimulateNode node : nodes) {
//                    event = new SimulateEvent();
//                    event.setId(UUIDUtil.generateId());
//                    event.setType(SimulateEvent.TYPE_CYCON);
//                    event.setTime(startTime);
//                    event.setNodeId(node.getId());
//                    cycEventList.add(event);
                    event = new SimulateEvent();
                    event.setId(UUIDUtil.generateId());
                    event.setType(SimulateEvent.TYPE_CYCOFF);
                    event.setTime(startTime + node.getCycOnDuration());
                    event.setNodeId(node.getId());
                    cycEventList.add(event);
                }
            }
        }

        // 3. 仿真结束事件
        SimulateEvent event = new SimulateEvent();
        event.setId(UUIDUtil.generateId());
        event.setType(SimulateEvent.TYPE_END);
        event.setTime(taskDuration);
        simulateStaticDataDto.getStaticEventList().add(event);
    }

    private void createAllModelData(boolean repairDiracFlag,
                              Long taskId,
                              Long productId,
                              String productName,
                              String productNamePath,
                              List<XhProductModel> productList,
                              List<ParamData> paramDataList,
                              List<TaskPhaseModel> taskPhaseModelAll,
                              List<TaskBinoParam> binoParams,
                              SimulateStaticDataDto simulateStaticDataDto) {
        double startTime = 0;
        for (TaskPhaseModel taskPhaseModel : taskPhaseModelAll) {
            List<OperatConditModel> gkModelsAssembled = operatConditModelDao.getGKModelAssembled(
                    taskPhaseModel.getOperatConditId());
            OperatConditModel gkModelTop = gkModelsAssembled.stream().filter(item ->
                    productId.equals(item.getProductId())).collect(Collectors.toList()).get(0);
            List<ModelNode> modelNodeAndVnodeList = modelNodeAlgorithmDao.getListByModelId(gkModelTop.getModelId());
            List<Algorithm> algorithmList = algorithmDao.getListByModelId(gkModelTop.getModelId());
            // 将模型转换为Tree
            SimulateNode root = new SimulateNode();
            Algorithm endAlgo = algorithmList.stream().filter(item ->
                    "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);
            Date beginDate = new Date();
            node2Tree(repairDiracFlag,
                    taskId,
                    taskPhaseModel,
                    productId,
                    productName,
                    productNamePath,
                    productList,
                    paramDataList,
                    gkModelsAssembled,
                    algorithmList,
                    modelNodeAndVnodeList,
                    binoParams,
                    computerNode, root);
            Date date1 = new Date();
            logger.info("node2Tree时间：" + CommonUtils.getDatePoor(date1, beginDate));
            SimulateModelData simulateModelData = new SimulateModelData();
            SimulateNode.treeToModelData(root, simulateModelData);
            Date date2 = new Date();
            logger.info("treeToModelData时间：" + CommonUtils.getDatePoor(date2, date1));
            simulateStaticDataDto.getModelDataMap().put(taskPhaseModel.getId(), simulateModelData);
            SimulatePhaseModel simulatePhaseModel = new SimulatePhaseModel();
            simulatePhaseModel.setId(taskPhaseModel.getId());
            simulatePhaseModel.setStartTime(startTime);
            simulateStaticDataDto.getModelStartTimeMap().put(taskPhaseModel.getId(), simulatePhaseModel);
            startTime += taskPhaseModel.getOperatConditDuration();
        }
    }

    // 递归函数
    private void node2Tree(boolean repairDiracFlag,
                          Long taskId,
                          TaskPhaseModel taskPhaseModel,
                          Long productId,
                          String productName,
                          String productNamePath,
                          List<XhProductModel> productList,
                          List<ParamData> paramDataList,
                          List<OperatConditModel> gkModelsAssembled,
                          List<Algorithm> algorithmList,
                          List<ModelNode> modelNodeAndVnodeList,
                          List<TaskBinoParam> binoParams,
                          ModelNode node,
                           SimulateNode simulateNode) {
        if ("node".equals(node.getNodeType())) {
            simulateNode.setIsActualNode(true);
            Long dataId = node.getDataId();
            XhProductModel product = productList.stream().filter(item ->
                    dataId.equals(item.getId())).collect(Collectors.toList()).get(0);
            if ("3,4,10".contains(product.getProductType())) {
                // 系统、分系统、虚单元
                OperatConditModel gkModel = gkModelsAssembled.stream().filter(item ->
                        dataId.equals(item.getProductId())).collect(Collectors.toList()).get(0);
                List<Algorithm> algorithmListSub = algorithmDao.getListByModelId(gkModel.getModelId());
                List<ModelNode> modelNodeAndVnodeListSub = modelNodeAlgorithmDao.getListByModelId(gkModel.getModelId());
                Algorithm endAlgo = algorithmListSub.stream().filter(item ->
                        "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);
                node2Tree(repairDiracFlag,
                        taskId,
                        taskPhaseModel,
                        product.getId(),
                        product.getName(),
                        product.getNamePath(),
                        productList,
                        paramDataList,
                        gkModelsAssembled,
                        algorithmListSub,
                        modelNodeAndVnodeListSub,
                        binoParams,
                        computerNode, simulateNode);
            } else if ("5".equals(product.getProductType())) {
                // 设备
                simulateNode.setIsLeafNode(true);
                simulateNode.setFailureRate(1.0);
                Integer deviceNo = node.getDeviceNo();
                simulateNode.setId(dataId.toString() + "-" + deviceNo);
                simulateNode.setName(product.getName() + "-" + deviceNo);
                simulateNode.setNamePath(product.getNamePath());

                ParamData paramData = paramDataList.stream().filter(item ->
                        dataId.equals(item.getProductId())).collect(Collectors.toList()).get(0);
                Double ratio = paramData.getTaskMtbcfOperatingRatio();
                if (null != ratio && ratio != 1.0) {
                    // 间断型设备的处理
                    simulateNode.setRunningRatio(ratio);
                    double cycon = taskPhaseModel.getOperatConditDuration() * ratio;
                    double cycdown = taskPhaseModel.getOperatConditDuration() - cycon;
                    simulateNode.setCycOnDuration(cycon);
                    simulateNode.setCycOffDuration(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 -> dataId.equals(item.getProductId()))
                            .collect(Collectors.toList()).get(0);
                }
                if (1 == paramData.getRepairable() &&
                        isRepairDirac(repairDiracFlag, taskPhaseModel, product.getId())) {
                    simulateNode.setIsRepairDirac(true);
                } else {
                    simulateNode.setIsRepairDirac(false);
                    simulateNode.setFailureModel(createFailureModel(paramData, taskBinoParam));
                }
                if (1 == paramData.getRepairable()) {
                    // 可维修
                    simulateNode.setRepairModel(createRepairModel(paramData));
                }
            }
        } else {
            // vnode（运算节点）
            Algorithm algo = algorithmList.stream().filter(item ->
                    node.getId().equals(item.getId())).collect(Collectors.toList()).get(0);
            if (null == productId) {
                simulateNode.setIsActualNode(false);
                simulateNode.setId(algo.getId().toString());
            } else {
                simulateNode.setIsActualNode(true);
                simulateNode.setId(productId.toString());
                simulateNode.setName(productName);
                simulateNode.setNamePath(productNamePath);
            }
            if (SimulateNode.LOGIC_TYPE_SERIES.equals(algo.getAlgorithmType())) {
                simulateNode.setLogicType(SimulateNode.LOGIC_TYPE_SERIES);
            } else if (SimulateNode.LOGIC_TYPE_PARALLEL.equals(algo.getAlgorithmType())) {
                simulateNode.setLogicType(SimulateNode.LOGIC_TYPE_PARALLEL);
            } else if (SimulateNode.LOGIC_TYPE_VOTE.equals(algo.getAlgorithmType())) {
                simulateNode.setLogicType(SimulateNode.LOGIC_TYPE_VOTE);
                simulateNode.setVoteNum(algo.getVoteNum());
            } else if ("switch".equals(algo.getAlgorithmType())) {
                simulateNode.setLogicType(SimulateNode.LOGIC_TYPE_STANDBY);
                simulateNode.setVoteNum(algo.getVoteNum());
            } else if ("warm_switch".equals(algo.getAlgorithmType())) {
                simulateNode.setLogicType(SimulateNode.LOGIC_TYPE_WARM_STANDBY);
                simulateNode.setVoteNum(algo.getVoteNum());
            } else if (SimulateNode.LOGIC_TYPE_BRIDGE.equals(algo.getAlgorithmType())) {
                simulateNode.setLogicType(SimulateNode.LOGIC_TYPE_BRIDGE);
            }
            String[] computerNodeListStr = algo.getComputerList().split(",");
            for (String nodeStr : computerNodeListStr) {
                SimulateNode sn = new SimulateNode();
                simulateNode.getChildren().add(sn);
                ModelNode mn = modelNodeAndVnodeList.stream().filter(item ->
                        nodeStr.equals(item.getId().toString())).collect(Collectors.toList()).get(0);
                node2Tree(repairDiracFlag,
                        taskId,
                        taskPhaseModel,
                        null,
                        null,
                        null,
                        productList,
                        paramDataList,
                        gkModelsAssembled,
                        algorithmList,
                        modelNodeAndVnodeList,
                        binoParams,
                        mn, sn);
            }
        }
    }

    private void doSimulate(int sCnt, SimulatAssess simulatAssess,
                               SimulateStaticDataDto simulateStaticDataDto,
                               SimulateDynamicDataDto simulateDynamicDataDto) {
        // 1. 仿真事件初始化
        initSimulateEvent(simulateStaticDataDto, simulateDynamicDataDto);
        // 2. 仿真时钟初始化
        double lastTime = 0.0;
        // 3. 仿真事件死循环（仿真结束事件退出）
        for (;;) {
            boolean hasModelChgEvent = false;
            // 3.1 从仿真事件列表中查询出事件时间最小的事件集合
            List<SimulateEvent> minEventList = getMinEventList(simulateDynamicDataDto.getEventList());
            double currentTime = minEventList.get(0).getTime();
            // 3.2 最小时间事件集合处理
            List<SimulateEvent> endEvents = minEventList.stream().filter(item ->
                    SimulateEvent.TYPE_END==item.getType()).collect(Collectors.toList());
            if (endEvents.size() > 0) {
                break;
            }
            List<SimulateEvent> modelChgEvents = minEventList.stream().filter(item ->
                    SimulateEvent.TYPE_MODEL_CHG==item.getType()).collect(Collectors.toList());
            if (modelChgEvents.size() > 0) {
                hasModelChgEvent = true;
                SimulateEvent modelChgEvent = modelChgEvents.get(0);
                // 3.2.1 新阶段数据加载
                loadNewModelData(simulateStaticDataDto, simulateDynamicDataDto, modelChgEvent);
            }
            List<SimulateNode> leafNodes = simulateDynamicDataDto.getNodeList().stream().filter(item ->
                    item.getIsLeafNode()).collect(Collectors.toList());
            for (SimulateNode leafNode : leafNodes) {
                // 3.2.2 耗时及状态处理（对所有叶子节点处理）
                handleLifeAndStatus(currentTime-lastTime, currentTime, leafNode, simulateDynamicDataDto.getNodeList());
            }
            if (hasModelChgEvent) {
                // 3.2.3 阶段工况模型切换处理
                // 二项分布设备处理
                // 移除该阶段切换事件
                removeEvent(simulateDynamicDataDto, modelChgEvents.get(0));
            }
            List<SimulateEvent> cycoffEvents = minEventList.stream().filter(item ->
                    SimulateEvent.TYPE_CYCOFF==item.getType()).collect(Collectors.toList());
            for (SimulateEvent cycoffEvent : cycoffEvents) {
                // 3.2.4 cycoff事件处理
                SimulateNode node = simulateDynamicDataDto.getNodeList().stream().filter(item ->
                        cycoffEvent.getNodeId().equals(item.getId())).collect(Collectors.toList()).get(0);
                node.setStatus(SimulateStatus.STATUS_CYCDOWN);
                // 移除该cycoff事件
                removeEvent(simulateDynamicDataDto, cycoffEvent);
            }
            // 3.2.5 迭代处理

        }
    }

    private void removeEvent(SimulateDynamicDataDto simulateDynamicDataDto, SimulateEvent event) {
        Iterator<SimulateEvent> iterator = simulateDynamicDataDto.getEventList().iterator();
        while (iterator.hasNext()) {
            SimulateEvent item = iterator.next();
            if (event.getId().equals(item.getId())) iterator.remove();
        }
    }

    private void handleLifeAndStatus(double deltaTime,
                                     double currentTime,
                                     SimulateNode node,
                                     List<SimulateNode> nodeList) {
        // 耗时处理
        if (SimulateStatus.STATUS_ACTIVE.equals(node.getStatus()) ||
                SimulateStatus.STATUS_WARM.equals(node.getStatus())) {
            node.setLifeTime(node.getLifeTime()-deltaTime*node.getFailureRate());
        }
        if (node.getRepairTime()>0 && node.getRepairModel()!=null) {
            double repairTime = node.getRepairTime()-deltaTime;
            if (repairTime < 0) repairTime = 0;
            node.setRepairTime(repairTime);
        }
        // 状态处理
        if (SimulateStatus.STATUS_ACTIVE.equals(node.getStatus()) &&
                node.getLifeTime()<=0) {
            if (node.getRepairModel()==null) {
                node.setStatus(SimulateStatus.STATUS_FAILED);
            } else {
                node.setStatus(SimulateStatus.STATUS_MAINTENANCE);
                double repairTime = createRepairTime(node.getRepairModel());
                node.setRepairTime(repairTime);
                node.setLifeTime(0.0);
                node.getFailureEvent().setType(SimulateEvent.TYPE_EXPECT_REPAIR);
                node.getFailureEvent().setTime(currentTime+repairTime);
            }
            setMayChangeStatus(node, nodeList);
        }
        if (SimulateStatus.STATUS_MAINTENANCE.equals(node.getStatus()) &&
                node.getRepairTime()<=0) {
            node.setStatus(SimulateStatus.STATUS_ACTIVE);
            double lifeTime = createLifeTime(node.getFailureModel());
            node.setLifeTime(lifeTime);
            node.setRepairTime(0.0);
            node.getFailureEvent().setType(SimulateEvent.TYPE_EXPECT_FAIL);
            node.getFailureEvent().setTime(currentTime+lifeTime);
            setMayChangeStatus(node, nodeList);
        }
    }

    private void setMayChangeStatus(SimulateNode node,
                                    List<SimulateNode> nodeList) {
        node.setMayChangeStatus(true);
        for (String pid : node.getPids()) {
            SimulateNode pNode = nodeList.stream().filter(item ->
                    pid.equals(item.getId())).collect(Collectors.toList()).get(0);
            pNode.setMayChangeStatus(true);
        }
    }

    private void loadNewModelData(SimulateStaticDataDto simulateStaticDataDto,
                                  SimulateDynamicDataDto simulateDynamicDataDto,
                                  SimulateEvent modelChgEvent) {
        // 删除仿真动态数据中的虚节点
        Iterator<SimulateNode> iterator = simulateDynamicDataDto.getNodeList().iterator();
        while (iterator.hasNext()) {
            SimulateNode item = iterator.next();
            if (!item.getIsActualNode()) iterator.remove();
        }
        // 所有实节点初始化为未使用
        for (SimulateNode node : simulateDynamicDataDto.getNodeList()) {
            node.setIsUsed(false);
        }
        // 加入该阶段工况模型的所有虚节点
        SimulateModelData modelData = simulateStaticDataDto.getModelDataMap().get(Long.valueOf(modelChgEvent.getNodeId()));
        for (SimulateNode vnode : modelData.getVirtualNodeList()) {
            simulateDynamicDataDto.getNodeList().add(vnode.clone());
        }
        // 把该阶段工况模型中的所有实节点的内容拷贝到仿真动态数据中的实节点
        for (SimulateNode anode : modelData.getActualNodeList()) {
            SimulateNode node = simulateDynamicDataDto.getNodeList().stream().filter(item ->
                    anode.getId().equals(item.getId())).collect(Collectors.toList()).get(0);
            node.setPid(anode.getPid());
            node.setNamePath(anode.getNamePath());
            node.setPids(anode.getCids());
            node.setCids(anode.getCids());
            node.setIsLeafNode(anode.getIsLeafNode());
            node.setIsUsed(anode.getIsUsed());
            node.setFailureRate(anode.getFailureRate());
//            node.setRunningRatio(anode.getRunningRatio());
//            node.setCycOnDuration(anode.getCycOnDuration());
//            node.setCycOffDuration(anode.getCycOffDuration());
            node.setFailureModel(anode.getFailureModel());
            node.setRepairModel(anode.getRepairModel());
            node.setIsRepairDirac(anode.getIsRepairDirac());
            node.setLogicType(anode.getLogicType());
            node.setVoteNum(anode.getVoteNum());
            node.setNodeNo(anode.getNodeNo());
        }
        // 把该阶段工况模型中的cycoff事件加入到仿真事件列表
        List<SimulateEvent> cycEvents = simulateStaticDataDto.getCycEventMap().get(Long.valueOf(modelChgEvent.getNodeId()));
        for (SimulateEvent event : cycEvents) {
            simulateDynamicDataDto.getEventList().add(event);
        }
    }

    private List<SimulateEvent> getMinEventList(List<SimulateEvent> eventList) {
        List<SimulateEvent> result = new ArrayList<>();
        double minTime = Double.MAX_VALUE;
        for (SimulateEvent event : eventList) {
            if (event.getTime() <= minTime) {
                minTime = event.getTime();
                result.add(event);
            }
        }
        return result;
    }

    private void initSimulateEvent(SimulateStaticDataDto simulateStaticDataDto,
                                   SimulateDynamicDataDto simulateDynamicDataDto) {
        simulateDynamicDataDto.getEventList().clear();
        simulateDynamicDataDto.getEventList().addAll(simulateStaticDataDto.getStaticEventList());

        List<SimulateNode> leafNodeList = simulateDynamicDataDto.getNodeList().stream().filter(item ->
                item.getIsLeafNode()).collect(Collectors.toList());
        for (SimulateNode leafNode : leafNodeList) {
            double lifeTime = createLifeTime(leafNode.getFailureModel());
            // 为了提高效率，动态事件列表及设备节点里同时保存预期故障/修复事件实体的指针
            SimulateEvent event = new SimulateEvent();
            event.setId(UUIDUtil.generateId());
            event.setType(SimulateEvent.TYPE_EXPECT_FAIL);
            event.setTime(lifeTime);
            event.setNodeId(leafNode.getId());
            simulateDynamicDataDto.getEventList().add(event);
            leafNode.setFailureEvent(event);
            leafNode.setLifeTime(lifeTime);
            leafNode.setRepairTime(0.0);
            leafNode.setStatus(SimulateStatus.STATUS_ACTIVE);
        }
    }

    private double createLifeTime(FailureModel failureModel) {
        return 0.0;
    }

    private double createRepairTime(RepairModel repairModel) {
        return 0.0;
    }

 */
}