diff --git a/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/NameStandUtil.java b/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/NameStandUtil.java index 9ef9dbaa..a3edb8d8 100644 --- a/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/NameStandUtil.java +++ b/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/NameStandUtil.java @@ -1,5 +1,6 @@ package org.jeecg.common.util; +import cn.hutool.core.util.StrUtil; import com.baomidou.mybatisplus.core.toolkit.StringPool; import org.jeecg.common.properties.SpectrumPathProperties; import org.jeecg.modules.base.enums.DataType; @@ -34,6 +35,8 @@ public class NameStandUtil { path = pathMap.getOrDefault(SystemType.PARTICULATE.getType(), "Spectrum/Particulates"); } else if(systemType.contains(SystemType.WATER.getType())) { path = pathMap.getOrDefault(SystemType.WATER.getType(), "Spectrum/Water"); + } else if (systemType.contains(SystemType.SELFSTATION.getType())) { + path = pathMap.getOrDefault(SystemType.SELFSTATION.getType(), "Spectrum/Xenon/Self"); } return path; } @@ -84,14 +87,15 @@ public class NameStandUtil { public Map NameStandard(String dataType, String spectrumQuantity, Double acqusitionLiveTime, String sampleFileName, String measurementId) { String suffix = GetSuffix(dataType, spectrumQuantity,String.valueOf(acqusitionLiveTime)); - Map fileNames = NameStandardByName(sampleFileName, measurementId,suffix); - return fileNames; + return NameStandardByName(sampleFileName, measurementId,suffix); } public Map NameStandard(PHDFile fileAnlyse) { - String suffix = GetSuffix(fileAnlyse.getMsgInfo().getData_type(), fileAnlyse.getHeader().getSpectrum_quantity(),String.valueOf(fileAnlyse.getAcq().getAcquisition_live_time())); - Map fileNames = NameStandardByName(fileAnlyse.getFilename(), fileAnlyse.getHeader().getMeasurement_id(),suffix); - return fileNames; + String suffix = GetSuffix(fileAnlyse.getMsgInfo().getData_type(), + fileAnlyse.getHeader().getSpectrum_quantity(), + String.valueOf(fileAnlyse.getAcq().getAcquisition_live_time()), + fileAnlyse.getRoiSuffix()); + return NameStandardByName(fileAnlyse.getFilename(), fileAnlyse.getHeader().getMeasurement_id(),suffix); } public String GetSuffix(String dataType, String Fulltype, String LT) { @@ -117,6 +121,33 @@ public class NameStandUtil { return rData; } + public String GetSuffix(String dataType, String Fulltype, String LT, String roiSuffix) { + String rData = ""; + DecimalFormat df = new DecimalFormat("#.##########"); + //AUX09_003-20151226_1855 _S_FULL_40184.8.PHD + //将acquisition_live_time保留六位有效数字 如果保留一位小数后小数点后的值是0则四舍五入保留整数，否则按正常条件四舍五入保留小数位 + String numberCal = NumberFormatUtil.numberCal(LT); + numberCal = df.format(Double.valueOf(numberCal)); + // 谱类型增加 SPHDF 和 SPHDP + if(dataType.contains(DataType.SAMPLEPHD.getType()) || + dataType.contains(DataType.SPHDF.getType()) || + dataType.contains(DataType.SPHDP.getType())) { + + rData = StrUtil.isBlank(roiSuffix) ? "_S_"+Fulltype+"_"+numberCal+".PHD" + : "_S_"+Fulltype+"_"+numberCal+roiSuffix+".PHD"; + } else if(dataType.contains(DataType.GASBKPHD.getType())) { + rData = StrUtil.isBlank(roiSuffix) ? "_G_"+Fulltype+"_"+numberCal+".PHD" + : "_G_"+Fulltype+"_"+numberCal+roiSuffix+".PHD"; + } else if(dataType.contains(DataType.DETBKPHD.getType())) { + rData = StrUtil.isBlank(roiSuffix) ? "_D_"+Fulltype+"_"+numberCal+".PHD" + : "_D_"+Fulltype+"_"+numberCal+roiSuffix+".PHD"; + } else if(dataType.contains(DataType.QCPHD.getType())) { + rData = StrUtil.isBlank(roiSuffix) ? "_Q_"+Fulltype+"_"+numberCal+".PHD" + : "_Q_"+Fulltype+"_"+numberCal+roiSuffix+".PHD"; + } + return rData; + } + public Map NameStandardByName(String fileName, String dateTimeFormat, String suffix) { Map map = new HashMap<>(); String StandardFileName=""; diff --git a/jeecg-boot-base-core/src/main/java/org/jeecg/modules/entity/vo/PHDFile.java b/jeecg-boot-base-core/src/main/java/org/jeecg/modules/entity/vo/PHDFile.java index bb637270..02316e98 100644 --- a/jeecg-boot-base-core/src/main/java/org/jeecg/modules/entity/vo/PHDFile.java +++ b/jeecg-boot-base-core/src/main/java/org/jeecg/modules/entity/vo/PHDFile.java @@ -181,6 +181,8 @@ public class PHDFile implements Serializable { private Map phdNuclideMap; + private String roiSuffix; + public PHDFile() { userId = ""; xmlFilePath = ""; diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/exception/CAnalyseException.java b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/exception/CAnalyseException.java new file mode 100644 index 00000000..d0ad8190 --- /dev/null +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/exception/CAnalyseException.java @@ -0,0 +1,24 @@ +package org.jeecg.modules.exception; + +/** + * C谱分析异常 + */ +public class CAnalyseException extends AnalyseException{ + + /** + * Constructs a new exception with the specified detail message. The + * cause is not initialized, and may subsequently be initialized by + * a call to {@link #initCause}. + * + * @param message the detail message. The detail message is saved for + * later retrieval by the {@link #getMessage()} method. + */ + public CAnalyseException(String message) { + super(message); + } + + public CAnalyseException(String message, boolean isDuplicateKeyException) { + super(message,isDuplicateKeyException); + } + +} diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/spectrum/Sample_C_Analysis.java b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/spectrum/Sample_C_Analysis.java new file mode 100644 index 00000000..1bae27d2 --- /dev/null +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/spectrum/Sample_C_Analysis.java @@ -0,0 +1,1363 @@ +package org.jeecg.modules.spectrum; + +import cn.hutool.core.bean.BeanUtil; +import cn.hutool.core.collection.CollUtil; +import cn.hutool.core.date.DateUtil; +import cn.hutool.core.map.MapUtil; +import cn.hutool.core.util.NumberUtil; +import cn.hutool.core.util.StrUtil; +import com.baomidou.mybatisplus.core.toolkit.CollectionUtils; +import com.baomidou.mybatisplus.core.toolkit.StringPool; +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import lombok.Data; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; +import org.jeecg.common.constant.*; +import org.jeecg.common.constant.enums.SpectrumSystemType; +import org.jeecg.common.properties.ParameterProperties; +import org.jeecg.common.properties.SpectrumPathProperties; +import org.jeecg.common.util.*; +import org.jeecg.modules.base.bizVo.AttributeItemVo; +import org.jeecg.modules.base.dto.*; +import org.jeecg.modules.base.entity.original.GardsSampleData; +import org.jeecg.modules.base.entity.rnauto.*; +import org.jeecg.modules.base.enums.DSType; +import org.jeecg.modules.base.enums.MiddleDataType; +import org.jeecg.modules.base.enums.SpectrumType; +import org.jeecg.modules.config.datasource.DataSourceSwitcher; +import org.jeecg.modules.entity.vo.*; +import org.jeecg.modules.exception.AnalySpectrumException; +import org.jeecg.modules.exception.CAnalyseException; +import org.jeecg.modules.exception.GAnalyseException; +import org.jeecg.modules.file.FileOperation; +import org.jeecg.modules.native_jni.EnergySpectrumHandler; +import org.jeecg.modules.native_jni.struct.BgBoundary; +import org.jeecg.modules.native_jni.struct.CalcBgBoundaryParam; +import org.jeecg.modules.native_jni.struct.EnergySpectrumStruct; +import org.jeecgframework.core.util.ApplicationContextUtil; +import org.springframework.dao.DuplicateKeyException; +import org.springframework.transaction.TransactionStatus; +import org.w3c.dom.*; +import org.xml.sax.SAXException; + +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.ParserConfigurationException; +import java.io.File; +import java.io.IOException; +import java.lang.reflect.Field; +import java.text.ParseException; +import java.time.Instant; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.util.*; + + +@Data +@Slf4j +public class Sample_C_Analysis { + + private final Map fieldMap = fieldMap(); + + private AbstractS_D_Q_G_SpectrumHandler spectrumHandler; + + // Sample谱原始数据 + private GardsSampleData sampleData; + + // 分析所需Service + private SpectrumServiceQuotes serviceQuotes; + + // Sample谱结构体数据 + private EnergySpectrumStruct sampleStruct; + + // 能谱文件存储路径属性 + private SpectrumPathProperties spectrumPathProperties; + + private ParameterProperties parameterProperties; + + private RedisUtil redisUtil; + + private FTPUtil ftpUtil; + + /** + * 系统类型 + */ + private String systemType; + + /** + * 数据类型 + */ + private String dataType; + + /** + * 样品谱地址 + */ + private String sampleInputFilename; + + /** + * 样品谱名称 + */ + private String sampleFilename; + + private String sampleFilePath; + + /** + * 日志文件路径 + */ + private String logFilePath; + /** + * 日志文件名称 + */ + private String logFileName; + /** + * 报告文件路径 + */ + private String arrFilePath; + /** + * 报告文件名称 + */ + private String arrFileName; + + /* + * 自建台站谱解析所需的四个Gamms谱对象 + * */ + private PHDFile phdFile1; + private PHDFile phdFile2; + private PHDFile phdFile3; + private PHDFile phdFile4; + + public Sample_C_Analysis(AbstractS_D_Q_G_SpectrumHandler spectrumHandler, EnergySpectrumStruct sampleStruct, SpectrumServiceQuotes serviceQuotes, + GardsSampleData sampleData) { + this.spectrumHandler = spectrumHandler; + this.sampleData = sampleData; + this.serviceQuotes = serviceQuotes; + this.sampleStruct = sampleStruct; + this.systemType = sampleStruct.system_type; + this.dataType = sampleStruct.data_type; + this.sampleInputFilename = sampleData.getInputFileName(); + this.sampleFilename = StringUtils.substring(sampleData.getInputFileName(), + sampleData.getInputFileName().lastIndexOf((StringConstant.SLASH))+1); + } + + public void analysis() throws CAnalyseException, AnalySpectrumException{ + log.info("SelfStaion自动处理分析--Start"); + try { + //获取PHD文件的路径以及文件名称信息 + String sampleFilePathName = spectrumHandler.spectrumFile.getAbsolutePath().replace("\\", StringPool.SLASH); + this.sampleFilePath = sampleFilePathName.substring(0, sampleFilePathName.lastIndexOf(StringPool.SLASH)); + + /* 使用自建台站谱生成4个Gamma谱 */ + this.create4PHD(); + + /* 准备Gamma分析需要的数据 */ + Integer sampleId = sampleData.getSampleId(); + // 获取配置文件 + GammaFileUtil gammaFileUtil = ApplicationContextUtil.getContext().getBean(GammaFileUtil.class); + parameterProperties = ApplicationContextUtil.getContext().getBean(ParameterProperties.class); + phdFile1.setXmlFilePath(parameterProperties.getFilePath()); + phdFile2.setXmlFilePath(parameterProperties.getFilePath()); + phdFile3.setXmlFilePath(parameterProperties.getFilePath()); + phdFile4.setXmlFilePath(parameterProperties.getFilePath()); + + // 获取数据库 Gamma 默认参数 + getSettingFromDB(phdFile1, phdFile2, phdFile3, phdFile4); + + // 文件路径 + GStoreMiddleProcessData middleData1 = new GStoreMiddleProcessData(); + GStoreMiddleProcessData middleData2 = new GStoreMiddleProcessData(); + GStoreMiddleProcessData middleData3 = new GStoreMiddleProcessData(); + GStoreMiddleProcessData middleData4 = new GStoreMiddleProcessData(); + middleData1.setAnalyses_save_filePath(this.sampleInputFilename); + middleData2.setAnalyses_save_filePath(this.sampleInputFilename); + middleData3.setAnalyses_save_filePath(this.sampleInputFilename); + middleData4.setAnalyses_save_filePath(this.sampleInputFilename); + + // 读取文件内容并附值 + this.setPHDFile(phdFile1, phdFile2, phdFile3, phdFile4); + + phdFile1.getSetting().setRefTime_act(DateUtils.parseDate(phdFile1.getAcq().getAcquisition_start_date()+" "+phdFile1.getAcq().getAcquisition_start_time())); + phdFile2.getSetting().setRefTime_act(DateUtils.parseDate(phdFile2.getAcq().getAcquisition_start_date()+" "+phdFile2.getAcq().getAcquisition_start_time())); + phdFile3.getSetting().setRefTime_act(DateUtils.parseDate(phdFile3.getAcq().getAcquisition_start_date()+" "+phdFile3.getAcq().getAcquisition_start_time())); + phdFile4.getSetting().setRefTime_act(DateUtils.parseDate(phdFile4.getAcq().getAcquisition_start_date()+" "+phdFile4.getAcq().getAcquisition_start_time())); + phdFile1.getSetting().setRefTime_conc(DateUtils.parseDate(phdFile1.getCollect().getCollection_start_date()+" "+phdFile1.getCollect().getCollection_start_time())); + phdFile2.getSetting().setRefTime_conc(DateUtils.parseDate(phdFile2.getCollect().getCollection_start_date()+" "+phdFile2.getCollect().getCollection_start_time())); + phdFile3.getSetting().setRefTime_conc(DateUtils.parseDate(phdFile3.getCollect().getCollection_start_date()+" "+phdFile3.getCollect().getCollection_start_time())); + phdFile4.getSetting().setRefTime_conc(DateUtils.parseDate(phdFile4.getCollect().getCollection_start_date()+" "+phdFile4.getCollect().getCollection_start_time())); + + // 根据能谱的系统类型传入不同的核素参数 + Map nuclideLibs = this.getNuclideLinesG(); + + //读取参数内容 + readMDCParameter(phdFile1); + readMDCParameter(phdFile2); + readMDCParameter(phdFile3); + readMDCParameter(phdFile4); + + // 执行分析业务代码 + boolean analyFlag1 = gammaFileUtil.GetMiddleData(phdFile1, CommonConstant.REPORT_PREFIX_AUTO, nuclideLibs, middleData1, MiddleDataType.Auto.getType(), ""); + boolean analyFlag2 = gammaFileUtil.GetMiddleData(phdFile2, CommonConstant.REPORT_PREFIX_AUTO, nuclideLibs, middleData2, MiddleDataType.Auto.getType(), ""); + boolean analyFlag3 = gammaFileUtil.GetMiddleData(phdFile3, CommonConstant.REPORT_PREFIX_AUTO, nuclideLibs, middleData3, MiddleDataType.Auto.getType(), ""); + boolean analyFlag4 = gammaFileUtil.GetMiddleData(phdFile4, CommonConstant.REPORT_PREFIX_AUTO, nuclideLibs, middleData4, MiddleDataType.Auto.getType(), ""); + /*if (analyFlag) { + // 数据插入数据库 + this.storageDataToDatabase(phdFile, middleData, phdFile.getQcItems()); + + // 生成日志文件 + writeLog(middleData.getAnalyses_LogPath(), middleData); + + // 生成报告文件 + spectrumPathProperties = SpringContextUtils.getBean(SpectrumPathProperties.class); + String reportContent = gammaFileUtil.GetReportContent(middleData); + String reportPath = StringUtils.substringBeforeLast(middleData.getAnalyses_ReportPath(), StringPool.SLASH); + String reportName = StringUtils.substringAfterLast(middleData.getAnalyses_ReportPath(), StringPool.SLASH) + ".txt"; + String savePath = spectrumPathProperties.getRootPath() + spectrumPathProperties.getSaveFilePath() + File.separator + reportPath + + File.separator + reportName; + // 保存文件 + FileOperation.saveOrAppendFile(savePath, reportContent, false); + //发送数据到redis + middleData.setSample_id(String.valueOf(sampleId)); + pushToRedis(middleData); + } else { + ErrorLogManager.getInstance().write(new SpectrumErrorEvent(new Date(), phdFile.getAnalyMessage(), this.sampleFilename)); + throw new AnalySpectrumException(phdFile.getAnalyMessage()); + }*/ + } catch (Exception e){ + e.printStackTrace(); + log.error("Sample_C_Analysis", e); + if (e instanceof DuplicateKeyException) { + throw new CAnalyseException("Sample Analyse Error at "+DateUtils.formatDate(new Date(),"yyyy-MM-dd HH:mm:ss"), true); + } else if (e instanceof AnalySpectrumException) { + throw new AnalySpectrumException(e.getMessage()); + } else { + throw new CAnalyseException("Sample Analyse Error at "+DateUtils.formatDate(new Date(),"yyyy-MM-dd HH:mm:ss")); + } + } + log.info("SelfStaion自动处理分析--End"); + } + + /* + * 根据自建台站样品谱生成4个Gamma谱 + * */ + public void create4PHD(){ + // 计算边界值 + List gEnergy = sampleStruct.g_energy; + List gCentroidChannel = sampleStruct.g_centroid_channel; + List bElectronEnergy = sampleStruct.b_electron_energy; + List bChannel = sampleStruct.b_channel; + long bChannels = sampleStruct.b_channels; + long gChannels = sampleStruct.g_channels; + List hCounts = sampleStruct.h_counts; + CalcBgBoundaryParam calcBgBoundaryParam = new CalcBgBoundaryParam(); + calcBgBoundaryParam.g_e_cal = EnergySpectrumHandler.GetFileFittingPara(gEnergy, gCentroidChannel); + calcBgBoundaryParam.b_e_cal = EnergySpectrumHandler.GetFileFittingPara(bElectronEnergy, bChannel); + calcBgBoundaryParam.b_energy = sampleStruct.b_electron_energy; + calcBgBoundaryParam.b_channel = sampleStruct.b_channel; + calcBgBoundaryParam.g_channel = sampleStruct.g_centroid_channel; + calcBgBoundaryParam.g_energy = sampleStruct.g_energy; + calcBgBoundaryParam.ROI_B_start_x1 = sampleStruct.POI_B_x1; + calcBgBoundaryParam.ROI_B_stop_x2 = sampleStruct.POI_B_x2; + calcBgBoundaryParam.ROI_G_start_y1 = sampleStruct.POI_G_y1; + calcBgBoundaryParam.ROI_G_stop_y2 = sampleStruct.POI_G_y2; + BgBoundary bgBoundary = EnergySpectrumHandler.CalcBgBoundary(calcBgBoundaryParam); + // 新Beta谱：只取X轴数据从Y轴0的位置开始连成一条线，一直到顶画出矩形框 这个矩形框内的数据就是Gamma谱数据 + List roiBBoundaryStart = bgBoundary.ROI_B_Boundary_start; + List roiBBoundaryStop = bgBoundary.ROI_B_Boundary_stop; + + SelfUtil selfStationUtil = serviceQuotes.getSelfStationUtil(); + + // 根据范围1划分 范围1对应的折线图 + List roiOneCounts = selfStationUtil.roiList(roiBBoundaryStart.get(0), roiBBoundaryStop.get(0), + bChannels, gChannels, hCounts); + // 根据范围2划分 范围2对应的折线图 + List roiTwoCounts = selfStationUtil.roiList(roiBBoundaryStart.get(1), roiBBoundaryStop.get(1), + bChannels, gChannels, hCounts); + // 根据范围3划分 范围3对应的折线图 + List roiThreeCounts = selfStationUtil.roiList(roiBBoundaryStart.get(2), roiBBoundaryStop.get(2), + bChannels, gChannels, hCounts); + // 根据范围4划分 范围4对应的折线图 + List roiFourCounts = selfStationUtil.roiList(roiBBoundaryStart.get(3), roiBBoundaryStop.get(3), + bChannels, gChannels, hCounts); + + // 根据ROI生成四个Gamma谱文件 文件命名格式为: 样品谱原名_ROI_x.PHD + String gammaOneName = StrUtil.subBefore(sampleFilename, ".PHD", true) + "_ROI_1.PHD"; + selfStationUtil.createGammaFile(this.savePath(), gammaOneName, this.sampleStruct, roiOneCounts); + + String gammaTwoName = StrUtil.subBefore(sampleFilename, ".PHD", true) + "_ROI_2.PHD"; + selfStationUtil.createGammaFile(this.savePath(), gammaTwoName, this.sampleStruct, roiTwoCounts); + + String gammaThreeName = StrUtil.subBefore(sampleFilename, ".PHD", true) + "_ROI_3.PHD"; + selfStationUtil.createGammaFile(this.savePath(), gammaThreeName, this.sampleStruct, roiThreeCounts); + + String gammaFourName = StrUtil.subBefore(sampleFilename, ".PHD", true) + "_ROI_4.PHD"; + selfStationUtil.createGammaFile(this.savePath(), gammaFourName, this.sampleStruct, roiFourCounts); + // 将生成的GammaPHD文件转换为PHDFile对象 + this.phdFile1 = selfStationUtil.getGammaPHD(gammaOneName, this.savePath()); + this.phdFile1.setRoiSuffix("_ROI_1"); + this.phdFile2 = selfStationUtil.getGammaPHD(gammaTwoName, this.savePath()); + this.phdFile2.setRoiSuffix("_ROI_2"); + this.phdFile3 = selfStationUtil.getGammaPHD(gammaThreeName, this.savePath()); + this.phdFile3.setRoiSuffix("_ROI_3"); + this.phdFile4 = selfStationUtil.getGammaPHD(gammaFourName, this.savePath()); + this.phdFile4.setRoiSuffix("_ROI_4"); + } + + /* + * 获取savefile全路径 不包含文件名 + * */ + public String savePath(){ + spectrumPathProperties = SpringContextUtils.getBean(SpectrumPathProperties.class); + String rootPath = spectrumPathProperties.getRootPath(); + String saveFilePath = spectrumPathProperties.getSaveFilePath(); + String saveRelativePath = this.spectrumHandler.getFileSaveRelativePath(); + return rootPath + saveFilePath + File.separator + saveRelativePath; + } + + /** + * 读取计算MDC参数文件方法 + */ + public void readMDCParameter(PHDFile phd) { + //存储文件结果用的map + Map mdcInfoMap = new TreeMap<>(); + //配置文件路径 + String filePath = parameterProperties.getFilePath()+ File.separator + "MDCParameter.xml"; + try { + //创建一个文档解析器工厂 + DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); + //创建文档解析器 + DocumentBuilder documentBuilder = factory.newDocumentBuilder(); + //读取xml文件生成一个文档 + Document document = documentBuilder.parse(filePath); + if (Objects.nonNull(document)){ + //获取文档的根元素 + Element element = document.getDocumentElement(); + //获取根元素的子节点 + NodeList docChildNodes = element.getChildNodes(); + //判断文件内的节点是否大于0 + if (Objects.nonNull(docChildNodes) && docChildNodes.getLength() > 0) { + //遍历文件节点读取内容 + for (int i=0; i 0) { + //遍历子节点信息 + for (int j=0; j< childNodes.getLength(); j++) { + //获取子节点信息 + Node childNode = childNodes.item(j); + //判断节点名称是否是item + if (childNode.getNodeName().equalsIgnoreCase("item")) { + //获取节点属性信息 + NamedNodeMap attributes = childNode.getAttributes(); + //判断节点属性信息是否为空 + if (Objects.nonNull(attributes)) { + CalMDCInfo info = new CalMDCInfo(); + //遍历属性信息 + for (int k=0; k nuclides = Maps.newHashMap(); + for (int i=0; i qcItems){ + //如果数据已经存储，不在重复存储 + final Integer idAnalysis = serviceQuotes.getAnalysesService().getIdAnalysis(this.sampleData.getSampleId()); + if(Objects.nonNull(idAnalysis)){ +// log.warn("{} file analysis data has been stored",new File(this.sampleTempFilePath).getName()); + return; + } + DataSourceSwitcher.switchToOracle(); + final TransactionStatus transactionStatus = serviceQuotes.getTransactionManager().getTransaction(serviceQuotes.getTransactionDefinition()); + try { + Integer sampleId = this.sampleData.getSampleId(); + // 保存分析结果 ==> INSERT INTO RNAUTO.GARDS_ANALYSES + saveAnalysis(middleData, sampleId); + // 获取分析结果ID ==> SELECT IDANALYSIS + Integer IdAnalysis = getIdAnalysis(sampleId); + // 修改保存结果状态 ==> UPDATE ORIGINAL.GARDS_SAMPLE_DATA +// serviceQuotes.getSampleDataService().updateStatus(null,null); + /* GARDS_CALIBRATION_PAIRS 数据表保存 */ + saveCalibrationPairs(middleData, sampleId, IdAnalysis); + /* GARDS_CALIBRATION 数据表保存 */ + saveCalibration(middleData, sampleId, IdAnalysis); + /* Gards_Peaks 数据表保存 */ + savePeaks(middleData, sampleId, IdAnalysis); + /* Gards_Nucl_Lines_Ided 数据表保存 */ + saveNuclLinesIded(middleData, sampleId, IdAnalysis); + /* Gards_Nucl_Ided 数据表保存 */ + saveNuclIded(middleData, sampleId, IdAnalysis); + /* Gards_Qc_Check 数据表保存 */ + saveQcCheck(middleData, sampleId, IdAnalysis, qcItems); + /* GARDS_MDC 数据表保存 */ + saveMDC(sampleId, IdAnalysis, phdFile.getMdcInfoMap()); + //提交事务 + serviceQuotes.getTransactionManager().commit(transactionStatus); + } catch (Exception e) { + //设置分析数据存储失败标记 +// this.parsingProcessLog.setAnalysisDataStoreFlag(false); + //回滚事务 + serviceQuotes.getTransactionManager().rollback(transactionStatus); + throw e; + } finally { + DataSourceSwitcher.clearDataSource(); + } + } + + /** + * 生成日志文件 + * @param logFilePath + * @param middleData + */ + private void writeLog(String logFilePath, GStoreMiddleProcessData middleData) { + logFilePath = spectrumPathProperties.getRootPath() + spectrumPathProperties.getLogPath() + File.separator + logFilePath; + String sampleId = middleData.getSample_id(); + MyLogFormatUtil myLogFormatUtil = new MyLogFormatUtil(); + List writes = new LinkedList<>(); + + // 自动处理分析开始 + String analyseBegin = MyLogFormatUtil.analyseResultsBegin.replace("%1", "date"); + writes.add(MyLogFormatUtil.getTitleFormat(analyseBegin, MyLogFormatUtil.FILE_TITLE_FLAG)); + + /* Read calibration data */ + writes.add(MyLogFormatUtil.getTitleFormat(MyLogFormatUtil.titleCalibration)); + + List data = new ArrayList<>(); + writes.add(MyLogFormatUtil.getHeaderFormat(MyLogFormatUtil.SetSampleGEnergyChannel.replace("%1", sampleId))); + + AttributeItemVo item = null; + item = new AttributeItemVo("Channel", MyLogFormatUtil.getValuePoint(middleData.getCalibration_pairs_S_E_xValue(), 3)); + data.add(item); + item = new AttributeItemVo("Energy", MyLogFormatUtil.getValuePoint(middleData.getCalibration_pairs_S_E_yValue(),3)); + data.add(item); + item = new AttributeItemVo("Error", MyLogFormatUtil.getValuePoint(middleData.getCalibration_pairs_S_E_uncYValue(), 3)); + data.add(item); + writes.addAll(MyLogFormatUtil.getBlockContext(data)); + + // Reading gamma Efficiency pairs(sampleID: %1) + writes.add(MyLogFormatUtil.getHeaderFormat(MyLogFormatUtil.GSetSampleEfficiencyChannel.replace("%1", sampleId))); + data.clear(); + item = new AttributeItemVo("Channel", MyLogFormatUtil.getValuePoint(middleData.getCalibration_pairs_S_EF_xValue(), 3)); + data.add(item); + item = new AttributeItemVo("Energy", MyLogFormatUtil.getValuePoint(middleData.getCalibration_pairs_S_EF_yValue(), 3)); + data.add(item); + item = new AttributeItemVo("Error", MyLogFormatUtil.getValuePoint(middleData.getCalibration_pairs_S_EF_uncYValue(), 3)); + data.add(item); + writes.addAll(MyLogFormatUtil.getBlockContext(data)); + + // Reading gamma Resolution pairs(sampleID: %1) + writes.add(MyLogFormatUtil.getHeaderFormat(MyLogFormatUtil.GSetSampleResolutionChannel.replace("%1", sampleId))); + data.clear(); + item = new AttributeItemVo("Channel", MyLogFormatUtil.getValuePoint(middleData.getCalibration_pairs_S_R_xValue(), 3)); + data.add(item); + item = new AttributeItemVo("Energy", MyLogFormatUtil.getValuePoint(middleData.getCalibration_pairs_S_R_yValue(),3)); + data.add(item); + item = new AttributeItemVo("Error", MyLogFormatUtil.getValuePoint(middleData.getCalibration_pairs_S_R_uncYValue(),3)); + data.add(item); + writes.addAll(MyLogFormatUtil.getBlockContext(data)); + + // Reading gamma TotalEfficiency pairs(sampleID: %1) + writes.add(MyLogFormatUtil.getHeaderFormat(MyLogFormatUtil.GSetSampleTotalEfficiencyChannel.replace("%1", sampleId))); + data.clear(); + item = new AttributeItemVo("Channel", middleData.getCalibration_pairs_S_T_xValue()); + data.add(item); + item = new AttributeItemVo("Energy", MyLogFormatUtil.getValuePoint(middleData.getCalibration_pairs_S_T_yValue(), 3)); + data.add(item); + item = new AttributeItemVo("Error", MyLogFormatUtil.getValuePoint(middleData.getCalibration_pairs_S_T_uncYValue(), 3)); + data.add(item); + writes.addAll(MyLogFormatUtil.getBlockContext(data)); + + // Reading sample information + writes.add(MyLogFormatUtil.getHeaderFormat(MyLogFormatUtil.sampleInfo)); + Map infoMap = new LinkedHashMap<>(); + infoMap.put("Collection Start", middleData.sample_collection_start); + infoMap.put("Collection Stop", middleData.sample_collection_stop); + infoMap.put("Sampling Time[h]", middleData.sample_time); + infoMap.put("Sample Quantity[m3]", middleData.sample_quantity); + infoMap.put("Decay Time[h]", middleData.sample_decay_time); + infoMap.put("Acquisition Start", middleData.sample_acquisiton_start); + infoMap.put("Acquisition Stop", middleData.sample_acquistion_stop); + infoMap.put("Acquisition Time[s]", middleData.sample_acquistion_time); + writes.addAll(MyLogFormatUtil.getBlockContext(infoMap)); + + // Read calibration finished + writes.add(MyLogFormatUtil.getTitleFormat(MyLogFormatUtil.titleCalibrationIdEnd)); + + /* Starting Calibration */ + writes.add(MyLogFormatUtil.getTitleFormat(MyLogFormatUtil.GTitleCalibration)); + + // Energy Calibration [%1 ] + if(middleData.calibration_pairs_E_idCalPoint.size()>0) { + infoMap = new LinkedHashMap<>(); + infoMap.put("Energy Calibration [%1 ]".replace("%1", middleData.calibration_pairs_R_Input), ""); + infoMap.put("Function", middleData.calibration_E_functionTypeDef); + infoMap.put("E", middleData.calibration_E_functionDef); + infoMap.put("P", middleData.calibration_E_coeff_string); + infoMap.put("Err", middleData.calibration_E_uncoeff_string); + infoMap.put("Data", middleData.calibration_pairs_E_Input); + writes.addAll(MyLogFormatUtil.getBlockContext(infoMap)); + } + + // Resolution Calibration [%1 ] + if(middleData.calibration_pairs_R_idCalPoint.size()>0) { + infoMap = new LinkedHashMap<>(); + infoMap.put("Resolution Calibration [%1 ]".replace("%1", middleData.calibration_pairs_R_Input) , ""); + infoMap.put("Function", middleData.calibration_R_functionTypeDef); + infoMap.put("E", middleData.calibration_R_functionDef); + infoMap.put("P", middleData.calibration_R_coeff_string); + infoMap.put("Err", middleData.calibration_R_uncoeff_string); + infoMap.put("Data", middleData.calibration_pairs_R_Input); + writes.addAll(MyLogFormatUtil.getBlockContext(infoMap)); + } + + // Efficiency Calibration [PHD ] + if(middleData.calibration_pairs_EF_idCalPoint.size()>0) { + infoMap = new LinkedHashMap<>(); + infoMap.put("Efficiency Calibration [%1 ]".replace("%1", middleData.calibration_pairs_EF_Input), ""); + infoMap.put("Function", middleData.calibration_pairs_EF_Input); + infoMap.put("E", middleData.calibration_EF_functionTypeDef); + infoMap.put("P", middleData.calibration_EF_functionDef); + infoMap.put("Err", middleData.calibration_EF_coeff_string); + infoMap.put("Data", middleData.calibration_EF_uncoeff_string); + writes.addAll(MyLogFormatUtil.getBlockContext(infoMap)); + } + + if(middleData.calibration_pairs_T_idCalPoint.size()>0) { + infoMap = new LinkedHashMap<>(); + infoMap.put("Tot_efficiency Calibration [%1 ]".replace("%1", middleData.calibration_pairs_T_Input), ""); + infoMap.put("Function", middleData.calibration_pairs_T_Input); + infoMap.put("E", middleData.calibration_T_functionTypeDef); + infoMap.put("P", middleData.calibration_T_functionDef); + infoMap.put("Err", middleData.calibration_T_coeff_string); + infoMap.put("Data", middleData.calibration_T_uncoeff_string); + writes.addAll(MyLogFormatUtil.getBlockContext(infoMap)); + + } + // Calibration Finished + writes.add(MyLogFormatUtil.getTitleFormat(MyLogFormatUtil.GTitleCalibrationEnd)); + + /* Starting Spectrum Analysis */ + writes.add(MyLogFormatUtil.getTitleFormat(MyLogFormatUtil.GTitleSpectrum)); + + // PROCESSING PARAMETERS..... + writes.add(MyLogFormatUtil.getHeaderFormat(MyLogFormatUtil.GGetPROCESSING)); + + infoMap = new LinkedHashMap<>(); + infoMap.put("ECutAnalysis_Low", middleData.setting_specSetup.getECutAnalysis_Low()); + infoMap.put("ECutAnalysis_High", middleData.setting_specSetup.getECutAnalysis_High()); + infoMap.put("EnergyTolerance", middleData.setting_specSetup.getEnergyTolerance()); + infoMap.put("BaseImprovePSS", middleData.setting_specSetup.getBaseImprovePSS()); + infoMap.put("PSS_low", middleData.setting_specSetup.getPss_low()); + infoMap.put("k_back", middleData.setting_specSetup.getK_back()); + infoMap.put("k_alpha", middleData.setting_specSetup.getK_alpha()); + infoMap.put("k_beta", middleData.setting_specSetup.getK_beta()); + infoMap.put("RiskLevelK", middleData.setting_specSetup.getRiskLevelK()); + infoMap.put("refTime_act", middleData.setting_specSetup.getRefTime_act()); + infoMap.put("refTime_conc", middleData.setting_specSetup.getRefTime_conc()); + writes.addAll(MyLogFormatUtil.getBlockContext(infoMap)); + + // CALIBRATION PARAMETERS..... + writes.add(MyLogFormatUtil.getHeaderFormat(MyLogFormatUtil.GGetCALIBRATION)); + infoMap = new LinkedHashMap<>(); + infoMap.put("CalibrationPSS_low", middleData.setting_specSetup.getCalibrationPSS_low()); + infoMap.put("CalibrationPSS_high", middleData.setting_specSetup.getCalibrationPSS_high()); + infoMap.put("bUpdateCal", middleData.setting_specSetup.isBUpdateCal()); + infoMap.put("KeepCalPeakSearchPeaks", middleData.setting_specSetup.isKeepCalPeakSearchPeaks()); + writes.addAll(MyLogFormatUtil.getBlockContext(infoMap)); + + // Nuclide Identified..... + writes.add(MyLogFormatUtil.getHeaderFormat(MyLogFormatUtil.GGetPeakSearchResult)); + infoMap = new LinkedHashMap<>(); + int idPeakSize = middleData.peaks_idPeak.size(); + double peaksUsed = 0; + for(int m=0;m(); + item = new AttributeItemVo("PeakID", middleData.getPeaks_idPeak()); + data.add(item); + item = new AttributeItemVo("Energy", MyLogFormatUtil.getValuePoint(middleData.getPeaks_Energy(), 3)); + data.add(item); + item = new AttributeItemVo("Centroid", MyLogFormatUtil.getValuePoint(middleData.getPeaks_peakCentroid(), 3)); + data.add(item); + item = new AttributeItemVo("FWHM", MyLogFormatUtil.getValuePoint(middleData.getPeaks_Fwhm(), 3)); + data.add(item); + item = new AttributeItemVo("NetArea", MyLogFormatUtil.getValuePoint(middleData.getPeaks_Area(), 3)); + data.add(item); + List percentData = MyLogFormatUtil.getPercent(middleData.getPeaks_areaErr(), middleData.getPeaks_Area()); + item = new AttributeItemVo("NAErr%", MyLogFormatUtil.getValuePoint(percentData, 3)); + data.add(item); + item = new AttributeItemVo("Signif", MyLogFormatUtil.getValuePoint(middleData.getPeaks_Significance(), 3)); + data.add(item); + item = new AttributeItemVo("Sensit", MyLogFormatUtil.getValuePoint(middleData.getPeaks_Sensitivity(), 3)); + data.add(item); + item = new AttributeItemVo("Nuclide", middleData.getPeaks_Nuclide_name()); + data.add(item); + writes.addAll(MyLogFormatUtil.getBlock(MyLogFormatUtil.GSetSampleEfficiencyChannel, sampleId, data)); + + // Nuclide Identified..... + writes.add(MyLogFormatUtil.getHeaderFormat(MyLogFormatUtil.GGetPeakSearchResult)); + StringBuilder qsNuclidesName = new StringBuilder(); + for(int m = 0; m < middleData.nucl_ided_Nuclidename.size() -1; m++) + { + qsNuclidesName.append(middleData.nucl_ided_Nuclidename.get(m)).append(","); + } + if(middleData.nucl_ided_Nuclidename.size() > 1) + { + qsNuclidesName.append(middleData.nucl_ided_Nuclidename.get(middleData.nucl_ided_Nuclidename.size() - 1)); + } + infoMap = new LinkedHashMap<>(); + infoMap.put("Nuclides Identified", qsNuclidesName.toString()); + infoMap.put("Keyline Activities for Nuclides with defined Reference Line", ""); + infoMap.put("Activity Reference Time", middleData.getSample_acquisiton_start()); + infoMap.put("Concentration Reference Time", middleData.getSample_collection_start()); + writes.addAll(MyLogFormatUtil.getBlockContext(infoMap)); + + data = new ArrayList<>(); + item = new AttributeItemVo("Nuclide", middleData.getNucl_ided_Nuclidename()); + data.add(item); + item = new AttributeItemVo("Halflife", middleData.getNucl_ided_Halflife()); + data.add(item); + item = new AttributeItemVo("Activity", + MyLogFormatUtil.getValuePoint(middleData.getNucl_ided_activ_key(), 3), "bq"); + data.add(item); + List ideaPercent = MyLogFormatUtil.getPercent(middleData.getNucl_ided_activ_key_err(), middleData.getNucl_ided_activ_key()); + item = new AttributeItemVo("RelErr", ideaPercent, "%"); + data.add(item); + item = new AttributeItemVo("Conc", middleData.getNucl_ided_Concentration(), "uBq/m^3"); + data.add(item); + item = new AttributeItemVo("MDC", middleData.getNucl_ided_MDC(), "uBq/m^3"); + data.add(item); + writes.addAll(MyLogFormatUtil.getBlockContext(data)); + + data = new ArrayList<>(); + item = new AttributeItemVo("Name", middleData.getQC_CHECK_QC_NAME()); + data.add(item); + item = new AttributeItemVo("Pass/Fail", MyLogFormatUtil.getPass(middleData.getQC_CHECK_QC_RESULT())); + data.add(item); + item = new AttributeItemVo("Value", MyLogFormatUtil.getValuePoint(middleData.getQC_CHECK_QC_VALUE(), 3)); + data.add(item); + item = new AttributeItemVo("Test", middleData.getQC_CHECK_QC_STANDARD()); + data.add(item); + writes.addAll(MyLogFormatUtil.getBlockContext(data)); + // Starting Data Quality..... + writes.add(MyLogFormatUtil.getHeaderFormat(MyLogFormatUtil.GGetDataQuality)); + + // Spectrum Analysis Finished + writes.add(MyLogFormatUtil.getTitleFormat(MyLogFormatUtil.GTitleSpectrumEnd)); + // todo Data store successfully ..... + // todo Instance status successfully set to: P..... + // todo Error info: data has NULL INF..... + + + // Sample Analyse Successfully at %1 + String analyseEnd = MyLogFormatUtil.analyseResultsEnd.replace("%1", "date"); + writes.add(MyLogFormatUtil.getTitleFormat(analyseEnd)); + + // 保存文件 + try { + FileOperation.saveFile(logFilePath, writes); + } catch (IOException e) { + e.printStackTrace(); + } + } + + public void saveAnalysis(GStoreMiddleProcessData middleData,Integer sampleId){ + GardsAnalyses analysis = toAnalysis(middleData); + analysis.setSampleId(sampleId); + serviceQuotes.getAnalysesService().save(analysis); + } + + public Integer getIdAnalysis(Integer sampleId){ + return serviceQuotes.getAnalysesService().getIdAnalysis(sampleId); + } + + public void saveCalibrationPairs(GStoreMiddleProcessData middleData, + Integer sampleId, Integer IdAnalysis){ + String pairsSampleType = middleData.getCalibration_pairs_sample_type(); + GardsCalibrationPairs pairs = new GardsCalibrationPairs(); + // GARDS_CALIBRATION_PAIRS (Energy) ==> INSERT INTO RNAUTO.GARDS_CALIBRATION_PAIRS + String base_E_Paris = "calibration_pairs_E_idCalPoint"; + PairsEDto pairsEDto = new PairsEDto(); + BeanUtil.copyProperties(middleData,pairsEDto); + List pairsE = Lists.newArrayList(); + if (pairsEDto.getCalibration_pairs_E_idCalPoint().size() > 0) { + pairsE = mapFields(pairsEDto, pairs, base_E_Paris, fieldMap); + String pairsECaltype = middleData.getCalibration_pairs_E_Caltype(); + String pairsEInput = middleData.getCalibration_pairs_E_Input(); + for (GardsCalibrationPairs onePairs : pairsE) { + onePairs.setSampleId(sampleId); + onePairs.setIdAnalysis(IdAnalysis); + onePairs.setSampleType(pairsSampleType); + onePairs.setCaltype(pairsECaltype); + onePairs.setInput(pairsEInput); + } + } + // GARDS_CALIBRATION_PAIRS (Efficiency) ==> INSERT INTO RNAUTO.GARDS_CALIBRATION_PAIRS + String base_EF_Paris = "calibration_pairs_EF_idCalPoint"; + PairsEFDto pairsEFDto = new PairsEFDto(); + BeanUtil.copyProperties(middleData,pairsEFDto); + List pairsEF = Lists.newArrayList(); + if (pairsEFDto.getCalibration_pairs_EF_idCalPoint().size() > 0) { + pairsEF = mapFields(pairsEFDto, pairs, base_EF_Paris, fieldMap); + String pairsEFCaltype = middleData.getCalibration_pairs_EF_Caltype(); + String pairsEFInput = middleData.getCalibration_pairs_EF_Input(); + for (GardsCalibrationPairs onePairs : pairsEF) { + onePairs.setSampleId(sampleId); + onePairs.setIdAnalysis(IdAnalysis); + onePairs.setSampleType(pairsSampleType); + onePairs.setCaltype(pairsEFCaltype); + onePairs.setInput(pairsEFInput); + } + } + // GARDS_CALIBRATION_PAIRS (Resolution) ==> INSERT INTO RNAUTO.GARDS_CALIBRATION_PAIRS + String base_R_Paris = "calibration_pairs_R_idCalPoint"; + PairsRDto pairsRDto = new PairsRDto(); + BeanUtil.copyProperties(middleData,pairsRDto); + List pairsR = Lists.newArrayList(); + if (pairsRDto.getCalibration_pairs_R_idCalPoint().size() > 0) { + pairsR = mapFields(pairsRDto, pairs, base_R_Paris, fieldMap); + String pairsRCaltype = middleData.getCalibration_pairs_R_Caltype(); + String pairsRInput = middleData.getCalibration_pairs_R_Input(); + for (GardsCalibrationPairs onePairs : pairsR) { + onePairs.setSampleId(sampleId); + onePairs.setIdAnalysis(IdAnalysis); + onePairs.setSampleType(pairsSampleType); + onePairs.setCaltype(pairsRCaltype); + onePairs.setInput(pairsRInput); + } + } + // GARDS_CALIBRATION_PAIRS (TotalEfficiency) ==> INSERT INTO RNAUTO.GARDS_CALIBRATION_PAIRS + String base_T_Paris = "calibration_pairs_T_idCalPoint"; + PairsTDto pairsTDto = new PairsTDto(); + BeanUtil.copyProperties(middleData,pairsTDto); + List pairsT = Lists.newArrayList(); + if (pairsTDto.getCalibration_pairs_T_idCalPoint().size() > 0) { + pairsT = mapFields(pairsTDto, pairs, base_T_Paris, fieldMap); + String pairsTCaltype = middleData.getCalibration_pairs_T_Caltype(); + String pairsTInput = middleData.getCalibration_pairs_T_Input(); + for (GardsCalibrationPairs onePairs : pairsT) { + onePairs.setSampleId(sampleId); + onePairs.setIdAnalysis(IdAnalysis); + onePairs.setSampleType(pairsSampleType); + onePairs.setCaltype(pairsTCaltype); + onePairs.setInput(pairsTInput); + } + } + // GARDS_CALIBRATION_PAIRS 汇总保存 + List allPairs = new ArrayList<>(); + allPairs.addAll(pairsE);allPairs.addAll(pairsEF); + allPairs.addAll(pairsR);allPairs.addAll(pairsT); + serviceQuotes.getGardsCalibrationPairsService().saveBatch(allPairs); + } + public void saveCalibration(GStoreMiddleProcessData middleData, + Integer sampleId, Integer IdAnalysis){ + String calibrationSampleType = middleData.getCalibration_sample_type(); + List pairsEIdCalPoint = middleData.getCalibration_pairs_E_idCalPoint(); + List pairsEFIdCalPoint = middleData.getCalibration_pairs_EF_idCalPoint(); + List pairsRIdCalPoint = middleData.getCalibration_pairs_R_idCalPoint(); + List pairsTIdCalPoint = middleData.getCalibration_pairs_T_idCalPoint(); + List calibrations = new ArrayList<>(); + // GARDS_CALIBRATION (E) ==> INSERT INTO RNAUTO.GARDS_CALIBRATION + if (CollUtil.isNotEmpty(pairsEIdCalPoint)){ + GardsCalibration calibration = new GardsCalibration(); + calibration.setSampleId(sampleId); + calibration.setIdAnalysis(IdAnalysis); + calibration.setSampleType(calibrationSampleType); + calibration.setCalType(middleData.getCalibration_E_Caltype()); + calibration.setFunction((int)middleData.getCalibration_E_function()); + calibration.setFunctionDef(middleData.getCalibration_E_functionDef()); + calibration.setStartOfRange((int)middleData.getCalibration_E_startOfRange()); + calibration.setEndOfRange((int)middleData.getCalibration_E_endOfRange()); + calibration.setCoeffString(middleData.getCalibration_E_coeff_string()); + calibration.setModdate(new Date()); + calibrations.add(calibration); + } + // GARDS_CALIBRATION (EF) ==> INSERT INTO RNAUTO.GARDS_CALIBRATION + if (CollUtil.isNotEmpty(pairsEFIdCalPoint)){ + GardsCalibration calibration = new GardsCalibration(); + calibration.setSampleId(sampleId); + calibration.setIdAnalysis(IdAnalysis); + calibration.setSampleType(calibrationSampleType); + String efCaltype = middleData.getCalibration_EF_Caltype(); + double efFunction = middleData.getCalibration_EF_function(); + String efFunctionDef = middleData.getCalibration_EF_functionDef(); + double efStartOfRange = middleData.getCalibration_EF_startOfRange(); + double efEndOfRange = middleData.getCalibration_EF_endOfRange(); + String efCoeffString = middleData.getCalibration_EF_coeff_string(); + calibration.setCalType(efCaltype); + calibration.setFunction((int)efFunction); + calibration.setFunctionDef(efFunctionDef); + calibration.setStartOfRange((int)efStartOfRange); + calibration.setEndOfRange((int)efEndOfRange); + calibration.setCoeffString(efCoeffString); + calibration.setModdate(new Date()); + calibrations.add(calibration); + } + // GARDS_CALIBRATION (R) ==> INSERT INTO RNAUTO.GARDS_CALIBRATION + if (CollUtil.isNotEmpty(pairsRIdCalPoint)){ + GardsCalibration calibration = new GardsCalibration(); + calibration.setSampleId(sampleId); + calibration.setIdAnalysis(IdAnalysis); + calibration.setSampleType(calibrationSampleType); + String rCaltype = middleData.getCalibration_R_Caltype(); + double rFunction = middleData.getCalibration_R_function(); + String rFunctionDef = middleData.getCalibration_R_functionDef(); + double rStartOfRange = middleData.getCalibration_R_startOfRange(); + double rEndOfRange = middleData.getCalibration_R_endOfRange(); + String rCoeffString = middleData.getCalibration_R_coeff_string(); + calibration.setCalType(rCaltype); + calibration.setFunction((int)rFunction); + calibration.setFunctionDef(rFunctionDef); + calibration.setStartOfRange((int)rStartOfRange); + calibration.setEndOfRange((int)rEndOfRange); + calibration.setCoeffString(rCoeffString); + calibration.setModdate(new Date()); + calibrations.add(calibration); + } + // GARDS_CALIBRATION (T) ==> INSERT INTO RNAUTO.GARDS_CALIBRATION + if (CollUtil.isNotEmpty(pairsTIdCalPoint)){ + GardsCalibration calibration = new GardsCalibration(); + calibration.setSampleId(sampleId); + calibration.setIdAnalysis(IdAnalysis); + calibration.setSampleType(calibrationSampleType); + String tCaltype = middleData.getCalibration_T_Caltype(); + double tFunction = middleData.getCalibration_T_function(); + String tFunctionDef = middleData.getCalibration_T_functionDef(); + double tStartOfRange = middleData.getCalibration_T_startOfRange(); + double tEndOfRange = middleData.getCalibration_T_endOfRange(); + String tCoeffString = middleData.getCalibration_T_coeff_string(); + calibration.setCalType(tCaltype); + calibration.setFunction((int)middleData.getCalibration_T_function()); + calibration.setFunctionDef(tFunctionDef); + calibration.setStartOfRange((int)tStartOfRange); + calibration.setEndOfRange((int)tEndOfRange); + calibration.setCoeffString(tCoeffString); + calibration.setModdate(new Date()); + calibrations.add(calibration); + } + if (calibrations.size() > 0) { + serviceQuotes.getGardsCalibrationService().createBatch(calibrations); + } + } + + public void savePeaks(GStoreMiddleProcessData middleData,Integer sampleId, Integer IdAnalysis){ + // Gards_Peaks数据表 ==> INSERT INTO RNAUTO.GARDS_PEAKS + String base_P_IdPeak = "peaks_idPeak"; + GardsPeaksDto gardsPeaksDto = new GardsPeaksDto(); + BeanUtil.copyProperties(middleData,gardsPeaksDto); + GardsPeaks gardsPeaks = new GardsPeaks(); + if (gardsPeaksDto.getPeaks_idPeak().size() > 0) { + List peaks = mapFields(gardsPeaksDto, gardsPeaks, base_P_IdPeak, fieldMap); + peaks.forEach(ided -> { + ided.setSampleId(sampleId); + ided.setIdAnalysis(IdAnalysis); + }); + serviceQuotes.getGardsPeaksAutoService().saveBatch(peaks); + } + } + + public void saveNuclLinesIded(GStoreMiddleProcessData middleData, + Integer sampleId, Integer IdAnalysis){ + // Gards_Nucl_Lines_Ided数据表 ==> INSERT INTO RNAUTO.GARDS_NUCL_LINES_IDED + Map nuclLinesIdedData = middleData.getNucl_lines_ided_data(); + String base_IdPeak = "idPeak"; + List allNuclLinesIdeds = new ArrayList<>(); + for (Map.Entry entry : nuclLinesIdedData.entrySet()) { + String nuclideName = entry.getKey(); + GStoreMiddleProcessDataNuclLinesIded nuclLinesIded = entry.getValue(); + GardsNuclLinesIded gardsNuclLinesIded = new GardsNuclLinesIded(); + List gardsNuclLinesIdeds = mapFields(nuclLinesIded, gardsNuclLinesIded, base_IdPeak, fieldMap); + if (CollUtil.isNotEmpty(gardsNuclLinesIdeds)){ + for (GardsNuclLinesIded ided : gardsNuclLinesIdeds) { + ided.setSampleId(sampleId); + ided.setIdAnalysis(IdAnalysis); + ided.setNuclideName(nuclideName); + } + allNuclLinesIdeds.addAll(gardsNuclLinesIdeds); + } + } + serviceQuotes.getGardsNuclLinesIdedAutoService().saveBatch(allNuclLinesIdeds); + } + + public void saveNuclIded(GStoreMiddleProcessData middleData, + Integer sampleId, Integer IdAnalysis){ + // Gards_Nucl_Ided数据表 ==> INSERT INTO RNAUTO.GARDS_NUCL_IDED + GardsNuclIdedDto gardsNuclIdedDto = new GardsNuclIdedDto(); + GardsNuclIded gardsNuclIded = new GardsNuclIded(); + BeanUtil.copyProperties(middleData,gardsNuclIdedDto); + if (!gardsNuclIdedDto.getNucl_ided_Nuclidename().isEmpty()) { + String base_NuclideName = "nucl_ided_Nuclidename"; + List gardsNuclIdeds = + mapFields(gardsNuclIdedDto, gardsNuclIded, base_NuclideName, fieldMap); + for (GardsNuclIded ided : gardsNuclIdeds) { + ided.setSampleId(sampleId); + ided.setIdAnalysis(IdAnalysis); + } + serviceQuotes.getGardsNuclIdedAutoService().saveBatch(gardsNuclIdeds); + } + // serviceQuotes.get + } + + public void saveQcCheck(GStoreMiddleProcessData middleData, + Integer sampleId, Integer IdAnalysis,Map qcItems){ + // Gards_Qc_Check数据表 ==> INSERT INTO RNAUTO.GARDS_QC_CHECK + if (MapUtil.isNotEmpty(qcItems)){ + String base_QC = String.valueOf(qcItems.size()); + QcCheckDto qcCheckDto = new QcCheckDto(); + BeanUtil.copyProperties(middleData,qcCheckDto); + if (!qcItems.isEmpty()) { + GardsQcCheck gardsQcCheck = new GardsQcCheck(); + List gardsQcChecks = mapFields(qcCheckDto, gardsQcCheck,base_QC,fieldMap); + for (GardsQcCheck qcCheck : gardsQcChecks) { + qcCheck.setSampleId(sampleId); + qcCheck.setIdanalysis(IdAnalysis); + } + serviceQuotes.getGardsQcCheckAutoService().saveBatch(gardsQcChecks); + } + } + } + + public void saveMDC(Integer sampleId, Integer IdAnalysis, Map mdcInfoMap) { + List mdcList = new LinkedList<>(); + if (CollectionUtils.isNotEmpty(mdcInfoMap)) { + for (CalMDCInfo mdcInfo :mdcInfoMap.values()) { + if (Objects.nonNull(mdcInfo.getEnergy()) && Objects.nonNull(mdcInfo.getYield()) && Objects.nonNull(mdcInfo.getEfficiency())) { + GardsMDC mdc = new GardsMDC(); + mdc.setIdAnalysis(IdAnalysis); + mdc.setSampleId(sampleId); + mdc.setNuclideName(mdcInfo.getNuclideName()); + mdc.setEnergy(mdcInfo.getEnergy()); + mdc.setYield(mdcInfo.getYield()); + mdc.setEfficiency(mdcInfo.getEfficiency()); + if (Objects.nonNull(mdcInfo.getMdc()) && Double.isFinite(mdcInfo.getMdc())) { + mdc.setMdc(String.valueOf(mdcInfo.getMdc())); + } else { + mdc.setMdc(null); + } + mdc.setMdcErr(null); + mdcList.add(mdc); + } + } + } + if (CollectionUtils.isNotEmpty(mdcList)) { + serviceQuotes.getGardsMDCAutoService().saveBatch(mdcList); + } + } + + public Map getNuclideLinesG() { + redisUtil = ApplicationContextUtil.getContext().getBean(RedisUtil.class); + Object nuclideLibs = redisUtil.get(RedisConstant.NUCLIDE_LINES_LIB + "G"); + return Objects.isNull(nuclideLibs) ? Maps.newHashMap() : (Map) nuclideLibs; + } + + public Map getNuclideLinesP(){ + redisUtil = ApplicationContextUtil.getContext().getBean(RedisUtil.class); + Object nuclideLibs = redisUtil.get(RedisConstant.NUCLIDE_LINES_LIB + "P"); + return Objects.isNull(nuclideLibs) ? Maps.newHashMap() : (Map) nuclideLibs; + } + + public Map fieldMap(){ + Map fieldMap = new HashMap<>(); + // Gards_Nucl_Lines_Ided + fieldMap.put("nuclideFullname","nuclidefullname"); + fieldMap.put("Energy","energy"); + fieldMap.put("Abundance","abundance"); + fieldMap.put("Activity","activity"); + fieldMap.put("Effic","effic"); + fieldMap.put("uncEffic","unEffic"); + fieldMap.put("Mda","mda"); + fieldMap.put("key_flag","keyFlag"); + fieldMap.put("csc_ratio","cscRatio"); + fieldMap.put("csc_ratio_err","cscRatioErr"); + fieldMap.put("csc_mod_flag","cscModFlag"); + fieldMap.put("MDC","mdc"); + fieldMap.put("Concentration","concentration"); + // Gards_Nucl_Ided + fieldMap.put("nucl_ided_Nuclidename","nuclideName"); + fieldMap.put("nucl_ided_Type","type"); + fieldMap.put("nucl_ided_Halflife","halflife"); + fieldMap.put("nucl_ided_ave_activ","aveActiv"); + fieldMap.put("nucl_ided_ave_activ_err","aveActivErr"); + fieldMap.put("nucl_ided_activ_key","activKey"); + fieldMap.put("nucl_ided_activ_key_err","activKeyErr"); + fieldMap.put("nucl_ided_mda","mda"); + fieldMap.put("nucl_ided_mda_err","mdaErr"); + fieldMap.put("nucl_ided_nid_flag","nidFlag"); + fieldMap.put("nucl_ided_csc_ratio","cscRatio"); + fieldMap.put("nucl_ided_csc_ratio_err","cscRatioErr"); + fieldMap.put("nucl_ided_csc_mod_flag","cscModFlag"); + fieldMap.put("nucl_ided_MDC","mdc"); + fieldMap.put("nucl_ided_Concentration","concentration"); + fieldMap.put("nucl_ided_Key_Energy","keyEnergy"); + fieldMap.put("nucl_ided_Key_Yield","keyYield"); + // Gards_Qc_Check + fieldMap.put("QC_CHECK_QC_NAME","qcName"); + fieldMap.put("QC_CHECK_QC_VALUE","qcValue"); + fieldMap.put("QC_CHECK_QC_STANDARD","qcStandard"); + fieldMap.put("QC_CHECK_QC_RESULT","qcResult"); + // Gards_Peaks + fieldMap.put("peaks_idPeak", "idPeak"); + fieldMap.put("peaks_peakCentroid", "centroidChannel"); + fieldMap.put("peaks_uncpeakCentroid", "uncCentroidChannel"); + fieldMap.put("peaks_Energy", "energy"); + fieldMap.put("peaks_uncEnergy", "uncEnergy"); + fieldMap.put("peaks_Area", "area"); + fieldMap.put("peaks_areaErr", "uncArea"); + fieldMap.put("peaks_netCountRate", "netCountRate"); + fieldMap.put("peaks_uncNetCountRate", "uncNetCountRate"); + fieldMap.put("peaks_Efficiency", "efficiency"); + fieldMap.put("peaks_Uncefficiency", "uncefficiency"); + fieldMap.put("peaks_Fwhm", "fwhm"); + fieldMap.put("peaks_Fwhmc", "fwtm"); + fieldMap.put("peaks_Significance", "significance"); + fieldMap.put("peaks_Sensitivity", "sensitivity"); + fieldMap.put("peaks_multiIndex", "mulitiIndex"); + fieldMap.put("peaks_ROIstart", "roiStart"); + fieldMap.put("peaks_ROIend", "roiEnd"); + fieldMap.put("peaks_tail", "tail"); + fieldMap.put("peaks_tailAlpha", "tailAlpha"); + fieldMap.put("peaks_upperTail", "upperTail"); + fieldMap.put("peaks_upperTailAlpha", "upperTailAlpha"); + fieldMap.put("peaks_BWWidthChan", "bwwidthchan"); + fieldMap.put("peaks_recoilDeltaChan", "recoildeltachan"); + fieldMap.put("peaks_stepRatio", "stepraio"); + fieldMap.put("peaks_backgroundArea", "backgroundarea"); + fieldMap.put("peaks_meanBackCount", "meanbackcount"); + fieldMap.put("peaks_Lc", "lc"); + fieldMap.put("peaks_Ld", "ld"); + // GARDS_CALIBRATION_PAIRS + fieldMap.put("calibration_pairs_E_idCalPoint","idCalPoint"); + fieldMap.put("calibration_pairs_E_xValue","xValue"); + fieldMap.put("calibration_pairs_E_yValue","yValue"); + fieldMap.put("calibration_pairs_E_uncYValue","uncYValue"); + fieldMap.put("calibration_pairs_EF_idCalPoint","idCalPoint"); + fieldMap.put("calibration_pairs_EF_xValue","xValue"); + fieldMap.put("calibration_pairs_EF_yValue","yValue"); + fieldMap.put("calibration_pairs_EF_uncYValue","uncYValue"); + fieldMap.put("calibration_pairs_R_idCalPoint","idCalPoint"); + fieldMap.put("calibration_pairs_R_xValue","xValue"); + fieldMap.put("calibration_pairs_R_yValue","yValue"); + fieldMap.put("calibration_pairs_R_uncYValue","uncYValue"); + fieldMap.put("calibration_pairs_T_idCalPoint","idCalPoint"); + fieldMap.put("calibration_pairs_T_xValue","xValue"); + fieldMap.put("calibration_pairs_T_yValue","yValue"); + fieldMap.put("calibration_pairs_T_uncYValue","uncYValue"); + return fieldMap; + } + + public void getSettingFromDB(PHDFile... phdFiles){ + Map mapSetting = serviceQuotes.getGammaDefaultParamsService() + .mapSetting(); + for (PHDFile phdFile : phdFiles) { + SpecSetup setting = phdFile.getSetting(); + String BaseImprovePSS = mapSetting.get(Setting.BASEIMPROVEPSS); + if (StrUtil.isNotBlank(BaseImprovePSS)) + setting.setBaseImprovePSS(Double.parseDouble(BaseImprovePSS)); + String CalibrationPSS_low = mapSetting.get(Setting.CALIBRATIONPSS_LOW); + if (StrUtil.isNotBlank(CalibrationPSS_low)) + setting.setCalibrationPSS_low(Double.parseDouble(CalibrationPSS_low)); + String CalibrationPSS_high = mapSetting.get(Setting.CALIBRATIONPSS_HIGH); + if (StrUtil.isNotBlank(CalibrationPSS_high)) + setting.setCalibrationPSS_high(Double.parseDouble(CalibrationPSS_high)); + String ECutAnalysis_High = mapSetting.get(Setting.ECUTANALYSIS_HIGH); + if (StrUtil.isNotBlank(ECutAnalysis_High)){ + setting.setECutAnalysis_High(Double.parseDouble(ECutAnalysis_High)); + }else { + setting.setECutAnalysis_High(Double.POSITIVE_INFINITY); + } + String systemType = sampleStruct.system_type; + if (StrUtil.equals(systemType, SpectrumSystemType.P.name())){ + String ECutAnalysis_Low = mapSetting.get(Setting.ECUTANALYSIS_LOW_P); + if (StrUtil.isNotBlank(ECutAnalysis_Low)) + setting.setECutAnalysis_Low(Double.parseDouble(ECutAnalysis_Low)); + String bUpdateCal_P = mapSetting.get(Setting.BUPDATECAL_P); + setting.setBUpdateCal(StrUtil.equals(bUpdateCal_P, "1")); + }else { + String ECutAnalysis_Low = mapSetting.get(Setting.ECUTANALYSIS_LOW_G); + if (StrUtil.isNotBlank(ECutAnalysis_Low)) + setting.setECutAnalysis_Low(Double.parseDouble(ECutAnalysis_Low)); + String bUpdateCal_G = mapSetting.get(Setting.BUPDATECAL_G); + setting.setBUpdateCal(StrUtil.equals(bUpdateCal_G, "1")); + } + String EnergyTolerance = mapSetting.get(Setting.ENERGYTOLERANCE); + if (StrUtil.isNotBlank(EnergyTolerance)) + setting.setEnergyTolerance(Double.parseDouble(EnergyTolerance)); + String KeepCalPeakSearchPeaks = mapSetting.get(Setting.KEEPCALPEAKSERCHPEAKS); + setting.setKeepCalPeakSearchPeaks(StrUtil.equals(KeepCalPeakSearchPeaks,"1")); + String k_alpha = mapSetting.get(Setting.K_ALPHA); + if (StrUtil.isNotBlank(k_alpha)) + setting.setK_alpha(Double.parseDouble(k_alpha)); + String k_back = mapSetting.get(Setting.K_BACK); + if (StrUtil.isNotBlank(k_back)) + setting.setK_back(Double.parseDouble(k_back)); + String k_beta = mapSetting.get(Setting.K_BETA); + if (StrUtil.isNotBlank(k_beta)) + setting.setK_beta(Double.parseDouble(k_beta)); + String PSS_low = mapSetting.get(Setting.PSS_LOW); + if (StrUtil.isNotBlank(PSS_low)) + setting.setPss_low(Double.parseDouble(PSS_low)); + String RiskLevelK = mapSetting.get(Setting.RISKLEVELK); + if (StrUtil.isNotBlank(RiskLevelK)) + setting.setRiskLevelK(Double.parseDouble(RiskLevelK)); + } + } + + private GardsAnalyses toAnalysis(GStoreMiddleProcessData middleData){ + GardsAnalyses gardsAnalyses = new GardsAnalyses(); + String dateTime = DateConstant.DATE_BIAS_TIME; + String analysisBegin = middleData.getAnalyses_analysisBegin(); + Date analysis_Begin = DateUtil.parse(analysisBegin, dateTime) + .toJdkDate(); + gardsAnalyses.setAnalysisBegin(analysis_Begin); + String analysisEnd = middleData.getAnalyses_analysisEnd(); + Date analysis_End = DateUtil.parse(analysisEnd, dateTime) + .toJdkDate(); + gardsAnalyses.setAnalysisEnd(analysis_End); + gardsAnalyses.setType(middleData.getAnalyses_type()); + gardsAnalyses.setSoftware(middleData.getAnalyses_software()); + gardsAnalyses.setSwVersion(middleData.getAnalyses_swVersion()); + gardsAnalyses.setAnalyst(middleData.getAnalyses_analyst()); + gardsAnalyses.setComments(middleData.getAnalyses_comments()); + gardsAnalyses.setSearchStartChannel((int)middleData.getAnalyses_searchStartChannel()); + gardsAnalyses.setSearchEndChannel((int)middleData.getAnalyses_searchEndChannel()); + gardsAnalyses.setSearchThreshold(middleData.getAnalyses_searchThreshold()); + gardsAnalyses.setNumberOfPeaks((int) middleData.getAnalyses_numberOfPeaks()); + gardsAnalyses.setTotalCounts((float) middleData.getAnalyses_totalCounts()); + gardsAnalyses.setBaselinePath(middleData.getAnalyses_baseline_filePath()); + gardsAnalyses.setLcPath(middleData.getAnalyses_lc_filePath()); + gardsAnalyses.setScacPath(middleData.getAnalyses_scac_filePath()); + gardsAnalyses.setLogPath(middleData.getAnalyses_LogPath()); + gardsAnalyses.setReportPath(middleData.getAnalyses_ReportPath()); + return gardsAnalyses; + } + + /* public List mapFields(T1 source, T2 tartget, String baseLine, Map fieldMap) { + try { + List result = new ArrayList<>(); + Class sourceClass = source.getClass(); + boolean isNumber = NumberUtil.isNumber(baseLine); + int total; + if (isNumber){ + total = Integer.parseInt(baseLine); + }else { + Field declaredField = sourceClass.getDeclaredField(baseLine); + declaredField.setAccessible(true); + List baseList = (List) declaredField.get(source); + if (CollUtil.isEmpty(baseList)) + return result; + total = baseList.size(); + } + Class tartgetClass = (Class) tartget.getClass(); + Field[] sourceFields = sourceClass.getDeclaredFields(); + for (int i = 0; i < total; i++) { + tartget = tartgetClass.newInstance(); + for (Field sourceField : sourceFields) { + sourceField.setAccessible(true); + List sourceList = (List) sourceField.get(source); + if (CollUtil.isEmpty(sourceList)) + continue; + if (sourceList.size() <= i) + continue; + String value = sourceList.get(i); + if (StrUtil.isNotBlank(value)){ + String sourceFieldName = sourceField.getName(); + String targetFieldName = fieldMap.get(sourceFieldName); + targetFieldName = StrUtil.isBlank(targetFieldName) ? sourceFieldName : targetFieldName; + Field tartgetField = tartgetClass.getDeclaredField(targetFieldName); + tartgetField.setAccessible(true); + Class type = tartgetField.getType(); + if (type == String.class) { + tartgetField.set(tartget, value); + } else if (type == Integer.class || type == int.class) { + // 避免类似0.000的String值转Integer时NumberFormatException + tartgetField.set(tartget, Double.valueOf(value).intValue()); + } else if (type == Double.class || type == double.class) { + tartgetField.set(tartget, Double.valueOf(value)); + } else if (type == Boolean.class || type == boolean.class) { + tartgetField.set(tartget, Boolean.valueOf(value)); + } + } + } + result.add(tartget); + } + return result; + } catch (Exception e) { + e.printStackTrace(); + return new ArrayList<>(); + } + }*/ + + public List mapFields(T1 source, T2 tartget, String baseLine, Map fieldMap) { + try { + List result = new ArrayList<>(); + Class sourceClass = source.getClass(); + boolean isNumber = NumberUtil.isNumber(baseLine); + int total; + if (isNumber){ + total = Integer.parseInt(baseLine); + }else { + Field declaredField = sourceClass.getDeclaredField(baseLine); + declaredField.setAccessible(true); + List baseList = (List) declaredField.get(source); + if (CollUtil.isEmpty(baseList)) + return result; + total = baseList.size(); + } + Class tartgetClass = (Class) tartget.getClass(); + Field[] sourceFields = sourceClass.getDeclaredFields(); + for (int i = 0; i < total; i++) { + tartget = tartgetClass.newInstance(); + for (Field sourceField : sourceFields) { + try { + sourceField.setAccessible(true); + List sourceList = (List) sourceField.get(source); + if (CollUtil.isEmpty(sourceList)) + continue; + if (sourceList.size() <= i) + continue; + String value = sourceList.get(i); + if (StrUtil.isNotBlank(value)){ + String sourceFieldName = sourceField.getName(); + String targetFieldName = fieldMap.get(sourceFieldName); + targetFieldName = StrUtil.isBlank(targetFieldName) ? sourceFieldName : targetFieldName; + Field tartgetField = tartgetClass.getDeclaredField(targetFieldName); + tartgetField.setAccessible(true); + Class type = tartgetField.getType(); + if (type == String.class) { + tartgetField.set(tartget, value); + } else if (type == Integer.class || type == int.class) { + // 避免类似0.000的String值转Integer时NumberFormatException + tartgetField.set(tartget, Double.valueOf(value).intValue()); + } else if (type == Double.class || type == double.class) { + tartgetField.set(tartget, Double.valueOf(value)); + } else if (type == Boolean.class || type == boolean.class) { + tartgetField.set(tartget, Boolean.valueOf(value)); + } + } + }catch (Exception e){ + log.error("Sample_G_Analysis.mapFields()值映射异常: {}", e.getMessage()); + } + } + result.add(tartget); + } + return result; + } catch (Exception e) { + e.printStackTrace(); + return new ArrayList<>(); + } + } + + private void setPHDFile(PHDFile... phdFiles) { + for (PHDFile phdFile : phdFiles) { + String filePath = phdFile.getTmpFilePath(); + EnergySpectrumStruct spectrumStruct = EnergySpectrumHandler.getSourceData(filePath); + HeaderBlock headerBlock = new HeaderBlock(); + BeanUtil.copyProperties(spectrumStruct, headerBlock); + phdFile.setHeader(headerBlock); + + CollectionBlock collectionBlock = new CollectionBlock(); + BeanUtil.copyProperties(spectrumStruct, collectionBlock); + phdFile.setCollect(collectionBlock); + + // MessageInfo + MessageInfo messageInfo = new MessageInfo(); + BeanUtil.copyProperties(spectrumStruct, messageInfo); + phdFile.setMsgInfo(messageInfo); + // AcquisitionBlock + AcquisitionBlock acquisitionBlock = new AcquisitionBlock(); + BeanUtil.copyProperties(spectrumStruct, acquisitionBlock); + phdFile.setAcq(acquisitionBlock); + // GSpectrumBlock + GSpectrumBlock gSpectrumBlock = new GSpectrumBlock(); + BeanUtil.copyProperties(spectrumStruct, gSpectrumBlock); + phdFile.setSpec(gSpectrumBlock); + // ProcessingBlock + ProcessingBlock processingBlock = new ProcessingBlock(); + BeanUtil.copyProperties(spectrumStruct, processingBlock); + phdFile.setProcess(processingBlock); + // CalibrationBlock + CalibrationBlock calibrationBlock = new CalibrationBlock(); + BeanUtil.copyProperties(spectrumStruct, calibrationBlock); + phdFile.setCalibration(calibrationBlock); + // SampleBlock + SampleBlock sampleBlock = new SampleBlock(); + BeanUtil.copyProperties(spectrumStruct, sampleBlock); + phdFile.setSampleBlock(sampleBlock); + // CertificateBlock + CertificateBlock certificateBlock = new CertificateBlock(); + BeanUtil.copyProperties(spectrumStruct, certificateBlock); + phdFile.setCertificate(certificateBlock); + } + } +} diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/spectrum/SamplephdSpectrum.java b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/spectrum/SamplephdSpectrum.java index 1f7432ac..113d7765 100644 --- a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/spectrum/SamplephdSpectrum.java +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/spectrum/SamplephdSpectrum.java @@ -116,5 +116,9 @@ public class SamplephdSpectrum extends AbstractS_D_Q_G_SpectrumHandler { Sample_G_Analysis sample_g_analysis = new Sample_G_Analysis(this, super.sourceData, super.spectrumServiceQuotes, super.sampleData); sample_g_analysis.analysis(); } + if (this.sourceData.system_type.equals(SystemType.SELFSTATION.getType())) { + Sample_C_Analysis sample_c_analysis = new Sample_C_Analysis(this, super.sourceData, super.spectrumServiceQuotes, super.sampleData); + sample_c_analysis.analysis(); + } } } diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/spectrum/SpectrumServiceQuotes.java b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/spectrum/SpectrumServiceQuotes.java index df200c2f..7057fc44 100644 --- a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/spectrum/SpectrumServiceQuotes.java +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/spectrum/SpectrumServiceQuotes.java @@ -6,6 +6,7 @@ import org.jeecg.common.properties.*; import org.jeecg.common.util.NameStandUtil; import org.jeecg.common.util.RedisStreamUtil; import org.jeecg.common.util.RedisUtil; +import org.jeecg.common.util.SelfUtil; import org.jeecg.modules.datasource.OraDataSourceProperties; import org.jeecg.modules.service.*; import org.springframework.context.ApplicationContext; @@ -88,11 +89,12 @@ public class SpectrumServiceQuotes { private final IGardsGPSDataService gardsGPSDataService; + private final SelfUtil selfStationUtil; + /** * 原始库插入数据锁 */ private final Object originalLibraryLock = new Object(); private final BatchesCounter batchesCounter; - } diff --git a/jeecg-module-beta-gamma-analyser/src/main/java/org/jeecg/common/util/GammaFileUtil.java b/jeecg-module-beta-gamma-analyser/src/main/java/org/jeecg/common/util/GammaFileUtil.java index 97b7889c..83f8747e 100644 --- a/jeecg-module-beta-gamma-analyser/src/main/java/org/jeecg/common/util/GammaFileUtil.java +++ b/jeecg-module-beta-gamma-analyser/src/main/java/org/jeecg/common/util/GammaFileUtil.java @@ -2,6 +2,7 @@ package org.jeecg.common.util; import cn.hutool.core.io.FileUtil; import cn.hutool.core.util.ObjectUtil; +import cn.hutool.core.util.StrUtil; import com.alibaba.fastjson.JSON; import com.baomidou.mybatisplus.core.toolkit.CollectionUtils; import com.baomidou.mybatisplus.core.toolkit.StringPool; @@ -3178,8 +3179,9 @@ public class GammaFileUtil extends AbstractLogOrReport { boolean bRet=true; //标准名称规范化 String dataType = fileAnlyse.getMsgInfo().getData_type(); + String systemType = fileAnlyse.getHeader().getSystem_type(); String subDirSavePath = ""; - subDirSavePath+=nameStandUtil.GetSysTemSubdir(fileAnlyse.getHeader().getSystem_type()); + subDirSavePath+=nameStandUtil.GetSysTemSubdir(systemType); subDirSavePath+=nameStandUtil.GetDateTypeSubdir(dataType); Map fileNames = nameStandUtil.NameStandard(fileAnlyse); String lcName = fileNames.get("lc"); @@ -3212,7 +3214,8 @@ public class GammaFileUtil extends AbstractLogOrReport { anylseBegin = DateUtils.formatDate(new Date(), "yyyy/MM/dd HH:mm:ss"); bRet = AnalyseSpectrum(fileAnlyse,nucline); if (bRet) { - RunQC(fileAnlyse); + if (!StrUtil.equals(systemType, SystemType.SELFSTATION.getType())) + RunQC(fileAnlyse); fileAnlyse.setEfficiencyParam(fileAnlyse.getUsedEffiPara().getP()); fileAnlyse.setEfficiencyEnergy(fileAnlyse.getUsedEffiKD().getG_energy()); fileAnlyse.setEfficiencyCurRow(0); @@ -3316,7 +3319,7 @@ public class GammaFileUtil extends AbstractLogOrReport { } //gards_ calibration_pairs Efficiency - middleData.calibration_pairs_sample_type = fileAnlyse.getHeader().getSystem_type(); + middleData.calibration_pairs_sample_type = systemType; if(fileAnlyse.getUsedEffiKD() != null && fileAnlyse.getUsedEffiKD().getG_energy().size() != 0) { middleData.calibration_pairs_EF_Caltype = CalType.EFFICIENCY_CAL.getType(); middleData.calibration_pairs_EF_Input = fileAnlyse.getUsedEffi(); @@ -3390,7 +3393,7 @@ public class GammaFileUtil extends AbstractLogOrReport { // gards_ calibration 数据表 //拼写刻度字符串 //获取刻度描述字符串 - middleData.calibration_sample_type = fileAnlyse.getHeader().getSystem_type(); + middleData.calibration_sample_type = systemType; String coeffEnergy = ""; String uncerEnergy = ""; String funcDefEnergy = ""; @@ -3805,7 +3808,7 @@ public class GammaFileUtil extends AbstractLogOrReport { middleData.sample_stationID = fileAnlyse.getHeader().getSite_code(); middleData.sample_detectID = fileAnlyse.getHeader().getDetector_code(); middleData.sample_Geometry = fileAnlyse.getHeader().getSample_geometry(); - middleData.sample_Type = fileAnlyse.getHeader().getSystem_type(); + middleData.sample_Type = systemType; middleData.setting_specSetup = fileAnlyse.getUsedSetting(); middleData.Collection_Station_Comments = StringUtils.isNotBlank(fileAnlyse.getOriTotalCmt())?fileAnlyse.getOriTotalCmt():""; middleData.NDC_Analysis_General_Comments = StringUtils.isNotBlank(fileAnlyse.getTotalCmt())?fileAnlyse.getTotalCmt():""; diff --git a/jeecg-module-beta-gamma-analyser/src/main/java/org/jeecg/common/util/SelfUtil.java b/jeecg-module-beta-gamma-analyser/src/main/java/org/jeecg/common/util/SelfUtil.java new file mode 100644 index 00000000..c261c8e5 --- /dev/null +++ b/jeecg-module-beta-gamma-analyser/src/main/java/org/jeecg/common/util/SelfUtil.java @@ -0,0 +1,348 @@ +package org.jeecg.common.util; + +import cn.hutool.core.util.StrUtil; +import com.baomidou.mybatisplus.core.toolkit.CollectionUtils; +import com.baomidou.mybatisplus.core.toolkit.StringPool; +import org.jeecg.modules.base.enums.CalName; +import org.jeecg.modules.entity.vo.*; +import org.jeecg.modules.native_jni.EnergySpectrumHandler; +import org.jeecg.modules.native_jni.struct.EnergySpectrumStruct; +import org.springframework.beans.BeanUtils; +import org.springframework.stereotype.Component; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.PrintWriter; +import java.text.DecimalFormat; +import java.util.Date; +import java.util.LinkedList; +import java.util.List; +import java.util.Objects; + +@Component +public class SelfUtil { + + public List roiList(Integer startChannel, Integer endChannel, long betaChannels, long gammaChannels, List h_counts) { + // g_counts + List counts = new LinkedList<>(); + //存储同一列不同行加和后的数量 + List sumList = new LinkedList<>(); + //遍历所有列 + for (int i=0; i 0 && index < h_counts.size()) { + count = h_counts.get(index); + } + sum+=count; + } + counts.add(sum); + } + return counts; + } + + /** + * 根据ROI卡出来的Gamma数据生成新的GammaPHD文件 + * @param pathName 文件存储路径 + * @param fileName GammaPHD名称 + * @param struct BetaPHD内容 + * @param g_counts ROI卡出来的Gamma数据 + */ + public void createGammaFile(String pathName,String fileName, EnergySpectrumStruct struct, List g_counts) { + File file = new File(pathName + "\\" + fileName); + // 创建PrintWriter对象 + PrintWriter out = null; + DecimalFormat decimalFormat = new DecimalFormat("0.000000"); + try { + out = new PrintWriter(file); + out.println("BEGIN IMS2.0"); + out.println("MSG_TYPE DATA"); + // todo msg_type用的不对，dll没解析出这个字段 + out.println("MSG_ID " + struct.msg_id + " " + struct.msg_type + "\n" + "DATA_TYPE " + struct.data_type); + out.println("#Header 3"); + // 解析出的Gamma谱 系统类型暂时使用G + out.println(struct.site_code + " " + struct.detector_code + " C " + + struct.sample_geometry + " " + struct.spectrum_quantity); + out.println(struct.sample_ref_id); + out.println(struct.measurement_id + " " + struct.detector_bk_measurement_id + " 0"); + out.println(struct.transmit_date + " " + struct.transmit_time); + out.println("#Collection"); + out.println(struct.collection_start_date + " " + struct.collection_start_time + " " + + struct.collection_stop_date + " " + struct.collection_stop_time + " " + + decimalFormat.format(struct.air_volume)); + out.println("#Acquisition"); + out.println(struct.acquisition_start_date + " " + struct.acquisition_start_time + " " + + decimalFormat.format(struct.acquisition_real_time) + " " + + decimalFormat.format(struct.acquisition_live_time)); + out.println("#g_Energy"); + + + format(struct.g_energy, struct.g_centroid_channel, struct.g_uncertainty, out); + out.println("#g_Resolution"); + format(struct.g_r_energy, struct.g_r_FWHM, struct.g_r_uncertainty, out); + out.println("#g_Efficiency"); + format(struct.g_e_energy, struct.g_e_efficiency, struct.g_e_uncertainty, out); + out.println("#g_Spectrum"); + // num_g_channel 根据g_counts数量得来和PHD写的数字没有关系；g_energy_span是PHD写的值 + out.println(struct.num_g_channel + " " + struct.g_energy_span); + // 存储前一个数字 + String beforeStr = ""; + for (int i = 0; i < g_counts.size(); i++) { + String str = g_counts.get(i).toString(); + if(i % 5 == 0) { + if (i == 0) { + out.printf((i+1)+""); + } else { + out.printf("\n" + (i+1) ); + } + beforeStr = i+""; + } + + if(StrUtil.isEmpty(beforeStr)){ + beforeStr = str; + } + // 根据前一个字符长度计算需要的空格 + out.printf("%" + (str.length() + (6 - beforeStr.length()))+ "s" , g_counts.get(i)); + if(i == g_counts.size() - 1) { + out.println(); + } + beforeStr = str; + } + out.print("STOP"); + } catch (FileNotFoundException e) { + throw new RuntimeException(e); + } finally { + if (null != out) { + out.close(); + } + } + } + + /** + * 数据格式化 + * @param aList 第一列数据 + * @param bList 第二列数据 + * @param cList 第三列数据 + * @param out + */ + private static void format(List aList, List bList,List cList,PrintWriter out) { + for (int i = 0; i < aList.size(); i++) { + DecimalFormat decimalFormat = new DecimalFormat("0.000000"); + String a = decimalFormat.format(aList.get(i)); + String b = decimalFormat.format(bList.get(i)); + String c = decimalFormat.format(cList.get(i)); + out.print(a); + out.printf("%" + ( b.length() + (17 - a.length())) + "s", b); + out.printf("%" + ( c.length() + (17 - b.length())) + "s", c+"\n"); + } + } + + /** + * 根据DLL解析GammaPHD内容 得到PHDFile实体 + * @param fileName + * @param pathName + * @return + */ + public PHDFile getGammaPHD(String fileName, String pathName) { + PHDFile phd = new PHDFile(); + phd.setFilepath(pathName); + phd.setFilename(fileName); + File file = new File(pathName + StringPool.SLASH + fileName); + phd.setTmpFilePath(file.getAbsolutePath()); + try { + //读取文件信息 + EnergySpectrumStruct struct = EnergySpectrumHandler.getSourceData(file.getAbsolutePath()); + //MsgInfo + phd.getMsgInfo().setMsg_id(struct.msg_id); + phd.getMsgInfo().setMsg_type(struct.msg_type); + phd.getMsgInfo().setData_type(struct.data_type); + //Header + phd.getHeader().setDesignator(struct.designator); + phd.getHeader().setSite_code(struct.site_code); + phd.getHeader().setDetector_code(struct.detector_code); + phd.getHeader().setSystem_type(struct.system_type); + phd.getHeader().setSample_geometry(struct.sample_geometry); + phd.getHeader().setSpectrum_quantity(struct.spectrum_quantity); + phd.getHeader().setSample_ref_id(struct.sample_ref_id); + phd.getHeader().setMeasurement_id(struct.measurement_id); + phd.getHeader().setDetector_bk_measurement_id(struct.detector_bk_measurement_id); + phd.getHeader().setGas_bk_measurement_id(struct.gas_bk_measurement_id); + phd.getHeader().setTransmit_date(struct.transmit_date); + phd.getHeader().setTransmit_time(struct.transmit_time); + //Comment + phd.setOriTotalCmt(struct.comment); + //Collection + if (StrUtil.isNotBlank(struct.collection_start_date) && StrUtil.isNotBlank(struct.collection_start_time) + && StrUtil.isNotBlank(struct.collection_stop_date) && StrUtil.isNotBlank(struct.collection_stop_time) + && Objects.nonNull(struct.air_volume)) { + phd.getCollect().setCollection_start_date(struct.collection_start_date); + phd.getCollect().setCollection_start_time(struct.collection_start_time); + phd.getCollect().setCollection_stop_date(struct.collection_stop_date); + phd.getCollect().setCollection_stop_time(struct.collection_stop_time); + phd.getCollect().setAir_volume(struct.air_volume); + if (phd.getCollect().getCollection_start_time().indexOf('.') < 0) { + phd.getCollect().setCollection_start_time(phd.getCollect().getCollection_start_time() + ".0"); + } + if (phd.getCollect().getCollection_stop_time().indexOf('.') < 0) { + phd.getCollect().setCollection_stop_time(phd.getCollect().getCollection_stop_time() + ".0"); + } + } else { + phd.getCollect().setAir_volume(0.0); + } + //Acquisition + if (StrUtil.isNotBlank(struct.acquisition_start_date) && StrUtil.isNotBlank(struct.acquisition_start_time) + && Objects.nonNull(struct.acquisition_real_time) && Objects.nonNull(struct.acquisition_live_time)) { + phd.getAcq().setAcquisition_start_date(struct.acquisition_start_date); + phd.getAcq().setAcquisition_start_time(struct.acquisition_start_time); + phd.getAcq().setAcquisition_real_time(struct.acquisition_real_time); + phd.getAcq().setAcquisition_live_time(struct.acquisition_live_time); + if (phd.getAcq().getAcquisition_start_time().indexOf('.') < 0) { + phd.getAcq().setAcquisition_start_time(phd.getAcq().getAcquisition_start_time() + ".0"); + } + } else { + phd.getAcq().setAcquisition_live_time(0.0); + phd.getAcq().setAcquisition_real_time(0.0); + } + //Processing + if (Objects.nonNull(struct.sample_volume_of_Xe) && Objects.nonNull(struct.uncertainty_1) + && Objects.nonNull(struct.Xe_collection_yield) && Objects.nonNull(struct.uncertainty_2) + && StrUtil.isNotBlank(struct.archive_bottle_id)) { + phd.getProcess().setSample_volume_of_Xe(struct.sample_volume_of_Xe); + phd.getProcess().setUncertainty_1(struct.uncertainty_1); + phd.getProcess().setXe_collection_yield(struct.Xe_collection_yield); + phd.getProcess().setUncertainty_2(struct.uncertainty_2); + phd.getProcess().setArchive_bottle_id(struct.archive_bottle_id); + } else { + phd.getProcess().setSample_volume_of_Xe(0.0); + phd.getProcess().setXe_collection_yield(0.0); + phd.getProcess().setUncertainty_1(0.0); + phd.getProcess().setUncertainty_2(0.0); + } + //Sample + if (Objects.nonNull(struct.dimension_1) && Objects.nonNull(struct.dimension_2)) { + phd.getSampleBlock().setDimension_1(struct.dimension_1); + phd.getSampleBlock().setDimension_2(struct.dimension_2); + } else { + phd.getSampleBlock().setDimension_1(0.0); + phd.getSampleBlock().setDimension_2(0.0); + } + //Calibration + if (StrUtil.isNotBlank(struct.date_calibration) && StrUtil.isNotBlank(struct.time_calibration)) { + phd.getCalibration().setDate_calibration(struct.date_calibration); + phd.getCalibration().setTime_calibration(struct.time_calibration); + } + //Certificate + if (Objects.nonNull(struct.total_source_activity) && StrUtil.isNotBlank(struct.assay_date) + && StrUtil.isNotBlank(struct.assay_time) && StrUtil.isNotBlank(struct.units_activity) + && CollectionUtils.isNotEmpty(struct.nuclide_name) + && CollectionUtils.isNotEmpty(struct.half_life_time) && CollectionUtils.isNotEmpty(struct.time_unit) + && CollectionUtils.isNotEmpty(struct.activity_nuclide_time_assay) && CollectionUtils.isNotEmpty(struct.uncertainty) + && CollectionUtils.isNotEmpty(struct.cer_g_energy) && CollectionUtils.isNotEmpty(struct.g_intensity) + && CollectionUtils.isNotEmpty(struct.electron_decay_mode) && CollectionUtils.isNotEmpty(struct.maximum_energy) + && CollectionUtils.isNotEmpty(struct.intensity_b_particle) && Objects.nonNull(struct.record_count)) { + phd.getCertificate().setTotal_source_activity(struct.total_source_activity); + phd.getCertificate().setAssay_date(struct.assay_date); + phd.getCertificate().setAssay_time(struct.assay_time); + phd.getCertificate().setUnits_activity(struct.units_activity); + phd.getCertificate().setNuclide_name(struct.nuclide_name); + phd.getCertificate().setHalf_life_time(struct.half_life_time); + phd.getCertificate().setTime_unit(struct.time_unit); + phd.getCertificate().setActivity_nuclide_time_assay(struct.activity_nuclide_time_assay); + phd.getCertificate().setUncertainty(struct.uncertainty); + phd.getCertificate().setG_energy(struct.cer_g_energy); + phd.getCertificate().setG_intensity(struct.g_intensity); + phd.getCertificate().setElectron_decay_mode(struct.electron_decay_mode); + phd.getCertificate().setMaximum_energy(struct.maximum_energy); + phd.getCertificate().setIntensity_b_particle(struct.intensity_b_particle); + phd.getCertificate().setRecord_count(struct.record_count); + } + //g_Spectrum + if (Objects.nonNull(struct.num_g_channel) && Objects.nonNull(struct.g_energy_span) + && Objects.nonNull(struct.g_begin_channel) && CollectionUtils.isNotEmpty(struct.g_counts)) { + phd.getSpec().setNum_g_channel(struct.g_counts.size()); // todo 原Num_g_channel有误 + phd.getSpec().setG_energy_span(struct.g_energy_span); + phd.getSpec().setBegin_channel(struct.g_begin_channel); + phd.getSpec().setCounts(struct.g_counts); + int i = 0; + for (; i < phd.getSpec().getNum_g_channel(); i++) { + if (phd.getSpec().getCounts().get(i) > 0) { + break; + } + } + if (i == phd.getSpec().getNum_g_channel()) { + phd.setValid(false); + } + } + //g_Energy + if (CollectionUtils.isNotEmpty(struct.g_energy) && CollectionUtils.isNotEmpty(struct.g_centroid_channel) && + CollectionUtils.isNotEmpty(struct.g_uncertainty) && Objects.nonNull(struct.g_record_count)) { + GEnergyBlock gEnergyBlock = new GEnergyBlock(); + gEnergyBlock.setG_energy(struct.g_energy); + gEnergyBlock.setCentroid_channel(struct.g_centroid_channel); + gEnergyBlock.setUncertainty(struct.g_uncertainty); + gEnergyBlock.setRecord_count(struct.g_record_count); + phd.getMapEnerKD().put(CalName.CalPHD.getType(), gEnergyBlock); + } + //g_Resolution + if (CollectionUtils.isNotEmpty(struct.g_r_energy) && CollectionUtils.isNotEmpty(struct.g_r_FWHM) && + CollectionUtils.isNotEmpty(struct.g_r_uncertainty) && Objects.nonNull(struct.g_r_record_count)) { + GResolutionBlock gResolutionBlock = new GResolutionBlock(); + gResolutionBlock.setG_energy(struct.g_r_energy); + gResolutionBlock.setFWHM(struct.g_r_FWHM); + gResolutionBlock.setUncertainty(struct.g_r_uncertainty); + gResolutionBlock.setRecord_count(struct.g_r_record_count); + phd.getMapResoKD().put(CalName.CalPHD.getType(), gResolutionBlock); + } + //g_Efficiency + if (CollectionUtils.isNotEmpty(struct.g_e_energy) && CollectionUtils.isNotEmpty(struct.g_e_efficiency) && + CollectionUtils.isNotEmpty(struct.g_e_uncertainty) && Objects.nonNull(struct.g_e_record_count)) { + GEfficiencyBlock gEfficiencyBlock = new GEfficiencyBlock(); + gEfficiencyBlock.setG_energy(struct.g_e_energy); + gEfficiencyBlock.setEfficiency(struct.g_e_efficiency); + gEfficiencyBlock.setUncertainty(struct.g_e_uncertainty); + gEfficiencyBlock.setRecord_count(struct.g_e_record_count); + phd.getMapEffiKD().put(CalName.CalPHD.getType(), gEfficiencyBlock); + } + //TotalEff + if (CollectionUtils.isNotEmpty(struct.t_g_energy) && CollectionUtils.isNotEmpty(struct.total_efficiency) && + CollectionUtils.isNotEmpty(struct.t_uncertainty) && Objects.nonNull(struct.t_record_count)) { + TotaleffBlock totaleffBlock = new TotaleffBlock(); + totaleffBlock.setG_energy(struct.t_g_energy); + totaleffBlock.setTotal_efficiency(struct.total_efficiency); + totaleffBlock.setUncertainty(struct.t_uncertainty); + totaleffBlock.setRecord_count(struct.t_record_count); + phd.getMapTotEKD().put(CalName.CalPHD.getType(), totaleffBlock); + } + + // 初始化默认分析设置 + if(phd.getHeader().getSystem_type().equalsIgnoreCase("P")) { + phd.getSetting().setECutAnalysis_Low(35.0); + phd.getSetting().setBUpdateCal(true); + } + if (StrUtil.isNotBlank(phd.getCollect().getCollection_start_date()) + && StrUtil.isNotBlank(phd.getCollect().getCollection_start_time())) { + phd.getSetting().setRefTime_conc(DateUtils.parseDate(phd.getCollect().getCollection_start_date() + + StringPool.SPACE + phd.getCollect().getCollection_start_time())); + } + if (StrUtil.isNotBlank(phd.getAcq().getAcquisition_start_date()) && StrUtil.isNotBlank(phd.getAcq().getAcquisition_start_time())) { + phd.getSetting().setRefTime_act(DateUtils.parseDate(phd.getAcq().getAcquisition_start_date() + + StringPool.SPACE + phd.getAcq().getAcquisition_start_time())); + } + SpecSetup usedSetting = new SpecSetup(); + BeanUtils.copyProperties(phd.getSetting(), usedSetting); + phd.setUsedSetting(usedSetting); + + phd.setBAnalyed(false); + phd.setAnaly_start_time(DateUtils.formatDate(new Date(), "yyyy/MM/dd HH:mm:ss")); + + } catch (Exception e) { + throw new RuntimeException(e); + } + return phd; + } +} diff --git a/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/common/util/SelfStationUtil.java b/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/common/util/SelfStationUtil.java index d3cb9cef..ddb57f0c 100644 --- a/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/common/util/SelfStationUtil.java +++ b/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/common/util/SelfStationUtil.java @@ -401,6 +401,30 @@ public class SelfStationUtil extends AbstractLogOrReport { return map; } + public List roiList(Integer startChannel, Integer endChannel, long betaChannels, long gammaChannels, List h_counts) { + // g_counts + List counts = new LinkedList<>(); + //存储同一列不同行加和后的数量 + List sumList = new LinkedList<>(); + //遍历所有列 + for (int i=0; i 0 && index < h_counts.size()) { + count = h_counts.get(index); + } + sum+=count; + } + counts.add(sum); + } + return counts; + } + public String UpdateEquationEnergy(ParameterInfo m_curParam) { String equation =""; int p_size = m_curParam.getP().size()-1;