diff --git a/detection/src/main/java/com/njcn/gather/result/service/impl/ResultServiceImpl.java b/detection/src/main/java/com/njcn/gather/result/service/impl/ResultServiceImpl.java
index da259608..2ef06c36 100644
--- a/detection/src/main/java/com/njcn/gather/result/service/impl/ResultServiceImpl.java
+++ b/detection/src/main/java/com/njcn/gather/result/service/impl/ResultServiceImpl.java
@@ -227,6 +227,10 @@ public class ResultServiceImpl implements IResultService {
         subName.put("Freq", "频率变化对XX测量的影响");
         subName.put("Harm", "谐波对XX测量的影响");
         subName.put("Single", "单影响量下XX准确度测试");
+        subName.put("Many", "多影响量下XX准确度测试");
+        subName.put("Many-Vol-Harm-InHarm", "电压和谐波和间谐波对XX的影响");
+        subName.put("Many-IMBV-Harm-InHarm", "三项电压不平衡和谐波和间谐波对XX的影响");
+        subName.put("Many-Freq-Harm-InHarm", "频率和谐波和间谐波对XX的影响");
         Boolean isValueType = scriptMapper.selectScriptIsValueType(param.getScriptId());
 
         List<TreeDataVO> infoVOS = new ArrayList<>();
@@ -282,7 +286,7 @@ public class ResultServiceImpl implements IResultService {
                 //单影响量下频率准确度测试
                 LinkedHashMap<String, List<PqScriptDtls>> subSingleTypeMap = value.stream()
                         .sorted(Comparator.comparing(PqScriptDtls::getScriptIndex))
-                        .filter(x -> !"Base".equals(x.getScriptSubType()))
+                        .filter(x -> !"Base".equals(x.getScriptSubType()) && !x.getScriptSubType().contains("Many"))
                         .collect(Collectors.groupingBy(PqScriptDtls::getScriptSubType, LinkedHashMap::new, Collectors.toList()));
                 if (CollUtil.isNotEmpty(subSingleTypeMap)) {
                     TreeDataVO subType = new TreeDataVO();
@@ -329,6 +333,56 @@ public class ResultServiceImpl implements IResultService {
                         scriptSubList.add(subType);
                     }
                 }
+                //多影响量下xx
+                LinkedHashMap<String, List<PqScriptDtls>> subManyTypeMap = value.stream()
+                        .sorted(Comparator.comparing(PqScriptDtls::getScriptIndex))
+                        .filter(x -> x.getScriptSubType().contains("Many"))
+                        .collect(Collectors.groupingBy(PqScriptDtls::getScriptSubType, LinkedHashMap::new, Collectors.toList()));
+                if (CollUtil.isNotEmpty(subManyTypeMap)) {
+                    TreeDataVO subType = new TreeDataVO();
+                    subType.setScriptTypeName(!subName.containsKey("Many") ? "" : subName.get("Many").replace("XX", dictTree.getName()));
+                    subType.setScriptTypeCode(dictTree.getCode());
+                    //多影响量下xx准测量集合
+                    List<TreeDataVO> subSingleList = new ArrayList<>();
+                    subManyTypeMap.forEach((subKey, subValue) -> {
+                        TreeDataVO treeDataVO = new TreeDataVO();
+                        treeDataVO.setScriptTypeName(!subName.containsKey(subKey) ? "" : subName.get(subKey).replace("XX", dictTree.getName()));
+                        treeDataVO.setScriptTypeCode(subKey);
+                        List<TreeDataVO> subTypeList = new ArrayList<>();
+
+                        LinkedHashMap<Integer, List<PqScriptDtls>> indexMap = subValue.stream()
+                                .sorted(Comparator.comparing(PqScriptDtls::getScriptIndex))
+                                .collect(Collectors.groupingBy(PqScriptDtls::getScriptIndex, LinkedHashMap::new, Collectors.toList()));
+                        indexMap.forEach((index, scriptDtlIndexList) -> {
+                            TreeDataVO dtlType = new TreeDataVO();
+                            dtlType.setIndex(index);
+                            dtlType.setScriptType(scriptDtlIndexList.get(0).getScriptType());
+                            dtlType.setScriptTypeCode(subKey);
+                            if ("Many-Vol-Harm-InHarm".equals(subKey)) {
+                                volAndharmAndInHarmScriptTypeName(scriptDtlIndexList, dictTree, isValueType, dtlType);
+                            }
+                            if ("Many-IMBV-Harm-InHarm".equals(subKey)) {
+                                imbvAndHarmAndInHarmScriptTypeName(scriptDtlIndexList, dictTree, isValueType, dtlType);
+                            }
+                            if ("Many-Vol-Harm-InHarm".equals(subKey)) {
+                                volAndHarmAndInHarmScriptTypeName(scriptDtlIndexList, dictTree, isValueType, dtlType);
+                            }
+                            dtlType.setSourceDesc(ScriptDtlsDesc.getStringBuffer(scriptDtlIndexList, false, isValueType).toString());
+                            if (finalResultMap.containsKey(index)) {
+                                dtlType.setFly(conform(finalResultMap.get(index)));
+                            }
+                            subTypeList.add(dtlType);
+                        });
+                        if (CollUtil.isNotEmpty(subTypeList)) {
+                            treeDataVO.setChildren(subTypeList);
+                            subSingleList.add(treeDataVO);
+                        }
+                    });
+                    if (CollUtil.isNotEmpty(subSingleList)) {
+                        subType.setChildren(subSingleList);
+                        scriptSubList.add(subType);
+                    }
+                }
                 if (CollUtil.isNotEmpty(scriptSubList)) {
                     infoVO.setChildren(scriptSubList);
                     infoVOS.add(infoVO);
@@ -867,6 +921,246 @@ public class ResultServiceImpl implements IResultService {
         }
     }
 
+    private void volAndharmAndInHarmScriptTypeName(List<PqScriptDtls> dtls, DictTree dictTree, Boolean isValueType, TreeDataVO dtlType) {
+        ResultUnitEnum resultUnitEnumByCode = ResultUnitEnum.getResultUnitEnumByCode(dictTree.getCode());
+        List<PqScriptDtls> f = dtls.stream().filter(x -> "Freq".equals(x.getValueType())).collect(Collectors.toList());
+        String unit;
+        if (isValueType) {
+            unit = ResultUnitEnum.V_RELATIVE.getUnit();
+        } else {
+            unit = ResultUnitEnum.V_ABSOLUTELY.getUnit();
+        }
+        List<PqScriptDtls> v = dtls.stream().filter(x -> "VOL".equals(x.getValueType())).collect(Collectors.toList());
+        switch (resultUnitEnumByCode) {
+            /**
+             * 频率
+             */
+            case FREQ:
+                dtlType.setScriptTypeName("电压：" + v.get(0).getValue() + unit + "，叠加多次谐波和间谐波对" + dictTree.getName() + "=" + f.get(0).getValue() + ResultUnitEnum.FREQ.getUnit() + "的影响");
+                break;
+            /**
+             * 电压
+             */
+            case V_RELATIVE:
+            case V_ABSOLUTELY:
+                break;
+            /**
+             * 电流
+             */
+            case I_RELATIVE:
+            case I_ABSOLUTELY:
+                break;
+            /**
+             * 谐波电压
+             */
+            case HV:
+                break;
+            /**
+             * 谐波电流
+             */
+            case HI:
+                break;
+            /**
+             * 间谐波电压
+             */
+            case HSV:
+                break;
+            /**
+             * 间谐波电流
+             */
+            case HSI:
+                break;
+            /**
+             * 三相电压不平衡度
+             */
+            case IMBV:
+                break;
+            /**
+             * 三相电流不平衡度
+             */
+            case IMBA:
+                break;
+            /**
+             * 谐波有功功率
+             */
+            case HP:
+                break;
+            /**
+             * 闪变
+             */
+            case F:
+                break;
+            /**
+             * 暂态
+             */
+            case VOLTAGE_MAG:
+            case VOLTAGE_DUR:
+                break;
+            default:
+                break;
+        }
+    }
+
+    private void imbvAndHarmAndInHarmScriptTypeName(List<PqScriptDtls> dtls, DictTree dictTree, Boolean isValueType, TreeDataVO dtlType) {
+        ResultUnitEnum resultUnitEnumByCode = ResultUnitEnum.getResultUnitEnumByCode(dictTree.getCode());
+        List<PqScriptDtls> f = dtls.stream().filter(x -> "Freq".equals(x.getValueType())).collect(Collectors.toList());
+        switch (resultUnitEnumByCode) {
+            /**
+             * 频率
+             */
+            case FREQ:
+                dtlType.setScriptTypeName("三项电压不平衡和叠加多次谐波和间谐波对" + dictTree.getName() + "=" + f.get(0).getValue() + ResultUnitEnum.FREQ.getUnit() + "的影响");
+                break;
+            /**
+             * 电压
+             */
+            case V_RELATIVE:
+            case V_ABSOLUTELY:
+                String unit;
+                if (isValueType) {
+                    unit = ResultUnitEnum.V_RELATIVE.getUnit();
+                } else {
+                    unit = ResultUnitEnum.V_ABSOLUTELY.getUnit();
+                }
+                List<PqScriptDtls> v = dtls.stream().filter(x -> "VOL".equals(x.getValueType())).collect(Collectors.toList());
+                dtlType.setScriptTypeName("三项电压不平衡和叠加多次谐波和间谐波对" + dictTree.getName() + "=" + v.get(0).getValue() + unit + "的影响");
+                break;
+            /**
+             * 电流
+             */
+            case I_RELATIVE:
+            case I_ABSOLUTELY:
+                break;
+            /**
+             * 谐波电压
+             */
+            case HV:
+                break;
+            /**
+             * 谐波电流
+             */
+            case HI:
+                break;
+            /**
+             * 间谐波电压
+             */
+            case HSV:
+                break;
+            /**
+             * 间谐波电流
+             */
+            case HSI:
+                break;
+            /**
+             * 三相电压不平衡度
+             */
+            case IMBV:
+                break;
+            /**
+             * 三相电流不平衡度
+             */
+            case IMBA:
+                break;
+            /**
+             * 谐波有功功率
+             */
+            case HP:
+                break;
+            /**
+             * 闪变
+             */
+            case F:
+                break;
+            /**
+             * 暂态
+             */
+            case VOLTAGE_MAG:
+            case VOLTAGE_DUR:
+                break;
+            default:
+                break;
+        }
+    }
+
+    private void volAndHarmAndInHarmScriptTypeName(List<PqScriptDtls> dtls, DictTree dictTree, Boolean isValueType, TreeDataVO dtlType) {
+        ResultUnitEnum resultUnitEnumByCode = ResultUnitEnum.getResultUnitEnumByCode(dictTree.getCode());
+        switch (resultUnitEnumByCode) {
+            /**
+             * 频率
+             */
+            case FREQ:
+                break;
+            /**
+             * 电压
+             */
+            case V_RELATIVE:
+            case V_ABSOLUTELY:
+                String unit;
+                if (isValueType) {
+                    unit = ResultUnitEnum.V_RELATIVE.getUnit();
+                } else {
+                    unit = ResultUnitEnum.V_ABSOLUTELY.getUnit();
+                }
+                List<PqScriptDtls> v = dtls.stream().filter(x -> "VOL".equals(x.getValueType())).collect(Collectors.toList());
+                List<PqScriptDtls> f = dtls.stream().filter(x -> "Freq".equals(x.getValueType())).collect(Collectors.toList());
+                dtlType.setScriptTypeName("频率：" + f.get(0).getValue() + ResultUnitEnum.FREQ.getUnit() + "，叠加多次谐波和间谐波对" + dictTree.getName() + "=" + v.get(0).getValue() + unit + "的影响");
+                break;
+            /**
+             * 电流
+             */
+            case I_RELATIVE:
+            case I_ABSOLUTELY:
+                break;
+            /**
+             * 谐波电压
+             */
+            case HV:
+                break;
+            /**
+             * 谐波电流
+             */
+            case HI:
+                break;
+            /**
+             * 间谐波电压
+             */
+            case HSV:
+                break;
+            /**
+             * 间谐波电流
+             */
+            case HSI:
+                break;
+            /**
+             * 三相电压不平衡度
+             */
+            case IMBV:
+                break;
+            /**
+             * 三相电流不平衡度
+             */
+            case IMBA:
+                break;
+            /**
+             * 谐波有功功率
+             */
+            case HP:
+                break;
+            /**
+             * 闪变
+             */
+            case F:
+                break;
+            /**
+             * 暂态
+             */
+            case VOLTAGE_MAG:
+            case VOLTAGE_DUR:
+                break;
+            default:
+                break;
+        }
+    }
 
     @Override
     public ResultVO resultData(ResultParam param) {
diff --git a/detection/src/main/java/com/njcn/gather/script/service/impl/PqScriptDtlsServiceImpl.java b/detection/src/main/java/com/njcn/gather/script/service/impl/PqScriptDtlsServiceImpl.java
index d877ff2e..340a291a 100644
--- a/detection/src/main/java/com/njcn/gather/script/service/impl/PqScriptDtlsServiceImpl.java
+++ b/detection/src/main/java/com/njcn/gather/script/service/impl/PqScriptDtlsServiceImpl.java
@@ -848,6 +848,7 @@ public class PqScriptDtlsServiceImpl extends ServiceImpl<PqScriptDtlsMapper, PqS
                     if (flyDeltaV) {
                         checkData.setValue(0.0);
                     } else {
+                        // 在这里重新根据谐波、间谐波含有率计算新的幅值
                         checkData.setValue(listDTO.getFAmp());
                     }
                 }