diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitProbabilityVO.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitProbabilityVO.java
index ef702dc4c..ea7c687a4 100644
--- a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitProbabilityVO.java
+++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitProbabilityVO.java
@@ -17,8 +17,6 @@ public class LimitProbabilityVO {
     private String indexName;
     @ApiModelProperty("指标编码")
     private String indexCode;
-    @ApiModelProperty("占比")
-    private double proportion;
     @ApiModelProperty("越限程度档级对应次数")
     private List<Map<Integer, Integer>> extentGrades;
 }
diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/TotalLimitStatisticsDetailsVO.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/TotalLimitStatisticsDetailsVO.java
index a615cd2b1..82ad347c7 100644
--- a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/TotalLimitStatisticsDetailsVO.java
+++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/TotalLimitStatisticsDetailsVO.java
@@ -1,9 +1,207 @@
 package com.njcn.harmonic.pojo.vo;
 
+import com.fasterxml.jackson.annotation.JsonFormat;
+import io.swagger.annotations.ApiModelProperty;
 import lombok.Data;
-import lombok.EqualsAndHashCode;
 
-@EqualsAndHashCode(callSuper = true)
+import java.time.LocalDate;
+
 @Data
-public class TotalLimitStatisticsDetailsVO extends MainLineStatLimitRateDetailsVO {
+public class TotalLimitStatisticsDetailsVO {
+    @ApiModelProperty("监测点名称")
+    private String lineName;
+
+    @ApiModelProperty(value = "监测点ID合格率的变电站/装置/母线/线路序号")
+    private String lineId;
+
+    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
+    @ApiModelProperty(value = "合格率时间")
+    private LocalDate time;
+
+    @ApiModelProperty(value = "总计算次数")
+    private Integer allTime;
+
+    @ApiModelProperty(value = "闪变越限次数")
+    private Integer flickerOvertime;
+
+
+    @ApiModelProperty(value = "频率偏差越限")
+    private double freqDevOvertime;
+
+    @ApiModelProperty(value = "电压偏差越限")
+    private double voltageDevOvertime;
+
+    @ApiModelProperty(value = "三相电压不平衡度越限")
+    private double ubalanceOvertime;
+
+    @ApiModelProperty(value = "电压谐波畸变率越限")
+    private double uaberranceOvertime;
+
+    @ApiModelProperty(value = "负序电流限值")
+    private double iNegOvertime;
+
+    @ApiModelProperty(value = "2次电压谐波含有率越限")
+    private double uharm2Overtime;
+
+    @ApiModelProperty(value = "3次电压谐波含有率越限")
+    private double uharm3Overtime;
+
+    @ApiModelProperty(value = "4次电压谐波含有率越限")
+    private double uharm4Overtime;
+
+    @ApiModelProperty(value = "5次电压谐波含有率越限")
+    private double uharm5Overtime;
+
+    @ApiModelProperty(value = "6次电压谐波含有率越限")
+    private double uharm6Overtime;
+
+    @ApiModelProperty(value = "7次电压谐波含有率越限")
+    private double uharm7Overtime;
+
+    @ApiModelProperty(value = "8次电压谐波含有率越限")
+    private double uharm8Overtime;
+
+    @ApiModelProperty(value = "9次电压谐波含有率越限")
+    private double uharm9Overtime;
+
+    @ApiModelProperty(value = "10次电压谐波含有率越限")
+    private double uharm10Overtime;
+
+    @ApiModelProperty(value = "11次电压谐波含有率越限")
+    private double uharm11Overtime;
+
+    @ApiModelProperty(value = "12次电压谐波含有率越限")
+    private double uharm12Overtime;
+
+    @ApiModelProperty(value = "13次电压谐波含有率越限")
+    private double uharm13Overtime;
+
+    @ApiModelProperty(value = "14次电压谐波含有率越限")
+    private double uharm14Overtime;
+
+    @ApiModelProperty(value = "15次电压谐波含有率越限")
+    private double uharm15Overtime;
+
+    @ApiModelProperty(value = "16次电压谐波含有率越限")
+    private double uharm16Overtime;
+
+    @ApiModelProperty(value = "17次电压谐波含有率越限")
+    private double uharm17Overtime;
+
+
+    @ApiModelProperty(value = "18次电压谐波含有率越限")
+    private double uharm18Overtime;
+
+
+    @ApiModelProperty(value = "19次电压谐波含有率越限")
+    private double uharm19Overtime;
+
+
+    @ApiModelProperty(value = "20次电压谐波含有率越限")
+    private double uharm20Overtime;
+
+
+    @ApiModelProperty(value = "21次电压谐波含有率越限")
+    private double uharm21Overtime;
+
+    @ApiModelProperty(value = "22次电压谐波含有率越限")
+    private double uharm22Overtime;
+
+
+    @ApiModelProperty(value = "23次电压谐波含有率越限")
+    private double uharm23Overtime;
+
+    @ApiModelProperty(value = "24次电压谐波含有率越限")
+    private double uharm24Overtime;
+
+    @ApiModelProperty(value = "25次电压谐波含有率越限")
+    private double uharm25Overtime;
+
+    @ApiModelProperty(value = "2次电流谐波幅值越限")
+    private double iharm2Overtime;
+
+    @ApiModelProperty(value = "3次电流谐波幅值越限")
+    private double iharm3Overtime;
+
+    @ApiModelProperty(value = "4次电流谐波幅值越限")
+    private double iharm4Overtime;
+
+
+    @ApiModelProperty(value = "5次电流谐波幅值越限")
+    private double iharm5Overtime;
+
+
+    @ApiModelProperty(value = "6次电流谐波幅值越限")
+    private double iharm6Overtime;
+
+    @ApiModelProperty(value = "7次电流谐波幅值越限")
+    private double iharm7Overtime;
+
+    @ApiModelProperty(value = "8次电流谐波幅值越限")
+    private double iharm8Overtime;
+
+    @ApiModelProperty(value = "9次电流谐波幅值越限")
+    private double iharm9Overtime;
+
+    @ApiModelProperty(value = "10次电流谐波幅值越限")
+    private double iharm10Overtime;
+
+
+    @ApiModelProperty(value = "11次电流谐波幅值越限")
+    private double iharm11Overtime;
+
+
+    @ApiModelProperty(value = "12次电流谐波幅值越限")
+    private double iharm12Overtime;
+
+
+    @ApiModelProperty(value = "13次电流谐波幅值越限")
+    private double iharm13Overtime;
+
+
+    @ApiModelProperty(value = "14次电流谐波幅值越限")
+    private double iharm14Overtime;
+
+
+    @ApiModelProperty(value = "15次电流谐波幅值越限")
+    private double iharm15Overtime;
+
+
+    @ApiModelProperty(value = "16次电流谐波幅值越限")
+    private double iharm16Overtime;
+
+
+    @ApiModelProperty(value = "17次电流谐波幅值越限")
+    private double iharm17Overtime;
+
+
+    @ApiModelProperty(value = "18次电流谐波幅值越限")
+    private double iharm18Overtime;
+
+
+    @ApiModelProperty(value = "19次电流谐波幅值越限")
+    private double iharm19Overtime;
+
+
+    @ApiModelProperty(value = "20次电流谐波幅值越限")
+    private double iharm20Overtime;
+
+
+    @ApiModelProperty(value = "21次电流谐波幅值越限")
+    private double iharm21Overtime;
+
+
+    @ApiModelProperty(value = "22次电流谐波幅值越限")
+    private double iharm22Overtime;
+
+
+    @ApiModelProperty(value = "23次电流谐波幅值越限")
+    private double iharm23Overtime;
+
+
+    @ApiModelProperty(value = "24次电流谐波幅值越限")
+    private double iharm24Overtime;
+
+    @ApiModelProperty(value = "25次电流谐波幅值越限")
+    private double iharm25Overtime;
 }
diff --git a/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/controller/RStatLimitRateDController.java b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/controller/RStatLimitRateDController.java
index 3b080a080..3afe0eb66 100644
--- a/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/controller/RStatLimitRateDController.java
+++ b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/controller/RStatLimitRateDController.java
@@ -135,4 +135,25 @@ public class RStatLimitRateDController extends BaseController {
         List<TotalLimitStatisticsDetailsVO> list = limitRateDService.totalLimitStatisticsDetails(param);
         return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe);
     }
