diff --git a/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/NumberFormatUtil.java b/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/NumberFormatUtil.java
index fe879765..f1aebd6e 100644
--- a/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/NumberFormatUtil.java
+++ b/jeecg-boot-base-core/src/main/java/org/jeecg/common/util/NumberFormatUtil.java
@@ -1,5 +1,6 @@
 package org.jeecg.common.util;
 
+import com.baomidou.mybatisplus.core.toolkit.StringPool;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Component;
 
@@ -47,5 +48,38 @@ public class NumberFormatUtil {
         return String.valueOf(b.divide(divisor, mc));
     }
 
+    //总数字个数是6位的数
+    public static String numberSixLen(String number) {
+        Double preNum = null;
+        String suffixNum = "";
+        //判断传进来的数据是否是科学计数法的数据
+        if (number.indexOf("e") > 0) {
+            String calNumber = number.substring(0, number.indexOf("e"));
+            if (calNumber.length() < 6) {
+                preNum = Double.valueOf(number);
+            } else {
+                preNum = Double.valueOf(calNumber);
+                suffixNum = number.substring(number.indexOf("e"));
+            }
+        } else if (number.indexOf("E") > 0) {
+            String calNumber = number.substring(0, number.indexOf("E"));
+            if (calNumber.length() < 6) {
+                preNum = Double.valueOf(number);
+            } else {
+                preNum = Double.valueOf(calNumber);
+                suffixNum = number.substring(number.indexOf("E"));
+            }
+        } else  {
+            preNum = Double.valueOf(number);
+        }
+        double absNum = Math.abs(preNum);
+        //获取长度
+        int length = String.valueOf(absNum).substring(0, String.valueOf(absNum).indexOf(StringPool.DOT)).length();
+        String value = String.format("%." + (6 - length) + "f", preNum);
+        if (StringUtils.isNotBlank(suffixNum)) {
+            value = value + suffixNum;
+        }
+        return value;
+    }
 
 }
diff --git a/jeecg-module-beta-gamma-analyser/src/main/java/org/jeecg/common/util/GammaFileUtil.java b/jeecg-module-beta-gamma-analyser/src/main/java/org/jeecg/common/util/GammaFileUtil.java
index eb3e8acc..60c185f5 100644
--- a/jeecg-module-beta-gamma-analyser/src/main/java/org/jeecg/common/util/GammaFileUtil.java
+++ b/jeecg-module-beta-gamma-analyser/src/main/java/org/jeecg/common/util/GammaFileUtil.java
@@ -2617,6 +2617,8 @@ public class GammaFileUtil extends AbstractLogOrReport {
                 //换行
                 strBuffer.append(System.lineSeparator());
             }
