package com.zt.life.modules.mainPart.taskReliability.service;
|
|
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.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.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.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.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 com.zt.life.modules.mainPart.utils.OSUtils.ProcessUtils;
|
import io.swagger.models.auth.In;
|
import org.apache.commons.io.IOUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.dom4j.Document;
|
import org.dom4j.DocumentHelper;
|
import org.dom4j.Element;
|
import org.dom4j.io.OutputFormat;
|
import org.dom4j.io.XMLWriter;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
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;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
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;
|
|
|
/**
|
* simulat_assess
|
*
|
* @author zt generator
|
* @since 1.0.0 2024-03-20
|
*/
|
@Service
|
public class SimulatAssessService extends BaseService<SimulatAssessDao, SimulatAssess> {
|
private static final Logger logger = LoggerFactory.getLogger(SimulatAssessService.class);
|
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;
|
@Value("${spring.redis.port}")
|
private String redisPort;
|
@Value("${data.reliaSimLib.mainPy}")
|
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 SimulatAssessTaskPhaseModelService simulatAssessTaskPhaseModelService;
|
@Autowired
|
private TaskPhaseDao taskPhaseDao;
|
@Autowired
|
private TaskPhaseModelDao taskPhaseModelDao;
|
@Autowired
|
private OperatConditModelDao operatConditModelDao;
|
@Autowired
|
private ModelNodeAlgorithmDao modelNodeAlgorithmDao;
|
@Autowired
|
private AlgorithmDao algorithmDao;
|
@Autowired
|
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<>();
|
Map<Integer, String> templetsStrMap2 = new HashMap<>();
|
|
private JSONObject xmlJSONObj;
|
|
/**
|
* 分页查询
|
*
|
* @param queryFilter
|
* @return
|
*/
|
/* public List<SimulatAssess> page(QueryFilter queryFilter) {
|
return baseDao.getList(queryFilter.getQueryParams());
|
}*/
|
|
/**
|
* 删除
|
*
|
* @param ids
|
*/
|
public void delete(Long[] ids) {
|
super.deleteLogic(ids);
|
}
|
|
public Integer getNumById(Long productId, Long taskModelId) {
|
return baseDao.getNumById(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) {
|
return baseDao.getParams(id, taskModelId);
|
}
|
|
public List<ProductStatusDto> getProduct(Long productId, Long taskId) {
|
return baseDao.getChildren(productId, taskId);
|
}
|
|
public TimeDiagramDto getTimeDiagram(Long productId, Long taskId, Long fzId, double smallWidth, double minPointNum) {
|
TimeDiagramDto timeDiagramDto = new TimeDiagramDto();
|
timeDiagramDto.setSmallWidth(smallWidth);
|
timeDiagramDto.setMinPointNum(minPointNum);
|
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");
|
|
JSONObject jsonObject3 = new JSONObject(templetStr);
|
JSONArray jsonArray3 = jsonObject3.getJSONArray("cells");
|
|
String modelStr2 = this.getPetsInfo();
|
double x1 = 0;
|
double x2 = 0;
|
int y = -10;
|
int groupY = 0;
|
int spaceHeight = 20;
|
int groupHeight = 20;
|
|
double pointNumPerHour = 60.0 / simulatAssess.getSamplPeriod();
|
|
//时序图线
|
List<TimeDiagramStatusDto> statusDtoList = new ArrayList<>();
|
List<TimeDiagramStatusDto> statusDtoListOld = new ArrayList<>();
|
for (int i = 0; i < list.size(); i++) {
|
x1 = 0;
|
groupY = groupHeight * i;
|
ProductStatusDto dto = list.get(i);
|
double startTime = 0.0;
|
int status2 = 5;
|
for (StatusDto status : dto.getStatusList()) {
|
switch (status.getStatus()) {
|
case "O":
|
y = groupY;
|
status2 = 5;
|
break;
|
case "F":
|
y = groupY;// + spaceHeight;
|
status2 = 1;
|
break;
|
case "I":
|
y = groupY;// + spaceHeight;
|
status2 = 3;
|
break;
|
case "S":
|
y = groupY;// + spaceHeight;
|
status2 = 2;
|
break;
|
case "M":
|
y = groupY;// + 2 * spaceHeight;
|
status2 = 4;
|
break;
|
}
|
x2 = x1 + status.getTimes() * pointNumPerHour + 5;
|
if (i == 0) {
|
statusDtoList.add(new TimeDiagramStatusDto(x1, x2, status2));
|
} else {
|
statusDtoListOld.add(new TimeDiagramStatusDto(x1, x2, status2));
|
}
|
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("%.1f", startTime));
|
JsonUtils2.setJsonValueByPath(lineJson, "data/endTimes".split("/"), String.format("%.1f", startTime + status.getTimes()));
|
JsonUtils2.setJsonValueByPath(lineJson, "id".split("/"), UUIDUtil.generateId().toString());
|
startTime = startTime + status.getTimes();
|
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);
|
jsonArray3.add(textJson);
|
}
|
|
//阶段模型及刻度
|
x1 = 0;
|
x2 = 0;
|
double y1 = -60;
|
y = -40;
|
double y2 = -30;
|
|
JSONObject modelJson = new JSONObject(templetsStrMap.get("model"));
|
setlineXy(modelJson, 1, y1, 1, 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();
|
double gkPoint = modelDto.getGkDuration() * pointNumPerHour;
|
x2 = x2 + gkPoint;
|
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();
|
}
|
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("/"), "模型" + (i + 1));
|
JsonUtils2.setJsonValueByPath(textJson, "attrs/label/textWrap/modelName".split("/"), modelName);
|
|
JsonUtils2.setJsonValueByPath(textJson, "size/width".split("/"), mapSpace.get("width") + 10);
|
|
double x11 = x1 + ((gkPoint - mapSpace.get("width") + 12) / 2);
|
JsonUtils2.setJsonValueByPath(textJson, "position/x".split("/"), x11);
|
JsonUtils2.setJsonValueByPath(textJson, "position/y".split("/"), y1 - 10);
|
jsonArray.add(textJson);
|
x1 = x2;
|
}
|
|
JSONObject modelJson3 = new JSONObject(templetsStrMap.get("model"));
|
setlineXy(modelJson3, 0, y, x2, y, null);
|
jsonArray.add(modelJson3);
|
|
//刻度
|
Integer curPointHour = 100, periodHour = 100;
|
while (curPointHour < totalHours) {
|
JSONObject modelJson4 = new JSONObject(templetsStrMap.get("model"));
|
double x = curPointHour * pointNumPerHour;
|
setlineXy(modelJson4, x, y, x, y2, null);
|
jsonArray.add(modelJson4);
|
|
Map<String, Integer> mapSpace = GetStringSpace.getStringSpaceSize(curPointHour.toString(), null, 20);
|
JSONObject textJson = new JSONObject(templetsStrMap.get("text"));
|
JsonUtils2.setJsonValueByPath(textJson, "id".split("/"), UUIDUtil.generateId().toString());
|
JsonUtils2.setJsonValueByPath(textJson, "attrs/label/textWrap/text".split("/"), curPointHour.toString());
|
|
JsonUtils2.setJsonValueByPath(textJson, "size/width".split("/"), mapSpace.get("width") + 20);
|
|
double x11 = x - mapSpace.get("width") / 2 - 5;
|
JsonUtils2.setJsonValueByPath(textJson, "position/x".split("/"), x11);
|
JsonUtils2.setJsonValueByPath(textJson, "position/y".split("/"), y2 - 10);
|
jsonArray.add(textJson);
|
|
curPointHour += periodHour;
|
}
|
|
List<TimeDiagramStatusDto> statusDtoListNew = new ArrayList<>();
|
while (statusDtoListOld.size() > 0) {
|
//statusDtoListOld.stream().sorted(Comparator.comparing(TimeDiagramStatusDto::getX1)).collect(Collectors.toList());
|
statusDtoListOld.sort(Comparator.comparing(TimeDiagramStatusDto::getX1, Comparator.naturalOrder()));
|
TimeDiagramStatusDto nextStatusDto = statusDtoListOld.get(0);
|
if (statusDtoListNew.size() == 0) {
|
statusDtoListNew.add(nextStatusDto);
|
} else {
|
TimeDiagramStatusDto currentStatusDto = statusDtoListNew.get(statusDtoListNew.size() - 1);
|
if (nextStatusDto.getStatus() < currentStatusDto.getStatus()) {
|
if (nextStatusDto.getX1() == currentStatusDto.getX1() && nextStatusDto.getX2() == currentStatusDto.getX2()) {
|
currentStatusDto.setStatus(nextStatusDto.getStatus());
|
} else if (nextStatusDto.getX1() == currentStatusDto.getX1() && nextStatusDto.getX2() < currentStatusDto.getX2()) {
|
statusDtoListOld.add(new TimeDiagramStatusDto(nextStatusDto.getX2(), currentStatusDto.getX2(), currentStatusDto.getStatus()));
|
currentStatusDto.setStatus(nextStatusDto.getStatus());
|
currentStatusDto.setX2(nextStatusDto.getX2());
|
} else if (nextStatusDto.getX1() == currentStatusDto.getX1() && nextStatusDto.getX2() > currentStatusDto.getX2()) {
|
currentStatusDto.setStatus(nextStatusDto.getStatus());
|
currentStatusDto.setX2(nextStatusDto.getX2());
|
} else if (nextStatusDto.getX1() > currentStatusDto.getX1() && nextStatusDto.getX2() >= currentStatusDto.getX2()) {
|
currentStatusDto.setX2(nextStatusDto.getX1());
|
statusDtoListNew.add(new TimeDiagramStatusDto(nextStatusDto.getX1(), nextStatusDto.getX2(), nextStatusDto.getStatus()));
|
} else if (nextStatusDto.getX1() > currentStatusDto.getX1() && nextStatusDto.getX2() < currentStatusDto.getX2()) {
|
statusDtoListNew.add(new TimeDiagramStatusDto(nextStatusDto.getX1(), nextStatusDto.getX2(), nextStatusDto.getStatus()));
|
statusDtoListOld.add(new TimeDiagramStatusDto(nextStatusDto.getX2(), currentStatusDto.getX2(), currentStatusDto.getStatus()));
|
currentStatusDto.setX2(nextStatusDto.getX1());
|
}
|
} else {
|
if (nextStatusDto.getX1() >= currentStatusDto.getX2()) {
|
statusDtoListNew.add(new TimeDiagramStatusDto(nextStatusDto.getX1(), nextStatusDto.getX2(), nextStatusDto.getStatus()));
|
} else if (nextStatusDto.getX2() > currentStatusDto.getX2()) {
|
statusDtoListOld.add(new TimeDiagramStatusDto(currentStatusDto.getX2(), nextStatusDto.getX2(), nextStatusDto.getStatus()));
|
}
|
}
|
}
|
statusDtoListOld.remove(0);
|
}
|
timeDiagramDto.setTotalWidth(x2);
|
double pointRate = timeDiagramDto.getTotalWidth() / timeDiagramDto.getSmallWidth();
|
|
List<List<TimeDiagramStatusDto>> lineArray = new ArrayList();
|
lineArray.add(statusDtoList);
|
lineArray.add(statusDtoListNew);
|
|
List<List<TimeDiagramStatusDto>> smallStatusDtoList = new ArrayList<>();
|
for (int j = 0; j < lineArray.size(); j++) {
|
List<TimeDiagramStatusDto> tmpStatusDtoList = new ArrayList<>();
|
int lastStatus = 5;
|
Boolean isFirst = true;
|
x1 = 0;
|
for (double i = 0; i < timeDiagramDto.getSmallWidth(); i = i + timeDiagramDto.getMinPointNum()) {
|
int netStatus = getPointStatus(lineArray.get(j), i * pointRate, (i + timeDiagramDto.getMinPointNum()) * pointRate - 1);
|
if (!isFirst) {
|
if (lastStatus != netStatus) {
|
tmpStatusDtoList.add(new TimeDiagramStatusDto(x1, x2, lastStatus));
|
lastStatus = netStatus;
|
x1 = i;
|
}
|
} else {
|
lastStatus = netStatus;
|
isFirst = false;
|
}
|
x2 = i + timeDiagramDto.getMinPointNum() - 1;
|
}
|
tmpStatusDtoList.add(new TimeDiagramStatusDto(x1, x2, lastStatus));
|
smallStatusDtoList.add(tmpStatusDtoList);
|
}
|
|
JSONObject jsonObject2 = new JSONObject(modelStr2);
|
JSONArray jsonArray2 = jsonObject2.getJSONArray("cells");
|
y = 10;
|
for (int i = 0; i < smallStatusDtoList.size(); i++) {
|
for (TimeDiagramStatusDto status : smallStatusDtoList.get(i)) {
|
JSONObject lineJson = new JSONObject(templetsStrMap2.get(status.getStatus()));
|
setlineXy(lineJson, status.getX1(), y, status.getX2() + 5, y, "");
|
JsonUtils2.setJsonValueByPath(lineJson, "data/status".split("/"), status.getStatus());
|
JsonUtils2.setJsonValueByPath(lineJson, "id".split("/"), UUIDUtil.generateId().toString());
|
jsonArray2.add(lineJson);
|
}
|
y = y + 25;
|
}
|
|
//图例
|
int spaceWitdth = 80;
|
x1 = 0;
|
x2 = spaceWitdth - 11;
|
y = 60;
|
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);
|
jsonArray2.add(f);
|
}
|
timeDiagramDto.setDiagramJson(jsonObject.toString());
|
timeDiagramDto.setSmallDiagramJson(jsonObject2.toString());
|
timeDiagramDto.setTextDiagramJson(jsonObject3.toString());
|
|
return timeDiagramDto;
|
}
|
|
private int getPointStatus(List<TimeDiagramStatusDto> dtoList, double x1, double x2) {
|
int status = 5;
|
boolean findStart = false;
|
for (int i = 0; i < dtoList.size(); i++) {
|
if (x2 <= dtoList.get(i).getX1()) {
|
break;
|
}
|
|
if (!findStart) {
|
if (dtoList.get(i).getX1() >= x1 && x1 <= dtoList.get(i).getX2()) {
|
status = dtoList.get(i).getStatus();
|
findStart = true;
|
}
|
}
|
|
if (dtoList.get(i).getX2() >= x2) {
|
if (dtoList.get(i).getStatus() < status)
|
status = dtoList.get(i).getStatus();
|
}
|
}
|
return status;
|
}
|
|
|
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);
|
JsonUtils2.setJsonValueByPath(lineJson, "id".split("/"), UUIDUtil.generateId().toString());
|
if (text != null) {
|
JsonUtils2.setArrJsonValueByPath(lineJson, "labels".split("/"), null, "0", "attrs/text/text", "");
|
}
|
}
|
|
public String getPetsInfo() {
|
Map<String, Object> params = new HashMap<String, Object>();
|
params.put("projectId", 10000);
|
params.put("diagramId", 10000);
|
String modelStr2 = "";
|
List<TimeDiagram> list_style = baseDao.getTimeDiagram(params);
|
if (list_style.size() > 0) {
|
modelStr2 = list_style.get(0).getContent2();
|
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());
|
templetsStrMap2.put(5, jsonObject.toString());
|
}
|
if ("故障".equals(nodeMarker)) {
|
templetsMap.put("F", jsonObject);
|
templetsStrMap.put("F", jsonObject.toString());
|
templetsStrMap2.put(1, jsonObject.toString());
|
}
|
if ("空闲".equals(nodeMarker)) {
|
templetsMap.put("I", jsonObject);
|
templetsStrMap.put("I", jsonObject.toString());
|
templetsStrMap2.put(3, jsonObject.toString());
|
}
|
if ("备份".equals(nodeMarker)) {
|
templetsMap.put("S", jsonObject);
|
templetsStrMap.put("S", jsonObject.toString());
|
templetsStrMap2.put(2, jsonObject.toString());
|
}
|
if ("未用".equals(nodeMarker)) {
|
templetsMap.put("M", jsonObject);
|
templetsStrMap.put("M", jsonObject.toString());
|
templetsStrMap2.put(4, 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());
|
}
|
}
|
}
|
}
|
return modelStr2;
|
}
|
|
public List<ProductStatusDto> getStatusData(Long productId, Long taskId) {
|
|
List<ProductStatusDto> dbList = this.getProduct(productId, taskId);
|
List<ProductStatusDto> childList = new ArrayList<>();
|
for (ProductStatusDto item : dbList) {
|
if (item.getSameSbNum() > 1) {
|
for (int i = 1; i <= item.getSameSbNum(); i++) {
|
try {
|
ProductStatusDto newRow = item.clone();
|
newRow.setDeviceNo(i);
|
newRow.setName(item.getName() + "-" + i);
|
newRow.setDataId(item.getId().toString() + "-" + i);
|
childList.add(newRow);
|
} catch (CloneNotSupportedException e) {
|
e.printStackTrace();
|
}
|
}
|
} else {
|
item.setDeviceNo(0);
|
item.setDataId(item.getId().toString());
|
childList.add(item);
|
}
|
}
|
childList.sort(Comparator.comparing(ProductStatusDto::getDeviceNo, Comparator.naturalOrder()));
|
for (ProductStatusDto item : childList) {
|
JSONArray jsonArray = dialgramJson.getJSONArray(item.getDataId());
|
if (jsonArray != null) {
|
this.processJSONArray(jsonArray, item, taskId);
|
}
|
}
|
childList.removeIf(item -> item.getStatusList().size() == 0);
|
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);
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public List<TaskModelCheckResultDto> simulateChecK(SimulatAssess simulatAssess) {
|
List<TaskModelCheckResultDto> result = null;
|
// 1. 检查模型完整性
|
List<TaskModelCheckResultDto> chkResult = taskService.checkTaskModel(simulatAssess.getProductId(),
|
simulatAssess.getTaskModelId());
|
if (chkResult.size() > 0) {
|
return chkResult;
|
}
|
return result;
|
}
|
|
public Boolean simulate(SimulatAssess simulatAssess) {
|
Boolean result = false;
|
// 2. 组装供算法库仿真的模型xml
|
assembleModelXml(simulatAssess);
|
|
// 3. 调用算法库，进行仿真计算
|
result = callReliaSimLib(simulatAssess);
|
|
return result;
|
}
|
|
public List<SimulatAssess> process(QueryFilter queryFilter) {
|
List<SimulatAssess> page = baseDao.getProcessList(queryFilter.getParams());
|
return queryFilter.getPageList(page);
|
}
|
|
private Boolean callReliaSimLib(SimulatAssess simulatAssess) {
|
Boolean result = false;
|
InputStream is = null;
|
BufferedReader br = null;
|
try {
|
try {
|
setParamToRedis(simulatAssess);
|
} catch (Exception e) {
|
throw new RenException("访问Redis失败。请检查Redis是否已启动。");
|
}
|
|
Process process = null;
|
String command = "python " + reliaSimMain;
|
command += " -ip " + redisHost + " -port " + redisPort;
|
command += " -taskType " + RELIA_SIM_TASK_TYPE_SIMULATION + " -taskId " + simulatAssess.getId().toString();
|
logger.info("cmd命令为：" + command);
|
if (System.getProperty("os.name").toLowerCase().indexOf("windows") > -1) {
|
process = Runtime.getRuntime().exec(new String[]{"cmd", "/c", command});
|
} else if (System.getProperty("os.name").toLowerCase().indexOf("linux") > -1) {
|
process = Runtime.getRuntime().exec(new String[]{"/bin/sh", "-c", command});
|
} else {
|
throw new RenException("暂不支持该操作系统，进行启动算法库计算！");
|
}
|
long pid = ProcessUtils.getProcessId(process);
|
logger.info("算法库PID：" + pid);
|
is = process.getInputStream();
|
// 以命令行方式调用算法库时，接口约定返回的结果是utf-8编码
|
br = new BufferedReader(new InputStreamReader(is, "utf-8"));
|
String line = br.readLine();
|
logger.info("算法库返回结果：" + line);
|
// int exitCode = process.waitFor(); // 异步方式，不等待算法库计算完毕，所以要注释掉该行
|
if (line != null) {
|
ReliaSimLibResult rtn = com.alibaba.fastjson.JSONObject.parseObject(line, ReliaSimLibResult.class);
|
if ("0".equals(rtn.getCode())) {
|
logger.info("启动可靠性仿真评估算法库成功。");
|
newProcess(simulatAssess, pid, command);
|
update(simulatAssess);
|
result = true;
|
} else {
|
String errorMsg = rtn.getErrorMsg();
|
throw new RenException("启动可靠性仿真评估算法库失败: errorMsg=" + errorMsg);
|
}
|
}
|
} catch (IOException e) {
|
logger.error("启动可靠性仿真评估算法库仿真时发生Exception：", e);
|
e.printStackTrace();
|
throw new RenException("启动可靠性仿真评估算法库失败: errorMsg=" + e.getMessage());
|
} finally {
|
if (is != null) {
|
try {
|
is.close();
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
if (br != null) {
|
try {
|
br.close();
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
|
return result;
|
}
|
|
public void newProcess(SimulatAssess simulatAssess, long pid, String command) {
|
simulatAssess.setPid(pid);
|
simulatAssess.setCommandLine(command);
|
simulatAssess.setProcessIsAlive(true);
|
simulatAssess.setProcessStartTime(new Date());
|
simulatAssess.setProgress(0);
|
}
|
|
private void setParamToRedis(SimulatAssess simulatAssess) {
|
String key = simulatAssess.getId().toString() + RELIA_SIM_TASK_TYPE_SIMULATION;
|
logger.info("redis key：" + key);
|
com.alibaba.fastjson.JSONObject jsonObject = new com.alibaba.fastjson.JSONObject();
|
jsonObject.put("xmlfile", simulatAssess.getXml());
|
// 仿真次数
|
jsonObject.put("simulate_times", simulatAssess.getSimulatFrequency());
|
// 采样周期
|
jsonObject.put("timeslice", simulatAssess.getSamplPeriod() / 60.0); // 单位统一换算为小时
|
jsonObject.put("result_home", resultHome);
|
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);
|
if (simulatAssess.getTaskDuration() != null) {
|
task.setTaskDuration(simulatAssess.getTaskDuration());
|
}
|
List<TaskBinoParam> binoParams = taskBinoParamDao.getBinoParams(taskId);
|
|
// 1. 计算各任务阶段的运行时长
|
List<TaskPhase> taskPhases = calcTaskPhaseDuration(task);
|
// 2. 计算各工况模型的运行时长
|
List<TaskPhaseModel> taskPhaseModelAll = new ArrayList<>();
|
for (TaskPhase taskPhase : taskPhases) {
|
calcTaskPhaseModelDuration(taskPhase, taskPhaseModelAll);
|
}
|
// 3. 将各工况模型递归拆解为完整的可供算法包仿真计算的模型
|
try {
|
List<FailureModel> failureModels = new ArrayList<>();
|
List<RepairModel> repairModels = new ArrayList<>();
|
|
Document document = DocumentHelper.createDocument();
|
// 添加root节点
|
Element root = document.addElement("des");
|
root.addAttribute("name", "General system");
|
addTasksTag(taskPhaseModelAll, root);
|
addModelsTag(simulatAssess,
|
taskId,
|
productId,
|
product.getName(),
|
product.getNamePath(),
|
productList,
|
paramDataList,
|
taskPhaseModelAll,
|
binoParams,
|
root,
|
failureModels, repairModels);
|
addFailureModelsTag(failureModels, root);
|
addRepairModelsTag(repairModels, root);
|
saveSimulatAssessTaskPhaseModel(simulatAssess,
|
task,
|
taskPhases,
|
taskPhaseModelAll);
|
|
// 输出格式化xml
|
XMLWriter xmlWriter = null;
|
try {
|
OutputFormat format = OutputFormat.createPrettyPrint();
|
format.setEncoding("UTF-8");
|
StringWriter writer = new StringWriter();
|
xmlWriter = new XMLWriter(writer, format);
|
xmlWriter.write(document);
|
simulatAssess.setXml(writer.toString());
|
} finally {
|
if (xmlWriter != null) xmlWriter.close();
|
}
|
// XML存盘
|
insert(simulatAssess);
|
} catch (Exception e) {
|
e.printStackTrace();
|
throw new RenException("组装算法库仿真计算用模型XML失败: " + e.getMessage());
|
}
|
}
|
|
private void saveSimulatAssessTaskPhaseModel(SimulatAssess simulatAssess,
|
Task task,
|
List<TaskPhase> taskPhases,
|
List<TaskPhaseModel> taskPhaseModelAll) {
|
int sort = 1;
|
for (TaskPhaseModel tpm : taskPhaseModelAll) {
|
TaskPhase phase = taskPhases.stream().filter(item ->
|
tpm.getPhaseId().equals(item.getId())).collect(Collectors.toList()).get(0);
|
SimulatAssessTaskPhaseModel satpm = new SimulatAssessTaskPhaseModel();
|
satpm.setId(UUIDUtil.generateId());
|
satpm.setFzId(simulatAssess.getId());
|
satpm.setTaskId(task.getId());
|
satpm.setTaskName(task.getTaskName());
|
satpm.setTaskDuration(task.getTaskDuration());
|
satpm.setPhaseId(tpm.getPhaseId());
|
satpm.setPhaseName(phase.getPhaseName());
|
satpm.setPhaseDurationRate(phase.getPhaseDurationRate());
|
satpm.setPhaseDuration(phase.getPhaseDuration());
|
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());
|
satpm.setGkDuration(tpm.getOperatConditDuration());
|
satpm.setSort(sort++);
|
simulatAssessTaskPhaseModelService.insert(satpm);
|
}
|
}
|
|
public void addTasksTag(List<TaskPhaseModel> taskPhaseModelAll,
|
Element root) {
|
Element tasksTag = root.addElement("tasks");
|
for (TaskPhaseModel taskPhaseModel : taskPhaseModelAll) {
|
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(",")));
|
}
|
}
|
}
|
|
private void addFailureModelsTag(List<FailureModel> failureModels,
|
Element root) {
|
Element ele = null;
|
Element failureModelsTag = root.addElement("failure_models");
|
for (FailureModel failureModel : failureModels) {
|
Element failureModelTag = failureModelsTag.addElement("failure_model");
|
failureModelTag.addAttribute("name", failureModel.getId().toString());
|
failureModelTag.addAttribute("type", failureModel.getType());
|
switch (failureModel.getType()) {
|
case FailureModel.TYPE_EXP:
|
ele = failureModelTag.addElement("failure-rate");
|
ele.addAttribute("value", String.valueOf(failureModel.getParam1()));
|
break;
|
case FailureModel.TYPE_BIN:
|
ele = failureModelTag.addElement("reliability");
|
ele.addAttribute("value", String.valueOf(failureModel.getParam1()));
|
ele = failureModelTag.addElement("n");
|
ele.addAttribute("value", String.valueOf(failureModel.getParam2()));
|
ele = failureModelTag.addElement("k");
|
ele.addAttribute("value", String.valueOf(failureModel.getParam3()));
|
break;
|
case FailureModel.TYPE_WBL:
|
ele = failureModelTag.addElement("scale");
|
ele.addAttribute("value", String.valueOf(failureModel.getParam2()));
|
ele = failureModelTag.addElement("shape");
|
ele.addAttribute("value", String.valueOf(failureModel.getParam3()));
|
break;
|
case FailureModel.TYPE_FIX:
|
ele = failureModelTag.addElement("reliability");
|
ele.addAttribute("value", String.valueOf(failureModel.getParam1()));
|
break;
|
default:
|
break;
|
}
|
}
|
}
|
|
private void addRepairModelsTag(List<RepairModel> repairModels,
|
Element root) {
|
Element ele = null;
|
Element repairModelsTag = root.addElement("repair_models");
|
for (RepairModel repairModel : repairModels) {
|
Element repairModelTag = repairModelsTag.addElement("repair_model");
|
repairModelTag.addAttribute("name", repairModel.getId().toString());
|
repairModelTag.addAttribute("type", repairModel.getType());
|
switch (repairModel.getType()) {
|
case RepairModel.TYPE_EXP:
|
ele = repairModelTag.addElement("repair-rate");
|
ele.addAttribute("value", String.valueOf(repairModel.getParam1()));
|
break;
|
case RepairModel.TYPE_WBL:
|
ele = repairModelTag.addElement("scale");
|
ele.addAttribute("value", String.valueOf(repairModel.getParam2()));
|
ele = repairModelTag.addElement("shape");
|
ele.addAttribute("value", String.valueOf(repairModel.getParam3()));
|
break;
|
case RepairModel.TYPE_DIRAC:
|
ele = repairModelTag.addElement("repair-time");
|
ele.addAttribute("value", String.valueOf(repairModel.getParam1()));
|
break;
|
default:
|
break;
|
}
|
}
|
}
|
|
public void calcTaskPhaseModelDuration(TaskPhase taskPhase,
|
List<TaskPhaseModel> taskPhaseModelAll) {
|
List<TaskPhaseModel> taskPhaseModels = taskPhaseModelDao.getListByPhaseId(taskPhase.getId());
|
double totalRate = taskPhaseModels.stream().mapToDouble(TaskPhaseModel::getOperatConditDurationRate).sum();
|
double sum = 0.0;
|
for (TaskPhaseModel taskPhaseModel : taskPhaseModels) {
|
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);
|
}
|
// 把零头补到最后一个工况模型
|
double duration = taskPhaseModels.get(taskPhaseModels.size() - 1).getOperatConditDuration();
|
taskPhaseModels.get(taskPhaseModels.size() - 1).setOperatConditDuration(duration + taskPhase.getPhaseDuration() - sum);
|
}
|
|
public List<TaskPhase> calcTaskPhaseDuration(Task task) {
|
List<TaskPhase> taskPhases = taskPhaseDao.getListByTaskId(task.getId());
|
double totalRate = taskPhases.stream().mapToDouble(TaskPhase::getPhaseDurationRate).sum();
|
double sum = 0.0;
|
for (TaskPhase taskPhase : taskPhases) {
|
double duration = task.getTaskDuration() * taskPhase.getPhaseDurationRate() / totalRate;
|
taskPhase.setPhaseDuration(duration);
|
sum += duration;
|
}
|
// 把零头补到最后一个阶段
|
double duration = taskPhases.get(taskPhases.size() - 1).getPhaseDuration();
|
taskPhases.get(taskPhases.size() - 1).setPhaseDuration(duration + task.getTaskDuration() - sum);
|
|
return taskPhases;
|
}
|
|
private void addModelsTag(SimulatAssess simulatAssess,
|
Long taskId,
|
Long productId,
|
String productName,
|
String productNamePath,
|
List<XhProductModel> productList,
|
List<ParamData> paramDataList,
|
List<TaskPhaseModel> taskPhaseModelAll,
|
List<TaskBinoParam> binoParams,
|
Element root,
|
List<FailureModel> failureModels,
|
List<RepairModel> repairModels) {
|
Element modelsTag = root.addElement("models");
|
for (TaskPhaseModel taskPhaseModel : taskPhaseModelAll) {
|
Element modelTag = modelsTag.addElement("model");
|
modelTag.addAttribute("name", taskPhaseModel.getOperatConditId().toString());
|
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());
|
// 将模型转换为DOM，添加到model标签
|
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);
|
node2DOM(simulatAssess,
|
taskId,
|
taskPhaseModel,
|
gkModelTop.getModelId(),
|
productId,
|
productName,
|
productNamePath,
|
productList,
|
paramDataList,
|
gkModelsAssembled,
|
algorithmList,
|
modelNodeAndVnodeList,
|
binoParams,
|
computerNode, modelTag,
|
failureModels, repairModels);
|
}
|
}
|
|
// 递归函数
|
private void node2DOM(SimulatAssess simulatAssess,
|
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,
|
ModelNode node,
|
Element parent,
|
List<FailureModel> failureModels,
|
List<RepairModel> repairModels) {
|
if ("node".equals(node.getNodeType())) {
|
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);
|
node2DOM(simulatAssess,
|
taskId,
|
taskPhaseModel,
|
gkModel.getModelId(),
|
product.getId(),
|
product.getName(),
|
product.getNamePath(),
|
productList,
|
paramDataList,
|
gkModelsAssembled,
|
algorithmListSub,
|
modelNodeAndVnodeListSub,
|
binoParams,
|
computerNode, parent,
|
failureModels, repairModels);
|
} else if ("5".equals(product.getProductType())) {
|
// 设备
|
Integer deviceNo = node.getDeviceNo();
|
Element nodeTag = parent.addElement("node");
|
nodeTag.addAttribute("name", deviceNo == 0 ? dataId.toString() : dataId.toString() + "-" + deviceNo);
|
nodeTag.addAttribute("real_name", deviceNo == 0 ? product.getName() : product.getName() + "-" + deviceNo);
|
nodeTag.addAttribute("name_path", product.getNamePath());
|
nodeTag.addAttribute("type", "node");
|
|
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 = null;
|
if (isRepairDirac(simulatAssess.getRepairDiracFlag(), taskPhaseModel, product.getId())) {
|
repairModel = createRepairModelDirac(0);
|
} else {
|
repairModel = createRepairModel(paramData);
|
}
|
repairModels.add(repairModel);
|
Element repairTag = nodeTag.addElement("repair_model");
|
repairTag.addAttribute("name", repairModel.getId().toString());
|
}
|
}
|
} else {
|
// vnode（运算节点）
|
Algorithm algo = algorithmList.stream().filter(item ->
|
node.getId().equals(item.getId())).collect(Collectors.toList()).get(0);
|
Element element = parent.addElement("logic");
|
if (null == productId) {
|
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");
|
} else if ("parallel".equals(algo.getAlgorithmType())) {
|
element.addAttribute("type", "parallel");
|
} else if ("vote".equals(algo.getAlgorithmType())) {
|
element.addAttribute("type", "vote");
|
element.addAttribute("k", algo.getVoteNum().toString());
|
} else if ("switch".equals(algo.getAlgorithmType())) {
|
element.addAttribute("type", "standby");
|
element.addAttribute("k", algo.getVoteNum().toString());
|
} else if ("bridge".equals(algo.getAlgorithmType())) {
|
element.addAttribute("type", "bridge");
|
}
|
String[] computerNodeListStr = algo.getComputerList().split(",");
|
for (String nodeStr : computerNodeListStr) {
|
ModelNode mn = modelNodeAndVnodeList.stream().filter(item ->
|
nodeStr.equals(item.getId().toString())).collect(Collectors.toList()).get(0);
|
node2DOM(simulatAssess,
|
taskId,
|
taskPhaseModel,
|
modelId,
|
null,
|
null,
|
null,
|
productList,
|
paramDataList,
|
gkModelsAssembled,
|
algorithmList,
|
modelNodeAndVnodeList,
|
binoParams,
|
mn, element,
|
failureModels, repairModels);
|
}
|
}
|
}
|
|
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:
|
// 二项分布
|
if ((taskBinoParam.getSimulatTimes() == null && taskBinoParam.getSuccessTimes() == null) ||
|
(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;
|
}
|
|
return failureModel;
|
}
|
|
private boolean isRepairDirac(Boolean repairDiracFlag, TaskPhaseModel taskPhaseModel, Long productId) {
|
boolean result = false;
|
|
if (repairDiracFlag != null && repairDiracFlag) {
|
if (taskPhaseModel.getPhaseConstraints() == null) {
|
result = true;
|
} else {
|
List<TaskPhaseConstraintDto> list = taskPhaseModel.getPhaseConstraints().stream().filter(item ->
|
productId.equals(item.getProductId())).collect(Collectors.toList());
|
if (list.size() == 0) {
|
result = true;
|
}
|
}
|
}
|
|
return result;
|
}
|
|
private RepairModel createRepairModelDirac(double time) {
|
RepairModel repairModel = new RepairModel();
|
repairModel.setId(UUIDUtil.generateId());
|
repairModel.setType(RepairModel.TYPE_DIRAC);
|
repairModel.setParam1(0);
|
return repairModel;
|
}
|
|
private RepairModel createRepairModel(ParamData paramData) {
|
RepairModel repairModel = new RepairModel();
|
repairModel.setId(UUIDUtil.generateId());
|
switch (paramData.getRepairDistribType()) {
|
case 1:
|
// 指数分布
|
repairModel.setType(RepairModel.TYPE_EXP);
|
repairModel.setParam1(1.0 / paramData.getRepairMttcr());
|
break;
|
case 2:
|
// 威布尔分布
|
repairModel.setType(RepairModel.TYPE_WBL);
|
repairModel.setParam2(paramData.getRepairMttcrOtherParams2());
|
repairModel.setParam3(paramData.getRepairMttcrOtherParams3());
|
break;
|
default:
|
break;
|
}
|
|
return repairModel;
|
}
|
|
public List<WeakDto> getReliabilityWeakness(Long fzId, Long taskId, Long productId) {
|
String filePath = path + "/" + fzId + "/" + "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();
|
}
|
|
}
|
|
Map<Long, WeakDto> map = new HashMap<>();
|
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;
|
String nameValue = jsonArray.getJSONObject(i).get("name").toString();
|
if (StringUtils.isNotBlank(nameValue)) {
|
productId1 = Convert.toLong(nameValue.split("-")[0]);
|
|
Double mtbf = (Double) jsonArray.getJSONObject(i).get("mttf");
|
Double mttr = (Double) jsonArray.getJSONObject(i).get("mttr");
|
Double msr = (Double) jsonArray.getJSONObject(i).get("msr");
|
WeakDto weakDto = new WeakDto();
|
weakDto.setId(productId1);
|
weakDto.setMtbf(mtbf);
|
weakDto.setMttr(mttr);
|
weakDto.setMsr(msr);
|
if (map.get(productId1) == null) {
|
map.put(productId1, weakDto);
|
} else {
|
if (weakDto.getMsr() < map.get(productId1).getMsr()) {
|
map.put(productId1, weakDto);
|
}
|
}
|
}
|
}
|
List<WeakDto> productList = baseDao.getProductList(taskId, productId);
|
for (WeakDto item : productList) {
|
WeakDto dto = map.get(item.getId());
|
item.setMtbf(dto.getMtbf());
|
item.setMttr(dto.getMttr());
|
item.setMsr(dto.getMsr());
|
item.setMtbfTime(dto.getMtbf() / item.getTimeRate());
|
item.setIsWeak(0);
|
}
|
|
List<WeakDto> treeList = new ArrayList<>();
|
if (productList.size() > 0) {
|
treeList = TreeUtils.build(productList);
|
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 SimulatResult SchemeCompar(String[] taskList, Long showProductId, Integer samplPeriod, Integer simulatFrequency) {
|
SimulatResult simulatResult = new SimulatResult();
|
List<Long> idList = new ArrayList<>();
|
List<TaskModelCheckResultDto> result = null;
|
/* SchemeComparDto dto = new SchemeComparDto();
|
List<SimulaDataDto> dataDtoList = new ArrayList<>();
|
List<SchemeComparCurve> curveList = new ArrayList<>();
|
List<Double> xData = new ArrayList<>();
|
|
SimulaDataDto data;*/
|
|
List<SimulatAssess> simulatAssessList = new ArrayList<>();
|
|
Task task;
|
double maxTaskDuration = 0.0;
|
for (String taskId : taskList) {
|
task = taskService.get(Long.parseLong(taskId));
|
if (task.getTaskDuration() > maxTaskDuration) {
|
maxTaskDuration = task.getTaskDuration();
|
}
|
|
SimulatAssess simulatAssess = new SimulatAssess();
|
Long id = UUIDUtil.generateId();
|
simulatAssess.setId(id);
|
simulatAssess.setName("");
|
simulatAssess.setProductId(showProductId);
|
simulatAssess.setSamplPeriod(samplPeriod);
|
simulatAssess.setSimulatFrequency(simulatFrequency);
|
simulatAssess.setTaskDuration(maxTaskDuration);
|
simulatAssess.setTaskModelId(Long.parseLong(taskId));
|
|
simulatAssessList.add(simulatAssess);
|
result = simulateChecK(simulatAssess);
|
if (result != null) {
|
simulatResult.setType("errorList");
|
simulatResult.setErrList(result);
|
return simulatResult;
|
}
|
idList.add(id);
|
}
|
|
for (SimulatAssess simulatAssess : simulatAssessList) {
|
simulatAssess.setTaskDuration(maxTaskDuration);
|
this.simulate(simulatAssess);
|
}
|
|
simulatResult.setType("idList");
|
simulatResult.setIdList(idList);
|
return simulatResult;
|
}
|
|
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().toString());
|
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++) {
|
String nameValue = jsonArray.getJSONObject(i).get("name").toString();
|
if (nameValue.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;
|
}
|
|
public String verify(Long taskId) {
|
StringBuilder result = new StringBuilder();
|
Task task = taskService.get(taskId);
|
double taskTime = task.getTaskDuration();
|
List<OperatConditModel> list = baseDao.getModel(taskId);
|
List<Double> reliabiyList = new ArrayList<>();
|
String modelStr2 = "";
|
for (OperatConditModel model : list) {
|
if (model.getProductId().equals(task.getProductId())) {
|
modelStr2 = model.getContent();
|
continue;
|
}
|
List<verifyDto> listNodes = baseDao.getNode(model.getModelId());
|
for (verifyDto node : listNodes) {
|
//lmd,reliabiy,failRate
|
double lmd = 1 / node.getMtbf();
|
double reliabiy = Math.exp(-1 * lmd * taskTime);
|
double failRate = 1 - reliabiy;
|
node.setLmd(lmd);
|
node.setReliabiy(reliabiy);
|
node.setFailRate(failRate);
|
}
|
int total = listNodes.size();
|
String modelStr = model.getContent();
|
//找到表决数量
|
|
if (modelStr.contains("switch")) {
|
double a = 0;
|
double lmd = listNodes.get(0).getLmd();
|
result.append("\n").append(total).append("个相同设备旁联,3选1,MTTBCF是").append(listNodes.get(0).getMtbf()).append("\n");
|
for (int i = 0; i <= total - 1; i++) {
|
double ijc = getjc(i);
|
double b = Math.pow(taskTime * lmd, i) * Math.exp(-1 * lmd * taskTime) / ijc;
|
a = a + b;
|
result.append("有").append(i + 1).append("个设备好的的概率为").append(b).append("\n");
|
}
|
result.append("整个旁联系统的可靠度为").append(new Formatter().format("%.4f", a)).append("\n");
|
reliabiyList.add(a);
|
} else if (modelStr.contains("parallel")) {
|
double a = 1;
|
result.append("\n并联设备有").append(total).append("个\n");
|
for (int i = 0; i < listNodes.size(); i++) {
|
a = a * listNodes.get(i).getFailRate();
|
result.append("第").append(i + 1).append("个设备的MTBCF为").append(listNodes.get(i).getMtbf()).append(",").append(i + 1).append("个设备并联的失效率为").append(a).append("\n");
|
}
|
double reliabiy = 1 - a;
|
result.append("整个并联系统的失效率为").append(a).append("整个并联系统的可靠度为").append(new Formatter().format("%.4f", reliabiy)).append("\n");
|
reliabiyList.add(reliabiy);
|
} else if (modelStr.contains("vote")) {
|
Integer voteNum = baseDao.getVoteNum(model.getModelId());
|
if (voteNum != null) {
|
result.append("\n").append(total).append("个相同设备表决,MTBCF为").append(listNodes.get(0).getMtbf()).append("表决数量为").append(voteNum).append("个\n");
|
double a = 0;
|
double zjc = getjc(total);
|
double reliabiy = listNodes.get(0).getReliabiy();
|
for (int i = voteNum; i <= total; i++) {
|
double ijc = getjc(i);
|
double nijc = getjc(total - i);
|
double b = (zjc / (ijc * nijc)) * Math.pow(reliabiy, i) * Math.pow(1 - reliabiy, total - i);
|
a = a + b;
|
result.append("有").append(i).append("个设备是好的概率为").append(b).append("\n");
|
}
|
result.append("整个表决系统的可靠度为").append(new Formatter().format("%.4f", a)).append("\n");
|
reliabiyList.add(a);
|
}
|
|
}
|
}
|
double totalReliabiy = 1;
|
if (modelStr2.contains("parallel")) {
|
for (Double reliabiy : reliabiyList) {
|
totalReliabiy = totalReliabiy * (1 - reliabiy);
|
}
|
totalReliabiy = 1 - totalReliabiy;
|
} else {
|
for (Double reliabiy : reliabiyList) {
|
totalReliabiy = totalReliabiy * reliabiy;
|
}
|
}
|
result.append("\n整个总体系统的可靠度为").append(totalReliabiy).append("\n");
|
return String.valueOf(result);
|
}
|
|
Double getjc(int a) {
|
double result = 1.0;
|
for (int i = a; i > 0; i--)
|
result = result * i;
|
return result;
|
}
|
|
public SchemeComparDto getEcharts(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);
|
simulatAssess.setDataType("fz");
|
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;
|
}
|
}
|