+
+
+    @PostMapping("/gridSideLimitStatistics/data")
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @ApiOperation("电网侧指标越限统计数据")
+    public HttpResult<TotalLimitTotalStatisticsVO> gridSideLimitTotalStatisticsData(@RequestBody TotalLimitStatisticsParam mainLineQueryParam) {
+        String methodDescribe = getMethodDescribe("gridSideLimitTotalStatisticsData");
+        TotalLimitTotalStatisticsVO data = limitRateDService.gridSideLimitTotalStatisticsData(mainLineQueryParam);
+
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, data, methodDescribe);
+    }
+
+    @PostMapping("/gridSideLimitStatistics/list")
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @ApiOperation("电网侧指标越限统计列表")
+    public HttpResult<List<TotalLimitStatisticsVO>> gridSideLimitStatisticsList(@RequestBody TotalLimitStatisticsParam mainLineQueryParam) {
+        String methodDescribe = getMethodDescribe("gridSideLimitStatisticsList");
+        List<TotalLimitStatisticsVO> list = limitRateDService.gridSideLimitStatisticsList(mainLineQueryParam);
+
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe);
+    }
 }
diff --git a/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/IRStatLimitRateDService.java b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/IRStatLimitRateDService.java
index b246ff3d9..b2f4e4a55 100644
--- a/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/IRStatLimitRateDService.java
+++ b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/IRStatLimitRateDService.java
@@ -40,4 +40,9 @@ public interface IRStatLimitRateDService extends IService<RStatLimitRateDPO> {
     List<TotalLimitStatisticsVO> totalLimitStatisticsList(TotalLimitStatisticsParam param);
 
     List<TotalLimitStatisticsDetailsVO> totalLimitStatisticsDetails(TotalLimitStatisticsDetailsQueryParam param);
+
+    TotalLimitTotalStatisticsVO gridSideLimitTotalStatisticsData(TotalLimitStatisticsParam param);
+
+    List<TotalLimitStatisticsVO> gridSideLimitStatisticsList(TotalLimitStatisticsParam param);
+
 }