+            //换行
+            strBuffer.append(System.lineSeparator());
             //获取核素信息
             String qsNuclidesName = "";
             for(int m=0;m<middleData.nucl_ided_Nuclidename.size()-1;m++) {
@@ -2673,6 +2675,8 @@ public class GammaFileUtil extends AbstractLogOrReport {
             }
             //换行
             strBuffer.append(System.lineSeparator());
+            //换行
+            strBuffer.append(System.lineSeparator());
             strBuffer.append("#PEAK SEARCH RESULTS");
             //换行
             strBuffer.append(System.lineSeparator());
@@ -2709,6 +2713,8 @@ public class GammaFileUtil extends AbstractLogOrReport {
             }
             //换行
             strBuffer.append(System.lineSeparator());
+            //换行
+            strBuffer.append(System.lineSeparator());
             strBuffer.append("#PROCESSING PARAMETERS");
             //换行
             strBuffer.append(System.lineSeparator());
@@ -2746,6 +2752,8 @@ public class GammaFileUtil extends AbstractLogOrReport {
             strBuffer.append(String.format("%s:%-30s%s", " refTime_conc", StringPool.SPACE, DateUtils.formatDate(middleData.setting_specSetup.getRefTime_conc(), "yyyy-MM-dd HH:mm:ss")));
             //换行
             strBuffer.append(System.lineSeparator());
+            //换行
+            strBuffer.append(System.lineSeparator());
             strBuffer.append("#CALIBRATION PARAMETERS");
             //换行
             strBuffer.append(System.lineSeparator());
@@ -2761,6 +2769,8 @@ public class GammaFileUtil extends AbstractLogOrReport {
             strBuffer.append(String.format("%s:%-30s%s", " KeepCalPeakSearchPeaks", StringPool.SPACE, (middleData.setting_specSetup.isKeepCalPeakSearchPeaks()?"1":"0")));
             //换行
             strBuffer.append(System.lineSeparator());
+            //换行
+            strBuffer.append(System.lineSeparator());
             if(middleData.calibration_pairs_E_idCalPoint.size()>0) {
                 strBuffer.append("#Calibration");
                 //换行
@@ -2896,6 +2906,8 @@ public class GammaFileUtil extends AbstractLogOrReport {
                 //换行
                 strBuffer.append(System.lineSeparator());
             }
+            //换行
+            strBuffer.append(System.lineSeparator());
             strBuffer.append("#DATA QUALITY FLAGS");
             //换行
             strBuffer.append(System.lineSeparator());
diff --git a/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/common/util/PHDFileUtil.java b/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/common/util/PHDFileUtil.java
index f1a2a07c..1e3a98c0 100644
--- a/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/common/util/PHDFileUtil.java
+++ b/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/common/util/PHDFileUtil.java
@@ -1056,16 +1056,16 @@ public class PHDFileUtil extends AbstractLogOrReport {
             betaCalibrationSpectrumEList.add(betaCalibrationS);
         } else {
             GardsCalibrationSpectrum betaCalibrationS = new GardsCalibrationSpectrum();
-            if (bgAnalyseResult.s_b_fitting_c_e.size() < 0) {
+            if (bgAnalyseResult.s_b_fitting_e_c.size() < 0) {
                 betaCalibrationS.setDataType(DataTypeAbbr.SAMPLEPHD.getType());
                 betaCalibrationS.setCoeff1(Double.valueOf(betaFittingParaToUi.get(0)));
                 betaCalibrationS.setCoeff2(Double.valueOf(betaFittingParaToUi.get(1)));
                 betaCalibrationS.setCoeff3(Double.valueOf(betaFittingParaToUi.get(2)));
             } else {
                 betaCalibrationS.setDataType(DataTypeAbbr.SAMPLEPHD.getType());
-                betaCalibrationS.setCoeff1(bgAnalyseResult.s_b_fitting_c_e.get(0));
-                betaCalibrationS.setCoeff2(bgAnalyseResult.s_b_fitting_c_e.get(1));
-                betaCalibrationS.setCoeff3(bgAnalyseResult.s_b_fitting_c_e.get(2));
+                betaCalibrationS.setCoeff1(bgAnalyseResult.s_b_fitting_e_c.get(0));
+                betaCalibrationS.setCoeff2(bgAnalyseResult.s_b_fitting_e_c.get(1));
+                betaCalibrationS.setCoeff3(bgAnalyseResult.s_b_fitting_e_c.get(2));
             }
             betaCalibrationSpectrumEList.add(betaCalibrationS);
         }
@@ -1078,16 +1078,16 @@ public class PHDFileUtil extends AbstractLogOrReport {
             betaCalibrationSpectrumEList.add(betaCalibrationG);
         } else {
             GardsCalibrationSpectrum betaCalibrationG = new GardsCalibrationSpectrum();
-            if (bgAnalyseResult.g_b_fitting_c_e.size() < 0) {
+            if (bgAnalyseResult.g_b_fitting_e_c.size() < 0) {
                 betaCalibrationG.setDataType(DataTypeAbbr.GASBKPHD.getType());
                 betaCalibrationG.setCoeff1(Double.valueOf(betaFittingParaToUi.get(0)));
                 betaCalibrationG.setCoeff2(Double.valueOf(betaFittingParaToUi.get(1)));
                 betaCalibrationG.setCoeff3(Double.valueOf(betaFittingParaToUi.get(2)));
             } else {
                 betaCalibrationG.setDataType(DataTypeAbbr.GASBKPHD.getType());
-                betaCalibrationG.setCoeff1(bgAnalyseResult.g_b_fitting_c_e.get(0));
-                betaCalibrationG.setCoeff2(bgAnalyseResult.g_b_fitting_c_e.get(1));
-                betaCalibrationG.setCoeff3(bgAnalyseResult.g_b_fitting_c_e.get(2));
+                betaCalibrationG.setCoeff1(bgAnalyseResult.g_b_fitting_e_c.get(0));
+                betaCalibrationG.setCoeff2(bgAnalyseResult.g_b_fitting_e_c.get(1));
+                betaCalibrationG.setCoeff3(bgAnalyseResult.g_b_fitting_e_c.get(2));
             }
             betaCalibrationSpectrumEList.add(betaCalibrationG);
         }
@@ -1100,16 +1100,16 @@ public class PHDFileUtil extends AbstractLogOrReport {
             betaCalibrationSpectrumEList.add(betaCalibrationD);
         } else {
             GardsCalibrationSpectrum betaCalibrationD = new GardsCalibrationSpectrum();
-            if (bgAnalyseResult.d_b_fitting_c_e.size() < 0) {
+            if (bgAnalyseResult.d_b_fitting_e_c.size() < 0) {
                 betaCalibrationD.setDataType(DataTypeAbbr.DETBKPHD.getType());
                 betaCalibrationD.setCoeff1(Double.valueOf(betaFittingParaToUi.get(0)));
                 betaCalibrationD.setCoeff2(Double.valueOf(betaFittingParaToUi.get(1)));
                 betaCalibrationD.setCoeff3(Double.valueOf(betaFittingParaToUi.get(2)));
             } else {
                 betaCalibrationD.setDataType(DataTypeAbbr.DETBKPHD.getType());
-                betaCalibrationD.setCoeff1(bgAnalyseResult.d_b_fitting_c_e.get(0));
-                betaCalibrationD.setCoeff2(bgAnalyseResult.d_b_fitting_c_e.get(1));
-                betaCalibrationD.setCoeff3(bgAnalyseResult.d_b_fitting_c_e.get(2));
+                betaCalibrationD.setCoeff1(bgAnalyseResult.d_b_fitting_e_c.get(0));
+                betaCalibrationD.setCoeff2(bgAnalyseResult.d_b_fitting_e_c.get(1));
+                betaCalibrationD.setCoeff3(bgAnalyseResult.d_b_fitting_e_c.get(2));
             }
             betaCalibrationSpectrumEList.add(betaCalibrationD);
         }
@@ -1150,6 +1150,7 @@ public class PHDFileUtil extends AbstractLogOrReport {
         betaDataFile.setRoiChannelsSpectrumList(roiChannelsSpectrumList);
         bgAnalyseResult.LC.add(0, 0.0);
         bgAnalyseResult.MDC.add(0, 0.0);
+        bgAnalyseResult.LC_CTS.add(0, 0.0);
         //存储roiResult的数据
         List<GardsROIResultsSpectrum> roiResultsSpectrumList = new LinkedList<>();
         for (int i=0; i<bgAnalyseResult.s_roi_cts.size(); i++) {
@@ -1171,6 +1172,7 @@ public class PHDFileUtil extends AbstractLogOrReport {
             } else {
                 roiResults.setNidFlag(0);
             }
+            roiResults.setLcCts(bgAnalyseResult.LC_CTS.get(i));
             roiResultsSpectrumList.add(roiResults);
         }
         betaDataFile.setRoiResultsSpectrumList(roiResultsSpectrumList);
diff --git a/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/entity/GardsROIResultsSpectrum.java b/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/entity/GardsROIResultsSpectrum.java
index 99f2cb84..69eaf0f3 100644
--- a/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/entity/GardsROIResultsSpectrum.java
+++ b/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/entity/GardsROIResultsSpectrum.java
@@ -76,6 +76,8 @@ public class GardsROIResultsSpectrum implements Serializable {
      */
     private Double lc;
 
+    private Double lcCts;
+
     /**
      *  感兴趣区MDC
      */
diff --git a/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/mapper/SpectrumAnalysisMapper.java b/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/mapper/SpectrumAnalysisMapper.java
index f9bfbc12..52720933 100644
--- a/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/mapper/SpectrumAnalysisMapper.java
+++ b/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/mapper/SpectrumAnalysisMapper.java
@@ -82,11 +82,11 @@ public interface SpectrumAnalysisMapper {
 
     List<GardsCalibrationPairsSpectrum> ReadGammaFitChannelEnergy(@Param(value = "idAnalysis") Integer idAnalysis, @Param(value = "sampleId") Integer sampleId);
 
-    List<GardsCalibrationSpectrum> ReadGammaCalibrationParam(@Param(value = "dbName") String dbName, @Param(value = "idAnalysis") Integer idAnalysis, @Param(value = "sampleId") Integer sampleId);
+    List<GardsCalibrationSpectrum> ReadGammaCalibrationParam(@Param(value = "dbName") String dbName, @Param(value = "idAnalysis") Integer idAnalysis);
 
     List<GardsCalibrationPairsSpectrum> ReadBetaFitChannelEnergy(@Param(value = "idAnalysis") Integer idAnalysis, @Param(value = "sampleId") Integer sampleId);
 
-    List<GardsCalibrationSpectrum> ReadBetaCalibrationParam(@Param(value = "dbName") String dbName, @Param(value = "idAnalysis") Integer idAnalysis, @Param(value = "sampleId") Integer sampleId);
+    List<GardsCalibrationSpectrum> ReadBetaCalibrationParam(@Param(value = "dbName") String dbName, @Param(value = "idAnalysis") Integer idAnalysis);
 
     List<GardsROIChannelsSpectrum> ReadROIChannels(@Param(value = "dbName") String dbName, @Param(value = "idAnalysis") Integer idAnalysis, @Param(value = "sampleId") Integer sampleId);
 
diff --git a/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/mapper/xml/SpectrumAnalysisMapper.xml b/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/mapper/xml/SpectrumAnalysisMapper.xml
index 78e61abe..cf2afd89 100644
--- a/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/mapper/xml/SpectrumAnalysisMapper.xml
+++ b/jeecg-module-spectrum-analysis/src/main/java/org/jeecg/modules/mapper/xml/SpectrumAnalysisMapper.xml
@@ -546,6 +546,7 @@
             CALIBRATION_PAIRS.SAMPLE_ID = SMAPLE_DATA.SAMPLE_ID
           AND CALIBRATION_PAIRS.SAMPLE_TYPE = 'B'
           AND CALIBRATION_PAIRS.IDANALYSIS = #{idAnalysis}
+          AND CALIBRATION_PAIRS.SAMPLE_ID = #{sampleId}
         ORDER BY CALIBRATION_PAIRS.IDCALPOINT ASC
     </select>
 
@@ -579,6 +580,7 @@
         WHERE
             ROI_CHANNELS.SAMPLE_ID = SAMPLE_DATA.SAMPLE_ID
             AND ROI_CHANNELS.IDANALYSIS = #{idAnalysis}
+            AND ROI_CHANNELS.SAMPLE_ID = #{sampleId}
         ORDER BY ROI_CHANNELS.ROI ASC
     </select>
 
@@ -602,6 +604,7 @@
             ${dbName}.GARDS_ROI_RESULTS ROI_RESULTS
         WHERE
             ROI_RESULTS.IDANALYSIS = #{idAnalysis}
+            AND ROI_RESULTS.SAMPLE_ID = #{sampleId}
         ORDER BY ROI_RESULTS.ROI ASC
     </select>
 
@@ -617,6 +620,7 @@
             ${dbName}.GARDS_XE_RESULTS XE_RESULTS
         WHERE
             XE_RESULTS.IDANALYSIS = #{idAnalysis}
+            AND XE_RESULTS.SAMPLE_ID = #{sampleId}
     </select>
 
     <select id="getUserNuclideNames" resultType="java.lang.String">
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 f10b6c65..4761f5b1 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
@@ -334,20 +334,20 @@ public class SpectrumAnalysisServiceImpl extends AbstractLogOrReport implements
             dbName = "RNAUTO";
             analysisID = spectrumAnalysisMapper.getAnalysisID(dbName, sampleId, "RNAUTO");
             xeResultsSpectrumList = spectrumAnalysisMapper.ReadXeResults(dbName, analysisID, sampleId);
-            gammaCalibrationSpectrumList = spectrumAnalysisMapper.ReadGammaCalibrationParam("RNAUTO", analysisID, sampleId);
-            betaCalibrationSpectrumList = spectrumAnalysisMapper.ReadBetaCalibrationParam("RNAUTO", analysisID, sampleId);
+            gammaCalibrationSpectrumList = spectrumAnalysisMapper.ReadGammaCalibrationParam("RNAUTO", analysisID);
+            betaCalibrationSpectrumList = spectrumAnalysisMapper.ReadBetaCalibrationParam("RNAUTO", analysisID);
             roiChannelsSpectrumList = spectrumAnalysisMapper.ReadROIChannels("RNAUTO", analysisID, sampleId);
             roiResultsSpectrumList = spectrumAnalysisMapper.ReadROIResults("RNAUTO", analysisID, sampleId);
         } else if (dbName.equalsIgnoreCase("man")){
             dbName = "RNMAN";
             analysisID = spectrumAnalysisMapper.getAnalysisID(dbName, sampleId, userName);
             gammaCalibrationPairsList = spectrumAnalysisMapper.ReadGammaFitChannelEnergy(analysisID, sampleId);
-            gammaCalibrationSpectrumList = spectrumAnalysisMapper.ReadGammaCalibrationParam("RNMAN", analysisID, sampleId);
             betaCalibrationPairsList = spectrumAnalysisMapper.ReadBetaFitChannelEnergy(analysisID, sampleId);
-            betaCalibrationSpectrumList = spectrumAnalysisMapper.ReadBetaCalibrationParam("RNMAN", analysisID, sampleId);
+            xeResultsSpectrumList = spectrumAnalysisMapper.ReadXeResults(dbName, analysisID, sampleId);
+            gammaCalibrationSpectrumList = spectrumAnalysisMapper.ReadGammaCalibrationParam("RNMAN", analysisID);
+            betaCalibrationSpectrumList = spectrumAnalysisMapper.ReadBetaCalibrationParam("RNMAN", analysisID);
             roiChannelsSpectrumList = spectrumAnalysisMapper.ReadROIChannels("RNMAN", analysisID, sampleId);
             roiResultsSpectrumList = spectrumAnalysisMapper.ReadROIResults("RNMAN", analysisID, sampleId);
-            xeResultsSpectrumList = spectrumAnalysisMapper.ReadXeResults(dbName, analysisID, sampleId);
         }else {
             result.error500("The database type does not exist");
             return result;
@@ -486,9 +486,9 @@ public class SpectrumAnalysisServiceImpl extends AbstractLogOrReport implements
                             xeData.setColor("green");
                             xeData.setNidFlag(1);
                         }
-                        xeData.setMdc(Double.valueOf(String.format("%."+(6 - String.valueOf(Math.abs(xeData.getMdc())).substring(0, String.valueOf(Math.abs(xeData.getMdc())).lastIndexOf(StringPool.DOT)).length())+"f", xeData.getMdc())));
-                        xeData.setConc(Double.valueOf(String.format("%."+(6 - String.valueOf(Math.abs(xeData.getConc())).substring(0, String.valueOf(Math.abs(xeData.getConc())).lastIndexOf(StringPool.DOT)).length())+"f", xeData.getConc())));
-                        xeData.setConcErr(Double.valueOf(String.format("%."+((6 - String.valueOf(Math.abs(xeData.getConcErr())).substring(0, String.valueOf(Math.abs(xeData.getConcErr())).lastIndexOf(StringPool.DOT)).length()))+"f", xeData.getConcErr())));
+                        xeData.setMdc(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getMdc()))));
+                        xeData.setConc(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getConc()))));
+                        xeData.setConcErr(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getConcErr()))));
                     }
                 }
                 betaDataFile.setGammaCalibrationSpectrumList(gammaCalibrationSpectrumList);
