diff --git a/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/CommonConstant.java b/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/CommonConstant.java index 27b960f4..7c8c8423 100644 --- a/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/CommonConstant.java +++ b/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/CommonConstant.java @@ -30,7 +30,7 @@ public interface CommonConstant { * 系统日志类型： 登录 */ int LOG_TYPE_1 = 1; - + /** * 系统日志类型： 操作 */ @@ -40,38 +40,38 @@ public interface CommonConstant { * 操作日志类型： 查询 */ int OPERATE_TYPE_1 = 1; - + /** * 操作日志类型： 添加 */ int OPERATE_TYPE_2 = 2; - + /** * 操作日志类型： 更新 */ int OPERATE_TYPE_3 = 3; - + /** * 操作日志类型： 删除 */ int OPERATE_TYPE_4 = 4; - + /** * 操作日志类型： 倒入 */ int OPERATE_TYPE_5 = 5; - + /** * 操作日志类型： 导出 */ int OPERATE_TYPE_6 = 6; - - + + /** {@code 500 Server Error} (HTTP/1.0 - RFC 1945) */ Integer SC_INTERNAL_SERVER_ERROR_500 = 500; /** {@code 200 OK} (HTTP/1.0 - RFC 1945) */ Integer SC_OK_200 = 200; - + /**访问权限认证未通过 510*/ Integer SC_JEECG_NO_AUTHZ=510; @@ -94,7 +94,7 @@ public interface CommonConstant { */ Integer MENU_TYPE_0 = 0; /** - * 1：子菜单 + * 1：子菜单 */ Integer MENU_TYPE_1 = 1; /** @@ -105,34 +105,34 @@ public interface CommonConstant { /**通告对象类型（USER:指定用户，ALL:全体用户）*/ String MSG_TYPE_UESR = "USER"; String MSG_TYPE_ALL = "ALL"; - + /**发布状态（0未发布，1已发布，2已撤销）*/ String NO_SEND = "0"; String HAS_SEND = "1"; String HAS_CANCLE = "2"; - + /**阅读状态（0未读，1已读）*/ String HAS_READ_FLAG = "1"; String NO_READ_FLAG = "0"; - + /**优先级（L低，M中，H高）*/ String PRIORITY_L = "L"; String PRIORITY_M = "M"; String PRIORITY_H = "H"; - + /** * 短信模板方式 0 .登录模板、1.注册模板、2.忘记密码模板 */ String SMS_TPL_TYPE_0 = "0"; String SMS_TPL_TYPE_1 = "1"; String SMS_TPL_TYPE_2 = "2"; - + /** * 状态(0无效1有效) */ String STATUS_0 = "0"; String STATUS_1 = "1"; - + /** * 同步工作流引擎1同步0不同步 */ @@ -144,7 +144,7 @@ public interface CommonConstant { */ String MSG_CATEGORY_1 = "1"; String MSG_CATEGORY_2 = "2"; - + /** * 是否配置菜单的数据权限 1是0否 */ @@ -157,7 +157,7 @@ public interface CommonConstant { Integer USER_UNFREEZE = 1; Integer USER_FREEZE = 2; Integer USER_QUIT = 3; - + /**字典翻译文本后缀*/ String DICT_TEXT_SUFFIX = "_dictText"; @@ -382,7 +382,7 @@ public interface CommonConstant { * https:// https协议 */ String HTTPS_PROTOCOL = "https://"; - + /** 部门表唯一key，id */ String DEPART_KEY_ID = "id"; /** 部门表唯一key，orgCode */ @@ -510,4 +510,14 @@ public interface CommonConstant { String BETA = "Beta"; String GAMMA = "Gamma"; + + /** + * 自动处理Gamma报告前缀 + */ + String REPORT_PREFIX_AUTO = "RNAUTO_"; + + /** + * 自动处理报告后缀 + */ + String REPORT_SUFFIX_AUTO = "_rpt"; } diff --git a/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/FileTypeEnum.java b/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/FileTypeEnum.java index b36c2f0e..adace180 100644 --- a/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/FileTypeEnum.java +++ b/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/FileTypeEnum.java @@ -26,7 +26,13 @@ public enum FileTypeEnum { flv(".flv","video","视频"), mp4(".mp4","video","视频"), zip(".zip","zip","压缩包"), - pdf(".pdf","pdf","pdf"); + pdf(".pdf","pdf","pdf"), + baseline(".baseline","baseline","基线数据"), + lc(".lc","lc","lc数据基线"), + scac(".scac","scac","scac数据"), + log(".log","log","日志"), + arr(".txt","arr","自动处理报告"), + rrr(".txt","rrr","人工交互分析报告"); private String type; private String value; diff --git a/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/SpectrumSystemType.java b/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/SpectrumSystemType.java new file mode 100644 index 00000000..86c72619 --- /dev/null +++ b/jeecg-boot-base-core/src/main/java/org/jeecg/common/constant/enums/SpectrumSystemType.java @@ -0,0 +1,22 @@ +package org.jeecg.common.constant.enums; + +/** + * 能谱 系统类型 + * @author: xiao + */ +public enum SpectrumSystemType { + + /** + * particulate + */ + P, + /** + * G :all other gas systems (high-resolution + * γ-spectrometry or 2-D β-γ coincidence detection) + */ + G, + /** + * gas with 3-D β-γ coincidence detection + */ + B; +} diff --git a/jeecg-boot-base-core/src/main/java/org/jeecg/common/properties/SpectrumPathProperties.java b/jeecg-boot-base-core/src/main/java/org/jeecg/common/properties/SpectrumPathProperties.java index 9c7155ff..9624cff0 100644 --- a/jeecg-boot-base-core/src/main/java/org/jeecg/common/properties/SpectrumPathProperties.java +++ b/jeecg-boot-base-core/src/main/java/org/jeecg/common/properties/SpectrumPathProperties.java @@ -1,10 +1,13 @@ package org.jeecg.common.properties; import lombok.Data; +import org.jeecg.common.constant.StringConstant; +import org.jeecg.common.constant.enums.FileTypeEnum; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component; import java.io.Serializable; +import java.time.LocalDate; import java.util.Map; /** @@ -55,4 +58,35 @@ public class SpectrumPathProperties implements Serializable { * 能谱文件存储路径以能谱系统类型/能谱类型为key，以存储路径为value */ private Map filePathMap; + + public String getSavePath(String fileType, String systemType, String dataType) { + // systemType dataTYpe year month fileName fileType + // Spectrum/Particulates /Samplephd /2023 /06 /RNAUTO_ARP01_001-20230603_1452_S_PREL_57371 .baseline + // Spectrum/Xenon/Spalax /Samplephd /2023 /09 /RNAUTO_CAX05_001-20230910_1528_S_FULL_37564 .baseline + StringBuilder path = new StringBuilder(); + + final int year = LocalDate.now().getYear(); + final int month = LocalDate.now().getMonth().getValue(); + + path.append(this.getRootPath()).append(StringConstant.SLASH); + + // 自动处理报告 + if (fileType.equals(FileTypeEnum.arr.getValue())) { + path.append(this.getArrPath()).append(StringConstant.SLASH); + } + // todo 人工交互分析报告地址 + if (fileType.equals(FileTypeEnum.rrr.getValue())) { + } + + // systemType + path.append(this.getFilePathMap().get(systemType)).append(StringConstant.SLASH); + // dataType + path.append(this.getFilePathMap().get(dataType)).append(StringConstant.SLASH); + // year + path.append(year).append(StringConstant.SLASH); + // month + path.append(month >= 10 ? month : "0" + month).append(StringConstant.SLASH); + + return path.toString(); + } } diff --git a/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/MyLogFormatUtil.java b/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/MyLogFormatUtil.java index ea298212..790558ae 100644 --- a/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/MyLogFormatUtil.java +++ b/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/MyLogFormatUtil.java @@ -304,6 +304,11 @@ public class MyLogFormatUtil { if(data.size() > 0) { List> tempData = new LinkedList<>(); // 行 + for(int row = 0; row < data.size(); row++) { + List columns = new LinkedList<>(); + columns.add(data.get(row).getAttribute()); + tempData.add(columns); + } for(int row = 0; row < data.get(0).getContext().size(); row++) { List columns = new LinkedList<>(); tempData.add(columns); diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/common/GammaFileUtil.java b/jeecg-module-auto-process/src/main/java/org/jeecg/common/GammaFileUtil.java new file mode 100644 index 00000000..752ef3d7 --- /dev/null +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/common/GammaFileUtil.java @@ -0,0 +1,4026 @@ +package org.jeecg.common; + +import com.baomidou.mybatisplus.core.toolkit.CollectionUtils; +import com.baomidou.mybatisplus.core.toolkit.StringPool; +import com.baomidou.mybatisplus.core.toolkit.StringUtils; +import org.apache.commons.io.FileUtils; +import org.apache.commons.net.ftp.FTPClient; +import org.apache.commons.net.ftp.FTPFile; +import org.ejml.simple.SimpleMatrix; +import org.jeecg.common.api.vo.Result; +import org.jeecg.common.properties.SpectrumPathProperties; +import org.jeecg.common.util.DateUtils; +import org.jeecg.common.util.FTPUtil; +import org.jeecg.modules.base.entity.configuration.GardsNuclLib; +import org.jeecg.modules.base.entity.configuration.GardsNuclLinesLib; +import org.jeecg.modules.base.entity.rnman.GardsAnalySetting; +import org.jeecg.modules.base.enums.CalName; +import org.jeecg.modules.base.enums.CalType; +import org.jeecg.modules.base.enums.MiddleDataType; +import org.jeecg.modules.eneity.*; +import org.jeecg.modules.entity.vo.*; +import org.jeecg.modules.mapper.SpectrumAnalysisMapper; +import org.jeecg.modules.native_jni.CalValuesHandler; +import org.jeecg.modules.native_jni.EnergySpectrumHandler; +import org.jeecg.modules.native_jni.struct.CalValuesOut; +import org.jeecg.modules.native_jni.struct.EnergySpectrumStruct; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Component; +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.io.InputStream; +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.text.DecimalFormat; +import java.text.NumberFormat; +import java.text.ParseException; +import java.util.*; +import java.util.stream.Collectors; + +@Component +public class GammaFileUtil { + + @Value("${parameter.filePath}") + private String parameterFilePath; + @Autowired + private FTPUtil ftpUtil; + @Autowired + private SpectrumPathProperties spectrumPathProperties; + @Autowired + private SpectrumAnalysisMapper spectrumAnalysisMapper; + @Autowired + private NameStandUtil nameStandUtil; + + public boolean loadFile(String pathName, String fileName, PHDFile phd, Result result){ + phd.setFilepath(pathName); + phd.setFilename(fileName); + //连接ftp + FTPClient ftpClient = ftpUtil.LoginFTP(); + if (Objects.isNull(ftpClient)){ + result.error500("ftp连接失败"); + return false; + } + //加载dll工具库 + System.loadLibrary("ReadPHDFile"); + try { + //切换被动模式 + ftpClient.enterLocalPassiveMode(); + ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE); + // 设置编码，当文件中存在中文且上传后文件乱码时可使用此配置项 + ftpClient.setControlEncoding("UTF-8"); + ftpClient.setFileTransferMode(FTPClient.STREAM_TRANSFER_MODE); + ftpClient.changeWorkingDirectory(pathName); + List ftpFiles = Arrays.asList(ftpClient.listFiles()); + ftpFiles = ftpFiles.stream().filter(item -> item.getName().equals(fileName)).collect(Collectors.toList()); + if (ftpFiles.size() == 0) { + result.error500("ftp获取文件数据失败"); + return false; + } + FTPFile ftpFile = ftpFiles.get(0); + if (Objects.nonNull(ftpFile)) { + InputStream inputStream = ftpClient.retrieveFileStream(ftpFile.getName()); + //声明一个临时文件 + File file = File.createTempFile("tmp", null); + //将ftp文件的输入流复制给临时文件 + FileUtils.copyInputStreamToFile(inputStream, file); + //读取文件信息 + 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 (StringUtils.isNotBlank(struct.collection_start_date) || StringUtils.isNotBlank(struct.collection_start_time) || StringUtils.isNotBlank(struct.collection_stop_date) || StringUtils.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 (StringUtils.isNotBlank(struct.acquisition_start_date) || StringUtils.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) || StringUtils.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 (StringUtils.isNotBlank(struct.date_calibration) || StringUtils.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) || StringUtils.isNotBlank(struct.assay_date) || StringUtils.isNotBlank(struct.assay_time) || StringUtils.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.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); + } + phd.getSetting().setRefTime_conc(DateUtils.parseDate(phd.getCollect().getCollection_start_date() + " " + phd.getCollect().getCollection_start_time().substring(0, phd.getCollect().getCollection_start_time().indexOf(StringPool.DOT)), "yyyy/MM/dd HH:mm:ss")); + phd.getSetting().setRefTime_act(DateUtils.parseDate(phd.getAcq().getAcquisition_start_date() + " " + phd.getAcq().getAcquisition_start_time().substring(0, phd.getAcq().getAcquisition_start_time().indexOf(StringPool.DOT)), "yyyy/MM/dd HH:mm:ss")); + phd.setUsedSetting(phd.getSetting()); + + phd.setBAnalyed(false); + phd.setAnaly_start_time(DateUtils.formatDate(new Date(), "yyyy/MM/dd HH:mm:ss")); + + } + }catch (IOException e) { + throw new RuntimeException(e); + } catch (ParseException e) { + throw new RuntimeException(e); + } finally { + try { + if (Objects.nonNull(ftpClient)){ + ftpClient.disconnect(); + } + } catch (IOException e) { + throw new RuntimeException(e); + } + } + return true; + } + + public void SetBaseInfo(PHDFile phd){ + String pathName = phd.getFilepath(); + String fileName = phd.getFilename(); + //文件名称需要加上自动处理的前缀以及修改不同的文件后缀名 + String subFileName = fileName.substring(0, fileName.lastIndexOf(StringPool.DOT)); + pathName = StringPool.SLASH + spectrumPathProperties.getRootPath() + StringPool.SLASH + pathName; + if(StringUtils.isNotBlank(subFileName)){ + //连接ftp + FTPClient ftpClient = ftpUtil.LoginFTP(); + if (Objects.isNull(ftpClient)){ + String warning = "ftp连接失败"; + } + try { + //切换被动模式 + ftpClient.enterLocalPassiveMode(); + ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE); + // 设置编码，当文件中存在中文且上传后文件乱码时可使用此配置项 + ftpClient.setControlEncoding("UTF-8"); + ftpClient.setFileTransferMode(FTPClient.STREAM_TRANSFER_MODE); + ftpClient.changeWorkingDirectory(pathName); + List ftpFiles = Arrays.asList(ftpClient.listFiles()); + String lcFileName = "RNAUTO_"+subFileName + ".lc"; + List lcFiles = ftpFiles.stream().filter(item -> item.getName().equals(lcFileName)).collect(Collectors.toList()); + if (CollectionUtils.isNotEmpty(lcFiles)){ + FTPFile lcFile = lcFiles.get(0); + if (Objects.nonNull(lcFile)){ + InputStream inputStream = ftpClient.retrieveFileStream(lcFile.getName()); + //声明一个临时文件 + File file = File.createTempFile("tmp", null); + //将ftp文件的输入流复制给临时文件 + FileUtils.copyInputStreamToFile(inputStream, file); + List readLines = FileUtils.readLines(file, "UTF-8"); + List vData = ReadLcScacInfo(readLines); + phd.setVLc(vData); + } + } + } catch (IOException e) { + throw new RuntimeException(e); + } finally { + try { + ftpClient.disconnect(); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + } + if(StringUtils.isNotBlank(subFileName)){ + //连接ftp + FTPClient ftpClient = ftpUtil.LoginFTP(); + if (Objects.isNull(ftpClient)){ + String warning = "ftp连接失败"; + } + try { + //切换被动模式 + ftpClient.enterLocalPassiveMode(); + ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE); + // 设置编码，当文件中存在中文且上传后文件乱码时可使用此配置项 + ftpClient.setControlEncoding("UTF-8"); + ftpClient.setFileTransferMode(FTPClient.STREAM_TRANSFER_MODE); + ftpClient.changeWorkingDirectory(pathName); + List ftpFiles = Arrays.asList(ftpClient.listFiles()); + String scacFileName = "RNAUTO_"+subFileName + ".scac"; + List scacFiles = ftpFiles.stream().filter(item -> item.getName().equals(scacFileName)).collect(Collectors.toList()); + if (CollectionUtils.isNotEmpty(scacFiles)){ + FTPFile scacFile = scacFiles.get(0); + if (Objects.nonNull(scacFile)){ + InputStream inputStream = ftpClient.retrieveFileStream(scacFile.getName()); + //声明一个临时文件 + File file = File.createTempFile("tmp", null); + //将ftp文件的输入流复制给临时文件 + FileUtils.copyInputStreamToFile(inputStream, file); + List readLines = FileUtils.readLines(file, "UTF-8"); + List vData = ReadLcScacInfo(readLines); + phd.setVScac(vData); + } + } + } catch (IOException e) { + throw new RuntimeException(e); + } finally { + try { + ftpClient.disconnect(); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + } + if(StringUtils.isNotBlank(subFileName)){ + //连接ftp + FTPClient ftpClient = ftpUtil.LoginFTP(); + if (Objects.isNull(ftpClient)){ + String warning = "ftp连接失败"; + } + try { + //切换被动模式 + ftpClient.enterLocalPassiveMode(); + ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE); + // 设置编码，当文件中存在中文且上传后文件乱码时可使用此配置项 + ftpClient.setControlEncoding("UTF-8"); + ftpClient.setFileTransferMode(FTPClient.STREAM_TRANSFER_MODE); + ftpClient.changeWorkingDirectory(pathName); + List ftpFiles = Arrays.asList(ftpClient.listFiles()); + String baselineFileName = "RNAUTO_"+subFileName + ".baseline"; + List baselineFiles = ftpFiles.stream().filter(item -> item.getName().equals(baselineFileName)).collect(Collectors.toList()); + if (CollectionUtils.isNotEmpty(baselineFiles)){ + FTPFile baselineFile = baselineFiles.get(0); + if (Objects.nonNull(baselineFile)){ + InputStream inputStream = ftpClient.retrieveFileStream(baselineFile.getName()); + //声明一个临时文件 + File file = File.createTempFile("tmp", null); + //将ftp文件的输入流复制给临时文件 + FileUtils.copyInputStreamToFile(inputStream, file); + List readLines = FileUtils.readLines(file, "UTF-8"); + ReadBaseCtrlInfo(phd,readLines); + phd.setVBase(phd.getBaseCtrls().getBaseline()); + } + } + } catch (IOException e) { + throw new RuntimeException(e); + } finally { + try { + ftpClient.disconnect(); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + } + } + + public List ReadLcScacInfo(List readLines){ + List vData = new LinkedList<>(); + for (int i=0; i< readLines.size(); i++){ + String line = readLines.get(i); + if (line.contains("#")){ + int j=i+1; + line = readLines.get(j); + String line1 = line; + while (j != readLines.size()-1 && StringUtils.isNotBlank(line) ){ + j++; + line = readLines.get(j); + if (!line.contains("#")){ + line1 += " " + line; + }else { + break; + } + } + line1 = line1.trim(); + List strList = Arrays.asList(line1.split("\\s+")); + if(strList.size() < 2){ + continue; + } + for(int k=1; k readLines){ + for (int i=0; i< readLines.size(); i++){ + String line = readLines.get(i); + if (line.contains("#")){ + String block_name = line.trim(); + int j=i+1; + line = readLines.get(j); + String block_data = line; + while(j!= readLines.size()-1 && StringUtils.isNotBlank(line)) { + j++; + line = readLines.get(j); + if (!line.contains("#")){ + block_data += " " + line; + }else { + break; + } + } + i=j-1; + block_data = block_data.trim(); + List str_list = Arrays.asList(block_data.split("\\s+")); + if(str_list.size() < 1){ + continue; + } + List vTemp = new LinkedList<>(); + for(String str:str_list) { + if (StringUtils.isNotBlank(str) && !str.equalsIgnoreCase("nan")){ + double d = Double.valueOf(str); + vTemp.add(d); + } else if (StringUtils.isNotBlank(str) && str.equalsIgnoreCase("nan")) { + vTemp.add(0.0); + } + } + if(block_name.contains("#AnalyseRange")) { + if(vTemp.size() == 2) { + phd.getBaseCtrls().setRg_low(vTemp.get(0).intValue()); + phd.getBaseCtrls().setRg_high(vTemp.get(1).intValue()); + } + } else if(block_name.contains("#XCtrl")) { + phd.getBaseCtrls().setXCtrl(vTemp); + } else if(block_name.contains("#YCtrl")) { + phd.getBaseCtrls().setYCtrl(vTemp); + } else if(block_name.contains("#YSlope")) { + phd.getBaseCtrls().setYSlope(vTemp); + } else if(block_name.contains("#Baseline")) { + List list = vTemp.subList(1, vTemp.size()); + phd.getBaseCtrls().setBaseline(list); + } else if(block_name.contains("#StepCounts")) { + List list = vTemp.subList(1, vTemp.size()); + phd.getBaseCtrls().setStepCounts(list); + } + } + } + } + + public boolean getResultFromDB(String dbName, Integer sampleId, PHDFile phd, Result result){ + //判断连接的数据库 + String T_analy, T_calib, T_peaks, T_param, T_nuc_line, T_nuc_act, T_qc, T_setting; + if (dbName.equals("auto")){ + T_analy = "RNAUTO.GARDS_ANALYSES"; + T_calib = "RNAUTO.GARDS_CALIBRATION_PAIRS"; + T_peaks = "RNAUTO.GARDS_PEAKS"; + T_param = "RNAUTO.GARDS_CALIBRATION"; + T_nuc_line = "RNAUTO.GARDS_NUCL_LINES_IDED"; + T_nuc_act = "RNAUTO.GARDS_NUCL_IDED"; + T_qc = "RNAUTO.GARDS_QC_CHECK"; + }else { + T_analy = "RNMAN.GARDS_ANALYSES"; + T_calib = "RNMAN.GARDS_CALIBRATION_PAIRS"; + T_peaks = "RNMAN.GARDS_PEAKS"; + T_param = "RNMAN.GARDS_CALIBRATION"; + T_nuc_line = "RNMAN.GARDS_NUCL_LINES_IDED"; + T_nuc_act = "RNMAN.GARDS_NUCL_IDED"; + T_qc = "RNMAN.GARDS_QC_CHECK"; + T_setting = "RNMAN.GARDS_ANALY_SETTING"; + } + + String status = spectrumAnalysisMapper.getStatus(sampleId); + if (StringUtils.isNotBlank(status)){ + phd.setStatus(status); + if (!phd.getStatus().equals("P") && !phd.getStatus().equals("R")){ + return false; + } + }else { + return false; + } + + // 获取 ananlysis_id、BaseLine、Lc、Scac、峰数量、Category、谱注释等信息 + GardsAnalysesSpectrum analysis = spectrumAnalysisMapper.getAnalysis(T_analy, sampleId); + int peakNum = 0; + if (Objects.nonNull(analysis)){ + phd.setId_analysis(analysis.getIdAnalysis().toString()); + phd.setBaseline_path(StringPool.SLASH + spectrumPathProperties.getRootPath() + StringPool.SLASH + analysis.getBaselinePath()); + phd.setLc_path(StringPool.SLASH + spectrumPathProperties.getRootPath() + StringPool.SLASH + analysis.getLcPath()); + phd.setScac_path(StringPool.SLASH + spectrumPathProperties.getRootPath() + StringPool.SLASH + analysis.getScacPath()); + peakNum = analysis.getNumberOfPeaks(); + phd.setTotalCmt(analysis.getComments()); + phd.getBaseCtrls().setRg_low(analysis.getSearchStartChannel()); + phd.getBaseCtrls().setRg_high(analysis.getSearchEndChannel()); + phd.getUsedSetting().setEnergyTolerance(analysis.getSearchThreshold()); + }else { + result.error500("There are 0 records when sample_id is "+sampleId+"!"); + return false; + } + + if (peakNum>0){ + // 获取峰信息列表 + List peaks = spectrumAnalysisMapper.getPeaks(T_peaks, analysis.getIdAnalysis()); + if (CollectionUtils.isNotEmpty(peaks)){ + for (GardsPeaksSpectrum peaksSpectrum:peaks) { + PeakInfo peakInfo = new PeakInfo(); + peakInfo.index = peaksSpectrum.getIdPeak()==null?0:peaksSpectrum.getIdPeak(); + peakInfo.multiIndex = peaksSpectrum.getMulitiIndex()==null?0:peaksSpectrum.getMulitiIndex().intValue(); + peakInfo.left = peaksSpectrum.getRoiStart()==null?0:peaksSpectrum.getRoiStart().intValue(); + peakInfo.right = peaksSpectrum.getRoiEnd()==null?0:peaksSpectrum.getRoiEnd().intValue(); + peakInfo.peakCentroid = peaksSpectrum.getCentroidChannel()==null?0:peaksSpectrum.getCentroidChannel(); + peakInfo.energy = peaksSpectrum.getEnergy()==null?0:peaksSpectrum.getEnergy(); + peakInfo.fwhmc = peaksSpectrum.getFwtm()==null?0:peaksSpectrum.getFwtm(); + peakInfo.fwhm = peaksSpectrum.getFwhm()==null?0:peaksSpectrum.getFwhm(); + peakInfo.area = peaksSpectrum.getArea()==null?0:peaksSpectrum.getArea(); + peakInfo.areaErr = peaksSpectrum.getUncArea()==null?0:peaksSpectrum.getUncArea(); + peakInfo.efficiency = peaksSpectrum.getEfficiency()==null?0:peaksSpectrum.getEfficiency(); + peakInfo.lc = peaksSpectrum.getLc()==null?0:peaksSpectrum.getLc(); + peakInfo.ld = peaksSpectrum.getLd()==null?0:peaksSpectrum.getLd(); + peakInfo.meanBackCount = peaksSpectrum.getMeanbackcount()==null?0:peaksSpectrum.getMeanbackcount(); + peakInfo.backgroundArea = peaksSpectrum.getBackgroundarea()==null?0:peaksSpectrum.getBackgroundarea(); + peakInfo.significance = peaksSpectrum.getSignificance()==null?0:peaksSpectrum.getSignificance(); + peakInfo.sensitivity = peaksSpectrum.getSensitivity()==null?0:peaksSpectrum.getSensitivity(); + peakInfo.stepRatio = peaksSpectrum.getStepraio()==null?0:peaksSpectrum.getStepraio(); + peakInfo.tail = peaksSpectrum.getTail()==null?0:peaksSpectrum.getTail(); + peakInfo.tailAlpha = peaksSpectrum.getTailAlpha()==null?0:peaksSpectrum.getTailAlpha(); + peakInfo.upperTail = peaksSpectrum.getUpperTail()==null?0:peaksSpectrum.getUpperTail(); + peakInfo.upperTailAlpha = peaksSpectrum.getUpperTailAlpha()==null?0:peaksSpectrum.getUpperTailAlpha(); + peakInfo.BWWidthChan = peaksSpectrum.getBwwidthchan()==null?0:peaksSpectrum.getBwwidthchan(); + peakInfo.recoilBetaChan = "1"; + peakInfo.recoilDeltaChan = peaksSpectrum.getRecoildeltachan()==null?"1":peaksSpectrum.getRecoildeltachan().toString(); + peakInfo.comments = StringUtils.isNotBlank(peaksSpectrum.getPeakcomments())?peaksSpectrum.getPeakcomments():""; + phd.getVPeak().add(peakInfo); + } + } + } + // 获取刻度点数据 + List calibrationPairs = spectrumAnalysisMapper.getCalibrationPairs(T_calib, analysis.getIdAnalysis()); + if (CollectionUtils.isNotEmpty(calibrationPairs)){ + GEnergyBlock gEnergyBlock = new GEnergyBlock(); + GResolutionBlock gResolutionBlock = new GResolutionBlock(); + GEfficiencyBlock gEfficiencyBlock = new GEfficiencyBlock(); + TotaleffBlock totaleffBlock = new TotaleffBlock(); + for (GardsCalibrationPairsSpectrum pairsSpectrum:calibrationPairs) { + String calType = pairsSpectrum.getCaltype().trim(); + if(calType.equals(CalType.ENERGY_CAL.getType())) { + phd.setUsedEner(pairsSpectrum.getInput()); + gEnergyBlock.getCentroid_channel().add(pairsSpectrum.getXValue()); + gEnergyBlock.getG_energy().add(pairsSpectrum.getYValue()); + gEnergyBlock.getUncertainty().add(StringUtils.isBlank(pairsSpectrum.getUncYValue())? 0:Double.valueOf(pairsSpectrum.getUncYValue())); + } else if(calType.equals(CalType.RESOLUTION_CAL.getType())) { + phd.setUsedReso(pairsSpectrum.getInput()); + gResolutionBlock.getG_energy().add(pairsSpectrum.getXValue()); + gResolutionBlock.getFWHM().add(pairsSpectrum.getYValue()); + gResolutionBlock.getUncertainty().add(StringUtils.isBlank(pairsSpectrum.getUncYValue())? 0: Double.valueOf(pairsSpectrum.getUncYValue())); + } else if(calType.equals(CalType.EFFICIENCY_CAL.getType())) { + phd.setUsedEffi(pairsSpectrum.getInput()); + gEfficiencyBlock.getG_energy().add(pairsSpectrum.getXValue()); + gEfficiencyBlock.getEfficiency().add(pairsSpectrum.getYValue()); + gEfficiencyBlock.getUncertainty().add(StringUtils.isBlank(pairsSpectrum.getUncYValue())? 0: Double.valueOf(pairsSpectrum.getUncYValue())); + } else if(calType.equals(CalType.TOTALEFFICIENCY_CAL.getType())) { + phd.setUsedTotE(pairsSpectrum.getInput()); + totaleffBlock.getG_energy().add(pairsSpectrum.getXValue()); + totaleffBlock.getTotal_efficiency().add(pairsSpectrum.getYValue()); + totaleffBlock.getUncertainty().add(StringUtils.isBlank(pairsSpectrum.getUncYValue())? 0: Double.valueOf(pairsSpectrum.getUncYValue())); + } + } + if (phd.getUsedEner().isEmpty()){ + phd.setUsedEner(CalName.CalPHD.getType()); + } + if (phd.getUsedReso().isEmpty()){ + phd.setUsedReso(CalName.CalPHD.getType()); + } + if (phd.getUsedEffi().isEmpty()){ + phd.setUsedEffi(CalName.CalPHD.getType()); + } + if (phd.getUsedTotE().isEmpty()){ + phd.setUsedTotE(CalName.CalPHD.getType()); + } + gEnergyBlock.setRecord_count(gEnergyBlock.getG_energy().size()); + gResolutionBlock.setRecord_count(gResolutionBlock.getG_energy().size()); + gEfficiencyBlock.setRecord_count(gEfficiencyBlock.getG_energy().size()); + totaleffBlock.setRecord_count(totaleffBlock.getG_energy().size()); + if(gEnergyBlock.getRecord_count() > 0) { + phd.setUsedEnerKD(gEnergyBlock); + phd.getMapEnerKD().put(phd.getUsedEner(), gEnergyBlock); + } + + if(gResolutionBlock.getRecord_count() > 0) { + phd.setUsedResoKD(gResolutionBlock); + phd.getMapResoKD().put(phd.getUsedReso(), gResolutionBlock); + } + + if(gEfficiencyBlock.getRecord_count() > 0) { + phd.setUsedEffiKD(gEfficiencyBlock); + phd.getMapEffiKD().put(phd.getUsedEffi(), gEfficiencyBlock); + } + + if(totaleffBlock.getRecord_count() > 0) { + phd.setUsedTotEKD(totaleffBlock); + phd.getMapTotEKD().put(phd.getUsedTotE(), totaleffBlock); + } + } + // 获取刻度拟合系数 + List paras = spectrumAnalysisMapper.getPara(T_param, analysis.getIdAnalysis()); + if (CollectionUtils.isNotEmpty(paras)){ + for (GardsCalibrationSpectrum calibrationSpectrum:paras) { + ParameterInfo para = new ParameterInfo(); + String calType = calibrationSpectrum.getCalType().trim(); + para.getP().add(calibrationSpectrum.getFunction().doubleValue()); + String[] list_coeff = calibrationSpectrum.getCoeffString().split(StringPool.COMMA); + for (String str:list_coeff) { + para.getP().add(Double.valueOf(str)); + para.getPerr().add(0.0); + } + if(calType.equals(CalType.ENERGY_CAL.getType())) { + phd.setUsedEnerPara(para); + phd.getMapEnerPara().put(phd.getUsedEner(), para); + phd.setNewEner(phd.getUsedEner()); + } else if(calType.equals(CalType.RESOLUTION_CAL.getType())) { + phd.setUsedResoPara(para); + phd.getMapResoPara().put(phd.getUsedReso(), para); + phd.setNewReso(phd.getUsedReso()); + } else if(calType.equals(CalType.EFFICIENCY_CAL.getType())) { + phd.setUsedEffiPara(para); + phd.getMapEffiPara().put(phd.getUsedEffi(), para); + phd.setNewEffi(phd.getUsedEffi()); + } else if(calType.equals(CalType.TOTALEFFICIENCY_CAL.getType())) { + phd.setUsedTotEPara(para); + phd.getMapTotEPara().put(phd.getUsedTotE(), para); + phd.setNewTotE(phd.getUsedTotE()); + } + } + } + // 获取被识别核素射线信息 + List nuclLinesIdeds = spectrumAnalysisMapper.getNuclLinesIded(T_nuc_line, analysis.getIdAnalysis()); + if (CollectionUtils.isNotEmpty(nuclLinesIdeds)){ + for (GardsNuclLinesIdedSpectrum nuclLinesIdedSpectrum:nuclLinesIdeds) { + String str_key = nuclLinesIdedSpectrum.getNuclideName(); + phd.getMapNucActMda().put(str_key, new NuclideActMda()); + if(Objects.nonNull(phd.getMapNucActMda().get(str_key))) { + phd.getMapNucActMda().get(str_key).setActivity(Double.valueOf(nuclLinesIdedSpectrum.getActivity())); + phd.getMapNucActMda().get(str_key).setAct_err(nuclLinesIdedSpectrum.getUncActivity()); + phd.getMapNucActMda().get(str_key).setEfficiency(nuclLinesIdedSpectrum.getEffic()); + phd.getMapNucActMda().get(str_key).setEffi_err(nuclLinesIdedSpectrum.getUnEffic()); + phd.getMapNucActMda().get(str_key).setMda(nuclLinesIdedSpectrum.getMda()); + phd.getMapNucActMda().get(str_key).setMdc(Double.valueOf(nuclLinesIdedSpectrum.getMdc())); + phd.getMapNucActMda().get(str_key).setConcentration(Double.valueOf(nuclLinesIdedSpectrum.getConcentration())); + if(phd.getMapNucActMda().get(str_key).getActivity() > 0){ + phd.getMapNucActMda().get(str_key).setBCalculateMDA(true); + } + } + if(nuclLinesIdedSpectrum.getKeyFlag().toString().equals("1")){ + phd.getMapNucActMda().get(str_key).setKey_flag(phd.getMapNucActMda().get(str_key).getVYield().size()); + } + phd.getMapNucActMda().get(str_key).getFullNames().add(nuclLinesIdedSpectrum.getNuclidefullname()); + phd.getMapNucActMda().get(str_key).getVEnergy().add(nuclLinesIdedSpectrum.getEnergy()); + phd.getMapNucActMda().get(str_key).getVUncertE().add(nuclLinesIdedSpectrum.getUncEnergy()); + phd.getMapNucActMda().get(str_key).getVYield().add(nuclLinesIdedSpectrum.getAbundance()); + phd.getMapNucActMda().get(str_key).getVUncertY().add(nuclLinesIdedSpectrum.getUncAbundance()); + + int idx = nuclLinesIdedSpectrum.getIdPeak() - 1; + if(idx >= 0 && idx < peakNum) { + phd.getMapNucActMda().get(str_key).getVPeakIdx().add(idx+1); + if(!phd.getVPeak().get(idx).nuclides.contains(str_key)){ + phd.getVPeak().get(idx).nuclides.add(str_key); + } + } + } + } + // 获取被识别核素的活度浓度 + List nuclIdeds = spectrumAnalysisMapper.getNuclIded(T_nuc_act, analysis.getIdAnalysis()); + if (CollectionUtils.isNotEmpty(nuclIdeds)){ + for (GardsNuclIdedSpectrum nuclIdedSpectrum:nuclIdeds) { + String str_key = nuclIdedSpectrum.getNuclideName(); + if(Objects.isNull(phd.getMapNucActMda().get(str_key))) { + phd.getMapNucActMda().get(str_key).setHalflife(Double.valueOf(nuclIdedSpectrum.getHalflife())); + List vEner = phd.getMapNucActMda().get(str_key).getVEnergy(); + Double key_ener = Double.valueOf(nuclIdedSpectrum.getKeyEnergy()); + for(int i=0; i qcChecks = spectrumAnalysisMapper.getQcCheck(T_qc, analysis.getIdAnalysis()); + if (CollectionUtils.isNotEmpty(qcChecks)){ + for (GardsQcCheckSpectrum qcCheckSpectrum:qcChecks) { + String str_key = qcCheckSpectrum.getQcName(); + QcCheckItem qcCheckItem = new QcCheckItem(); + qcCheckItem.setValue(qcCheckSpectrum.getQcValue()); + qcCheckItem.setBPass(qcCheckSpectrum.getQcResult() == 1); + qcCheckItem.setStandard(qcCheckSpectrum.getQcStandard()); + phd.getQcItems().put(str_key, qcCheckItem); + } + } + // 从 RNMAN.GARDS_ANALY_SETTING 表读分析设置 + if (dbName.equals("auto")){ + GardsAnalySetting analySetting = spectrumAnalysisMapper.getAnalySetting(analysis.getIdAnalysis()); + if (Objects.nonNull(analySetting)){ + phd.getUsedSetting().setECutAnalysis_Low(analySetting.getEcutanalysisLow()); + double t_d = analySetting.getEcutanalysisHigh(); + phd.getUsedSetting().setECutAnalysis_High((t_d <= phd.getUsedSetting().getECutAnalysis_Low() ? 0 : t_d)); + phd.getUsedSetting().setEnergyTolerance(analySetting.getEnergytolerance()); + phd.getUsedSetting().setCalibrationPSS_high(analySetting.getCalibrationpssHigh()); + phd.getUsedSetting().setCalibrationPSS_low(analySetting.getCalibrationpssLow()); + phd.getUsedSetting().setBaseImprovePSS(analySetting.getBaseimprovepss()); + phd.getUsedSetting().setPSS_low(analySetting.getPssLow()); + phd.getUsedSetting().setK_back(analySetting.getKBack()); + phd.getUsedSetting().setK_alpha(analySetting.getKAlpha()); + phd.getUsedSetting().setK_beta(analySetting.getKBeta()); + phd.getUsedSetting().setRiskLevelK(analySetting.getRisklevelk()); + phd.getUsedSetting().setBUpdateCal(analySetting.getBupdatecal() == 1); + phd.getUsedSetting().setKeepCalPeakSearchPeaks(analySetting.getKeepcalpeakserchpeaks() == 1); + Date reftimeAct = analySetting.getReftimeAct(); + if(Objects.nonNull(reftimeAct)){ + phd.getUsedSetting().setRefTime_act(reftimeAct); + } + Date reftimeConc = analySetting.getReftimeConc(); + if(Objects.nonNull(reftimeConc)){ + phd.getUsedSetting().setRefTime_conc(reftimeConc); + } + } + } + + if(!phd.getUsedEnerPara().getP().isEmpty()) { + List vChan = new LinkedList<>(); + double c = 1; + while(c <= phd.getSpec().getNum_g_channel()) { + vChan.add(c); + c += 1; + } + System.loadLibrary("GammaAnaly"); + CalValuesOut calValuesOut = CalValuesHandler.calFcnEval(vChan, phd.getUsedEnerPara().getP()); + phd.setVEnergy(calValuesOut.counts); + phd.setBAnalyed(true); + } + return true; + } + + public List Qcstate(PHDFile phd){ + // Collection Time、 Acq Time、 Decay Time、 SampVol、 Be7-FWHM、 Ba140-MDC、 Xe133-MDC + List qcState = new LinkedList<>(); + for (int i=0;i<7; i++){ + qcState.add("GRAY"); + } + if(phd.getQcItems().size() <= 5) { + this.RunQC(phd); + } + qcState.set(0, phd.getQcItems().get("col_time").isBPass()?"BLUE":"RED"); + qcState.set(1, phd.getQcItems().get("acq_time").isBPass()?"BLUE":"RED"); + qcState.set(2, phd.getQcItems().get("decay_time").isBPass()?"BLUE":"RED"); + qcState.set(3, phd.getQcItems().get("samp_vol").isBPass()?"BLUE":"RED"); + + if(phd.getHeader().getSystem_type().equalsIgnoreCase("P")) { + if(Objects.isNull(phd.getQcItems().get("Be7-FWHM"))) { + qcState.set(4, phd.getQcItems().get("Be7-FWHM").isBPass()?"BLUE":"RED"); + qcState.set(5, phd.getQcItems().get("Ba140-MDC").isBPass()?"BLUE":"RED"); + } + } else if(phd.getHeader().getSystem_type().equalsIgnoreCase("G")) { + if(Objects.isNull(phd.getQcItems().get("Xe133-MDC"))) { + qcState.set(6, phd.getQcItems().get("Xe133-MDC").isBPass()?"BLUE":"RED"); + } + } + return qcState; + } + + public void RunQC(PHDFile phd){ + System.loadLibrary("GammaAnaly"); + try { + Date start = DateUtils.parseDate(phd.getCollect().getCollection_start_date() + " " + phd.getCollect().getCollection_start_time().substring(0, phd.getCollect().getCollection_start_time().indexOf(StringPool.DOT)),"yyyy/MM/dd HH:mm:ss"); + Date end = DateUtils.parseDate(phd.getCollect().getCollection_stop_date() + " " + phd.getCollect().getCollection_stop_time().substring(0, phd.getCollect().getCollection_stop_time().indexOf(StringPool.DOT)),"yyyy/MM/dd HH:mm:ss"); + Date acq = DateUtils.parseDate(phd.getAcq().getAcquisition_start_date() + " " + phd.getAcq().getAcquisition_start_time().substring(0, phd.getAcq().getAcquisition_start_time().indexOf(StringPool.DOT)),"yyyy/MM/dd HH:mm:ss"); + + double collect_hour = (start.getTime()/1000 - end.getTime()/1000) / 3600.0; + double acq_hour = phd.getAcq().getAcquisition_real_time() / 3600.0; + double Decay_hour = (end.getTime()/1000 - acq.getTime()/1000) / 3600.0; + + Double ener_Be7 = 0.0; + Map vMdcInfoMap = new HashMap<>(); + List vMdcInfo = new LinkedList<>(); + Map qcItems = new LinkedHashMap<>(); + if(!this.ReadQCLimit(qcItems, vMdcInfoMap, ener_Be7, phd.getHeader().getSystem_type().toUpperCase())) { + String WARNING = "Read QC Flags from SystemManager.xml Failed!"; + } + if (CollectionUtils.isNotEmpty(vMdcInfoMap)) { + vMdcInfo.add(vMdcInfoMap.get("0")); + vMdcInfo.add(vMdcInfoMap.get("1")); + vMdcInfo.add(vMdcInfoMap.get("2")); + } + + QcCheckItem colTime = qcItems.get("col_time"); + colTime.setValue(collect_hour); + qcItems.put("col_time", colTime); + + QcCheckItem acqTime = qcItems.get("acq_time"); + acqTime.setValue(acq_hour); + qcItems.put("acq_time", acqTime); + + QcCheckItem decayTime = qcItems.get("decay_time"); + decayTime.setValue(Decay_hour); + qcItems.put("decay_time", decayTime); + + QcCheckItem sampVol = qcItems.get("samp_vol"); + sampVol.setValue(phd.getCollect().getAir_volume()); + qcItems.put("samp_vol", sampVol); + + QcCheckItem airFlow = qcItems.get("airFlow"); + airFlow.setValue(phd.getCollect().getAir_volume() / collect_hour); + qcItems.put("airFlow", airFlow); + + if(phd.isValid() && phd.getVBase().size() == phd.getSpec().getNum_g_channel()) { + if(phd.getHeader().getSystem_type().equalsIgnoreCase("P")) { + List energy = new LinkedList<>(); + energy.add(ener_Be7); + CalValuesOut calValuesOut = CalValuesHandler.calFcnEval(energy, phd.getUsedResoPara().getP()); + List fwhm = calValuesOut.counts; + QcCheckItem be7 = qcItems.get("Be7-FWHM"); + be7.setValue(fwhm.get(0)); + qcItems.put("Be7-FWHM", be7); + QcCheckItem Ba140 = qcItems.get("Ba140-MDC"); + Ba140.setValue(CalculateMDC(phd, vMdcInfo, 1.0)); + qcItems.put("Ba140-MDC", Ba140); + } else { + QcCheckItem Xe133 = qcItems.get("Xe133-MDC"); + Xe133.setValue(CalculateMDC(phd, vMdcInfo, 1.0)); + qcItems.put("Xe133-MDC", Xe133); + } + } + + for(Map.Entry iter:qcItems.entrySet()){ + if(iter.getValue().getStandard().isEmpty()){ + continue; + } + String[] lists = iter.getValue().getStandard().split(StringPool.COMMA); + boolean bSatisfy = true; + for(String str : lists) { + if(str.contains(StringPool.DASH)){ + continue; + } else if(str.contains(StringPool.LEFT_BRACKET)) { + if(iter.getValue().getValue() <= Double.valueOf(str.replace(StringPool.LEFT_BRACKET,""))) { + bSatisfy = false; + break; + } + } else if(str.contains(StringPool.RIGHT_BRACKET)) { + if(iter.getValue().getValue() >= Double.valueOf(str.replace(StringPool.RIGHT_BRACKET,""))) { + bSatisfy = false; + break; + } + } else if(str.contains(StringPool.LEFT_SQ_BRACKET)) { + if(iter.getValue().getValue() < Double.valueOf(str.replace(StringPool.LEFT_SQ_BRACKET,""))) { + bSatisfy = false; + break; + } + } else if(str.contains(StringPool.RIGHT_SQ_BRACKET)) { + if(iter.getValue().getValue() > Double.valueOf(str.replace(StringPool.RIGHT_SQ_BRACKET,""))) { + bSatisfy = false; + break; + } + } + } + iter.getValue().setBPass(bSatisfy); + } + phd.setQcItems(qcItems); + } catch (ParseException e) { + throw new RuntimeException(e); + } + } + + public Double CalculateMDC(PHDFile phd, List vMdcInfo, Double CCF){ + try { + System.loadLibrary("GammaAnaly"); + if(vMdcInfo.size() < 3 || vMdcInfo.get(2) == 0) { + return 0.0; + } + Date collectStart = DateUtils.parseDate(phd.getCollect().getCollection_start_date() + " " + phd.getCollect().getCollection_start_time().substring(0,phd.getCollect().getCollection_start_time().indexOf(StringPool.DOT)), "yyyy/MM/dd HH:mm:ss"); + Date collectStop = DateUtils.parseDate(phd.getCollect().getCollection_stop_date() + " " + phd.getCollect().getCollection_stop_time().substring(0,phd.getCollect().getCollection_stop_time().indexOf(StringPool.DOT)), "yyyy/MM/dd HH:mm:ss"); + Date acqStart = DateUtils.parseDate(phd.getAcq().getAcquisition_start_date() + " " + phd.getAcq().getAcquisition_start_time().substring(0,phd.getAcq().getAcquisition_start_time().indexOf(StringPool.DOT)), "yyyy/MM/dd HH:mm:ss"); + double Ts = (collectStart.getTime()/1000 - collectStop.getTime()/1000); // 采样时间 + double Td = (collectStop.getTime()/1000 - acqStart.getTime()/1000); // 衰变时间 + double Ta = phd.getAcq().getAcquisition_real_time(); // 能谱获取实时间 + double Tl = phd.getAcq().getAcquisition_live_time(); // 能谱获取活时间 + double Svol = phd.getCollect().getAir_volume(); // 样品采样体积 + double DCF1, DCF2, DCF3; + + double lambda = Math.log(2.0) / (vMdcInfo.get(2) * 86400); + if ( Ts == 0 ) DCF1 = 1; + else DCF1 = lambda * Ts / (1-Math.exp(-lambda*Ts)); + if ( Td == 0 ) DCF2 = 1; + else DCF2 = Math.exp(lambda*Td); + if ( Ta == 0 ) DCF3 = 1; + else DCF3 = lambda * Ta / (1-Math.exp(-lambda*Ta)); + + double DCF_conc = Math.exp(lambda * (phd.getUsedSetting().getRefTime_conc().getTime()/1000 - collectStart.getTime()/1000)); + + List energy = new LinkedList<>(); + energy.add(vMdcInfo.get(0)); + //使用energyToChannel方法计算 + CalValuesOut energyToChannel = CalValuesHandler.energyToChannel(energy, phd.getUsedEnerPara().getP()); + List channel = energyToChannel.counts; + //使用calDerivEval方法计算dE矩阵 + CalValuesOut calDerivEval = CalValuesHandler.calDerivEval(channel, phd.getUsedEnerPara().getP()); + List dE = calDerivEval.counts; + double[] array = dE.stream().mapToDouble(Double::doubleValue).toArray(); + SimpleMatrix dEMatrix = new SimpleMatrix(calDerivEval.rowNum, calDerivEval.colNum, true, array); + //calFcnEval计算得到矩阵数据 + CalValuesOut calFcnEval = CalValuesHandler.calFcnEval(energy, phd.getUsedEnerPara().getP()); + List counts = calFcnEval.counts; + //计算后的矩阵的集合转换成数组 + double[] array2 = counts.stream().mapToDouble(Double::doubleValue).toArray(); + //按照行数 列数 实际数据 生成矩阵 + SimpleMatrix calMatrix = new SimpleMatrix(calFcnEval.rowNum, calFcnEval.colNum, true, array2); + //计算后的矩阵 / dE矩阵 得到除后的矩阵 + SimpleMatrix matrixC = calMatrix.elementDiv(dEMatrix); + //声明一个集合接收除后的矩阵数据 + List values = new LinkedList<>(); + //遍历相除后的矩阵 行数 + for (int i=0; i= vMdcInfo.get(0)) { + index = i; + if(phd.getVEnergy().get(i) - vMdcInfo.get(0) > vMdcInfo.get(0) - phd.getVEnergy().get(i-1)){ + index = i-1; + } + break; + } + } + double lcc = phd.getVLc().get(index); + double baseline = phd.getVBase().get(index); + double mdc = (2 * fwhmc * (lcc - baseline) / 0.8591 ) * CCF*DCF1*DCF2*DCF3*DCF_conc / ( vMdcInfo.get(1) * effi * Tl ) *1e6 / Svol; + return mdc; + } catch (ParseException e) { + throw new RuntimeException(e); + } + } + + public boolean ReadQCLimit(Map qcItems, Map vMdcInfoMap, Double ener_Be7, String systemType){ + try { + String filePath = parameterFilePath+ File.separator +"SystemManager.xml"; + //创建一个文档解析器工厂 + DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); + //创建文档解析器 + DocumentBuilder documentBuilder = factory.newDocumentBuilder(); + //读取xml文件生成一个文档 + Document document = documentBuilder.parse(filePath); + if (Objects.isNull(document)){ + return false; + } + //获取文档的根元素 + Element element = document.getDocumentElement(); + //获取根元素的子节点 + NodeList docChildNodes = element.getChildNodes(); + if (Objects.nonNull(docChildNodes) && docChildNodes.getLength()>0){ + //遍历子节点信息 + for(int i = 0; i < docChildNodes.getLength(); i++) { + //根据下标获取对应的节点信息 + Node n = docChildNodes.item(i); + //判断节点名称是否是 QCFlags-P 并且当前解析文件的系统类型是否是 P + if(n.getNodeName().equals("QCFlags-P") && systemType.equalsIgnoreCase("P")) { + // 获取节点的第一个子节点 + Node childNode = n.getFirstChild(); + //如果节点信息不为空 + while(Objects.nonNull(childNode)) { + String nodeName = childNode.getNodeName(); + //判断节点名称是否是 item + if(nodeName.equals("col_time") || nodeName.equals("acq_time") || nodeName.equals("decay_time") || nodeName.equals("samp_vol") + || nodeName.equals("airFlow") || nodeName.equals("Be7-FWHM") || nodeName.equals("Ba140-MDC")) { + QcCheckItem qcCheckItem = new QcCheckItem(); + // 获取节点的属性信息 + NamedNodeMap attributes = childNode.getAttributes(); + // 如果属性信息不为空 + if (Objects.nonNull(attributes)){ + // 遍历获取属性值 + for (int j=0; j< attributes.getLength(); j++){ + // 获取属性 + Node item = attributes.item(j); + //判断属性名称是否是 number + if(item.getNodeName().equals("green")) { + qcCheckItem.setStandard(item.getNodeValue()); + qcItems.put(nodeName, qcCheckItem); + } + } + } + }else if(nodeName.equals("Be7")) { + // 获取节点的属性信息 + NamedNodeMap attributes = childNode.getAttributes(); + // 如果属性信息不为空 + if (Objects.nonNull(attributes)){ + // 遍历获取属性值 + for (int j=0; j< attributes.getLength(); j++){ + // 获取属性 + Node item = attributes.item(j); + //判断属性名称是否是 number + if(item.getNodeName().equals(CalType.ENERGY_CAL.getType())) { + ener_Be7 = Double.valueOf(item.getNodeValue()); + } + } + } + } else if(nodeName.equals("Ba140")) { + // 获取节点的属性信息 + NamedNodeMap attributes = childNode.getAttributes(); + // 如果属性信息不为空 + if (Objects.nonNull(attributes)){ + // 遍历获取属性值 + for (int j=0; j< attributes.getLength(); j++){ + // 获取属性 + Node item = attributes.item(j); + //判断属性名称是否是 number + if(item.getNodeName().equals(CalType.ENERGY_CAL.getType())) { + vMdcInfoMap.put("0", Double.valueOf(item.getNodeValue())); + }else if (item.getNodeName().equals("yield")){ + vMdcInfoMap.put("1", Double.valueOf(item.getNodeValue())); + }else if (item.getNodeName().equals("halflife")){ + vMdcInfoMap.put("2", Double.valueOf(item.getNodeValue())); + } + } + } + } + // 获取下一个节点 + childNode = childNode.getNextSibling(); + } + }else if(n.getNodeName().equals("QCFlags-G") && systemType.equalsIgnoreCase("G")) { + // 获取节点的第一个子节点 + Node childNode = n.getFirstChild(); + //如果节点信息不为空 + while(Objects.nonNull(childNode)) { + String nodeName = childNode.getNodeName(); + //判断节点名称是否是 item + if(nodeName.equals("col_time") || nodeName.equals("acq_time") || nodeName.equals("decay_time") || nodeName.equals("samp_vol") + || nodeName.equals("airFlow") || nodeName.equals("Xe133-MDC")) { + QcCheckItem qcCheckItem = new QcCheckItem(); + // 获取节点的属性信息 + NamedNodeMap attributes = childNode.getAttributes(); + // 如果属性信息不为空 + if (Objects.nonNull(attributes)){ + // 遍历获取属性值 + for (int j=0; j< attributes.getLength(); j++){ + // 获取属性 + Node item = attributes.item(j); + //判断属性名称是否是 number + if(item.getNodeName().equals("green")) { + qcCheckItem.setStandard(item.getNodeValue()); + qcItems.put(nodeName, qcCheckItem); + } + } + } + }else if(nodeName.equals("Xe133")) { + // 获取节点的属性信息 + NamedNodeMap attributes = childNode.getAttributes(); + // 如果属性信息不为空 + if (Objects.nonNull(attributes)){ + // 遍历获取属性值 + for (int j=0; j< attributes.getLength(); j++){ + // 获取属性 + Node item = attributes.item(j); + //判断属性名称是否是 number + if(item.getNodeName().equals(CalType.ENERGY_CAL.getType())) { + vMdcInfoMap.put("0", Double.valueOf(item.getNodeValue())); + }else if (item.getNodeName().equals("yield")){ + vMdcInfoMap.put("1", Double.valueOf(item.getNodeValue())); + }else if (item.getNodeName().equals("halflife")){ + vMdcInfoMap.put("2", Double.valueOf(item.getNodeValue())); + } + } + } + } + // 获取下一个节点 + childNode = childNode.getNextSibling(); + } + } + } + } + } catch (ParserConfigurationException e) { + throw new RuntimeException(e); + } catch (IOException e) { + throw new RuntimeException(e); + } catch (SAXException e) { + throw new RuntimeException(e); + } + return true; + } + + public List DetailedInfo(Integer sampleId, PHDFile phd) { + try { + // Sample_Id, Station_Code, Detector_Code, System_Type, Data_Type, Spectral_Qualifier, + // SRID, Sample_Status, Collect_Start, Sampling_Time, Quantity, Flow_Rate, + // Acq_Start, Acq_Real, Acq_Live, Decay_Time, Auto_Cat, Category + List detailInfo = new LinkedList<>(); + for (int i=0; i<18; i++){ + detailInfo.add(""); + } + detailInfo.set(0, Objects.nonNull(sampleId)?sampleId.toString():""); // Sample_Id + detailInfo.set(1, phd.getHeader().getSite_code()); // Station_Code + detailInfo.set(2, phd.getHeader().getDetector_code()); // Detector_Code + detailInfo.set(3, phd.getHeader().getSystem_type().toUpperCase()); // System_Type + detailInfo.set(4, phd.getMsgInfo().getData_type()); // Data_Type + detailInfo.set(5, phd.getHeader().getSpectrum_quantity()); // Spectral_Qualifier + detailInfo.set(6, phd.getHeader().getSample_ref_id()); // SRID + detailInfo.set(7, phd.getStatus()); // Sample_Status + String collect_stop = phd.getCollect().getCollection_stop_date() + " " + phd.getCollect().getCollection_stop_time().substring(0,phd.getCollect().getCollection_stop_time().indexOf(StringPool.DOT)); + Date collect_stop_dt = DateUtils.parseDate(collect_stop,"yyyy/MM/dd HH:mm:ss"); + detailInfo.set(8, phd.getCollect().getCollection_start_date() + " " + phd.getCollect().getCollection_start_time()); + Date date = DateUtils.parseDate(phd.getCollect().getCollection_start_date() + " " + phd.getCollect().getCollection_start_time().substring(0,phd.getCollect().getCollection_start_time().indexOf(StringPool.DOT)),"yyyy/MM/dd HH:mm:ss"); + double timeSpan = (collect_stop_dt.getTime()/1000 - date.getTime()/1000) / 3600.0; + detailInfo.set(9, String.format("%.2f", timeSpan));// Sampling_Time + detailInfo.set(10, String.format("%.2f", phd.getCollect().getAir_volume())); + if(timeSpan != 0){ + detailInfo.set(11, String.format("%.2f", phd.getCollect().getAir_volume()/timeSpan)); + } + detailInfo.set(12, phd.getAcq().getAcquisition_start_date() + " " + phd.getAcq().getAcquisition_start_time()); + String start_time = phd.getAcq().getAcquisition_start_date() + " " + phd.getAcq().getAcquisition_start_time().substring(0, phd.getAcq().getAcquisition_start_time().indexOf(StringPool.DOT)); + Date start_date = DateUtils.parseDate(start_time, "yyyy/MM/dd HH:mm:ss"); + detailInfo.set(13, String.format("%.2f", phd.getAcq().getAcquisition_real_time())); + detailInfo.set(14, String.format("%.2f", phd.getAcq().getAcquisition_live_time())); + double timespan = (start_date.getTime()/1000 - collect_stop_dt.getTime()/1000); + detailInfo.set(15, String.format("%.2f", timespan / 3600.0)); + detailInfo.set(17, phd.getCategory()); + return detailInfo; + } catch (ParseException e) { + throw new RuntimeException(e); + } + } + + public void UpdateChart(PHDFile phd, Map map){ + List m_vCount = new LinkedList<>(); + long m_nCount = phd.getSpec().getNum_g_channel(); + long m_nSChan = phd.getSpec().getBegin_channel(); + + // 确保绘制曲线时所有谱都是从1道开始 + int i = 0; + if(m_nSChan == 0){ + i = 1; + } + for(; i allData = AllData(false, phd, m_vCount, m_nCount); + map.put("allData", allData); + List shapeEnergyData = Energy_BaseCP(phd); + map.put("shapeEnergyData", shapeEnergyData); + List shapeChannelData = Channel_BaseCP(phd); + map.put("shapeChannelData", shapeChannelData); + } + + public ChartData Energy_Count(PHDFile phd, List m_vCount, long m_nCount){ + int start = 0; + long end = -1; + //Energy + ChartData data1 = new ChartData(); + if(m_nCount > 1 && phd.getVEnergy().size() == m_nCount) { + if(start < 1) { + start = 1; + } + if(end < 1 || end > m_nCount){ + end = m_nCount; + } + for(int i=start-1; i m_vCount, long m_nCount){ + int start = 1; + long end = -1; + ChartData data1 = new ChartData(); + if(m_nCount > 1) { + if(start < 1){ + start = 1; + } + if(end < 1 || end > m_nCount){ + end = m_nCount; + } + for(int i=start-1; i Lc_Scac_base(boolean showLc, PHDFile phd, long m_nCount){ + List datalist = new LinkedList<>(); + int start = 0; + long end = -1; + if(m_nCount > 1 && phd.getVEnergy().size() == m_nCount && phd.getVLc().size() == m_nCount + && phd.getVScac().size() == m_nCount && phd.getVBase().size() == m_nCount) { + if(start < 1) { + start = 1; + } + if(end < 1 || end > m_nCount) { + end = m_nCount; + } + + ChartData data2 = new ChartData(); + ChartData data3 = new ChartData(); + ChartData data4 = new ChartData(); + ChartData data6 = new ChartData(); + ChartData data7 = new ChartData(); + ChartData data8 = new ChartData(); + for(int i=start-1; iSpectrum.counts[i] == 0) continue; + SeriseData data2Point = new SeriseData(); + data2Point.setX(i+1); + data2Point.setY(phd.getVLc().get(i)); + data2.getPointlist().add(data2Point); + + SeriseData data3Point = new SeriseData(); + data3Point.setX(i+1); + data3Point.setY(phd.getVScac().get(i)); + data3.getPointlist().add(data3Point); + + SeriseData data4Point = new SeriseData(); + data4Point.setX(i+1); + data4Point.setY(phd.getVBase().get(i)); + data4.getPointlist().add(data4Point); + + SeriseData data6Point = new SeriseData(); + data6Point.setX(phd.getVEnergy().get(i)); + data6Point.setY(phd.getVLc().get(i)); + data6.getPointlist().add(data6Point); + + SeriseData data7Point = new SeriseData(); + data7Point.setX(phd.getVEnergy().get(i)); + data7Point.setY(phd.getVScac().get(i)); + data7.getPointlist().add(data7Point); + + SeriseData data8Point = new SeriseData(); + data8Point.setX(phd.getVEnergy().get(i)); + data8Point.setY(phd.getVBase().get(i)); + data8.getPointlist().add(data8Point); + } + // 颜色：原谱:0；峰:1；Lc:2；BaseLine:3；Scac:4；比较谱:5； + data2.setGroup("channel"); + data2.setName("Lc"); + data2.setColor("255,0,0"); + data2.setShow(showLc); + data3.setGroup("channel"); + data3.setName("Scac"); + data3.setColor("244,112,247"); + data3.setShow(showLc); + data4.setGroup("channel"); + data4.setName("BaseLine"); + data4.setColor("0,246,255"); + data6.setGroup("energy"); + data6.setName("Lc"); + data6.setColor("255,0,0"); + data6.setShow(showLc); + data7.setGroup("energy"); + data7.setName("Scac"); + data7.setColor("244,112,247"); + data7.setShow(showLc); + data8.setGroup("energy"); + data8.setName("BaseLine"); + data8.setColor("0,246,255"); + data2.setType("Line"); + data3.setType("Line"); + data4.setType("Line"); + data6.setType("Line"); + data7.setType("Line"); + data8.setType("Line"); + datalist.add(data2); + datalist.add(data3); + datalist.add(data4); + datalist.add(data6); + datalist.add(data7); + datalist.add(data8); + } + return datalist; + } + + public List Channel_Peak(PHDFile phd, long m_nCount){ + return PeakSet(phd.getVPeak(), phd.getVBase(), m_nCount, null, false); + } + + public List Energy_Peak(PHDFile phd, long m_nCount){ + return PeakSet(phd.getVPeak(), phd.getVBase(), m_nCount, phd.getUsedEnerPara().getP(), true); + } + + public List PeakSet(List vPeak, List vBase, long m_nCount, List p, boolean bEnergy){ + System.loadLibrary("GammaAnaly"); + List datalist = new LinkedList<>(); + int peakNum = vPeak.size(); + if(peakNum < 1 || vBase.size() != m_nCount){ + return datalist; + } + int start = 0; + long end = -1; + if(start < 1){ + start = 1; + } + if(end > m_nCount || end < 1){ + end = m_nCount; + } + + // 找出在所给范围的第一道拟合峰和最后一道拟合峰的索引下标 + int index = 0, startPeak = -1, endPeak = peakNum-1; + while(index < peakNum && start > vPeak.get(index).right){ + ++index; + } + if(index < peakNum) { + startPeak = index; + while(index < peakNum && vPeak.get(index).left < end){ + ++index; + } + endPeak = index-1; + } + if(startPeak < 0 || startPeak > endPeak){ + return datalist; + } + + for(int i=startPeak; i<=endPeak; ++i) { + PeakInfo peak = vPeak.get(i); + + ChartData cData = new ChartData(); + cData.setColor("255,127,39"); + cData.setName("Peak"); + + List regChan = new LinkedList<>(); + double d = peak.left; + while(d <= peak.right) { + regChan.add(d); + d += 0.25; + } + List t_base = vBase.subList(peak.left, peak.right + 1); + List regPeak = CalValuesHandler.interp1(peak, t_base, regChan); + + if(bEnergy) { + cData.setGroup("energy"); + CalValuesOut calValuesOut = CalValuesHandler.calFcnEval(regChan, p); + List regEnergy = calValuesOut.counts; + for(int ii=0; ii end){ + continue; + } + SeriseData seriseData = new SeriseData(); + seriseData.setX(regEnergy.get(ii)); + seriseData.setY(regPeak.get(ii)); + cData.getPointlist().add(seriseData); + } + } else { + cData.setGroup("channel"); + for(int ii=0; ii end){ + continue; + } + SeriseData seriseData = new SeriseData(); + seriseData.setX(regChan.get(ii)); + seriseData.setY(regPeak.get(ii)); + cData.getPointlist().add(seriseData); + } + } + datalist.add(cData); + } + return datalist; + } + + public List Energy_BaseCP(PHDFile phd){ + System.loadLibrary("GammaAnaly"); + List shapes = new LinkedList<>(); + CalValuesOut calValuesOut = CalValuesHandler.calFcnEval(phd.getBaseCtrls().getXCtrl(), phd.getUsedEnerPara().getP()); + List vEner = calValuesOut.counts; + if(phd.getBaseCtrls().getXCtrl().size() == phd.getBaseCtrls().getYCtrl().size()) { + for(int i=0; i Channel_BaseCP(PHDFile phd){ + List shapes = new LinkedList<>(); + int num = phd.getBaseCtrls().getXCtrl().size(); + if(num == phd.getBaseCtrls().getYCtrl().size()) { + for(int i=0; i AllData(boolean showLc, PHDFile phd, List m_vCount, long m_nCount){ + List datalist = new LinkedList<>(); + datalist.add(Channel_Count(m_vCount, m_nCount)); + datalist.add(Energy_Count(phd, m_vCount, m_nCount)); + datalist.addAll(Lc_Scac_base(showLc, phd, m_nCount)); + datalist.addAll(Channel_Peak(phd, m_nCount)); + datalist.addAll(Energy_Peak(phd, m_nCount)); + return datalist; + } + + public boolean AnalyseData(PHDFile phd, ConfigureData configureData, List nuclides, boolean bSingle){ + //调用方法判断是否修改了参数 + if (Objects.nonNull(configureData)){ + SpecSetup phdSetting = phd.getSetting(); + phdSetting.setECutAnalysis_Low(configureData.getECutAnalysis_Low()); + phdSetting.setECutAnalysis_High(configureData.getECutAnalysis_High()); + phdSetting.setEnergyTolerance(configureData.getEnergyTolerance()); + phdSetting.setPSS_low(configureData.getPSS_low()); + phdSetting.setBaseImprovePSS(configureData.getBaseImprovePSS()); + phdSetting.setK_back(configureData.getK_back()); + phdSetting.setK_alpha(configureData.getK_alpha()); + phdSetting.setK_beta(configureData.getK_beta()); + phdSetting.setRiskLevelK(configureData.getRiskLevelK()); + phdSetting.setRefTime_act(configureData.getRefTime_act()); + phdSetting.setRefTime_conc(configureData.getRefTime_conc()); + } + + int change = SettingChanged(phd); + if(change == 0 && phd.getVPeak().size() > 0) return false; + else if(change == -1) { + phd.setUsedEffi(phd.getNewEffi()); + phd.setUsedEffiKD(phd.getMapEffiKD().get(phd.getNewEffi())); + phd.setUsedEffiPara(phd.getMapEffiPara().get(phd.getNewEffi())); + UpdateEfficiency(phd); + Map nuclideLinesMap = GetNuclideLines(nuclides); + NuclidesIdent(phd, nuclideLinesMap); + RunQC(phd); + String Warning = "Finish three tasks:\n"+ + "\t1.Update efficiencies of all peaks;\n"+ + "\t2.Identify nuclides again;\n"+ + "\t3.Test QC again."; + } else { + if(bSingle) { +// AnalyseFlowChart flow_dlg(this); +// flow_dlg.exec(); + } else { + Map nuclideLinesMap = GetNuclideLines(nuclides); +// AnalyseSpectrum(phd, nuclideLinesMap); + } + } + return true; + } + + public boolean AnalyseSpectrum(PHDFile phd, Map map){ + return false; + } + + public int SettingChanged(PHDFile phd) { + SpecSetup newSets = phd.getSetting(); + SpecSetup oldSets = phd.getUsedSetting(); + + if(newSets.getECutAnalysis_Low() != oldSets.getECutAnalysis_Low() + || newSets.getECutAnalysis_High() != oldSets.getECutAnalysis_High() + || newSets.getEnergyTolerance() != oldSets.getEnergyTolerance() + || newSets.getPSS_low() != oldSets.getCalibrationPSS_low() + || newSets.getBaseImprovePSS() != oldSets.getBaseImprovePSS() + || newSets.getK_back() != oldSets.getK_back() + || newSets.getK_alpha() != oldSets.getK_alpha() + || newSets.getK_beta() != oldSets.getK_beta() + || newSets.getRiskLevelK() != oldSets.getRiskLevelK() + || newSets.getRefTime_act() != oldSets.getRefTime_act() + || newSets.getRefTime_conc() != oldSets.getRefTime_conc()) + { + return 1; + } + + List old_ener = phd.getUsedEnerPara().getP(); + List new_ener = phd.getMapEnerPara().get(phd.getNewEner()).getP(); + if(old_ener.size() != new_ener.size()) return 1; + for(int i=0; i 1E-6){ + return 1; + } + } + + List old_reso = phd.getUsedResoPara().getP(); + List new_reso = phd.getMapResoPara().get(phd.getNewReso()).getP(); + if(old_reso.size() != new_reso.size()) return 1; + for(int i=0; i 1E-6){ + return 1; + } + } + + List old_effi = phd.getUsedEffiPara().getP(); + List new_effi = phd.getMapEffiPara().get(phd.getNewEffi()).getP(); + if(old_effi.size() != new_effi.size()) return -1; + for(int i=0; i 1E-6){ + return -1; + } + } + return 0; + } + + public void UpdateEfficiency(PHDFile phd) { + int peakNum = phd.getVPeak().size(); + List vEner = new LinkedList<>(); + for (int i=0; i vEffi = calValuesOut.counts; + for (int i=0; i map){ + // 当重新分析时先清除上一次的分析结果 + phd.getMapNucActMda().clear(); + for(int i=0; i mapHalflife = new HashMap<>(); // 用其他核素半衰期计算活度/浓度的核素 + List vNuclides = new LinkedList<>(); // 只识别不计算活度/浓度的核素 + ReadSpecialNuclides(mapHalflife, vNuclides); + + double energyWidth = phd.getUsedSetting().getEnergyTolerance(); + int peakNum = phd.getVPeak().size(); + for (Map.Entry iter: map.entrySet()){ + if(iter.getValue().halflife <= 0){ + continue; + } + FilterNuclideLine(iter.getValue(), phd.getUsedSetting().getECutAnalysis_Low()); // 过滤核素能量小于ECutAnalysis_Low的射线 + + List vEnergy = iter.getValue().vEnergy; // 该核素的所有γ射线能量 + List vYield = iter.getValue().vYield; + List vEffi = CalValuesHandler.calFcnEval(vEnergy, phd.getUsedEffiPara().getP()).counts; // 该核素所有γ射线能量处的探测效率 + List vFit = new LinkedList<>(); // γ射线能量与峰中心道能量匹配标识 + for (int i=0; i= 510 && phd.getVPeak().get(j).energy <= 512) { + continue; // 峰中心道能量为511的峰不进行核素识别 + } + if(vEnergy.get(i) < phd.getVPeak().get(j).energy - energyWidth){ + break; + } else if(vEnergy.get(i) <= phd.getVPeak().get(j).energy + energyWidth) { + sum_found += vEffi.get(i) * vYield.get(i); + vFit.set(i, j); + if(iter.getValue().maxYeildIdx == i){ + mainPeakIdx = j; + } + break; + } + } + sum_total += vEffi.get(i) * vYield.get(i); + } + + // 核素匹配到峰 + if(sum_total > 0) { + // 如果该核素属特殊核素，则用“特殊核素配置文件”中指明的其他核素的半衰期 + double halflife = (Objects.nonNull(mapHalflife.get(iter.getKey()))? iter.getValue().halflife : mapHalflife.get(iter.getKey())); + double lambda = Math.log(2.0) / halflife; + double rate = sum_found / sum_total; + if(rate > 0.5) { + // 获取用于计算Activity、MDC的主γ峰和最大分支比 + double maxFoundYield = vYield.get(iter.getValue().maxYeildIdx); + if(mainPeakIdx < 0) + { + maxFoundYield = 0; + for(int ii=0; ii= 0 && vYield.get(ii) > maxFoundYield) { + mainPeakIdx = vFit.get(ii); + maxFoundYield = vYield.get(ii); + } + } + if(mainPeakIdx < 0) continue; + } + + NuclideActMda ActMda = phd.getMapNucActMda().get(iter.getKey()); + boolean bActBigger = CalculateMDCs(phd, ActMda, mainPeakIdx, lambda, maxFoundYield, 1.0); + + if(rate > 0.8 || bActBigger) { + ActMda.setHalflife(halflife); + ActMda.setKey_flag(-1); + if(!vNuclides.contains(iter.getKey())) // 需要计算活度浓度的核素 + { + ActMda.setBCalculateMDA(true); + } else { + ActMda.setActivity(0); + ActMda.setAct_err(0); + ActMda.setEfficiency(0); + ActMda.setEffi_err(0); + ActMda.setMda(0); + ActMda.setMdc(0); + ActMda.setConcentration(0); + } + + int fitLineNum = 0, peakIdx = -1; + for(int ii=0; ii= 0) { + // 向峰信息表中添加识别到的核素 + if(vFit.get(ii) != peakIdx) { + phd.getVPeak().get(vFit.get(ii)).nuclides.add(iter.getKey()); + peakIdx = vFit.get(ii); + } + // 添加匹配的γ射线的信息 + if(vFit.get(ii) == mainPeakIdx){ + ActMda.setCalculateIdx(fitLineNum); + } + if(iter.getValue().maxYeildIdx == ii && iter.getValue().key_flag >= 0){ + ActMda.setKey_flag(fitLineNum); + } + ActMda.getVPeakIdx().add(peakIdx+1); + ActMda.getFullNames().add(iter.getValue().fullNames.get(ii)); + ActMda.getVEnergy().add(vEnergy.get(ii)); + ActMda.getVUncertE().add(iter.getValue().vUncertE.get(ii)); + ActMda.getVYield().add(vYield.get(ii)); + ActMda.getVUncertY().add(iter.getValue().vUncertY.get(ii)); + ++fitLineNum; + } + } + phd.getMapNucActMda().put(iter.getKey(), ActMda); + } + } + } + } + } + + private void ReadSpecialNuclides(Map mapHalflife, List vNuclides) { + try { + String fileName = parameterFilePath+"/setup/nuclide_ActMdc.txt"; + File t_file = new File(fileName); + List readLines = FileUtils.readLines(t_file, "UTF-8"); + for (int i=0;i< readLines.size();i++){ + String line = readLines.get(i); + if(line.contains("#MDA")) { + for (int j=i+1; j strList = Arrays.asList(line.split("\\s")); + if(strList.size() == 3) { + mapHalflife.put(strList.get(0), Double.valueOf(strList.get(2)) * 86400); + } + }else { + i=j; + break; + } + } + break; + } + if(line.contains("#Identify")) { + for (int j=i+1; j strList = Arrays.asList(line.split("\\s")); + vNuclides.addAll(strList); + } + } + } + } + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + private void FilterNuclideLine(NuclideLines lines, double lowE) { + List vE = lines.vEnergy; + for(int i=0, j=0; i 0) { + List vY = lines.vYield; + lines.maxYeildIdx = 0; + double maxYield = vY.get(0); + for(int ii=1; ii maxYield) { + maxYield = vY.get(ii); + lines.maxYeildIdx = ii; + } + } + } else{ + lines.maxYeildIdx = lines.key_flag; + } + } + + private boolean CalculateMDCs(PHDFile phd, NuclideActMda nucActMda, int mainPeakIdx, double lambda, double keyLineYield, double CCF){ + // 计算衰变校正因子——DCF + try { + Date collectStart = DateUtils.parseDate(phd.getCollect().getCollection_start_date() + " " + phd.getCollect().getCollection_start_time().substring(0, phd.getCollect().getCollection_start_time().indexOf(StringPool.DOT)), "yyyy/MM/dd HH:mm:ss"); + Date collectStop = DateUtils.parseDate(phd.getCollect().getCollection_stop_date() + " " + phd.getCollect().getCollection_stop_time().substring(0, phd.getCollect().getCollection_stop_time().indexOf(StringPool.DOT)), "yyyy/MM/dd HH:mm:ss"); + Date acqStart = DateUtils.parseDate(phd.getAcq().getAcquisition_start_date() + " " + phd.getAcq().getAcquisition_start_time().substring(0, phd.getAcq().getAcquisition_start_time().indexOf(StringPool.DOT)), "yyyy/MM/dd HH:mm:ss"); + double Ts = collectStart.getTime()/1000 - collectStop.getTime()/1000; // 采样时间 + double Td = collectStop.getTime()/1000 - acqStart.getTime()/1000; // 衰变时间 + double Ta = phd.getAcq().getAcquisition_real_time(); // 能谱获取实时间 + double Tl = phd.getAcq().getAcquisition_live_time(); // 能谱获取活时间 + double Svol = phd.getCollect().getAir_volume(); // 样品采样体积 + double DCF1, DCF2, DCF3; + + if ( Ts == 0 ) DCF1 = 1; + else DCF1 = lambda * Ts / (1-Math.exp(-lambda*Ts)); + if ( Td == 0 ) DCF2 = 1; + else DCF2 = Math.exp(lambda*Td); + if ( Ta == 0 ) DCF3 = 1; + else DCF3 = lambda * Ta / (1-Math.exp(-lambda*Ta)); + + double DCF_act = Math.exp(lambda * (phd.getUsedSetting().getRefTime_act().getTime()/1000 - acqStart.getTime()/1000)); + double DCF_conc = Math.exp(lambda * (phd.getUsedSetting().getRefTime_conc().getTime()/1000 - collectStart.getTime()/1000)); + + PeakInfo peak = phd.getVPeak().get(mainPeakIdx); + double netKeyPeakArea = peak.area; + double linePeakAreaErr = peak.areaErr; + + double detectorEfficiency = peak.efficiency; + double detectorEfficiencyError = 0.01 * peak.efficiency; + double fwhmc = peak.fwhmc; + int index = (int)(peak.peakCentroid + 0.5) - 1; + double lcc = phd.getVLc().get(index); + double baseline = phd.getVBase().get(index); + + double activity, mda; + if ( keyLineYield == 0 ) { + activity = 0; + mda = 0; + } else { + activity = ( netKeyPeakArea * CCF * DCF3*DCF_act ) / ( keyLineYield * detectorEfficiency * Tl ) ;//Bq,参考时间为referenceTimeActivity + mda = (2 * fwhmc * (lcc - baseline) / 0.8591 ) * CCF * DCF3*DCF_act / ( keyLineYield * detectorEfficiency * Tl ) ;//Bq,参考时间为referenceTimeActivity + } + double concentration = ( netKeyPeakArea * CCF*DCF1*DCF2*DCF3*DCF_conc ) / ( keyLineYield * detectorEfficiency * Tl ) *1e6/ Svol;//mBq/m3,参考时间为referenceTimeConc + double mdc = (2 * fwhmc * (lcc - baseline) / 0.8591 ) * CCF*DCF1*DCF2*DCF3*DCF_conc / ( keyLineYield * detectorEfficiency * Tl ) *1e6 / Svol; + double activityErr = Math.sqrt( Math.pow(linePeakAreaErr/netKeyPeakArea, 2) + Math.pow(detectorEfficiencyError/detectorEfficiency, 2) ) * activity; + + nucActMda.setActivity(activity); + nucActMda.setAct_err(activityErr); + nucActMda.setMda(mda); + nucActMda.setMdc(mdc); + nucActMda.setEfficiency(peak.efficiency); + nucActMda.setEffi_err(detectorEfficiencyError); + nucActMda.setConcentration(concentration); + + return (activity > mda); + } catch (ParseException e) { + throw new RuntimeException(e); + } + } + + public Map GetNuclideLines(List nuclideList) { + Map mapLines = new HashMap<>(); + if(nuclideList.size() < 1){ + return mapLines; + } + for(String name : nuclideList) { + NuclideLines nlines = new NuclideLines(); + List nuclideLineList = spectrumAnalysisMapper.getNuclideLines(name); + for(int j=0;j 0) { + nlines.key_flag = j; + nlines.maxYeildIdx = j; + } + } + mapLines.put(name, nlines); + } + long start = System.currentTimeMillis(); + List halfs = spectrumAnalysisMapper.getHalf(nuclideList); + for(int m=0;m 1 && phd.getVBase().size() == m_nCount) { + if(start < 1){ + start = 1; + } + if(end > m_nCount || end < 1){ + end = m_nCount; + } + + for(int i=start-1; i Differance(PHDFile phd, List vecPeak, List m_vCount, long m_nCount){ + System.loadLibrary("GammaAnaly"); + List pointlist = new LinkedList<>(); + int start =0; + long end = -1; + int peakNum = vecPeak.size(); + if(peakNum < 1 || phd.getVBase().size() != m_nCount){ + return pointlist; + } + + if(start < 1){ + start = 1; + } + if(end > m_nCount || end < 1){ + end = m_nCount; + } + + // 找出在所给范围的第一道拟合峰和最后一道拟合峰的索引下标 + int index = 0; + int startPeak = -1; + int endPeak = peakNum-1; + while(index < peakNum && start > vecPeak.get(index).right){ + ++index; + } + if(index < peakNum) { + startPeak = index; + while(index < peakNum && vecPeak.get(index).left < end){ + ++index; + } + endPeak = index-1; + } + if(startPeak < 0 || startPeak > endPeak){ + return pointlist; + } + + List regPeak = new LinkedList<>(); + int channel = 1; + for(int i=start-1; i= peak.left && channel <= peak.right) { + if(CollectionUtils.isEmpty(regPeak)) { + List regChan = new LinkedList<>(); + for(double d=peak.left; d<=peak.right; d+=1.0){ + regChan.add(d); + } + List vBase = phd.getVBase(); + List t_base = vBase.subList(peak.left-1, peak.right); + regPeak = CalValuesHandler.interp1(peak, t_base, regChan); + } + // 差值 = 原谱值 - 峰面积 + SeriseData seriseData = new SeriseData(); + seriseData.setX(channel); + seriseData.setY(m_vCount.get(i) - regPeak.get(channel-peak.left)); + pointlist.add(seriseData); + } else if(m_vCount.get(i) > 0 && phd.getVBase().get(i) > 0) { + SeriseData seriseData = new SeriseData(); + seriseData.setX(channel); + seriseData.setY(m_vCount.get(i) - phd.getVBase().get(i)); + pointlist.add(seriseData); + } else{ + SeriseData seriseData = new SeriseData(); + seriseData.setX(channel); + seriseData.setY(0); + pointlist.add(seriseData); + } + + if(vecPeak.get(startPeak).right < channel) { + ++startPeak; regPeak.clear(); + } + if(startPeak > endPeak){ + break; + } + } + for(int i=channel; i 0 && phd.getVBase().get(i) > 0) { + SeriseData seriseData = new SeriseData(); + seriseData.setX(i+1); + seriseData.setY(m_vCount.get(i) - phd.getVBase().get(i)); + pointlist.add(seriseData); + } else { + SeriseData seriseData = new SeriseData(); + seriseData.setX(i+1); + seriseData.setY(0); + pointlist.add(seriseData); + } + } + + return pointlist; + } + + public void ReadData(List m_vEnergy, List m_vNuclide){ + try { + String filePath = parameterFilePath+File.separator+"Energy_Nuclide.txt"; + File file = new File(filePath); + List readLines = FileUtils.readLines(file, "UTF-8"); + for (int i=0; i= 2 && m_curParam.getP().get(2) > 0) { + // Polynomial: y=a0+a1*x+a2*x^2+a3*x^3 + equation +="Energy = "+m_curParam.getP().get(1)+" + C * "+m_curParam.getP().get(2); + for(int i=3; i<=p_size; ++i) { + equation += " + C" + (i-1) +" * "+m_curParam.getP().get(i)+""; + } + } else if(p_size == 1) { + equation = "Energy = "+m_curParam.getP().get(1)+" * C"; + } + return equation; + } + + public void UpdateChartEnergy(List m_vCurEnergy, ParameterInfo m_curParam, List m_vCurCentroid, PHDFile phd, Map map) { + System.loadLibrary("GammaAnaly"); + int num = m_vCurEnergy.size(); + if(num < 1){ + return; + } + List datalist = new LinkedList<>(); + if(CollectionUtils.isNotEmpty(m_curParam.getP())) { + // 拟合曲线 + ChartData lData = new ChartData(); + lData.setColor("255, 255, 0"); + lData.setType("Line"); + + List vChan = new LinkedList<>(); + double MaxChan = Double.valueOf(phd.getSpec().getNum_g_channel()); + double d = 1; + double dStep = MaxChan / 30 * 2; + while(d < MaxChan) { + vChan.add(d); + d+= dStep; + } + vChan.add(MaxChan); + + List vFit = CalValuesHandler.calFcnEval(vChan, m_curParam.getP()).counts; + for(int i=0; i 0){ + SeriseData seriseData = new SeriseData(); + seriseData.setX(vChan.get(i)); + seriseData.setY(vFit.get(i)); + lData.getPointlist().add(seriseData); + } + } + if(lData.getPointlist().size() > 1){ + datalist.add(lData); + } + } + + // Channel——Energy 点集 + ChartData pData = new ChartData(); + pData.setColor("red"); + pData.setType("Scatter"); + for(int i=0; i= 2 && m_curParam.getP().get(1) > 0 && m_curParam.getP().get(2) > 0) { + // Square root of polynomial: y = sqrt(a0+a1*x+a2*x^2+a3*x^3 ) + equation += "FWHM = ("+m_curParam.getP().get(1)+" + E * "+m_curParam.getP().get(2); + for(int i=3; i<=p_size; ++i) { + equation += " + E"+(i-1)+" * "+m_curParam.getP().get(i); + } + equation += ")"+1+"/"+2+""; + } + return equation; + } + + public void UpdateChartResolution(List m_vCurEnergy, ParameterInfo m_curParam, List m_vCurReso, PHDFile phd, Map map) { + System.loadLibrary("GammaAnaly"); + int num = m_vCurEnergy.size(); + if(num < 1) return; + + List datalist = new LinkedList<>(); + if(CollectionUtils.isNotEmpty(m_curParam.getP())) { + // 拟合曲线 + ChartData lData = new ChartData(); + lData.setColor("255, 255, 0"); + lData.setType("Line"); + + List vChan = new LinkedList<>(); + vChan.add(1.0); + vChan.add(Double.valueOf(phd.getSpec().getNum_g_channel())); + + List vEner = CalValuesHandler.calFcnEval(vChan, phd.getUsedEnerPara().getP()).counts; + double d = vEner.get(0), maxE = vEner.get(1); + double dStep = maxE / 30 * 2; + + vEner.remove(vEner.size()-1); + while(d < maxE) { + vEner.add(d); + d += dStep; + } + vEner.add(maxE); + + List vFit = CalValuesHandler.calFcnEval(vEner, m_curParam.getP()).counts; + for(int i=0; i 0){ + SeriseData seriseData = new SeriseData(); + seriseData.setX(vEner.get(i)); + seriseData.setY(vFit.get(i)); + lData.getPointlist().add(seriseData); + } + } + if(lData.getPointlist().size() > 1){ + datalist.add(lData); + } + } + + // Channel——Energy 点集 + ChartData pData = new ChartData(); + pData.setColor("red"); + pData.setType("Scatter"); + for(int i=0; i m_vCurEnergy, ParameterInfo m_curParam) { + String equation = ""; + if(m_curParam.getP().size() > 2) { + int p_size = m_curParam.getP().size()-1; + int e_size = m_vCurEnergy.size(); + int funId = m_curParam.getP().get(0).intValue(); + switch(funId) { + case 1: // Interpolation: y=yi+(y(i+1)-yi)*(x-xi)/(x(i+1)-xi) for xi<=x= 4) { + int i = 0; + if(i < 0 || i >= e_size) break; + + double y1, y0, x1, x0; + if(i < e_size - 1) + { + y1 = m_curParam.getP().get(i*2+3); + y0 = m_curParam.getP().get(i*2+1); + x1 = m_curParam.getP().get(i*2+2); + x0 = m_curParam.getP().get(i*2); + } + else { + y1 = m_curParam.getP().get(i*2+1); + y0 = m_curParam.getP().get(i*2-1); + x1 = m_curParam.getP().get(i*2); + x0 = m_curParam.getP().get(i*2-2); + } + equation += "Efficiency = "+y0+" + ("+y1+"-"+y0+") * (E - "+x0+") / ("+x1+" - "+x0+")"; + } + break; + case 5: // HT Efficiency: y = A*exp(-(E1/x)^k)*(1-exp(-(E2/x)^n)) + if(p_size == 5) { + for(int i=1; i<=p_size; ++i) { + if(m_curParam.getP().get(i) <= 0) break; + } + equation += "Efficiency = "+m_curParam.getP().get(1)+" * exp(-("+m_curParam.getP().get(2)+" / E)"+m_curParam.getP().get(3)+") * "+ + "(1-exp(-("+m_curParam.getP().get(4)+" / E)"+m_curParam.getP().get(5)+"))"; + } + break; + case 6: // Polynomial in log(y) against log(x): log(y) = a0 + a1*log(x) +a2*log(x)^2+ a3*log(x)^3 + if(p_size >= 2) { + equation += "log(Efficiency) = "+m_curParam.getP().get(1)+" + "+m_curParam.getP().get(2)+" * log(E)"; + for(int i=3; i<=p_size; ++i) { + equation += " + "+m_curParam.getP().get(i)+" * log(E)"+(i-1)+""; + } + } + break; + case 8: // Polynomial in log(y) against log(1/x): log(y) = a0 + a1*log(c/x) + a2*log(c/x)^2 + a3*log(c/x)^3 + a4*log(c/x)^4 + if(p_size >= 3) { + equation += "log(Efficiency) = "+m_curParam.getP().get(1)+" + "+m_curParam.getP().get(2)+" * log(C/E)"; + for(int i=3; i<=p_size; ++i) { + equation += " + "+m_curParam.getP().get(i)+" * log(C/E)"+(i-1)+""; + } + } + break; + case 93: // HAE Efficiency (1-3): y=S*exp(-(E1/x)^k)*(1- exp(-(2*E3/(x-E3))^n)) + if(p_size == 5) { + equation += "Efficiency = "+m_curParam.getP().get(1)+" * exp(-("+m_curParam.getP().get(2)+" / E)"+m_curParam.getP().get(3)+") * "+ + "(1 - exp(-(2 * "+m_curParam.getP().get(4)+" / (E - "+m_curParam.getP().get(4)+"))"+m_curParam.getP().get(5)+"))"; + } + break; + case 94: // HAE Efficiency (1-2): y=S*exp(-(E1/x)^k)*(1- exp(-b*(1/(x-E2))^m)) + if(p_size == 6) { + equation += "Efficiency = "+m_curParam.getP().get(1)+" * exp(-("+m_curParam.getP().get(2)+" / E)"+m_curParam.getP().get(3)+") * "+ + "(1 - exp(-"+m_curParam.getP().get(4)+" * (1 / (E - "+m_curParam.getP().get(5)+"))"+m_curParam.getP().get(6)+"))"; + } + break; + case 95: // HAE Efficiency (1-2-3): y = S * exp(-(E1/x)^k) * (1- exp(-b*(1/(x-E2))^m)) *(1 - exp(-(2*E3/(E-E3))^n)) + if(p_size == 8) { + equation += "Efficiency = "+m_curParam.getP().get(1)+" * exp(-("+m_curParam.getP().get(2)+" / E)"+m_curParam.getP().get(3)+") * "+ + "(1 - exp(-"+m_curParam.getP().get(4)+" * (1 / (E - "+m_curParam.getP().get(5)+"))"+m_curParam.getP().get(6)+")) * "+ + "(1 - exp(-(2 * "+m_curParam.getP().get(7)+" / (E - "+m_curParam.getP().get(7)+"))"+m_curParam.getP().get(8)+"))"; + } + break; + } + } + return equation; + } + + public void UpdateChartEfficiency(List m_vCurEnergy, ParameterInfo m_curParam, List m_vCurEffi, PHDFile phd, Map map) { + System.loadLibrary("GammaAnaly"); + int num = m_vCurEnergy.size(); + if(num < 1) return; + + List datalist = new LinkedList<>(); + if(CollectionUtils.isNotEmpty(m_curParam.getP())) { + // 拟合曲线 + ChartData lData = new ChartData(); + lData.setColor("255, 255, 0"); + lData.setType("Line"); + + List vChan = new LinkedList<>(); + vChan.add(1.0); + vChan.add(Double.valueOf(phd.getSpec().getNum_g_channel())); + + List vEner = CalValuesHandler.calFcnEval(vChan, phd.getUsedEnerPara().getP()).counts; + double d = vEner.get(0); + double maxE = vEner.get(1); + double dStep = maxE / 30 * 2; + + vEner.remove(vEner.size()-1); + while(d < maxE) { + vEner.add(d); + d += dStep; + } + vEner.add(maxE); + + List vFit = CalValuesHandler.calFcnEval(vEner, m_curParam.getP()).counts; + for(int i=0; i 0){ + SeriseData seriseData = new SeriseData(); + seriseData.setX(vEner.get(i)); + seriseData.setY(vFit.get(i)); + lData.getPointlist().add(seriseData); + } + } + if(lData.getPointlist().size() > 1){ + datalist.add(lData); + } + } + + // Channel——Energy 点集 + ChartData pData = new ChartData(); + pData.setColor("red"); + pData.setType("Scatter"); + for(int i=0; i InitNuclideLine(String editEnergy, double err, String name) { + Double min = null; + Double max = null; + if (StringUtils.isNotBlank(editEnergy) && Objects.nonNull(err)){ + double editEnergyDou = Double.valueOf(editEnergy); + min = editEnergyDou - err; + max = editEnergyDou + err; + } + List nuclideLines = spectrumAnalysisMapper.getNuclideLine(min, max, name); + return nuclideLines; + } + + public Map InitNuclideInfo(String name) { + Map map = new HashMap<>(); + GardsNuclLib nuclideInfo = spectrumAnalysisMapper.getNuclideInfo(name); + if(Objects.nonNull(nuclideInfo)) { + Long numLines = nuclideInfo.getNumLines(); + map.put("lab_lines", numLines.toString()); + if(Objects.isNull(nuclideInfo.getHalflife())) { + map.put("lab_halfLife", ""); + } else { + String units = "D"; + double halflife = nuclideInfo.getHalflife().doubleValue(); + if(halflife >= 1000) { + halflife = halflife / 365.25; + units = "A"; + } else if(halflife < 0.1 && halflife >= 1.0 / 1440.0) { + halflife = halflife * 1440.0; + units = "M"; + } else if(halflife <= 1.0 / 1440.0 && halflife > 0.0) { + halflife = halflife * 86400.0; + units = "S"; + } + char flag = 'f'; + if(halflife >= 1000){ + flag = 'e'; + } + if (flag == 'f'){ + map.put("lab_halfLife", String.format("%.3f", halflife)+units); + } else if (flag == 'e') { + NumberFormat numberFormat = new DecimalFormat("0.###E0"); + String formatNum = numberFormat.format(halflife); + map.put("lab_halfLife", formatNum+units); + } + } + if(Objects.isNull(nuclideInfo.getHalflifeErr())) { + map.put("lab_halfLifeErr", ""); + } else { + map.put("lab_halfLifeErr", String.format("%.3f", nuclideInfo.getHalflifeErr().doubleValue())+"%"); + } + } + return map; + } + + public Map InitParentAndDaughter(String name) { + Map map = new HashMap<>(); + GardsNuclLib parentAndDaughter = spectrumAnalysisMapper.getParentAndDaughter(name); + List parentList = new LinkedList<>(); + if(Objects.nonNull(parentAndDaughter)) { + parentList.add(parentAndDaughter.getParents1()); + parentList.add(parentAndDaughter.getParents2()); + parentList.add(parentAndDaughter.getParents3()); + parentList.add(parentAndDaughter.getParents4()); + parentList.add(parentAndDaughter.getParents5()); + parentList.add(parentAndDaughter.getParents6()); + map.put("list_parent", parentList); + List daughterList = new LinkedList<>(); + TableDaughter tableDaughter1 = new TableDaughter(); + tableDaughter1.setDaughters(parentAndDaughter.getDaughters1()); + tableDaughter1.setBranchingratios(String.format("%.2f", parentAndDaughter.getBranchingratios1().doubleValue())+"%"); + tableDaughter1.setDaughtersstable(parentAndDaughter.getDaughtersstable1().intValue() == 1? "Stable" : "Unstable"); + daughterList.add(tableDaughter1); + TableDaughter tableDaughter2 = new TableDaughter(); + tableDaughter2.setDaughters(parentAndDaughter.getDaughters2()); + tableDaughter2.setBranchingratios(String.format("%.2f", parentAndDaughter.getBranchingratios2().doubleValue())+"%"); + tableDaughter2.setDaughtersstable(parentAndDaughter.getDaughtersstable2().intValue() == 1? "Stable" : "Unstable"); + daughterList.add(tableDaughter2); + TableDaughter tableDaughter3 = new TableDaughter(); + tableDaughter3.setDaughters(parentAndDaughter.getDaughters3()); + tableDaughter3.setBranchingratios(String.format("%.2f", parentAndDaughter.getBranchingratios3().doubleValue())+"%"); + tableDaughter3.setDaughtersstable(parentAndDaughter.getDaughtersstable3().intValue() == 1? "Stable" : "Unstable"); + daughterList.add(tableDaughter3); + TableDaughter tableDaughter4 = new TableDaughter(); + tableDaughter4.setDaughters(parentAndDaughter.getDaughters4()); + tableDaughter4.setBranchingratios(String.format("%.2f", parentAndDaughter.getBranchingratios4().doubleValue())+"%"); + tableDaughter4.setDaughtersstable(parentAndDaughter.getDaughtersstable4().intValue() == 1? "Stable" : "Unstable"); + daughterList.add(tableDaughter4); + TableDaughter tableDaughter5 = new TableDaughter(); + tableDaughter5.setDaughters(parentAndDaughter.getDaughters5()); + tableDaughter5.setBranchingratios(String.format("%.2f", parentAndDaughter.getBranchingratios5().doubleValue())+"%"); + tableDaughter5.setDaughtersstable(parentAndDaughter.getDaughtersstable5().intValue() == 1? "Stable" : "Unstable"); + daughterList.add(tableDaughter5); + map.put("table_daughter", daughterList); + } + return map; + } + + public String GetReportContent(PHDFile phd, boolean bLog) { + GStoreMiddleProcessData middleData = new GStoreMiddleProcessData(); + this.GetInterMiddlData(phd, "", middleData); + if(bLog) { + return this.GetLogContent(middleData); + } else { + return this.GetReportContent(middleData); + } + } + + public boolean GetInterMiddlData(PHDFile phd, String userName, GStoreMiddleProcessData middleData){ + boolean bRet = true; + Map temp = new HashMap<>(); + try { + bRet = GetMiddleData(phd, userName, temp,middleData, MiddleDataType.InterAction.getType()); + middleData.analyses_type ="Interactive"; + } catch (ParseException e) { + throw new RuntimeException(e); + } + return bRet; + } + + public String GetLogContent(GStoreMiddleProcessData middleData){ + StringBuffer strBuffer = new StringBuffer(); + strBuffer.append("-------------------------- Sample Analyse Beginning at "+DateUtils.formatDate(new Date(), "yyyy-MM-dd HH:mm:ss")+" ---------------------------\n"); + strBuffer.append("\n"); + strBuffer.append("....................................... Read calibration data ........................................\n"); + strBuffer.append("\n"); + strBuffer.append("Reading gamma energy pairs(sampleID: "+middleData.sample_id+").....\n"); + strBuffer.append("\n"); + for (int i=0;i0) { + strBuffer.append("Energy Calibration ["+middleData.calibration_pairs_E_Input+" ]\n"); + strBuffer.append("Function: "+middleData.calibration_E_functionTypeDef+"\n"); + strBuffer.append("E: "+middleData.calibration_E_functionDef+"\n"); + strBuffer.append("P: "+middleData.calibration_E_coeff_string+"\n"); + strBuffer.append("Err: "+middleData.calibration_E_uncoeff_string+"\n"); + strBuffer.append("Data: "+middleData.calibration_pairs_E_Input+"\n"); + } + if(middleData.calibration_pairs_R_idCalPoint.size()>0) { + strBuffer.append("Resolution Calibration ["+middleData.calibration_pairs_R_Input+" ]\n"); + strBuffer.append("Function: "+middleData.calibration_R_functionTypeDef+"\n"); + strBuffer.append("E: "+middleData.calibration_R_functionDef+"\n"); + strBuffer.append("P: "+middleData.calibration_R_coeff_string+"\n"); + strBuffer.append("Err: "+middleData.calibration_R_uncoeff_string+"\n"); + strBuffer.append("Data: "+middleData.calibration_pairs_R_Input+"\n"); + } + if(middleData.calibration_pairs_EF_idCalPoint.size()>0) { + strBuffer.append("Efficiency Calibration ["+middleData.calibration_pairs_EF_Input+" ]\n"); + strBuffer.append("Function: "+middleData.calibration_EF_functionTypeDef+"\n"); + strBuffer.append("E: "+middleData.calibration_EF_functionDef+"\n"); + strBuffer.append("P: "+middleData.calibration_EF_coeff_string+"\n"); + strBuffer.append("Err: "+middleData.calibration_EF_uncoeff_string+"\n"); + strBuffer.append("Data: "+middleData.calibration_pairs_EF_Input+"\n"); + } + if(middleData.calibration_pairs_T_idCalPoint.size()>0) { + strBuffer.append("Tot_efficiency Calibration ["+middleData.calibration_pairs_T_Input+" ]\n"); + strBuffer.append("Function: "+middleData.calibration_T_functionTypeDef+"\n"); + strBuffer.append("E: "+middleData.calibration_T_functionDef+"\n"); + strBuffer.append("P: "+middleData.calibration_T_coeff_string+"\n"); + strBuffer.append("Err: "+middleData.calibration_T_uncoeff_string+"\n"); + strBuffer.append("Data: "+middleData.calibration_pairs_T_Input+"\n"); + } + strBuffer.append("\n"); + strBuffer.append("........................................ Calibration Finished ........................................"); + strBuffer.append("\n"); + strBuffer.append("..................................... Starting Spectrum Analysis ....................................."); + strBuffer.append("\n"); + strBuffer.append("PROCESSING PARAMETERS.....\n"); + strBuffer.append("ECutAnalysis_Low : "+middleData.setting_specSetup.getECutAnalysis_Low()+"\n"); + strBuffer.append("ECutAnalysis_High : "+middleData.setting_specSetup.getECutAnalysis_High()+"\n"); + strBuffer.append("EnergyTolerance : "+middleData.setting_specSetup.getEnergyTolerance()+"\n"); + strBuffer.append("BaseImprovePSS : "+middleData.setting_specSetup.getBaseImprovePSS()+"\n"); + strBuffer.append("PSS_low : "+middleData.setting_specSetup.getPSS_low()+"\n"); + strBuffer.append("k_back : "+middleData.setting_specSetup.getK_back()+"\n"); + strBuffer.append("k_alpha : "+middleData.setting_specSetup.getK_alpha()+"\n"); + strBuffer.append("k_beta : "+middleData.setting_specSetup.getK_beta()+"\n"); + strBuffer.append("RiskLevelK : "+middleData.setting_specSetup.getRiskLevelK()+"\n"); + strBuffer.append("refTime_act : "+middleData.setting_specSetup.getRefTime_act()+"\n"); + strBuffer.append("refTime_conc : "+middleData.setting_specSetup.getRefTime_conc()+"\n"); + strBuffer.append("\n"); + strBuffer.append("CALIBRATION PARAMETERS.....\n"); + strBuffer.append("\n"); + strBuffer.append("CalibrationPSS_low : "+middleData.setting_specSetup.getCalibrationPSS_low()+"\n"); + strBuffer.append("CalibrationPSS_high : "+middleData.setting_specSetup.getCalibrationPSS_high()+"\n"); + strBuffer.append("bUpdateCal : "+(middleData.setting_specSetup.isBUpdateCal()?"1":"0")+"\n"); + strBuffer.append("KeepCalPeakSearchPeaks : "+(middleData.setting_specSetup.isKeepCalPeakSearchPeaks()?"1":"0")+"\n"); + strBuffer.append("\n"); + double peaksUsed = 0; + for(int m=0;m1) + { + qsNuclidesName = qsNuclidesName+middleData.nucl_ided_Nuclidename.get(middleData.nucl_ided_Nuclidename.size()-1); + } + strBuffer.append("Nuclide Identified.....\n"); + strBuffer.append("\n"); + strBuffer.append("Nuclides Identified : "+qsNuclidesName+"\n"); + strBuffer.append("Keyline Activities for Nuclides with defined Reference Line : \n"); + strBuffer.append("Activity Reference Time : "+middleData.sample_acquisiton_start+"\n"); + strBuffer.append("Concentration Reference Time : "+middleData.sample_collection_start+"\n"); + strBuffer.append("\n"); + for (int i=0;i1) { + qsNuclidesName = qsNuclidesName+middleData.nucl_ided_Nuclidename.get(middleData.nucl_ided_Nuclidename.size()-1); + } + strBuffer.append("#ACTIVITY SUMMARY\n"); + strBuffer.append(" Nuclides Identified: "+qsNuclidesName+"\n"); + strBuffer.append(" Keyline Activities for Nuclides: \n"); + strBuffer.append(" with defined Reference Line: \n"); + strBuffer.append(" Activity Reference Time: "+middleData.sample_acquisiton_start+"\n"); + strBuffer.append(" Concentration Reference Time: "+middleData.sample_collection_start+"\n"); + strBuffer.append(" \n"); + strBuffer.append(" \n"); + strBuffer.append(" \n"); + strBuffer.append(" Nuclide Halflife(s) Activity(Bq) RelErr% MDA(Bq) Conc(uBq/m^3) MDC\n"); + for (int i=0; i0) { + strBuffer.append("#Calibration\n"); + strBuffer.append(" Energy Calibration ["+middleData.calibration_pairs_E_Input+" ]\n"); + strBuffer.append(" Function: "+middleData.calibration_E_functionTypeDef+"\n"); + strBuffer.append(" E: "+middleData.calibration_E_functionDef+"\n"); + strBuffer.append(" P: "+middleData.calibration_E_coeff_string+"\n"); + strBuffer.append(" Err: "+middleData.calibration_E_uncoeff_string+"\n"); + strBuffer.append(" Data: "+middleData.calibration_pairs_E_Input+"\n"); + strBuffer.append("\n"); + strBuffer.append("\n"); + strBuffer.append("\n"); + } + if(middleData.calibration_pairs_R_idCalPoint.size()>0) { + strBuffer.append(" Resolution Calibration ["+middleData.calibration_pairs_R_Input+" ]\n"); + strBuffer.append(" Function: "+middleData.calibration_R_functionTypeDef+"\n"); + strBuffer.append(" E: "+middleData.calibration_R_functionDef+"\n"); + strBuffer.append(" P: "+middleData.calibration_R_coeff_string+"\n"); + strBuffer.append(" Err: "+middleData.calibration_R_uncoeff_string+"\n"); + strBuffer.append(" Data: "+middleData.calibration_pairs_R_Input+"\n"); + strBuffer.append("\n"); + strBuffer.append("\n"); + strBuffer.append("\n"); + } + if(middleData.calibration_pairs_EF_idCalPoint.size()>0) { + strBuffer.append(" Efficiency Calibration ["+middleData.calibration_pairs_EF_Input+" ]\n"); + strBuffer.append(" Function: "+middleData.calibration_EF_functionTypeDef+"\n"); + strBuffer.append(" E: "+middleData.calibration_EF_functionDef+"\n"); + strBuffer.append(" P: "+middleData.calibration_EF_coeff_string+"\n"); + strBuffer.append(" Err: "+middleData.calibration_EF_uncoeff_string+"\n"); + strBuffer.append(" Data: "+middleData.calibration_pairs_EF_Input+"\n"); + strBuffer.append("\n"); + strBuffer.append("\n"); + strBuffer.append("\n"); + } + if(middleData.calibration_pairs_T_idCalPoint.size()>0) { + strBuffer.append(" Tot_efficiency Calibration ["+middleData.calibration_pairs_T_Input+" ]\n"); + strBuffer.append(" Function: "+middleData.calibration_T_functionTypeDef+"\n"); + strBuffer.append(" E: "+middleData.calibration_T_functionDef+"\n"); + strBuffer.append(" P: "+middleData.calibration_T_coeff_string+"\n"); + strBuffer.append(" Err: "+middleData.calibration_T_uncoeff_string+"\n"); + strBuffer.append(" Data: "+middleData.calibration_pairs_T_Input+"\n"); + strBuffer.append("\n"); + strBuffer.append("\n"); + strBuffer.append("\n"); + } + strBuffer.append("#DATA QUALITY FLAGS\n"); + strBuffer.append(" Name Pass/Fail Value Test\n"); + for (int i=0;i DoubleLimit(List data){ + for(int pos=0;pos DoubleLimit_G(List _data) { + NumberFormat numberFormat = new DecimalFormat("0.##########E0"); + List rdata = new LinkedList<>(); + for(int pos=0;pos<_data.size();pos++) { + if(Objects.isNull(_data.get(pos))) { + rdata.add("NULL"); + } else { + rdata.add(numberFormat.format(_data.get(pos))); + } + } + return rdata; + } + + public String EquationDescription(int funcId) { + String desc = ""; + switch (funcId) + { + case 1: desc = "y=yi+(y(i+1)-yi)*(x-xi)/(x(i+1)-xi) for xi<=x nucline,GStoreMiddleProcessData middleData, String type) throws ParseException { + boolean bRet=true; + + //标准名称规范化 + String dataType = fileAnlyse.getMsgInfo().getData_type(); + String subDirSavePath = ""; + subDirSavePath+=nameStandUtil.GetSysTemSubdir(fileAnlyse.getHeader().getSystem_type()); + subDirSavePath+=nameStandUtil.GetDateTypeSubdir(dataType); + Map fileNames = nameStandUtil.NameStandard(subDirSavePath, fileAnlyse); + String lcName = fileNames.get("lc"); + String scacName = fileNames.get("scac"); + String baselineName = fileNames.get("baseline"); + String logName = fileNames.get("log"); + String rptName = fileNames.get("rpt"); + String saveFileName = fileNames.get("saveFile"); + String path = nameStandUtil.SetFileDir(subDirSavePath, saveFileName); + middleData.analyses_analyst=userName; + String qsSaveFile = path+StringPool.SLASH+saveFileName; + qsSaveFile = qsSaveFile.replace(StringPool.BACK_SLASH, StringPool.SLASH); + String qsLogPath= path+StringPool.SLASH+middleData.analyses_analyst+"_"+logName; + qsLogPath = qsLogPath.replace(StringPool.BACK_SLASH, StringPool.SLASH); + String qsReportPath="Arr"+StringPool.SLASH+path+StringPool.SLASH+middleData.analyses_analyst+"_"+rptName; + qsReportPath = qsReportPath.replace(StringPool.BACK_SLASH, StringPool.SLASH); + + middleData.analyses_save_filePath = qsSaveFile; + middleData.analyses_LogPath = qsLogPath; + middleData.analyses_ReportPath = qsReportPath; + //获取算法数据 + if(type.equals(MiddleDataType.Auto.getType())) { + String anylseBegin; + String anylseEnd; + anylseBegin = DateUtils.formatDate(new Date(), "yyyy/MM/dd HH:mm:ss"); + bRet = AnalyseSpectrum(fileAnlyse,nucline); + anylseEnd = DateUtils.formatDate(new Date(), "yyyy/MM/dd HH:mm:ss"); + middleData.analyses_analysisBegin = anylseBegin; + middleData.analyses_analysisEnd = anylseEnd; + } + + + //gards_analyses + String qsBaseLinePath = path+StringPool.SLASH+middleData.analyses_analyst+"_"+baselineName; + qsBaseLinePath = qsBaseLinePath.replace(StringPool.BACK_SLASH, StringPool.SLASH); + // m_baseLineFileName; + String qsLcPath= path+StringPool.SLASH+middleData.analyses_analyst+"_"+lcName; + qsLcPath = qsLcPath.replace(StringPool.BACK_SLASH, StringPool.SLASH); + String qsScacPath= path+StringPool.SLASH+middleData.analyses_analyst+"_"+scacName; + qsScacPath = qsScacPath.replace(StringPool.BACK_SLASH, StringPool.SLASH); + + + + String qsSaveBaseLine = StringPool.SLASH+spectrumPathProperties.getRootPath()+StringPool.SLASH+qsBaseLinePath; + String qsSaveLc = StringPool.SLASH+spectrumPathProperties.getRootPath()+StringPool.SLASH+qsLcPath; + String qsSaveScac = StringPool.SLASH+spectrumPathProperties.getRootPath()+StringPool.SLASH+qsScacPath; + middleData.analyses_baseline_filePath = qsSaveBaseLine; + middleData.analyses_lc_filePath = qsSaveLc; + middleData.analyses_scac_filePath = qsSaveScac; +// WriteBaseInfo(fileAnlyse.getBaseCtrls(),qsSaveBaseLine); +// WriteLcScac(fileAnlyse.getVLc(),"Lc",qsSaveLc); +// WriteLcScac(fileAnlyse.getVScac(),"Scac",qsSaveScac); + + double totalNumber = 0.0; + for(int m=0;m temp = new LinkedList<>(); + for(int pos=0;pos temp = new LinkedList<>(); + for(int pos=0;pos temp = new LinkedList<>(); + for(int pos=0;pos temp = new LinkedList<>(); + for(int pos=0;pos0) { + funcType = fileAnlyse.getUsedEnerPara().getP().get(0).intValue(); + } + for(int m=1;m0) { + coeffEnergy+=numberFormat.format(fileAnlyse.getUsedEnerPara().getP().get(coeffNumber-1)); + } + + uncerNumber = fileAnlyse.getUsedEnerPara().getPerr().size(); + for(int m=0;m0) { + uncerEnergy+=numberFormat.format(fileAnlyse.getUsedEnerPara().getPerr().get(uncerNumber-1)); + } + funcDefEnergy = EquationDescription(funcType); + funcTypeDefEnergy = EquationName(funcType); + middleData.calibration_E_Caltype = CalType.ENERGY_CAL.getType(); + middleData.calibration_E_function = funcType; + middleData.calibration_E_functionDef = funcDefEnergy; + middleData.calibration_E_functionTypeDef = funcTypeDefEnergy; + middleData.calibration_E_startOfRange = 0; + middleData.calibration_E_endOfRange = 1; + middleData.calibration_E_coeff_string = coeffEnergy; + + + String coeffEffi = ""; + String uncerEffi = ""; + String funcDefEffi = ""; + String funcTypeDefEffi = ""; + coeffNumber = fileAnlyse.getUsedEffiPara().getP().size(); + if(coeffNumber>0) { + funcType = fileAnlyse.getUsedEffiPara().getP().get(0).intValue(); + } + for(int m=1;m0) { + coeffEffi+=numberFormat.format(fileAnlyse.getUsedEffiPara().getP().get(coeffNumber-1)); + } + + uncerNumber = fileAnlyse.getUsedEffiPara().getPerr().size(); + for(int m=0;m0) { + uncerEffi+= numberFormat.format(fileAnlyse.getUsedEffiPara().getPerr().get(uncerNumber-1)); + } + funcDefEffi = EquationDescription(funcType); + funcTypeDefEffi = EquationName(funcType); + middleData.calibration_EF_Caltype = "efficiency"; + middleData.calibration_EF_function = funcType; + middleData.calibration_EF_functionDef = funcDefEffi; + middleData.calibration_EF_functionTypeDef = funcTypeDefEffi; + middleData.calibration_EF_startOfRange = 0; + middleData.calibration_EF_endOfRange = 1; + middleData.calibration_EF_coeff_string = coeffEffi; + + String coeffReso = ""; + String uncerReso = ""; + String funcDefReso = ""; + String funcTypeDefReso = ""; + coeffNumber = fileAnlyse.getUsedResoPara().getP().size(); + if(coeffNumber>0) { + funcType = fileAnlyse.getUsedResoPara().getP().get(0).intValue(); + } + for(int m=1;m0) { + coeffReso+= numberFormat.format(fileAnlyse.getUsedResoPara().getP().get(coeffNumber-1)); + } + + uncerNumber = fileAnlyse.getUsedResoPara().getPerr().size(); + for(int m=0;m0) { + uncerReso+= numberFormat.format(fileAnlyse.getUsedResoPara().getPerr().get(uncerNumber-1)); + } + funcDefReso = EquationDescription(funcType); + funcTypeDefReso = EquationName(funcType); + middleData.calibration_R_Caltype = "Resolution"; + middleData.calibration_R_function = funcType; + middleData.calibration_R_functionDef = funcDefReso; + middleData.calibration_R_functionTypeDef = funcTypeDefReso; + middleData.calibration_R_startOfRange = 0; + middleData.calibration_R_endOfRange = 1; + middleData.calibration_R_coeff_string = coeffReso; + + String coeffTotE = ""; + String uncerTotE = ""; + String funcDefTotE = ""; + String funcTypeDefTotE = ""; + coeffNumber = fileAnlyse.getUsedTotEPara().getP().size(); + if(coeffNumber>0) { + funcType = fileAnlyse.getUsedTotEPara().getP().get(0).intValue(); + } + for(int m=1;m0) { + coeffTotE+= numberFormat.format(fileAnlyse.getUsedTotEPara().getP().get(coeffNumber-1)); + } + + uncerNumber = fileAnlyse.getUsedTotEPara().getPerr().size(); + for(int m=0;m0) { + uncerTotE+= numberFormat.format(fileAnlyse.getUsedTotEPara().getPerr().get(uncerNumber-1)); + } + funcDefTotE = EquationDescription(funcType); + funcTypeDefTotE = EquationName(funcType); + middleData.calibration_T_Caltype = "TotalEfficiency"; + middleData.calibration_T_function = funcType; + middleData.calibration_T_functionDef = funcDefTotE; + middleData.calibration_T_functionTypeDef = funcTypeDefTotE; + middleData.calibration_T_startOfRange = 0; + middleData.calibration_T_endOfRange = 1; + middleData.calibration_T_coeff_string = coeffTotE; + + //gards_ peaks数据表 + + if(fileAnlyse.getVPeak().size() != 0) { + List dvctIDPEAK = new LinkedList<>(); + List dvctCENTROIDCHANNEL = new LinkedList<>(); + List dvctUNCCENTROIDCHANNEL = new LinkedList<>(); + List dvctENERGY = new LinkedList<>(); + List dvctUNCENERGY = new LinkedList<>(); + List dvctAREA = new LinkedList<>(); + List dvctnetCountRate = new LinkedList<>(); + List dvctuncNetCountRate = new LinkedList<>(); + List dvctUNCAREA = new LinkedList<>(); + List dvctEFFICIENCY = new LinkedList<>(); + List dvctUNCEFFICIENCY = new LinkedList<>(); + List dvctFWHM = new LinkedList<>(); + List dvctFWTM = new LinkedList<>(); + List dvctSIGNIFICANCE = new LinkedList<>(); + List dvctSENSITIVITY = new LinkedList<>(); + List dvctMULTIINDEX = new LinkedList<>(); + List dvctROISTART = new LinkedList<>(); + List dvctROIEND = new LinkedList<>(); + List dvctTAIL = new LinkedList<>(); + List dvctTAILALPHA = new LinkedList<>(); + List dvctUPPERTAIL = new LinkedList<>(); + List dvctUPPERTAILALPHA = new LinkedList<>(); + List dvctBWWIDTHCHAN = new LinkedList<>(); + List dvctRECOILBETACHAN = new LinkedList<>(); + List dvctRECOILDELTACHAN = new LinkedList<>(); + List dvctSTEPRAIO = new LinkedList<>(); + List dvctBACKGROUNDAREA = new LinkedList<>(); + List dvctMEANBACKCOUNT = new LinkedList<>(); + List dvctLC = new LinkedList<>(); + List dvctLD = new LinkedList<>(); + List dvctNuclide_name = new LinkedList<>(); + List dvctComments = new LinkedList<>(); + for(int m=0;m 1024){ + t_comment = t_comment.substring(0, 1025); + } + dvctComments.add(t_comment); + + String qsName = ""; + for(int n=0;n svctNUCLIDEFULLNAME = new LinkedList<>(); + List dvctIDPEAK = new LinkedList<>(); + List dvctENERGY = new LinkedList<>(); + List dvctUNCENERGY = new LinkedList<>(); + List dvctABUNDANCE = new LinkedList<>(); + List dvctUNCABUNDANCE = new LinkedList<>(); + List dvctACTIVITY = new LinkedList<>(); + List dvctUNCACTIVITY = new LinkedList<>(); + List dvctEFFIC = new LinkedList<>(); + List dvctUNEFFIC = new LinkedList<>(); + List dvctMDA = new LinkedList<>(); + List dvctKEY_FLAG = new LinkedList<>(); + List dvctCSC_RATIO = new LinkedList<>(); + List dvctCSC_RATIO_ERR = new LinkedList<>(); + List dvctCSC_MOD_FLAG = new LinkedList<>(); + List dvctMDC = new LinkedList<>(); + List dvctCONCENTRATION = new LinkedList<>(); + for(Map.Entry itor:fileAnlyse.getMapNucActMda().entrySet()) { + int first=itor.getValue().getFullNames().size(); + int second=itor.getValue().getVPeakIdx().size(); + first = first svctNUCLIDEFULLNAME1 = new LinkedList<>(); + List svctTYPE = new LinkedList<>(); + List dvctHALFLIFE = new LinkedList<>(); + List dvctAVE_ACTIV = new LinkedList<>(); + List dvctAVE_ACTIV_ERR = new LinkedList<>(); + List dvctACTIV_KEY = new LinkedList<>(); + List dvctACTIV_KEY_ERR = new LinkedList<>(); + List dvctMDA1 = new LinkedList<>(); + List dvctMDA_ERR = new LinkedList<>(); + List dvctNID_FLAG = new LinkedList<>(); + List dvctCSC_RATIO1 = new LinkedList<>(); + List dvctCSC_RATIO_ERR1 = new LinkedList<>(); + List dvctCSC_MOD_FLAG1 = new LinkedList<>(); + List dvctMDC1 = new LinkedList<>(); + List dvctCONCENTRATION1 = new LinkedList<>(); + List dvctKey_Energy = new LinkedList<>(); + List dvctKey_Yield = new LinkedList<>(); + + if( fileAnlyse.getMapNucActMda().size() != 0) { + for(Map.Entry itor_v: fileAnlyse.getMapNucActMda().entrySet()) { + String nuclideName = itor_v.getKey(); + svctNUCLIDEFULLNAME1.add(nuclideName); + dvctHALFLIFE.add(itor_v.getValue().getHalflife()); + dvctACTIV_KEY.add(itor_v.getValue().getActivity()); + dvctACTIV_KEY_ERR.add(itor_v.getValue().getAct_err()); + dvctMDA1.add(numberFormat.format(itor_v.getValue().getMda())); + dvctMDC1.add(numberFormat.format(itor_v.getValue().getMdc())); + dvctCONCENTRATION1.add(numberFormat.format(itor_v.getValue().getConcentration())); + dvctCSC_RATIO1.add(1.0); + dvctCSC_RATIO_ERR1.add(0.0); + if(itor_v.getValue().getCalculateIdx() >= 0 && itor_v.getValue().getCalculateIdx()= 0 && itor_v.getValue().getCalculateIdx() qvctQC_NAME = new LinkedList<>(); + List dvctQC_VALUE = new LinkedList<>(); + List qvctQC_STANDARD = new LinkedList<>(); + List dvctQC_RESULT = new LinkedList<>(); + if( fileAnlyse.getQcItems().size() != 0) { + for(Map.Entry itor_q:fileAnlyse.getQcItems().entrySet()) { + String nuclideName = itor_q.getKey(); + qvctQC_NAME.add(nuclideName); + dvctQC_VALUE.add(itor_q.getValue().getValue()); + qvctQC_STANDARD.add(itor_q.getValue().getStandard()); + dvctQC_RESULT.add(itor_q.getValue().isBPass()?1.0:0.0); + } + middleData.QC_CHECK_QC_NAME=qvctQC_NAME; + middleData.QC_CHECK_QC_RESULT=DoubleLimit_G(dvctQC_RESULT); + middleData.QC_CHECK_QC_STANDARD=qvctQC_STANDARD; + middleData.QC_CHECK_QC_VALUE=DoubleLimit_G(dvctQC_VALUE); + } + + //sample info + middleData.sample_collection_start = fileAnlyse.getCollect().getCollection_start_date()+" "+fileAnlyse.getCollect().getCollection_start_time(); + middleData.sample_collection_stop = fileAnlyse.getCollect().getCollection_stop_date()+" "+fileAnlyse.getCollect().getCollection_stop_time(); + + if(Objects.nonNull(fileAnlyse.getQcItems().get("col_time"))) { + middleData.sample_time = String.format("%.4f", fileAnlyse.getQcItems().get("col_time").getValue()); + if(fileAnlyse.getQcItems().get("col_time").getValue()!=0) { + middleData.sample_Avg_Flow_Rate = String.format("%.5f", fileAnlyse.getCollect().getAir_volume()/fileAnlyse.getQcItems().get("col_time").getValue()); + } + } + if(Objects.nonNull(fileAnlyse.getQcItems().get("decay_time"))) { + middleData.sample_decay_time = String.format("%.5f", fileAnlyse.getQcItems().get("decay_time").getValue()); + } + if(Objects.nonNull(fileAnlyse.getQcItems().get("acq_time"))) { + middleData.sample_acquistion_time = String.format("%.5f", fileAnlyse.getQcItems().get("acq_time").getValue()); + } + middleData.sample_quantity = String.format("%.4f", fileAnlyse.getCollect().getAir_volume()); + middleData.sample_acquisiton_start = fileAnlyse.getAcq().getAcquisition_start_date()+" "+fileAnlyse.getAcq().getAcquisition_start_time(); + String acquisition_start = middleData.sample_acquisiton_start; + Date dataTime = DateUtils.parseDate(acquisition_start.substring(0, acquisition_start.indexOf(StringPool.DOT)), "yyyy/MM/dd HH:mm:ss"); + acquisition_start = DateUtils.formatDate(dataTime, "yyyy/MM/dd HH:mm:ss"); + middleData.sample_acquistion_stop = DateUtils.formatDate(new Date((long) (dataTime.getTime()/1000 + fileAnlyse.getAcq().getAcquisition_live_time())), "yyyy/MM/dd HH:mm:ss"); + middleData.sample_acquistion_time = String.format("%.2f", fileAnlyse.getAcq().getAcquisition_real_time()) ; + 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.setting_specSetup = fileAnlyse.getUsedSetting(); + + middleData.Collection_Station_Comments = fileAnlyse.getOriTotalCmt(); + middleData.NDC_Analysis_General_Comments = fileAnlyse.getTotalCmt(); + return bRet; + } + + public Map UpdateDatasNuclideActivity(Map mapNucAct, Date act_ref, Date con_ref) { + Map map = new HashMap<>(); + map.put("dateTime_act_ref", act_ref); + map.put("dateTime_con_ref", con_ref); + + //m_mapAct = mapNucAct; + int size_map = mapNucAct.size(); + if(size_map < 1){ + return map; + } + List nuclideActivityList = new LinkedList<>(); + for(Map.Entry iter:mapNucAct.entrySet()){ + TableNuclideActivity tableNuclideActivity = new TableNuclideActivity(); + NuclideActMda nuc = iter.getValue(); + tableNuclideActivity.setNuclide(iter.getKey()); + char units = 'S'; + double halflife = nuc.getHalflife(); + if(halflife >= 31556736) // 1年 = 365.24 * 24 * 60 * 60 = 31556736s + { + halflife /= 31556736; + units = 'A'; + } + else if(halflife >= 86400) // 1天 = 24 * 60 * 60 = 86400s + { + halflife /= 86400; + units = 'D'; + } + else if(halflife >= 3600) + { + halflife /= 3600; + units = 'H'; + } + tableNuclideActivity.setHalfLife(halflife+" "+units); + tableNuclideActivity.setEnergy(nuc.getVEnergy().get(nuc.getCalculateIdx()).toString()); + tableNuclideActivity.setYield(String.valueOf(nuc.getVYield().get(nuc.getCalculateIdx())*100)); + + String str_effi = (nuc.getEfficiency() <= 0 ? "null" : String.valueOf(nuc.getEfficiency())); + tableNuclideActivity.setEfficiency(str_effi); + + String str_act = (nuc.getActivity() <= 0 ? "null" : String.valueOf(nuc.getActivity())); + tableNuclideActivity.setActivity(str_act); + + String str_act_err = (nuc.getActivity() <= 0 ? "null" : String.valueOf(nuc.getAct_err() / nuc.getActivity() * 100)); + tableNuclideActivity.setActErr(str_act_err); + + String str_mda = (nuc.getMda() <= 0 ? "null" : String.valueOf(nuc.getMda())); + tableNuclideActivity.setMda(str_mda); + + String str_con = (nuc.getConcentration() <= 0 ? "null" : String.valueOf(nuc.getConcentration())); + tableNuclideActivity.setConc(str_con); + + String str_mdc = (nuc.getMdc() <= 0 ? "null" : String.valueOf(nuc.getMdc())); + tableNuclideActivity.setMdc(str_mdc); + nuclideActivityList.add(tableNuclideActivity); + } + map.put("table", nuclideActivityList); + return map; + } + + public String RightFill(String str, int fieldWidth) { + String fillChar = " "; + int fillNum = fieldWidth - str.length(); + while(fillNum > 0) { + str+=fillChar; + --fillNum; + } + return str; + } + + public String MakeUpSpectrum(PHDFile phd) { + StringBuffer spectrum = new StringBuffer(); + + spectrum.append("BEGIN IMS2.0\r\n"); + spectrum.append("MSG_TYPE "+phd.getMsgInfo().getMsg_type()+"\r\n"); + spectrum.append("MSG_ID "+phd.getMsgInfo().getMsg_id()+" "+phd.getMsgInfo().getMsg_src_code()+"\r\n"); + if(phd.getMsgInfo().isVerify_srid()) { + spectrum.append("REF_ID\r\n"); + spectrum.append(phd.getMsgInfo().getRef_id_str()+" "+phd.getMsgInfo().getRef_src_code()+" "+phd.getMsgInfo().getSeq_num()+" "+phd.getMsgInfo().getTot_num()+"\r\n"); + spectrum.append("PROD_ID "+phd.getMsgInfo().getProduct_id()+" "+phd.getMsgInfo().getDelivery_id()+"\r\n"); + } + spectrum.append("DATA_TYPE "+phd.getMsgInfo().getData_type()+"\r\n"); + + List data_types = new LinkedList<>(); + data_types.add("SAMPLEPHD"); + data_types.add("SPHDF"); + data_types.add("SPHDP"); + data_types.add("GASBKPHD"); + data_types.add("BLANKPHD"); + data_types.add("DETBKPHD"); + data_types.add("QCPHD"); + data_types.add("CALIBPHD"); + + if(!data_types.contains(phd.getMsgInfo().getData_type())){ + return spectrum.toString(); + } + + // #Header + spectrum.append("#Header "+phd.getHeader().getDesignator()+"\r\n"); + spectrum.append(RightFill(phd.getHeader().getSite_code(), 5)+ + " "+RightFill(phd.getHeader().getDetector_code(), 9)+ + " "+RightFill(phd.getHeader().getSystem_type().toUpperCase(), 1)+ + " "+RightFill(phd.getHeader().getSample_geometry(), 17)+ + " "+RightFill(phd.getHeader().getSpectrum_quantity(), 4)+"\r\n"); + spectrum.append(phd.getHeader().getSample_ref_id() + "\r\n"); + spectrum.append(RightFill(phd.getHeader().getMeasurement_id(), 31)+" "+RightFill(phd.getHeader().getDetector_bk_measurement_id(), 31)+" "+phd.getHeader().getGas_bk_measurement_id()+"\r\n"); + spectrum.append(phd.getHeader().getTransmit_date()+" "+phd.getHeader().getTransmit_time()+"\r\n"); + + // #Comment + if(StringUtils.isNotBlank(phd.getOriTotalCmt())) { + String comment = phd.getOriTotalCmt().replace("\r\n", "\n"); + comment.replace("\n", "\r\n"); + spectrum.append("#Comment\r\n"); + spectrum.append(comment + "\r\n"); + } + + // #Collection + spectrum.append("#Collection\r\n"); + spectrum.append(phd.getCollect().getCollection_start_date()+" "+phd.getCollect().getCollection_start_time()+ + " "+phd.getCollect().getCollection_stop_date()+" "+phd.getCollect().getCollection_stop_time()+" "+phd.getCollect().getAir_volume()+"\r\n"); + + // #Acquisition + spectrum.append("#Acquisition\r\n"); + spectrum.append(phd.getAcq().getAcquisition_start_date()+" "+phd.getAcq().getAcquisition_start_time()+ + " "+RightFill(String.format("%.2f", phd.getAcq().getAcquisition_real_time()), 14)+ + " "+RightFill(String.format("%.2f", phd.getAcq().getAcquisition_live_time()), 14)+"\r\n"); + + // #Processing + if(phd.getProcess().getSample_volume_of_Xe() > 0) { + spectrum.append("#Processing\r\n"); + spectrum.append(RightFill(String.valueOf(phd.getProcess().getSample_volume_of_Xe()), 8)+" "+RightFill(String.valueOf(phd.getProcess().getUncertainty_1()), 8)+"\r\n"+ + " "+RightFill(String.valueOf(phd.getProcess().getXe_collection_yield()), 8)+" "+RightFill(String.valueOf(phd.getProcess().getUncertainty_2()), 8)+"\r\n"+ + " "+phd.getProcess().getArchive_bottle_id()+"\r\n"); + } + + // #Sample + if(phd.getSampleBlock().getDimension_1() > 0) { + spectrum.append("#Sample\r\n"); + spectrum.append(phd.getSampleBlock().getDimension_1()+" "+phd.getSampleBlock().getDimension_2()+"\r\n"); + } + + // Certificate + if(CollectionUtils.isNotEmpty(phd.getCertificate().getG_energy())) { + spectrum.append("#Certificate\r\n"); + spectrum.append(phd.getCertificate().getTotal_source_activity()+""+ phd.getCertificate().getAssay_date()+"" + + phd.getCertificate().getAssay_time()+""+phd.getCertificate().getUnits_activity() + "\r\n"); + + int fieldWidth = 12; + for(int i=0; i 0) { + spectrum.append("#TotalEff\r\n"); + TotaleffBlock g_totE = phd.getUsedTotEKD(); + for(int i=0; i 0 ? channel-1 : channel; // 确保索引大于等于0 + if(phd.getVEnergy().size() == m_nCount && index < m_nCount) // 确保索引有效 + { + int index2 = (index < m_nCount-1 ? index + 1 : index - 1); + double y1 = phd.getVEnergy().get(index); + double y2 = phd.getVEnergy().get(index2); + y = y1 + (y2 - y1) / (index2 - index) * (channel - index); + } + return y; + } + + public List InitList(double energy, double tolerance, List nuclides){ + if(nuclides.size() < 1){ + return new LinkedList<>(); + } + double min = energy - tolerance; + double max = energy + tolerance; + List nuclideList = spectrumAnalysisMapper.findNuclideList(min, max, nuclides); + return nuclideList; + } + + public void InitTable(String name, Map map, PHDFile phd){ + InitNuclideInfo(name, map); + long span = phd.getSpec().getG_energy_span(); + List nuclideTableList = spectrumAnalysisMapper.getNuclideTable(name, span); + if (CollectionUtils.isNotEmpty(nuclideTableList)){ + map.put("table", nuclideTableList); + InitChart(nuclideTableList, phd, map); + } + } + + public void InitNuclideInfo(String name, Map map){ + map.put("name", name); + + GardsNuclLib nuclideInfo = spectrumAnalysisMapper.getNuclideInfo(name); + if(Objects.nonNull(nuclideInfo)) { + map.put("lines", nuclideInfo.getNumLines()); + if(Objects.isNull(nuclideInfo.getHalflife())) { + map.put("halfLife", ""); + } else { + String units = "D"; + double halflife = nuclideInfo.getHalflife().doubleValue(); + if(halflife >= 1000) { + halflife = halflife / 365.25; + units = "A"; + } else if(halflife < 0.1 && halflife >= 1.0 / 1440) { + halflife = halflife * 1440; + units = "M"; + } else if(halflife <= 1.0 / 1440 && halflife > 0) { + halflife = halflife * 86400; + units = "S"; + } + halflife = halflife + 0.0001; + map.put("halfLife", String.format("%.3f", halflife) + units); + } + if(Objects.isNull(nuclideInfo.getHalflifeErr())) { + map.put("halfLifeErr", ""); + } else { + map.put("halfLifeErr", String.format("%.3f", nuclideInfo.getHalflifeErr().doubleValue())+"%"); + } + } + } + + public void InitChart(List nuclideTableList, PHDFile phd, Map map){ + List> chartList = new LinkedList<>(); + for (int i=0; i < nuclideTableList.size(); i++){ + Map chartMap = new HashMap<>(); + GardsNuclLinesLib item = nuclideTableList.get(i); + double energy = item.getEnergy(); + List chartData = Energy_Count_Base(energy, 30, phd); + String title = "Line" + (i+1); + String bottom = "Abundance:" + item.getYield(); + String selPos = energy+""; + String cursorText = energy + " keV"; + chartMap.put("chartData", chartData); + chartMap.put("title", title); + chartMap.put("bottom", bottom); + chartMap.put("selPos", selPos); + chartMap.put("cursorText", cursorText); + chartList.add(chartMap); + } + map.put("chart", chartList); + } + + public List Energy_Count_Base(double energy, int chanNum, PHDFile phd) { + List datalist = new LinkedList<>(); + int channel = GetChannelByEnergy(energy, 0, phd); + int start = channel-chanNum/2, end = channel+chanNum/2; + if(start < 1) { + start = 1; + end = start + chanNum; + } else if(end > phd.getSpec().getNum_g_channel()) { + end = (int) phd.getSpec().getNum_g_channel(); + start = end - chanNum; + } + datalist.add(Energy_CountCahrt(start, end, phd)); + datalist.add(Energy_BaseLine(start, end, phd)); + return datalist; + } + + public ChartData Energy_CountCahrt(int start, int end, PHDFile phd) { + ChartData data1 = new ChartData(); + if(phd.getSpec().getNum_g_channel() > 1 && phd.getVEnergy().size() == phd.getSpec().getNum_g_channel()) { + if(start < 1){ + start = 1; + } + if(end < 1 || end > phd.getSpec().getNum_g_channel()){ + end = (int) phd.getSpec().getNum_g_channel(); + } + for(int i=start-1; iSpectrum.counts[i] == 0) continue; + data1.getPointlist().add(seriseData); + } + data1.setName("Energy"); + data1.setGroup("energy"); + data1.setColor("255,255,0"); // 颜色：原谱:0；峰:1；Lc:2；BaseLine:3；Scac:4；比较谱:5； + } + return data1; + } + + public ChartData Energy_BaseLine(int start, int end, PHDFile phd) { + ChartData cData = new ChartData(); + if(phd.getSpec().getNum_g_channel() > 1 && phd.getVEnergy().size() == phd.getSpec().getNum_g_channel() && phd.getVBase().size() == phd.getSpec().getNum_g_channel()) { + if(start < 1){ + start = 1; + } + if(end > phd.getSpec().getNum_g_channel() || end < 1){ + end = (int) phd.getSpec().getNum_g_channel(); + } + + for(int i=start-1; i= energy) { + if(phd.getVEnergy().get(i) - energy > energy - phd.getVEnergy().get(i-1)){ + channel = i; // 道在索引(i-1)处 + } else{ + channel = i+1; // 道在索引(i)处 + } + break; + } + } + return channel; + } + + public void InitPara(PHDFile phd){ + List Acal_tail_para = new LinkedList<>(); + Acal_tail_para.add(99.0); + Acal_tail_para.add(0.0); + Acal_tail_para.add(0.0); + Acal_tail_para.add(0.0); + phd.getPara_tail().setP(Acal_tail_para); + List Acal_tail_alpha_para = new LinkedList<>(); + Acal_tail_alpha_para.add(98.0); + Acal_tail_alpha_para.add(1.0); + phd.getPara_tailAlpha().setP(Acal_tail_alpha_para); + List Acal_tail_right_para = new LinkedList<>(); + Acal_tail_right_para.add(98.0); + Acal_tail_right_para.add(0.35); + phd.getPara_tailRight().setP(Acal_tail_right_para); + List Acal_tail_right_alpha_para = new LinkedList<>(); + Acal_tail_right_alpha_para.add(98.0); + Acal_tail_right_alpha_para.add(1.0); + phd.getPara_tailRightAlpha().setP(Acal_tail_right_alpha_para); + List Acal_step_ratio_para = new LinkedList<>(); + Acal_step_ratio_para.add(98.0); + Acal_step_ratio_para.add(0.0); + phd.getPara_stepRatio().setP(Acal_step_ratio_para); + } + + public void PeaksChanged(PHDFile phd) { + System.loadLibrary("GammaAnaly"); + List vCentroid = new LinkedList<>(); + List vFwhmCh = new LinkedList<>(); + List vTail = new LinkedList<>(); + List vUpperTail = new LinkedList<>(); + for (PeakInfo peak: phd.getVPeak()) { + vCentroid.add(peak.peakCentroid); + vFwhmCh.add(peak.fwhmc); + vTail.add(peak.tail); + vUpperTail.add(peak.upperTail); + } + //重新计算各个peak的左值 右值 multiIndex + StructInsertOutput structInsertOutput = CalValuesHandler.ComputePeakRange(phd.getVPeak().size(), (int) phd.getSpec().getNum_g_channel(), vCentroid, vFwhmCh, vTail, vUpperTail); + System.out.println(structInsertOutput.vLeft.size()); + } + + public int FindNearPeak(List vPeak, int channel, boolean bFind) { + boolean t_bFind = false; + int i=0, peakNum = vPeak.size(); + for(; i= peak.left && channel <= peak.right) { + // 如果 channel 在峰的左右边界内 + if(peak.multiIndex > 0 && channel > peak.peakCentroid) { + // 如果是重峰，且 channel 在重峰的第一个峰的中心道右侧 + int j = i; + double temp = channel - peak.peakCentroid; + while(++j < peakNum && vPeak.get(j).multiIndex == peak.multiIndex) { + if(Math.abs(vPeak.get(j).peakCentroid - channel) < temp) // 找出重峰中峰中心道离 channel 最近的峰 + { + temp = Math.abs(vPeak.get(j).peakCentroid - channel); + i = j; + } + } + } + // channel 在索引(i)对应的峰内 + t_bFind = true; + break; + } else if(peak.left > channel) { + // channel 不在任何峰内，找离它最近的峰 + if(i>0 && channel-vPeak.get(i-1).peakCentroid < peak.peakCentroid-channel) i -= 1; + break; + } + } + if(i >= peakNum) i -= 1; + if(bFind) bFind = t_bFind; + return i; + } + + public List FitPeakBaseLine(PHDFile phd, List vIdx){ + List tablePeaksList = new LinkedList<>(); + int peakNum = vIdx.size(); + for (int i=0; i InitPeakTable(List vPeak) { + List result = new LinkedList<>(); + for(int i=0; i vPeakIdx) { + if(lines.halflife <= 0) { + return; + } + // 过滤核素能量小于ECutAnalysis_Low的射线 + FilterNuclideLine(lines, phd.getUsedSetting().getECutAnalysis_Low()); + + // 获取需特殊处理的核素 + Map mapHalflife = new HashMap<>(); // 用其他核素半衰期计算活度/浓度的核素 + List vNuclides = new LinkedList<>(); // 只识别不计算活度/浓度的核素 + ReadSpecialNuclides(mapHalflife, vNuclides); + + double energyWidth = phd.getUsedSetting().getEnergyTolerance(); + List vEnergy = lines.vEnergy; // 该核素的所有γ射线能量 + double maxYield = 0; + int mainPeakIdx = -1; // 记录核素主γ峰的索引下标 + + NuclideActMda ActMda = new NuclideActMda(); + ActMda.setHalflife(Objects.isNull(mapHalflife.get(nucName))?lines.halflife : mapHalflife.get(nucName)); + for (int i=0, j=0; i maxYield) { + maxYield = ActMda.getVYield().get(i); + mainPeakIdx = ActMda.getVPeakIdx().get(i)-1; + ActMda.setCalculateIdx(i); + } + } + if(mainPeakIdx < 0) { + return; + } + + // 如果该核素属特殊核素，则用“特殊核素配置文件”中指明的其他核素的半衰期 + double halflife = Objects.isNull(mapHalflife.get(nucName))?lines.halflife : mapHalflife.get(nucName); + double lambda = Math.log(2.0) / halflife; + + CalculateMDCs(phd, ActMda, mainPeakIdx, lambda, maxYield, 1.0); + + ActMda.setBCalculateMDA(true); + phd.getMapNucActMda().put(nucName, ActMda); + } + + public void ReCalcMdaMdc(PHDFile phd, String nuclide, int removePeakIdx) { + NuclideActMda it = phd.getMapNucActMda().get(nuclide); + if(Objects.isNull(it)) { + return; + } + NuclideActMda nuc = it; + // 如果该核素只与一个峰对应则直接删除该核素的 MDA 信息 + if(nuc.getVPeakIdx().size() == 1) { + phd.getMapNucActMda().remove(nuclide); + return; + } + // 否则删除该核素与该峰所有关联的射线信息 + boolean needReCalc = false; + for(int i=nuc.getVPeakIdx().size()-1; i>=0; i--) { + if(nuc.getVPeakIdx().get(i) == removePeakIdx) { + nuc.getVEnergy().remove(i); + nuc.getVUncertE().remove(i); + nuc.getVYield().remove(i); + nuc.getVUncertY().remove(i); + nuc.getFullNames().remove(i); + if(nuc.getCalculateIdx() == i && nuc.isBCalculateMDA()) { + needReCalc = true; + } + } + } + nuc.getVPeakIdx().remove(removePeakIdx); + // 如果该核素只与一个峰对应则直接删除该核素的 MDA 信息 + if(nuc.getVPeakIdx().size() < 1) { + phd.getMapNucActMda().remove(nuclide); + return; + } + + if(needReCalc) { + double maxYield = 0; + int mainPeakIdx = -1; + for(int j=0; j maxYield) { + nuc.setCalculateIdx(j); + maxYield = nuc.getVYield().get(j); + mainPeakIdx = nuc.getVPeakIdx().get(j)-1; + } + } + if(mainPeakIdx < 0) { + return; + } + CalculateMDCs(phd, nuc, mainPeakIdx, Math.log(2.0)/nuc.getHalflife(), maxYield, 1.0); + } + } + +} diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/common/NameStandUtil.java b/jeecg-module-auto-process/src/main/java/org/jeecg/common/NameStandUtil.java new file mode 100644 index 00000000..9a98db16 --- /dev/null +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/common/NameStandUtil.java @@ -0,0 +1,196 @@ +package org.jeecg.common; + +import com.baomidou.mybatisplus.core.toolkit.StringPool; +import org.jeecg.common.util.DateUtils; +import org.jeecg.modules.base.enums.DataType; +import org.jeecg.modules.base.enums.SystemType; +import org.jeecg.modules.entity.vo.PHDFile; +import org.springframework.stereotype.Component; + +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.text.ParseException; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +@Component +public class NameStandUtil { + + public String GetSysTemSubdir(String systemType) { + StringBuffer path = new StringBuffer(); + if(systemType.contains(SystemType.BETA.getType())) { + path.append(StringPool.SLASH+"Spectrum"); + path.append(StringPool.SLASH+"Xenon"); + path.append(StringPool.SLASH+"Sauna"); + } else if(systemType.contains(SystemType.GAMMA.getType())) { + path.append(StringPool.SLASH+"Spectrum"); + path.append(StringPool.SLASH+"Xenon"); + path.append(StringPool.SLASH+"Spalax"); + } else if(systemType.contains(SystemType.PARTICULATE.getType())) { + path.append(StringPool.SLASH+"Spectrum"); + path.append(StringPool.SLASH+"Particulates"); + } + return path.toString(); + } + + public String GetDateTypeSubdir(String dataType){ + StringBuffer path = new StringBuffer(); + if(dataType.contains(DataType.SAMPLEPHD.getType())) + { + path.append(StringPool.SLASH+"Samplephd"); + } + else if(dataType.contains(DataType.QCPHD.getType())) + { + path.append(StringPool.SLASH+"Qcphd"); + } + else if(dataType.contains(DataType.DETBKPHD.getType())) + { + path.append(StringPool.SLASH+"Detbkphd"); + } + else if(dataType.contains(DataType.GASBKPHD.getType())) + { + path.append(StringPool.SLASH+"Gasbkphd"); + } + else if(dataType.contains(DataType.SOH.getType())) + { + path.append(StringPool.SLASH+"Soh"); + } + else if(dataType.contains(DataType.MET.getType())) + { + path.append(StringPool.SLASH+"Met"); + } + else if(dataType.contains(DataType.ALERT_FLOW.getType())|| + dataType.contains(DataType.ALERT_SYSTEM.getType())|| + dataType.contains(DataType.ALERT_TEMP.getType())|| + dataType.contains(DataType.ALERT_UPS.getType())) + { + path.append(StringPool.SLASH+"Alert"); + } + else if(dataType.contains(DataType.ERROR.getType())) + { + path.append(StringPool.SLASH+"Error"); + } + else + { + path.append(StringPool.SLASH+"Other"); + } + return path.toString(); + } + + public Map NameStandard(String path, PHDFile fileAnlyse) { + String suffix = GetSuffix(fileAnlyse.getMsgInfo().getData_type(),fileAnlyse.getHeader().getSystem_type(),fileAnlyse.getHeader().getSpectrum_quantity(),String.valueOf(fileAnlyse.getAcq().getAcquisition_live_time())); + Map fileNames = NameStandardByName(path, fileAnlyse.getFilename(), fileAnlyse.getHeader().getMeasurement_id(),suffix); + return fileNames; + } + + public String GetSuffix(String dataType,String sysType,String Fulltype,String LT) { + String rData = ""; + BigDecimal bd = new BigDecimal(LT); + if(dataType.contains(DataType.SAMPLEPHD.getType())) { + bd = bd.setScale(1, RoundingMode.HALF_UP); + rData = "_S_"+Fulltype+"_"+bd+".PHD"; + } else if(dataType.contains(DataType.GASBKPHD.getType())){ + bd = bd.setScale(1, RoundingMode.HALF_UP); + rData = "_G_"+Fulltype+"_"+bd+".PHD"; + }else if(dataType.contains(DataType.DETBKPHD.getType())){ + bd = bd.setScale(0, RoundingMode.HALF_UP); + rData = "_D_"+Fulltype+"_"+bd+".PHD"; + }else if(dataType.contains(DataType.QCPHD.getType())){ + bd = bd.setScale(2, RoundingMode.HALF_UP); + rData = "_Q_"+Fulltype+"_"+bd+".PHD"; + } + return rData; + } + + public Map NameStandardByName(String path, String fileName, String dateTimeFormat, String suffix) { + Map map = new HashMap<>(); + String StandardFileName=""; + String measurementName = GetFileNameFromDateTime(dateTimeFormat, suffix); + String fileDir = path + StringPool.SLASH; + if(measurementName != fileName) { + StandardFileName = fileDir+measurementName; + } + String fileSuffix = "PHD"; + + String m_lcFileName = StandardFileName; + String m_baseLineFileName = StandardFileName; + String m_scacFileName = StandardFileName; + String m_logfileName = StandardFileName; + String m_reportFileName = StandardFileName; + + m_lcFileName.replace(fileSuffix,"lc"); + m_baseLineFileName.replace(fileSuffix,"baseline"); + m_scacFileName.replace(fileSuffix,"scac"); + m_logfileName.replace(fileSuffix,"log"); + m_reportFileName.replace("."+fileSuffix,"_rpt"); + + String m_saveFileName = StandardFileName; + + map.put("lc", m_lcFileName); + map.put("baseline", m_baseLineFileName); + map.put("scac", m_scacFileName); + map.put("log", m_logfileName); + map.put("rpt", m_reportFileName); + map.put("saveFile", m_saveFileName); + return map; + } + + public String GetFileNameFromDateTime(String dateTimeFormat, String suffix){ + String rData = ""; + int pos = dateTimeFormat.indexOf("-"); + if(-1 != pos) { + String dateTime = dateTimeFormat; + if (pos+17>dateTime.length()){ + dateTime = dateTime.substring(pos+1); + }else { + dateTime = dateTime.substring(pos+1, pos+17); + } + dateTime = dateTime.replace(" ","-"); + String fileHeader = dateTimeFormat.substring(0, pos+1); + String temp = DateTimeStandardToFileFormat(dateTime); + rData = fileHeader+ temp + suffix; + } + return rData; + } + + public String DateTimeStandardToFileFormat(String data) { + String dateTime = ""; + try { + if ( data.indexOf("-") > 0 ){ + dateTime = DateUtils.formatDate(DateUtils.parseDate(data,"yyyy/MM/dd-HH:mm"), "yyyyMMdd_HHmm"); + } else if( data.indexOf(" ") > 0 ) { + dateTime = DateUtils.formatDate(DateUtils.parseDate(data,"yyyy/MM/dd HH:mm"), "yyyyMMdd_HHmm"); + } else if( data.indexOf("-")<0 && data.indexOf(" ") < 0) { + dateTime = DateUtils.formatDate(DateUtils.parseDate(data,"yyyy/MM/dd"), "yyyyMMdd"); + } + } catch (ParseException e) { + throw new RuntimeException(e); + } + return dateTime; + } + + public String SetFileDir(String path, String saveFileName) { + String input_file_name = path; + //添加文件名日期 + List dateSub = GetSubDirByFileName(saveFileName); + for(int pos=0;pos GetSubDirByFileName(String fileName) { + List rData = new LinkedList<>(); + int pos = fileName.indexOf('-'); + if(-1 == pos) { + // + } else if(fileName.length()>=pos+7) { + rData.add(fileName.substring(pos+1, pos+5)); + rData.add(fileName.substring(pos+5, pos+7)); + } + return rData; + } + +} diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsAnalysesSpectrum.java b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsAnalysesSpectrum.java new file mode 100644 index 00000000..0e9397b1 --- /dev/null +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsAnalysesSpectrum.java @@ -0,0 +1,149 @@ +package org.jeecg.modules.eneity; + +import com.fasterxml.jackson.annotation.JsonFormat; +import lombok.Data; +import org.springframework.format.annotation.DateTimeFormat; + +import java.io.Serializable; +import java.util.Date; + +@Data +public class GardsAnalysesSpectrum implements Serializable { + + /** + * 分析ID号 + */ + private Integer idAnalysis; + + /** + * 样品id + */ + private Integer sampleId; + + /** + * 分析开始时间 + */ + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private Date analysisBegin; + + /** + * 开始时间-字符串 + */ + private String analysisBeginStr; + + /** + * 分析结束时间 + */ + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private Date analysisEnd; + + /** + * 结束时间-字符串 + */ + private String analysisEndStr; + + /** + * Reviewed:交互,auto:自动 + */ + private String type; + + /** + * 使用的软件名称 + */ + private String software; + + /** + * 软件版本号 + */ + private String swVersion; + + /** + * 分析员名称 + */ + private String analyst; + + /** + * 基线计数方法描述 + */ + private String baselineMethod; + + /** + * 寻峰方法描述 + */ + private String peaksMethod; + + /** + * 核素识别方法描述 + */ + private String nuclideMethod; + + /** + * 不确定度计算描述 + */ + private String uncCalcMethod; + + /** + * Lc计算方法描述 + */ + private String lcMethod; + + /** + * 寻峰起始道 + */ + private Integer searchStartChannel; + + /** + * 寻峰结束道 + */ + private Integer searchEndChannel; + + /** + * 寻峰阈值 + */ + private Double searchThreshold; + + /** + * 峰数目 + */ + private Integer numberOfPeaks; + + /** + * 总计数 + */ + private Float totalCounts; + + /** + * 分级结果 + */ + private Integer category; + + /** + * 注释 + */ + private String comments; + + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private Date moddate; + + private String usedgasphd; + + private String useddetphd; + + private Integer usedgasphdId; + + private Integer useddetphdId; + + private String baselinePath; + + private String lcPath; + + private String scacPath; + + private String logPath; + + private String reportPath; + +} diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsCalibrationPairsSpectrum.java b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsCalibrationPairsSpectrum.java new file mode 100644 index 00000000..d31a5830 --- /dev/null +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsCalibrationPairsSpectrum.java @@ -0,0 +1,60 @@ +package org.jeecg.modules.eneity; + +import com.fasterxml.jackson.annotation.JsonFormat; +import lombok.Data; +import org.springframework.format.annotation.DateTimeFormat; + +import java.io.Serializable; +import java.util.Date; + +@Data +public class GardsCalibrationPairsSpectrum implements Serializable { + + /** + * 样品id + */ + private Integer sampleId; + + /** + * 分析ID号 + */ + private Integer idAnalysis; + + /** + * G：gamma探测器的数据，#g_；B：beta探测器的数据,#b_ + */ + private String sampleType; + + /** + * energy：能量刻度； + * efficiency：效率刻度； + * Resolution：分辨率刻度 + */ + private String caltype; + + /** + * PHD：代表数据来自PHD文件；External：代表数据来自外部，如刻度工具、其它文件等 + */ + private String input; + + /** + * 刻度点ID号 + */ + private Integer idCalPoint; + + private Double xValue; + + private Double yValue; + + private String decayMode; + + /** + * y值不确定度 + */ + private String uncYValue; + + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private Date moddate; + +} diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsCalibrationSpectrum.java b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsCalibrationSpectrum.java new file mode 100644 index 00000000..4f185996 --- /dev/null +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsCalibrationSpectrum.java @@ -0,0 +1,106 @@ +package org.jeecg.modules.eneity; + +import com.fasterxml.jackson.annotation.JsonFormat; +import lombok.Data; +import org.springframework.format.annotation.DateTimeFormat; + +import java.io.Serializable; +import java.util.Date; + +@Data +public class GardsCalibrationSpectrum implements Serializable { + + /** + * 样品id + */ + private Integer sampleId; + + /** + * 分析ID号 + */ + private Integer idAnalysis; + + /** + * G：gamma探测器的数据，#g_；B：beta探测器的数据,#b_ + */ + private String sampleType; + + /** + * energy：能量刻度； + * efficiency：效率刻度； + * Resolution：分辨率刻度 + */ + private String calType; + + /** + * 拟合方程ID号（统一定义） + */ + private Integer function; + + /** + * 拟合方程描述 + */ + private String functionDef; + + /** + * 拟合的起始值 + */ + private Integer startOfRange; + + /** + * 拟合的结束值 + */ + private Integer endOfRange; + + /** + * 拟合系数1 + */ + private Double coeff1; + + /** + * 拟合系数2 + */ + private Double coeff2; + + /** + * 拟合系数3 + */ + private Double coeff3; + + /** + * 拟合系数4 + */ + private Double coeff4; + + /** + * 拟合系数5 + */ + private Double coeff5; + + /** + * 拟合系数6 + */ + private Double coeff6; + + /** + * 拟合系数7 + */ + private Double coeff7; + + /** + * 拟合系数8 + */ + private Double coeff8; + + /** + * 拟合系数9 + */ + private Double coeff9; + + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private Date moddate; + + private String coeffString; + +} diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsNuclIdedSpectrum.java b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsNuclIdedSpectrum.java new file mode 100644 index 00000000..552b1c09 --- /dev/null +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsNuclIdedSpectrum.java @@ -0,0 +1,103 @@ +package org.jeecg.modules.eneity; + +import com.fasterxml.jackson.annotation.JsonFormat; +import lombok.Data; +import org.springframework.format.annotation.DateTimeFormat; + +import java.io.Serializable; +import java.util.Date; + +@Data +public class GardsNuclIdedSpectrum implements Serializable { + + /** + * 样品id + */ + private Integer sampleId; + + /** + * 分析ID号 + */ + private Integer idAnalysis; + + /** + * 核素名称 + */ + private String nuclideName; + + /** + * 核素类型 + */ + private String type; + + /** + * 核素半衰期 + */ + private String halflife; + + /** + * 平均活度值 + */ + private String aveActiv; + + /** + * 平均活度值不确定度 + */ + private Double aveActivErr; + + /** + * 主射线活度值 + */ + private Double activKey; + + /** + * 主射线活度值不确定度 + */ + private Double activKeyErr; + + /** + * 核素的最小可探测活度 + */ + private String mda; + + /** + * 核素的最小可探测活度不确定度 + */ + private Double mdaErr; + + /** + * 核素识别标志 + */ + private Integer nidFlag; + + private Double activDecay; + + private Double activDecayErr; + /** + * 符合相加校正因子（无设为1） + */ + private Double cscRatio; + + /** + * 符合相加校正因子不确定度（无设为0） + */ + private Double cscRatioErr; + + /** + * 活度是否经过符合相加校正 + */ + private Integer cscModFlag; + + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8") + @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private Date moddate; + + private String mdc; + + private String concentration; + + private String keyEnergy; + + private String keyYield; + +} diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsNuclLinesIdedSpectrum.java b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsNuclLinesIdedSpectrum.java new file mode 100644 index 00000000..83a16d5c --- /dev/null +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsNuclLinesIdedSpectrum.java @@ -0,0 +1,108 @@ +package org.jeecg.modules.eneity; + +import com.fasterxml.jackson.annotation.JsonFormat; +import lombok.Data; +import org.springframework.format.annotation.DateTimeFormat; + +import java.io.Serializable; +import java.util.Date; + +@Data +public class GardsNuclLinesIdedSpectrum implements Serializable { + + /** + * 样品id + */ + private Integer sampleId; + + /** + * 峰序号 + */ + private Integer idPeak; + + /** + * 分析ID号 + */ + private Integer idAnalysis; + + /** + * 核素名称 + */ + private String nuclideName; + + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private Date moddate; + + /** + * 核素库中核素对应峰的能量（keV） + */ + private Double energy; + + /** + * 核素库中核素对应峰的能量不确定度（keV） + */ + private Double uncEnergy; + + /** + * 核素库中核素对应峰的发射几率 + */ + private Double abundance; + + /** + * 核素库中核素对应峰的发射几率不确定度 + */ + private Double uncAbundance; + + /** + * 利用该峰计算得到的活度 + */ + private String activity; + + /** + * 利用该峰计算得到的活度不确定度 + */ + private Double uncActivity; + + /** + * 该峰处的探测效率 + */ + private Double effic; + + /** + * 该峰处的探测效率不确定度 + */ + private Double unEffic; + + /** + * 利用该峰计算得到的最小可探测活度 + */ + private Double mda; + + /** + * 主射线标识：0－否；1－是 + */ + private Double keyFlag; + + /** + * 符合相加校正因子（无设为1） + */ + private Double cscRatio; + + /** + * 符合相加校正因子不确定度（无设为0） + */ + private Double cscRatioErr; + + /** + * 活度是否经过符合相加校正 + */ + private Double cscModFlag; + + private String nuclidefullname; + + private String mdc; + + private String concentration; + +} diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsPeaksSpectrum.java b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsPeaksSpectrum.java new file mode 100644 index 00000000..67cd8452 --- /dev/null +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsPeaksSpectrum.java @@ -0,0 +1,131 @@ +package org.jeecg.modules.eneity; + +import com.fasterxml.jackson.annotation.JsonFormat; +import lombok.Data; +import org.springframework.format.annotation.DateTimeFormat; + +import java.io.Serializable; +import java.util.Date; + +@Data +public class GardsPeaksSpectrum implements Serializable { + + /** + * 样品id + */ + private Integer sampleId; + + /** + * 峰序号 + */ + private Integer idPeak; + + /** + * 分析ID号 + */ + private Integer idAnalysis; + + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private Date moddate; + + /** + * 峰中心道（道址） + */ + private Double centroidChannel; + + /** + * 峰中心道不确定度（道址） + */ + private Double uncCentroidChannel; + + /** + * 峰中心道能量（keV） + */ + private Double energy; + + /** + * 峰中心道能量不确定度（keV） + */ + private Double uncEnergy; + + /** + * 峰面积（计数）。已扣除基线面积，但未扣除空白样品计数和探测器本底计数 + */ + private Double area; + + /** + * 峰面积不确定度（计数） + */ + private Double uncArea; + + /** + * 峰的净计数率（1/s）=峰面积/活时间 + */ + private Double netCountRate; + /** + * 峰的净计数率的不确定度（1/s） + */ + private Double uncNetCountRate; + /** + * 测量系统在峰能量处的绝对效率 + */ + private Double efficiency; + /** + * 测量系统在峰能量处的绝对效率的不确定度 + */ + private Double uncefficiency; + /** + * 峰的半高宽（道） + */ + private Double fwhm; + /** + * 峰的十分之一高宽（道） + */ + private Double fwtm; + /** + * 峰的重要性因子 + */ + private Double significance; + /** + * 峰的可探测线Lc + */ + private Double lc; + /** + * 峰的感兴趣区的起始道 + */ + private Double roiStart; + /** + * 峰的感兴趣区的结束道 + */ + private Double roiEnd; + + private Double mulitiIndex; + + private Double tail; + + private Double tailAlpha; + + private Double upperTail; + + private Double upperTailAlpha; + + private Double bwwidthchan; + + private Double recoildeltachan; + + private Double stepraio; + + private Double ld; + + private Double sensitivity; + + private Double backgroundarea; + + private Double meanbackcount; + + private Double recoilbetachan; + + private String peakcomments; + +} diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsQcCheckSpectrum.java b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsQcCheckSpectrum.java new file mode 100644 index 00000000..6899dc9e --- /dev/null +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsQcCheckSpectrum.java @@ -0,0 +1,29 @@ +package org.jeecg.modules.eneity; + +import com.fasterxml.jackson.annotation.JsonFormat; +import lombok.Data; +import org.springframework.format.annotation.DateTimeFormat; + +import java.io.Serializable; +import java.util.Date; + +@Data +public class GardsQcCheckSpectrum implements Serializable { + + private Integer sampleId; + + private Integer idanalysis; + + private String qcName; + + private Double qcValue; + + private String qcStandard; + + private Integer qcResult; + + @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8") + private Date moddate; + +} diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsSampleDataSpectrum.java b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsSampleDataSpectrum.java new file mode 100644 index 00000000..1fd2eb91 --- /dev/null +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/eneity/GardsSampleDataSpectrum.java @@ -0,0 +1,38 @@ +package org.jeecg.modules.eneity; + +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableName; +import lombok.Data; +import org.jeecg.modules.base.entity.original.GardsSampleData; +import org.jeecgframework.poi.excel.annotation.Excel; + +@Data +@TableName("ORIGINAL.GARDS_SAMPLE_DATA") +public class GardsSampleDataSpectrum extends GardsSampleData { + + /** + * 台站名称 + */ + @TableField(exist = false) + @Excel(name = "STATION" ,orderNum = "2") + private String stationName; + + /** + * 探测器名称 + */ + @TableField(exist = false) + private String detectorsName; + + + @TableField(exist = false) + @Excel(name = "CALIB REPORTS" ,orderNum = "7") + private String calibReports; + + @TableField(exist = false) + private String dbName; + + @TableField(exist = false) + @Excel(name = "NO" ,orderNum = "1") + private Integer no; + +} diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/mapper/SpectrumAnalysisMapper.java b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/mapper/SpectrumAnalysisMapper.java new file mode 100644 index 00000000..b10b7792 --- /dev/null +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/mapper/SpectrumAnalysisMapper.java @@ -0,0 +1,51 @@ +package org.jeecg.modules.mapper; + +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.jeecg.modules.base.entity.configuration.GardsNuclLib; +import org.jeecg.modules.base.entity.configuration.GardsNuclLinesLib; +import org.jeecg.modules.base.entity.rnman.GardsAnalySetting; +import org.jeecg.modules.eneity.*; +import org.jeecg.modules.entity.vo.*; + +import java.util.List; + +@Mapper +public interface SpectrumAnalysisMapper { + + String getStatus(@Param(value = "sampleId") Integer sampleId); + + GardsAnalysesSpectrum getAnalysis(@Param(value = "dbName") String dbName, @Param(value = "sampleId") Integer sampleId); + + List getPeaks(@Param(value = "dbName") String dbName, @Param(value = "idAnalysis") Integer idAnalysis); + + List getCalibrationPairs(@Param(value = "dbName") String dbName, @Param(value = "idAnalysis") Integer idAnalysis); + + List getPara(@Param(value = "dbName") String dbName, @Param(value = "idAnalysis") Integer idAnalysis); + + List getNuclLinesIded(@Param(value = "dbName") String dbName, @Param(value = "idAnalysis") Integer idAnalysis); + + List getNuclIded(@Param(value = "dbName") String dbName, @Param(value = "idAnalysis") Integer idAnalysis); + + List getQcCheck(@Param(value = "dbName") String dbName, @Param(value = "idAnalysis") Integer idAnalysis); + + GardsAnalySetting getAnalySetting(@Param(value = "idAnalysis") Integer idAnalysis); + + List getNuclideLines(@Param(value = "name") String name); + + List getHalf(@Param(value = "names") List names); + + List getNuclideLine(@Param(value = "min") Double min, @Param(value = "max") Double max, @Param(value = "name") String name); + + GardsNuclLib getNuclideInfo(@Param(value = "name") String name); + + GardsNuclLib getParentAndDaughter(@Param(value = "name") String name); + + List findNuclideList(@Param(value = "min") Double min, @Param(value = "max") Double max, @Param(value = "nuclides") List nuclides); + + List getNuclideTable( @Param(value = "name") String name, @Param(value = "span") Long span); + + Integer getSampleId(@Param(value = "filePathName") String filePathName); + + +} diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/native_jni/CalValuesOut.java b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/native_jni/CalValuesOut.java new file mode 100644 index 00000000..c2d673a0 --- /dev/null +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/native_jni/CalValuesOut.java @@ -0,0 +1,13 @@ +package org.jeecg.modules.native_jni; + +import java.util.List; + +public class CalValuesOut { + + public int rowNum; + + public int colNum; + + public List counts; + +} diff --git a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/spectrum/Sample_G_Analysis.java b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/spectrum/Sample_G_Analysis.java index cf89f4ed..e1fc6119 100644 --- a/jeecg-module-auto-process/src/main/java/org/jeecg/modules/spectrum/Sample_G_Analysis.java +++ b/jeecg-module-auto-process/src/main/java/org/jeecg/modules/spectrum/Sample_G_Analysis.java @@ -6,9 +6,16 @@ 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.google.common.collect.Maps; import lombok.Data; -import org.jeecg.common.constant.DateConstant; -import org.jeecg.common.constant.Setting; +import org.apache.commons.lang3.StringUtils; +import org.jeecg.common.GammaFileUtil; +import org.jeecg.common.constant.*; +import org.jeecg.common.constant.enums.SpectrumSystemType; +import org.jeecg.common.properties.SpectrumPathProperties; +import org.jeecg.common.util.RedisUtil; +import org.jeecg.modules.base.bizVo.AttributeItemVo; +import org.jeecg.common.util.MyLogFormatUtil; import org.jeecg.modules.base.dto.*; import org.jeecg.modules.base.entity.original.GardsSampleData; import org.jeecg.modules.base.entity.rnauto.*; @@ -31,11 +38,58 @@ public class Sample_G_Analysis { // Sample谱结构体数据 private EnergySpectrumStruct energySpectrumStruct; + // 能谱文件存储路径属性 + private SpectrumPathProperties spectrumPathProperties; + + private RedisUtil redisUtil; + + /** + * 系统类型 + */ + private String systemType; + + /** + * 数据类型 + */ + private String dataType; + + /** + * 样品谱地址 + */ + private String sampleInputFilename; + + /** + * 样品谱名称 + */ + private String sampleFilename; + + /** + * 日志文件路径 + */ + private String logFilePath; + /** + * 日志文件名称 + */ + private String logFileName; + /** + * 报告文件路径 + */ + private String arrFilePath; + /** + * 报告文件名称 + */ + private String arrFileName; + public Sample_G_Analysis(EnergySpectrumStruct energySpectrumStruct,SpectrumServiceQuotes serviceQuotes, GardsSampleData sampleData) { this.sampleData = sampleData; this.serviceQuotes = serviceQuotes; this.energySpectrumStruct = energySpectrumStruct; + this.systemType = energySpectrumStruct.system_type; + this.dataType = energySpectrumStruct.data_type; + this.sampleInputFilename = sampleData.getInputFileName(); + this.sampleFilename = StringUtils.substring(sampleData.getInputFileName(), + sampleData.getInputFileName().lastIndexOf((StringConstant.SLASH)+1)); } public void analysis(){ @@ -44,6 +98,24 @@ public class Sample_G_Analysis { GStoreMiddleProcessData middleData = new GStoreMiddleProcessData(); Integer sampleId = sampleData.getSampleId(); + GammaFileUtil gammaFileUtil = new GammaFileUtil(); + PHDFile phdFile = new PHDFile(); + + // todo 获取数据库 Gamma 默认参数 + // todo 文件路径 + middleData.setAnalyses_save_filePath(this.sampleInputFilename); + // todo 读取文件内容并附值 + this.setPHDFile(phdFile, this.energySpectrumStruct); + // todo 根据系统类型传入不同的核素参数 + Map nuclideLibs = new HashMap<>(); + if (this.systemType.equals(SpectrumSystemType.P.name())) { + nuclideLibs = this.getNuclideLinesP(); + } + if (this.systemType.equals(SpectrumSystemType.G.name())) { + nuclideLibs = this.getNuclideLinesG(); + } + gammaFileUtil.GetMiddleData(phdFile, CommonConstant.REPORT_PREFIX_AUTO, nuclideLibs, middleData, "1"); + // 保存分析结果 ==> INSERT INTO RNAUTO.GARDS_ANALYSES saveAnalysis(middleData,sampleId); // 获取分析结果ID ==> SELECT IDANALYSIS @@ -72,6 +144,312 @@ public class Sample_G_Analysis { } } + private void writeLog(String logFilePath, GStoreMiddleProcessData middleData) { + 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))); + + 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_xValue(), 3)); + data.add(item); + item = new AttributeItemVo("Error", MyLogFormatUtil.getValuePoint(middleData.getCalibration_pairs_S_EF_xValue(), 3)); + data.add(item); + writes.addAll(MyLogFormatUtil.getBlockContext(data)); + + // Reading gamma Resolution pairs(sampleID: %1) + writes.add(MyLogFormatUtil.getHeaderFormat(MyLogFormatUtil.GSetSampleResolutionChannel.replace("%1", sampleId))); + + 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_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))); + 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(infoMap)); + + // Starting Data Quality..... + writes.add(MyLogFormatUtil.getHeaderFormat(MyLogFormatUtil.GGetDataQuality)); + 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(infoMap)); + + // 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)); + } + + private static List getAttribute(List channel, String channelUnit, List energys, String energyUnit, + List errors, String errorUnit){ + + List> data = new ArrayList<>(); + List result = new ArrayList<>(); + + // 初始化数据 + for (int i = 0; i < channel.size(); i++) { + data.add(Arrays.asList( + "Channel : " + channel.get(i) + " " + channelUnit, + "Energy : " + energys.get(i) + " " + energyUnit, + "Error : " + errors.get(i) + " " + errorUnit) + ); + } + // 计算每列数据中最长的字符串长度 + int[] columnWidths = new int[data.get(0).size()]; + for (List row : data) { + for (int i = 0; i < row.size(); i++) { + columnWidths[i] = Math.max(columnWidths[i], row.get(i).length()); + } + } + + // 构造格式化字符串 + StringBuilder formatBuilder = new StringBuilder(); + for (int i = 0; i < columnWidths.length; i++) { + formatBuilder.append("%-" + (columnWidths[i] + 4) + "s"); + } + formatBuilder.append("\n"); + String format = formatBuilder.toString(); + // 格式化输出日志 + for (List row : data) { + String log = String.format(format, row.toArray()); + result.add(log); + System.out.print(log); + } + return result; + } + + public static void main(String[] args) { + List channels = Arrays.asList("59.541", "88.034", "122.061", "165.857", "391.698", "661.657", "834.838", "898.036", "1115.540", "1173.230", "1332.490", "1836.050"); + List energies = Arrays.asList("0.168", "0.176", "0.174", "0.155", "0.092", "0.059", "0.051", "0.040", "0.040", "0.031", "0.028", "0.022"); + List errors = Arrays.asList("0.003", "0.004", "0.003", "0.003", "0.002", "0.001", "0.001", "0.001", "0.001", "0.001", "0.001", "0.000"); + getAttribute(channels,"",energies,"",errors,""); + } + public void saveAnalysis(GStoreMiddleProcessData middleData,Integer sampleId){ GardsAnalyses analysis = toAnalysis(middleData); analysis.setSampleId(sampleId); @@ -303,12 +681,14 @@ public class Sample_G_Analysis { } } - public void getNuclideLinesG(){ - + public Map getNuclideLinesG() { + Object nuclideLibs = redisUtil.get(RedisConstant.NUCLIDE_LINES_LIB + "G"); + return Objects.isNull(nuclideLibs) ? Maps.newHashMap() : (Map) nuclideLibs; } - public void getNuclideLinesP(){ - + public Map getNuclideLinesP(){ + Object nuclideLibs = redisUtil.get(RedisConstant.NUCLIDE_LINES_LIB + "P"); + return Objects.isNull(nuclideLibs) ? Maps.newHashMap() : (Map) nuclideLibs; } public Map fieldMap(){ @@ -407,7 +787,7 @@ public class Sample_G_Analysis { setting.setECutAnalysis_High(Double.POSITIVE_INFINITY); } String systemType = energySpectrumStruct.system_type; - if (StrUtil.equals(systemType,"P")){ + 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)); @@ -524,4 +904,43 @@ public class Sample_G_Analysis { return new ArrayList<>(); } } + + private void setPHDFile(PHDFile phdFile, EnergySpectrumStruct spectrumStruct) { + 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); + } }