diff --git a/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDServiceImpl.java b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDServiceImpl.java
index fc14db2e3..a44b99187 100644
--- a/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDServiceImpl.java
+++ b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDServiceImpl.java
@@ -50,6 +50,8 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl<RStatLimitRateDMappe
     private final DicDataFeignClient dicDataFeignClient;
     private final DecimalFormat df = new DecimalFormat("#0.00");
 
+    private final String GRID_SIDE_DICT_CODE = "Grid_Side";
+
     @Override
     public List<RStatLimitRateDPO> monitorIdsGetLimitRateInfo(String date, List<String> monitorIds) {
         return this.baseMapper.selectList(new LambdaQueryWrapper<RStatLimitRateDPO>()
@@ -286,7 +288,7 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl<RStatLimitRateDMappe
                 String key = entry.getKey();
                 if (key.endsWith("Overtime")) {
                     String value = entry.getValue().toString();
-                    Integer intValue = new Integer(value);
+                    int intValue = new Integer(value);
                     if (key.startsWith("uharm")) {
                         uharmTotalTime += intValue;
                     }
@@ -301,11 +303,11 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl<RStatLimitRateDMappe
         if (totalTime == 0) {
             return statisticsVO;
         }
-        statisticsVO.setFlicker(flickerTotalTime / totalTime * 100);
-        statisticsVO.setUharm(uharmTotalTime / totalTime * 100);
-        statisticsVO.setIharm(iharmTotalTime / totalTime * 100);
-        statisticsVO.setVoltageDev(voltageDevTotalTime / totalTime * 100);
-        statisticsVO.setUbalance(ubalanceTotalTime / totalTime * 100);
+        statisticsVO.setFlicker(calculatePercentage(flickerTotalTime, totalTime));
+        statisticsVO.setUharm(calculatePercentage(uharmTotalTime, totalTime));
+        statisticsVO.setIharm(calculatePercentage(iharmTotalTime, totalTime));
+        statisticsVO.setVoltageDev(calculatePercentage(voltageDevTotalTime, totalTime));
+        statisticsVO.setUbalance(calculatePercentage(ubalanceTotalTime, totalTime));
         return statisticsVO;
     }
 
@@ -360,15 +362,21 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl<RStatLimitRateDMappe
                     }
                 }
                 // 取最大值