@@ -624,9 +624,9 @@ public class SpectrumAnalysisServiceImpl extends AbstractLogOrReport implements
                     xeData.setColor("green");
                     xeData.setNidFlag(1);
                 }
-                xeData.setMdc(Double.valueOf(String.format("%."+(6 - String.valueOf(Math.abs(xeData.getMdc())).substring(0, String.valueOf(Math.abs(xeData.getMdc())).lastIndexOf(StringPool.DOT)).length())+"f", xeData.getMdc())));
-                xeData.setConc(Double.valueOf(String.format("%."+(6 - String.valueOf(Math.abs(xeData.getConc())).substring(0, String.valueOf(Math.abs(xeData.getConc())).lastIndexOf(StringPool.DOT)).length())+"f", xeData.getConc())));
-                xeData.setConcErr(Double.valueOf(String.format("%."+((6 - String.valueOf(Math.abs(xeData.getConcErr())).substring(0, String.valueOf(Math.abs(xeData.getConcErr())).lastIndexOf(StringPool.DOT)).length()))+"f", xeData.getConcErr())));
+                xeData.setMdc(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getMdc()))));
+                xeData.setConc(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getConc()))));
+                xeData.setConcErr(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getConcErr()))));
             }
         }
         resultMap.put("XeData", xeResultsSpectrumList);
@@ -932,66 +932,58 @@ public class SpectrumAnalysisServiceImpl extends AbstractLogOrReport implements
                 strBuffer.append(" Old Beta                                        Old Gamma                                       ").append("\n");
                 if (betaDataFile.isBBetaEnergyValidSample() || betaDataFile.isBGammaEnergyValidSample()){
                     if (betaDataFile.isBBetaEnergyValidSample()) {
-                        strBuffer.append(rowFormat(" CH(x) = (%s)+(%s)*x+(%s)x*x ", NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaOld().get(0)), NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaOld().get(1)), NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaOld().get(2))));
+                        strBuffer.append(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 {
                         strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x ");
                     }
                     if (betaDataFile.isBGammaEnergyValidSample()) {
-                        strBuffer.append(rowFormat(" CH(x) = (%s)+(%s)*x+(%s)x*x ", NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaOld().get(0)), NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaOld().get(1)), NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaOld().get(2))));
+                        strBuffer.append(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))));
                         strBuffer.append("\n");
                     } else {
-                        strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x ");
+                        strBuffer.append("                        CH(x) = (?1)+(?2)*x+(?3)x*x ");
                         strBuffer.append("\n");
                     }
                     if (betaDataFile.isBBetaEnergyValidSample()) {
-                        strBuffer.append(rowFormat(" E(x) =  (%s)+(%s)*x+(%s)x*x ", NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaToUiOld().get(0)), NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaToUiOld().get(1)), NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaToUiOld().get(2))));
+                        strBuffer.append(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 {
                         strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x ");
                     }
                     if (betaDataFile.isBGammaEnergyValidSample()) {
-                        strBuffer.append(rowFormat(" E(x) =  (%s)+(%s)*x+(%s)x*x ", NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaToUiOld().get(0)), NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaToUiOld().get(1)), NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaToUiOld().get(2))));
+                        strBuffer.append(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))));
                         strBuffer.append("\n");
                     } else {
-                        strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x ");
+                        strBuffer.append("                        E(x) =  (?1)+(?2)*x+(?3)x*x ");
                         strBuffer.append("\n");
                     }
                 } else {
-                    strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x ").append(" CH(x) = (?1)+(?2)*x+(?3)x*x").append("\n");
-                    strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x ").append(" E(x) =  (?1)+(?2)*x+(?3)x*x").append("\n");
+                    strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x ").append("                        CH(x) = (?1)+(?2)*x+(?3)x*x").append("\n");
+                    strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x ").append("                        E(x) =  (?1)+(?2)*x+(?3)x*x").append("\n");
                 }
                 strBuffer.append("\n");
                 strBuffer.append("#SAMPLE New CALIBRATION").append("\n");
                 strBuffer.append(" New Beta                                        New Gamma                                       ").append("\n");
-                if (Objects.nonNull(betaCalibrationParamS)) {
-                    strBuffer.append(" CH(x) = ("+String.format("%.6f", betaCalibrationParamS.getCoeff1())+")+("+String.format("%.6f", betaCalibrationParamS.getCoeff2())+")*x+("+String.format("%.6f", betaCalibrationParamS.getCoeff3())+")x*x ");
-                } else {
-                    strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x ");
-                }
-                if (Objects.nonNull(gammaCalibrationParamS)) {
-                    strBuffer.append(" CH(x) = ("+String.format("%.6f", gammaCalibrationParamS.getCoeff1())+")+("+String.format("%.6f", gammaCalibrationParamS.getCoeff2())+")*x+("+String.format("%.6f", gammaCalibrationParamS.getCoeff3())+")x*x ");
-                    strBuffer.append("\n");
-                } else {
-                    strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x");
-                    strBuffer.append("\n");
-                }
-                if (Objects.nonNull(betaCalibrationParamES)) {
-                    strBuffer.append(" E(x) =  ("+String.format("%.6f", betaCalibrationParamES.getCoeff1())+")+("+String.format("%.6f", betaCalibrationParamES.getCoeff2())+")*x+("+String.format("%.6f", betaCalibrationParamES.getCoeff3())+")x*x ");
-                } else {
-                    strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x ");
-                }
-                if (Objects.nonNull(gammaCalibrationParamES)) {
-                    strBuffer.append(" E(x) =  ("+String.format("%.6f", gammaCalibrationParamES.getCoeff1())+")+("+String.format("%.6f", gammaCalibrationParamES.getCoeff2())+")*x+("+String.format("%.6f", gammaCalibrationParamES.getCoeff3())+")x*x");
-                    strBuffer.append("\n");
-                } else {
-                    strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x");
-                    strBuffer.append("\n");
-                }
+                strBuffer.append(" 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 ")
+                        .append("                        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 ").append("\n");
+                strBuffer.append(" 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 ")
+                        .append("                        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").append("\n");
                 strBuffer.append("\n");
                 strBuffer.append("#SAMPLE: LIMITS PER ROI").append("\n");
                 strBuffer.append(" Roi                                             Beta                                             Gamma       ").append("\n");
                 if (CollectionUtils.isNotEmpty(channelsSpectrums)) {
                     for (GardsROIChannelsSpectrum channelsSpectrum:channelsSpectrums) {
-                        strBuffer.append(StringPool.SPACE+channelsSpectrum.getRoi()+"                                             "+channelsSpectrum.getBChanStart()+"to"+channelsSpectrum.getBChanStop()+"                                             "+channelsSpectrum.getGChanStart()+"to"+channelsSpectrum.getGChanStop()).append("\n");
+                        strBuffer.append(StringPool.SPACE+channelsSpectrum.getRoi()+"                                             "+channelsSpectrum.getBChanStart()+" to "+channelsSpectrum.getBChanStop()+"                                             "+channelsSpectrum.getGChanStart()+" to "+channelsSpectrum.getGChanStop()).append("\n");
                     }
                 }
                 strBuffer.append("\n");
@@ -999,66 +991,58 @@ public class SpectrumAnalysisServiceImpl extends AbstractLogOrReport implements
                 strBuffer.append(" Old Beta                                        Old Gamma                                       ").append("\n");
                 if (betaDataFile.isBBetaEnergyValidDet() || betaDataFile.isBGammaEnergyValidDet()){
                     if (betaDataFile.isBBetaEnergyValidDet()) {
-                        strBuffer.append(rowFormat(" CH(x) = (%s)+(%s)*x+(%s)x*x ", NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaOld().get(0)), NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaOld().get(1)), NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaOld().get(2))));
+                        strBuffer.append(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 {
                         strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x ");
                     }
                     if (betaDataFile.isBGammaEnergyValidDet()) {
-                        strBuffer.append(rowFormat(" CH(x) = (%s)+(%s)*x+(%s)x*x ", NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaOld().get(0)), NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaOld().get(1)), NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaOld().get(2))));
+                        strBuffer.append(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))));
                         strBuffer.append("\n");
                     } else {
-                        strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x ");
+                        strBuffer.append("                        CH(x) = (?1)+(?2)*x+(?3)x*x ");
                         strBuffer.append("\n");
                     }
                     if (betaDataFile.isBBetaEnergyValidDet()) {
-                        strBuffer.append(rowFormat(" E(x) =  (%s)+(%s)*x+(%s)x*x ", NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaToUiOld().get(0)), NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaToUiOld().get(1)), NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaToUiOld().get(2))));
+                        strBuffer.append(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 {
                         strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x ");
                     }
                     if (betaDataFile.isBGammaEnergyValidDet()) {
-                        strBuffer.append(rowFormat(" E(x) =  (%s)+(%s)*x+(%s)x*x ", NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaToUiOld().get(0)), NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaToUiOld().get(1)), NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaToUiOld().get(2))));
+                        strBuffer.append(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))));
                         strBuffer.append("\n");
                     } else {
-                        strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x ");
+                        strBuffer.append("                        E(x) =  (?1)+(?2)*x+(?3)x*x ");
                         strBuffer.append("\n");
                     }
                 } else {
-                    strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x ").append(" CH(x) = (?1)+(?2)*x+(?3)x*x").append("\n");
-                    strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x ").append(" E(x) =  (?1)+(?2)*x+(?3)x*x").append("\n");
+                    strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x ").append("                        CH(x) = (?1)+(?2)*x+(?3)x*x").append("\n");
+                    strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x ").append("                        E(x) =  (?1)+(?2)*x+(?3)x*x").append("\n");
                 }
                 strBuffer.append("\n");
                 strBuffer.append("#DET New CALIBRATION").append("\n");
                 strBuffer.append(" New Beta                                        New Gamma                                       ").append("\n");
