From 862db910809bd287bce9afafe10bc0a18e57d1e2 Mon Sep 17 00:00:00 2001 From: nieziyan Date: Fri, 10 Nov 2023 20:17:24 +0800 Subject: [PATCH] =?UTF-8?q?fix=EF=BC=9A=E9=87=8D=E6=96=B0=E7=BC=96?= =?UTF-8?q?=E5=86=99save?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../jeecg/modules/base/dto/Calibration.java | 11 + .../modules/base/dto/ROIResultsStrDto.java | 66 +++ .../modules/base/dto/XeResultsStrDto.java | 35 ++ .../resources/excelTemplate/SaveExcel.xls | Bin 29696 -> 26624 bytes .../resources/excelTemplate/SaveHtml.html | 67 +-- .../SpectrumAnalysesController.java | 8 +- .../service/ISpectrumAnalysisService.java | 4 +- .../impl/SpectrumAnalysisServiceImpl.java | 438 +++++++++++++++++- 8 files changed, 564 insertions(+), 65 deletions(-) create mode 100644 jeecg-boot-base-core/src/main/java/org/jeecg/modules/base/dto/Calibration.java create mode 100644 jeecg-boot-base-core/src/main/java/org/jeecg/modules/base/dto/ROIResultsStrDto.java create mode 100644 jeecg-boot-base-core/src/main/java/org/jeecg/modules/base/dto/XeResultsStrDto.java diff --git a/jeecg-boot-base-core/src/main/java/org/jeecg/modules/base/dto/Calibration.java b/jeecg-boot-base-core/src/main/java/org/jeecg/modules/base/dto/Calibration.java new file mode 100644 index 00000000..5f739322 --- /dev/null +++ b/jeecg-boot-base-core/src/main/java/org/jeecg/modules/base/dto/Calibration.java @@ -0,0 +1,11 @@ +package org.jeecg.modules.base.dto; + +import lombok.Data; + +@Data +public class Calibration { + + private String beta; + + private String gamma; +} diff --git a/jeecg-boot-base-core/src/main/java/org/jeecg/modules/base/dto/ROIResultsStrDto.java b/jeecg-boot-base-core/src/main/java/org/jeecg/modules/base/dto/ROIResultsStrDto.java new file mode 100644 index 00000000..4eff1545 --- /dev/null +++ b/jeecg-boot-base-core/src/main/java/org/jeecg/modules/base/dto/ROIResultsStrDto.java @@ -0,0 +1,66 @@ +package org.jeecg.modules.base.dto; + +import cn.hutool.core.util.ObjectUtil; +import lombok.Data; +import org.jeecg.common.util.NumUtil; + +@Data +public class ROIResultsStrDto { + + /** + * 感兴趣区ID号 + */ + private Integer roi; + + + /** + * 样品谱感兴趣区总计数 + */ + private Double sGross; + + /** + * 气体本底谱感兴趣区总计数 + */ + private Double gGross; + + /** + * 探测器本底谱感兴趣区总计数 + */ + private Double bGross; + + /** + * 感兴趣区净计数 + */ + private Double net; + + /** + * 感兴趣区净计数不确定度 + */ + private Double netErr; + + /** + * 感兴趣区活度浓度 + */ + private Double conc; + + /** + * 感兴趣区活度浓度不确定度 + */ + private Double concErr; + + /** + * 感兴趣区LC + */ + private String lc; + + private String lcCts = ""; + + /** + * 感兴趣区MDC + */ + private String mdc; + + private String netCount; + + private String concStr; +} diff --git a/jeecg-boot-base-core/src/main/java/org/jeecg/modules/base/dto/XeResultsStrDto.java b/jeecg-boot-base-core/src/main/java/org/jeecg/modules/base/dto/XeResultsStrDto.java new file mode 100644 index 00000000..754f8261 --- /dev/null +++ b/jeecg-boot-base-core/src/main/java/org/jeecg/modules/base/dto/XeResultsStrDto.java @@ -0,0 +1,35 @@ +package org.jeecg.modules.base.dto; + +import lombok.Data; +import org.jeecg.common.util.NumUtil; + +@Data +public class XeResultsStrDto { + /** + * 核素名称 + */ + private String nuclideName; + /** + * 感兴趣区活度浓度 + */ + private Double conc; + + /** + * 感兴趣区活度浓度不确定度 + */ + private Double concErr; + /** + * 感兴趣区MDC + */ + private String mdc; + /** + * 感兴趣区LC + */ + private String lc; + /** + * 感兴趣区识别标示；1：识别到，0，未识别到 + */ + private Integer nidFlag; + + private String concStr; +} diff --git a/jeecg-boot-base-core/src/main/resources/excelTemplate/SaveExcel.xls b/jeecg-boot-base-core/src/main/resources/excelTemplate/SaveExcel.xls index 22c3e55673c9db9e4c0cbcc2ddd5535c31977ab9..80e4219c429c054ded1428aa52320c68298d0cd8 100644 GIT binary patch delta 3163 zcmaJ@T})h65T0|n!0rb2m$D0O*`);v6j&CaEoFh_!j|$6t!=GsQm9q>L!k;yqm5bo zdC~Y#nLcRLL}Oyoq>191m>AP)eK01*)TFUL`k;wMt@WV~KGfLa%-p>T+qLHAoV|1A z@0;(OJ7?#AQ}dVAnW$=5Z2wZJ2vVOvC#}c1McKod%w^M?^5~@nHf+GfJgSPEvX@iS82CtwU(p{P(YG~ zxW7EHAtkQ^EggWAvJN* z8cE6(FiSNnSYa)*XFxN}ro@$54A!o&Wl$T*$^^CXzN8M}&VUwxgzRQrmI0Gz2sBPq zFQBZgt6!0bwM?x6n^K?}#MT1Uu)>x>G4Up-u;ffwM~DM4@dj+BnU7dw7AW2dgTR>8 zMat_*xakW8>vD%v&49 zFnMdsLKKxO?ew{QKE5_#(bFz*EPC2A=xNWOr-S_Cz%yg+5I^hGcVw{Bk@jOuooP&+ z%a}&NYzK$)0j9JNowPbwLmgoYJ^X9Q*6;tV+cY=C@YNl@YbV)7jW9oRP*}{}^NHR#`TDr);Th@8Spm)>CkO)02B`CZhbi~t24zZ0S z4q-?Leq(2Iv%0eYawr3OY32fYvh*B#`HaUU{dQWr3)Cv&d}e_9GdZ(l^&qZ?VJzd` zCXW5$$U62LNcn9``!QICVuJ0>0>g<77!*He0=8!vFqCDqeUfyD))-Kqa5bEkm@B?x zIB8#+ZicuFyI&&E4 zbW3pK(dh!>3rVNjf$s-hzDNEIOKaAt>o(%i!<7SV(sFc&(!=^r`RH`|yOK;^my!d*jeAh1f3}1K;i6Lqr*jVT>%s2*xPJ zox6AM^4N##1GS$9c8OQC_0St<-yc19>uoV6KdrqO=v}*Z0(ZAM6lvZ*!OI#?UaHZ0?k=G=D~3#&vUOuUrpp zmB%r6tEo#~4Ry&yjIW0xa(h#=%!MMgZ-Q+`(z>#mXS!Gd@d3e9r6;^w#e5a@kAJLzJE7Dbd!=3 z$%#&)Ht8lSa`|-gW0Wm7qb2}r;^d#!>DOBMF97&ST#(Q&{_Gl+d)RYMwubXm#UNc?|_%4bP=eA;w* zA5IO;`&5+K!yWR&!_yC4@DKQTdY)EM7-UhNnTQXbpc2xuht_cWoTYO(vZ`oCQe5b? z7d=u(n~8I2=w6M{x`vV5i+;&vBTu2s7jP(=DX$qfO$R>X#rqL;=-iX4%BZ&}u85J* z0&=?fjJnZ&L~RuVO}B<8qy8iv(ITU6Gxy4<8}CQd;iK2T_M-iW+B87Z z-84>`$mnKz)obQn8Fjn$BkIU#uh)lzs!Zr#mhbAD?$xRL>Qyh=kFY(nUJVD`&GxF- z%tvR|i}xey$gJ+waZ=r6uTFV-$xYRkpR^b4N7SYPn(n4?(%fXPdd;|LIfV(l?8pwSO0zMKC~OmJ0Gt>8eLY=f>_T64sILByO`VNDjCq~X_%$SU#h(Z4>R}glhr;rQ17mlrh^iej&O+6HFITqJ|?9uGk-kxmDd zn>KvuxdY(uJ{?qz0EU$xvq6UIek$Bx%$dui(<60oR)NPMaRgZ#DaLZibjsDSBMN({ zjvZmF{NrL;zIX>qYAp6sP=3s2!M0-WmV%>Om|BUZ@XLxt zrD%3bQR$g`LDAAbPf}L);)$R(=*S zce@G}WtCQbsxqfCYN^vnNbIz1rIp)%Bdv4F#A9`xIYsr9CGjKWV|5F2R#rI+Mga2` z!K%4Qa@0C~9KRgFf(05xh`?cI-Rj3k%MSP zv8eK3MzN^!uwp^k%qpa}@ZdPrNc6H8lG&vP6WB}C?!mhd?;?|w55(w)!G2j@8fYuv zwnrurH?A7xOG`J$lK>Ht(uaf3{pwM#;StAAbq$YFewb=_Z1PKp26z0V((n|@$m@^y zFXhxGs$t{g2ZM&a;fOjj0hUYZ2Gl@=Z#E6h% Collection Start: - + Collection Stop: - + Collection TIME(h): @@ -68,7 +68,7 @@ Acquisition Start: - + Acq Real Time(s): @@ -98,13 +98,9 @@ Old Beta Old Gamma - - CH(x) = (?1)+(?2)*x+(?3)x*x - CH(x) = (?1)+(?2)*x+(?3)x*x - - - E(x) = (?1)+(?2)*x+(?3)x*x - E(x) = (?1)+(?2)*x+(?3)x*x + + +   @@ -116,13 +112,9 @@ New Beta New Gamma - - CH(x) = ([[${betaCalibrationSEC.coeff1}]])+([[${betaCalibrationSEC.coeff2}]])*x+([[${betaCalibrationSEC.coeff3}]])x*x - CH(x) = ([[${gammaCalibrationSEC.coeff1}]])+([[${gammaCalibrationSEC.coeff2}]])*x+([[${gammaCalibrationSEC.coeff3}]])x*x - - - E(x) = ([[${betaCalibrationSCE.coeff1}]])+([[${betaCalibrationSCE.coeff2}]])*x+([[${betaCalibrationSCE.coeff3}]])x*x - E(x) = ([[${gammaCalibrationSCE.coeff1}]])+([[${gammaCalibrationSCE.coeff2}]])*x+([[${gammaCalibrationSCE.coeff3}]])x*x + + +   @@ -150,13 +142,9 @@ Old Beta Old Gamma - - CH(x) = (?1)+(?2)*x+(?3)x*x - CH(x) = (?1)+(?2)*x+(?3)x*x - - - E(x) = (?1)+(?2)*x+(?3)x*x - E(x) = (?1)+(?2)*x+(?3)x*x + + +   @@ -168,13 +156,9 @@ New Beta New Gamma - - CH(x) = ([[${betaCalibrationDEC.coeff1}]])+([[${betaCalibrationDEC.coeff2}]])*x+([[${betaCalibrationDEC.coeff3}]])x*x - CH(x) = ([[${gammaCalibrationDEC.coeff1}]])+([[${gammaCalibrationDEC.coeff2}]])*x+([[${gammaCalibrationDEC.coeff3}]])x*x - - - E(x) = ([[${betaCalibrationDCE.coeff1}]])+([[${betaCalibrationDCE.coeff2}]])*x+([[${betaCalibrationDCE.coeff3}]])x*x - E(x) = ([[${gammaCalibrationDCE.coeff1}]])+([[${gammaCalibrationDCE.coeff2}]])*x+([[${gammaCalibrationDCE.coeff3}]])x*x + + +   @@ -203,13 +187,9 @@ Old Beta Old Gamma - - CH(x) = (?1)+(?2)*x+(?3)x*x - CH(x) = (?1)+(?2)*x+(?3)x*x - - - E(x) = (?1)+(?2)*x+(?3)x*x - E(x) = (?1)+(?2)*x+(?3)x*x + + +   @@ -221,13 +201,9 @@ New Beta New Gamma - - CH(x) = ([[${betaCalibrationGEC.coeff1}]])+([[${betaCalibrationGEC.coeff2}]])*x+([[${betaCalibrationGEC.coeff3}]])x*x - CH(x) = ([[${gammaCalibrationGEC.coeff1}]])+([[${gammaCalibrationGEC.coeff2}]])*x+([[${gammaCalibrationGEC.coeff3}]])x*x - - - E(x) = ([[${betaCalibrationGCE.coeff1}]])+([[${betaCalibrationGCE.coeff2}]])*x+([[${betaCalibrationGCE.coeff3}]])x*x - E(x) = ([[${gammaCalibrationGCE.coeff1}]])+([[${gammaCalibrationGCE.coeff2}]])*x+([[${gammaCalibrationGCE.coeff3}]])x*x + + +   @@ -276,6 +252,7 @@ +   diff --git a/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/controller/SpectrumAnalysesController.java b/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/controller/SpectrumAnalysesController.java index 30d48380..312732e4 100644 --- a/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/controller/SpectrumAnalysesController.java +++ b/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/controller/SpectrumAnalysesController.java @@ -227,14 +227,14 @@ public class SpectrumAnalysesController { @PostMapping("saveToHTML") public void saveToHTML(HttpServletRequest request, HttpServletResponse response, - @RequestBody BgDataAnlyseResultIn anlyseResultIn){ - spectrumAnalysisService.saveToHTML(anlyseResultIn, request, response); + @RequestBody RRRLogInfo rrrLogInfo){ + spectrumAnalysisService.saveToHTML(rrrLogInfo, request, response); } @PostMapping("saveToExcel") public void saveToExcel(HttpServletRequest request, HttpServletResponse response, - @RequestBody BgDataAnlyseResultIn anlyseResultIn){ - spectrumAnalysisService.saveToExcel(anlyseResultIn, request, response); + @RequestBody RRRLogInfo rrrLogInfo){ + spectrumAnalysisService.saveToExcel(rrrLogInfo, request, response); } @PostMapping("saveToTxt") diff --git a/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/service/ISpectrumAnalysisService.java b/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/service/ISpectrumAnalysisService.java index 32baead2..9a57ecc5 100644 --- a/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/service/ISpectrumAnalysisService.java +++ b/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/service/ISpectrumAnalysisService.java @@ -80,9 +80,9 @@ public interface ISpectrumAnalysisService { Result saveToDB(BgDataAnlyseResultIn anlyseResultIn, HttpServletRequest request); - void saveToHTML(BgDataAnlyseResultIn anlyseResultIn, HttpServletRequest request, HttpServletResponse response); + void saveToHTML(RRRLogInfo rrrLogInfo, HttpServletRequest request, HttpServletResponse response); - void saveToExcel(BgDataAnlyseResultIn anlyseResultIn, HttpServletRequest request, HttpServletResponse response); + void saveToExcel(RRRLogInfo rrrLogInfo, HttpServletRequest request, HttpServletResponse response); void saveToTxt(RRRLogInfo rrrLogInfo, HttpServletRequest request, HttpServletResponse response); } diff --git a/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/service/impl/SpectrumAnalysisServiceImpl.java b/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/service/impl/SpectrumAnalysisServiceImpl.java index 79d1d436..7325feff 100644 --- a/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/service/impl/SpectrumAnalysisServiceImpl.java +++ b/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/service/impl/SpectrumAnalysisServiceImpl.java @@ -3,7 +3,6 @@ package org.jeecg.modules.service.impl; import cn.hutool.core.bean.BeanUtil; import cn.hutool.core.collection.CollUtil; import cn.hutool.core.collection.ListUtil; -import cn.hutool.core.io.FileUtil; import cn.hutool.core.util.ObjectUtil; import cn.hutool.core.util.ReUtil; import cn.hutool.core.util.StrUtil; @@ -15,8 +14,6 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.google.common.cache.Cache; import org.apache.commons.io.FileUtils; import org.apache.commons.io.IOUtils; -import org.apache.commons.net.ftp.FTP; -import org.apache.commons.net.ftp.FTPClient; import org.apache.shiro.SecurityUtils; import org.jeecg.common.api.QueryRequest; import org.jeecg.common.api.vo.Result; @@ -30,10 +27,7 @@ import org.jeecg.common.system.vo.LoginUser; import org.jeecg.common.util.*; import org.jeecg.modules.base.abstracts.AbstractLogOrReport; import org.jeecg.modules.base.bizVo.BetaRLR; -import org.jeecg.modules.base.dto.ESStructDto; -import org.jeecg.modules.base.dto.ROIChannelsDto; -import org.jeecg.modules.base.dto.ROIResultsDto; -import org.jeecg.modules.base.dto.XeResultsDto; +import org.jeecg.modules.base.dto.*; import org.jeecg.modules.base.entity.configuration.GardsDetectors; import org.jeecg.modules.base.entity.original.GardsSampleData; import org.jeecg.modules.base.entity.rnman.*; @@ -65,7 +59,6 @@ import java.util.*; import java.util.regex.Pattern; import java.util.stream.Collectors; -import static org.aspectj.weaver.tools.cache.SimpleCacheFactory.path; import static org.jeecg.modules.base.enums.ExportTemplate.*; @Service("spectrumAnalysisService") @@ -3690,17 +3683,434 @@ public class SpectrumAnalysisServiceImpl extends AbstractLogOrReport implements return analyze; } + private Map exportDataNew(RRRLogInfo rrrLogInfo){ + LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); + String username = sysUser.getUsername(); + Map result = new HashMap<>(); + //获取本地缓存 + Cache cache = betaCache.getBetaCache(); + BetaDataFile betaDataFile = cache.getIfPresent(rrrLogInfo.getSampleFileName() + "-" + username); + if (Objects.isNull(betaDataFile)) { + return result; + } + GardsCalibrationSpectrum gammaCalibrationParamS = new GardsCalibrationSpectrum(); + GardsCalibrationSpectrum gammaCalibrationParamG = new GardsCalibrationSpectrum(); + GardsCalibrationSpectrum gammaCalibrationParamD = new GardsCalibrationSpectrum(); + GardsCalibrationSpectrum gammaCalibrationParamES = new GardsCalibrationSpectrum(); + GardsCalibrationSpectrum gammaCalibrationParamEG = new GardsCalibrationSpectrum(); + GardsCalibrationSpectrum gammaCalibrationParamED = new GardsCalibrationSpectrum(); + + GardsCalibrationSpectrum betaCalibrationParamS = new GardsCalibrationSpectrum(); + GardsCalibrationSpectrum betaCalibrationParamG = new GardsCalibrationSpectrum(); + GardsCalibrationSpectrum betaCalibrationParamD = new GardsCalibrationSpectrum(); + GardsCalibrationSpectrum betaCalibrationParamES = new GardsCalibrationSpectrum(); + GardsCalibrationSpectrum betaCalibrationParamEG = new GardsCalibrationSpectrum(); + GardsCalibrationSpectrum betaCalibrationParamED = new GardsCalibrationSpectrum(); + + StringBuffer strBuffer = new StringBuffer(); + //判断 + if (betaDataFile.isSaveAnalysisResult()) { + //对分析后的内容进行数据获取 + List channelsSpectrums = betaDataFile.getRoiChannelsSpectrumList(); + List roiChannelsSpectrumsSample = channelsSpectrums.stream().filter(item -> item.getDataType().equalsIgnoreCase("S")).collect(Collectors.toList()); + List roiChannelsSpectrumsGas = channelsSpectrums.stream().filter(item -> item.getDataType().equalsIgnoreCase("G")).collect(Collectors.toList()); + List roiChannelsSpectrumsDet = channelsSpectrums.stream().filter(item -> item.getDataType().equalsIgnoreCase("D")).collect(Collectors.toList()); + List resultsSpectrums = betaDataFile.getRoiResultsSpectrumList(); + List xeResultsSpectrums = betaDataFile.getXeResultsSpectrumList(); + for (int i=0; i gammaCalibrationParamList = betaDataFile.getGammaCalibrationSpectrumList(); + List gammaCalibrationSpectrumEList = betaDataFile.getGammaCalibrationSpectrumEList(); + for (int i=0; i betaCalibrationParamList = betaDataFile.getBetaCalibrationSpectrumList(); + List betaCalibrationSpectrumEList = betaDataFile.getBetaCalibrationSpectrumEList(); + for (int i=0; i samplOldCalibrations = new ArrayList<>(); + Calibration samplOldCalibrationCH = new Calibration(); + Calibration samplOldCalibrationE = new Calibration(); + if (betaDataFile.isBBetaEnergyValidSample() || betaDataFile.isBGammaEnergyValidSample()){ + if (betaDataFile.isBBetaEnergyValidSample()) { + samplOldCalibrationCH.setBeta(rowFormat("CH(x) = (%s)+(%s)*x+(%s)x*x", NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaOld().get(0)), NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaOld().get(1)), NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaOld().get(2)))); + } else { + samplOldCalibrationCH.setBeta("CH(x) = (?1)+(?2)*x+(?3)x*x"); + } + if (betaDataFile.isBGammaEnergyValidSample()) { + samplOldCalibrationCH.setGamma(rowFormat("CH(x) = (%s)+(%s)*x+(%s)x*x", NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaOld().get(0)), NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaOld().get(1)), NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaOld().get(2)))); + } else { + samplOldCalibrationCH.setGamma("CH(x) = (?1)+(?2)*x+(?3)x*x"); + } + if (betaDataFile.isBBetaEnergyValidSample()) { + samplOldCalibrationE.setBeta(rowFormat("E(x) = (%s)+(%s)*x+(%s)x*x", NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaToUiOld().get(0)), NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaToUiOld().get(1)), NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaToUiOld().get(2)))); + } else { + samplOldCalibrationE.setBeta("E(x) = (?1)+(?2)*x+(?3)x*x"); + } + if (betaDataFile.isBGammaEnergyValidSample()) { + samplOldCalibrationE.setGamma(rowFormat("E(x) = (%s)+(%s)*x+(%s)x*x ", NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaToUiOld().get(0)), NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaToUiOld().get(1)), NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaToUiOld().get(2)))); + } else { + samplOldCalibrationE.setGamma("E(x) = (?1)+(?2)*x+(?3)x*x"); + } + } else { + samplOldCalibrationCH.setBeta("CH(x) = (?1)+(?2)*x+(?3)x*x"); + samplOldCalibrationCH.setGamma("CH(x) = (?1)+(?2)*x+(?3)x*x"); + samplOldCalibrationE.setBeta("E(x) = (?1)+(?2)*x+(?3)x*x"); + samplOldCalibrationE.setGamma("E(x) = (?1)+(?2)*x+(?3)x*x"); + } + samplOldCalibrations.add(samplOldCalibrationCH); + samplOldCalibrations.add(samplOldCalibrationE); + result.put("samplOldCalibrations",samplOldCalibrations); + + // #SAMPLE New CALIBRATION + List samplNewCalibrations = new ArrayList<>(); + Calibration samplNewCalibrationCH = new Calibration(); + Calibration samplNewCalibrationE = new Calibration(); + samplNewCalibrationCH.setBeta("CH(x) = ("+ (Objects.isNull(betaCalibrationParamES.getCoeff1())?"?1":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamES.getCoeff1()))) + +")+("+ (Objects.isNull(betaCalibrationParamES.getCoeff2())?"?2":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamES.getCoeff2()))) + +")*x+("+ (Objects.isNull(betaCalibrationParamES.getCoeff3())?"?3":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamES.getCoeff3()))) + +")x*x"); + samplNewCalibrationCH.setGamma("CH(x) = ("+ (Objects.isNull(gammaCalibrationParamES.getCoeff1())?"?1":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamES.getCoeff1()))) + +")+("+ (Objects.isNull(gammaCalibrationParamES.getCoeff2())?"?2":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamES.getCoeff2()))) + +")*x+("+ (Objects.isNull(gammaCalibrationParamES.getCoeff3())?"?3":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamES.getCoeff3()))) + +")x*x"); + samplNewCalibrationE.setBeta("E(x) = ("+ (Objects.isNull(betaCalibrationParamS.getCoeff1())?"?1":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamS.getCoeff1()))) + +")+("+ (Objects.isNull(betaCalibrationParamS.getCoeff2())?"?2":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamS.getCoeff2()))) + +")*x+("+ (Objects.isNull(betaCalibrationParamS.getCoeff3())?"?3":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamS.getCoeff3()))) + +")x*x"); + samplNewCalibrationE.setGamma("E(x) = ("+ (Objects.isNull(gammaCalibrationParamS.getCoeff1())?"?1":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamS.getCoeff1()))) + +")+("+ (Objects.isNull(gammaCalibrationParamS.getCoeff2())?"?2":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamS.getCoeff2()))) + +")*x+("+ (Objects.isNull(gammaCalibrationParamS.getCoeff3())?"?3":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamS.getCoeff3()))) + +")x*x"); + samplNewCalibrations.add(samplNewCalibrationCH); + samplNewCalibrations.add(samplNewCalibrationE); + result.put("samplNewCalibrations",samplNewCalibrations); + + // #SAMPLE: LIMITS PER ROI + List roiChannelsDtosS = new LinkedList<>(); + for (GardsROIChannelsSpectrum roiChannels : roiChannelsSpectrumsSample) { + ROIChannelsDto roiChannelsDto = new ROIChannelsDto(); + BeanUtil.copyProperties(roiChannels, roiChannelsDto); + roiChannelsDto.shift(); + roiChannelsDtosS.add(roiChannelsDto); + } + result.put("roiChannelsS",roiChannelsDtosS); + + /* + * DET + * */ + // #DET Old CALIBRATION + List detOldCalibrations = new ArrayList<>(); + Calibration detOldCalibrationCH = new Calibration(); + Calibration detOldCalibrationE = new Calibration(); + if (betaDataFile.isBBetaEnergyValidDet() || betaDataFile.isBGammaEnergyValidDet()){ + if (betaDataFile.isBBetaEnergyValidDet()) { + detOldCalibrationCH.setBeta(rowFormat("CH(x) = (%s)+(%s)*x+(%s)x*x", NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaOld().get(0)), NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaOld().get(1)), NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaOld().get(2)))); + } else { + detOldCalibrationCH.setBeta("CH(x) = (?1)+(?2)*x+(?3)x*x"); + } + if (betaDataFile.isBGammaEnergyValidDet()) { + detOldCalibrationCH.setGamma(rowFormat("CH(x) = (%s)+(%s)*x+(%s)x*x", NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaOld().get(0)), NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaOld().get(1)), NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaOld().get(2)))); + } else { + detOldCalibrationCH.setGamma("CH(x) = (?1)+(?2)*x+(?3)x*x"); + } + if (betaDataFile.isBBetaEnergyValidDet()) { + detOldCalibrationE.setBeta(rowFormat("E(x) = (%s)+(%s)*x+(%s)x*x", NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaToUiOld().get(0)), NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaToUiOld().get(1)), NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaToUiOld().get(2)))); + } else { + detOldCalibrationE.setBeta("E(x) = (?1)+(?2)*x+(?3)x*x"); + } + if (betaDataFile.isBGammaEnergyValidDet()) { + detOldCalibrationE.setGamma(rowFormat("E(x) = (%s)+(%s)*x+(%s)x*x ", NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaToUiOld().get(0)), NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaToUiOld().get(1)), NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaToUiOld().get(2)))); + } else { + detOldCalibrationE.setGamma("E(x) = (?1)+(?2)*x+(?3)x*x"); + } + } else { + detOldCalibrationCH.setBeta("CH(x) = (?1)+(?2)*x+(?3)x*x"); + detOldCalibrationCH.setGamma("CH(x) = (?1)+(?2)*x+(?3)x*x"); + detOldCalibrationE.setBeta("E(x) = (?1)+(?2)*x+(?3)x*x"); + detOldCalibrationE.setGamma("E(x) = (?1)+(?2)*x+(?3)x*x"); + } + detOldCalibrations.add(detOldCalibrationCH); + detOldCalibrations.add(detOldCalibrationE); + result.put("detOldCalibrations", detOldCalibrations); + + // DET New CALIBRATION + List detNewCalibrations = new ArrayList<>(); + Calibration detNewCalibrationCH = new Calibration(); + Calibration detNewCalibrationE = new Calibration(); + detNewCalibrationCH.setBeta("CH(x) = ("+ (Objects.isNull(betaCalibrationParamED.getCoeff1())?"?1":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamED.getCoeff1()))) + +")+("+ (Objects.isNull(betaCalibrationParamED.getCoeff2())?"?2":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamED.getCoeff2()))) + +")*x+("+ (Objects.isNull(betaCalibrationParamED.getCoeff3())?"?3":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamED.getCoeff3()))) + +")x*x"); + detNewCalibrationCH.setGamma("CH(x) = ("+ (Objects.isNull(gammaCalibrationParamED.getCoeff1())?"?1":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamED.getCoeff1()))) + +")+("+ (Objects.isNull(gammaCalibrationParamED.getCoeff2())?"?2":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamED.getCoeff2()))) + +")*x+("+ (Objects.isNull(gammaCalibrationParamED.getCoeff3())?"?3":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamED.getCoeff3()))) + +")x*x"); + detNewCalibrationE.setBeta("E(x) = ("+ (Objects.isNull(betaCalibrationParamD.getCoeff1())?"?1":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamD.getCoeff1()))) + +")+("+ (Objects.isNull(betaCalibrationParamD.getCoeff2())?"?2":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamD.getCoeff2()))) + +")*x+("+ (Objects.isNull(betaCalibrationParamD.getCoeff3())?"?3":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamD.getCoeff3()))) + +")x*x"); + detNewCalibrationE.setGamma("E(x) = ("+ (Objects.isNull(gammaCalibrationParamD.getCoeff1())?"?1":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamD.getCoeff1()))) + +")+("+ (Objects.isNull(gammaCalibrationParamD.getCoeff2())?"?2":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamD.getCoeff2()))) + +")*x+("+ (Objects.isNull(gammaCalibrationParamD.getCoeff3())?"?3":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamD.getCoeff3()))) + +")x*x"); + detNewCalibrations.add(detNewCalibrationCH); + detNewCalibrations.add(detNewCalibrationE); + result.put("detNewCalibrations", detNewCalibrations); + + // DET: LIMITS PER ROI + List roiChannelsDtosD = new LinkedList<>(); + for (GardsROIChannelsSpectrum roiChannels : roiChannelsSpectrumsDet) { + ROIChannelsDto roiChannelsDto = new ROIChannelsDto(); + BeanUtil.copyProperties(roiChannels, roiChannelsDto); + roiChannelsDto.shift(); + roiChannelsDtosD.add(roiChannelsDto); + } + result.put("roiChannelsD",roiChannelsDtosD); + + /* + * GAS + * */ + // #GAS Old CALIBRATION + List gasOldCalibrations = new ArrayList<>(); + Calibration gasOldCalibrationCH = new Calibration(); + Calibration gasOldCalibrationE = new Calibration(); + if (betaDataFile.isBBetaEnergyValidGas() || betaDataFile.isBGammaEnergyValidGas()){ + if (betaDataFile.isBBetaEnergyValidGas()) { + gasOldCalibrationCH.setBeta(rowFormat("CH(x) = (%s)+(%s)*x+(%s)x*x", NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaOld().get(0)), NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaOld().get(1)), NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaOld().get(2)))); + } else { + gasOldCalibrationCH.setBeta("CH(x) = (?1)+(?2)*x+(?3)x*x"); + } + if (betaDataFile.isBGammaEnergyValidGas()) { + gasOldCalibrationCH.setGamma(rowFormat("CH(x) = (%s)+(%s)*x+(%s)x*x", NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaOld().get(0)), NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaOld().get(1)), NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaOld().get(2)))); + } else { + gasOldCalibrationCH.setGamma("CH(x) = (?1)+(?2)*x+(?3)x*x"); + } + if (betaDataFile.isBBetaEnergyValidGas()) { + gasOldCalibrationE.setBeta(rowFormat("E(x) = (%s)+(%s)*x+(%s)x*x", NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaToUiOld().get(0)), NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaToUiOld().get(1)), NumberFormatUtil.numberSixLen(betaDataFile.getBetaFittingParaToUiOld().get(2)))); + } else { + gasOldCalibrationE.setBeta("E(x) = (?1)+(?2)*x+(?3)x*x"); + } + if (betaDataFile.isBGammaEnergyValidGas()) { + gasOldCalibrationE.setGamma(rowFormat("E(x) = (%s)+(%s)*x+(%s)x*x ", NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaToUiOld().get(0)), NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaToUiOld().get(1)), NumberFormatUtil.numberSixLen(betaDataFile.getGammaFittingParaToUiOld().get(2)))); + } else { + gasOldCalibrationE.setGamma("E(x) = (?1)+(?2)*x+(?3)x*x"); + } + } else { + gasOldCalibrationCH.setBeta("CH(x) = (?1)+(?2)*x+(?3)x*x"); + gasOldCalibrationCH.setGamma("CH(x) = (?1)+(?2)*x+(?3)x*x"); + gasOldCalibrationE.setBeta("E(x) = (?1)+(?2)*x+(?3)x*x"); + gasOldCalibrationE.setGamma("E(x) = (?1)+(?2)*x+(?3)x*x"); + } + gasOldCalibrations.add(gasOldCalibrationCH); + gasOldCalibrations.add(gasOldCalibrationE); + result.put("gasOldCalibrations",gasOldCalibrations); + + // #GAS New CALIBRATION + List gasNewCalibrations = new ArrayList<>(); + Calibration gasNewCalibrationCH = new Calibration(); + Calibration gasNewCalibrationE = new Calibration(); + gasNewCalibrationCH.setBeta("CH(x) = ("+ (Objects.isNull(betaCalibrationParamEG.getCoeff1())?"?1":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamEG.getCoeff1()))) + +")+("+ (Objects.isNull(betaCalibrationParamEG.getCoeff2())?"?2":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamEG.getCoeff2()))) + +")*x+("+ (Objects.isNull(betaCalibrationParamEG.getCoeff3())?"?3":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamEG.getCoeff3()))) + +")x*x"); + gasNewCalibrationCH.setGamma("CH(x) = ("+ (Objects.isNull(gammaCalibrationParamEG.getCoeff1())?"?1":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamEG.getCoeff1()))) + +")+("+ (Objects.isNull(gammaCalibrationParamEG.getCoeff2())?"?2":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamEG.getCoeff2()))) + +")*x+("+ (Objects.isNull(gammaCalibrationParamEG.getCoeff3())?"?3":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamEG.getCoeff3()))) + +")x*x"); + gasNewCalibrationE.setBeta("E(x) = ("+ (Objects.isNull(betaCalibrationParamG.getCoeff1())?"?1":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamG.getCoeff1()))) + +")+("+ (Objects.isNull(betaCalibrationParamG.getCoeff2())?"?2":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamG.getCoeff2()))) + +")*x+("+ (Objects.isNull(betaCalibrationParamG.getCoeff3())?"?3":NumberFormatUtil.numberSixLen(String.valueOf(betaCalibrationParamG.getCoeff3()))) + +")x*x"); + gasNewCalibrationE.setGamma("E(x) = ("+ (Objects.isNull(gammaCalibrationParamG.getCoeff1())?"?1":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamG.getCoeff1()))) + +")+("+ (Objects.isNull(gammaCalibrationParamG.getCoeff2())?"?2":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamG.getCoeff2()))) + +")*x+("+ (Objects.isNull(gammaCalibrationParamG.getCoeff3())?"?3":NumberFormatUtil.numberSixLen(String.valueOf(gammaCalibrationParamG.getCoeff3()))) + +")x*x"); + gasNewCalibrations.add(gasNewCalibrationCH); + gasNewCalibrations.add(gasNewCalibrationE); + result.put("gasNewCalibrations",gasNewCalibrations); + + // #GAS: LIMITS PER ROI + List roiChannelsDtosG = new LinkedList<>(); + for (GardsROIChannelsSpectrum roiChannels : roiChannelsSpectrumsGas) { + ROIChannelsDto roiChannelsDto = new ROIChannelsDto(); + BeanUtil.copyProperties(roiChannels, roiChannelsDto); + roiChannelsDto.shift(); + roiChannelsDtosG.add(roiChannelsDto); + } + result.put("roiChannelsG",roiChannelsDtosG); + + /* + * GardsROIResultsSpectrum + * */ + // #GROSS COUNTS PER ROI + // #NET COUNTS AND LC PER ROI + // #CONCENTRATION AND LC PER ROI + List roiResults = new ArrayList<>(); + for (GardsROIResultsSpectrum resultsSpectrum:resultsSpectrums) { + ROIResultsStrDto roiResultsStrDto = new ROIResultsStrDto(); + roiResultsStrDto.setRoi(resultsSpectrum.getRoi()); + roiResultsStrDto.setSGross(resultsSpectrum.getSGross()); + roiResultsStrDto.setGGross(resultsSpectrum.getGGross()); + roiResultsStrDto.setBGross(resultsSpectrum.getBGross()); + roiResultsStrDto.setLc(NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getLc()))); + roiResultsStrDto.setMdc(NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getMdc()))); + if (betaDataFile.isBProcessed()) { + roiResultsStrDto.setConcStr(NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getConc()))+" +/- "+NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getConcErr()))); + roiResultsStrDto.setNetCount(NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getNet()))+" +/- "+NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getNetErr()))); + if (ObjectUtil.isNotNull(resultsSpectrums.get(0).getLcCts())) { + roiResultsStrDto.setLcCts(NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getLcCts()))); + } + }else { + roiResultsStrDto.setConcStr(NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getConcErr()))+" +/- "+NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getConcErr()))); + roiResultsStrDto.setNetCount(NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getNet()))+" +/- "+NumberFormatUtil.numberSixLen(String.valueOf(Math.sqrt(resultsSpectrum.getNetErr())))); + if (ObjectUtil.isNotNull(resultsSpectrums.get(0).getLcCts())) { + roiResultsStrDto.setLcCts(NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getLcCts()))); + } + } + roiResults.add(roiResultsStrDto); + } + result.put("roiResults", roiResults); + + /* + * GardsXeResultsSpectrum + * */ + // #RESULT SUMMARY + List xeResults = new ArrayList<>(); + for (GardsXeResultsSpectrum xeResultsSpectrum : xeResultsSpectrums) { + XeResultsStrDto xeResultsStrDto = new XeResultsStrDto(); + xeResultsStrDto.setNuclideName(xeResultsSpectrum.getNuclideName()); + xeResultsStrDto.setConcStr(NumberFormatUtil.numberSixLen(String.valueOf(xeResultsSpectrum.getConc()))+" +/- "+NumberFormatUtil.numberSixLen(String.valueOf(xeResultsSpectrum.getConcErr()))); + xeResultsStrDto.setLc(NumberFormatUtil.numberSixLen(String.valueOf(xeResultsSpectrum.getLc()))); + xeResultsStrDto.setMdc(NumberFormatUtil.numberSixLen(String.valueOf(xeResultsSpectrum.getMdc()))); + xeResultsStrDto.setNidFlag(xeResultsSpectrum.getNidFlag()); + xeResults.add(xeResultsStrDto); + } + result.put("xeResults", xeResults); + } catch (ParseException e) { + throw new RuntimeException(e); + } + } + return result; + } + @Override - public void saveToHTML(BgDataAnlyseResultIn anlyseResultIn, HttpServletRequest request, HttpServletResponse response) { + public void saveToHTML(RRRLogInfo rrrLogInfo, HttpServletRequest request, HttpServletResponse response) { String userName = JwtUtil.getUserNameByToken(request); // 解析文件,生成导出数据 - Map analyze = exportData(anlyseResultIn, userName); + Map analyze = exportDataNew(rrrLogInfo); // 解析生成Html字符串并导出为Html文件 String result = parseHtml(analyze); PrintWriter writer = null; try { String export = "saveToHtml.html"; - String sampleFileName = anlyseResultIn.getSampleFileName(); + String sampleFileName = rrrLogInfo.getSampleFileName(); if (StrUtil.isNotBlank(sampleFileName)){ if (StrUtil.contains(sampleFileName, ".PHD")) export = StrUtil.replace(sampleFileName, ".PHD", ".html"); @@ -3716,14 +4126,14 @@ public class SpectrumAnalysisServiceImpl extends AbstractLogOrReport implements } @Override - public void saveToExcel(BgDataAnlyseResultIn anlyseResultIn, HttpServletRequest request, HttpServletResponse response) { + public void saveToExcel(RRRLogInfo rrrLogInfo, HttpServletRequest request, HttpServletResponse response) { String userName = JwtUtil.getUserNameByToken(request); // 解析文件,生成导出数据 - Map analyze = exportData(anlyseResultIn, userName); + Map analyze = exportDataNew(rrrLogInfo); // 将Null值替换为"",避免空指针异常(集合为空集合,不能为null) analyze.replaceAll((key, value) -> ObjectUtil.isNull(value) ? "" : value); String export = "SaveToExcel.xls"; - String sampleFileName = anlyseResultIn.getSampleFileName(); + String sampleFileName = rrrLogInfo.getSampleFileName(); if (StrUtil.isNotBlank(sampleFileName)){ if (StrUtil.contains(sampleFileName, ".PHD")) export = StrUtil.replace(sampleFileName, ".PHD", ".xls");