-                uharm += uharmList.stream().max(Integer::compareTo).get();
-                iharm += iharmList.stream().max(Integer::compareTo).get();
+                uharm += uharmList.stream().max(Integer::compareTo).orElse(0);
+                iharm += iharmList.stream().max(Integer::compareTo).orElse(0);
             }
-            if (totalTime != 0) {
-                statisticsVO.setFlicker(Double.parseDouble(df.format(BigDecimal.valueOf(flickerTotalTime / totalTime * 100L).setScale(2, RoundingMode.HALF_UP).doubleValue())));
-                statisticsVO.setVoltageDev(Double.parseDouble(df.format(BigDecimal.valueOf(voltageDevTotalTime / totalTime * 100L).setScale(2, RoundingMode.HALF_UP).doubleValue())));
-                statisticsVO.setUbalance(Double.parseDouble(df.format(BigDecimal.valueOf(ubalanceTotalTime / totalTime * 100L).setScale(2, RoundingMode.HALF_UP).doubleValue())));
-                statisticsVO.setUharm(Double.parseDouble(df.format(BigDecimal.valueOf(uharm / totalTime * 100L).setScale(2, RoundingMode.HALF_UP).doubleValue())));
-                statisticsVO.setIharm(Double.parseDouble(df.format(BigDecimal.valueOf(iharm / totalTime * 100L).setScale(2, RoundingMode.HALF_UP).doubleValue())));
+            if (totalTime == 0) {
+                statisticsVO.setFlicker(0.0);
+                statisticsVO.setVoltageDev(0.0);
+                statisticsVO.setUbalance(0.0);
+                statisticsVO.setUharm(0.0);
+                statisticsVO.setIharm(0.0);
+            } else {
+                statisticsVO.setFlicker(calculatePercentage(flickerTotalTime, totalTime));
+                statisticsVO.setVoltageDev(calculatePercentage(voltageDevTotalTime, totalTime));
+                statisticsVO.setUbalance(calculatePercentage(ubalanceTotalTime, totalTime));
+                statisticsVO.setUharm(calculatePercentage(uharm, totalTime));
+                statisticsVO.setIharm(calculatePercentage(iharm, totalTime));
             }
             result.add(statisticsVO);
 
@@ -400,9 +408,9 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl<RStatLimitRateDMappe
                 String key = entry.getKey();
                 if (key.endsWith("Overtime") && allTime != 0) {
                     String value = entry.getValue().toString();
-                    Integer intValue = new Integer(value);
+                    int intValue = new Integer(value);
                     // 占比 = 越限次数 / 总次数 * 100
-                    int proportion = intValue / allTime * 100;
+                    double proportion = calculatePercentage(intValue, allTime);
                     entries.putOpt(key, proportion);
                 }
             }
@@ -410,6 +418,149 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl<RStatLimitRateDMappe
         }).collect(Collectors.toList());
     }
 