-                if (Objects.nonNull(betaCalibrationParamD)) {
-                    strBuffer.append(" CH(x) = ("+String.format("%.6f", betaCalibrationParamD.getCoeff1())+")+("+String.format("%.6f", betaCalibrationParamD.getCoeff2())+")*x+("+String.format("%.6f", betaCalibrationParamD.getCoeff3())+")x*x ");
-                } else {
-                    strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x ");
-                }
-                if (Objects.nonNull(gammaCalibrationParamD)) {
-                    strBuffer.append(" CH(x) = ("+String.format("%.6f", gammaCalibrationParamD.getCoeff1())+")+("+String.format("%.6f", gammaCalibrationParamD.getCoeff2())+")*x+("+String.format("%.6f", gammaCalibrationParamD.getCoeff3())+")x*x");
-                    strBuffer.append("\n");
-                } else {
-                    strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x");
-                    strBuffer.append("\n");
-                }
-                if (Objects.nonNull(betaCalibrationParamED)) {
-                    strBuffer.append(" E(x) =  ("+String.format("%.6f", betaCalibrationParamED.getCoeff1())+")+("+String.format("%.6f", betaCalibrationParamED.getCoeff2())+")*x+("+String.format("%.6f", betaCalibrationParamED.getCoeff3())+")x*x ");
-                } else {
-                    strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x ");
-                }
-                if (Objects.nonNull(gammaCalibrationParamED)) {
-                    strBuffer.append(" E(x) =  ("+String.format("%.6f", gammaCalibrationParamED.getCoeff1())+")+("+String.format("%.6f", gammaCalibrationParamED.getCoeff2())+")*x+("+String.format("%.6f", gammaCalibrationParamED.getCoeff3())+")x*x");
-                    strBuffer.append("\n");
-                } else {
-                    strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x");
-                    strBuffer.append("\n");
-                }
+                strBuffer.append(" 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 ")
+                        .append("                        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").append("\n");
+                strBuffer.append(" 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 ")
+                        .append("                        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").append("\n");
                 strBuffer.append("\n");
                 strBuffer.append("#DET: LIMITS PER ROI").append("\n");
                 strBuffer.append(" Roi                                             Beta                                             Gamma       ").append("\n");
                 if (CollectionUtils.isNotEmpty(channelsSpectrums)) {
                     for (GardsROIChannelsSpectrum channelsSpectrum:channelsSpectrums) {
-                        strBuffer.append(StringPool.SPACE+channelsSpectrum.getRoi()+"                                             "+channelsSpectrum.getBChanStart()+"to"+channelsSpectrum.getBChanStop()+"                                             "+channelsSpectrum.getGChanStart()+"to"+channelsSpectrum.getGChanStop()).append("\n");
+                        strBuffer.append(StringPool.SPACE+channelsSpectrum.getRoi()+"                                             "+channelsSpectrum.getBChanStart()+" to "+channelsSpectrum.getBChanStop()+"                                             "+channelsSpectrum.getGChanStart()+" to "+channelsSpectrum.getGChanStop()).append("\n");
                     }
                 }
                 strBuffer.append("\n");
@@ -1066,66 +1050,58 @@ public class SpectrumAnalysisServiceImpl extends AbstractLogOrReport implements
                 strBuffer.append(" Old Beta                                        Old Gamma                                       ").append("\n");
                 if (betaDataFile.isBBetaEnergyValidGas() || betaDataFile.isBGammaEnergyValidGas()){
                     if (betaDataFile.isBBetaEnergyValidGas()) {
-                        strBuffer.append(rowFormat(" CH(x) = (%s)+(%s)*x+(%s)x*x ", NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaOld().get(0)), NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaOld().get(1)), NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaOld().get(2))));
+                        strBuffer.append(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 {
                         strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x ");
                     }
                     if (betaDataFile.isBGammaEnergyValidGas()) {
-                        strBuffer.append(rowFormat(" CH(x) = (%s)+(%s)*x+(%s)x*x ", NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaOld().get(0)), NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaOld().get(1)), NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaOld().get(2))));
+                        strBuffer.append(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))));
                         strBuffer.append("\n");
                     } else {
-                        strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x ");
+                        strBuffer.append("                        CH(x) = (?1)+(?2)*x+(?3)x*x ");
                         strBuffer.append("\n");
                     }
                     if (betaDataFile.isBBetaEnergyValidGas()) {
-                        strBuffer.append(rowFormat(" E(x) =  (%s)+(%s)*x+(%s)x*x ", NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaToUiOld().get(0)), NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaToUiOld().get(1)), NumberFormatUtil.numberFormat(betaDataFile.getBetaFittingParaToUiOld().get(2))));
+                        strBuffer.append(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 {
                         strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x ");
                     }
                     if (betaDataFile.isBGammaEnergyValidGas()) {
-                        strBuffer.append(rowFormat(" E(x) =  (%s)+(%s)*x+(%s)x*x ", NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaToUiOld().get(0)), NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaToUiOld().get(1)), NumberFormatUtil.numberFormat(betaDataFile.getGammaFittingParaToUiOld().get(2))));
+                        strBuffer.append(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))));
                         strBuffer.append("\n");
                     } else {
-                        strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x ");
+                        strBuffer.append("                        E(x) =  (?1)+(?2)*x+(?3)x*x ");
                         strBuffer.append("\n");
                     }
                 } else {
-                    strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x ").append(" CH(x) = (?1)+(?2)*x+(?3)x*x").append("\n");
-                    strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x ").append(" E(x) =  (?1)+(?2)*x+(?3)x*x").append("\n");
+                    strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x ").append("                        CH(x) = (?1)+(?2)*x+(?3)x*x").append("\n");
+                    strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x ").append("                        E(x) =  (?1)+(?2)*x+(?3)x*x").append("\n");
                 }
                 strBuffer.append("\n");
                 strBuffer.append("#GAS New CALIBRATION").append("\n");
                 strBuffer.append(" New Beta                                        New Gamma                                       ").append("\n");
-                if (Objects.nonNull(betaCalibrationParamG)) {
-                    strBuffer.append(" CH(x) = ("+String.format("%.6f", betaCalibrationParamG.getCoeff1())+")+("+String.format("%.6f", betaCalibrationParamG.getCoeff2())+")*x+("+String.format("%.6f", betaCalibrationParamG.getCoeff3())+")x*x ");
-                } else {
-                    strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x ");
-                }
-                if (Objects.nonNull(gammaCalibrationParamG)) {
-                    strBuffer.append(" CH(x) = ("+String.format("%.6f", gammaCalibrationParamG.getCoeff1())+")+("+String.format("%.6f", gammaCalibrationParamG.getCoeff2())+")*x+("+String.format("%.6f", gammaCalibrationParamG.getCoeff3())+")x*x");
-                    strBuffer.append("\n");
-                } else {
-                    strBuffer.append(" CH(x) = (?1)+(?2)*x+(?3)x*x");
-                    strBuffer.append("\n");
-                }
-                if (Objects.nonNull(betaCalibrationParamEG)) {
-                    strBuffer.append(" E(x) =  ("+String.format("%.6f", betaCalibrationParamEG.getCoeff1())+")+("+String.format("%.6f", betaCalibrationParamEG.getCoeff2())+")*x+("+String.format("%.6f", betaCalibrationParamEG.getCoeff3())+")x*x ");
-                } else {
-                    strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x ");
-                }
-                if (Objects.nonNull(gammaCalibrationParamEG)) {
-                    strBuffer.append(" E(x) =  ("+String.format("%.6f", gammaCalibrationParamEG.getCoeff1())+")+("+String.format("%.6f", gammaCalibrationParamEG.getCoeff2())+")*x+("+String.format("%.6f", gammaCalibrationParamEG.getCoeff3())+")x*x");
-                    strBuffer.append("\n");
-                } else {
-                    strBuffer.append(" E(x) =  (?1)+(?2)*x+(?3)x*x");
-                    strBuffer.append("\n");
-                }
+                strBuffer.append(" 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 ")
+                        .append("                        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").append("\n");
+                strBuffer.append(" 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 ")
+                        .append("                        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").append("\n");
                 strBuffer.append("\n");
                 strBuffer.append("#GAS: LIMITS PER ROI").append("\n");
                 strBuffer.append(" Roi                                             Beta                                             Gamma       ").append("\n");
                 if (CollectionUtils.isNotEmpty(channelsSpectrums)) {
                     for (GardsROIChannelsSpectrum channelsSpectrum:channelsSpectrums) {
-                        strBuffer.append(StringPool.SPACE+channelsSpectrum.getRoi()+"                                             "+channelsSpectrum.getBChanStart()+"to"+channelsSpectrum.getBChanStop()+"                                             "+channelsSpectrum.getGChanStart()+"to"+channelsSpectrum.getGChanStop()).append("\n");
+                        strBuffer.append(StringPool.SPACE+channelsSpectrum.getRoi()+"                                             "+channelsSpectrum.getBChanStart()+" to "+channelsSpectrum.getBChanStop()+"                                             "+channelsSpectrum.getGChanStart()+" to "+channelsSpectrum.getGChanStop()).append("\n");
                     }
                 }
                 strBuffer.append("\n");
