diff --git a/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java b/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java index 5b27e73..172f687 100644 --- a/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java +++ b/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java @@ -917,7 +917,10 @@ //电流表示值误差（间接测量）需计算标准值 if ("5".equals(measureData.getDataType())) { //标准值 = 标准电压值/标准电阻值 - BigDecimal standardValue = new BigDecimal(measureData.getStandardVoltageValue()).divide(new BigDecimal(measureData.getStandardResistanceValue()), 4, RoundingMode.HALF_UP); + //单位转换 + BigDecimal resistance = UnitConvertUtil.resistanceConvert(measureData.getStandardResistanceValue(), measureData.getStandardResistanceValueUnit(), "Ω"); + BigDecimal voltage = UnitConvertUtil.voltageConvert(measureData.getStandardVoltageValue(), measureData.getStandardVoltageValueUnit(), "V"); + BigDecimal standardValue = voltage.divide(resistance, 4, RoundingMode.HALF_UP); measureData.setStandardValue(String.valueOf(standardValue)); } @@ -1275,7 +1278,6 @@ String unit = measureData.getUnit(); if ("1".equals(measureData.getDataType())) { BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); //测量值1、测量值2、测量值3，根据单位保留小数位，单位和标称值单位相同 BigDecimal oneValue = UnitConvertUtil.valueDecimalConvert(unit, measureData.getOneValue()); BigDecimal twoValue = UnitConvertUtil.valueDecimalConvert(unit, measureData.getTwoValue()); @@ -1283,29 +1285,33 @@ measureData.setOneValue(String.valueOf(oneValue)); measureData.setTwoValue(String.valueOf(twoValue)); measureData.setThreeValue(String.valueOf(threeValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同测量值 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - lowerIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(lowerIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - upperIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(upperIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); //均值 = （测量值1+测量值2+测量值3）/ 3，保留小数规则同测量值 BigDecimal averageValue = (oneValue.add(twoValue).add(threeValue)).divide(BigDecimal.valueOf(3), 12, RoundingMode.HALF_UP); averageValue = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(averageValue)); measureData.setAverageValue(String.valueOf(averageValue)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标，保留小数规则同测量值 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + lowerIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(lowerIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + upperIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(upperIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("2".equals(measureData.getDataType())) { //扫描宽度 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); //fl1、fr1、fl2、fr2、fl3、fr3 BigDecimal oneValue = new BigDecimal(measureData.getOneValue()).round(new MathContext(5, RoundingMode.HALF_UP)); BigDecimal twoValue = new BigDecimal(measureData.getTwoValue()).round(new MathContext(5, RoundingMode.HALF_UP)); @@ -1319,31 +1325,34 @@ measureData.setFourValue(String.valueOf(fourValue)); measureData.setFiveValue(String.valueOf(fiveValue)); measureData.setSixValue(String.valueOf(sixValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 - BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - BigDecimal lowerIndex = beforeLowerIndex.round(new MathContext(5, RoundingMode.HALF_UP)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - BigDecimal upperIndex = beforeUpperIndex.round(new MathContext(5, RoundingMode.HALF_UP)); - measureData.setUpperIndex(String.valueOf(upperIndex)); //均值 = ((fr1-fl1)+(fr2-fl2)+(fr3-fl3))*10/8/3 BigDecimal beforeAverageValue = (twoValue.subtract(oneValue).add(fourValue).subtract(threeValue).add(sixValue).subtract(fiveValue)) .multiply(BigDecimal.valueOf(10)).divide(BigDecimal.valueOf(8), 6, RoundingMode.HALF_UP).divide(BigDecimal.valueOf(3), 6, RoundingMode.HALF_UP); BigDecimal averageValue = beforeAverageValue.round(new MathContext(5, RoundingMode.HALF_UP)); measureData.setAverageValue(String.valueOf(averageValue)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 + BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + BigDecimal lowerIndex = beforeLowerIndex.round(new MathContext(5, RoundingMode.HALF_UP)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + BigDecimal upperIndex = beforeUpperIndex.round(new MathContext(5, RoundingMode.HALF_UP)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("3".equals(measureData.getDataType())) { //中频带宽 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndexLeft = measureData.getTechnicalIndexLeft(); - String technicalIndexRight = measureData.getTechnicalIndexRight(); if (StringUtils.isNotEmpty(measureData.getOneValue()) && StringUtils.isNotEmpty(measureData.getTwoValue()) && StringUtils.isNotEmpty(measureData.getThreeValue()) && StringUtils.isNotEmpty(measureData.getFourValue()) && StringUtils.isNotEmpty(measureData.getFiveValue()) && StringUtils.isNotEmpty(measureData.getSixValue())) { @@ -1367,20 +1376,26 @@ //均值 = (△f1+△f2+△f3)/3 BigDecimal averageValue = (eightValue.add(nineValue).add(tenValue)).divide(BigDecimal.valueOf(3), 2, RoundingMode.HALF_UP); measureData.setAverageValue(String.valueOf(averageValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 - BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndexLeft)); - BigDecimal lowerIndex = beforeLowerIndex.setScale(2, RoundingMode.HALF_UP); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndexRight)); - BigDecimal upperIndex = beforeUpperIndex.setScale(2, RoundingMode.HALF_UP); - measureData.setUpperIndex(String.valueOf(upperIndex)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndexLeft()) || "/".equals(measureData.getTechnicalIndexRight())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndexLeft = measureData.getTechnicalIndexLeft(); + String technicalIndexRight = measureData.getTechnicalIndexRight(); + //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 + BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndexLeft)); + BigDecimal lowerIndex = beforeLowerIndex.setScale(2, RoundingMode.HALF_UP); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndexRight)); + BigDecimal upperIndex = beforeUpperIndex.setScale(2, RoundingMode.HALF_UP); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("4".equals(measureData.getDataType())) { //中频带宽转换偏差 @@ -1391,13 +1406,17 @@ BigDecimal convertDeviation = new BigDecimal(measureData.getOneValue()).subtract(new BigDecimal(referValue)); measureData.setConvertDeviation(String.valueOf(convertDeviation)); //结论，转换偏差是否在转换偏差下限、转换偏差上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将转换偏差字段（参与比较字段）标* - BigDecimal upperConvertDeviation = new BigDecimal(measureData.getUpperConvertDeviation()); - BigDecimal lowerConvertDeviation = new BigDecimal(measureData.getLowerConvertDeviation()); - if (convertDeviation.compareTo(upperConvertDeviation) > 0 || convertDeviation.compareTo(lowerConvertDeviation) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperConvertDeviation()) || "/".equals(measureData.getLowerConvertDeviation())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperConvertDeviation = new BigDecimal(measureData.getUpperConvertDeviation()); + BigDecimal lowerConvertDeviation = new BigDecimal(measureData.getLowerConvertDeviation()); + if (convertDeviation.compareTo(upperConvertDeviation) > 0 || convertDeviation.compareTo(lowerConvertDeviation) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("5".equals(measureData.getDataType())) { @@ -1412,18 +1431,22 @@ measureData.setOneValue(String.valueOf(oneValue)); //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); - //指标下限 = 标称值 - 技术指标 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); - if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("6".equals(measureData.getDataType())) { @@ -1434,13 +1457,7 @@ BigDecimal firstAttenuatorAttenuation = new BigDecimal(firstData.getStandardAttenuatorAttenuation()); BigDecimal firstSourceAmplitude = new BigDecimal(firstData.getSignalSourceAmplitude()); BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); - //指标下限 = 标称值 - 技术指标 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); + //测量值 = 标准衰减器衰减量(当次测量)-标准衰减器衰减量(上一次测量)+(信号源幅度(当次测量)-信号源幅度（上一次测量）).后面带单位，与标称值单位相同 BigDecimal attenuatorAttenuation = new BigDecimal(measureData.getStandardAttenuatorAttenuation()); BigDecimal sourceAmplitude = new BigDecimal(measureData.getSignalSourceAmplitude()); @@ -1458,12 +1475,23 @@ value = attenuatorAttenuation.subtract(preAttenuatorAttenuation).add(sourceAmplitude).subtract(preSourceAmplitude); } measureData.setOneValue(String.valueOf(value)); - //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* - if (value.compareTo(upperIndex) > 0 || value.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* + if (value.compareTo(upperIndex) > 0 || value.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("7".equals(measureData.getDataType())) { @@ -1481,13 +1509,17 @@ BigDecimal inputFrequency = new BigDecimal(firstAverage).subtract(averageValue); measureData.setInputFrequency(String.valueOf(inputFrequency)); //结论，输入频响是否在输入频响上限、下限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将输入频响字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); - if (inputFrequency.compareTo(upperIndex) > 0 || inputFrequency.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex()) || "/".equals(measureData.getLowerIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); + if (inputFrequency.compareTo(upperIndex) > 0 || inputFrequency.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("8".equals(measureData.getDataType())) { @@ -1502,12 +1534,16 @@ measureData.setRevisedResult(String.valueOf(value)); } //结论，修正后结果小于指标上限，如是，则“符合指标”，如不是则"不符合指标"，并将修正后结果字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - if (revisedResult.compareTo(upperIndex) > 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + if (revisedResult.compareTo(upperIndex) > 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("9".equals(measureData.getDataType())) { //谐波失真 @@ -1527,15 +1563,28 @@ //结论，二/三/四谐波失真是否小于二/三/四谐波失真指标上限，如是，则“符合指标”，如不是则"不符合指标"，并将二/三/四谐波失真字段（参与比较字段）标* //如果三次谐波失真、四次谐波失真未配置，结论处不参与计算 if (StringUtils.isNotEmpty(measureData.getFiveValue()) && StringUtils.isNotEmpty(measureData.getSevenValue())) { - BigDecimal upperIndexTwice = new BigDecimal(measureData.getUpperIndexTwice()); - BigDecimal upperIndexThrice = new BigDecimal(measureData.getUpperIndexThrice()); - BigDecimal upperIndexQuartic = new BigDecimal(measureData.getUpperIndexQuartic()); BigDecimal fiveValue = new BigDecimal(measureData.getFiveValue()); BigDecimal sevenValue = new BigDecimal(measureData.getSevenValue()); - if (threeValue.compareTo(upperIndexTwice) > 0 || fiveValue.compareTo(upperIndexThrice) > 0 || sevenValue.compareTo(upperIndexQuartic) > 0) { + if ("/".equals(measureData.getUpperIndexTwice())) { + measureData.setConclusion("/"); + } else { + BigDecimal upperIndexTwice = new BigDecimal(measureData.getUpperIndexTwice()); if (threeValue.compareTo(upperIndexTwice) > 0) measureData.setExceedMark(1); + } + if ("/".equals(measureData.getUpperIndexThrice())) { + measureData.setConclusion("/"); + } else { + + BigDecimal upperIndexThrice = new BigDecimal(measureData.getUpperIndexThrice()); if (fiveValue.compareTo(upperIndexThrice) > 0) measureData.setExceedMarkOne(1); + } + if ("/".equals(measureData.getUpperIndexQuartic())) { + measureData.setConclusion("/"); + } else { + BigDecimal upperIndexQuartic = new BigDecimal(measureData.getUpperIndexQuartic()); if (sevenValue.compareTo(upperIndexQuartic) > 0) measureData.setExceedMarkTwo(1); + } + if (measureData.getExceedMark() == 1 && measureData.getExceedMarkOne() == 1 || measureData.getExceedMarkTwo() == 1) { measureData.setConclusion("不符合指标"); } else { measureData.setConclusion("符合指标"); @@ -1553,13 +1602,17 @@ BigDecimal inputAttenuatorConversionEffect = oneValue.subtract(new BigDecimal(firstValue)).subtract((attenuatorAttenuation.subtract(new BigDecimal(firstAttenuatorAttenuation)))); measureData.setInputAttenuatorConversionEffect(String.valueOf(inputAttenuatorConversionEffect)); //结论，输入衰减器转换影响是否在下限、上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将输入衰减器转换影响字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); - if (inputAttenuatorConversionEffect.compareTo(upperIndex) > 0 || inputAttenuatorConversionEffect.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex()) || "/".equals(measureData.getLowerIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); + if (inputAttenuatorConversionEffect.compareTo(upperIndex) > 0 || inputAttenuatorConversionEffect.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("11".equals(measureData.getDataType())) { @@ -1570,26 +1623,22 @@ BigDecimal gainCompression = oneValue.subtract(inputAttenuator); measureData.setGainCompression(String.valueOf(gainCompression)); //结论，增益压缩是否在技术指标范围内，如是，则“符合指标”，如不是则"不符合指标"，并将增益压缩字段（参与比较字段）标* - String symbol = measureData.getTechnicalIndex().substring(0, 1); - String technicalIndex = measureData.getTechnicalIndex().substring(1); - int exceedMark = judgeSymbol(symbol, String.valueOf(gainCompression), new BigDecimal(technicalIndex)); - if (1 == exceedMark) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String symbol = measureData.getTechnicalIndex().substring(0, 1); + String technicalIndex = measureData.getTechnicalIndex().substring(1); + int exceedMark = judgeSymbol(symbol, String.valueOf(gainCompression), new BigDecimal(technicalIndex)); + if (1 == exceedMark) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("12".equals(measureData.getDataType())) { //校准信号 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String beforeTechnicalIndex = measureData.getTechnicalIndex().replace("±", ""); - BigDecimal technicalIndex = new BigDecimal(beforeTechnicalIndex); - //指标下限 = 标称值-输入项配置（技术指标配置数值） - BigDecimal lowerIndex = nominalValue.subtract(technicalIndex); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值+输入项配置（技术指标配置数值） - BigDecimal upperIndex = nominalValue.add(technicalIndex); - measureData.setUpperIndex(String.valueOf(upperIndex)); //测量结果 = 如果类型为频率，手工编辑输入值，需要补充单位，单位与标称值单位相同；如果类型为幅度，根据公式计算，公式：前三次测量值的和/3 if ("幅度".equals(measureData.getTypeValue())) { BigDecimal oneValue = new BigDecimal(measureData.getOneValue()); @@ -1600,22 +1649,34 @@ measureData.setMeasureResultUnit(measureData.getUnit()); //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* String conclusion = ""; - if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - conclusion = "不符合指标"; + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); + } else { + String beforeTechnicalIndex = measureData.getTechnicalIndex().replace("±", ""); + BigDecimal technicalIndex = new BigDecimal(beforeTechnicalIndex); + //指标下限 = 标称值-输入项配置（技术指标配置数值） + BigDecimal lowerIndex = nominalValue.subtract(technicalIndex); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值+输入项配置（技术指标配置数值） + BigDecimal upperIndex = nominalValue.add(technicalIndex); + measureData.setUpperIndex(String.valueOf(upperIndex)); + if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + conclusion = "不符合指标"; + } + if (twoValue.compareTo(upperIndex) > 0 || twoValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMarkOne(1); + conclusion = "不符合指标"; + } + if (threeValue.compareTo(upperIndex) > 0 || threeValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMarkTwo(1); + conclusion = "不符合指标"; + } + if (StringUtils.isBlank(conclusion)) { + conclusion = "符合指标"; + } + measureData.setConclusion(conclusion); } - if (twoValue.compareTo(upperIndex) > 0 || twoValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMarkOne(1); - conclusion = "不符合指标"; - } - if (threeValue.compareTo(upperIndex) > 0 || threeValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMarkTwo(1); - conclusion = "不符合指标"; - } - if (StringUtils.isBlank(conclusion)) { - conclusion = "符合指标"; - } - measureData.setConclusion(conclusion); } else { measureData.setConclusion("/"); } @@ -1671,7 +1732,8 @@ BigDecimal aConvertQualityCorrectValue = new BigDecimal(measureData.getAConvertQualityCorrectValue()); BigDecimal bNominalQualityValue = new BigDecimal(measureData.getBNominalQualityValue()).multiply(BigDecimal.valueOf(100)); BigDecimal bConvertQualityCorrectValue = new BigDecimal(measureData.getBConvertQualityCorrectValue()); - BigDecimal deltaMThrow = deltaM.add(aNominalQualityValue.add(aConvertQualityCorrectValue)).add(bNominalQualityValue.add(bConvertQualityCorrectValue)); + BigDecimal deltaMThrowBefore = deltaM.add(aNominalQualityValue.add(aConvertQualityCorrectValue)).add(bNominalQualityValue.add(bConvertQualityCorrectValue)); + BigDecimal deltaMThrow = deltaMThrowBefore.divide(BigDecimal.valueOf(2), RoundingMode.HALF_UP); if (StringUtils.isNotEmpty(measureData.getPtOne())) { ptOneDeltaMThrowMap.put(deltaMThrow, measureData.getMeasureSequence()); } else if (StringUtils.isNotEmpty(measureData.getPtTwo())) { diff --git a/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java b/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java index 5b27e73..172f687 100644 --- a/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java +++ b/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java @@ -917,7 +917,10 @@ //电流表示值误差（间接测量）需计算标准值 if ("5".equals(measureData.getDataType())) { //标准值 = 标准电压值/标准电阻值 - BigDecimal standardValue = new BigDecimal(measureData.getStandardVoltageValue()).divide(new BigDecimal(measureData.getStandardResistanceValue()), 4, RoundingMode.HALF_UP); + //单位转换 + BigDecimal resistance = UnitConvertUtil.resistanceConvert(measureData.getStandardResistanceValue(), measureData.getStandardResistanceValueUnit(), "Ω"); + BigDecimal voltage = UnitConvertUtil.voltageConvert(measureData.getStandardVoltageValue(), measureData.getStandardVoltageValueUnit(), "V"); + BigDecimal standardValue = voltage.divide(resistance, 4, RoundingMode.HALF_UP); measureData.setStandardValue(String.valueOf(standardValue)); } @@ -1275,7 +1278,6 @@ String unit = measureData.getUnit(); if ("1".equals(measureData.getDataType())) { BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); //测量值1、测量值2、测量值3，根据单位保留小数位，单位和标称值单位相同 BigDecimal oneValue = UnitConvertUtil.valueDecimalConvert(unit, measureData.getOneValue()); BigDecimal twoValue = UnitConvertUtil.valueDecimalConvert(unit, measureData.getTwoValue()); @@ -1283,29 +1285,33 @@ measureData.setOneValue(String.valueOf(oneValue)); measureData.setTwoValue(String.valueOf(twoValue)); measureData.setThreeValue(String.valueOf(threeValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同测量值 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - lowerIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(lowerIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - upperIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(upperIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); //均值 = （测量值1+测量值2+测量值3）/ 3，保留小数规则同测量值 BigDecimal averageValue = (oneValue.add(twoValue).add(threeValue)).divide(BigDecimal.valueOf(3), 12, RoundingMode.HALF_UP); averageValue = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(averageValue)); measureData.setAverageValue(String.valueOf(averageValue)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标，保留小数规则同测量值 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + lowerIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(lowerIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + upperIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(upperIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("2".equals(measureData.getDataType())) { //扫描宽度 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); //fl1、fr1、fl2、fr2、fl3、fr3 BigDecimal oneValue = new BigDecimal(measureData.getOneValue()).round(new MathContext(5, RoundingMode.HALF_UP)); BigDecimal twoValue = new BigDecimal(measureData.getTwoValue()).round(new MathContext(5, RoundingMode.HALF_UP)); @@ -1319,31 +1325,34 @@ measureData.setFourValue(String.valueOf(fourValue)); measureData.setFiveValue(String.valueOf(fiveValue)); measureData.setSixValue(String.valueOf(sixValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 - BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - BigDecimal lowerIndex = beforeLowerIndex.round(new MathContext(5, RoundingMode.HALF_UP)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - BigDecimal upperIndex = beforeUpperIndex.round(new MathContext(5, RoundingMode.HALF_UP)); - measureData.setUpperIndex(String.valueOf(upperIndex)); //均值 = ((fr1-fl1)+(fr2-fl2)+(fr3-fl3))*10/8/3 BigDecimal beforeAverageValue = (twoValue.subtract(oneValue).add(fourValue).subtract(threeValue).add(sixValue).subtract(fiveValue)) .multiply(BigDecimal.valueOf(10)).divide(BigDecimal.valueOf(8), 6, RoundingMode.HALF_UP).divide(BigDecimal.valueOf(3), 6, RoundingMode.HALF_UP); BigDecimal averageValue = beforeAverageValue.round(new MathContext(5, RoundingMode.HALF_UP)); measureData.setAverageValue(String.valueOf(averageValue)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 + BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + BigDecimal lowerIndex = beforeLowerIndex.round(new MathContext(5, RoundingMode.HALF_UP)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + BigDecimal upperIndex = beforeUpperIndex.round(new MathContext(5, RoundingMode.HALF_UP)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("3".equals(measureData.getDataType())) { //中频带宽 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndexLeft = measureData.getTechnicalIndexLeft(); - String technicalIndexRight = measureData.getTechnicalIndexRight(); if (StringUtils.isNotEmpty(measureData.getOneValue()) && StringUtils.isNotEmpty(measureData.getTwoValue()) && StringUtils.isNotEmpty(measureData.getThreeValue()) && StringUtils.isNotEmpty(measureData.getFourValue()) && StringUtils.isNotEmpty(measureData.getFiveValue()) && StringUtils.isNotEmpty(measureData.getSixValue())) { @@ -1367,20 +1376,26 @@ //均值 = (△f1+△f2+△f3)/3 BigDecimal averageValue = (eightValue.add(nineValue).add(tenValue)).divide(BigDecimal.valueOf(3), 2, RoundingMode.HALF_UP); measureData.setAverageValue(String.valueOf(averageValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 - BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndexLeft)); - BigDecimal lowerIndex = beforeLowerIndex.setScale(2, RoundingMode.HALF_UP); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndexRight)); - BigDecimal upperIndex = beforeUpperIndex.setScale(2, RoundingMode.HALF_UP); - measureData.setUpperIndex(String.valueOf(upperIndex)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndexLeft()) || "/".equals(measureData.getTechnicalIndexRight())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndexLeft = measureData.getTechnicalIndexLeft(); + String technicalIndexRight = measureData.getTechnicalIndexRight(); + //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 + BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndexLeft)); + BigDecimal lowerIndex = beforeLowerIndex.setScale(2, RoundingMode.HALF_UP); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndexRight)); + BigDecimal upperIndex = beforeUpperIndex.setScale(2, RoundingMode.HALF_UP); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("4".equals(measureData.getDataType())) { //中频带宽转换偏差 @@ -1391,13 +1406,17 @@ BigDecimal convertDeviation = new BigDecimal(measureData.getOneValue()).subtract(new BigDecimal(referValue)); measureData.setConvertDeviation(String.valueOf(convertDeviation)); //结论，转换偏差是否在转换偏差下限、转换偏差上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将转换偏差字段（参与比较字段）标* - BigDecimal upperConvertDeviation = new BigDecimal(measureData.getUpperConvertDeviation()); - BigDecimal lowerConvertDeviation = new BigDecimal(measureData.getLowerConvertDeviation()); - if (convertDeviation.compareTo(upperConvertDeviation) > 0 || convertDeviation.compareTo(lowerConvertDeviation) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperConvertDeviation()) || "/".equals(measureData.getLowerConvertDeviation())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperConvertDeviation = new BigDecimal(measureData.getUpperConvertDeviation()); + BigDecimal lowerConvertDeviation = new BigDecimal(measureData.getLowerConvertDeviation()); + if (convertDeviation.compareTo(upperConvertDeviation) > 0 || convertDeviation.compareTo(lowerConvertDeviation) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("5".equals(measureData.getDataType())) { @@ -1412,18 +1431,22 @@ measureData.setOneValue(String.valueOf(oneValue)); //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); - //指标下限 = 标称值 - 技术指标 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); - if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("6".equals(measureData.getDataType())) { @@ -1434,13 +1457,7 @@ BigDecimal firstAttenuatorAttenuation = new BigDecimal(firstData.getStandardAttenuatorAttenuation()); BigDecimal firstSourceAmplitude = new BigDecimal(firstData.getSignalSourceAmplitude()); BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); - //指标下限 = 标称值 - 技术指标 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); + //测量值 = 标准衰减器衰减量(当次测量)-标准衰减器衰减量(上一次测量)+(信号源幅度(当次测量)-信号源幅度（上一次测量）).后面带单位，与标称值单位相同 BigDecimal attenuatorAttenuation = new BigDecimal(measureData.getStandardAttenuatorAttenuation()); BigDecimal sourceAmplitude = new BigDecimal(measureData.getSignalSourceAmplitude()); @@ -1458,12 +1475,23 @@ value = attenuatorAttenuation.subtract(preAttenuatorAttenuation).add(sourceAmplitude).subtract(preSourceAmplitude); } measureData.setOneValue(String.valueOf(value)); - //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* - if (value.compareTo(upperIndex) > 0 || value.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* + if (value.compareTo(upperIndex) > 0 || value.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("7".equals(measureData.getDataType())) { @@ -1481,13 +1509,17 @@ BigDecimal inputFrequency = new BigDecimal(firstAverage).subtract(averageValue); measureData.setInputFrequency(String.valueOf(inputFrequency)); //结论，输入频响是否在输入频响上限、下限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将输入频响字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); - if (inputFrequency.compareTo(upperIndex) > 0 || inputFrequency.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex()) || "/".equals(measureData.getLowerIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); + if (inputFrequency.compareTo(upperIndex) > 0 || inputFrequency.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("8".equals(measureData.getDataType())) { @@ -1502,12 +1534,16 @@ measureData.setRevisedResult(String.valueOf(value)); } //结论，修正后结果小于指标上限，如是，则“符合指标”，如不是则"不符合指标"，并将修正后结果字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - if (revisedResult.compareTo(upperIndex) > 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + if (revisedResult.compareTo(upperIndex) > 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("9".equals(measureData.getDataType())) { //谐波失真 @@ -1527,15 +1563,28 @@ //结论，二/三/四谐波失真是否小于二/三/四谐波失真指标上限，如是，则“符合指标”，如不是则"不符合指标"，并将二/三/四谐波失真字段（参与比较字段）标* //如果三次谐波失真、四次谐波失真未配置，结论处不参与计算 if (StringUtils.isNotEmpty(measureData.getFiveValue()) && StringUtils.isNotEmpty(measureData.getSevenValue())) { - BigDecimal upperIndexTwice = new BigDecimal(measureData.getUpperIndexTwice()); - BigDecimal upperIndexThrice = new BigDecimal(measureData.getUpperIndexThrice()); - BigDecimal upperIndexQuartic = new BigDecimal(measureData.getUpperIndexQuartic()); BigDecimal fiveValue = new BigDecimal(measureData.getFiveValue()); BigDecimal sevenValue = new BigDecimal(measureData.getSevenValue()); - if (threeValue.compareTo(upperIndexTwice) > 0 || fiveValue.compareTo(upperIndexThrice) > 0 || sevenValue.compareTo(upperIndexQuartic) > 0) { + if ("/".equals(measureData.getUpperIndexTwice())) { + measureData.setConclusion("/"); + } else { + BigDecimal upperIndexTwice = new BigDecimal(measureData.getUpperIndexTwice()); if (threeValue.compareTo(upperIndexTwice) > 0) measureData.setExceedMark(1); + } + if ("/".equals(measureData.getUpperIndexThrice())) { + measureData.setConclusion("/"); + } else { + + BigDecimal upperIndexThrice = new BigDecimal(measureData.getUpperIndexThrice()); if (fiveValue.compareTo(upperIndexThrice) > 0) measureData.setExceedMarkOne(1); + } + if ("/".equals(measureData.getUpperIndexQuartic())) { + measureData.setConclusion("/"); + } else { + BigDecimal upperIndexQuartic = new BigDecimal(measureData.getUpperIndexQuartic()); if (sevenValue.compareTo(upperIndexQuartic) > 0) measureData.setExceedMarkTwo(1); + } + if (measureData.getExceedMark() == 1 && measureData.getExceedMarkOne() == 1 || measureData.getExceedMarkTwo() == 1) { measureData.setConclusion("不符合指标"); } else { measureData.setConclusion("符合指标"); @@ -1553,13 +1602,17 @@ BigDecimal inputAttenuatorConversionEffect = oneValue.subtract(new BigDecimal(firstValue)).subtract((attenuatorAttenuation.subtract(new BigDecimal(firstAttenuatorAttenuation)))); measureData.setInputAttenuatorConversionEffect(String.valueOf(inputAttenuatorConversionEffect)); //结论，输入衰减器转换影响是否在下限、上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将输入衰减器转换影响字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); - if (inputAttenuatorConversionEffect.compareTo(upperIndex) > 0 || inputAttenuatorConversionEffect.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex()) || "/".equals(measureData.getLowerIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); + if (inputAttenuatorConversionEffect.compareTo(upperIndex) > 0 || inputAttenuatorConversionEffect.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("11".equals(measureData.getDataType())) { @@ -1570,26 +1623,22 @@ BigDecimal gainCompression = oneValue.subtract(inputAttenuator); measureData.setGainCompression(String.valueOf(gainCompression)); //结论，增益压缩是否在技术指标范围内，如是，则“符合指标”，如不是则"不符合指标"，并将增益压缩字段（参与比较字段）标* - String symbol = measureData.getTechnicalIndex().substring(0, 1); - String technicalIndex = measureData.getTechnicalIndex().substring(1); - int exceedMark = judgeSymbol(symbol, String.valueOf(gainCompression), new BigDecimal(technicalIndex)); - if (1 == exceedMark) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String symbol = measureData.getTechnicalIndex().substring(0, 1); + String technicalIndex = measureData.getTechnicalIndex().substring(1); + int exceedMark = judgeSymbol(symbol, String.valueOf(gainCompression), new BigDecimal(technicalIndex)); + if (1 == exceedMark) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("12".equals(measureData.getDataType())) { //校准信号 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String beforeTechnicalIndex = measureData.getTechnicalIndex().replace("±", ""); - BigDecimal technicalIndex = new BigDecimal(beforeTechnicalIndex); - //指标下限 = 标称值-输入项配置（技术指标配置数值） - BigDecimal lowerIndex = nominalValue.subtract(technicalIndex); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值+输入项配置（技术指标配置数值） - BigDecimal upperIndex = nominalValue.add(technicalIndex); - measureData.setUpperIndex(String.valueOf(upperIndex)); //测量结果 = 如果类型为频率，手工编辑输入值，需要补充单位，单位与标称值单位相同；如果类型为幅度，根据公式计算，公式：前三次测量值的和/3 if ("幅度".equals(measureData.getTypeValue())) { BigDecimal oneValue = new BigDecimal(measureData.getOneValue()); @@ -1600,22 +1649,34 @@ measureData.setMeasureResultUnit(measureData.getUnit()); //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* String conclusion = ""; - if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - conclusion = "不符合指标"; + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); + } else { + String beforeTechnicalIndex = measureData.getTechnicalIndex().replace("±", ""); + BigDecimal technicalIndex = new BigDecimal(beforeTechnicalIndex); + //指标下限 = 标称值-输入项配置（技术指标配置数值） + BigDecimal lowerIndex = nominalValue.subtract(technicalIndex); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值+输入项配置（技术指标配置数值） + BigDecimal upperIndex = nominalValue.add(technicalIndex); + measureData.setUpperIndex(String.valueOf(upperIndex)); + if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + conclusion = "不符合指标"; + } + if (twoValue.compareTo(upperIndex) > 0 || twoValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMarkOne(1); + conclusion = "不符合指标"; + } + if (threeValue.compareTo(upperIndex) > 0 || threeValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMarkTwo(1); + conclusion = "不符合指标"; + } + if (StringUtils.isBlank(conclusion)) { + conclusion = "符合指标"; + } + measureData.setConclusion(conclusion); } - if (twoValue.compareTo(upperIndex) > 0 || twoValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMarkOne(1); - conclusion = "不符合指标"; - } - if (threeValue.compareTo(upperIndex) > 0 || threeValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMarkTwo(1); - conclusion = "不符合指标"; - } - if (StringUtils.isBlank(conclusion)) { - conclusion = "符合指标"; - } - measureData.setConclusion(conclusion); } else { measureData.setConclusion("/"); } @@ -1671,7 +1732,8 @@ BigDecimal aConvertQualityCorrectValue = new BigDecimal(measureData.getAConvertQualityCorrectValue()); BigDecimal bNominalQualityValue = new BigDecimal(measureData.getBNominalQualityValue()).multiply(BigDecimal.valueOf(100)); BigDecimal bConvertQualityCorrectValue = new BigDecimal(measureData.getBConvertQualityCorrectValue()); - BigDecimal deltaMThrow = deltaM.add(aNominalQualityValue.add(aConvertQualityCorrectValue)).add(bNominalQualityValue.add(bConvertQualityCorrectValue)); + BigDecimal deltaMThrowBefore = deltaM.add(aNominalQualityValue.add(aConvertQualityCorrectValue)).add(bNominalQualityValue.add(bConvertQualityCorrectValue)); + BigDecimal deltaMThrow = deltaMThrowBefore.divide(BigDecimal.valueOf(2), RoundingMode.HALF_UP); if (StringUtils.isNotEmpty(measureData.getPtOne())) { ptOneDeltaMThrowMap.put(deltaMThrow, measureData.getMeasureSequence()); } else if (StringUtils.isNotEmpty(measureData.getPtTwo())) { diff --git a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml index d557ffb..7c14299 100644 --- a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml +++ b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml @@ -32,10 +32,12 @@ SELECT bbdma.*, eei.equipment_no AS sampleNo, eei.equipment_name AS sampleName, eei.model AS model, eei.manufacture_no AS manufactureNo, bbdmi.measure_category AS measureCategory, bbdmi.create_user_name AS staffName, bbdmi.trace_date AS traceDate, bbdmi.manufacturer AS manufacturer, bbdmi.conclusion AS conclusion, bbdmi.restriction_instruction AS restrictionInstruction, - bbdmi.measure_address AS measureAddress, bbdmi.data_no AS measureDataNo, bbdmi.measure_valid_date, bbdmi.meter_identify, bbdmi.measure_valid_date + bbdmi.measure_address AS measureAddress, bbdmi.data_no AS measureDataNo, bbdmi.measure_valid_date, bbdmi.meter_identify, bbdmi.measure_valid_date, + bbdmii.belong_standard_equipment, bbdmii.item_category_id, bbdmii.item_category_name FROM biz_business_device_measure_approval bbdma JOIN eqpt_equipment_info eei ON bbdma.sample_id = eei.id JOIN biz_business_device_measure_info bbdmi ON bbdma.data_id = bbdmi.id + JOIN biz_business_device_measure_item_info bbdmii ON bbdmii.id = bbdmi.item_id WHERE 1=1 and bbdma.approval_status = #{request.approvalStatus} diff --git a/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java b/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java index 5b27e73..172f687 100644 --- a/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java +++ b/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java @@ -917,7 +917,10 @@ //电流表示值误差（间接测量）需计算标准值 if ("5".equals(measureData.getDataType())) { //标准值 = 标准电压值/标准电阻值 - BigDecimal standardValue = new BigDecimal(measureData.getStandardVoltageValue()).divide(new BigDecimal(measureData.getStandardResistanceValue()), 4, RoundingMode.HALF_UP); + //单位转换 + BigDecimal resistance = UnitConvertUtil.resistanceConvert(measureData.getStandardResistanceValue(), measureData.getStandardResistanceValueUnit(), "Ω"); + BigDecimal voltage = UnitConvertUtil.voltageConvert(measureData.getStandardVoltageValue(), measureData.getStandardVoltageValueUnit(), "V"); + BigDecimal standardValue = voltage.divide(resistance, 4, RoundingMode.HALF_UP); measureData.setStandardValue(String.valueOf(standardValue)); } @@ -1275,7 +1278,6 @@ String unit = measureData.getUnit(); if ("1".equals(measureData.getDataType())) { BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); //测量值1、测量值2、测量值3，根据单位保留小数位，单位和标称值单位相同 BigDecimal oneValue = UnitConvertUtil.valueDecimalConvert(unit, measureData.getOneValue()); BigDecimal twoValue = UnitConvertUtil.valueDecimalConvert(unit, measureData.getTwoValue()); @@ -1283,29 +1285,33 @@ measureData.setOneValue(String.valueOf(oneValue)); measureData.setTwoValue(String.valueOf(twoValue)); measureData.setThreeValue(String.valueOf(threeValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同测量值 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - lowerIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(lowerIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - upperIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(upperIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); //均值 = （测量值1+测量值2+测量值3）/ 3，保留小数规则同测量值 BigDecimal averageValue = (oneValue.add(twoValue).add(threeValue)).divide(BigDecimal.valueOf(3), 12, RoundingMode.HALF_UP); averageValue = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(averageValue)); measureData.setAverageValue(String.valueOf(averageValue)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标，保留小数规则同测量值 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + lowerIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(lowerIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + upperIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(upperIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("2".equals(measureData.getDataType())) { //扫描宽度 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); //fl1、fr1、fl2、fr2、fl3、fr3 BigDecimal oneValue = new BigDecimal(measureData.getOneValue()).round(new MathContext(5, RoundingMode.HALF_UP)); BigDecimal twoValue = new BigDecimal(measureData.getTwoValue()).round(new MathContext(5, RoundingMode.HALF_UP)); @@ -1319,31 +1325,34 @@ measureData.setFourValue(String.valueOf(fourValue)); measureData.setFiveValue(String.valueOf(fiveValue)); measureData.setSixValue(String.valueOf(sixValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 - BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - BigDecimal lowerIndex = beforeLowerIndex.round(new MathContext(5, RoundingMode.HALF_UP)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - BigDecimal upperIndex = beforeUpperIndex.round(new MathContext(5, RoundingMode.HALF_UP)); - measureData.setUpperIndex(String.valueOf(upperIndex)); //均值 = ((fr1-fl1)+(fr2-fl2)+(fr3-fl3))*10/8/3 BigDecimal beforeAverageValue = (twoValue.subtract(oneValue).add(fourValue).subtract(threeValue).add(sixValue).subtract(fiveValue)) .multiply(BigDecimal.valueOf(10)).divide(BigDecimal.valueOf(8), 6, RoundingMode.HALF_UP).divide(BigDecimal.valueOf(3), 6, RoundingMode.HALF_UP); BigDecimal averageValue = beforeAverageValue.round(new MathContext(5, RoundingMode.HALF_UP)); measureData.setAverageValue(String.valueOf(averageValue)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 + BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + BigDecimal lowerIndex = beforeLowerIndex.round(new MathContext(5, RoundingMode.HALF_UP)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + BigDecimal upperIndex = beforeUpperIndex.round(new MathContext(5, RoundingMode.HALF_UP)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("3".equals(measureData.getDataType())) { //中频带宽 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndexLeft = measureData.getTechnicalIndexLeft(); - String technicalIndexRight = measureData.getTechnicalIndexRight(); if (StringUtils.isNotEmpty(measureData.getOneValue()) && StringUtils.isNotEmpty(measureData.getTwoValue()) && StringUtils.isNotEmpty(measureData.getThreeValue()) && StringUtils.isNotEmpty(measureData.getFourValue()) && StringUtils.isNotEmpty(measureData.getFiveValue()) && StringUtils.isNotEmpty(measureData.getSixValue())) { @@ -1367,20 +1376,26 @@ //均值 = (△f1+△f2+△f3)/3 BigDecimal averageValue = (eightValue.add(nineValue).add(tenValue)).divide(BigDecimal.valueOf(3), 2, RoundingMode.HALF_UP); measureData.setAverageValue(String.valueOf(averageValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 - BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndexLeft)); - BigDecimal lowerIndex = beforeLowerIndex.setScale(2, RoundingMode.HALF_UP); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndexRight)); - BigDecimal upperIndex = beforeUpperIndex.setScale(2, RoundingMode.HALF_UP); - measureData.setUpperIndex(String.valueOf(upperIndex)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndexLeft()) || "/".equals(measureData.getTechnicalIndexRight())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndexLeft = measureData.getTechnicalIndexLeft(); + String technicalIndexRight = measureData.getTechnicalIndexRight(); + //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 + BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndexLeft)); + BigDecimal lowerIndex = beforeLowerIndex.setScale(2, RoundingMode.HALF_UP); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndexRight)); + BigDecimal upperIndex = beforeUpperIndex.setScale(2, RoundingMode.HALF_UP); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("4".equals(measureData.getDataType())) { //中频带宽转换偏差 @@ -1391,13 +1406,17 @@ BigDecimal convertDeviation = new BigDecimal(measureData.getOneValue()).subtract(new BigDecimal(referValue)); measureData.setConvertDeviation(String.valueOf(convertDeviation)); //结论，转换偏差是否在转换偏差下限、转换偏差上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将转换偏差字段（参与比较字段）标* - BigDecimal upperConvertDeviation = new BigDecimal(measureData.getUpperConvertDeviation()); - BigDecimal lowerConvertDeviation = new BigDecimal(measureData.getLowerConvertDeviation()); - if (convertDeviation.compareTo(upperConvertDeviation) > 0 || convertDeviation.compareTo(lowerConvertDeviation) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperConvertDeviation()) || "/".equals(measureData.getLowerConvertDeviation())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperConvertDeviation = new BigDecimal(measureData.getUpperConvertDeviation()); + BigDecimal lowerConvertDeviation = new BigDecimal(measureData.getLowerConvertDeviation()); + if (convertDeviation.compareTo(upperConvertDeviation) > 0 || convertDeviation.compareTo(lowerConvertDeviation) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("5".equals(measureData.getDataType())) { @@ -1412,18 +1431,22 @@ measureData.setOneValue(String.valueOf(oneValue)); //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); - //指标下限 = 标称值 - 技术指标 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); - if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("6".equals(measureData.getDataType())) { @@ -1434,13 +1457,7 @@ BigDecimal firstAttenuatorAttenuation = new BigDecimal(firstData.getStandardAttenuatorAttenuation()); BigDecimal firstSourceAmplitude = new BigDecimal(firstData.getSignalSourceAmplitude()); BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); - //指标下限 = 标称值 - 技术指标 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); + //测量值 = 标准衰减器衰减量(当次测量)-标准衰减器衰减量(上一次测量)+(信号源幅度(当次测量)-信号源幅度（上一次测量）).后面带单位，与标称值单位相同 BigDecimal attenuatorAttenuation = new BigDecimal(measureData.getStandardAttenuatorAttenuation()); BigDecimal sourceAmplitude = new BigDecimal(measureData.getSignalSourceAmplitude()); @@ -1458,12 +1475,23 @@ value = attenuatorAttenuation.subtract(preAttenuatorAttenuation).add(sourceAmplitude).subtract(preSourceAmplitude); } measureData.setOneValue(String.valueOf(value)); - //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* - if (value.compareTo(upperIndex) > 0 || value.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* + if (value.compareTo(upperIndex) > 0 || value.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("7".equals(measureData.getDataType())) { @@ -1481,13 +1509,17 @@ BigDecimal inputFrequency = new BigDecimal(firstAverage).subtract(averageValue); measureData.setInputFrequency(String.valueOf(inputFrequency)); //结论，输入频响是否在输入频响上限、下限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将输入频响字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); - if (inputFrequency.compareTo(upperIndex) > 0 || inputFrequency.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex()) || "/".equals(measureData.getLowerIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); + if (inputFrequency.compareTo(upperIndex) > 0 || inputFrequency.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("8".equals(measureData.getDataType())) { @@ -1502,12 +1534,16 @@ measureData.setRevisedResult(String.valueOf(value)); } //结论，修正后结果小于指标上限，如是，则“符合指标”，如不是则"不符合指标"，并将修正后结果字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - if (revisedResult.compareTo(upperIndex) > 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + if (revisedResult.compareTo(upperIndex) > 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("9".equals(measureData.getDataType())) { //谐波失真 @@ -1527,15 +1563,28 @@ //结论，二/三/四谐波失真是否小于二/三/四谐波失真指标上限，如是，则“符合指标”，如不是则"不符合指标"，并将二/三/四谐波失真字段（参与比较字段）标* //如果三次谐波失真、四次谐波失真未配置，结论处不参与计算 if (StringUtils.isNotEmpty(measureData.getFiveValue()) && StringUtils.isNotEmpty(measureData.getSevenValue())) { - BigDecimal upperIndexTwice = new BigDecimal(measureData.getUpperIndexTwice()); - BigDecimal upperIndexThrice = new BigDecimal(measureData.getUpperIndexThrice()); - BigDecimal upperIndexQuartic = new BigDecimal(measureData.getUpperIndexQuartic()); BigDecimal fiveValue = new BigDecimal(measureData.getFiveValue()); BigDecimal sevenValue = new BigDecimal(measureData.getSevenValue()); - if (threeValue.compareTo(upperIndexTwice) > 0 || fiveValue.compareTo(upperIndexThrice) > 0 || sevenValue.compareTo(upperIndexQuartic) > 0) { + if ("/".equals(measureData.getUpperIndexTwice())) { + measureData.setConclusion("/"); + } else { + BigDecimal upperIndexTwice = new BigDecimal(measureData.getUpperIndexTwice()); if (threeValue.compareTo(upperIndexTwice) > 0) measureData.setExceedMark(1); + } + if ("/".equals(measureData.getUpperIndexThrice())) { + measureData.setConclusion("/"); + } else { + + BigDecimal upperIndexThrice = new BigDecimal(measureData.getUpperIndexThrice()); if (fiveValue.compareTo(upperIndexThrice) > 0) measureData.setExceedMarkOne(1); + } + if ("/".equals(measureData.getUpperIndexQuartic())) { + measureData.setConclusion("/"); + } else { + BigDecimal upperIndexQuartic = new BigDecimal(measureData.getUpperIndexQuartic()); if (sevenValue.compareTo(upperIndexQuartic) > 0) measureData.setExceedMarkTwo(1); + } + if (measureData.getExceedMark() == 1 && measureData.getExceedMarkOne() == 1 || measureData.getExceedMarkTwo() == 1) { measureData.setConclusion("不符合指标"); } else { measureData.setConclusion("符合指标"); @@ -1553,13 +1602,17 @@ BigDecimal inputAttenuatorConversionEffect = oneValue.subtract(new BigDecimal(firstValue)).subtract((attenuatorAttenuation.subtract(new BigDecimal(firstAttenuatorAttenuation)))); measureData.setInputAttenuatorConversionEffect(String.valueOf(inputAttenuatorConversionEffect)); //结论，输入衰减器转换影响是否在下限、上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将输入衰减器转换影响字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); - if (inputAttenuatorConversionEffect.compareTo(upperIndex) > 0 || inputAttenuatorConversionEffect.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex()) || "/".equals(measureData.getLowerIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); + if (inputAttenuatorConversionEffect.compareTo(upperIndex) > 0 || inputAttenuatorConversionEffect.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("11".equals(measureData.getDataType())) { @@ -1570,26 +1623,22 @@ BigDecimal gainCompression = oneValue.subtract(inputAttenuator); measureData.setGainCompression(String.valueOf(gainCompression)); //结论，增益压缩是否在技术指标范围内，如是，则“符合指标”，如不是则"不符合指标"，并将增益压缩字段（参与比较字段）标* - String symbol = measureData.getTechnicalIndex().substring(0, 1); - String technicalIndex = measureData.getTechnicalIndex().substring(1); - int exceedMark = judgeSymbol(symbol, String.valueOf(gainCompression), new BigDecimal(technicalIndex)); - if (1 == exceedMark) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String symbol = measureData.getTechnicalIndex().substring(0, 1); + String technicalIndex = measureData.getTechnicalIndex().substring(1); + int exceedMark = judgeSymbol(symbol, String.valueOf(gainCompression), new BigDecimal(technicalIndex)); + if (1 == exceedMark) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("12".equals(measureData.getDataType())) { //校准信号 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String beforeTechnicalIndex = measureData.getTechnicalIndex().replace("±", ""); - BigDecimal technicalIndex = new BigDecimal(beforeTechnicalIndex); - //指标下限 = 标称值-输入项配置（技术指标配置数值） - BigDecimal lowerIndex = nominalValue.subtract(technicalIndex); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值+输入项配置（技术指标配置数值） - BigDecimal upperIndex = nominalValue.add(technicalIndex); - measureData.setUpperIndex(String.valueOf(upperIndex)); //测量结果 = 如果类型为频率，手工编辑输入值，需要补充单位，单位与标称值单位相同；如果类型为幅度，根据公式计算，公式：前三次测量值的和/3 if ("幅度".equals(measureData.getTypeValue())) { BigDecimal oneValue = new BigDecimal(measureData.getOneValue()); @@ -1600,22 +1649,34 @@ measureData.setMeasureResultUnit(measureData.getUnit()); //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* String conclusion = ""; - if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - conclusion = "不符合指标"; + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); + } else { + String beforeTechnicalIndex = measureData.getTechnicalIndex().replace("±", ""); + BigDecimal technicalIndex = new BigDecimal(beforeTechnicalIndex); + //指标下限 = 标称值-输入项配置（技术指标配置数值） + BigDecimal lowerIndex = nominalValue.subtract(technicalIndex); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值+输入项配置（技术指标配置数值） + BigDecimal upperIndex = nominalValue.add(technicalIndex); + measureData.setUpperIndex(String.valueOf(upperIndex)); + if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + conclusion = "不符合指标"; + } + if (twoValue.compareTo(upperIndex) > 0 || twoValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMarkOne(1); + conclusion = "不符合指标"; + } + if (threeValue.compareTo(upperIndex) > 0 || threeValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMarkTwo(1); + conclusion = "不符合指标"; + } + if (StringUtils.isBlank(conclusion)) { + conclusion = "符合指标"; + } + measureData.setConclusion(conclusion); } - if (twoValue.compareTo(upperIndex) > 0 || twoValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMarkOne(1); - conclusion = "不符合指标"; - } - if (threeValue.compareTo(upperIndex) > 0 || threeValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMarkTwo(1); - conclusion = "不符合指标"; - } - if (StringUtils.isBlank(conclusion)) { - conclusion = "符合指标"; - } - measureData.setConclusion(conclusion); } else { measureData.setConclusion("/"); } @@ -1671,7 +1732,8 @@ BigDecimal aConvertQualityCorrectValue = new BigDecimal(measureData.getAConvertQualityCorrectValue()); BigDecimal bNominalQualityValue = new BigDecimal(measureData.getBNominalQualityValue()).multiply(BigDecimal.valueOf(100)); BigDecimal bConvertQualityCorrectValue = new BigDecimal(measureData.getBConvertQualityCorrectValue()); - BigDecimal deltaMThrow = deltaM.add(aNominalQualityValue.add(aConvertQualityCorrectValue)).add(bNominalQualityValue.add(bConvertQualityCorrectValue)); + BigDecimal deltaMThrowBefore = deltaM.add(aNominalQualityValue.add(aConvertQualityCorrectValue)).add(bNominalQualityValue.add(bConvertQualityCorrectValue)); + BigDecimal deltaMThrow = deltaMThrowBefore.divide(BigDecimal.valueOf(2), RoundingMode.HALF_UP); if (StringUtils.isNotEmpty(measureData.getPtOne())) { ptOneDeltaMThrowMap.put(deltaMThrow, measureData.getMeasureSequence()); } else if (StringUtils.isNotEmpty(measureData.getPtTwo())) { diff --git a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml index d557ffb..7c14299 100644 --- a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml +++ b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml @@ -32,10 +32,12 @@ SELECT bbdma.*, eei.equipment_no AS sampleNo, eei.equipment_name AS sampleName, eei.model AS model, eei.manufacture_no AS manufactureNo, bbdmi.measure_category AS measureCategory, bbdmi.create_user_name AS staffName, bbdmi.trace_date AS traceDate, bbdmi.manufacturer AS manufacturer, bbdmi.conclusion AS conclusion, bbdmi.restriction_instruction AS restrictionInstruction, - bbdmi.measure_address AS measureAddress, bbdmi.data_no AS measureDataNo, bbdmi.measure_valid_date, bbdmi.meter_identify, bbdmi.measure_valid_date + bbdmi.measure_address AS measureAddress, bbdmi.data_no AS measureDataNo, bbdmi.measure_valid_date, bbdmi.meter_identify, bbdmi.measure_valid_date, + bbdmii.belong_standard_equipment, bbdmii.item_category_id, bbdmii.item_category_name FROM biz_business_device_measure_approval bbdma JOIN eqpt_equipment_info eei ON bbdma.sample_id = eei.id JOIN biz_business_device_measure_info bbdmi ON bbdma.data_id = bbdmi.id + JOIN biz_business_device_measure_item_info bbdmii ON bbdmii.id = bbdmi.item_id WHERE 1=1 and bbdma.approval_status = #{request.approvalStatus} diff --git a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureDataPistonGaugeMapper.xml b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureDataPistonGaugeMapper.xml index fcdf1c3..eed7806 100644 --- a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureDataPistonGaugeMapper.xml +++ b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureDataPistonGaugeMapper.xml @@ -36,6 +36,7 @@ + @@ -69,7 +70,7 @@ after_friction_reverse_stroke, variation_forward_stroke, variation_reverse_stroke, theoretical_output_value, first_forward_stroke, first_reverse_stroke, second_forward_stroke, second_reverse_stroke, third_forward_stroke, third_reverse_stroke, indicating_error, return_error, average_forward_stroke, average_reverse_stroke, average_value, average_return_error, forward_stroke_switch_value, - reverse_stroke_switch_value, point_deviation, different_gap,create_time, update_time, item, max_indicating_error, max_friction_error, + reverse_stroke_switch_value, point_deviation, different_gap,create_time, update_time, item, friction_error, max_indicating_error, max_friction_error, max_return_error, max_point_deviation, allow_point_deviation, max_different_gap, allow_different_gap, zero_drift_one, zero_drift_two, zero_drift_three, zero_drift_four, zero_drift_five, intercept_a, slope_b, sensitivity_b, repeatability_r, linear_l, hysteresis_h, basic_error_a, periodic_stability_s_b, range_lower, range_upper, return_error_lower, friction_error_lower, indicating_error_lower diff --git a/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java b/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java index 5b27e73..172f687 100644 --- a/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java +++ b/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java @@ -917,7 +917,10 @@ //电流表示值误差（间接测量）需计算标准值 if ("5".equals(measureData.getDataType())) { //标准值 = 标准电压值/标准电阻值 - BigDecimal standardValue = new BigDecimal(measureData.getStandardVoltageValue()).divide(new BigDecimal(measureData.getStandardResistanceValue()), 4, RoundingMode.HALF_UP); + //单位转换 + BigDecimal resistance = UnitConvertUtil.resistanceConvert(measureData.getStandardResistanceValue(), measureData.getStandardResistanceValueUnit(), "Ω"); + BigDecimal voltage = UnitConvertUtil.voltageConvert(measureData.getStandardVoltageValue(), measureData.getStandardVoltageValueUnit(), "V"); + BigDecimal standardValue = voltage.divide(resistance, 4, RoundingMode.HALF_UP); measureData.setStandardValue(String.valueOf(standardValue)); } @@ -1275,7 +1278,6 @@ String unit = measureData.getUnit(); if ("1".equals(measureData.getDataType())) { BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); //测量值1、测量值2、测量值3，根据单位保留小数位，单位和标称值单位相同 BigDecimal oneValue = UnitConvertUtil.valueDecimalConvert(unit, measureData.getOneValue()); BigDecimal twoValue = UnitConvertUtil.valueDecimalConvert(unit, measureData.getTwoValue()); @@ -1283,29 +1285,33 @@ measureData.setOneValue(String.valueOf(oneValue)); measureData.setTwoValue(String.valueOf(twoValue)); measureData.setThreeValue(String.valueOf(threeValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同测量值 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - lowerIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(lowerIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - upperIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(upperIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); //均值 = （测量值1+测量值2+测量值3）/ 3，保留小数规则同测量值 BigDecimal averageValue = (oneValue.add(twoValue).add(threeValue)).divide(BigDecimal.valueOf(3), 12, RoundingMode.HALF_UP); averageValue = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(averageValue)); measureData.setAverageValue(String.valueOf(averageValue)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标，保留小数规则同测量值 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + lowerIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(lowerIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + upperIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(upperIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("2".equals(measureData.getDataType())) { //扫描宽度 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); //fl1、fr1、fl2、fr2、fl3、fr3 BigDecimal oneValue = new BigDecimal(measureData.getOneValue()).round(new MathContext(5, RoundingMode.HALF_UP)); BigDecimal twoValue = new BigDecimal(measureData.getTwoValue()).round(new MathContext(5, RoundingMode.HALF_UP)); @@ -1319,31 +1325,34 @@ measureData.setFourValue(String.valueOf(fourValue)); measureData.setFiveValue(String.valueOf(fiveValue)); measureData.setSixValue(String.valueOf(sixValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 - BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - BigDecimal lowerIndex = beforeLowerIndex.round(new MathContext(5, RoundingMode.HALF_UP)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - BigDecimal upperIndex = beforeUpperIndex.round(new MathContext(5, RoundingMode.HALF_UP)); - measureData.setUpperIndex(String.valueOf(upperIndex)); //均值 = ((fr1-fl1)+(fr2-fl2)+(fr3-fl3))*10/8/3 BigDecimal beforeAverageValue = (twoValue.subtract(oneValue).add(fourValue).subtract(threeValue).add(sixValue).subtract(fiveValue)) .multiply(BigDecimal.valueOf(10)).divide(BigDecimal.valueOf(8), 6, RoundingMode.HALF_UP).divide(BigDecimal.valueOf(3), 6, RoundingMode.HALF_UP); BigDecimal averageValue = beforeAverageValue.round(new MathContext(5, RoundingMode.HALF_UP)); measureData.setAverageValue(String.valueOf(averageValue)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 + BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + BigDecimal lowerIndex = beforeLowerIndex.round(new MathContext(5, RoundingMode.HALF_UP)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + BigDecimal upperIndex = beforeUpperIndex.round(new MathContext(5, RoundingMode.HALF_UP)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("3".equals(measureData.getDataType())) { //中频带宽 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndexLeft = measureData.getTechnicalIndexLeft(); - String technicalIndexRight = measureData.getTechnicalIndexRight(); if (StringUtils.isNotEmpty(measureData.getOneValue()) && StringUtils.isNotEmpty(measureData.getTwoValue()) && StringUtils.isNotEmpty(measureData.getThreeValue()) && StringUtils.isNotEmpty(measureData.getFourValue()) && StringUtils.isNotEmpty(measureData.getFiveValue()) && StringUtils.isNotEmpty(measureData.getSixValue())) { @@ -1367,20 +1376,26 @@ //均值 = (△f1+△f2+△f3)/3 BigDecimal averageValue = (eightValue.add(nineValue).add(tenValue)).divide(BigDecimal.valueOf(3), 2, RoundingMode.HALF_UP); measureData.setAverageValue(String.valueOf(averageValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 - BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndexLeft)); - BigDecimal lowerIndex = beforeLowerIndex.setScale(2, RoundingMode.HALF_UP); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndexRight)); - BigDecimal upperIndex = beforeUpperIndex.setScale(2, RoundingMode.HALF_UP); - measureData.setUpperIndex(String.valueOf(upperIndex)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndexLeft()) || "/".equals(measureData.getTechnicalIndexRight())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndexLeft = measureData.getTechnicalIndexLeft(); + String technicalIndexRight = measureData.getTechnicalIndexRight(); + //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 + BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndexLeft)); + BigDecimal lowerIndex = beforeLowerIndex.setScale(2, RoundingMode.HALF_UP); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndexRight)); + BigDecimal upperIndex = beforeUpperIndex.setScale(2, RoundingMode.HALF_UP); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("4".equals(measureData.getDataType())) { //中频带宽转换偏差 @@ -1391,13 +1406,17 @@ BigDecimal convertDeviation = new BigDecimal(measureData.getOneValue()).subtract(new BigDecimal(referValue)); measureData.setConvertDeviation(String.valueOf(convertDeviation)); //结论，转换偏差是否在转换偏差下限、转换偏差上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将转换偏差字段（参与比较字段）标* - BigDecimal upperConvertDeviation = new BigDecimal(measureData.getUpperConvertDeviation()); - BigDecimal lowerConvertDeviation = new BigDecimal(measureData.getLowerConvertDeviation()); - if (convertDeviation.compareTo(upperConvertDeviation) > 0 || convertDeviation.compareTo(lowerConvertDeviation) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperConvertDeviation()) || "/".equals(measureData.getLowerConvertDeviation())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperConvertDeviation = new BigDecimal(measureData.getUpperConvertDeviation()); + BigDecimal lowerConvertDeviation = new BigDecimal(measureData.getLowerConvertDeviation()); + if (convertDeviation.compareTo(upperConvertDeviation) > 0 || convertDeviation.compareTo(lowerConvertDeviation) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("5".equals(measureData.getDataType())) { @@ -1412,18 +1431,22 @@ measureData.setOneValue(String.valueOf(oneValue)); //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); - //指标下限 = 标称值 - 技术指标 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); - if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("6".equals(measureData.getDataType())) { @@ -1434,13 +1457,7 @@ BigDecimal firstAttenuatorAttenuation = new BigDecimal(firstData.getStandardAttenuatorAttenuation()); BigDecimal firstSourceAmplitude = new BigDecimal(firstData.getSignalSourceAmplitude()); BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); - //指标下限 = 标称值 - 技术指标 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); + //测量值 = 标准衰减器衰减量(当次测量)-标准衰减器衰减量(上一次测量)+(信号源幅度(当次测量)-信号源幅度（上一次测量）).后面带单位，与标称值单位相同 BigDecimal attenuatorAttenuation = new BigDecimal(measureData.getStandardAttenuatorAttenuation()); BigDecimal sourceAmplitude = new BigDecimal(measureData.getSignalSourceAmplitude()); @@ -1458,12 +1475,23 @@ value = attenuatorAttenuation.subtract(preAttenuatorAttenuation).add(sourceAmplitude).subtract(preSourceAmplitude); } measureData.setOneValue(String.valueOf(value)); - //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* - if (value.compareTo(upperIndex) > 0 || value.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* + if (value.compareTo(upperIndex) > 0 || value.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("7".equals(measureData.getDataType())) { @@ -1481,13 +1509,17 @@ BigDecimal inputFrequency = new BigDecimal(firstAverage).subtract(averageValue); measureData.setInputFrequency(String.valueOf(inputFrequency)); //结论，输入频响是否在输入频响上限、下限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将输入频响字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); - if (inputFrequency.compareTo(upperIndex) > 0 || inputFrequency.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex()) || "/".equals(measureData.getLowerIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); + if (inputFrequency.compareTo(upperIndex) > 0 || inputFrequency.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("8".equals(measureData.getDataType())) { @@ -1502,12 +1534,16 @@ measureData.setRevisedResult(String.valueOf(value)); } //结论，修正后结果小于指标上限，如是，则“符合指标”，如不是则"不符合指标"，并将修正后结果字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - if (revisedResult.compareTo(upperIndex) > 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + if (revisedResult.compareTo(upperIndex) > 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("9".equals(measureData.getDataType())) { //谐波失真 @@ -1527,15 +1563,28 @@ //结论，二/三/四谐波失真是否小于二/三/四谐波失真指标上限，如是，则“符合指标”，如不是则"不符合指标"，并将二/三/四谐波失真字段（参与比较字段）标* //如果三次谐波失真、四次谐波失真未配置，结论处不参与计算 if (StringUtils.isNotEmpty(measureData.getFiveValue()) && StringUtils.isNotEmpty(measureData.getSevenValue())) { - BigDecimal upperIndexTwice = new BigDecimal(measureData.getUpperIndexTwice()); - BigDecimal upperIndexThrice = new BigDecimal(measureData.getUpperIndexThrice()); - BigDecimal upperIndexQuartic = new BigDecimal(measureData.getUpperIndexQuartic()); BigDecimal fiveValue = new BigDecimal(measureData.getFiveValue()); BigDecimal sevenValue = new BigDecimal(measureData.getSevenValue()); - if (threeValue.compareTo(upperIndexTwice) > 0 || fiveValue.compareTo(upperIndexThrice) > 0 || sevenValue.compareTo(upperIndexQuartic) > 0) { + if ("/".equals(measureData.getUpperIndexTwice())) { + measureData.setConclusion("/"); + } else { + BigDecimal upperIndexTwice = new BigDecimal(measureData.getUpperIndexTwice()); if (threeValue.compareTo(upperIndexTwice) > 0) measureData.setExceedMark(1); + } + if ("/".equals(measureData.getUpperIndexThrice())) { + measureData.setConclusion("/"); + } else { + + BigDecimal upperIndexThrice = new BigDecimal(measureData.getUpperIndexThrice()); if (fiveValue.compareTo(upperIndexThrice) > 0) measureData.setExceedMarkOne(1); + } + if ("/".equals(measureData.getUpperIndexQuartic())) { + measureData.setConclusion("/"); + } else { + BigDecimal upperIndexQuartic = new BigDecimal(measureData.getUpperIndexQuartic()); if (sevenValue.compareTo(upperIndexQuartic) > 0) measureData.setExceedMarkTwo(1); + } + if (measureData.getExceedMark() == 1 && measureData.getExceedMarkOne() == 1 || measureData.getExceedMarkTwo() == 1) { measureData.setConclusion("不符合指标"); } else { measureData.setConclusion("符合指标"); @@ -1553,13 +1602,17 @@ BigDecimal inputAttenuatorConversionEffect = oneValue.subtract(new BigDecimal(firstValue)).subtract((attenuatorAttenuation.subtract(new BigDecimal(firstAttenuatorAttenuation)))); measureData.setInputAttenuatorConversionEffect(String.valueOf(inputAttenuatorConversionEffect)); //结论，输入衰减器转换影响是否在下限、上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将输入衰减器转换影响字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); - if (inputAttenuatorConversionEffect.compareTo(upperIndex) > 0 || inputAttenuatorConversionEffect.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex()) || "/".equals(measureData.getLowerIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); + if (inputAttenuatorConversionEffect.compareTo(upperIndex) > 0 || inputAttenuatorConversionEffect.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("11".equals(measureData.getDataType())) { @@ -1570,26 +1623,22 @@ BigDecimal gainCompression = oneValue.subtract(inputAttenuator); measureData.setGainCompression(String.valueOf(gainCompression)); //结论，增益压缩是否在技术指标范围内，如是，则“符合指标”，如不是则"不符合指标"，并将增益压缩字段（参与比较字段）标* - String symbol = measureData.getTechnicalIndex().substring(0, 1); - String technicalIndex = measureData.getTechnicalIndex().substring(1); - int exceedMark = judgeSymbol(symbol, String.valueOf(gainCompression), new BigDecimal(technicalIndex)); - if (1 == exceedMark) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String symbol = measureData.getTechnicalIndex().substring(0, 1); + String technicalIndex = measureData.getTechnicalIndex().substring(1); + int exceedMark = judgeSymbol(symbol, String.valueOf(gainCompression), new BigDecimal(technicalIndex)); + if (1 == exceedMark) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("12".equals(measureData.getDataType())) { //校准信号 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String beforeTechnicalIndex = measureData.getTechnicalIndex().replace("±", ""); - BigDecimal technicalIndex = new BigDecimal(beforeTechnicalIndex); - //指标下限 = 标称值-输入项配置（技术指标配置数值） - BigDecimal lowerIndex = nominalValue.subtract(technicalIndex); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值+输入项配置（技术指标配置数值） - BigDecimal upperIndex = nominalValue.add(technicalIndex); - measureData.setUpperIndex(String.valueOf(upperIndex)); //测量结果 = 如果类型为频率，手工编辑输入值，需要补充单位，单位与标称值单位相同；如果类型为幅度，根据公式计算，公式：前三次测量值的和/3 if ("幅度".equals(measureData.getTypeValue())) { BigDecimal oneValue = new BigDecimal(measureData.getOneValue()); @@ -1600,22 +1649,34 @@ measureData.setMeasureResultUnit(measureData.getUnit()); //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* String conclusion = ""; - if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - conclusion = "不符合指标"; + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); + } else { + String beforeTechnicalIndex = measureData.getTechnicalIndex().replace("±", ""); + BigDecimal technicalIndex = new BigDecimal(beforeTechnicalIndex); + //指标下限 = 标称值-输入项配置（技术指标配置数值） + BigDecimal lowerIndex = nominalValue.subtract(technicalIndex); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值+输入项配置（技术指标配置数值） + BigDecimal upperIndex = nominalValue.add(technicalIndex); + measureData.setUpperIndex(String.valueOf(upperIndex)); + if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + conclusion = "不符合指标"; + } + if (twoValue.compareTo(upperIndex) > 0 || twoValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMarkOne(1); + conclusion = "不符合指标"; + } + if (threeValue.compareTo(upperIndex) > 0 || threeValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMarkTwo(1); + conclusion = "不符合指标"; + } + if (StringUtils.isBlank(conclusion)) { + conclusion = "符合指标"; + } + measureData.setConclusion(conclusion); } - if (twoValue.compareTo(upperIndex) > 0 || twoValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMarkOne(1); - conclusion = "不符合指标"; - } - if (threeValue.compareTo(upperIndex) > 0 || threeValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMarkTwo(1); - conclusion = "不符合指标"; - } - if (StringUtils.isBlank(conclusion)) { - conclusion = "符合指标"; - } - measureData.setConclusion(conclusion); } else { measureData.setConclusion("/"); } @@ -1671,7 +1732,8 @@ BigDecimal aConvertQualityCorrectValue = new BigDecimal(measureData.getAConvertQualityCorrectValue()); BigDecimal bNominalQualityValue = new BigDecimal(measureData.getBNominalQualityValue()).multiply(BigDecimal.valueOf(100)); BigDecimal bConvertQualityCorrectValue = new BigDecimal(measureData.getBConvertQualityCorrectValue()); - BigDecimal deltaMThrow = deltaM.add(aNominalQualityValue.add(aConvertQualityCorrectValue)).add(bNominalQualityValue.add(bConvertQualityCorrectValue)); + BigDecimal deltaMThrowBefore = deltaM.add(aNominalQualityValue.add(aConvertQualityCorrectValue)).add(bNominalQualityValue.add(bConvertQualityCorrectValue)); + BigDecimal deltaMThrow = deltaMThrowBefore.divide(BigDecimal.valueOf(2), RoundingMode.HALF_UP); if (StringUtils.isNotEmpty(measureData.getPtOne())) { ptOneDeltaMThrowMap.put(deltaMThrow, measureData.getMeasureSequence()); } else if (StringUtils.isNotEmpty(measureData.getPtTwo())) { diff --git a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml index d557ffb..7c14299 100644 --- a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml +++ b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml @@ -32,10 +32,12 @@ SELECT bbdma.*, eei.equipment_no AS sampleNo, eei.equipment_name AS sampleName, eei.model AS model, eei.manufacture_no AS manufactureNo, bbdmi.measure_category AS measureCategory, bbdmi.create_user_name AS staffName, bbdmi.trace_date AS traceDate, bbdmi.manufacturer AS manufacturer, bbdmi.conclusion AS conclusion, bbdmi.restriction_instruction AS restrictionInstruction, - bbdmi.measure_address AS measureAddress, bbdmi.data_no AS measureDataNo, bbdmi.measure_valid_date, bbdmi.meter_identify, bbdmi.measure_valid_date + bbdmi.measure_address AS measureAddress, bbdmi.data_no AS measureDataNo, bbdmi.measure_valid_date, bbdmi.meter_identify, bbdmi.measure_valid_date, + bbdmii.belong_standard_equipment, bbdmii.item_category_id, bbdmii.item_category_name FROM biz_business_device_measure_approval bbdma JOIN eqpt_equipment_info eei ON bbdma.sample_id = eei.id JOIN biz_business_device_measure_info bbdmi ON bbdma.data_id = bbdmi.id + JOIN biz_business_device_measure_item_info bbdmii ON bbdmii.id = bbdmi.item_id WHERE 1=1 and bbdma.approval_status = #{request.approvalStatus} diff --git a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureDataPistonGaugeMapper.xml b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureDataPistonGaugeMapper.xml index fcdf1c3..eed7806 100644 --- a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureDataPistonGaugeMapper.xml +++ b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureDataPistonGaugeMapper.xml @@ -36,6 +36,7 @@ + @@ -69,7 +70,7 @@ after_friction_reverse_stroke, variation_forward_stroke, variation_reverse_stroke, theoretical_output_value, first_forward_stroke, first_reverse_stroke, second_forward_stroke, second_reverse_stroke, third_forward_stroke, third_reverse_stroke, indicating_error, return_error, average_forward_stroke, average_reverse_stroke, average_value, average_return_error, forward_stroke_switch_value, - reverse_stroke_switch_value, point_deviation, different_gap,create_time, update_time, item, max_indicating_error, max_friction_error, + reverse_stroke_switch_value, point_deviation, different_gap,create_time, update_time, item, friction_error, max_indicating_error, max_friction_error, max_return_error, max_point_deviation, allow_point_deviation, max_different_gap, allow_different_gap, zero_drift_one, zero_drift_two, zero_drift_three, zero_drift_four, zero_drift_five, intercept_a, slope_b, sensitivity_b, repeatability_r, linear_l, hysteresis_h, basic_error_a, periodic_stability_s_b, range_lower, range_upper, return_error_lower, friction_error_lower, indicating_error_lower diff --git a/casic-metering-dao/src/main/resources/mapper/equipment/BizEquipmentStandardCheckRecordApprovalMapper.xml b/casic-metering-dao/src/main/resources/mapper/equipment/BizEquipmentStandardCheckRecordApprovalMapper.xml index ecae416..4d0f3de 100644 --- a/casic-metering-dao/src/main/resources/mapper/equipment/BizEquipmentStandardCheckRecordApprovalMapper.xml +++ b/casic-metering-dao/src/main/resources/mapper/equipment/BizEquipmentStandardCheckRecordApprovalMapper.xml @@ -26,14 +26,16 @@ SELECT bescra.*, besi.standard_name AS standardEquipmentName, beit.equipment_name AS equipmentName, beit.model AS equipmentModel, GROUP_CONCAT(bei.equipment_name SEPARATOR ',') AS checkEquipmentName, GROUP_CONCAT(bei.model SEPARATOR ',') AS checkEquipmentModel, - GROUP_CONCAT(bei.manufacture_no SEPARATOR ',') AS checkEquipmentManufactureNo, - besci.create_user_name AS checkUserName, besci.check_date, besci.data_no, beit.manufacture_no AS equipmentManufactureNo + GROUP_CONCAT(bei.manufacture_no SEPARATOR ',') AS checkEquipmentManufactureNo, besci.create_user_name AS checkUserName, + besci.check_date, besci.data_no, beit.manufacture_no AS equipmentManufactureNo, bescic.id AS itemCategoryId, + bescic.category_name AS itemCategoryName, bescic.belong_standard_equipment FROM biz_equipment_standard_check_record_approval bescra JOIN biz_equipment_standard_check_info besci ON bescra.data_id = besci.id JOIN biz_equipment_standard_check_info_equipment bescie ON bescie.data_id = besci.id JOIN biz_equipment_info bei ON bescie.check_equipment_id = bei.id JOIN biz_equipment_standard_info besi ON besci.standard_equipment_id = besi.id JOIN biz_equipment_info beit ON besci.equipment_id = beit.id + LEFT JOIN biz_equipment_standard_check_item_category bescic ON bescic.id = besci.item_category_id WHERE 1=1 and bescra.approval_status = #{request.approvalStatus} diff --git a/casic-metering-model/src/main/java/com/casic/missiles/model/business/BizBusinessDeviceMeasureApproval.java b/casic-metering-model/src/main/java/com/casic/missiles/model/business/BizBusinessDeviceMeasureApproval.java index a926039..5a3b218 100644 --- a/casic-metering-model/src/main/java/com/casic/missiles/model/business/BizBusinessDeviceMeasureApproval.java +++ b/casic-metering-model/src/main/java/com/casic/missiles/model/business/BizBusinessDeviceMeasureApproval.java @@ -467,9 +467,14 @@ private List measureDataSParamList; @ApiModelProperty(value = "标准装置编号", dataType = "String") + @DictCodeField(message = "检校标准装置描述不合法", cacheName = MeterDictCode.BIZ_STANDARD_EQUIPMENT_TYPE) @TableField(exist = false) private String belongStandardEquipment; + @ApiModelProperty(value = "检校标准装置(字典value)", dataType = "String") + @TableField(exist = false) + private String belongStandardEquipmentName; + @ApiModelProperty(value = "设备检定项分类id", dataType = "Long") @TableField(exist = false) private Long itemCategoryId; diff --git a/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java b/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java index 5b27e73..172f687 100644 --- a/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java +++ b/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java @@ -917,7 +917,10 @@ //电流表示值误差（间接测量）需计算标准值 if ("5".equals(measureData.getDataType())) { //标准值 = 标准电压值/标准电阻值 - BigDecimal standardValue = new BigDecimal(measureData.getStandardVoltageValue()).divide(new BigDecimal(measureData.getStandardResistanceValue()), 4, RoundingMode.HALF_UP); + //单位转换 + BigDecimal resistance = UnitConvertUtil.resistanceConvert(measureData.getStandardResistanceValue(), measureData.getStandardResistanceValueUnit(), "Ω"); + BigDecimal voltage = UnitConvertUtil.voltageConvert(measureData.getStandardVoltageValue(), measureData.getStandardVoltageValueUnit(), "V"); + BigDecimal standardValue = voltage.divide(resistance, 4, RoundingMode.HALF_UP); measureData.setStandardValue(String.valueOf(standardValue)); } @@ -1275,7 +1278,6 @@ String unit = measureData.getUnit(); if ("1".equals(measureData.getDataType())) { BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); //测量值1、测量值2、测量值3，根据单位保留小数位，单位和标称值单位相同 BigDecimal oneValue = UnitConvertUtil.valueDecimalConvert(unit, measureData.getOneValue()); BigDecimal twoValue = UnitConvertUtil.valueDecimalConvert(unit, measureData.getTwoValue()); @@ -1283,29 +1285,33 @@ measureData.setOneValue(String.valueOf(oneValue)); measureData.setTwoValue(String.valueOf(twoValue)); measureData.setThreeValue(String.valueOf(threeValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同测量值 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - lowerIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(lowerIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - upperIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(upperIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); //均值 = （测量值1+测量值2+测量值3）/ 3，保留小数规则同测量值 BigDecimal averageValue = (oneValue.add(twoValue).add(threeValue)).divide(BigDecimal.valueOf(3), 12, RoundingMode.HALF_UP); averageValue = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(averageValue)); measureData.setAverageValue(String.valueOf(averageValue)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标，保留小数规则同测量值 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + lowerIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(lowerIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + upperIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(upperIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("2".equals(measureData.getDataType())) { //扫描宽度 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); //fl1、fr1、fl2、fr2、fl3、fr3 BigDecimal oneValue = new BigDecimal(measureData.getOneValue()).round(new MathContext(5, RoundingMode.HALF_UP)); BigDecimal twoValue = new BigDecimal(measureData.getTwoValue()).round(new MathContext(5, RoundingMode.HALF_UP)); @@ -1319,31 +1325,34 @@ measureData.setFourValue(String.valueOf(fourValue)); measureData.setFiveValue(String.valueOf(fiveValue)); measureData.setSixValue(String.valueOf(sixValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 - BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - BigDecimal lowerIndex = beforeLowerIndex.round(new MathContext(5, RoundingMode.HALF_UP)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - BigDecimal upperIndex = beforeUpperIndex.round(new MathContext(5, RoundingMode.HALF_UP)); - measureData.setUpperIndex(String.valueOf(upperIndex)); //均值 = ((fr1-fl1)+(fr2-fl2)+(fr3-fl3))*10/8/3 BigDecimal beforeAverageValue = (twoValue.subtract(oneValue).add(fourValue).subtract(threeValue).add(sixValue).subtract(fiveValue)) .multiply(BigDecimal.valueOf(10)).divide(BigDecimal.valueOf(8), 6, RoundingMode.HALF_UP).divide(BigDecimal.valueOf(3), 6, RoundingMode.HALF_UP); BigDecimal averageValue = beforeAverageValue.round(new MathContext(5, RoundingMode.HALF_UP)); measureData.setAverageValue(String.valueOf(averageValue)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 + BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + BigDecimal lowerIndex = beforeLowerIndex.round(new MathContext(5, RoundingMode.HALF_UP)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + BigDecimal upperIndex = beforeUpperIndex.round(new MathContext(5, RoundingMode.HALF_UP)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("3".equals(measureData.getDataType())) { //中频带宽 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndexLeft = measureData.getTechnicalIndexLeft(); - String technicalIndexRight = measureData.getTechnicalIndexRight(); if (StringUtils.isNotEmpty(measureData.getOneValue()) && StringUtils.isNotEmpty(measureData.getTwoValue()) && StringUtils.isNotEmpty(measureData.getThreeValue()) && StringUtils.isNotEmpty(measureData.getFourValue()) && StringUtils.isNotEmpty(measureData.getFiveValue()) && StringUtils.isNotEmpty(measureData.getSixValue())) { @@ -1367,20 +1376,26 @@ //均值 = (△f1+△f2+△f3)/3 BigDecimal averageValue = (eightValue.add(nineValue).add(tenValue)).divide(BigDecimal.valueOf(3), 2, RoundingMode.HALF_UP); measureData.setAverageValue(String.valueOf(averageValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 - BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndexLeft)); - BigDecimal lowerIndex = beforeLowerIndex.setScale(2, RoundingMode.HALF_UP); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndexRight)); - BigDecimal upperIndex = beforeUpperIndex.setScale(2, RoundingMode.HALF_UP); - measureData.setUpperIndex(String.valueOf(upperIndex)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndexLeft()) || "/".equals(measureData.getTechnicalIndexRight())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndexLeft = measureData.getTechnicalIndexLeft(); + String technicalIndexRight = measureData.getTechnicalIndexRight(); + //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 + BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndexLeft)); + BigDecimal lowerIndex = beforeLowerIndex.setScale(2, RoundingMode.HALF_UP); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndexRight)); + BigDecimal upperIndex = beforeUpperIndex.setScale(2, RoundingMode.HALF_UP); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("4".equals(measureData.getDataType())) { //中频带宽转换偏差 @@ -1391,13 +1406,17 @@ BigDecimal convertDeviation = new BigDecimal(measureData.getOneValue()).subtract(new BigDecimal(referValue)); measureData.setConvertDeviation(String.valueOf(convertDeviation)); //结论，转换偏差是否在转换偏差下限、转换偏差上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将转换偏差字段（参与比较字段）标* - BigDecimal upperConvertDeviation = new BigDecimal(measureData.getUpperConvertDeviation()); - BigDecimal lowerConvertDeviation = new BigDecimal(measureData.getLowerConvertDeviation()); - if (convertDeviation.compareTo(upperConvertDeviation) > 0 || convertDeviation.compareTo(lowerConvertDeviation) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperConvertDeviation()) || "/".equals(measureData.getLowerConvertDeviation())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperConvertDeviation = new BigDecimal(measureData.getUpperConvertDeviation()); + BigDecimal lowerConvertDeviation = new BigDecimal(measureData.getLowerConvertDeviation()); + if (convertDeviation.compareTo(upperConvertDeviation) > 0 || convertDeviation.compareTo(lowerConvertDeviation) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("5".equals(measureData.getDataType())) { @@ -1412,18 +1431,22 @@ measureData.setOneValue(String.valueOf(oneValue)); //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); - //指标下限 = 标称值 - 技术指标 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); - if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("6".equals(measureData.getDataType())) { @@ -1434,13 +1457,7 @@ BigDecimal firstAttenuatorAttenuation = new BigDecimal(firstData.getStandardAttenuatorAttenuation()); BigDecimal firstSourceAmplitude = new BigDecimal(firstData.getSignalSourceAmplitude()); BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); - //指标下限 = 标称值 - 技术指标 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); + //测量值 = 标准衰减器衰减量(当次测量)-标准衰减器衰减量(上一次测量)+(信号源幅度(当次测量)-信号源幅度（上一次测量）).后面带单位，与标称值单位相同 BigDecimal attenuatorAttenuation = new BigDecimal(measureData.getStandardAttenuatorAttenuation()); BigDecimal sourceAmplitude = new BigDecimal(measureData.getSignalSourceAmplitude()); @@ -1458,12 +1475,23 @@ value = attenuatorAttenuation.subtract(preAttenuatorAttenuation).add(sourceAmplitude).subtract(preSourceAmplitude); } measureData.setOneValue(String.valueOf(value)); - //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* - if (value.compareTo(upperIndex) > 0 || value.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* + if (value.compareTo(upperIndex) > 0 || value.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("7".equals(measureData.getDataType())) { @@ -1481,13 +1509,17 @@ BigDecimal inputFrequency = new BigDecimal(firstAverage).subtract(averageValue); measureData.setInputFrequency(String.valueOf(inputFrequency)); //结论，输入频响是否在输入频响上限、下限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将输入频响字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); - if (inputFrequency.compareTo(upperIndex) > 0 || inputFrequency.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex()) || "/".equals(measureData.getLowerIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); + if (inputFrequency.compareTo(upperIndex) > 0 || inputFrequency.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("8".equals(measureData.getDataType())) { @@ -1502,12 +1534,16 @@ measureData.setRevisedResult(String.valueOf(value)); } //结论，修正后结果小于指标上限，如是，则“符合指标”，如不是则"不符合指标"，并将修正后结果字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - if (revisedResult.compareTo(upperIndex) > 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + if (revisedResult.compareTo(upperIndex) > 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("9".equals(measureData.getDataType())) { //谐波失真 @@ -1527,15 +1563,28 @@ //结论，二/三/四谐波失真是否小于二/三/四谐波失真指标上限，如是，则“符合指标”，如不是则"不符合指标"，并将二/三/四谐波失真字段（参与比较字段）标* //如果三次谐波失真、四次谐波失真未配置，结论处不参与计算 if (StringUtils.isNotEmpty(measureData.getFiveValue()) && StringUtils.isNotEmpty(measureData.getSevenValue())) { - BigDecimal upperIndexTwice = new BigDecimal(measureData.getUpperIndexTwice()); - BigDecimal upperIndexThrice = new BigDecimal(measureData.getUpperIndexThrice()); - BigDecimal upperIndexQuartic = new BigDecimal(measureData.getUpperIndexQuartic()); BigDecimal fiveValue = new BigDecimal(measureData.getFiveValue()); BigDecimal sevenValue = new BigDecimal(measureData.getSevenValue()); - if (threeValue.compareTo(upperIndexTwice) > 0 || fiveValue.compareTo(upperIndexThrice) > 0 || sevenValue.compareTo(upperIndexQuartic) > 0) { + if ("/".equals(measureData.getUpperIndexTwice())) { + measureData.setConclusion("/"); + } else { + BigDecimal upperIndexTwice = new BigDecimal(measureData.getUpperIndexTwice()); if (threeValue.compareTo(upperIndexTwice) > 0) measureData.setExceedMark(1); + } + if ("/".equals(measureData.getUpperIndexThrice())) { + measureData.setConclusion("/"); + } else { + + BigDecimal upperIndexThrice = new BigDecimal(measureData.getUpperIndexThrice()); if (fiveValue.compareTo(upperIndexThrice) > 0) measureData.setExceedMarkOne(1); + } + if ("/".equals(measureData.getUpperIndexQuartic())) { + measureData.setConclusion("/"); + } else { + BigDecimal upperIndexQuartic = new BigDecimal(measureData.getUpperIndexQuartic()); if (sevenValue.compareTo(upperIndexQuartic) > 0) measureData.setExceedMarkTwo(1); + } + if (measureData.getExceedMark() == 1 && measureData.getExceedMarkOne() == 1 || measureData.getExceedMarkTwo() == 1) { measureData.setConclusion("不符合指标"); } else { measureData.setConclusion("符合指标"); @@ -1553,13 +1602,17 @@ BigDecimal inputAttenuatorConversionEffect = oneValue.subtract(new BigDecimal(firstValue)).subtract((attenuatorAttenuation.subtract(new BigDecimal(firstAttenuatorAttenuation)))); measureData.setInputAttenuatorConversionEffect(String.valueOf(inputAttenuatorConversionEffect)); //结论，输入衰减器转换影响是否在下限、上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将输入衰减器转换影响字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); - if (inputAttenuatorConversionEffect.compareTo(upperIndex) > 0 || inputAttenuatorConversionEffect.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex()) || "/".equals(measureData.getLowerIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); + if (inputAttenuatorConversionEffect.compareTo(upperIndex) > 0 || inputAttenuatorConversionEffect.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("11".equals(measureData.getDataType())) { @@ -1570,26 +1623,22 @@ BigDecimal gainCompression = oneValue.subtract(inputAttenuator); measureData.setGainCompression(String.valueOf(gainCompression)); //结论，增益压缩是否在技术指标范围内，如是，则“符合指标”，如不是则"不符合指标"，并将增益压缩字段（参与比较字段）标* - String symbol = measureData.getTechnicalIndex().substring(0, 1); - String technicalIndex = measureData.getTechnicalIndex().substring(1); - int exceedMark = judgeSymbol(symbol, String.valueOf(gainCompression), new BigDecimal(technicalIndex)); - if (1 == exceedMark) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String symbol = measureData.getTechnicalIndex().substring(0, 1); + String technicalIndex = measureData.getTechnicalIndex().substring(1); + int exceedMark = judgeSymbol(symbol, String.valueOf(gainCompression), new BigDecimal(technicalIndex)); + if (1 == exceedMark) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("12".equals(measureData.getDataType())) { //校准信号 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String beforeTechnicalIndex = measureData.getTechnicalIndex().replace("±", ""); - BigDecimal technicalIndex = new BigDecimal(beforeTechnicalIndex); - //指标下限 = 标称值-输入项配置（技术指标配置数值） - BigDecimal lowerIndex = nominalValue.subtract(technicalIndex); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值+输入项配置（技术指标配置数值） - BigDecimal upperIndex = nominalValue.add(technicalIndex); - measureData.setUpperIndex(String.valueOf(upperIndex)); //测量结果 = 如果类型为频率，手工编辑输入值，需要补充单位，单位与标称值单位相同；如果类型为幅度，根据公式计算，公式：前三次测量值的和/3 if ("幅度".equals(measureData.getTypeValue())) { BigDecimal oneValue = new BigDecimal(measureData.getOneValue()); @@ -1600,22 +1649,34 @@ measureData.setMeasureResultUnit(measureData.getUnit()); //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* String conclusion = ""; - if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - conclusion = "不符合指标"; + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); + } else { + String beforeTechnicalIndex = measureData.getTechnicalIndex().replace("±", ""); + BigDecimal technicalIndex = new BigDecimal(beforeTechnicalIndex); + //指标下限 = 标称值-输入项配置（技术指标配置数值） + BigDecimal lowerIndex = nominalValue.subtract(technicalIndex); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值+输入项配置（技术指标配置数值） + BigDecimal upperIndex = nominalValue.add(technicalIndex); + measureData.setUpperIndex(String.valueOf(upperIndex)); + if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + conclusion = "不符合指标"; + } + if (twoValue.compareTo(upperIndex) > 0 || twoValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMarkOne(1); + conclusion = "不符合指标"; + } + if (threeValue.compareTo(upperIndex) > 0 || threeValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMarkTwo(1); + conclusion = "不符合指标"; + } + if (StringUtils.isBlank(conclusion)) { + conclusion = "符合指标"; + } + measureData.setConclusion(conclusion); } - if (twoValue.compareTo(upperIndex) > 0 || twoValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMarkOne(1); - conclusion = "不符合指标"; - } - if (threeValue.compareTo(upperIndex) > 0 || threeValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMarkTwo(1); - conclusion = "不符合指标"; - } - if (StringUtils.isBlank(conclusion)) { - conclusion = "符合指标"; - } - measureData.setConclusion(conclusion); } else { measureData.setConclusion("/"); } @@ -1671,7 +1732,8 @@ BigDecimal aConvertQualityCorrectValue = new BigDecimal(measureData.getAConvertQualityCorrectValue()); BigDecimal bNominalQualityValue = new BigDecimal(measureData.getBNominalQualityValue()).multiply(BigDecimal.valueOf(100)); BigDecimal bConvertQualityCorrectValue = new BigDecimal(measureData.getBConvertQualityCorrectValue()); - BigDecimal deltaMThrow = deltaM.add(aNominalQualityValue.add(aConvertQualityCorrectValue)).add(bNominalQualityValue.add(bConvertQualityCorrectValue)); + BigDecimal deltaMThrowBefore = deltaM.add(aNominalQualityValue.add(aConvertQualityCorrectValue)).add(bNominalQualityValue.add(bConvertQualityCorrectValue)); + BigDecimal deltaMThrow = deltaMThrowBefore.divide(BigDecimal.valueOf(2), RoundingMode.HALF_UP); if (StringUtils.isNotEmpty(measureData.getPtOne())) { ptOneDeltaMThrowMap.put(deltaMThrow, measureData.getMeasureSequence()); } else if (StringUtils.isNotEmpty(measureData.getPtTwo())) { diff --git a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml index d557ffb..7c14299 100644 --- a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml +++ b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml @@ -32,10 +32,12 @@ SELECT bbdma.*, eei.equipment_no AS sampleNo, eei.equipment_name AS sampleName, eei.model AS model, eei.manufacture_no AS manufactureNo, bbdmi.measure_category AS measureCategory, bbdmi.create_user_name AS staffName, bbdmi.trace_date AS traceDate, bbdmi.manufacturer AS manufacturer, bbdmi.conclusion AS conclusion, bbdmi.restriction_instruction AS restrictionInstruction, - bbdmi.measure_address AS measureAddress, bbdmi.data_no AS measureDataNo, bbdmi.measure_valid_date, bbdmi.meter_identify, bbdmi.measure_valid_date + bbdmi.measure_address AS measureAddress, bbdmi.data_no AS measureDataNo, bbdmi.measure_valid_date, bbdmi.meter_identify, bbdmi.measure_valid_date, + bbdmii.belong_standard_equipment, bbdmii.item_category_id, bbdmii.item_category_name FROM biz_business_device_measure_approval bbdma JOIN eqpt_equipment_info eei ON bbdma.sample_id = eei.id JOIN biz_business_device_measure_info bbdmi ON bbdma.data_id = bbdmi.id + JOIN biz_business_device_measure_item_info bbdmii ON bbdmii.id = bbdmi.item_id WHERE 1=1 and bbdma.approval_status = #{request.approvalStatus} diff --git a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureDataPistonGaugeMapper.xml b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureDataPistonGaugeMapper.xml index fcdf1c3..eed7806 100644 --- a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureDataPistonGaugeMapper.xml +++ b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureDataPistonGaugeMapper.xml @@ -36,6 +36,7 @@ + @@ -69,7 +70,7 @@ after_friction_reverse_stroke, variation_forward_stroke, variation_reverse_stroke, theoretical_output_value, first_forward_stroke, first_reverse_stroke, second_forward_stroke, second_reverse_stroke, third_forward_stroke, third_reverse_stroke, indicating_error, return_error, average_forward_stroke, average_reverse_stroke, average_value, average_return_error, forward_stroke_switch_value, - reverse_stroke_switch_value, point_deviation, different_gap,create_time, update_time, item, max_indicating_error, max_friction_error, + reverse_stroke_switch_value, point_deviation, different_gap,create_time, update_time, item, friction_error, max_indicating_error, max_friction_error, max_return_error, max_point_deviation, allow_point_deviation, max_different_gap, allow_different_gap, zero_drift_one, zero_drift_two, zero_drift_three, zero_drift_four, zero_drift_five, intercept_a, slope_b, sensitivity_b, repeatability_r, linear_l, hysteresis_h, basic_error_a, periodic_stability_s_b, range_lower, range_upper, return_error_lower, friction_error_lower, indicating_error_lower diff --git a/casic-metering-dao/src/main/resources/mapper/equipment/BizEquipmentStandardCheckRecordApprovalMapper.xml b/casic-metering-dao/src/main/resources/mapper/equipment/BizEquipmentStandardCheckRecordApprovalMapper.xml index ecae416..4d0f3de 100644 --- a/casic-metering-dao/src/main/resources/mapper/equipment/BizEquipmentStandardCheckRecordApprovalMapper.xml +++ b/casic-metering-dao/src/main/resources/mapper/equipment/BizEquipmentStandardCheckRecordApprovalMapper.xml @@ -26,14 +26,16 @@ SELECT bescra.*, besi.standard_name AS standardEquipmentName, beit.equipment_name AS equipmentName, beit.model AS equipmentModel, GROUP_CONCAT(bei.equipment_name SEPARATOR ',') AS checkEquipmentName, GROUP_CONCAT(bei.model SEPARATOR ',') AS checkEquipmentModel, - GROUP_CONCAT(bei.manufacture_no SEPARATOR ',') AS checkEquipmentManufactureNo, - besci.create_user_name AS checkUserName, besci.check_date, besci.data_no, beit.manufacture_no AS equipmentManufactureNo + GROUP_CONCAT(bei.manufacture_no SEPARATOR ',') AS checkEquipmentManufactureNo, besci.create_user_name AS checkUserName, + besci.check_date, besci.data_no, beit.manufacture_no AS equipmentManufactureNo, bescic.id AS itemCategoryId, + bescic.category_name AS itemCategoryName, bescic.belong_standard_equipment FROM biz_equipment_standard_check_record_approval bescra JOIN biz_equipment_standard_check_info besci ON bescra.data_id = besci.id JOIN biz_equipment_standard_check_info_equipment bescie ON bescie.data_id = besci.id JOIN biz_equipment_info bei ON bescie.check_equipment_id = bei.id JOIN biz_equipment_standard_info besi ON besci.standard_equipment_id = besi.id JOIN biz_equipment_info beit ON besci.equipment_id = beit.id + LEFT JOIN biz_equipment_standard_check_item_category bescic ON bescic.id = besci.item_category_id WHERE 1=1 and bescra.approval_status = #{request.approvalStatus} diff --git a/casic-metering-model/src/main/java/com/casic/missiles/model/business/BizBusinessDeviceMeasureApproval.java b/casic-metering-model/src/main/java/com/casic/missiles/model/business/BizBusinessDeviceMeasureApproval.java index a926039..5a3b218 100644 --- a/casic-metering-model/src/main/java/com/casic/missiles/model/business/BizBusinessDeviceMeasureApproval.java +++ b/casic-metering-model/src/main/java/com/casic/missiles/model/business/BizBusinessDeviceMeasureApproval.java @@ -467,9 +467,14 @@ private List measureDataSParamList; @ApiModelProperty(value = "标准装置编号", dataType = "String") + @DictCodeField(message = "检校标准装置描述不合法", cacheName = MeterDictCode.BIZ_STANDARD_EQUIPMENT_TYPE) @TableField(exist = false) private String belongStandardEquipment; + @ApiModelProperty(value = "检校标准装置(字典value)", dataType = "String") + @TableField(exist = false) + private String belongStandardEquipmentName; + @ApiModelProperty(value = "设备检定项分类id", dataType = "Long") @TableField(exist = false) private Long itemCategoryId; diff --git a/casic-metering-model/src/main/java/com/casic/missiles/model/business/BizBusinessDeviceMeasureDataCesiumAtom.java b/casic-metering-model/src/main/java/com/casic/missiles/model/business/BizBusinessDeviceMeasureDataCesiumAtom.java index 07259d2..90bab95 100644 --- a/casic-metering-model/src/main/java/com/casic/missiles/model/business/BizBusinessDeviceMeasureDataCesiumAtom.java +++ b/casic-metering-model/src/main/java/com/casic/missiles/model/business/BizBusinessDeviceMeasureDataCesiumAtom.java @@ -134,7 +134,7 @@ private String technicalIndex; public String getTechnicalIndex() { - if (!StringUtils.isEmpty(technicalIndex)) { + if (!StringUtils.isBlank(technicalIndex) && !"/".equals(technicalIndex)) { //将bigDecimal转为科学计数法，String.format转换方式，bigDecimal.toString()和bigDecimal.toPlainString()不生效 if (technicalIndex.contains("±")) { int scale = new BigDecimal(technicalIndex.replace("±", "")).scale(); diff --git a/casic-metering-model/src/main/java/com/casic/missiles/model/business/BizBusinessDeviceMeasureItemDataCesiumAtom.java b/casic-metering-model/src/main/java/com/casic/missiles/model/business/BizBusinessDeviceMeasureItemDataCesiumAtom.java index 3770b70..e3868e1 100644 --- a/casic-metering-model/src/main/java/com/casic/missiles/model/business/BizBusinessDeviceMeasureItemDataCesiumAtom.java +++ b/casic-metering-model/src/main/java/com/casic/missiles/model/business/BizBusinessDeviceMeasureItemDataCesiumAtom.java @@ -101,7 +101,7 @@ private String technicalIndex; public String getTechnicalIndex() { - if (!StringUtils.isEmpty(technicalIndex)) { + if (!StringUtils.isBlank(technicalIndex) && !"/".equals(technicalIndex)) { //将bigDecimal转为科学计数法，String.format转换方式，bigDecimal.toString()和bigDecimal.toPlainString()不生效 if (technicalIndex.contains("±")) { int scale = new BigDecimal(technicalIndex.replace("±", "")).scale(); diff --git a/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java b/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java index 5b27e73..172f687 100644 --- a/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java +++ b/casic-metering-common/src/main/java/com/casic/missiles/utils/MeasureInfoFormulaCalculateUtil.java @@ -917,7 +917,10 @@ //电流表示值误差（间接测量）需计算标准值 if ("5".equals(measureData.getDataType())) { //标准值 = 标准电压值/标准电阻值 - BigDecimal standardValue = new BigDecimal(measureData.getStandardVoltageValue()).divide(new BigDecimal(measureData.getStandardResistanceValue()), 4, RoundingMode.HALF_UP); + //单位转换 + BigDecimal resistance = UnitConvertUtil.resistanceConvert(measureData.getStandardResistanceValue(), measureData.getStandardResistanceValueUnit(), "Ω"); + BigDecimal voltage = UnitConvertUtil.voltageConvert(measureData.getStandardVoltageValue(), measureData.getStandardVoltageValueUnit(), "V"); + BigDecimal standardValue = voltage.divide(resistance, 4, RoundingMode.HALF_UP); measureData.setStandardValue(String.valueOf(standardValue)); } @@ -1275,7 +1278,6 @@ String unit = measureData.getUnit(); if ("1".equals(measureData.getDataType())) { BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); //测量值1、测量值2、测量值3，根据单位保留小数位，单位和标称值单位相同 BigDecimal oneValue = UnitConvertUtil.valueDecimalConvert(unit, measureData.getOneValue()); BigDecimal twoValue = UnitConvertUtil.valueDecimalConvert(unit, measureData.getTwoValue()); @@ -1283,29 +1285,33 @@ measureData.setOneValue(String.valueOf(oneValue)); measureData.setTwoValue(String.valueOf(twoValue)); measureData.setThreeValue(String.valueOf(threeValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同测量值 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - lowerIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(lowerIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - upperIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(upperIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); //均值 = （测量值1+测量值2+测量值3）/ 3，保留小数规则同测量值 BigDecimal averageValue = (oneValue.add(twoValue).add(threeValue)).divide(BigDecimal.valueOf(3), 12, RoundingMode.HALF_UP); averageValue = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(averageValue)); measureData.setAverageValue(String.valueOf(averageValue)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标，保留小数规则同测量值 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + lowerIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(lowerIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + upperIndex = UnitConvertUtil.valueDecimalConvert(unit, String.valueOf(upperIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("2".equals(measureData.getDataType())) { //扫描宽度 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); //fl1、fr1、fl2、fr2、fl3、fr3 BigDecimal oneValue = new BigDecimal(measureData.getOneValue()).round(new MathContext(5, RoundingMode.HALF_UP)); BigDecimal twoValue = new BigDecimal(measureData.getTwoValue()).round(new MathContext(5, RoundingMode.HALF_UP)); @@ -1319,31 +1325,34 @@ measureData.setFourValue(String.valueOf(fourValue)); measureData.setFiveValue(String.valueOf(fiveValue)); measureData.setSixValue(String.valueOf(sixValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 - BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - BigDecimal lowerIndex = beforeLowerIndex.round(new MathContext(5, RoundingMode.HALF_UP)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - BigDecimal upperIndex = beforeUpperIndex.round(new MathContext(5, RoundingMode.HALF_UP)); - measureData.setUpperIndex(String.valueOf(upperIndex)); //均值 = ((fr1-fl1)+(fr2-fl2)+(fr3-fl3))*10/8/3 BigDecimal beforeAverageValue = (twoValue.subtract(oneValue).add(fourValue).subtract(threeValue).add(sixValue).subtract(fiveValue)) .multiply(BigDecimal.valueOf(10)).divide(BigDecimal.valueOf(8), 6, RoundingMode.HALF_UP).divide(BigDecimal.valueOf(3), 6, RoundingMode.HALF_UP); BigDecimal averageValue = beforeAverageValue.round(new MathContext(5, RoundingMode.HALF_UP)); measureData.setAverageValue(String.valueOf(averageValue)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 + BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + BigDecimal lowerIndex = beforeLowerIndex.round(new MathContext(5, RoundingMode.HALF_UP)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + BigDecimal upperIndex = beforeUpperIndex.round(new MathContext(5, RoundingMode.HALF_UP)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("3".equals(measureData.getDataType())) { //中频带宽 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndexLeft = measureData.getTechnicalIndexLeft(); - String technicalIndexRight = measureData.getTechnicalIndexRight(); if (StringUtils.isNotEmpty(measureData.getOneValue()) && StringUtils.isNotEmpty(measureData.getTwoValue()) && StringUtils.isNotEmpty(measureData.getThreeValue()) && StringUtils.isNotEmpty(measureData.getFourValue()) && StringUtils.isNotEmpty(measureData.getFiveValue()) && StringUtils.isNotEmpty(measureData.getSixValue())) { @@ -1367,20 +1376,26 @@ //均值 = (△f1+△f2+△f3)/3 BigDecimal averageValue = (eightValue.add(nineValue).add(tenValue)).divide(BigDecimal.valueOf(3), 2, RoundingMode.HALF_UP); measureData.setAverageValue(String.valueOf(averageValue)); - //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 - BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndexLeft)); - BigDecimal lowerIndex = beforeLowerIndex.setScale(2, RoundingMode.HALF_UP); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 - BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndexRight)); - BigDecimal upperIndex = beforeUpperIndex.setScale(2, RoundingMode.HALF_UP); - measureData.setUpperIndex(String.valueOf(upperIndex)); - //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* - if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndexLeft()) || "/".equals(measureData.getTechnicalIndexRight())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndexLeft = measureData.getTechnicalIndexLeft(); + String technicalIndexRight = measureData.getTechnicalIndexRight(); + //指标下限 = 标称值 - 技术指标，保留小数规则同fl1 + BigDecimal beforeLowerIndex = nominalValue.subtract(new BigDecimal(technicalIndexLeft)); + BigDecimal lowerIndex = beforeLowerIndex.setScale(2, RoundingMode.HALF_UP); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标，保留小数规则同测量值 + BigDecimal beforeUpperIndex = nominalValue.add(new BigDecimal(technicalIndexRight)); + BigDecimal upperIndex = beforeUpperIndex.setScale(2, RoundingMode.HALF_UP); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，均值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将均值字段（参与比较字段）标* + if (averageValue.compareTo(upperIndex) > 0 || averageValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("4".equals(measureData.getDataType())) { //中频带宽转换偏差 @@ -1391,13 +1406,17 @@ BigDecimal convertDeviation = new BigDecimal(measureData.getOneValue()).subtract(new BigDecimal(referValue)); measureData.setConvertDeviation(String.valueOf(convertDeviation)); //结论，转换偏差是否在转换偏差下限、转换偏差上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将转换偏差字段（参与比较字段）标* - BigDecimal upperConvertDeviation = new BigDecimal(measureData.getUpperConvertDeviation()); - BigDecimal lowerConvertDeviation = new BigDecimal(measureData.getLowerConvertDeviation()); - if (convertDeviation.compareTo(upperConvertDeviation) > 0 || convertDeviation.compareTo(lowerConvertDeviation) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperConvertDeviation()) || "/".equals(measureData.getLowerConvertDeviation())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperConvertDeviation = new BigDecimal(measureData.getUpperConvertDeviation()); + BigDecimal lowerConvertDeviation = new BigDecimal(measureData.getLowerConvertDeviation()); + if (convertDeviation.compareTo(upperConvertDeviation) > 0 || convertDeviation.compareTo(lowerConvertDeviation) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("5".equals(measureData.getDataType())) { @@ -1412,18 +1431,22 @@ measureData.setOneValue(String.valueOf(oneValue)); //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); - //指标下限 = 标称值 - 技术指标 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); - if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("6".equals(measureData.getDataType())) { @@ -1434,13 +1457,7 @@ BigDecimal firstAttenuatorAttenuation = new BigDecimal(firstData.getStandardAttenuatorAttenuation()); BigDecimal firstSourceAmplitude = new BigDecimal(firstData.getSignalSourceAmplitude()); BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); - //指标下限 = 标称值 - 技术指标 - BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值 + 技术指标 - BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); - measureData.setUpperIndex(String.valueOf(upperIndex)); + //测量值 = 标准衰减器衰减量(当次测量)-标准衰减器衰减量(上一次测量)+(信号源幅度(当次测量)-信号源幅度（上一次测量）).后面带单位，与标称值单位相同 BigDecimal attenuatorAttenuation = new BigDecimal(measureData.getStandardAttenuatorAttenuation()); BigDecimal sourceAmplitude = new BigDecimal(measureData.getSignalSourceAmplitude()); @@ -1458,12 +1475,23 @@ value = attenuatorAttenuation.subtract(preAttenuatorAttenuation).add(sourceAmplitude).subtract(preSourceAmplitude); } measureData.setOneValue(String.valueOf(value)); - //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* - if (value.compareTo(upperIndex) > 0 || value.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String technicalIndex = measureData.getTechnicalIndex().replace("±", ""); + //指标下限 = 标称值 - 技术指标 + BigDecimal lowerIndex = nominalValue.subtract(new BigDecimal(technicalIndex)); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值 + 技术指标 + BigDecimal upperIndex = nominalValue.add(new BigDecimal(technicalIndex)); + measureData.setUpperIndex(String.valueOf(upperIndex)); + //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* + if (value.compareTo(upperIndex) > 0 || value.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("7".equals(measureData.getDataType())) { @@ -1481,13 +1509,17 @@ BigDecimal inputFrequency = new BigDecimal(firstAverage).subtract(averageValue); measureData.setInputFrequency(String.valueOf(inputFrequency)); //结论，输入频响是否在输入频响上限、下限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将输入频响字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); - if (inputFrequency.compareTo(upperIndex) > 0 || inputFrequency.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex()) || "/".equals(measureData.getLowerIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); + if (inputFrequency.compareTo(upperIndex) > 0 || inputFrequency.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("8".equals(measureData.getDataType())) { @@ -1502,12 +1534,16 @@ measureData.setRevisedResult(String.valueOf(value)); } //结论，修正后结果小于指标上限，如是，则“符合指标”，如不是则"不符合指标"，并将修正后结果字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - if (revisedResult.compareTo(upperIndex) > 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + if (revisedResult.compareTo(upperIndex) > 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("9".equals(measureData.getDataType())) { //谐波失真 @@ -1527,15 +1563,28 @@ //结论，二/三/四谐波失真是否小于二/三/四谐波失真指标上限，如是，则“符合指标”，如不是则"不符合指标"，并将二/三/四谐波失真字段（参与比较字段）标* //如果三次谐波失真、四次谐波失真未配置，结论处不参与计算 if (StringUtils.isNotEmpty(measureData.getFiveValue()) && StringUtils.isNotEmpty(measureData.getSevenValue())) { - BigDecimal upperIndexTwice = new BigDecimal(measureData.getUpperIndexTwice()); - BigDecimal upperIndexThrice = new BigDecimal(measureData.getUpperIndexThrice()); - BigDecimal upperIndexQuartic = new BigDecimal(measureData.getUpperIndexQuartic()); BigDecimal fiveValue = new BigDecimal(measureData.getFiveValue()); BigDecimal sevenValue = new BigDecimal(measureData.getSevenValue()); - if (threeValue.compareTo(upperIndexTwice) > 0 || fiveValue.compareTo(upperIndexThrice) > 0 || sevenValue.compareTo(upperIndexQuartic) > 0) { + if ("/".equals(measureData.getUpperIndexTwice())) { + measureData.setConclusion("/"); + } else { + BigDecimal upperIndexTwice = new BigDecimal(measureData.getUpperIndexTwice()); if (threeValue.compareTo(upperIndexTwice) > 0) measureData.setExceedMark(1); + } + if ("/".equals(measureData.getUpperIndexThrice())) { + measureData.setConclusion("/"); + } else { + + BigDecimal upperIndexThrice = new BigDecimal(measureData.getUpperIndexThrice()); if (fiveValue.compareTo(upperIndexThrice) > 0) measureData.setExceedMarkOne(1); + } + if ("/".equals(measureData.getUpperIndexQuartic())) { + measureData.setConclusion("/"); + } else { + BigDecimal upperIndexQuartic = new BigDecimal(measureData.getUpperIndexQuartic()); if (sevenValue.compareTo(upperIndexQuartic) > 0) measureData.setExceedMarkTwo(1); + } + if (measureData.getExceedMark() == 1 && measureData.getExceedMarkOne() == 1 || measureData.getExceedMarkTwo() == 1) { measureData.setConclusion("不符合指标"); } else { measureData.setConclusion("符合指标"); @@ -1553,13 +1602,17 @@ BigDecimal inputAttenuatorConversionEffect = oneValue.subtract(new BigDecimal(firstValue)).subtract((attenuatorAttenuation.subtract(new BigDecimal(firstAttenuatorAttenuation)))); measureData.setInputAttenuatorConversionEffect(String.valueOf(inputAttenuatorConversionEffect)); //结论，输入衰减器转换影响是否在下限、上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将输入衰减器转换影响字段（参与比较字段）标* - BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); - BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); - if (inputAttenuatorConversionEffect.compareTo(upperIndex) > 0 || inputAttenuatorConversionEffect.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getUpperIndex()) || "/".equals(measureData.getLowerIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + BigDecimal upperIndex = new BigDecimal(measureData.getUpperIndex()); + BigDecimal lowerIndex = new BigDecimal(measureData.getLowerIndex()); + if (inputAttenuatorConversionEffect.compareTo(upperIndex) > 0 || inputAttenuatorConversionEffect.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } } else if ("11".equals(measureData.getDataType())) { @@ -1570,26 +1623,22 @@ BigDecimal gainCompression = oneValue.subtract(inputAttenuator); measureData.setGainCompression(String.valueOf(gainCompression)); //结论，增益压缩是否在技术指标范围内，如是，则“符合指标”，如不是则"不符合指标"，并将增益压缩字段（参与比较字段）标* - String symbol = measureData.getTechnicalIndex().substring(0, 1); - String technicalIndex = measureData.getTechnicalIndex().substring(1); - int exceedMark = judgeSymbol(symbol, String.valueOf(gainCompression), new BigDecimal(technicalIndex)); - if (1 == exceedMark) { - measureData.setExceedMark(1); - measureData.setConclusion("不符合指标"); + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); } else { - measureData.setConclusion("符合指标"); + String symbol = measureData.getTechnicalIndex().substring(0, 1); + String technicalIndex = measureData.getTechnicalIndex().substring(1); + int exceedMark = judgeSymbol(symbol, String.valueOf(gainCompression), new BigDecimal(technicalIndex)); + if (1 == exceedMark) { + measureData.setExceedMark(1); + measureData.setConclusion("不符合指标"); + } else { + measureData.setConclusion("符合指标"); + } } } else if ("12".equals(measureData.getDataType())) { //校准信号 BigDecimal nominalValue = new BigDecimal(measureData.getNominalValue()); - String beforeTechnicalIndex = measureData.getTechnicalIndex().replace("±", ""); - BigDecimal technicalIndex = new BigDecimal(beforeTechnicalIndex); - //指标下限 = 标称值-输入项配置（技术指标配置数值） - BigDecimal lowerIndex = nominalValue.subtract(technicalIndex); - measureData.setLowerIndex(String.valueOf(lowerIndex)); - //指标上限 = 标称值+输入项配置（技术指标配置数值） - BigDecimal upperIndex = nominalValue.add(technicalIndex); - measureData.setUpperIndex(String.valueOf(upperIndex)); //测量结果 = 如果类型为频率，手工编辑输入值，需要补充单位，单位与标称值单位相同；如果类型为幅度，根据公式计算，公式：前三次测量值的和/3 if ("幅度".equals(measureData.getTypeValue())) { BigDecimal oneValue = new BigDecimal(measureData.getOneValue()); @@ -1600,22 +1649,34 @@ measureData.setMeasureResultUnit(measureData.getUnit()); //结论，测量值是否在指标下限、指标上限范围内，如是，则“符合指标”，如不是则"不符合指标"，并将测量值字段（参与比较字段）标* String conclusion = ""; - if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMark(1); - conclusion = "不符合指标"; + if ("/".equals(measureData.getTechnicalIndex())) { + measureData.setConclusion("/"); + } else { + String beforeTechnicalIndex = measureData.getTechnicalIndex().replace("±", ""); + BigDecimal technicalIndex = new BigDecimal(beforeTechnicalIndex); + //指标下限 = 标称值-输入项配置（技术指标配置数值） + BigDecimal lowerIndex = nominalValue.subtract(technicalIndex); + measureData.setLowerIndex(String.valueOf(lowerIndex)); + //指标上限 = 标称值+输入项配置（技术指标配置数值） + BigDecimal upperIndex = nominalValue.add(technicalIndex); + measureData.setUpperIndex(String.valueOf(upperIndex)); + if (oneValue.compareTo(upperIndex) > 0 || oneValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMark(1); + conclusion = "不符合指标"; + } + if (twoValue.compareTo(upperIndex) > 0 || twoValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMarkOne(1); + conclusion = "不符合指标"; + } + if (threeValue.compareTo(upperIndex) > 0 || threeValue.compareTo(lowerIndex) < 0) { + measureData.setExceedMarkTwo(1); + conclusion = "不符合指标"; + } + if (StringUtils.isBlank(conclusion)) { + conclusion = "符合指标"; + } + measureData.setConclusion(conclusion); } - if (twoValue.compareTo(upperIndex) > 0 || twoValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMarkOne(1); - conclusion = "不符合指标"; - } - if (threeValue.compareTo(upperIndex) > 0 || threeValue.compareTo(lowerIndex) < 0) { - measureData.setExceedMarkTwo(1); - conclusion = "不符合指标"; - } - if (StringUtils.isBlank(conclusion)) { - conclusion = "符合指标"; - } - measureData.setConclusion(conclusion); } else { measureData.setConclusion("/"); } @@ -1671,7 +1732,8 @@ BigDecimal aConvertQualityCorrectValue = new BigDecimal(measureData.getAConvertQualityCorrectValue()); BigDecimal bNominalQualityValue = new BigDecimal(measureData.getBNominalQualityValue()).multiply(BigDecimal.valueOf(100)); BigDecimal bConvertQualityCorrectValue = new BigDecimal(measureData.getBConvertQualityCorrectValue()); - BigDecimal deltaMThrow = deltaM.add(aNominalQualityValue.add(aConvertQualityCorrectValue)).add(bNominalQualityValue.add(bConvertQualityCorrectValue)); + BigDecimal deltaMThrowBefore = deltaM.add(aNominalQualityValue.add(aConvertQualityCorrectValue)).add(bNominalQualityValue.add(bConvertQualityCorrectValue)); + BigDecimal deltaMThrow = deltaMThrowBefore.divide(BigDecimal.valueOf(2), RoundingMode.HALF_UP); if (StringUtils.isNotEmpty(measureData.getPtOne())) { ptOneDeltaMThrowMap.put(deltaMThrow, measureData.getMeasureSequence()); } else if (StringUtils.isNotEmpty(measureData.getPtTwo())) { diff --git a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml index d557ffb..7c14299 100644 --- a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml +++ b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureApprovalMapper.xml @@ -32,10 +32,12 @@ SELECT bbdma.*, eei.equipment_no AS sampleNo, eei.equipment_name AS sampleName, eei.model AS model, eei.manufacture_no AS manufactureNo, bbdmi.measure_category AS measureCategory, bbdmi.create_user_name AS staffName, bbdmi.trace_date AS traceDate, bbdmi.manufacturer AS manufacturer, bbdmi.conclusion AS conclusion, bbdmi.restriction_instruction AS restrictionInstruction, - bbdmi.measure_address AS measureAddress, bbdmi.data_no AS measureDataNo, bbdmi.measure_valid_date, bbdmi.meter_identify, bbdmi.measure_valid_date + bbdmi.measure_address AS measureAddress, bbdmi.data_no AS measureDataNo, bbdmi.measure_valid_date, bbdmi.meter_identify, bbdmi.measure_valid_date, + bbdmii.belong_standard_equipment, bbdmii.item_category_id, bbdmii.item_category_name FROM biz_business_device_measure_approval bbdma JOIN eqpt_equipment_info eei ON bbdma.sample_id = eei.id JOIN biz_business_device_measure_info bbdmi ON bbdma.data_id = bbdmi.id + JOIN biz_business_device_measure_item_info bbdmii ON bbdmii.id = bbdmi.item_id WHERE 1=1 and bbdma.approval_status = #{request.approvalStatus} diff --git a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureDataPistonGaugeMapper.xml b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureDataPistonGaugeMapper.xml index fcdf1c3..eed7806 100644 --- a/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureDataPistonGaugeMapper.xml +++ b/casic-metering-dao/src/main/resources/mapper/business/BizBusinessDeviceMeasureDataPistonGaugeMapper.xml @@ -36,6 +36,7 @@ + @@ -69,7 +70,7 @@ after_friction_reverse_stroke, variation_forward_stroke, variation_reverse_stroke, theoretical_output_value, first_forward_stroke, first_reverse_stroke, second_forward_stroke, second_reverse_stroke, third_forward_stroke, third_reverse_stroke, indicating_error, return_error, average_forward_stroke, average_reverse_stroke, average_value, average_return_error, forward_stroke_switch_value, - reverse_stroke_switch_value, point_deviation, different_gap,create_time, update_time, item, max_indicating_error, max_friction_error, + reverse_stroke_switch_value, point_deviation, different_gap,create_time, update_time, item, friction_error, max_indicating_error, max_friction_error, max_return_error, max_point_deviation, allow_point_deviation, max_different_gap, allow_different_gap, zero_drift_one, zero_drift_two, zero_drift_three, zero_drift_four, zero_drift_five, intercept_a, slope_b, sensitivity_b, repeatability_r, linear_l, hysteresis_h, basic_error_a, periodic_stability_s_b, range_lower, range_upper, return_error_lower, friction_error_lower, indicating_error_lower diff --git a/casic-metering-dao/src/main/resources/mapper/equipment/BizEquipmentStandardCheckRecordApprovalMapper.xml b/casic-metering-dao/src/main/resources/mapper/equipment/BizEquipmentStandardCheckRecordApprovalMapper.xml index ecae416..4d0f3de 100644 --- a/casic-metering-dao/src/main/resources/mapper/equipment/BizEquipmentStandardCheckRecordApprovalMapper.xml +++ b/casic-metering-dao/src/main/resources/mapper/equipment/BizEquipmentStandardCheckRecordApprovalMapper.xml @@ -26,14 +26,16 @@