+    @Override
+    public TotalLimitTotalStatisticsVO gridSideLimitTotalStatisticsData(TotalLimitStatisticsParam param) {
+        TotalLimitTotalStatisticsVO statisticsVO = new TotalLimitTotalStatisticsVO();
+        // 获取电网侧监测点
+        DictData dictData = dicDataFeignClient.getDicDataByCode(GRID_SIDE_DICT_CODE).getData();
+        CsLinePO queryParam = new CsLinePO();
+        queryParam.setPosition(dictData.getId());
+        List<CsLinePO> linePOList = csLineFeignClient.list(queryParam).getData();
+        List<String> lineIds = linePOList.stream().map(CsLinePO::getLineId).collect(Collectors.toList());
+        if (CollUtil.isEmpty(lineIds)) {
+            return statisticsVO;
+        }
+        List<RStatLimitRateDPO> rateList = this.list(new LambdaQueryWrapper<RStatLimitRateDPO>()
+                .in(RStatLimitRateDPO::getLineId, lineIds)
+                .eq(RStatLimitRateDPO::getPhasicType, "T")
+                .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDPO::getTime, param.getSearchBeginTime())
+                .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDPO::getTime, param.getSearchEndTime())
+                .orderByAsc(RStatLimitRateDPO::getTime)
+        );
+
+
+        int flickerTotalTime = rateList.stream().mapToInt(RStatLimitRateDPO::getFlickerOvertime).sum();
+        int voltageDevTotalTime = rateList.stream().mapToInt(RStatLimitRateDPO::getVoltageDevOvertime).sum();
+        int ubalanceTotalTime = rateList.stream().mapToInt(RStatLimitRateDPO::getUbalanceOvertime).sum();
+        int iharmTotalTime = 0;
+        int uharmTotalTime = 0;
+        for (RStatLimitRateDPO rate : rateList) {
+            JSONObject entries = JSONUtil.parseObj(rate);
+            for (Map.Entry<String, Object> entry : entries.entrySet()) {
+                String key = entry.getKey();
+                if (key.endsWith("Overtime")) {
+                    String value = entry.getValue().toString();
+                    int intValue = new Integer(value);
+                    if (key.startsWith("uharm")) {
+                        uharmTotalTime += intValue;
+                    }
+                    if (key.startsWith("iharm")) {
+                        iharmTotalTime += intValue;
+                    }
+                }
+            }
+
+        }
+        int totalTime = flickerTotalTime + voltageDevTotalTime + ubalanceTotalTime + iharmTotalTime + uharmTotalTime;
+        if (totalTime == 0) {
+            return statisticsVO;
+        }
+        statisticsVO.setFlicker(calculatePercentage(flickerTotalTime, totalTime));
+        statisticsVO.setUharm(calculatePercentage(uharmTotalTime, totalTime));
+        statisticsVO.setIharm(calculatePercentage(iharmTotalTime, totalTime));
+        statisticsVO.setVoltageDev(calculatePercentage(voltageDevTotalTime, totalTime));
+        statisticsVO.setUbalance(calculatePercentage(ubalanceTotalTime, totalTime));
+        return statisticsVO;
+    }
+
+    @Override
+    public List<TotalLimitStatisticsVO> gridSideLimitStatisticsList(TotalLimitStatisticsParam param) {
+        List<TotalLimitStatisticsVO> result = new ArrayList<>();
+        // 获取电网侧监测点
+        DictData dictData = dicDataFeignClient.getDicDataByCode(GRID_SIDE_DICT_CODE).getData();
+        CsLinePO queryParam = new CsLinePO();
+        queryParam.setPosition(dictData.getId());
+        List<CsLinePO> linePOList = csLineFeignClient.list(queryParam).getData();
+        List<String> lineIds = linePOList.stream().map(CsLinePO::getLineId).collect(Collectors.toList());
+        if (CollUtil.isEmpty(lineIds)) {
+            return result;
+        }
+        List<RStatLimitRateDPO> rateList = this.list(new LambdaQueryWrapper<RStatLimitRateDPO>()
+                .in(RStatLimitRateDPO::getLineId, lineIds)
+                .eq(RStatLimitRateDPO::getPhasicType, "T")
+                .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDPO::getTime, param.getSearchBeginTime())
+                .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDPO::getTime, param.getSearchEndTime())
+                .orderByAsc(RStatLimitRateDPO::getTime)
+        );
+        if (CollUtil.isEmpty(rateList)) {
+            return result;
+        }
+        Map<String, List<RStatLimitRateDPO>> lineMap = rateList.stream().collect(Collectors.groupingBy(RStatLimitRateDPO::getLineId));
+        Map<String, CsLinePO> linePOMap = linePOList.stream().collect(Collectors.toMap(CsLinePO::getLineId, csLinePO -> csLinePO));
+        List<CsLinePO> lineList = new ArrayList<>();
+        for (String lineId : lineMap.keySet()) {
+            CsLinePO linePO = linePOMap.getOrDefault(lineId, null);
+            if (linePO != null) {
+                lineList.add(linePO);
+            }
+        }
+        if (CollUtil.isEmpty(lineList)) {
+            return result;
+        }
+        TotalLimitStatisticsVO statisticsVO;
+        for (CsLinePO linePO : lineList) {
+            statisticsVO = new TotalLimitStatisticsVO();
+            statisticsVO.setLineId(linePO.getLineId());
+            statisticsVO.setLineName(linePO.getName());
+            List<RStatLimitRateDPO> lineRateList = lineMap.get(linePO.getLineId());
+            int totalTime = lineRateList.stream().mapToInt(RStatLimitRateDPO::getAllTime).sum();
+            int flickerTotalTime = lineRateList.stream().mapToInt(RStatLimitRateDPO::getFlickerOvertime).sum();
+            int voltageDevTotalTime = lineRateList.stream().mapToInt(RStatLimitRateDPO::getVoltageDevOvertime).sum();
+            int ubalanceTotalTime = lineRateList.stream().mapToInt(RStatLimitRateDPO::getUbalanceOvertime).sum();
+            int uharm = 0;
+            int iharm = 0;
+            for (RStatLimitRateDPO item : lineRateList) {
+                JSONObject entries = JSONUtil.parseObj(item);
+                List<Integer> uharmList = new ArrayList<>();
+                List<Integer> iharmList = new ArrayList<>();
+                for (Map.Entry<String, Object> entry : entries.entrySet()) {
+                    String key = entry.getKey();
+                    if (key.endsWith("Overtime")) {
+                        if (key.startsWith("uharm")) {
+                            String value = entry.getValue().toString();
+                            Integer intValue = new Integer(value);
+                            uharmList.add(intValue);
+                        }
+                        if (key.startsWith("iharm")) {
+                            String value = entry.getValue().toString();
+                            Integer intValue = new Integer(value);
+                            iharmList.add(intValue);
+                        }
+                    }
+                }
+                // 取最大值
+                uharm += uharmList.stream().max(Integer::compareTo).orElse(0);
+                iharm += iharmList.stream().max(Integer::compareTo).orElse(0);
+            }
+            if (totalTime == 0) {
+                statisticsVO.setFlicker(0.0);
+                statisticsVO.setVoltageDev(0.0);
+                statisticsVO.setUbalance(0.0);
+                statisticsVO.setUharm(0.0);
+                statisticsVO.setIharm(0.0);
+            } else {
+                statisticsVO.setFlicker(calculatePercentage(flickerTotalTime, totalTime));
+                statisticsVO.setVoltageDev(calculatePercentage(voltageDevTotalTime, totalTime));
+                statisticsVO.setUbalance(calculatePercentage(ubalanceTotalTime, totalTime));
+                statisticsVO.setUharm(calculatePercentage(uharm, totalTime));
+                statisticsVO.setIharm(calculatePercentage(iharm, totalTime));
+            }
+            result.add(statisticsVO);
+
+        }
+        return result;
+    }
+
     private String getDescription(String key) {
         if (StrUtil.equals(key, "flickerOvertime")) {
             return "闪变越限超标";
@@ -438,4 +589,10 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl<RStatLimitRateDMappe
         return null;
     }
 
+
+    private double calculatePercentage(double part, double total) {
+        return Double.parseDouble(df.format(BigDecimal.valueOf(part / total * 100.0)
+                .setScale(2, RoundingMode.HALF_UP).doubleValue()));
+    }
+
 }