@@ -1138,18 +1114,27 @@ public class SpectrumAnalysisServiceImpl extends AbstractLogOrReport implements
                 }
                 strBuffer.append("\n");
                 strBuffer.append("#NET COUNTS AND LC PER ROI").append("\n");
-                strBuffer.append(" Roi                                             Net count                                       ").append("\n");
-                if (CollectionUtils.isNotEmpty(resultsSpectrums)) {
-                    for (GardsROIResultsSpectrum resultsSpectrum:resultsSpectrums){
-                        strBuffer.append(StringPool.SPACE+resultsSpectrum.getRoi()+"                                               "+resultsSpectrum.getNet()+" +/- "+Math.sqrt(resultsSpectrum.getNetErr())).append("\n");
+                if (Objects.isNull(resultsSpectrums.get(0).getLcCts())) {
+                    strBuffer.append(" Roi                                             Net count                                          ").append("\n");
+                    if (CollectionUtils.isNotEmpty(resultsSpectrums)) {
+                        for (GardsROIResultsSpectrum resultsSpectrum:resultsSpectrums){
+                            strBuffer.append(StringPool.SPACE+resultsSpectrum.getRoi()+"                                               "+NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getNet()))+" +/- "+NumberFormatUtil.numberSixLen(String.valueOf(Math.sqrt(resultsSpectrum.getNetErr())))).append("\n");
+                        }
+                    }
+                } else {
+                    strBuffer.append(" Roi                                             Net count                                          LC           ").append("\n");
+                    if (CollectionUtils.isNotEmpty(resultsSpectrums)) {
+                        for (GardsROIResultsSpectrum resultsSpectrum:resultsSpectrums){
+                            strBuffer.append(StringPool.SPACE+resultsSpectrum.getRoi()+"                                               "+NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getNet()))+" +/- "+NumberFormatUtil.numberSixLen(String.valueOf(Math.sqrt(resultsSpectrum.getNetErr())))+ "                                          " + NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getLcCts()))).append("\n");
+                        }
                     }
                 }
                 strBuffer.append("\n");
                 strBuffer.append("#CONCENTRATION AND LC PER ROI").append("\n");
-                strBuffer.append(" Roi                                             Conc(mBq/m3)                                    LC(mBq/m3)   MDC(mBq/m3):   ");
+                strBuffer.append(" Roi                                             Conc(mBq/m3)                                    LC(mBq/m3)   MDC(mBq/m3):   ").append("\n");
                 if (CollectionUtils.isNotEmpty(resultsSpectrums)) {
                     for (GardsROIResultsSpectrum resultsSpectrum:resultsSpectrums){
-                        strBuffer.append(StringPool.SPACE+resultsSpectrum.getRoi()+"                                               "+resultsSpectrum.getConcErr()+" +/- "+resultsSpectrum.getConcErr()+"                                    "+resultsSpectrum.getLc()+"   "+resultsSpectrum.getMdc()).append("\n");
+                        strBuffer.append(StringPool.SPACE+resultsSpectrum.getRoi()+"                                               "+NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getConcErr()))+" +/- "+NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getConcErr()))+"                                    "+NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getLc()))+"   "+NumberFormatUtil.numberSixLen(String.valueOf(resultsSpectrum.getMdc()))).append("\n");
                     }
                 }
                 strBuffer.append("\n");
@@ -1157,7 +1142,7 @@ public class SpectrumAnalysisServiceImpl extends AbstractLogOrReport implements
                 strBuffer.append(" Nuclide Name                                    Conc                                            LC           MDC            NID Flag   ").append("\n");
                 if (CollectionUtils.isNotEmpty(xeResultsSpectrums)) {
                     for (GardsXeResultsSpectrum xeResultsSpectrum:xeResultsSpectrums) {
-                        strBuffer.append(StringPool.SPACE+xeResultsSpectrum.getNuclideName()+"                                    "+xeResultsSpectrum.getConc()+" +/- "+xeResultsSpectrum.getConcErr()+"                                            "+xeResultsSpectrum.getLc()+"           "+xeResultsSpectrum.getMdc()+"            "+xeResultsSpectrum.getNidFlag()).append("\n");
+                        strBuffer.append(StringPool.SPACE+xeResultsSpectrum.getNuclideName()+"                                    "+NumberFormatUtil.numberSixLen(String.valueOf(xeResultsSpectrum.getConc()))+" +/- "+NumberFormatUtil.numberSixLen(String.valueOf(xeResultsSpectrum.getConcErr()))+"                                            "+NumberFormatUtil.numberSixLen(String.valueOf(xeResultsSpectrum.getLc()))+"           "+NumberFormatUtil.numberSixLen(String.valueOf(xeResultsSpectrum.getMdc()))+"            "+xeResultsSpectrum.getNidFlag()).append("\n");
                     }
                 }
                 strBuffer.append("\n");
@@ -1170,235 +1155,6 @@ public class SpectrumAnalysisServiceImpl extends AbstractLogOrReport implements
         return result;
     }
 
-    public boolean analyzeRRR(RRRLogInfo rrrLogInfo, BgCalibratePara BgCalPara, List<String> betaFittingPara, List<String> gammaFittingPara, List<String> betaFittingParaToUi, List<String> gammaFittingParaToUi) {
-        boolean bRet = true;
-        File sampleTmp = null;
-        File gasTmp = null;
-        File detTmp = null;
-        try {
-            //根据文件路径 文件名称获取对应的临时文件
-            sampleTmp = ftpUtil.downloadFile(rrrLogInfo.getSampleFilePath(), "betaGamma");
-            gasTmp = ftpUtil.downloadFile(rrrLogInfo.getGasFilePath(), "betaGamma");
-            detTmp = ftpUtil.downloadFile(rrrLogInfo.getDetFilePath(), "betaGamma");
-            //调用动态库解析文件
-            //Gamma Energy Calibration页面  如果点击过fitting使BGammaEnergyValid并且有勾选
-            //如果三个sampleData,GasData,DetData数据都是被勾选状态  则需要传递新的参数重新分析  否则不需要改变数据分析当前文件内容
-            BgAnalyseResult bgAnalyseResult = null;
-            if (Objects.isNull(BgCalPara)) {
-                bgAnalyseResult = EnergySpectrumHandler.bgAnalyse(sampleTmp.getAbsolutePath(), gasTmp.getAbsolutePath(), detTmp.getAbsolutePath());
-            } else {
-                bgAnalyseResult = EnergySpectrumHandler.bgReAnalyse(sampleTmp.getAbsolutePath(), gasTmp.getAbsolutePath(), detTmp.getAbsolutePath(), BgCalPara);
-            }
-            if (StringUtils.isNotBlank(bgAnalyseResult.error_log) && !bgAnalyseResult.error_log.equalsIgnoreCase("no error.")) {
-                bRet = false;
-            } else {
-                //处理XeData的数据
-                List<GardsXeResultsSpectrum> xeResultsSpectrumList = new LinkedList<>();
-                GardsXeResultsSpectrum xe131m = new GardsXeResultsSpectrum();
-                xe131m.setNuclideName(XeNuclideName.XE_131m.getType());
-                xe131m.setConc(bgAnalyseResult.Xe131m_con);
-                xe131m.setConcErr(bgAnalyseResult.Xe131m_uncer);
-                xe131m.setLc(bgAnalyseResult.LC_Xe131m);
-                xe131m.setMdc(bgAnalyseResult.MDC_Xe131m);
-                xe131m.setNidFlag(bgAnalyseResult.XE_131m_NID_FLAG);
-                xeResultsSpectrumList.add(xe131m);
-                GardsXeResultsSpectrum xe133 = new GardsXeResultsSpectrum();
-                xe133.setNuclideName(XeNuclideName.XE_133.getType());
-                xe133.setConc(bgAnalyseResult.Xe133_con);
-                xe133.setConcErr(bgAnalyseResult.Xe133_uncer);
-                xe133.setLc(bgAnalyseResult.LC_Xe133);
-                xe133.setMdc(bgAnalyseResult.MDC_Xe133);
-                xe133.setNidFlag(bgAnalyseResult.XE_133_NID_FLAG);
-                xeResultsSpectrumList.add(xe133);
-                GardsXeResultsSpectrum xe133m = new GardsXeResultsSpectrum();
-                xe133m.setNuclideName(XeNuclideName.XE_133m.getType());
-                xe133m.setConc(bgAnalyseResult.Xe133m_con);
-                xe133m.setConcErr(bgAnalyseResult.Xe133m_uncer);
-                xe133m.setLc(bgAnalyseResult.LC_Xe133m);
-                xe133m.setMdc(bgAnalyseResult.MDC_Xe133m);
-                xe133m.setNidFlag(bgAnalyseResult.XE_133m_NID_FLAG);
-                xeResultsSpectrumList.add(xe133m);
-                GardsXeResultsSpectrum xe135 = new GardsXeResultsSpectrum();
-                xe135.setNuclideName(XeNuclideName.XE_135.getType());
-                xe135.setConc(bgAnalyseResult.Xe135_con);
-                xe135.setConcErr(bgAnalyseResult.Xe135_uncer);
-                xe135.setLc(bgAnalyseResult.LC_Xe135);
-                xe135.setMdc(bgAnalyseResult.MDC_Xe135);
-                xe135.setNidFlag(bgAnalyseResult.XE_135_NID_FLAG);
-                xeResultsSpectrumList.add(xe135);
-                rrrLogInfo.setXeResultsSpectrumList(xeResultsSpectrumList);
-                //处理GammaCalibration的数据
-                List<GardsCalibrationSpectrum> gammaCalibrationSpectrumList = new LinkedList<>();
-                if (rrrLogInfo.isBGammaEnergyValidSample()) {
-                    GardsCalibrationSpectrum gammaCalibrationS = new GardsCalibrationSpectrum();
-                    gammaCalibrationS.setDataType(DataTypeAbbr.SAMPLEPHD.getType());
-                    gammaCalibrationS.setCoeff1(Double.valueOf(gammaFittingPara.get(0)));
-                    gammaCalibrationS.setCoeff2(Double.valueOf(gammaFittingPara.get(1)));
-                    gammaCalibrationS.setCoeff3(Double.valueOf(gammaFittingPara.get(2)));
-                    gammaCalibrationSpectrumList.add(gammaCalibrationS);
-                } else {
-                    GardsCalibrationSpectrum gammaCalibrationS = new GardsCalibrationSpectrum();
-                    gammaCalibrationS.setDataType(DataTypeAbbr.SAMPLEPHD.getType());
-                    gammaCalibrationS.setCoeff1(bgAnalyseResult.s_g_fitting_c_e.get(0));
-                    gammaCalibrationS.setCoeff2(bgAnalyseResult.s_g_fitting_c_e.get(1));
-                    gammaCalibrationS.setCoeff3(bgAnalyseResult.s_g_fitting_c_e.get(2));
-                    gammaCalibrationSpectrumList.add(gammaCalibrationS);
-                }
-                if (rrrLogInfo.isBGammaEnergyValidGas()) {
-                    GardsCalibrationSpectrum gammaCalibrationG = new GardsCalibrationSpectrum();
-                    gammaCalibrationG.setDataType(DataTypeAbbr.GASBKPHD.getType());
-                    gammaCalibrationG.setCoeff1(Double.valueOf(gammaFittingPara.get(0)));
-                    gammaCalibrationG.setCoeff2(Double.valueOf(gammaFittingPara.get(1)));
-                    gammaCalibrationG.setCoeff3(Double.valueOf(gammaFittingPara.get(2)));
-                    gammaCalibrationSpectrumList.add(gammaCalibrationG);
-                } else {
-                    GardsCalibrationSpectrum gammaCalibrationG = new GardsCalibrationSpectrum();
-                    gammaCalibrationG.setDataType(DataTypeAbbr.GASBKPHD.getType());
-                    gammaCalibrationG.setCoeff1(bgAnalyseResult.g_g_fitting_c_e.get(0));
-                    gammaCalibrationG.setCoeff2(bgAnalyseResult.g_g_fitting_c_e.get(1));
-                    gammaCalibrationG.setCoeff3(bgAnalyseResult.g_g_fitting_c_e.get(2));
-                    gammaCalibrationSpectrumList.add(gammaCalibrationG);
-                }
-                if (rrrLogInfo.isBGammaEnergyValidDet()) {
-                    GardsCalibrationSpectrum gammaCalibrationD = new GardsCalibrationSpectrum();
-                    gammaCalibrationD.setDataType(DataTypeAbbr.DETBKPHD.getType());
-                    gammaCalibrationD.setCoeff1(Double.valueOf(gammaFittingPara.get(0)));
-                    gammaCalibrationD.setCoeff2(Double.valueOf(gammaFittingPara.get(1)));
-                    gammaCalibrationD.setCoeff3(Double.valueOf(gammaFittingPara.get(2)));
-                    gammaCalibrationSpectrumList.add(gammaCalibrationD);
-                } else {
-                    GardsCalibrationSpectrum gammaCalibrationD = new GardsCalibrationSpectrum();
-                    gammaCalibrationD.setDataType(DataTypeAbbr.DETBKPHD.getType());
-                    gammaCalibrationD.setCoeff1(bgAnalyseResult.d_g_fitting_c_e.get(0));
-                    gammaCalibrationD.setCoeff2(bgAnalyseResult.d_g_fitting_c_e.get(1));
-                    gammaCalibrationD.setCoeff3(bgAnalyseResult.d_g_fitting_c_e.get(2));
-                    gammaCalibrationSpectrumList.add(gammaCalibrationD);
-                }
-                rrrLogInfo.setGammaCalibrationParamList(gammaCalibrationSpectrumList);
-                //处理BetaCalibration数据
-                List<GardsCalibrationSpectrum> betaCalibrationSpectrumList = new LinkedList<>();
-                if (rrrLogInfo.isBBetaEnergyValidSample()) {
-                    GardsCalibrationSpectrum betaCalibrationS = new GardsCalibrationSpectrum();
-                    betaCalibrationS.setDataType(DataTypeAbbr.SAMPLEPHD.getType());
-                    betaCalibrationS.setCoeff1(Double.valueOf(betaFittingPara.get(0)));
-                    betaCalibrationS.setCoeff2(Double.valueOf(betaFittingPara.get(1)));
-                    betaCalibrationS.setCoeff3(Double.valueOf(betaFittingPara.get(2)));
-                    betaCalibrationSpectrumList.add(betaCalibrationS);
-                } else {
-                    GardsCalibrationSpectrum betaCalibrationS = new GardsCalibrationSpectrum();
-                    betaCalibrationS.setDataType(DataTypeAbbr.SAMPLEPHD.getType());
-                    betaCalibrationS.setCoeff1(bgAnalyseResult.s_b_fitting_c_e.get(0));
-                    betaCalibrationS.setCoeff2(bgAnalyseResult.s_b_fitting_c_e.get(1));
-                    betaCalibrationS.setCoeff3(bgAnalyseResult.s_b_fitting_c_e.get(2));
-                    betaCalibrationSpectrumList.add(betaCalibrationS);
-                }
-                if (rrrLogInfo.isBBetaEnergyValidGas()) {
-                    GardsCalibrationSpectrum betaCalibrationG = new GardsCalibrationSpectrum();
-                    betaCalibrationG.setDataType(DataTypeAbbr.GASBKPHD.getType());
-                    betaCalibrationG.setCoeff1(Double.valueOf(betaFittingPara.get(0)));
-                    betaCalibrationG.setCoeff2(Double.valueOf(betaFittingPara.get(1)));
-                    betaCalibrationG.setCoeff3(Double.valueOf(betaFittingPara.get(2)));
-                    betaCalibrationSpectrumList.add(betaCalibrationG);
-                } else {
-                    GardsCalibrationSpectrum betaCalibrationG = new GardsCalibrationSpectrum();
-                    betaCalibrationG.setDataType(DataTypeAbbr.GASBKPHD.getType());
-                    betaCalibrationG.setCoeff1(bgAnalyseResult.g_b_fitting_c_e.get(0));
-                    betaCalibrationG.setCoeff2(bgAnalyseResult.g_b_fitting_c_e.get(1));
-                    betaCalibrationG.setCoeff3(bgAnalyseResult.g_b_fitting_c_e.get(2));
-                    betaCalibrationSpectrumList.add(betaCalibrationG);
-                }
-                if (rrrLogInfo.isBBetaEnergyValidDet()) {
-                    GardsCalibrationSpectrum betaCalibrationD = new GardsCalibrationSpectrum();
-                    betaCalibrationD.setDataType(DataTypeAbbr.DETBKPHD.getType());
-                    betaCalibrationD.setCoeff1(Double.valueOf(betaFittingPara.get(0)));
-                    betaCalibrationD.setCoeff2(Double.valueOf(betaFittingPara.get(1)));
-                    betaCalibrationD.setCoeff3(Double.valueOf(betaFittingPara.get(2)));
-                    betaCalibrationSpectrumList.add(betaCalibrationD);
-                } else {
-                    GardsCalibrationSpectrum betaCalibrationD = new GardsCalibrationSpectrum();
-                    betaCalibrationD.setDataType(DataTypeAbbr.DETBKPHD.getType());
-                    betaCalibrationD.setCoeff1(bgAnalyseResult.d_b_fitting_c_e.get(0));
-                    betaCalibrationD.setCoeff2(bgAnalyseResult.d_b_fitting_c_e.get(1));
-                    betaCalibrationD.setCoeff3(bgAnalyseResult.d_b_fitting_c_e.get(2));
-                    betaCalibrationSpectrumList.add(betaCalibrationD);
-                }
-                rrrLogInfo.setBetaCalibrationParamList(betaCalibrationSpectrumList);
-                //存储roiChannel数据
-                List<GardsROIChannelsSpectrum> roiChannelsSpectrumList = new LinkedList<>();
-                for (int i=0; i<bgAnalyseResult.S_ROI_B_Boundary_start.size(); i++) {
-                    GardsROIChannelsSpectrum roiChannels = new GardsROIChannelsSpectrum();
-                    roiChannels.setDataType(DataTypeAbbr.SAMPLEPHD.getType());
-                    roiChannels.setRoi(i+1);
-                    roiChannels.setBChanStart(bgAnalyseResult.S_ROI_B_Boundary_start.get(i));
-                    roiChannels.setBChanStop(bgAnalyseResult.S_ROI_B_Boundary_stop.get(i));
-                    roiChannels.setGChanStart(bgAnalyseResult.S_ROI_G_Boundary_start.get(i));
-                    roiChannels.setGChanStop(bgAnalyseResult.S_ROI_G_Boundary_stop.get(i));
-                    roiChannelsSpectrumList.add(roiChannels);
-                }
-                for (int i=0; i<bgAnalyseResult.G_ROI_B_Boundary_start.size(); i++) {
-                    GardsROIChannelsSpectrum roiChannels = new GardsROIChannelsSpectrum();
-                    roiChannels.setDataType(DataTypeAbbr.GASBKPHD.getType());
-                    roiChannels.setRoi(i+1);
-                    roiChannels.setBChanStart(bgAnalyseResult.G_ROI_B_Boundary_start.get(i));
-                    roiChannels.setBChanStop(bgAnalyseResult.G_ROI_B_Boundary_stop.get(i));
-                    roiChannels.setGChanStart(bgAnalyseResult.G_ROI_G_Boundary_start.get(i));
-                    roiChannels.setGChanStop(bgAnalyseResult.G_ROI_G_Boundary_stop.get(i));
-                    roiChannelsSpectrumList.add(roiChannels);
-                }
-                for (int i=0; i<bgAnalyseResult.D_ROI_B_Boundary_start.size(); i++) {
-                    GardsROIChannelsSpectrum roiChannels = new GardsROIChannelsSpectrum();
-                    roiChannels.setDataType(DataTypeAbbr.DETBKPHD.getType());
-                    roiChannels.setRoi(i+1);
-                    roiChannels.setBChanStart(bgAnalyseResult.D_ROI_B_Boundary_start.get(i));
-                    roiChannels.setBChanStop(bgAnalyseResult.D_ROI_B_Boundary_stop.get(i));
-                    roiChannels.setGChanStart(bgAnalyseResult.D_ROI_G_Boundary_start.get(i));
-                    roiChannels.setGChanStop(bgAnalyseResult.D_ROI_G_Boundary_stop.get(i));
-                    roiChannelsSpectrumList.add(roiChannels);
-                }
-                rrrLogInfo.setRoiChannelsSpectrumList(roiChannelsSpectrumList);
-                bgAnalyseResult.LC.add(0, 0.0);
-                bgAnalyseResult.MDC.add(0, 0.0);
-                //存储roiResult的数据
-                List<GardsROIResultsSpectrum> roiResultsSpectrumList = new LinkedList<>();
-                for (int i=0; i<bgAnalyseResult.s_roi_cts.size(); i++) {
-                    GardsROIResultsSpectrum roiResults = new GardsROIResultsSpectrum();
-                    roiResults.setRoi(i+1);
-                    roiResults.setLc(bgAnalyseResult.LC.get(i));
-                    roiResults.setSGross(bgAnalyseResult.s_roi_cts.get(i));
-                    roiResults.setGGross(bgAnalyseResult.g_roi_cts.get(i));
-                    roiResults.setBGross(bgAnalyseResult.d_roi_cts.get(i));
-                    roiResults.setSNet(bgAnalyseResult.s_deduct_d_cts.get((i+1)*3));
-                    roiResults.setGNet(bgAnalyseResult.g_deduct_d_cts.get((i+1)*3));
-                    roiResults.setNet(bgAnalyseResult.ROI_net_coutns.get(i));
-                    roiResults.setNetErr(bgAnalyseResult.ROI_net_coutns_err.get(i));
-                    roiResults.setConc(bgAnalyseResult.ROI_con_uncer.get(i));
-                    roiResults.setConcErr(bgAnalyseResult.ROI_con_uncer_err.get(i));
-                    roiResults.setMdc(bgAnalyseResult.MDC.get(i));
-                    if(bgAnalyseResult.ROI_con_uncer.get(i)>bgAnalyseResult.MDC.get(i)) {
-                        roiResults.setNidFlag(1);
-                    } else {
-                        roiResults.setNidFlag(0);
-                    }
-                    roiResultsSpectrumList.add(roiResults);
-                }
-                rrrLogInfo.setRoiResultsSpectrumList(roiResultsSpectrumList);
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        } finally {
-            if (Objects.nonNull(sampleTmp)) {
-                sampleTmp.delete();
-            }
-            if (Objects.nonNull(gasTmp)) {
-                gasTmp.delete();
-            }
-            if (Objects.nonNull(detTmp)) {
-                detTmp.delete();
-            }
-        }
-        return bRet;
-    }
-
     @Override
     public Result viewSpectrum(Integer sampleId, String dbName, String sampleFileName, String gasFileName, String detFileName, String qcFileName, HttpServletRequest request) {
         Result result = new Result();
@@ -3003,9 +2759,9 @@ public class SpectrumAnalysisServiceImpl extends AbstractLogOrReport implements
                                 xeData.setColor("green");
                                 xeData.setNidFlag(1);
                             }
-                            xeData.setMdc(Double.valueOf(String.format("%."+(6 - String.valueOf(Math.abs(xeData.getMdc())).substring(0, String.valueOf(Math.abs(xeData.getMdc())).lastIndexOf(StringPool.DOT)).length())+"f", xeData.getMdc())));
-                            xeData.setConc(Double.valueOf(String.format("%."+(6 - String.valueOf(Math.abs(xeData.getConc())).substring(0, String.valueOf(Math.abs(xeData.getConc())).lastIndexOf(StringPool.DOT)).length())+"f", xeData.getConc())));
-                            xeData.setConcErr(Double.valueOf(String.format("%."+((6 - String.valueOf(Math.abs(xeData.getConcErr())).substring(0, String.valueOf(Math.abs(xeData.getConcErr())).lastIndexOf(StringPool.DOT)).length()))+"f", xeData.getConcErr())));
+                            xeData.setMdc(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getMdc()))));
+                            xeData.setConc(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getConc()))));
+                            xeData.setConcErr(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getConcErr()))));
                         }
                         betaDataFile.setXeResultsSpectrumList(xeResultsSpectrumList);
                         betaDataFile.setBProcessed(true);