diff --git a/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDetailDServiceImpl.java b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDetailDServiceImpl.java
index d46e1ceb1..b5110ebf0 100644
--- a/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDetailDServiceImpl.java
+++ b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDetailDServiceImpl.java
@@ -18,7 +18,6 @@ import com.njcn.harmonic.pojo.param.LimitCalendarQueryParam;
 import com.njcn.harmonic.pojo.param.LimitExtentDayQueryParam;
 import com.njcn.harmonic.pojo.param.LimitExtentQueryParam;
 import com.njcn.harmonic.pojo.param.LimitProbabilityQueryParam;
-import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO;
 import com.njcn.harmonic.pojo.po.day.RStatLimitRateDetailDPO;
 import com.njcn.harmonic.pojo.vo.LimitCalendarVO;
 import com.njcn.harmonic.pojo.vo.LimitExtentVO;
@@ -231,7 +230,7 @@ public class RStatLimitRateDetailDServiceImpl extends ServiceImpl<RStatLimitRate
                                 String itemKey = StrUtil.sub(key, 0, key.length() - 8);
                                 float limitValue = overlimitJSON.getFloat(itemKey);
                                 if (limitValue != 0) {
-                                    double overlimitPercent = Double.parseDouble(df.format(BigDecimal.valueOf((maxValue - limitValue) / limitValue * 100).setScale(2, RoundingMode.HALF_UP).doubleValue()));
+                                    double overlimitPercent = calculatePercentage(maxValue - limitValue, limitValue);
                                     if (overlimitPercent >= 80) {
                                         status = 2;
                                     }
@@ -258,17 +257,6 @@ public class RStatLimitRateDetailDServiceImpl extends ServiceImpl<RStatLimitRate
                 .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDetailDPO::getTime, param.getSearchEndTime())
                 .orderByAsc(RStatLimitRateDetailDPO::getTime)
         );
-        List<RStatLimitRateDPO> lineRateList = rStatLimitRateDService
-                .list(new LambdaQueryWrapper<RStatLimitRateDPO>()
-                        .eq(RStatLimitRateDPO::getLineId, param.getLineId())
-                        .eq(RStatLimitRateDPO::getPhasicType, "T")
-                        .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDPO::getTime, param.getSearchBeginTime())
-                        .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDPO::getTime, param.getSearchEndTime())
-                        .orderByAsc(RStatLimitRateDPO::getTime)
-                );
-        // 总次数
-        int totalTimes = lineRateList.stream().mapToInt(RStatLimitRateDPO::getAllTime).sum();
-
         CsLinePO linePO = csLineFeignClient.getById(param.getLineId()).getData();
         List<Overlimit> overlimitList = overLimitClient.getOverLimitByLineIds(Collections.singletonList(linePO.getLineId())).getData();
         JSONObject overlimitJSON = null;
@@ -283,28 +271,6 @@ public class RStatLimitRateDetailDServiceImpl extends ServiceImpl<RStatLimitRate
             probabilityVO.setIndexCode(indexCode);
             probabilityVO.setLineId(linePO.getLineId());
             probabilityVO.setLineName(linePO.getName());
-            // 计算占比
-            int limitTimes = 0;
-            for (RStatLimitRateDPO item : lineRateList) {
-                JSONObject entries = JSONUtil.parseObj(item);
-                List<Integer> valueList = new ArrayList<>();
-                for (Map.Entry<String, Object> entry : entries.entrySet()) {
-                    String key = entry.getKey();
-                    if (key.endsWith("Overtime")) {
-                        if (key.startsWith(indexCode)) {
-                            String value = entry.getValue().toString();
-                            Integer intValue = new Integer(value);
-                            valueList.add(intValue);
-                        }
-                    }
-                }
-                limitTimes += valueList.stream().max(Integer::compareTo).orElse(0);
-            }
-            if (totalTimes != 0) {
-                probabilityVO.setProportion(Double.parseDouble(df.format(BigDecimal.valueOf(limitTimes / totalTimes * 100L).setScale(2, RoundingMode.HALF_UP).doubleValue())));
-            } else {
-                probabilityVO.setProportion(0f);
-            }
             // 计算越限程度
             List<Double> extentValuesList = new ArrayList<>();
             for (RStatLimitRateDetailDPO detail : detailList) {
@@ -321,7 +287,7 @@ public class RStatLimitRateDetailDServiceImpl extends ServiceImpl<RStatLimitRate
                                 String itemKey = StrUtil.sub(key, 0, key.length() - 8);
                                 double limitValue = overlimitJSON.getDouble(itemKey);
                                 if (limitValue != 0) {
-                                    extentValue = Double.parseDouble(df.format(BigDecimal.valueOf((maxValue - limitValue) / limitValue * 100).setScale(2, RoundingMode.HALF_UP).doubleValue()));
+                                    extentValue = calculatePercentage(maxValue - limitValue, limitValue);
 
                                 }
                             }
@@ -577,4 +543,8 @@ public class RStatLimitRateDetailDServiceImpl extends ServiceImpl<RStatLimitRate
         return null;
     }
 
+    private double calculatePercentage(double part, double total) {
+        return Double.parseDouble(df.format(BigDecimal.valueOf(part / total * 100.0)
+                .setScale(2, RoundingMode.HALF_UP).doubleValue()));
+    }
 }