@@ -3257,9 +3013,9 @@ public class SpectrumAnalysisServiceImpl extends AbstractLogOrReport implements
                                     xeData.setColor("green");
                                     xeData.setNidFlag(1);
                                 }
-                                xeData.setMdc(Double.valueOf(String.format("%."+(6 - String.valueOf(Math.abs(xeData.getMdc())).substring(0, String.valueOf(Math.abs(xeData.getMdc())).lastIndexOf(StringPool.DOT)).length())+"f", xeData.getMdc())));
-                                xeData.setConc(Double.valueOf(String.format("%."+(6 - String.valueOf(Math.abs(xeData.getConc())).substring(0, String.valueOf(Math.abs(xeData.getConc())).lastIndexOf(StringPool.DOT)).length())+"f", xeData.getConc())));
-                                xeData.setConcErr(Double.valueOf(String.format("%."+((6 - String.valueOf(Math.abs(xeData.getConcErr())).substring(0, String.valueOf(Math.abs(xeData.getConcErr())).lastIndexOf(StringPool.DOT)).length()))+"f", xeData.getConcErr())));
+                                xeData.setMdc(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getMdc()))));
+                                xeData.setConc(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getConc()))));
+                                xeData.setConcErr(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getConcErr()))));
                             }
                             sampleBetaData.setXeResultsSpectrumList(xeResultsSpectrumList);
                             sampleBetaData.setBProcessed(true);
@@ -3271,123 +3027,6 @@ public class SpectrumAnalysisServiceImpl extends AbstractLogOrReport implements
                         xeMap.put("XeData", Collections.EMPTY_LIST);
                         analyseResultMap.put(sampleFileName, xeMap);
                     }
-//                    BgAnalyseResult analyseResult = EnergySpectrumHandler.bgReAnalyse(sampleTmp.getAbsolutePath(), gasTmp.getAbsolutePath(), detTmp.getAbsolutePath(), spectrum_group.BgCalPara);
-//                    if (StringUtils.isNotBlank(analyseResult.error_log) && !analyseResult.error_log.equalsIgnoreCase("no error.")) {
-//                        analyseResultMap.put(sampleFileName, Collections.EMPTY_LIST);
-//                    } else {
-//                        //生成分析操作日志
-//                        EnergySpectrumStruct sample = phdFileUtil.analyzeFileSourceData(sampleTmp);
-//                        EnergySpectrumStruct gas = phdFileUtil.analyzeFileSourceData(gasTmp);
-//                        EnergySpectrumStruct det = phdFileUtil.analyzeFileSourceData(detTmp);
-//                        String logName = sampleFileName.replace("PHD", "log");
-//                        phdFileUtil.OutPutRnLog(analyseResult, sample, gas, det, logName);
-//                        //存入xeData数据
-//                        List<GardsXeResultsSpectrum> xeResultsSpectrumList = new LinkedList<>();
-//                        GardsXeResultsSpectrum xe131m = new GardsXeResultsSpectrum();
-//                        xe131m.setNuclideName(XeNuclideName.XE_131m.getType());
-//                        xe131m.setConc(analyseResult.Xe131m_con);
-//                        xe131m.setConcErr(analyseResult.Xe131m_uncer);
-//                        xe131m.setLc(analyseResult.LC_Xe131m);
-//                        xe131m.setMdc(analyseResult.MDC_Xe131m);
-//                        xe131m.setNidFlag(analyseResult.XE_131m_NID_FLAG);
-//                        xeResultsSpectrumList.add(xe131m);
-//                        GardsXeResultsSpectrum xe133 = new GardsXeResultsSpectrum();
-//                        xe133.setNuclideName(XeNuclideName.XE_133.getType());
-//                        xe133.setConc(analyseResult.Xe133_con);
-//                        xe133.setConcErr(analyseResult.Xe133_uncer);
-//                        xe133.setLc(analyseResult.LC_Xe133);
-//                        xe133.setMdc(analyseResult.MDC_Xe133);
-//                        xe133.setNidFlag(analyseResult.XE_133_NID_FLAG);
-//                        xeResultsSpectrumList.add(xe133);
-//                        GardsXeResultsSpectrum xe133m = new GardsXeResultsSpectrum();
-//                        xe133m.setNuclideName(XeNuclideName.XE_133m.getType());
-//                        xe133m.setConc(analyseResult.Xe133m_con);
-//                        xe133m.setConcErr(analyseResult.Xe133m_uncer);
-//                        xe133m.setLc(analyseResult.LC_Xe133m);
-//                        xe133m.setMdc(analyseResult.MDC_Xe133m);
-//                        xe133m.setNidFlag(analyseResult.XE_133m_NID_FLAG);
-//                        xeResultsSpectrumList.add(xe133m);
-//                        GardsXeResultsSpectrum xe135 = new GardsXeResultsSpectrum();
-//                        xe135.setNuclideName(XeNuclideName.XE_135.getType());
-//                        xe135.setConc(analyseResult.Xe135_con);
-//                        xe135.setConcErr(analyseResult.Xe135_uncer);
-//                        xe135.setLc(analyseResult.LC_Xe135);
-//                        xe135.setMdc(analyseResult.MDC_Xe135);
-//                        xe135.setNidFlag(analyseResult.XE_135_NID_FLAG);
-//                        xeResultsSpectrumList.add(xe135);
-//                        xeMap.put("XeData", xeResultsSpectrumList);
-//                        //新计算得到的边界值
-//                        if (CollectionUtils.isNotEmpty(analyseResult.S_ROI_B_Boundary_start)) {
-//                            List<Boundary> boundaryList = new LinkedList<>();
-//                            for (int i=0; i<analyseResult.S_ROI_B_Boundary_start.size(); i++) {
-//                                Boundary boundary = new Boundary();
-//                                boundary.setMinX(analyseResult.S_ROI_B_Boundary_start.get(i));
-//                                boundary.setMaxX(analyseResult.S_ROI_B_Boundary_stop.get(i));
-//                                boundary.setMinY(analyseResult.S_ROI_G_Boundary_start.get(i));
-//                                boundary.setMaxY(analyseResult.S_ROI_G_Boundary_stop.get(i));
-//                                boundaryList.add(boundary);
-//                            }
-//                            sampleBetaData.setSampleBoundary(boundaryList);
-//                            xeMap.put("SampleBoundary", boundaryList);
-//                        }
-//                        if (CollectionUtils.isNotEmpty(analyseResult.G_ROI_B_Boundary_start)) {
-//                            List<Boundary> boundaryList = new LinkedList<>();
-//                            for (int i=0; i<analyseResult.G_ROI_B_Boundary_start.size(); i++) {
-//                                Boundary boundary = new Boundary();
-//                                boundary.setMinX(analyseResult.G_ROI_B_Boundary_start.get(i));
-//                                boundary.setMaxX(analyseResult.G_ROI_B_Boundary_stop.get(i));
-//                                boundary.setMinY(analyseResult.G_ROI_G_Boundary_start.get(i));
-//                                boundary.setMaxY(analyseResult.G_ROI_G_Boundary_stop.get(i));
-//                                boundaryList.add(boundary);
-//                            }
-//                            sampleBetaData.setGasBoundary(boundaryList);
-//                            xeMap.put("GasBoundary", boundaryList);
-//                        }
-//                        if (CollectionUtils.isNotEmpty(analyseResult.D_ROI_B_Boundary_start)) {
-//                            List<Boundary> boundaryList = new LinkedList<>();
-//                            for (int i=0; i<analyseResult.D_ROI_B_Boundary_start.size(); i++) {
-//                                Boundary boundary = new Boundary();
-//                                boundary.setMinX(analyseResult.D_ROI_B_Boundary_start.get(i));
-//                                boundary.setMaxX(analyseResult.D_ROI_B_Boundary_stop.get(i));
-//                                boundary.setMinY(analyseResult.D_ROI_G_Boundary_start.get(i));
-//                                boundary.setMaxY(analyseResult.D_ROI_G_Boundary_stop.get(i));
-//                                boundaryList.add(boundary);
-//                            }
-//                            sampleBetaData.setDetBoundary(boundaryList);
-//                            xeMap.put("DetBoundary", boundaryList);
-//                        }
-//                        if (analyseData.isQcData()) {
-//                            if (StringUtils.isNotBlank(sampleBetaData.getQcFilePathName())) {
-//                                EnergySpectrumStruct struct = sampleBetaData.getQcStruct();
-//                                if (Objects.nonNull(struct)) {
-//                                    phdFileUtil.CalQCBoundary(betaList, gammaList, betaFittingParaToUi, gammaFittingParaToUi, struct, xeMap, sampleBetaData);
-//                                }
-//                            }
-//                        }
-//                        if (CollectionUtils.isNotEmpty(xeResultsSpectrumList)){
-//                            for (GardsXeResultsSpectrum xeData:xeResultsSpectrumList) {
-//                                Double conc = xeData.getConc();
-//                                Double mdc = xeData.getMdc();
-//                                if (conc < 0){
-//                                    xeData.setColor("red");
-//                                    xeData.setNidFlag(0);
-//                                } else if (0<conc && conc < mdc) {
-//                                    xeData.setColor("#ffcc30");
-//                                    xeData.setNidFlag(0);
-//                                } else if (conc > mdc) {
-//                                    xeData.setColor("green");
-//                                    xeData.setNidFlag(1);
-//                                }
-//                                xeData.setMdc(Double.valueOf(String.format("%."+(6 - String.valueOf(Math.abs(xeData.getMdc())).substring(0, String.valueOf(Math.abs(xeData.getMdc())).lastIndexOf(StringPool.DOT)).length())+"f", xeData.getMdc())));
-//                                xeData.setConc(Double.valueOf(String.format("%."+(6 - String.valueOf(Math.abs(xeData.getConc())).substring(0, String.valueOf(Math.abs(xeData.getConc())).lastIndexOf(StringPool.DOT)).length())+"f", xeData.getConc())));
-//                                xeData.setConcErr(Double.valueOf(String.format("%."+((6 - String.valueOf(Math.abs(xeData.getConcErr())).substring(0, String.valueOf(Math.abs(xeData.getConcErr())).lastIndexOf(StringPool.DOT)).length()))+"f", xeData.getConcErr())));
-//                            }
-//                            sampleBetaData.setXeResultsSpectrumList(xeResultsSpectrumList);
-//                            sampleBetaData.setBProcessed(true);
-//                            sampleBetaData.setSaveAnalysisResult(true);
-//                        }
-//                        analyseResultMap.put(sampleFileName, xeResultsSpectrumList);
-//                    }
                 }
             }
         } catch (Exception e) {
@@ -3487,9 +3126,9 @@ public class SpectrumAnalysisServiceImpl extends AbstractLogOrReport implements
                                 xeData.setColor("green");
                                 xeData.setNidFlag(1);
                             }
-                            xeData.setMdc(Double.valueOf(String.format("%."+(6 - String.valueOf(Math.abs(xeData.getMdc())).substring(0, String.valueOf(Math.abs(xeData.getMdc())).lastIndexOf(StringPool.DOT)).length())+"f", xeData.getMdc())));
-                            xeData.setConc(Double.valueOf(String.format("%."+(6 - String.valueOf(Math.abs(xeData.getConc())).substring(0, String.valueOf(Math.abs(xeData.getConc())).lastIndexOf(StringPool.DOT)).length())+"f", xeData.getConc())));
-                            xeData.setConcErr(Double.valueOf(String.format("%."+((6 - String.valueOf(Math.abs(xeData.getConcErr())).substring(0, String.valueOf(Math.abs(xeData.getConcErr())).lastIndexOf(StringPool.DOT)).length()))+"f", xeData.getConcErr())));
+                            xeData.setMdc(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getMdc()))));
+                            xeData.setConc(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getConc()))));
+                            xeData.setConcErr(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getConcErr()))));
                         }
                         betaDataFile.setXeResultsSpectrumList(xeDataList);
                     }
@@ -3597,9 +3236,9 @@ public class SpectrumAnalysisServiceImpl extends AbstractLogOrReport implements
                                         xeData.setColor("green");
                                         xeData.setNidFlag(1);
                                     }
-                                    xeData.setMdc(Double.valueOf(String.format("%."+(6 - String.valueOf(Math.abs(xeData.getMdc())).substring(0, String.valueOf(Math.abs(xeData.getMdc())).lastIndexOf(StringPool.DOT)).length())+"f", xeData.getMdc())));
-                                    xeData.setConc(Double.valueOf(String.format("%."+(6 - String.valueOf(Math.abs(xeData.getConc())).substring(0, String.valueOf(Math.abs(xeData.getConc())).lastIndexOf(StringPool.DOT)).length())+"f", xeData.getConc())));
-                                    xeData.setConcErr(Double.valueOf(String.format("%."+((6 - String.valueOf(Math.abs(xeData.getConcErr())).substring(0, String.valueOf(Math.abs(xeData.getConcErr())).lastIndexOf(StringPool.DOT)).length()))+"f", xeData.getConcErr())));
+                                    xeData.setMdc(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getMdc()))));
+                                    xeData.setConc(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getConc()))));
+                                    xeData.setConcErr(Double.valueOf(NumberFormatUtil.numberSixLen(String.valueOf(xeData.getConcErr()))));
                                 }
                                 betaDataFile.setXeResultsSpectrumList(xeDataList);
                             }